Commit 79d6edd6 by Francois Gygi

rel1_38_0


git-svn-id: http://qboxcode.org/svn/qb/trunk@576 cba15fb0-1239-40c8-b417-11db7ca47a34
parent cb28c0e6
......@@ -3,7 +3,7 @@
// AtomSet.C
//
////////////////////////////////////////////////////////////////////////////////
// $Id: AtomSet.C,v 1.20 2008-02-12 05:39:18 fgygi Exp $
// $Id: AtomSet.C,v 1.21 2008-03-05 04:04:48 fgygi Exp $
#include "AtomSet.h"
#include "Species.h"
......@@ -24,7 +24,7 @@ bool AtomSet::addSpecies(Species* sp, string name)
return false;
}
const double rcps = 1.0;
const double rcps = 1.5;
sp->initialize(rcps);
// create new entry in species list
......@@ -446,7 +446,7 @@ ostream& operator << ( ostream &os, const AtomSet &as )
if ( as.context().onpe0() )
{
os << "<atomset>\n";
os << as.unit_cell;
os << as.cell();
for ( int is = 0; is < as.species_list.size(); is++ )
{
os << *as.species_list[is];
......
......@@ -3,7 +3,7 @@
// AtomSet.h
//
////////////////////////////////////////////////////////////////////////////////
// $Id: AtomSet.h,v 1.18 2008-02-03 22:53:55 fgygi Exp $
// $Id: AtomSet.h,v 1.19 2008-03-05 04:04:48 fgygi Exp $
#ifndef ATOMSET_H
#define ATOMSET_H
......@@ -32,9 +32,9 @@ class AtomSet
std::map<std::string,int> ia_; // ia_[atom_name]: ia index of atom atom_name
std::vector<std::string> spname; // spname[is]: name of species is
public:
UnitCell cell_;
UnitCell unit_cell;
public:
AtomSet(const Context& ctxt) : ctxt_(ctxt), nel_(0) {}
......@@ -62,6 +62,12 @@ class AtomSet
void set_positions(const std::vector<std::vector<double> >& tau);
void get_velocities(std::vector<std::vector<double> >& vel) const;
void set_velocities(const std::vector<std::vector<double> >& vel);
const UnitCell& cell(void) const { return cell_; }
void set_cell(const UnitCell& cell) { cell_ = cell; }
void set_cell(const D3vector& a, const D3vector& b, const D3vector& c)
{
cell_.set(a,b,c);
}
void sync(void);
void reset_velocities(void);
D3vector vcm(void) const;
......
......@@ -3,7 +3,7 @@
// AtomSetHandler.C
//
////////////////////////////////////////////////////////////////////////////////
// $Id: AtomSetHandler.C,v 1.10 2008-02-12 05:39:18 fgygi Exp $
// $Id: AtomSetHandler.C,v 1.11 2008-03-05 04:04:48 fgygi Exp $
#if USE_XERCES
......@@ -60,7 +60,7 @@ void AtomSetHandler::startElement(const XMLCh* const uri,
}
}
as_.unit_cell.set(a,b,c);
as_.set_cell(a,b,c);
}
else if ( locname == "atom")
{
......@@ -96,15 +96,15 @@ void AtomSetHandler::endElement(const XMLCh* const uri,
as_.context().ibcast_send(1,1,(int*)&event,1);
// notify listening nodes
double buf[9];
buf[0] = as_.unit_cell.a(0).x;
buf[1] = as_.unit_cell.a(0).y;
buf[2] = as_.unit_cell.a(0).z;
buf[3] = as_.unit_cell.a(1).x;
buf[4] = as_.unit_cell.a(1).y;
buf[5] = as_.unit_cell.a(1).z;
buf[6] = as_.unit_cell.a(2).x;
buf[7] = as_.unit_cell.a(2).y;
buf[8] = as_.unit_cell.a(2).z;
buf[0] = as_.cell().a(0).x;
buf[1] = as_.cell().a(0).y;
buf[2] = as_.cell().a(0).z;
buf[3] = as_.cell().a(1).x;
buf[4] = as_.cell().a(1).y;
buf[5] = as_.cell().a(1).z;
buf[6] = as_.cell().a(2).x;
buf[7] = as_.cell().a(2).y;
buf[8] = as_.cell().a(2).z;
as_.context().dbcast_send(9,1,buf,9);
}
else if ( locname == "atom")
......
......@@ -3,7 +3,7 @@
// BOSampleStepper.C
//
////////////////////////////////////////////////////////////////////////////////
// $Id: BOSampleStepper.C,v 1.36 2008-02-12 05:39:18 fgygi Exp $
// $Id: BOSampleStepper.C,v 1.37 2008-03-05 04:04:48 fgygi Exp $
#include "BOSampleStepper.h"
#include "EnergyFunctional.h"
......@@ -245,7 +245,7 @@ void BOSampleStepper::step(int niter)
if ( onpe0 )
{
cout << "<atomset>" << endl;
cout << atoms.unit_cell;
cout << atoms.cell();
for ( int is = 0; is < atoms.atom_list.size(); is++ )
{
int i = 0;
......
......@@ -3,13 +3,15 @@
// Basis.h
//
////////////////////////////////////////////////////////////////////////////////
// $Id: Basis.h,v 1.8 2007-10-19 17:10:58 fgygi Exp $
// $Id: Basis.h,v 1.9 2008-03-05 04:04:48 fgygi Exp $
#ifndef BASIS_H
#define BASIS_H
#include "D3vector.h"
#include "UnitCell.h"
#include "Context.h"
#include <vector>
class Context;
......@@ -17,7 +19,42 @@ class Basis
{
private:
struct BasisImpl* pimpl_;
Context ctxt_;
int nprow_, myrow_;
UnitCell cell_; // cell dimensions
UnitCell refcell_; // reference cell dimensions
D3vector kpoint_; // k-point in units of b0,b1,b2
double ecut_; // energy cutoff of wavefunctions in Rydberg
int idxmin_[3]; // minimum index in each direction
int idxmax_[3]; // maximum index in each direction
int size_; // basis size
int nrods_; // total number of rods
std::vector<int> localsize_; // localsize_[ipe]
int maxlocalsize_, minlocalsize_;
std::vector<int> nrod_loc_;
std::vector<std::vector<int> > rod_h_;
std::vector<std::vector<int> > rod_k_;
std::vector<std::vector<int> > rod_lmin_;
std::vector<std::vector<int> > rod_size_;
std::vector<std::vector<int> > rod_first_;
std::vector<int> idx_; // 3-d index of vectors idx[i*3+j]
std::vector<double> g_; // norm of g vectors g[localsize]
std::vector<double> kpg_; // norm of g vectors g[localsize]
std::vector<double> gi_; // inverse norm of g vectors gi[localsize]
std::vector<double> kpgi_; // inverse norm of k+g vectors kpgi[localsize]
std::vector<double> g2_; // 2-norm of g vectors g2[localsize]
std::vector<double> kpg2_; // 2-norm of g vectors g2[localsize]
std::vector<double> g2i_; // inverse square norm of g vec g2i[localsize]
std::vector<double> kpg2i_; // inverse square norm of k+g vec kpg2i[localsize]
int np_[3]; // cache for the function np
std::vector<double> gx_; // g vec components gx[j*localsize+i], j=0,1,2
std::vector<double> kpgx_; // k+g vec components kpgx[j*localsize+i], j=0,1,2
std::vector<int> isort_loc; // index array to access locally sorted vectors
// kpg2_[isort_loc[i]] < kpg2_[isort_loc[j]] if i < j
bool real_; // true if k=0
void update_g(void);
public:
......@@ -27,6 +64,7 @@ class Basis
const UnitCell& refcell() const;// reference cell dimensions
const D3vector kpoint() const; // k-point in units of b0,b1,b2
int np(int i) const; // good size of FFT grid in direction i
bool factorizable(int n) const;// check if n is factorizable with low factors
int idxmin(int i) const; // smallest index in direction i
int idxmax(int i) const; // largest index in direction i
double ecut() const; // energy cutoff in Hartree
......@@ -89,7 +127,7 @@ class Basis
double localmemsize(void) const;
Basis(const Context &ctxt, D3vector kpoint);
Basis(const Basis &b);
//Basis(const Basis &b);
~Basis(void);
bool resize(const UnitCell& cell, const UnitCell& refcell, double ecut);
......
......@@ -3,7 +3,7 @@
// CPSampleStepper.C
//
////////////////////////////////////////////////////////////////////////////////
// $Id: CPSampleStepper.C,v 1.16 2008-02-12 05:39:18 fgygi Exp $
// $Id: CPSampleStepper.C,v 1.17 2008-03-05 04:04:48 fgygi Exp $
#include "CPSampleStepper.h"
#include "SlaterDet.h"
......@@ -180,7 +180,7 @@ void CPSampleStepper::step(int niter)
if ( onpe0 )
{
cout << "<atomset>" << endl;
cout << atoms.unit_cell;
cout << atoms.cell();
for ( int is = 0; is < atoms.atom_list.size(); is++ )
{
int i = 0;
......
......@@ -3,7 +3,7 @@
// Cell.h
//
////////////////////////////////////////////////////////////////////////////////
// $Id: Cell.h,v 1.6 2008-02-03 22:53:54 fgygi Exp $
// $Id: Cell.h,v 1.7 2008-03-05 04:04:48 fgygi Exp $
#ifndef CELL_H
#define CELL_H
......@@ -51,11 +51,11 @@ class Cell : public Var
s->wfv->clear();
}
s->atoms.unit_cell.set(a,b,c);
s->atoms.set_cell(a,b,c);
if ( ui->onpe0() )
{
cout << s->atoms.unit_cell;
cout << s->atoms.cell();
}
return 0;
}
......
......@@ -3,7 +3,7 @@
// ChargeDensity.C
//
////////////////////////////////////////////////////////////////////////////////
// $Id: ChargeDensity.C,v 1.16 2008-02-12 05:39:19 fgygi Exp $
// $Id: ChargeDensity.C,v 1.17 2008-03-05 04:04:48 fgygi Exp $
#include "ChargeDensity.h"
#include "Basis.h"
......@@ -30,6 +30,9 @@ wf_(wf), vcontext_(wf.sd(0,0)->basis().context())
int np0v = vbasis_->np(0)+2;
int np1v = vbasis_->np(1)+2;
int np2v = vbasis_->np(2)+2;
while (!vbasis_->factorizable(np0v)) np0v += 2;
while (!vbasis_->factorizable(np1v)) np1v += 2;
while (!vbasis_->factorizable(np2v)) np2v += 2;
#if 0
cout << " ChargeDensity: vbasis: " << endl;
cout << " idxmin: " << vb.idxmin(0) << "/" << vb.idxmin(1)
......
......@@ -3,7 +3,7 @@
// EnergyFunctional.C
//
////////////////////////////////////////////////////////////////////////////////
// $Id: EnergyFunctional.C,v 1.29 2008-02-12 05:39:19 fgygi Exp $
// $Id: EnergyFunctional.C,v 1.30 2008-03-05 04:04:48 fgygi Exp $
#include "EnergyFunctional.h"
#include "Sample.h"
......@@ -860,6 +860,18 @@ void EnergyFunctional::atoms_moved(void)
// compute esr: pseudocharge repulsion energy
const UnitCell& cell = s_.wf.cell();
const double omega_inv = 1.0 / cell.volume();
// distance between opposite planes of the cell
const double d0 = 2.0 * M_PI / length(cell.b(0));
const double d1 = 2.0 * M_PI / length(cell.b(1));
const double d2 = 2.0 * M_PI / length(cell.b(2));
assert (d0!=0.0);
assert (d1!=0.0);
assert (d2!=0.0);
#ifdef DEBUG
cout << " EnergyFunctional: d0 = " << d0 << endl;
cout << " EnergyFunctional: d1 = " << d1 << endl;
cout << " EnergyFunctional: d2 = " << d2 << endl;
#endif
esr_ = 0.0;
sigma_esr = 0.0;
......@@ -867,50 +879,69 @@ void EnergyFunctional::atoms_moved(void)
for ( int i = 0; i < fion_esr[is].size(); i++ )
fion_esr[is][i] = 0.0;
for ( int k = 0; k < nsp_; k++ )
for ( int is1 = 0; is1 < nsp_; is1++ )
{
for ( int j = k; j < nsp_; j++ )
for ( int is2 = is1; is2 < nsp_; is2++ )
{
double rckj = sqrt ( rcps_[k]*rcps_[k]+rcps_[j]*rcps_[j] );
int lax = na_[k];
if ( k == j ) lax--;
for ( int l = 0; l < lax; l++ )
double rcps12 = sqrt ( rcps_[is1]*rcps_[is1]+rcps_[is2]*rcps_[is2] );
// convergence criterion for lattice sums:
// fac * rcps12 < ncell * d
const double fac = 6.0;
const int ncell0 = (int) (fac * rcps12 / d0);
const int ncell1 = (int) (fac * rcps12 / d1);
const int ncell2 = (int) (fac * rcps12 / d2);
#ifdef DEBUG
const double mindist = min(min(d0,d1),d2);
cout << " EnergyFunctional: mindist/rcps12: " << mindist/rcps12 << endl;
cout << " EnergyFunctional: ncell[012]: "
<< ncell0 << " " << ncell1 << " " << ncell2 << endl;
#endif
for ( int ia1 = 0; ia1 < na_[is1]; ia1++ )
{
int inf = 0;
if ( k == j ) inf = l+1;
for ( int m = inf; m < na_[j]; m++ )
int ia2min = 0;
if ( is1 == is2 ) ia2min = ia1 + 1;
for ( int ia2 = ia2min; ia2 < na_[is2]; ia2++ )
{
double xlm = tau0[k][3*l+0] - tau0[j][3*m+0];
double ylm = tau0[k][3*l+1] - tau0[j][3*m+1];
double zlm = tau0[k][3*l+2] - tau0[j][3*m+2];
D3vector vlm(xlm,ylm,zlm);
cell.fold_in_ws(vlm);
xlm = vlm.x;
ylm = vlm.y;
zlm = vlm.z;
double rlm = sqrt(xlm*xlm + ylm*ylm + zlm*zlm);
double arg = rlm / rckj;
double esr_lm = zv_[k] * zv_[j] * erfc(arg) / rlm;
esr_ += esr_lm;
double desr_erfc = 2.0 * zv_[k]*zv_[j]*exp(-arg*arg)/rckj/sqrt(M_PI);
// desrdr = (1/r) d Esr / dr
double desrdr = -(esr_lm+desr_erfc) / ( rlm*rlm );
fion_esr[k][3*l+0] -= desrdr * xlm;
fion_esr[j][3*m+0] += desrdr * xlm;
fion_esr[k][3*l+1] -= desrdr * ylm;
fion_esr[j][3*m+1] += desrdr * ylm;
fion_esr[k][3*l+2] -= desrdr * zlm;
fion_esr[j][3*m+2] += desrdr * zlm;
sigma_esr[0] += desrdr * xlm * xlm;
sigma_esr[1] += desrdr * ylm * ylm;
sigma_esr[2] += desrdr * zlm * zlm;
sigma_esr[3] += desrdr * xlm * ylm;
sigma_esr[4] += desrdr * ylm * zlm;
sigma_esr[5] += desrdr * xlm * zlm;
double x12 = tau0[is1][3*ia1+0] - tau0[is2][3*ia2+0];
double y12 = tau0[is1][3*ia1+1] - tau0[is2][3*ia2+1];
double z12 = tau0[is1][3*ia1+2] - tau0[is2][3*ia2+2];
D3vector v12(x12,y12,z12);
cell.fold_in_ws(v12);
// loop over neighboring cells
for ( int ic0 = -ncell0; ic0 <= ncell0; ic0++ )
for ( int ic1 = -ncell1; ic1 <= ncell1; ic1++ )
for ( int ic2 = -ncell2; ic2 <= ncell2; ic2++ )
{
D3vector s = ic0*cell.a(0) + ic1*cell.a(1) + ic2*cell.a(2);
x12 = v12.x + s.x;
y12 = v12.y + s.y;
z12 = v12.z + s.z;
double r12 = sqrt(x12*x12 + y12*y12 + z12*z12);
double arg = r12 / rcps12;
double esr_term = zv_[is1] * zv_[is2] * erfc(arg) / r12;
esr_ += esr_term;
double desr_erfc = 2.0 * zv_[is1]*zv_[is2] *
exp(-arg*arg)/(rcps12*sqrt(M_PI));
// desrdr = (1/r) d Esr / dr
double desrdr = -(esr_term+desr_erfc) / ( r12*r12 );
fion_esr[is1][3*ia1+0] -= desrdr * x12;
fion_esr[is2][3*ia2+0] += desrdr * x12;
fion_esr[is1][3*ia1+1] -= desrdr * y12;
fion_esr[is2][3*ia2+1] += desrdr * y12;
fion_esr[is1][3*ia1+2] -= desrdr * z12;
fion_esr[is2][3*ia2+2] += desrdr * z12;
sigma_esr[0] += desrdr * x12 * x12;
sigma_esr[1] += desrdr * y12 * y12;
sigma_esr[2] += desrdr * z12 * z12;
sigma_esr[3] += desrdr * x12 * y12;
sigma_esr[4] += desrdr * y12 * z12;
sigma_esr[5] += desrdr * x12 * z12;
}
}
}
}
......
......@@ -3,7 +3,7 @@
// MDIonicStepper.C
//
////////////////////////////////////////////////////////////////////////////////
// $Id: MDIonicStepper.C,v 1.15 2008-02-12 05:39:18 fgygi Exp $
// $Id: MDIonicStepper.C,v 1.16 2008-03-05 04:04:48 fgygi Exp $
#include "MDIonicStepper.h"
using namespace std;
......@@ -75,6 +75,8 @@ void MDIonicStepper::compute_v(double e0, const vector<vector< double> >& f0)
else if ( thermostat_ == "ANDERSEN" )
{
const double boltz = 1.0 / ( 11605.0 * 2.0 * 13.6058 );
const double collision_probability = fabs(dt_) / th_time_ ;
for ( int is = 0; is < nsp_; is++ )
{
const double m = pmass_[is];
......@@ -82,8 +84,9 @@ void MDIonicStepper::compute_v(double e0, const vector<vector< double> >& f0)
for ( int ia = 0; ia < na_[is]; ia++ )
{
// if th_time is zero, set probability to one
if ( th_time_ == 0.0 || drand48() < fabs(dt_) / th_time_ )
if ( th_time_ == 0.0 || drand48() < collision_probability )
{
cout << " collision: atom is=" << is << " ia=" << ia << endl;
// draw gaussian random variables
double xi0 = drand48() + drand48() + drand48() +
drand48() + drand48() + drand48() +
......@@ -107,6 +110,9 @@ void MDIonicStepper::compute_v(double e0, const vector<vector< double> >& f0)
else if ( thermostat_ == "LOWE" )
{
const double boltz = 1.0 / ( 11605.0 * 2.0 * 13.6058 );
const int nat = atoms_.size();
const double collision_probability = nat > 1 ?
fabs(dt_) / ( 0.5*(nat-1) * th_time_ ) : 0.0 ;
// scan all atom pairs in the space (is,ia)
//int npairs = 0;
......@@ -125,14 +131,15 @@ void MDIonicStepper::compute_v(double e0, const vector<vector< double> >& f0)
for ( int ia2 = ia2min; ia2 < na_[is2]; ia2++ )
{
// if th_time is zero, set probability to one
if ( th_time_ == 0.0 || drand48() < fabs(dt_) / th_time_ )
if ( th_time_ == 0.0 || drand48() < collision_probability )
{
//cout << " pair " << is1 << " " << ia1 << " "
// << is2 << " " << ia2 << endl;
cout << " collision: pair " << is1 << " " << ia1 << " "
<< is2 << " " << ia2 << endl;
D3vector r1(&r0_[is1][3*ia1]);
s_.wf.cell().fold_in_ws(r1);
D3vector r2(&r0_[is2][3*ia2]);
s_.wf.cell().fold_in_ws(r2);
D3vector r12 = r1 - r2;
s_.wf.cell().fold_in_ws(r12);
D3vector e12 = normalized(r12);
D3vector v1(&v0_[is1][3*ia1]);
D3vector v2(&v0_[is2][3*ia2]);
......
#-------------------------------------------------------------------------------
# $Id: Makefile,v 1.49 2008-02-03 22:53:55 fgygi Exp $
# $Id: Makefile,v 1.50 2008-03-05 04:04:48 fgygi Exp $
#------------------------------------------------------------------------------
#
include $(TARGET).mk
......@@ -207,7 +207,7 @@ AtomSet.o: Context.h Atom.h D3vector.h UnitCell.h
AtomSetHandler.o: StructureHandler.h D3vector.h
Base64Transcoder.o: Base64Transcoder.h
Basis.o: Basis.h D3vector.h UnitCell.h Context.h
Basis.o: D3vector.h UnitCell.h
Basis.o: D3vector.h UnitCell.h Context.h
BasisMapping.o: Basis.h D3vector.h UnitCell.h Context.h BasisMapping.h
bisection1.o: Context.h Sample.h AtomSet.h Atom.h D3vector.h UnitCell.h
bisection1.o: ConstraintSet.h Wavefunction.h Control.h SampleReader.h Basis.h
......@@ -259,6 +259,7 @@ ComputeMLWFCmd.o: UserInterface.h Sample.h AtomSet.h Context.h Atom.h
ComputeMLWFCmd.o: D3vector.h UnitCell.h ConstraintSet.h Wavefunction.h
ComputeMLWFCmd.o: Control.h MLWFTransform.h BasisMapping.h
ConfinementPotential.o: ConfinementPotential.h Basis.h D3vector.h UnitCell.h
ConfinementPotential.o: Context.h
Constraint.o: Constraint.h
ConstraintCmd.o: UserInterface.h Sample.h AtomSet.h Context.h Atom.h
ConstraintCmd.o: D3vector.h UnitCell.h ConstraintSet.h Wavefunction.h
......@@ -350,7 +351,7 @@ MDWavefunctionStepper.o: SlaterDet.h Context.h Basis.h Matrix.h Sample.h
MDWavefunctionStepper.o: AtomSet.h Atom.h ConstraintSet.h Control.h
MDWavefunctionStepper.o: WavefunctionStepper.h Timer.h
MLWFTransform.o: MLWFTransform.h D3vector.h BasisMapping.h Basis.h UnitCell.h
MLWFTransform.o: SlaterDet.h Context.h Matrix.h Timer.h jade.h blas.h
MLWFTransform.o: Context.h SlaterDet.h Matrix.h Timer.h jade.h blas.h
MLWFTransform.o: D3vector.h BasisMapping.h
MoveCmd.o: UserInterface.h Sample.h AtomSet.h Context.h Atom.h D3vector.h
MoveCmd.o: UnitCell.h ConstraintSet.h Wavefunction.h Control.h
......@@ -480,7 +481,7 @@ StatusCmd.o: UnitCell.h ConstraintSet.h Wavefunction.h Control.h
Stress.o: Sample.h AtomSet.h Context.h Atom.h D3vector.h UnitCell.h
Stress.o: ConstraintSet.h Wavefunction.h Control.h
StructuredDocumentHandler.o: StrX.h StructureHandler.h
StructureFactor.o: StructureFactor.h Basis.h D3vector.h UnitCell.h
StructureFactor.o: StructureFactor.h Basis.h D3vector.h UnitCell.h Context.h
testAndersonMixer.o: Context.h AndersonMixer.h
testBase64Transcoder.o: Base64Transcoder.h
testBasis.o: Basis.h D3vector.h UnitCell.h Context.h
......
......@@ -3,7 +3,7 @@
// SDCellStepper.C
//
////////////////////////////////////////////////////////////////////////////////
// $Id: SDCellStepper.C,v 1.6 2008-02-12 05:39:18 fgygi Exp $
// $Id: SDCellStepper.C,v 1.7 2008-03-05 04:04:48 fgygi Exp $
#include "SDCellStepper.h"
using namespace std;
......@@ -145,6 +145,7 @@ void SDCellStepper::update_cell(void)
}
}
s_.atoms.set_positions(r);
s_.atoms.set_cell(cellp);
// resize wavefunction and basis sets
......
......@@ -3,7 +3,7 @@
// SampleReader.C:
//
////////////////////////////////////////////////////////////////////////////////
// $Id: SampleReader.C,v 1.24 2008-02-12 05:39:18 fgygi Exp $
// $Id: SampleReader.C,v 1.25 2008-03-05 04:04:48 fgygi Exp $
#include "Sample.h"
......@@ -238,7 +238,7 @@ void SampleReader::readSample (Sample& s, const string uri, bool serial)
D3vector a(buf[0],buf[1],buf[2]);
D3vector b(buf[3],buf[4],buf[5]);
D3vector c(buf[6],buf[7],buf[8]);
s.atoms.unit_cell = UnitCell(a,b,c);
s.atoms.set_cell(a,b,c);
}
else if ( event == species )
{
......@@ -583,7 +583,7 @@ void SampleReader::readSample (Sample& s, const string uri, bool serial)
// force consistency of unit cell
// copy wavefunction domain on atomset unit_cell
s.atoms.unit_cell = s.wf.cell();
s.atoms.set_cell(s.wf.cell());
// check if wavefunction_velocity element was read, if not, delete wfvtmp
if ( s.wfv != 0 )
......
......@@ -3,7 +3,7 @@
// UserInterface.C: definition of readCmd and processCmds
//
////////////////////////////////////////////////////////////////////////////////
// $Id: UserInterface.C,v 1.6 2008-02-12 05:39:18 fgygi Exp $
// $Id: UserInterface.C,v 1.7 2008-03-05 04:04:48 fgygi Exp $
#include "UserInterface.h"
#include <string>
......@@ -77,6 +77,7 @@ char *UserInterface::readCmd(char *s, int max, istream &fp, bool echo)
if ( !(ch == '\n') )
return NULL; /* return NULL for end of file */
}
if ( echo ) cout << endl;
return s;
}
......@@ -108,9 +109,6 @@ void UserInterface::processCmds ( istream &cmdstream, char *prompt, bool echo )
while ( !done )
{
if ( onpe0_ )
cout << endl;
// cmdline contains a string of tokens terminated by '\0'
// cout << " command line is: " << cmdline << endl;
......
--------------------------------------------------------------------------------
rel1_38_0
MDIonicStepper.C: Modified minimum image convention in LOWE thermostat to
conserve angular momentum in clusters. Fixed LOWE and ANDERSEN thermostats to
have correct collision rate.
UserInterface.C: fixed endl in output to avoid double endl.
Basis.C: remove pimpl implementation.
ChargeDensity.C: use factorizable sizes for density grid.
EnergyFunctional.C: corrected upper bound of ia1 in esr calculation.
EnergyFunctional.C: implemented multiple cell in esr calculation.
AtomSet.C: changed rcps value to 1.5. Changed interface to access cell.
--------------------------------------------------------------------------------
rel1_37_0
Cleaned up XML formatting of output. Removed comments. Use <timing> tag.
--------------------------------------------------------------------------------
......
......@@ -3,10 +3,10 @@
// release.C
//
////////////////////////////////////////////////////////////////////////////////
// $Id: release.C,v 1.45 2008-02-12 05:39:18 fgygi Exp $
// $Id: release.C,v 1.46 2008-03-05 04:04:48 fgygi Exp $
#include "release.h"
std::string release(void)
{
return std::string("1.37.0");
return std::string("1.38.0");
}
......@@ -3,7 +3,7 @@
# x8664_gcc.mk
#
#-------------------------------------------------------------------------------
# $Id: x8664_gcc.mk,v 1.6 2008-01-26 01:36:27 fgygi Exp $
# $Id: x8664_gcc.mk,v 1.7 2008-03-05 04:04:48 fgygi Exp $
#
PLT=Linux_x8664
#-------------------------------------------------------------------------------
......@@ -34,8 +34,8 @@
-L$(XERCESCDIR)/lib
LIBS = $(PLIBS) -lfftw \
-llapack -lf77blas -latlas -lm -lmpich -lgfortran \
$(XERCESCDIR)/lib/libxerces-c.a
-llapack -lf77blas -latlas -lm -lgfortran \
$(MPIDIR)/lib/libmpich.a $(XERCESCDIR)/lib/libxerces-c.a
LDFLAGS = $(LIBPATH) $(LIBS)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment