OOPSE/libmdtools/ZConstraint.cpp

#include "Integrator.hpp"
#include "simError.h"
#include <cmath>
template<typename T> ZConstraint<T>::ZConstraint(SimInfo* theInfo, ForceFields* the_ff) 
                                    : T(theInfo, the_ff), fz(NULL), 
                                      indexOfZConsMols(NULL)
{

  //get properties from SimInfo
  GenericData* data;
  ZConsParaData* zConsParaData;
  DoubleData* sampleTime;
  DoubleData* tolerance;
  StringData* filename; 
  double COM[3];

  //by default, the direction of constraint is z
  // 0 --> x
  // 1 --> y
  // 2 --> z
  whichDirection = 2;

  //estimate the force constant of harmonical potential
  double Kb = 1.986E-3 ; //in kcal/K
  
  double halfOfLargestBox = max(info->boxL[0], max(info->boxL[1], info->boxL[2])) /2;
  zForceConst = Kb * info->target_temp /(halfOfLargestBox * halfOfLargestBox);

  //retrieve sample time of z-contraint 
  data = info->getProperty(ZCONSTIME_ID);
  
  if(!data) {
      
    sprintf( painCave.errMsg,
               "ZConstraint error: If you use an ZConstraint\n"
               " , you must set sample time.\n");
    painCave.isFatal = 1;
    simError();      
  }
  else{
  
    sampleTime = dynamic_cast<DoubleData*>(data);
     
    if(!sampleTime){

      sprintf( painCave.errMsg,
                 "ZConstraint error: Can not get property from SimInfo\n");
      painCave.isFatal = 1;
      simError();  
       
    }
    else{
      this->zconsTime = sampleTime->getData();
    }

  }
  
  //retrieve output filename of z force
  data = info->getProperty(ZCONSFILENAME_ID);
  if(!data) {

      
    sprintf( painCave.errMsg,
               "ZConstraint error: If you use an ZConstraint\n"
               " , you must set output filename of z-force.\n");
    painCave.isFatal = 1;
    simError();  

  }
  else{

     filename = dynamic_cast<StringData*>(data);
    
    if(!filename){

      sprintf( painCave.errMsg,
                 "ZConstraint error: Can not get property from SimInfo\n");
      painCave.isFatal = 1;
      simError();  
        
    }
    else{
      this->zconsOutput = filename->getData();
    }
    

  }

  //retrieve tolerance for z-constraint molecuels
  data = info->getProperty(ZCONSTOL_ID);
  
  if(!data) {
      
    sprintf( painCave.errMsg,
               "ZConstraint error: can not get tolerance \n");
    painCave.isFatal = 1;
    simError();      
  }
  else{
  
    tolerance = dynamic_cast<DoubleData*>(data);
     
    if(!tolerance){

      sprintf( painCave.errMsg,
                 "ZConstraint error: Can not get property from SimInfo\n");
      painCave.isFatal = 1;
      simError();  
       
    }
    else{
      this->zconsTol = tolerance->getData();
    }

  }
        
  //retrieve index of z-constraint molecules
  data = info->getProperty(ZCONSPARADATA_ID);
  if(!data) {

    sprintf( painCave.errMsg,
               "ZConstraint error: If you use an ZConstraint\n"
               " , you must set index of z-constraint molecules.\n");
    painCave.isFatal = 1;
    simError();  
  }
  else{
  
    zConsParaData = dynamic_cast<ZConsParaData*>(data);
    
    if(!zConsParaData){

      sprintf( painCave.errMsg,
                 "ZConstraint error: Can not get parameters of zconstraint method from SimInfo\n");
      painCave.isFatal = 1;
      simError();  
    
    }
    else{
       
      parameters = zConsParaData->getData();

      //check the range of zconsIndex
      //and the minimum value of index is the first one (we already sorted the data)
      //the maximum value of index is the last one

      int maxIndex;
      int minIndex;
      int totalNumMol;

      minIndex = (*parameters)[0].zconsIndex;
      if(minIndex < 0){
        sprintf( painCave.errMsg,
               "ZConstraint error: index is out of range\n");
        painCave.isFatal = 1;
        simError(); 
        }

      maxIndex = (*parameters)[parameters->size() - 1].zconsIndex;

#ifndef IS_MPI
      totalNumMol = nMols;
#else
      totalNumMol = mpiSim->getTotNmol();   
#endif      
      
      if(maxIndex > totalNumMol - 1){
        sprintf( painCave.errMsg,
               "ZConstraint error: index is out of range\n");
        painCave.isFatal = 1;
        simError();                  
      }

      //if user does not specify the zpos for the zconstraint molecule
      //its initial z coordinate  will be used as default
      for(int i = 0; i < parameters->size(); i++){

              if(!(*parameters)[i].havingZPos){

#ifndef IS_MPI
            for(int j = 0; j < nMols; j++){
              if (molecules[j].getGlobalIndex() == (*parameters)[i].zconsIndex){
                 molecules[j].getCOM(COM);
                          break; 
              }
            }
#else
            //query which processor current zconstraint molecule belongs to
           int *MolToProcMap;
           int whichNode;
                         double initZPos;
           MolToProcMap = mpiSim->getMolToProcMap();
           whichNode = MolToProcMap[(*parameters)[i].zconsIndex];
                          
           //broadcast the zpos of current z-contraint molecule
           //the node which contain this 
           
           if (worldRank == whichNode ){
                                                
             for(int j = 0; j < nMols; j++)
               if (molecules[j].getGlobalIndex() == (*parameters)[i].zconsIndex){
                 molecules[j].getCOM(COM);
                                         break; 
               }
                                 
           }

            MPI_Bcast(&COM[whichDirection], 1, MPI_DOUBLE_PRECISION, whichNode, MPI_COMM_WORLD);                          
#endif
            
                 (*parameters)[i].zPos = COM[whichDirection];

            sprintf( painCave.errMsg,
                     "ZConstraint warningr: Does not specify zpos for z-constraint molecule "
                     "initial z coornidate will be used \n");
            painCave.isFatal = 0;
            simError();  
          
              }
            }
                        
    }//end if (!zConsParaData)
  }//end  if (!data)
             
//  
#ifdef IS_MPI
  update(); 
#else  
  int searchResult;
      
  for(int i = 0; i < nMols; i++){
    
    searchResult = isZConstraintMol(&molecules[i]); 
    
    if(searchResult > -1){
    
      zconsMols.push_back(&molecules[i]);      
      massOfZConsMols.push_back(molecules[i].getTotalMass());  

      zPos.push_back((*parameters)[searchResult].zPos);
           kz.push_back((*parameters)[searchResult]. kRatio * zForceConst);
      
      molecules[i].getCOM(COM);
    }
    else
    {
    
      unconsMols.push_back(&molecules[i]);
      massOfUnconsMols.push_back(molecules[i].getTotalMass());

    }
  }

  fz = new double[zconsMols.size()];
  indexOfZConsMols = new int [zconsMols.size()];

  if(!fz || !indexOfZConsMols){
    sprintf( painCave.errMsg,
             "Memory allocation failure in class Zconstraint\n");
    painCave.isFatal = 1;
    simError();
  }

  //determine the states of z-constraint molecules
  for(int i = 0; i < zconsMols.size(); i++){
    indexOfZConsMols[i] = zconsMols[i]->getGlobalIndex();

         zconsMols[i]->getCOM(COM);
    if (fabs(zPos[i] - COM[whichDirection]) < zconsTol)
                states.push_back(zcsFixed);
         else
                states.push_back(zcsMoving);
  }
  
#endif 

  //get total masss of unconstraint molecules
  double totalMassOfUncons_local;
  totalMassOfUncons_local = 0;
  
  for(int i = 0; i < unconsMols.size(); i++)
    totalMassOfUncons_local += unconsMols[i]->getTotalMass();
    
#ifndef IS_MPI
  totalMassOfUncons = totalMassOfUncons_local;
#else
  MPI_Allreduce(&totalMassOfUncons_local, &totalMassOfUncons, 1, MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);  
#endif


  //get total number of unconstrained atoms
  int nUnconsAtoms_local;
  nUnconsAtoms_local = 0;
  for(int i = 0; i < unconsMols.size(); i++)
    nUnconsAtoms_local += unconsMols[i]->getNAtoms();
    
#ifndef IS_MPI
  totNumOfUnconsAtoms = nUnconsAtoms_local;
#else
  MPI_Allreduce(&nUnconsAtoms_local, &totNumOfUnconsAtoms, 1, MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);  
#endif  

  // creat zconsWriter  
  fzOut = new ZConsWriter(zconsOutput.c_str());   
  
  if(!fzOut){
    sprintf( painCave.errMsg,
             "Memory allocation failure in class Zconstraint\n");
    painCave.isFatal = 1;
    simError();
  }
  
}

