OOPSE/libmdtools/SimInfo.cpp

#include <cstdlib>
#include <cstring>
#include <cmath>

#include <iostream>
using namespace std;

#include "SimInfo.hpp"
#define __C
#include "fSimulation.h"
#include "simError.h"

#include "fortranWrappers.hpp"

#ifdef IS_MPI
#include "mpiSimulation.hpp"
#endif

inline double roundMe( double x ){
  return ( x >= 0 ) ? floor( x + 0.5 ) : ceil( x - 0.5 );
}
          

SimInfo* currentInfo;

SimInfo::SimInfo(){
  excludes = NULL;
  n_constraints = 0;
  n_oriented = 0;
  n_dipoles = 0;
  ndf = 0;
  ndfRaw = 0;
  nZconstraints = 0;
  the_integrator = NULL;
  setTemp = 0;
  thermalTime = 0.0;
  currentTime = 0.0;
  rCut = 0.0;
  origRcut = -1.0;
  ecr = 0.0;
  origEcr = -1.0;
  est = 0.0;
  oldEcr = 0.0;
  oldRcut = 0.0;

  haveOrigRcut = 0;
  haveOrigEcr = 0;
  boxIsInit = 0;
  
  
  usePBC = 0;
  useLJ = 0; 
  useSticky = 0;
  useDipole = 0;
  useReactionField = 0;
  useGB = 0;
  useEAM = 0;

  myConfiguration = new SimState();

  wrapMeSimInfo( this );
}


SimInfo::~SimInfo(){

  delete myConfiguration;

  map<string, GenericData*>::iterator i;
  
  for(i = properties.begin(); i != properties.end(); i++)
    delete (*i).second;
    
}

void SimInfo::setBox(double newBox[3]) {
  
  int i, j;
  double tempMat[3][3];

  for(i=0; i<3; i++) 
    for (j=0; j<3; j++) tempMat[i][j] = 0.0;;

  tempMat[0][0] = newBox[0];
  tempMat[1][1] = newBox[1];
  tempMat[2][2] = newBox[2];

  setBoxM( tempMat );

}

void SimInfo::setBoxM( double theBox[3][3] ){
  
  int i, j, status;
  double smallestBoxL, maxCutoff;
  double FortranHmat[9]; // to preserve compatibility with Fortran the
                         // ordering in the array is as follows:
                         // [ 0 3 6 ]
                         // [ 1 4 7 ]
                         // [ 2 5 8 ]
  double FortranHmatInv[9]; // the inverted Hmat (for Fortran);

  
  if( !boxIsInit ) boxIsInit = 1;

  for(i=0; i < 3; i++) 
    for (j=0; j < 3; j++) Hmat[i][j] = theBox[i][j];
  
  calcBoxL();
  calcHmatInv();

  for(i=0; i < 3; i++) {
    for (j=0; j < 3; j++) {
      FortranHmat[3*j + i] = Hmat[i][j];
      FortranHmatInv[3*j + i] = HmatInv[i][j];
    }
  }

  setFortranBoxSize(FortranHmat, FortranHmatInv, &orthoRhombic);
 
}
 

void SimInfo::getBoxM (double theBox[3][3]) {

  int i, j;
  for(i=0; i<3; i++) 
    for (j=0; j<3; j++) theBox[i][j] = Hmat[i][j];
}


void SimInfo::scaleBox(double scale) {
  double theBox[3][3];
  int i, j;

  // cerr << "Scaling box by " << scale << "\n";

  for(i=0; i<3; i++) 
    for (j=0; j<3; j++) theBox[i][j] = Hmat[i][j]*scale;

  setBoxM(theBox);

}

void SimInfo::calcHmatInv( void ) {
  
  int i,j;
  double smallDiag;
  double tol;
  double sanity[3][3];

  invertMat3( Hmat, HmatInv );

  // Check the inverse to make sure it is sane:

  matMul3( Hmat, HmatInv, sanity );
    
  // check to see if Hmat is orthorhombic
  
  smallDiag = Hmat[0][0];
  if(smallDiag > Hmat[1][1]) smallDiag = Hmat[1][1];
  if(smallDiag > Hmat[2][2]) smallDiag = Hmat[2][2];
  tol = smallDiag * 1E-6;

  orthoRhombic = 1;
  
  for (i = 0; i < 3; i++ ) {
    for (j = 0 ; j < 3; j++) {
      if (i != j) {
        if (orthoRhombic) {
          if (Hmat[i][j] >= tol) orthoRhombic = 0;
        }        
      }
    }
  }
}

double SimInfo::matDet3(double a[3][3]) {
  int i, j, k;
  double determinant;

  determinant = 0.0;

  for(i = 0; i < 3; i++) {
    j = (i+1)%3;
    k = (i+2)%3;

    determinant += a[0][i] * (a[1][j]*a[2][k] - a[1][k]*a[2][j]);
  }

  return determinant;
}