template<typename T> ZConstraint<T>::~ZConstraint()
{
  if(fz)
    delete[] fz;
  
  if(indexOfZConsMols)
    delete[] indexOfZConsMols;
  
  if(fzOut)
    delete fzOut;
}

#ifdef IS_MPI
template<typename T> void ZConstraint<T>::update()
{
  double COM[3];
  int index;
  
  zconsMols.clear();
  massOfZConsMols.clear();
  zPos.clear();
  kz.clear();
  
  unconsMols.clear();
  massOfUnconsMols.clear();
 

  //creat zconsMol and unconsMol lists
  for(int i = 0; i < nMols; i++){
    
    index = isZConstraintMol(&molecules[i]); 
    
    if(index > -1){
    
      zconsMols.push_back(&molecules[i]);      
      zPos.push_back((*parameters)[index].zPos);
        kz.push_back((*parameters)[index].kRatio * zForceConst);
                        
      massOfZConsMols.push_back(molecules[i].getTotalMass());  
       
      molecules[i].getCOM(COM);
    }
    else
    {
    
      unconsMols.push_back(&molecules[i]);
      massOfUnconsMols.push_back(molecules[i].getTotalMass());

    }
  }

  //determine the states of z-constraint molecules
  for(int i = 0; i < zconsMols.size(); i++){
           zconsMols[i]->getCOM(COM);
      if (fabs(zPos[i] - COM[whichDirection]) < zconsTol)
                  states.push_back(zcsFixed);
           else
                  states.push_back(zcsMoving);
  }

    
  //The reason to declare fz and indexOfZconsMols as pointer to array is
  // that we want to make the MPI communication simple
  if(fz)
    delete[] fz;
    
  if(indexOfZConsMols)
    delete[] indexOfZConsMols;
    
  if (zconsMols.size() > 0){
    fz = new double[zconsMols.size()];
    indexOfZConsMols =  new int[zconsMols.size()];
    
    if(!fz || !indexOfZConsMols){
      sprintf( painCave.errMsg,
               "Memory allocation failure in class Zconstraint\n");
      painCave.isFatal = 1;
      simError();
    }
        
    for(int i = 0; i < zconsMols.size(); i++){
      indexOfZConsMols[i] = zconsMols[i]->getGlobalIndex();
    }

  }
  else{
    fz = NULL;
    indexOfZConsMols = NULL;
  }
  
}

#endif

/**  Function Name: isZConstraintMol
 **  Parameter
 **    Molecule* mol
 **  Return value:
 **    -1, if the molecule is not z-constraint molecule, 
 **    other non-negative values, its index in indexOfAllZConsMols vector
 */

template<typename T> int ZConstraint<T>::isZConstraintMol(Molecule* mol)
{
  int index;
  int low;
  int high;
  int mid;

  index = mol->getGlobalIndex();
  
  low = 0;
  high = parameters->size() - 1;
  
  //Binary Search (we have sorted the array)  
  while(low <= high){
    mid = (low + high) /2;
    if ((*parameters)[mid].zconsIndex == index)
      return mid;
    else if ((*parameters)[mid].zconsIndex > index )
       high = mid -1;
    else     
      low = mid + 1; 
  }
  
  return -1;
}

template<typename T> void ZConstraint<T>::integrate(){
  
  //zero out the velocities of center of mass of unconstrained molecules 
  //and the velocities of center of mass of every single z-constrained molecueles
  zeroOutVel();
  
  T::integrate();

}
 

/**
 *
 *
 *
 *
 */

 
template<typename T> void ZConstraint<T>::calcForce(int calcPot, int calcStress){
  double zsys;

  T::calcForce(calcPot, calcStress);

  if (checkZConsState())
  zeroOutVel();
  
  zsys = calcZSys();
  cout << "---------------------------------------------------------------------" <<endl;
  cout << "current time: " << info->getTime() <<"\tcenter of mass at z: " << zsys << endl;       
  cout << "before calcForce, the COMVel of unconstraint molecules is " << calcCOMVel() <<endl;
        

  //do zconstraint force; 
  if (haveFixedZMols())
    this->doZconstraintForce();


  //use harmonical poteintial to move the molecules to the specified positions
  if (haveMovingZMols())
    this->doHarmonic();
   
  fzOut->writeFZ(info->getTime(), zconsMols.size(),indexOfZConsMols, fz);
  cout << "after calcForce, the COMVel of unconstraint molecules is " << calcCOMVel() <<endl; 
}
 