void SimInfo::invertMat3(double a[3][3], double b[3][3]) {
  
  int  i, j, k, l, m, n;
  double determinant;

  determinant = matDet3( a );

  if (determinant == 0.0) {
    sprintf( painCave.errMsg,
             "Can't invert a matrix with a zero determinant!\n");
    painCave.isFatal = 1;
    simError();
  }

  for (i=0; i < 3; i++) {
    j = (i+1)%3;
    k = (i+2)%3;
    for(l = 0; l < 3; l++) {
      m = (l+1)%3;
      n = (l+2)%3;
      
      b[l][i] = (a[j][m]*a[k][n] - a[j][n]*a[k][m]) / determinant;
    }
  }
}

void SimInfo::matMul3(double a[3][3], double b[3][3], double c[3][3]) {
  double r00, r01, r02, r10, r11, r12, r20, r21, r22;

  r00 = a[0][0]*b[0][0] + a[0][1]*b[1][0] + a[0][2]*b[2][0];
  r01 = a[0][0]*b[0][1] + a[0][1]*b[1][1] + a[0][2]*b[2][1];
  r02 = a[0][0]*b[0][2] + a[0][1]*b[1][2] + a[0][2]*b[2][2];
  
  r10 = a[1][0]*b[0][0] + a[1][1]*b[1][0] + a[1][2]*b[2][0];
  r11 = a[1][0]*b[0][1] + a[1][1]*b[1][1] + a[1][2]*b[2][1];
  r12 = a[1][0]*b[0][2] + a[1][1]*b[1][2] + a[1][2]*b[2][2];
  
  r20 = a[2][0]*b[0][0] + a[2][1]*b[1][0] + a[2][2]*b[2][0];
  r21 = a[2][0]*b[0][1] + a[2][1]*b[1][1] + a[2][2]*b[2][1];
  r22 = a[2][0]*b[0][2] + a[2][1]*b[1][2] + a[2][2]*b[2][2];
  
  c[0][0] = r00; c[0][1] = r01; c[0][2] = r02;
  c[1][0] = r10; c[1][1] = r11; c[1][2] = r12;
  c[2][0] = r20; c[2][1] = r21; c[2][2] = r22;
}

void SimInfo::matVecMul3(double m[3][3], double inVec[3], double outVec[3]) {
  double a0, a1, a2;

  a0 = inVec[0];  a1 = inVec[1];  a2 = inVec[2];

  outVec[0] = m[0][0]*a0 + m[0][1]*a1 + m[0][2]*a2;
  outVec[1] = m[1][0]*a0 + m[1][1]*a1 + m[1][2]*a2;
  outVec[2] = m[2][0]*a0 + m[2][1]*a1 + m[2][2]*a2;
}

void SimInfo::transposeMat3(double in[3][3], double out[3][3]) {
  double temp[3][3];
  int i, j;

  for (i = 0; i < 3; i++) {
    for (j = 0; j < 3; j++) {
      temp[j][i] = in[i][j];
    }
  }
  for (i = 0; i < 3; i++) {
    for (j = 0; j < 3; j++) {
      out[i][j] = temp[i][j];
    }
  }
}
  
void SimInfo::printMat3(double A[3][3] ){

  std::cerr 
            << "[ " << A[0][0] << ", " << A[0][1] << ", " << A[0][2] << " ]\n"
            << "[ " << A[1][0] << ", " << A[1][1] << ", " << A[1][2] << " ]\n"
            << "[ " << A[2][0] << ", " << A[2][1] << ", " << A[2][2] << " ]\n";
}

void SimInfo::printMat9(double A[9] ){

  std::cerr 
            << "[ " << A[0] << ", " << A[1] << ", " << A[2] << " ]\n"
            << "[ " << A[3] << ", " << A[4] << ", " << A[5] << " ]\n"
            << "[ " << A[6] << ", " << A[7] << ", " << A[8] << " ]\n";
}

void SimInfo::calcBoxL( void ){

  double dx, dy, dz, dsq;
  int i;

  // boxVol = Determinant of Hmat

  boxVol = matDet3( Hmat );

  // boxLx
  
  dx = Hmat[0][0]; dy = Hmat[1][0]; dz = Hmat[2][0];
  dsq = dx*dx + dy*dy + dz*dz;
  boxL[0] = sqrt( dsq );
  maxCutoff = 0.5 * boxL[0];

  // boxLy
  
  dx = Hmat[0][1]; dy = Hmat[1][1]; dz = Hmat[2][1];
  dsq = dx*dx + dy*dy + dz*dz;
  boxL[1] = sqrt( dsq );
  if( (0.5 * boxL[1]) < maxCutoff ) maxCutoff = 0.5 * boxL[1];

  // boxLz
  
  dx = Hmat[0][2]; dy = Hmat[1][2]; dz = Hmat[2][2];
  dsq = dx*dx + dy*dy + dz*dz;
  boxL[2] = sqrt( dsq );
  if( (0.5 * boxL[2]) < maxCutoff ) maxCutoff = 0.5 * boxL[2];
  
  checkCutOffs();

}


void SimInfo::wrapVector( double thePos[3] ){

  int i, j, k;
  double scaled[3];

  if( !orthoRhombic ){
    // calc the scaled coordinates.
  

    matVecMul3(HmatInv, thePos, scaled);
    
    for(i=0; i<3; i++)
      scaled[i] -= roundMe(scaled[i]);
    
    // calc the wrapped real coordinates from the wrapped scaled coordinates
    
    matVecMul3(Hmat, scaled, thePos);

  }
  else{
    // calc the scaled coordinates.
    
    for(i=0; i<3; i++)
      scaled[i] = thePos[i]*HmatInv[i][i];
    
    // wrap the scaled coordinates
    
    for(i=0; i<3; i++)
      scaled[i] -= roundMe(scaled[i]);
    
    // calc the wrapped real coordinates from the wrapped scaled coordinates
    
    for(i=0; i<3; i++)
      thePos[i] = scaled[i]*Hmat[i][i];
  }
    
}


int SimInfo::getNDF(){
  int ndf_local, ndf;
  
  ndf_local = 3 * n_atoms + 3 * n_oriented - n_constraints;

#ifdef IS_MPI
  MPI_Allreduce(&ndf_local,&ndf,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD);
#else
  ndf = ndf_local;
#endif

  ndf = ndf - 3 - nZconstraints;

  return ndf;
}

int SimInfo::getNDFraw() {
  int ndfRaw_local, ndfRaw;

  // Raw degrees of freedom that we have to set
  ndfRaw_local = 3 * n_atoms + 3 * n_oriented;
  
#ifdef IS_MPI
  MPI_Allreduce(&ndfRaw_local,&ndfRaw,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD);
#else
  ndfRaw = ndfRaw_local;
#endif

  return ndfRaw;
}
 
void SimInfo::refreshSim(){

  simtype fInfo;
  int isError;
  int n_global;
  int* excl;

  fInfo.dielect = 0.0;

  if( useDipole ){
    if( useReactionField )fInfo.dielect = dielectric;
  }

  fInfo.SIM_uses_PBC = usePBC;
  //fInfo.SIM_uses_LJ = 0;
  fInfo.SIM_uses_LJ = useLJ;
  fInfo.SIM_uses_sticky = useSticky;
  //fInfo.SIM_uses_sticky = 0;
  fInfo.SIM_uses_dipoles = useDipole;
  //fInfo.SIM_uses_dipoles = 0;
  //fInfo.SIM_uses_RF = useReactionField;
  fInfo.SIM_uses_RF = 0;
  fInfo.SIM_uses_GB = useGB;
  fInfo.SIM_uses_EAM = useEAM;

  excl = Exclude::getArray();

#ifdef IS_MPI
  n_global = mpiSim->getTotAtoms();
#else
  n_global = n_atoms;
#endif

  isError = 0;

  setFsimulation( &fInfo, &n_global, &n_atoms, identArray, &n_exclude, excl, 
                  &nGlobalExcludes, globalExcludes, molMembershipArray, 
                  &isError );

  if( isError ){

    sprintf( painCave.errMsg,
             "There was an error setting the simulation information in fortran.\n" );
    painCave.isFatal = 1;
    simError();
  }

#ifdef IS_MPI
  sprintf( checkPointMsg,
           "succesfully sent the simulation information to fortran.\n");
  MPIcheckPoint();
#endif // is_mpi

  this->ndf = this->getNDF();
  this->ndfRaw = this->getNDFraw();

}


void SimInfo::setRcut( double theRcut ){

  if( !haveOrigRcut ){
    haveOrigRcut = 1;
    origRcut = theRcut;
  }

  rCut = theRcut;
  checkCutOffs();
}

void SimInfo::setEcr( double theEcr ){

  if( !haveOrigEcr ){
    haveOrigEcr = 1;
    origEcr = theEcr;
  }

  ecr = theEcr;
  checkCutOffs();
}

void SimInfo::setEcr( double theEcr, double theEst ){

  est = theEst;
  setEcr( theEcr );
}