template<typename T> double ZConstraint<T>::calcZSys()
{
  //calculate reference z coordinate for z-constraint molecules
  double totalMass_local;
  double totalMass;
  double totalMZ_local;
  double totalMZ;
  double massOfUncons_local;
  double massOfCurMol;
  double COM[3];
  
  totalMass_local = 0;
  totalMass = 0;
  totalMZ_local = 0;
  totalMZ = 0;
  massOfUncons_local = 0;
    
  
  for(int i = 0; i < nMols; i++){
    massOfCurMol = molecules[i].getTotalMass(); 
    molecules[i].getCOM(COM); 
     
    totalMass_local += massOfCurMol;
    totalMZ_local += massOfCurMol * COM[whichDirection];
    
    if(isZConstraintMol(&molecules[i]) == -1){
    
      massOfUncons_local += massOfCurMol;
    }  
    
  }
  
  
#ifdef IS_MPI  
  MPI_Allreduce(&totalMass_local, &totalMass, 1, MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);
  MPI_Allreduce(&totalMZ_local, &totalMZ, 1, MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);  
  MPI_Allreduce(&massOfUncons_local, &totalMassOfUncons, 1, MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);
#else
  totalMass = totalMass_local;
  totalMZ = totalMZ_local;
  totalMassOfUncons = massOfUncons_local;
#endif  

  double zsys;
  zsys = totalMZ / totalMass;

  return zsys;
}

/**
 *
 */
template<typename T> void ZConstraint<T>::thermalize( void ){

  T::thermalize();
  zeroOutVel();
}

/**
 *
 *
 *
 */