void SimInfo::checkCutOffs( void ){

  int cutChanged = 0;


  if( boxIsInit ){
    
    //we need to check cutOffs against the box
   
    if(( maxCutoff > rCut )&&(usePBC)){
      if( rCut < origRcut ){
        rCut = origRcut;
        if (rCut > maxCutoff) rCut = maxCutoff;
        
        sprintf( painCave.errMsg,
                 "New Box size is setting the long range cutoff radius "
                 "to %lf\n",
                 rCut );
        painCave.isFatal = 0;
        simError();
      }
    }

    if( maxCutoff > ecr ){
      if( ecr < origEcr ){
        rCut = origEcr;
        if (ecr > maxCutoff) ecr = maxCutoff;
        
        sprintf( painCave.errMsg,
                 "New Box size is setting the electrostaticCutoffRadius "
                 "to %lf\n",
                 ecr );
        painCave.isFatal = 0;
        simError();
      }
    }


    if ((rCut > maxCutoff)&&(usePBC)) {
      sprintf( painCave.errMsg,
               "New Box size is setting the long range cutoff radius "
               "to %lf\n",
               maxCutoff );
      painCave.isFatal = 0;
      simError();
      rCut = maxCutoff;
    }

    if( ecr > maxCutoff){
      sprintf( painCave.errMsg,
               "New Box size is setting the electrostaticCutoffRadius "
               "to %lf\n",
               maxCutoff  );
      painCave.isFatal = 0;
      simError();      
      ecr = maxCutoff;
    }

    
  }
   

  if( (oldEcr != ecr) || ( oldRcut != rCut ) ) cutChanged = 1;

  // rlist is the 1.0 plus max( rcut, ecr )
  
  ( rCut > ecr )? rList = rCut + 1.0: rList = ecr + 1.0;

  if( cutChanged ){
    
    notifyFortranCutOffs( &rCut, &rList, &ecr, &est );
  }

  oldEcr = ecr;
  oldRcut = rCut;
}

void SimInfo::addProperty(GenericData* prop){

  map<string, GenericData*>::iterator result;
  result = properties.find(prop->getID());
  
  //we can't simply use  properties[prop->getID()] = prop,
  //it will cause memory leak if we already contain a propery which has the same name of prop
  
  if(result != properties.end()){
    
    delete (*result).second;
    (*result).second = prop;
      
  }
  else{

    properties[prop->getID()] = prop;

  }
    
}

GenericData* SimInfo::getProperty(const string& propName){
 
  map<string, GenericData*>::iterator result;
  
  //string lowerCaseName = ();
  
  result = properties.find(propName);
  
  if(result != properties.end()) 
    return (*result).second;  
  else   
    return NULL;  
}

vector<GenericData*> SimInfo::getProperties(){

  vector<GenericData*> result;
  map<string, GenericData*>::iterator i;
  
  for(i = properties.begin(); i != properties.end(); i++)
    result.push_back((*i).second);
    
  return result;
}