template<typename T> void ZConstraint<T>::zeroOutVel(){

  Atom** fixedZAtoms;  
  double COMvel[3];
  double vel[3];

  double tempMass = 0;
  double tempMVz =0;
  double tempVz = 0;
  for(int i = 0; i < nMols; i++){
    molecules[i].getCOMvel(COMvel);
    tempMass +=molecules[i].getTotalMass();  
         tempMVz += molecules[i].getTotalMass() * COMvel[whichDirection];
         tempVz += COMvel[whichDirection];
  }
  cout << "initial velocity of center of mass is " << tempMVz / tempMass << endl;

  //zero out the velocities of center of mass of fixed z-constrained molecules
  
  for(int i = 0; i < zconsMols.size(); i++){

    if (states[i] == zcsFixed){ 

           zconsMols[i]->getCOMvel(COMvel);      
                cout << "before resetting " << indexOfZConsMols[i] <<"'s vz is " << COMvel[whichDirection] << endl;

      fixedZAtoms = zconsMols[i]->getMyAtoms(); 
          
      for(int j =0; j < zconsMols[i]->getNAtoms(); j++){
        fixedZAtoms[j]->getVel(vel);
             vel[whichDirection] -= COMvel[whichDirection];
             fixedZAtoms[j]->setVel(vel);
      }

                zconsMols[i]->getCOMvel(COMvel);
                cout << "after resetting " << indexOfZConsMols[i] <<"'s vz is " << COMvel[whichDirection] << endl;
    }
        
  }

        cout << "before resetting the COMVel of unconstraint molecules is " << calcCOMVel() <<endl;     
                   
  // calculate the vz of center of mass of unconstrained molecules and moving z-constrained molecules
  double MVzOfMovingMols_local;
  double MVzOfMovingMols;
  double totalMassOfMovingZMols_local;
  double totalMassOfMovingZMols;
      
  MVzOfMovingMols_local = 0;
  totalMassOfMovingZMols_local = 0;

  for(int i =0; i < unconsMols.size(); i++){
    unconsMols[i]->getCOMvel(COMvel);
    MVzOfMovingMols_local += massOfUnconsMols[i] * COMvel[whichDirection];      
  } 

  for(int i = 0; i < zconsMols.size(); i++){
    if (states[i] == zcsMoving){
      zconsMols[i]->getCOMvel(COMvel);
      MVzOfMovingMols_local += massOfZConsMols[i] * COMvel[whichDirection];   
      totalMassOfMovingZMols_local += massOfZConsMols[i];               
    }
                
  }

#ifndef IS_MPI
  MVzOfMovingMols = MVzOfMovingMols_local;
  totalMassOfMovingZMols = totalMassOfMovingZMols_local;
#else
  MPI_Allreduce(&MVzOfMovingMols_local, &MVzOfMovingMols, 1, MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);
  MPI_Allreduce(&totalMassOfMovingZMols_local, &totalMassOfMovingZMols, 1, MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);  
#endif

  double vzOfMovingMols;
  vzOfMovingMols = MVzOfMovingMols / (totalMassOfUncons + totalMassOfMovingZMols);

  //modify the velocites of unconstrained molecules  
  Atom** unconsAtoms;
  for(int i = 0; i < unconsMols.size(); i++){
  
    unconsAtoms = unconsMols[i]->getMyAtoms();
    for(int j = 0; j < unconsMols[i]->getNAtoms();j++){
      unconsAtoms[j]->getVel(vel);
      vel[whichDirection] -= vzOfMovingMols;
      unconsAtoms[j]->setVel(vel);
    }
  
  }  

  //modify the velocities of moving z-constrained molecuels
  Atom** movingZAtoms;
  for(int i = 0; i < zconsMols.size(); i++){

    if (states[i] ==zcsMoving){
   
      movingZAtoms = zconsMols[i]->getMyAtoms();
           for(int j = 0; j < zconsMols[i]->getNAtoms(); j++){
        movingZAtoms[j]->getVel(vel);
        vel[whichDirection] -= vzOfMovingMols;
             movingZAtoms[j]->setVel(vel);
          }
          
   }

 }

        cout << "after resetting the COMVel of unconstraint molecules is " << calcCOMVel() <<endl;

}