Revision:	690
Committed:	Tue Aug 12 21:44:06 2003 UTC (22 years, 2 months ago) by mmeineke
File size:	12164 byte(s)
Log Message:	fixed a really annoying bug in Directional Atom, where mu was getting written to pseudorandom memory location.
#	User	Rev	Content
1	mmeineke	377	#include <cstdlib>
2			#include <cstring>
3	mmeineke	568	#include <cmath>
4	mmeineke	377
5	mmeineke	572	#include <iostream>
6			using namespace std;
7	mmeineke	377
8			#include "SimInfo.hpp"
9			#define __C
10			#include "fSimulation.h"
11			#include "simError.h"
12
13			#include "fortranWrappers.hpp"
14
15	gezelter	490	#ifdef IS_MPI
16			#include "mpiSimulation.hpp"
17			#endif
18
19	mmeineke	572	inline double roundMe( double x ){
20			return ( x >= 0 ) ? floor( x + 0.5 ) : ceil( x - 0.5 );
21			}
22
23
24	mmeineke	377	SimInfo* currentInfo;
25
26			SimInfo::SimInfo(){
27			excludes = NULL;
28			n_constraints = 0;
29			n_oriented = 0;
30			n_dipoles = 0;
31	gezelter	458	ndf = 0;
32			ndfRaw = 0;
33	mmeineke	674	nZconstraints = 0;
34	mmeineke	377	the_integrator = NULL;
35			setTemp = 0;
36			thermalTime = 0.0;
37	mmeineke	642	currentTime = 0.0;
38	mmeineke	420	rCut = 0.0;
39	mmeineke	690	origRcut = -1.0;
40	mmeineke	618	ecr = 0.0;
41	mmeineke	690	origEcr = -1.0;
42	mmeineke	619	est = 0.0;
43	mmeineke	626	oldEcr = 0.0;
44			oldRcut = 0.0;
45	mmeineke	377
46	mmeineke	626	haveOrigRcut = 0;
47			haveOrigEcr = 0;
48			boxIsInit = 0;
49
50
51
52	mmeineke	377	usePBC = 0;
53			useLJ = 0;
54			useSticky = 0;
55			useDipole = 0;
56			useReactionField = 0;
57			useGB = 0;
58			useEAM = 0;
59
60	mmeineke	670	myConfiguration = new SimState();
61
62	gezelter	457	wrapMeSimInfo( this );
63			}
64	mmeineke	377
65	mmeineke	670
66	tim	660	SimInfo::~SimInfo(){
67
68	mmeineke	670	delete myConfiguration;
69
70	tim	660	map<string, GenericData*>::iterator i;
71
72			for(i = properties.begin(); i != properties.end(); i++)
73			delete (*i).second;
74	mmeineke	670
75	tim	660	}
76
77	gezelter	457	void SimInfo::setBox(double newBox[3]) {
78	mmeineke	586
79	gezelter	588	int i, j;
80			double tempMat[3][3];
81	gezelter	463
82	gezelter	588	for(i=0; i<3; i++)
83			for (j=0; j<3; j++) tempMat[i][j] = 0.0;;
84	gezelter	463
85	gezelter	588	tempMat[0][0] = newBox[0];
86			tempMat[1][1] = newBox[1];
87			tempMat[2][2] = newBox[2];
88	gezelter	463
89	mmeineke	586	setBoxM( tempMat );
90	mmeineke	568
91	gezelter	457	}
92	mmeineke	377
93	gezelter	588	void SimInfo::setBoxM( double theBox[3][3] ){
94	mmeineke	568
95	gezelter	588	int i, j, status;
96	mmeineke	568	double smallestBoxL, maxCutoff;
97	gezelter	588	double FortranHmat[9]; // to preserve compatibility with Fortran the
98			// ordering in the array is as follows:
99			// [ 0 3 6 ]
100			// [ 1 4 7 ]
101			// [ 2 5 8 ]
102			double FortranHmatInv[9]; // the inverted Hmat (for Fortran);
103	mmeineke	568
104	mmeineke	626
105			if( !boxIsInit ) boxIsInit = 1;
106	mmeineke	586
107	gezelter	588	for(i=0; i < 3; i++)
108			for (j=0; j < 3; j++) Hmat[i][j] = theBox[i][j];
109
110	mmeineke	568	calcBoxL();
111	gezelter	588	calcHmatInv();
112	mmeineke	568
113	gezelter	588	for(i=0; i < 3; i++) {
114			for (j=0; j < 3; j++) {
115			FortranHmat[3*j + i] = Hmat[i][j];
116			FortranHmatInv[3*j + i] = HmatInv[i][j];
117			}
118			}
119	mmeineke	586
120	mmeineke	590	setFortranBoxSize(FortranHmat, FortranHmatInv, &orthoRhombic);
121	mmeineke	568
122	mmeineke	377	}
123	gezelter	458
124	mmeineke	568
125	gezelter	588	void SimInfo::getBoxM (double theBox[3][3]) {
126	mmeineke	568
127	gezelter	588	int i, j;
128			for(i=0; i<3; i++)
129			for (j=0; j<3; j++) theBox[i][j] = Hmat[i][j];
130	mmeineke	568	}
131
132	gezelter	574
133			void SimInfo::scaleBox(double scale) {
134	gezelter	588	double theBox[3][3];
135			int i, j;
136	gezelter	574
137	gezelter	617	// cerr << "Scaling box by " << scale << "\n";
138	mmeineke	586
139	gezelter	588	for(i=0; i<3; i++)
140			for (j=0; j<3; j++) theBox[i][j] = Hmat[i][j]*scale;
141	gezelter	574
142			setBoxM(theBox);
143
144			}
145
146	gezelter	588	void SimInfo::calcHmatInv( void ) {
147	mmeineke	590
148			int i,j;
149	mmeineke	569	double smallDiag;
150			double tol;
151			double sanity[3][3];
152	mmeineke	568
153	gezelter	588	invertMat3( Hmat, HmatInv );
154	mmeineke	568
155	gezelter	588	// Check the inverse to make sure it is sane:
156	mmeineke	568
157	gezelter	588	matMul3( Hmat, HmatInv, sanity );
158
159			// check to see if Hmat is orthorhombic
160	mmeineke	568
161	gezelter	588	smallDiag = Hmat[0][0];
162			if(smallDiag > Hmat[1][1]) smallDiag = Hmat[1][1];
163			if(smallDiag > Hmat[2][2]) smallDiag = Hmat[2][2];
164			tol = smallDiag * 1E-6;
165	mmeineke	568
166	gezelter	588	orthoRhombic = 1;
167	mmeineke	568
168	gezelter	588	for (i = 0; i < 3; i++ ) {
169			for (j = 0 ; j < 3; j++) {
170			if (i != j) {
171			if (orthoRhombic) {
172			if (Hmat[i][j] >= tol) orthoRhombic = 0;
173			}
174			}
175	mmeineke	568	}
176			}
177	gezelter	588	}
178	mmeineke	569
179	gezelter	588	double SimInfo::matDet3(double a[3][3]) {
180			int i, j, k;
181			double determinant;
182	mmeineke	569
183	gezelter	588	determinant = 0.0;
184
185			for(i = 0; i < 3; i++) {
186			j = (i+1)%3;
187			k = (i+2)%3;
188
189			determinant += a[0][i] * (a[1][j]a[2][k] - a[1][k]a[2][j]);
190	mmeineke	569	}
191
192	gezelter	588	return determinant;
193			}
194	mmeineke	569
195	gezelter	588	void SimInfo::invertMat3(double a[3][3], double b[3][3]) {
196	mmeineke	569
197	gezelter	588	int i, j, k, l, m, n;
198			double determinant;
199	mmeineke	569
200	gezelter	588	determinant = matDet3( a );
201
202			if (determinant == 0.0) {
203			sprintf( painCave.errMsg,
204			"Can't invert a matrix with a zero determinant!\n");
205			painCave.isFatal = 1;
206			simError();
207			}
208
209			for (i=0; i < 3; i++) {
210			j = (i+1)%3;
211			k = (i+2)%3;
212			for(l = 0; l < 3; l++) {
213			m = (l+1)%3;
214			n = (l+2)%3;
215
216			b[l][i] = (a[j][m]a[k][n] - a[j][n]a[k][m]) / determinant;
217	mmeineke	569	}
218			}
219	mmeineke	568	}
220
221	gezelter	588	void SimInfo::matMul3(double a[3][3], double b[3][3], double c[3][3]) {
222			double r00, r01, r02, r10, r11, r12, r20, r21, r22;
223
224			r00 = a[0][0]b[0][0] + a[0][1]b[1][0] + a[0][2]*b[2][0];
225			r01 = a[0][0]b[0][1] + a[0][1]b[1][1] + a[0][2]*b[2][1];
226			r02 = a[0][0]b[0][2] + a[0][1]b[1][2] + a[0][2]*b[2][2];
227
228			r10 = a[1][0]b[0][0] + a[1][1]b[1][0] + a[1][2]*b[2][0];
229			r11 = a[1][0]b[0][1] + a[1][1]b[1][1] + a[1][2]*b[2][1];
230			r12 = a[1][0]b[0][2] + a[1][1]b[1][2] + a[1][2]*b[2][2];
231
232			r20 = a[2][0]b[0][0] + a[2][1]b[1][0] + a[2][2]*b[2][0];
233			r21 = a[2][0]b[0][1] + a[2][1]b[1][1] + a[2][2]*b[2][1];
234			r22 = a[2][0]b[0][2] + a[2][1]b[1][2] + a[2][2]*b[2][2];
235
236			c[0][0] = r00; c[0][1] = r01; c[0][2] = r02;
237			c[1][0] = r10; c[1][1] = r11; c[1][2] = r12;
238			c[2][0] = r20; c[2][1] = r21; c[2][2] = r22;
239			}
240
241			void SimInfo::matVecMul3(double m[3][3], double inVec[3], double outVec[3]) {
242			double a0, a1, a2;
243
244			a0 = inVec[0]; a1 = inVec[1]; a2 = inVec[2];
245
246			outVec[0] = m[0][0]a0 + m[0][1]a1 + m[0][2]*a2;
247			outVec[1] = m[1][0]a0 + m[1][1]a1 + m[1][2]*a2;
248			outVec[2] = m[2][0]a0 + m[2][1]a1 + m[2][2]*a2;
249			}
250	mmeineke	597
251			void SimInfo::transposeMat3(double in[3][3], double out[3][3]) {
252			double temp[3][3];
253			int i, j;
254
255			for (i = 0; i < 3; i++) {
256			for (j = 0; j < 3; j++) {
257			temp[j][i] = in[i][j];
258			}
259			}
260			for (i = 0; i < 3; i++) {
261			for (j = 0; j < 3; j++) {
262			out[i][j] = temp[i][j];
263			}
264			}
265			}
266	gezelter	588
267	mmeineke	597	void SimInfo::printMat3(double A[3][3] ){
268
269			std::cerr
270			<< "[ " << A[0][0] << ", " << A[0][1] << ", " << A[0][2] << " ]\n"
271			<< "[ " << A[1][0] << ", " << A[1][1] << ", " << A[1][2] << " ]\n"
272			<< "[ " << A[2][0] << ", " << A[2][1] << ", " << A[2][2] << " ]\n";
273			}
274
275			void SimInfo::printMat9(double A[9] ){
276
277			std::cerr
278			<< "[ " << A[0] << ", " << A[1] << ", " << A[2] << " ]\n"
279			<< "[ " << A[3] << ", " << A[4] << ", " << A[5] << " ]\n"
280			<< "[ " << A[6] << ", " << A[7] << ", " << A[8] << " ]\n";
281			}
282
283	mmeineke	568	void SimInfo::calcBoxL( void ){
284
285			double dx, dy, dz, dsq;
286			int i;
287
288	gezelter	588	// boxVol = Determinant of Hmat
289	mmeineke	568
290	gezelter	588	boxVol = matDet3( Hmat );
291	mmeineke	568
292			// boxLx
293
294	gezelter	588	dx = Hmat[0][0]; dy = Hmat[1][0]; dz = Hmat[2][0];
295	mmeineke	568	dsq = dxdx + dydy + dz*dz;
296	gezelter	621	boxL[0] = sqrt( dsq );
297	mmeineke	626	maxCutoff = 0.5 * boxL[0];
298	mmeineke	568
299			// boxLy
300
301	gezelter	588	dx = Hmat[0][1]; dy = Hmat[1][1]; dz = Hmat[2][1];
302	mmeineke	568	dsq = dxdx + dydy + dz*dz;
303	gezelter	621	boxL[1] = sqrt( dsq );
304	mmeineke	626	if( (0.5 * boxL[1]) < maxCutoff ) maxCutoff = 0.5 * boxL[1];
305	mmeineke	568
306			// boxLz
307
308	gezelter	588	dx = Hmat[0][2]; dy = Hmat[1][2]; dz = Hmat[2][2];
309	mmeineke	568	dsq = dxdx + dydy + dz*dz;
310	gezelter	621	boxL[2] = sqrt( dsq );
311	mmeineke	626	if( (0.5 * boxL[2]) < maxCutoff ) maxCutoff = 0.5 * boxL[2];
312	chuckv	669
313			checkCutOffs();
314	mmeineke	626
315	mmeineke	568	}
316
317
318			void SimInfo::wrapVector( double thePos[3] ){
319
320			int i, j, k;
321			double scaled[3];
322
323	mmeineke	569	if( !orthoRhombic ){
324			// calc the scaled coordinates.
325	gezelter	588
326
327			matVecMul3(HmatInv, thePos, scaled);
328	mmeineke	569
329			for(i=0; i<3; i++)
330	mmeineke	572	scaled[i] -= roundMe(scaled[i]);
331	mmeineke	569
332			// calc the wrapped real coordinates from the wrapped scaled coordinates
333
334	gezelter	588	matVecMul3(Hmat, scaled, thePos);
335
336	mmeineke	569	}
337			else{
338			// calc the scaled coordinates.
339
340			for(i=0; i<3; i++)
341	gezelter	588	scaled[i] = thePos[i]*HmatInv[i][i];
342	mmeineke	569
343			// wrap the scaled coordinates
344
345			for(i=0; i<3; i++)
346	mmeineke	572	scaled[i] -= roundMe(scaled[i]);
347	mmeineke	569
348			// calc the wrapped real coordinates from the wrapped scaled coordinates
349
350			for(i=0; i<3; i++)
351	gezelter	588	thePos[i] = scaled[i]*Hmat[i][i];
352	mmeineke	569	}
353
354	mmeineke	568	}
355
356
357	gezelter	458	int SimInfo::getNDF(){
358			int ndf_local, ndf;
359	gezelter	457
360	gezelter	458	ndf_local = 3 * n_atoms + 3 * n_oriented - n_constraints;
361
362			#ifdef IS_MPI
363			MPI_Allreduce(&ndf_local,&ndf,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD);
364			#else
365			ndf = ndf_local;
366			#endif
367
368	mmeineke	674	ndf = ndf - 3 - nZconstraints;
369	gezelter	458
370			return ndf;
371			}
372
373			int SimInfo::getNDFraw() {
374			int ndfRaw_local, ndfRaw;
375
376			// Raw degrees of freedom that we have to set
377			ndfRaw_local = 3 * n_atoms + 3 * n_oriented;
378
379			#ifdef IS_MPI
380			MPI_Allreduce(&ndfRaw_local,&ndfRaw,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD);
381			#else
382			ndfRaw = ndfRaw_local;
383			#endif
384
385			return ndfRaw;
386			}
387
388	mmeineke	377	void SimInfo::refreshSim(){
389
390			simtype fInfo;
391			int isError;
392	gezelter	490	int n_global;
393	mmeineke	424	int* excl;
394	mmeineke	626
395	mmeineke	469	fInfo.dielect = 0.0;
396	mmeineke	377
397	mmeineke	469	if( useDipole ){
398			if( useReactionField )fInfo.dielect = dielectric;
399			}
400
401	mmeineke	377	fInfo.SIM_uses_PBC = usePBC;
402	mmeineke	443	//fInfo.SIM_uses_LJ = 0;
403	chuckv	439	fInfo.SIM_uses_LJ = useLJ;
404	mmeineke	443	fInfo.SIM_uses_sticky = useSticky;
405			//fInfo.SIM_uses_sticky = 0;
406	chuckv	482	fInfo.SIM_uses_dipoles = useDipole;
407			//fInfo.SIM_uses_dipoles = 0;
408	mmeineke	443	//fInfo.SIM_uses_RF = useReactionField;
409			fInfo.SIM_uses_RF = 0;
410	mmeineke	377	fInfo.SIM_uses_GB = useGB;
411			fInfo.SIM_uses_EAM = useEAM;
412
413	mmeineke	424	excl = Exclude::getArray();
414	mmeineke	377
415	gezelter	490	#ifdef IS_MPI
416			n_global = mpiSim->getTotAtoms();
417			#else
418			n_global = n_atoms;
419			#endif
420
421	mmeineke	377	isError = 0;
422
423	gezelter	490	setFsimulation( &fInfo, &n_global, &n_atoms, identArray, &n_exclude, excl,
424	gezelter	483	&nGlobalExcludes, globalExcludes, molMembershipArray,
425			&isError );
426	mmeineke	377
427			if( isError ){
428
429			sprintf( painCave.errMsg,
430			"There was an error setting the simulation information in fortran.\n" );
431			painCave.isFatal = 1;
432			simError();
433			}
434
435			#ifdef IS_MPI
436			sprintf( checkPointMsg,
437			"succesfully sent the simulation information to fortran.\n");
438			MPIcheckPoint();
439			#endif // is_mpi
440	gezelter	458
441	gezelter	474	this->ndf = this->getNDF();
442			this->ndfRaw = this->getNDFraw();
443	gezelter	458
444	mmeineke	377	}
445
446	mmeineke	626
447			void SimInfo::setRcut( double theRcut ){
448
449			if( !haveOrigRcut ){
450			haveOrigRcut = 1;
451			origRcut = theRcut;
452			}
453
454			rCut = theRcut;
455			checkCutOffs();
456			}
457
458			void SimInfo::setEcr( double theEcr ){
459
460			if( !haveOrigEcr ){
461			haveOrigEcr = 1;
462			origEcr = theEcr;
463			}
464
465			ecr = theEcr;
466			checkCutOffs();
467			}
468
469			void SimInfo::setEcr( double theEcr, double theEst ){
470
471			est = theEst;
472			setEcr( theEcr );
473			}
474
475
476			void SimInfo::checkCutOffs( void ){
477
478			int cutChanged = 0;
479
480	chuckv	669
481
482	mmeineke	626	if( boxIsInit ){
483
484			//we need to check cutOffs against the box
485	chuckv	669
486			if(( maxCutoff > rCut )&&(usePBC)){
487	mmeineke	626	if( rCut < origRcut ){
488			rCut = origRcut;
489			if (rCut > maxCutoff) rCut = maxCutoff;
490
491			sprintf( painCave.errMsg,
492			"New Box size is setting the long range cutoff radius "
493			"to %lf\n",
494			rCut );
495			painCave.isFatal = 0;
496			simError();
497			}
498			}
499
500			if( maxCutoff > ecr ){
501			if( ecr < origEcr ){
502			rCut = origEcr;
503			if (ecr > maxCutoff) ecr = maxCutoff;
504
505			sprintf( painCave.errMsg,
506			"New Box size is setting the electrostaticCutoffRadius "
507			"to %lf\n",
508			ecr );
509			painCave.isFatal = 0;
510			simError();
511			}
512			}
513
514
515	chuckv	669	if ((rCut > maxCutoff)&&(usePBC)) {
516	mmeineke	626	sprintf( painCave.errMsg,
517			"New Box size is setting the long range cutoff radius "
518			"to %lf\n",
519			maxCutoff );
520			painCave.isFatal = 0;
521			simError();
522			rCut = maxCutoff;
523			}
524
525			if( ecr > maxCutoff){
526			sprintf( painCave.errMsg,
527			"New Box size is setting the electrostaticCutoffRadius "
528			"to %lf\n",
529			maxCutoff );
530			painCave.isFatal = 0;
531			simError();
532			ecr = maxCutoff;
533			}
534
535
536			}
537
538
539			if( (oldEcr != ecr) \|\| ( oldRcut != rCut ) ) cutChanged = 1;
540
541			// rlist is the 1.0 plus max( rcut, ecr )
542
543			( rCut > ecr )? rList = rCut + 1.0: rList = ecr + 1.0;
544
545			if( cutChanged ){
546
547			notifyFortranCutOffs( &rCut, &rList, &ecr, &est );
548			}
549
550			oldEcr = ecr;
551			oldRcut = rCut;
552			}
553	tim	658
554			void SimInfo::addProperty(GenericData* prop){
555
556			map<string, GenericData*>::iterator result;
557			result = properties.find(prop->getID());
558
559			//we can't simply use properties[prop->getID()] = prop,
560			//it will cause memory leak if we already contain a propery which has the same name of prop
561
562			if(result != properties.end()){
563
564			delete (*result).second;
565			(*result).second = prop;
566
567			}
568			else{
569
570			properties[prop->getID()] = prop;
571
572			}
573
574			}
575
576			GenericData* SimInfo::getProperty(const string& propName){
577
578			map<string, GenericData*>::iterator result;
579
580			//string lowerCaseName = ();
581
582			result = properties.find(propName);
583
584			if(result != properties.end())
585			return (*result).second;
586			else
587			return NULL;
588			}
589
590			vector<GenericData*> SimInfo::getProperties(){
591
592			vector<GenericData*> result;
593			map<string, GenericData*>::iterator i;
594
595			for(i = properties.begin(); i != properties.end(); i++)
596			result.push_back((*i).second);
597
598			return result;
599			}
600
601