template<typename T> void ZConstraint<T>::doZconstraintForce(){

  Atom** zconsAtoms;
  double totalFZ; 
  double totalFZ_local;
  double COMvel[3];   
  double COM[3];
  double force[3];

  int nMovingZMols_local;
  int nMovingZMols;

  //constrain the molecules which do not reach the specified positions  
    
  //Zero Out the force of z-contrained molecules    
  totalFZ_local = 0;

  //calculate the total z-contrained force of fixed z-contrained molecules
  cout << "Fixed Molecules" << endl;
  for(int i = 0; i < zconsMols.size(); i++){
                
    if (states[i] == zcsFixed){
                
      zconsMols[i]->getCOM(COM);
      zconsAtoms = zconsMols[i]->getMyAtoms();  

      fz[i] = 0;      
      for(int j =0; j < zconsMols[i]->getNAtoms(); j++) {
        zconsAtoms[j]->getFrc(force);
        fz[i] += force[whichDirection];      
      } 
      totalFZ_local += fz[i];

      cout << "index: " << indexOfZConsMols[i] <<"\tcurrent zpos: " << COM[whichDirection] << endl;

    }
          
  } 

  //calculate the number of atoms of moving z-constrained molecules
  nMovingZMols_local = 0;
  for(int i = 0; i < zconsMols.size(); i++)
    if(states[i] == zcsMoving)
           nMovingZMols_local += massOfZConsMols[i];
  
#ifdef IS_MPI
  MPI_Allreduce(&totalFZ_local, &totalFZ, 1, MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);
  MPI_Allreduce(&nMovingZMols_local, &nMovingZMols, 1, MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);
#else
  totalFZ = totalFZ_local;
  nMovingZMols = nMovingZMols_local;
#endif

  force[0]= 0;
  force[1]= 0;
  force[2]= 0;
  force[whichDirection] = totalFZ / (totNumOfUnconsAtoms + nMovingZMols);

  //modify the forces of unconstrained molecules
  for(int i = 0; i < unconsMols.size(); i++){
     
     Atom** unconsAtoms = unconsMols[i]->getMyAtoms();
     
     for(int j = 0; j < unconsMols[i]->getNAtoms(); j++)          
       unconsAtoms[j]->addFrc(force);
     
  }      

 //modify the forces of moving z-constrained molecules
  for(int i = 0; i < zconsMols.size(); i++) {
   if (states[i] == zcsMoving){
                
     Atom** movingZAtoms = zconsMols[i]->getMyAtoms();     

     for(int j = 0; j < zconsMols[i]->getNAtoms(); j++)          
       movingZAtoms[j]->addFrc(force);
     }
  }

  // apply negative to fixed z-constrained molecues;
  force[0]= 0;
  force[1]= 0;
  force[2]= 0;

  for(int i = 0; i < zconsMols.size(); i++){

    if (states[i] == zcsFixed){  
        
      int nAtomOfCurZConsMol = zconsMols[i]->getNAtoms();
      zconsAtoms = zconsMols[i]->getMyAtoms();  
    
      for(int j =0; j < nAtomOfCurZConsMol; j++) {
        force[whichDirection] = -fz[i]/ nAtomOfCurZConsMol;
        zconsAtoms[j]->addFrc(force);
      }
                
    }
        
  } 

}

template<typename T> bool ZConstraint<T>::checkZConsState(){
  double COM[3];
  double diff;
  
  bool changed;
  
  changed = false;
  
  for(int i =0; i < zconsMols.size(); i++){

    zconsMols[i]->getCOM(COM);
    diff = fabs(COM[whichDirection] - zPos[i]);  
    if (  diff <= zconsTol && states[i] == zcsMoving){
      states[i] = zcsFixed;
        changed = true;
    }
    else if ( diff > zconsTol && states[i] == zcsFixed){
      states[i] = zcsMoving;
        changed = true;   
    }
  
  }

  return changed;
}

template<typename T> bool ZConstraint<T>::haveFixedZMols(){
  for(int i = 0; i < zconsMols.size(); i++)
    if (states[i] == zcsFixed)
      return true;

  return false;
}


/**
 *
 */
template<typename T> bool ZConstraint<T>::haveMovingZMols(){
  for(int i = 0; i < zconsMols.size(); i++)
    if (states[i] == zcsMoving)
      return true;

  return false;
  
}

/**
  * 
  *
  */

template<typename T> void ZConstraint<T>::doHarmonic(){
  double force[3];
  double harmonicU;
  double harmonicF;
  double COM[3];
  double diff;
  double totalFZ;
        
  force[0] = 0;
  force[1] = 0;
  force[2] = 0;

  totalFZ = 0;

  cout << "Moving Molecules" << endl;   
  for(int i = 0; i < zconsMols.size(); i++) {

    if (states[i] == zcsMoving){
      zconsMols[i]->getCOM(COM);
      cout << "index: " << indexOfZConsMols[i] <<"\tcurrent zpos: " << COM[whichDirection] << endl;
                
                diff = COM[whichDirection] -zPos[i];
                
      harmonicU = 0.5 * kz[i] * diff * diff;  
                info->lrPot += harmonicU;

      harmonicF =  - kz[i] * diff / zconsMols[i]->getNAtoms();
                force[whichDirection] = harmonicF;
      totalFZ += harmonicF;
                
      Atom** movingZAtoms = zconsMols[i]->getMyAtoms();     

       for(int j = 0; j < zconsMols[i]->getNAtoms(); j++)          
         movingZAtoms[j]->addFrc(force);
    }

  }

  force[0]= 0;
  force[1]= 0;
  force[2]= 0;
  force[whichDirection] = -totalFZ /totNumOfUnconsAtoms;

  //modify the forces of unconstrained molecules
  for(int i = 0; i < unconsMols.size(); i++){
     
     Atom** unconsAtoms = unconsMols[i]->getMyAtoms();
     
     for(int j = 0; j < unconsMols[i]->getNAtoms(); j++)          
       unconsAtoms[j]->addFrc(force);     
  }   

}

template<typename T> double ZConstraint<T>::calcCOMVel()
{
  double MVzOfMovingMols_local;
  double MVzOfMovingMols;
  double totalMassOfMovingZMols_local;
  double totalMassOfMovingZMols;
  double COMvel[3];
      
  MVzOfMovingMols_local = 0;
  totalMassOfMovingZMols_local = 0;

  for(int i =0; i < unconsMols.size(); i++){
    unconsMols[i]->getCOMvel(COMvel);
    MVzOfMovingMols_local += massOfUnconsMols[i] * COMvel[whichDirection];      
  } 

  for(int i = 0; i < zconsMols.size(); i++){

    if (states[i] == zcsMoving){
      zconsMols[i]->getCOMvel(COMvel);
      MVzOfMovingMols_local += massOfZConsMols[i] * COMvel[whichDirection];   
      totalMassOfMovingZMols_local += massOfZConsMols[i];               
    }
                
  }

#ifndef IS_MPI
  MVzOfMovingMols = MVzOfMovingMols_local;
  totalMassOfMovingZMols = totalMassOfMovingZMols_local;
#else
  MPI_Allreduce(&MVzOfMovingMols_local, &MVzOfMovingMols, 1, MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);
  MPI_Allreduce(&totalMassOfMovingZMols_local, &totalMassOfMovingZMols, 1, MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);  
#endif

  double vzOfMovingMols;
  vzOfMovingMols = MVzOfMovingMols / (totalMassOfUncons + totalMassOfMovingZMols);

  return vzOfMovingMols;
}


template<typename T> double ZConstraint<T>::calcCOMVel2()
{
  double COMvel[3];
  double tempMVz = 0;
  int index;
                
  for(int i =0 ; i < nMols; i++){
         index = isZConstraintMol(&molecules[i]);
    if( index == -1){
       molecules[i].getCOMvel(COMvel);
            tempMVz += molecules[i].getTotalMass()*COMvel[whichDirection];
    }
         else if(states[i] == zcsMoving){
       zconsMols[index]->getCOMvel(COMvel);
            tempMVz += massOfZConsMols[index]*COMvel[whichDirection];    
         }
  }
        
  return tempMVz /totalMassOfUncons;
}
Revision:	693
Committed:	Wed Aug 13 19:21:53 2003 UTC (20 years, 10 months ago) by tim
File size:	23205 byte(s)
Log Message:	harmonic potential & z-contraint method