OOPSE/libmdtools/Integrator.cpp

#include <iostream>
#include <stdlib.h>
#include <math.h>

#ifdef IS_MPI
#include "mpiSimulation.hpp"
#include <unistd.h>
#endif //is_mpi

#ifdef PROFILE
#include "mdProfile.hpp"
#endif // profile

#include "Integrator.hpp"
#include "simError.h"


template<typename T> Integrator<T>::Integrator(SimInfo* theInfo,
                                               ForceFields* the_ff){
  info = theInfo;
  myFF = the_ff;
  isFirst = 1;

  molecules = info->molecules;
  nMols = info->n_mol;

  // give a little love back to the SimInfo object

  if (info->the_integrator != NULL){
    delete info->the_integrator;
  }

  nAtoms = info->n_atoms;

  // check for constraints

  constrainedA = NULL;
  constrainedB = NULL;
  constrainedDsqr = NULL;
  moving = NULL;
  moved = NULL;
  oldPos = NULL;

  nConstrained = 0;

  checkConstraints();
}

template<typename T> Integrator<T>::~Integrator(){
  if (nConstrained){
    delete[] constrainedA;
    delete[] constrainedB;
    delete[] constrainedDsqr;
    delete[] moving;
    delete[] moved;
    delete[] oldPos;
  }
}

template<typename T> void Integrator<T>::checkConstraints(void){
  isConstrained = 0;

  Constraint* temp_con;
  Constraint* dummy_plug;
  temp_con = new Constraint[info->n_SRI];
  nConstrained = 0;
  int constrained = 0;

  SRI** theArray;
  for (int i = 0; i < nMols; i++){
    theArray = (SRI * *) molecules[i].getMyBonds();
    for (int j = 0; j < molecules[i].getNBonds(); j++){
      constrained = theArray[j]->is_constrained();

      if (constrained){
        dummy_plug = theArray[j]->get_constraint();
        temp_con[nConstrained].set_a(dummy_plug->get_a());
        temp_con[nConstrained].set_b(dummy_plug->get_b());
        temp_con[nConstrained].set_dsqr(dummy_plug->get_dsqr());

        nConstrained++;
        constrained = 0;
      }
    }

    theArray = (SRI * *) molecules[i].getMyBends();
    for (int j = 0; j < molecules[i].getNBends(); j++){
      constrained = theArray[j]->is_constrained();

      if (constrained){
        dummy_plug = theArray[j]->get_constraint();
        temp_con[nConstrained].set_a(dummy_plug->get_a());
        temp_con[nConstrained].set_b(dummy_plug->get_b());
        temp_con[nConstrained].set_dsqr(dummy_plug->get_dsqr());

        nConstrained++;
        constrained = 0;
      }
    }

    theArray = (SRI * *) molecules[i].getMyTorsions();
    for (int j = 0; j < molecules[i].getNTorsions(); j++){
      constrained = theArray[j]->is_constrained();

      if (constrained){
        dummy_plug = theArray[j]->get_constraint();
        temp_con[nConstrained].set_a(dummy_plug->get_a());
        temp_con[nConstrained].set_b(dummy_plug->get_b());
        temp_con[nConstrained].set_dsqr(dummy_plug->get_dsqr());

        nConstrained++;
        constrained = 0;
      }
    }
  }

  if (nConstrained > 0){
    isConstrained = 1;

    if (constrainedA != NULL)
      delete[] constrainedA;
    if (constrainedB != NULL)
      delete[] constrainedB;
    if (constrainedDsqr != NULL)
      delete[] constrainedDsqr;

    constrainedA = new int[nConstrained];
    constrainedB = new int[nConstrained];
    constrainedDsqr = new double[nConstrained];

    for (int i = 0; i < nConstrained; i++){
      constrainedA[i] = temp_con[i].get_a();
      constrainedB[i] = temp_con[i].get_b();
      constrainedDsqr[i] = temp_con[i].get_dsqr();
    }


    // save oldAtoms to check for lode balanceing later on.

    oldAtoms = nAtoms;

    moving = new int[nAtoms];
    moved = new int[nAtoms];

    oldPos = new double[nAtoms * 3];
  }

  delete[] temp_con;
}


template<typename T> void Integrator<T>::integrate(void){

  double runTime = info->run_time;
  double sampleTime = info->sampleTime;
  double statusTime = info->statusTime;
  double thermalTime = info->thermalTime;
  double resetTime = info->resetTime;


  double currSample;
  double currThermal;
  double currStatus;
  double currReset;

  int calcPot, calcStress;

  tStats = new Thermo(info);
  statOut = new StatWriter(info);
  dumpOut = new DumpWriter(info);

  atoms = info->atoms;

  dt = info->dt;
  dt2 = 0.5 * dt;

  readyCheck();

  // initialize the forces before the first step

  calcForce(1, 1);

  if (nConstrained){
    preMove();
    constrainA();
    calcForce(1, 1);
    constrainB();
  }
  
  if (info->setTemp){
    thermalize();
  }

  calcPot     = 0;
  calcStress  = 0;
  currSample  = sampleTime + info->getTime();
  currThermal = thermalTime+ info->getTime();
  currStatus  = statusTime + info->getTime();
  currReset   = resetTime  + info->getTime();

  dumpOut->writeDump(info->getTime());
  statOut->writeStat(info->getTime());


#ifdef IS_MPI
  strcpy(checkPointMsg, "The integrator is ready to go.");
  MPIcheckPoint();
#endif // is_mpi

  while (info->getTime() < runTime){
    if ((info->getTime() + dt) >= currStatus){
      calcPot = 1;
      calcStress = 1;
    }

#ifdef PROFILE
    startProfile( pro1 );
#endif
    
    integrateStep(calcPot, calcStress);

#ifdef PROFILE
    endProfile( pro1 );

    startProfile( pro2 );
#endif // profile

    info->incrTime(dt);

    if (info->setTemp){
      if (info->getTime() >= currThermal){
        thermalize();
        currThermal += thermalTime;
      }
    }

    if (info->getTime() >= currSample){
      dumpOut->writeDump(info->getTime());
      currSample += sampleTime;
    }

    if (info->getTime() >= currStatus){
      statOut->writeStat(info->getTime());
      calcPot = 0;
      calcStress = 0;
      currStatus += statusTime;
    }

    if (info->resetIntegrator){
      if (info->getTime() >= currReset){
        this->resetIntegrator();
        currReset += resetTime;
      }
    }
    
#ifdef PROFILE
    endProfile( pro2 );
#endif //profile

#ifdef IS_MPI
    strcpy(checkPointMsg, "successfully took a time step.");
    MPIcheckPoint();
#endif // is_mpi
  }


  // write the last frame
  dumpOut->writeDump(info->getTime());

  delete dumpOut;
  delete statOut;
}

template<typename T> void Integrator<T>::integrateStep(int calcPot,
                                                       int calcStress){
  // Position full step, and velocity half step

#ifdef PROFILE
  startProfile(pro3);
#endif //profile

  preMove();

#ifdef PROFILE
  endProfile(pro3);

  startProfile(pro4);
#endif // profile

  moveA();

#ifdef PROFILE
  endProfile(pro4);
  
  startProfile(pro5);
#endif//profile


#ifdef IS_MPI
  strcpy(checkPointMsg, "Succesful moveA\n");
  MPIcheckPoint();
#endif // is_mpi


  // calc forces

  calcForce(calcPot, calcStress);

#ifdef IS_MPI
  strcpy(checkPointMsg, "Succesful doForces\n");
  MPIcheckPoint();
#endif // is_mpi

#ifdef PROFILE
  endProfile( pro5 );

  startProfile( pro6 );
#endif //profile

  // finish the velocity  half step

  moveB();

#ifdef PROFILE
  endProfile(pro6);
#endif // profile

#ifdef IS_MPI
  strcpy(checkPointMsg, "Succesful moveB\n");
  MPIcheckPoint();
#endif // is_mpi
}


template<typename T> void Integrator<T>::moveA(void){
  int i, j;
  DirectionalAtom* dAtom;
  double Tb[3], ji[3];
  double vel[3], pos[3], frc[3];
  double mass;

  for (i = 0; i < nAtoms; i++){
    atoms[i]->getVel(vel);
    atoms[i]->getPos(pos);
    atoms[i]->getFrc(frc);

    mass = atoms[i]->getMass();

    for (j = 0; j < 3; j++){
      // velocity half step
      vel[j] += (dt2 * frc[j] / mass) * eConvert;
      // position whole step
      pos[j] += dt * vel[j];
    }

    atoms[i]->setVel(vel);
    atoms[i]->setPos(pos);

    if (atoms[i]->isDirectional()){
      dAtom = (DirectionalAtom *) atoms[i];

      // get and convert the torque to body frame

      dAtom->getTrq(Tb);
      dAtom->lab2Body(Tb);

      // get the angular momentum, and propagate a half step

      dAtom->getJ(ji);

      for (j = 0; j < 3; j++)
        ji[j] += (dt2 * Tb[j]) * eConvert;

      this->rotationPropagation( dAtom, ji );

      dAtom->setJ(ji);
    }
  }

  if (nConstrained){
    constrainA();
  }
}


template<typename T> void Integrator<T>::moveB(void){
  int i, j;
  DirectionalAtom* dAtom;
  double Tb[3], ji[3];
  double vel[3], frc[3];
  double mass;

  for (i = 0; i < nAtoms; i++){
    atoms[i]->getVel(vel);
    atoms[i]->getFrc(frc);

    mass = atoms[i]->getMass();

    // velocity half step
    for (j = 0; j < 3; j++)
      vel[j] += (dt2 * frc[j] / mass) * eConvert;

    atoms[i]->setVel(vel);

    if (atoms[i]->isDirectional()){
      dAtom = (DirectionalAtom *) atoms[i];

      // get and convert the torque to body frame

      dAtom->getTrq(Tb);
      dAtom->lab2Body(Tb);

      // get the angular momentum, and propagate a half step

      dAtom->getJ(ji);

      for (j = 0; j < 3; j++)
        ji[j] += (dt2 * Tb[j]) * eConvert;


      dAtom->setJ(ji);
    }
  }

  if (nConstrained){
    constrainB();
  }
}

template<typename T> void Integrator<T>::preMove(void){
  int i, j;
  double pos[3];

  if (nConstrained){
    for (i = 0; i < nAtoms; i++){
      atoms[i]->getPos(pos);

      for (j = 0; j < 3; j++){
        oldPos[3 * i + j] = pos[j];
      }
    }
  }
}

template<typename T> void Integrator<T>::constrainA(){
  int i, j;
  int done;
  double posA[3], posB[3];
  double velA[3], velB[3];
  double pab[3];
  double rab[3];
  int a, b, ax, ay, az, bx, by, bz;
  double rma, rmb;
  double dx, dy, dz;
  double rpab;
  double rabsq, pabsq, rpabsq;
  double diffsq;
  double gab;
  int iteration;

  for (i = 0; i < nAtoms; i++){
    moving[i] = 0;
    moved[i] = 1;
  }

  iteration = 0;
  done = 0;
  while (!done && (iteration < maxIteration)){
    done = 1;
    for (i = 0; i < nConstrained; i++){
      a = constrainedA[i];
      b = constrainedB[i];

      ax = (a * 3) + 0;
      ay = (a * 3) + 1;
      az = (a * 3) + 2;

      bx = (b * 3) + 0;
      by = (b * 3) + 1;
      bz = (b * 3) + 2;

      if (moved[a] || moved[b]){
        atoms[a]->getPos(posA);
        atoms[b]->getPos(posB);

        for (j = 0; j < 3; j++)
          pab[j] = posA[j] - posB[j];

        //periodic boundary condition

        info->wrapVector(pab);

        pabsq = pab[0] * pab[0] + pab[1] * pab[1] + pab[2] * pab[2];

        rabsq = constrainedDsqr[i];
        diffsq = rabsq - pabsq;

        // the original rattle code from alan tidesley
        if (fabs(diffsq) > (tol * rabsq * 2)){
          rab[0] = oldPos[ax] - oldPos[bx];
          rab[1] = oldPos[ay] - oldPos[by];
          rab[2] = oldPos[az] - oldPos[bz];

          info->wrapVector(rab);

          rpab = rab[0] * pab[0] + rab[1] * pab[1] + rab[2] * pab[2];

          rpabsq = rpab * rpab;


          if (rpabsq < (rabsq * -diffsq)){
#ifdef IS_MPI
            a = atoms[a]->getGlobalIndex();
            b = atoms[b]->getGlobalIndex();
#endif //is_mpi
            sprintf(painCave.errMsg,
                    "Constraint failure in constrainA at atom %d and %d.\n", a,
                    b);
            painCave.isFatal = 1;
            simError();
          }

          rma = 1.0 / atoms[a]->getMass();
          rmb = 1.0 / atoms[b]->getMass();

          gab = diffsq / (2.0 * (rma + rmb) * rpab);

          dx = rab[0] * gab;
          dy = rab[1] * gab;
          dz = rab[2] * gab;

          posA[0] += rma * dx;
          posA[1] += rma * dy;
          posA[2] += rma * dz;

          atoms[a]->setPos(posA);

          posB[0] -= rmb * dx;
          posB[1] -= rmb * dy;
          posB[2] -= rmb * dz;

          atoms[b]->setPos(posB);

          dx = dx / dt;
          dy = dy / dt;
          dz = dz / dt;

          atoms[a]->getVel(velA);

          velA[0] += rma * dx;
          velA[1] += rma * dy;
          velA[2] += rma * dz;

          atoms[a]->setVel(velA);

          atoms[b]->getVel(velB);

          velB[0] -= rmb * dx;
          velB[1] -= rmb * dy;
          velB[2] -= rmb * dz;

          atoms[b]->setVel(velB);

          moving[a] = 1;
          moving[b] = 1;
          done = 0;
        }
      }
    }

    for (i = 0; i < nAtoms; i++){
      moved[i] = moving[i];
      moving[i] = 0;
    }

    iteration++;
  }

  if (!done){
    sprintf(painCave.errMsg,
            "Constraint failure in constrainA, too many iterations: %d\n",
            iteration);
    painCave.isFatal = 1;
    simError();
  }

}

template<typename T> void Integrator<T>::constrainB(void){
  int i, j;
  int done;
  double posA[3], posB[3];
  double velA[3], velB[3];
  double vxab, vyab, vzab;
  double rab[3];
  int a, b, ax, ay, az, bx, by, bz;
  double rma, rmb;
  double dx, dy, dz;
  double rvab;
  double gab;
  int iteration;

  for (i = 0; i < nAtoms; i++){
    moving[i] = 0;
    moved[i] = 1;
  }

  done = 0;
  iteration = 0;
  while (!done && (iteration < maxIteration)){
    done = 1;

    for (i = 0; i < nConstrained; i++){
      a = constrainedA[i];
      b = constrainedB[i];

      ax = (a * 3) + 0;
      ay = (a * 3) + 1;
      az = (a * 3) + 2;

      bx = (b * 3) + 0;
      by = (b * 3) + 1;
      bz = (b * 3) + 2;

      if (moved[a] || moved[b]){
        atoms[a]->getVel(velA);
        atoms[b]->getVel(velB);

        vxab = velA[0] - velB[0];
        vyab = velA[1] - velB[1];
        vzab = velA[2] - velB[2];

        atoms[a]->getPos(posA);
        atoms[b]->getPos(posB);

        for (j = 0; j < 3; j++)
          rab[j] = posA[j] - posB[j];

        info->wrapVector(rab);

        rma = 1.0 / atoms[a]->getMass();
        rmb = 1.0 / atoms[b]->getMass();

        rvab = rab[0] * vxab + rab[1] * vyab + rab[2] * vzab;

        gab = -rvab / ((rma + rmb) * constrainedDsqr[i]);

        if (fabs(gab) > tol){
          dx = rab[0] * gab;
          dy = rab[1] * gab;
          dz = rab[2] * gab;

          velA[0] += rma * dx;
          velA[1] += rma * dy;
          velA[2] += rma * dz;

          atoms[a]->setVel(velA);

          velB[0] -= rmb * dx;
          velB[1] -= rmb * dy;
          velB[2] -= rmb * dz;

          atoms[b]->setVel(velB);

          moving[a] = 1;
          moving[b] = 1;
          done = 0;
        }
      }
    }

    for (i = 0; i < nAtoms; i++){
      moved[i] = moving[i];
      moving[i] = 0;
    }

    iteration++;
  }

  if (!done){
    sprintf(painCave.errMsg,
            "Constraint failure in constrainB, too many iterations: %d\n",
            iteration);
    painCave.isFatal = 1;
    simError();
  }
}

template<typename T> void Integrator<T>::rotationPropagation
( DirectionalAtom* dAtom, double ji[3] ){

  double angle;
  double A[3][3], I[3][3];

  // use the angular velocities to propagate the rotation matrix a
  // full time step

  dAtom->getA(A);
  dAtom->getI(I);

  // rotate about the x-axis
  angle = dt2 * ji[0] / I[0][0];
  this->rotate( 1, 2, angle, ji, A );

  // rotate about the y-axis
  angle = dt2 * ji[1] / I[1][1];
  this->rotate( 2, 0, angle, ji, A );

  // rotate about the z-axis
  angle = dt * ji[2] / I[2][2];
  this->rotate( 0, 1, angle, ji, A);

  // rotate about the y-axis
  angle = dt2 * ji[1] / I[1][1];
  this->rotate( 2, 0, angle, ji, A );

  // rotate about the x-axis
  angle = dt2 * ji[0] / I[0][0];
  this->rotate( 1, 2, angle, ji, A );

  dAtom->setA( A  );
}

template<typename T> void Integrator<T>::rotate(int axes1, int axes2,
                                                double angle, double ji[3],
                                                double A[3][3]){
  int i, j, k;
  double sinAngle;
  double cosAngle;
  double angleSqr;
  double angleSqrOver4;
  double top, bottom;
  double rot[3][3];
  double tempA[3][3];
  double tempJ[3];

  // initialize the tempA

  for (i = 0; i < 3; i++){
    for (j = 0; j < 3; j++){
      tempA[j][i] = A[i][j];
    }
  }

  // initialize the tempJ

  for (i = 0; i < 3; i++)
    tempJ[i] = ji[i];

  // initalize rot as a unit matrix

  rot[0][0] = 1.0;
  rot[0][1] = 0.0;
  rot[0][2] = 0.0;

  rot[1][0] = 0.0;
  rot[1][1] = 1.0;
  rot[1][2] = 0.0;

  rot[2][0] = 0.0;
  rot[2][1] = 0.0;
  rot[2][2] = 1.0;

  // use a small angle aproximation for sin and cosine

  angleSqr = angle * angle;
  angleSqrOver4 = angleSqr / 4.0;
  top = 1.0 - angleSqrOver4;
  bottom = 1.0 + angleSqrOver4;

  cosAngle = top / bottom;
  sinAngle = angle / bottom;

  rot[axes1][axes1] = cosAngle;
  rot[axes2][axes2] = cosAngle;

  rot[axes1][axes2] = sinAngle;
  rot[axes2][axes1] = -sinAngle;

  // rotate the momentum acoording to: ji[] = rot[][] * ji[]

  for (i = 0; i < 3; i++){
    ji[i] = 0.0;
    for (k = 0; k < 3; k++){
      ji[i] += rot[i][k] * tempJ[k];
    }
  }

  // rotate the Rotation matrix acording to:
  //            A[][] = A[][] * transpose(rot[][])


  // NOte for as yet unknown reason, we are performing the
  // calculation as:
  //                transpose(A[][]) = transpose(A[][]) * transpose(rot[][])

  for (i = 0; i < 3; i++){
    for (j = 0; j < 3; j++){
      A[j][i] = 0.0;
      for (k = 0; k < 3; k++){
        A[j][i] += tempA[i][k] * rot[j][k];
      }
    }
  }
}

template<typename T> void Integrator<T>::calcForce(int calcPot, int calcStress){
  myFF->doForces(calcPot, calcStress);
}

template<typename T> void Integrator<T>::thermalize(){
  tStats->velocitize();
}

template<typename T> double Integrator<T>::getConservedQuantity(void){
  return tStats->getTotalE();
}
template<typename T> string Integrator<T>::getAdditionalParameters(void){
  //By default, return a null string
  //The reason we use string instead of char* is that if we use char*, we will
  //return a pointer point to local variable which might cause problem
  return string();
}
Revision:	892
Committed:	Mon Dec 22 21:27:04 2003 UTC (20 years, 6 months ago) by chuckv
File size:	17393 byte(s)
Log Message:	Fixes to profile code.
#	User	Rev	Content
1	mmeineke	558	#include <iostream>
2	gezelter	829	#include <stdlib.h>
3			#include <math.h>
4	mmeineke	558
5			#ifdef IS_MPI
6			#include "mpiSimulation.hpp"
7			#include <unistd.h>
8			#endif //is_mpi
9
10	chuckv	892	#ifdef PROFILE
11			#include "mdProfile.hpp"
12			#endif // profile
13
14	mmeineke	558	#include "Integrator.hpp"
15			#include "simError.h"
16
17
18	tim	725	template<typename T> Integrator<T>::Integrator(SimInfo* theInfo,
19			ForceFields* the_ff){
20	mmeineke	558	info = theInfo;
21			myFF = the_ff;
22			isFirst = 1;
23
24			molecules = info->molecules;
25			nMols = info->n_mol;
26
27			// give a little love back to the SimInfo object
28	tim	725
29			if (info->the_integrator != NULL){
30			delete info->the_integrator;
31			}
32	tim	837
33	mmeineke	558	nAtoms = info->n_atoms;
34
35			// check for constraints
36	tim	725
37			constrainedA = NULL;
38			constrainedB = NULL;
39	mmeineke	558	constrainedDsqr = NULL;
40	tim	725	moving = NULL;
41			moved = NULL;
42			oldPos = NULL;
43
44	mmeineke	558	nConstrained = 0;
45
46			checkConstraints();
47			}
48
49	tim	725	template<typename T> Integrator<T>::~Integrator(){
50			if (nConstrained){
51	mmeineke	558	delete[] constrainedA;
52			delete[] constrainedB;
53			delete[] constrainedDsqr;
54			delete[] moving;
55			delete[] moved;
56	mmeineke	561	delete[] oldPos;
57	mmeineke	558	}
58			}
59
60	tim	725	template<typename T> void Integrator<T>::checkConstraints(void){
61	mmeineke	558	isConstrained = 0;
62
63	tim	725	Constraint* temp_con;
64			Constraint* dummy_plug;
65	mmeineke	558	temp_con = new Constraint[info->n_SRI];
66			nConstrained = 0;
67			int constrained = 0;
68	tim	725
69	mmeineke	558	SRI** theArray;
70	tim	725	for (int i = 0; i < nMols; i++){
71			theArray = (SRI * *) molecules[i].getMyBonds();
72			for (int j = 0; j < molecules[i].getNBonds(); j++){
73	mmeineke	558	constrained = theArray[j]->is_constrained();
74	mmeineke	594
75	tim	725	if (constrained){
76			dummy_plug = theArray[j]->get_constraint();
77			temp_con[nConstrained].set_a(dummy_plug->get_a());
78			temp_con[nConstrained].set_b(dummy_plug->get_b());
79			temp_con[nConstrained].set_dsqr(dummy_plug->get_dsqr());
80	mmeineke	594
81	tim	725	nConstrained++;
82			constrained = 0;
83			}
84	mmeineke	558	}
85
86	tim	725	theArray = (SRI * *) molecules[i].getMyBends();
87			for (int j = 0; j < molecules[i].getNBends(); j++){
88	mmeineke	558	constrained = theArray[j]->is_constrained();
89	tim	725
90			if (constrained){
91			dummy_plug = theArray[j]->get_constraint();
92			temp_con[nConstrained].set_a(dummy_plug->get_a());
93			temp_con[nConstrained].set_b(dummy_plug->get_b());
94			temp_con[nConstrained].set_dsqr(dummy_plug->get_dsqr());
95
96			nConstrained++;
97			constrained = 0;
98	mmeineke	558	}
99			}
100
101	tim	725	theArray = (SRI * *) molecules[i].getMyTorsions();
102			for (int j = 0; j < molecules[i].getNTorsions(); j++){
103	mmeineke	558	constrained = theArray[j]->is_constrained();
104	tim	725
105			if (constrained){
106			dummy_plug = theArray[j]->get_constraint();
107			temp_con[nConstrained].set_a(dummy_plug->get_a());
108			temp_con[nConstrained].set_b(dummy_plug->get_b());
109			temp_con[nConstrained].set_dsqr(dummy_plug->get_dsqr());
110
111			nConstrained++;
112			constrained = 0;
113	mmeineke	558	}
114			}
115			}
116
117	tim	725	if (nConstrained > 0){
118	mmeineke	558	isConstrained = 1;
119
120	tim	725	if (constrainedA != NULL)
121			delete[] constrainedA;
122			if (constrainedB != NULL)
123			delete[] constrainedB;
124			if (constrainedDsqr != NULL)
125			delete[] constrainedDsqr;
126	mmeineke	558
127	tim	725	constrainedA = new int[nConstrained];
128			constrainedB = new int[nConstrained];
129	mmeineke	558	constrainedDsqr = new double[nConstrained];
130	tim	725
131			for (int i = 0; i < nConstrained; i++){
132	mmeineke	558	constrainedA[i] = temp_con[i].get_a();
133			constrainedB[i] = temp_con[i].get_b();
134			constrainedDsqr[i] = temp_con[i].get_dsqr();
135			}
136
137	tim	725
138	mmeineke	558	// save oldAtoms to check for lode balanceing later on.
139	tim	725
140	mmeineke	558	oldAtoms = nAtoms;
141	tim	725
142	mmeineke	558	moving = new int[nAtoms];
143	tim	725	moved = new int[nAtoms];
144	mmeineke	558
145	tim	725	oldPos = new double[nAtoms * 3];
146	mmeineke	558	}
147	tim	725
148	mmeineke	558	delete[] temp_con;
149			}
150
151
152	tim	725	template<typename T> void Integrator<T>::integrate(void){
153	mmeineke	558
154	tim	725	double runTime = info->run_time;
155			double sampleTime = info->sampleTime;
156			double statusTime = info->statusTime;
157	mmeineke	558	double thermalTime = info->thermalTime;
158	mmeineke	746	double resetTime = info->resetTime;
159	mmeineke	558
160	mmeineke	746
161	mmeineke	558	double currSample;
162			double currThermal;
163			double currStatus;
164	mmeineke	746	double currReset;
165	tim	837
166	mmeineke	558	int calcPot, calcStress;
167
168	tim	725	tStats = new Thermo(info);
169			statOut = new StatWriter(info);
170			dumpOut = new DumpWriter(info);
171	mmeineke	558
172	mmeineke	561	atoms = info->atoms;
173
174			dt = info->dt;
175	mmeineke	558	dt2 = 0.5 * dt;
176
177	mmeineke	784	readyCheck();
178
179	mmeineke	558	// initialize the forces before the first step
180
181	tim	677	calcForce(1, 1);
182	tim	781
183			if (nConstrained){
184			preMove();
185			constrainA();
186	tim	837	calcForce(1, 1);
187	tim	781	constrainB();
188			}
189	mmeineke	843
190	tim	725	if (info->setTemp){
191	tim	677	thermalize();
192	mmeineke	558	}
193	tim	725
194	mmeineke	558	calcPot = 0;
195			calcStress = 0;
196	mmeineke	711	currSample = sampleTime + info->getTime();
197			currThermal = thermalTime+ info->getTime();
198			currStatus = statusTime + info->getTime();
199	mmeineke	746	currReset = resetTime + info->getTime();
200	mmeineke	558
201	tim	725	dumpOut->writeDump(info->getTime());
202			statOut->writeStat(info->getTime());
203	mmeineke	559
204
205			#ifdef IS_MPI
206	tim	725	strcpy(checkPointMsg, "The integrator is ready to go.");
207	mmeineke	559	MPIcheckPoint();
208			#endif // is_mpi
209
210	tim	725	while (info->getTime() < runTime){
211			if ((info->getTime() + dt) >= currStatus){
212	mmeineke	558	calcPot = 1;
213			calcStress = 1;
214			}
215	mmeineke	561
216	chuckv	892	#ifdef PROFILE
217			startProfile( pro1 );
218			#endif
219
220	tim	725	integrateStep(calcPot, calcStress);
221
222	chuckv	892	#ifdef PROFILE
223			endProfile( pro1 );
224
225			startProfile( pro2 );
226			#endif // profile
227
228	mmeineke	643	info->incrTime(dt);
229	mmeineke	558
230	tim	725	if (info->setTemp){
231			if (info->getTime() >= currThermal){
232			thermalize();
233			currThermal += thermalTime;
234	mmeineke	558	}
235			}
236
237	tim	725	if (info->getTime() >= currSample){
238			dumpOut->writeDump(info->getTime());
239	mmeineke	558	currSample += sampleTime;
240			}
241
242	tim	725	if (info->getTime() >= currStatus){
243	tim	837	statOut->writeStat(info->getTime());
244			calcPot = 0;
245	mmeineke	558	calcStress = 0;
246			currStatus += statusTime;
247	tim	837	}
248	mmeineke	559
249	mmeineke	746	if (info->resetIntegrator){
250			if (info->getTime() >= currReset){
251			this->resetIntegrator();
252			currReset += resetTime;
253			}
254			}
255	chuckv	892
256			#ifdef PROFILE
257			endProfile( pro2 );
258			#endif //profile
259	mmeineke	746
260	mmeineke	559	#ifdef IS_MPI
261	tim	725	strcpy(checkPointMsg, "successfully took a time step.");
262	mmeineke	559	MPIcheckPoint();
263			#endif // is_mpi
264	mmeineke	558	}
265
266
267	mmeineke	804	// write the last frame
268			dumpOut->writeDump(info->getTime());
269
270	mmeineke	561	delete dumpOut;
271			delete statOut;
272	mmeineke	558	}
273
274	tim	725	template<typename T> void Integrator<T>::integrateStep(int calcPot,
275			int calcStress){
276	mmeineke	558	// Position full step, and velocity half step
277	chuckv	892
278			#ifdef PROFILE
279			startProfile(pro3);
280			#endif //profile
281
282	tim	725	preMove();
283	mmeineke	558
284	chuckv	892	#ifdef PROFILE
285			endProfile(pro3);
286
287			startProfile(pro4);
288			#endif // profile
289
290	mmeineke	558	moveA();
291
292	chuckv	892	#ifdef PROFILE
293			endProfile(pro4);
294
295			startProfile(pro5);
296			#endif//profile
297	tim	725
298
299	mmeineke	614	#ifdef IS_MPI
300	tim	725	strcpy(checkPointMsg, "Succesful moveA\n");
301	mmeineke	614	MPIcheckPoint();
302			#endif // is_mpi
303
304	tim	725
305	mmeineke	558	// calc forces
306
307	tim	725	calcForce(calcPot, calcStress);
308	mmeineke	558
309	mmeineke	614	#ifdef IS_MPI
310	tim	725	strcpy(checkPointMsg, "Succesful doForces\n");
311	mmeineke	614	MPIcheckPoint();
312			#endif // is_mpi
313
314	chuckv	892	#ifdef PROFILE
315			endProfile( pro5 );
316	tim	725
317	chuckv	892	startProfile( pro6 );
318			#endif //profile
319
320	mmeineke	558	// finish the velocity half step
321	tim	725
322	mmeineke	558	moveB();
323	tim	725
324	chuckv	892	#ifdef PROFILE
325			endProfile(pro6);
326			#endif // profile
327	tim	725
328	mmeineke	614	#ifdef IS_MPI
329	tim	725	strcpy(checkPointMsg, "Succesful moveB\n");
330	mmeineke	614	MPIcheckPoint();
331			#endif // is_mpi
332	mmeineke	558	}
333
334
335	tim	725	template<typename T> void Integrator<T>::moveA(void){
336	gezelter	600	int i, j;
337	mmeineke	558	DirectionalAtom* dAtom;
338	gezelter	600	double Tb[3], ji[3];
339			double vel[3], pos[3], frc[3];
340			double mass;
341	mmeineke	558
342	tim	725	for (i = 0; i < nAtoms; i++){
343			atoms[i]->getVel(vel);
344			atoms[i]->getPos(pos);
345			atoms[i]->getFrc(frc);
346	mmeineke	567
347	gezelter	600	mass = atoms[i]->getMass();
348	mmeineke	594
349	tim	725	for (j = 0; j < 3; j++){
350	gezelter	600	// velocity half step
351	tim	725	vel[j] += (dt2 * frc[j] / mass) * eConvert;
352	gezelter	600	// position whole step
353			pos[j] += dt * vel[j];
354			}
355	mmeineke	594
356	tim	725	atoms[i]->setVel(vel);
357			atoms[i]->setPos(pos);
358	gezelter	600
359	tim	725	if (atoms[i]->isDirectional()){
360			dAtom = (DirectionalAtom *) atoms[i];
361	mmeineke	558
362			// get and convert the torque to body frame
363	mmeineke	597
364	tim	725	dAtom->getTrq(Tb);
365			dAtom->lab2Body(Tb);
366
367	mmeineke	558	// get the angular momentum, and propagate a half step
368	gezelter	600
369	tim	725	dAtom->getJ(ji);
370	gezelter	600
371	tim	725	for (j = 0; j < 3; j++)
372	gezelter	600	ji[j] += (dt2 * Tb[j]) * eConvert;
373	tim	725
374	mmeineke	778	this->rotationPropagation( dAtom, ji );
375	gezelter	600
376	tim	725	dAtom->setJ(ji);
377			}
378	mmeineke	558	}
379	mmeineke	768
380			if (nConstrained){
381			constrainA();
382			}
383	mmeineke	558	}
384
385
386	tim	725	template<typename T> void Integrator<T>::moveB(void){
387	gezelter	600	int i, j;
388	mmeineke	558	DirectionalAtom* dAtom;
389	gezelter	600	double Tb[3], ji[3];
390			double vel[3], frc[3];
391			double mass;
392	mmeineke	558
393	tim	725	for (i = 0; i < nAtoms; i++){
394			atoms[i]->getVel(vel);
395			atoms[i]->getFrc(frc);
396	mmeineke	558
397	gezelter	600	mass = atoms[i]->getMass();
398
399	mmeineke	558	// velocity half step
400	tim	725	for (j = 0; j < 3; j++)
401			vel[j] += (dt2 * frc[j] / mass) * eConvert;
402	gezelter	600
403	tim	725	atoms[i]->setVel(vel);
404	mmeineke	597
405	tim	725	if (atoms[i]->isDirectional()){
406			dAtom = (DirectionalAtom *) atoms[i];
407
408	tim	837	// get and convert the torque to body frame
409	gezelter	600
410	tim	725	dAtom->getTrq(Tb);
411			dAtom->lab2Body(Tb);
412	gezelter	600
413			// get the angular momentum, and propagate a half step
414
415	tim	725	dAtom->getJ(ji);
416	gezelter	600
417	tim	725	for (j = 0; j < 3; j++)
418	gezelter	600	ji[j] += (dt2 * Tb[j]) * eConvert;
419	mmeineke	597
420	tim	725
421			dAtom->setJ(ji);
422	mmeineke	558	}
423			}
424	mmeineke	768
425			if (nConstrained){
426			constrainB();
427			}
428	mmeineke	558	}
429
430	tim	725	template<typename T> void Integrator<T>::preMove(void){
431	gezelter	600	int i, j;
432			double pos[3];
433	mmeineke	558
434	tim	725	if (nConstrained){
435			for (i = 0; i < nAtoms; i++){
436			atoms[i]->getPos(pos);
437	mmeineke	561
438	tim	725	for (j = 0; j < 3; j++){
439			oldPos[3 * i + j] = pos[j];
440	gezelter	600	}
441			}
442	tim	725	}
443	gezelter	600	}
444
445	tim	645	template<typename T> void Integrator<T>::constrainA(){
446	mmeineke	787	int i, j;
447	mmeineke	558	int done;
448	gezelter	600	double posA[3], posB[3];
449			double velA[3], velB[3];
450	mmeineke	572	double pab[3];
451			double rab[3];
452	mmeineke	563	int a, b, ax, ay, az, bx, by, bz;
453	mmeineke	558	double rma, rmb;
454			double dx, dy, dz;
455	mmeineke	561	double rpab;
456	mmeineke	558	double rabsq, pabsq, rpabsq;
457			double diffsq;
458			double gab;
459			int iteration;
460
461	tim	725	for (i = 0; i < nAtoms; i++){
462	mmeineke	558	moving[i] = 0;
463	tim	725	moved[i] = 1;
464	mmeineke	558	}
465	mmeineke	567
466	mmeineke	558	iteration = 0;
467			done = 0;
468	tim	725	while (!done && (iteration < maxIteration)){
469	mmeineke	558	done = 1;
470	tim	725	for (i = 0; i < nConstrained; i++){
471	mmeineke	558	a = constrainedA[i];
472			b = constrainedB[i];
473	mmeineke	563
474	tim	725	ax = (a * 3) + 0;
475			ay = (a * 3) + 1;
476			az = (a * 3) + 2;
477	mmeineke	563
478	tim	725	bx = (b * 3) + 0;
479			by = (b * 3) + 1;
480			bz = (b * 3) + 2;
481
482			if (moved[a] \|\| moved[b]){
483			atoms[a]->getPos(posA);
484			atoms[b]->getPos(posB);
485
486			for (j = 0; j < 3; j++)
487	gezelter	600	pab[j] = posA[j] - posB[j];
488	mmeineke	567
489	tim	725	//periodic boundary condition
490	mmeineke	567
491	tim	725	info->wrapVector(pab);
492	mmeineke	572
493	tim	725	pabsq = pab[0] * pab[0] + pab[1] * pab[1] + pab[2] * pab[2];
494	mmeineke	558
495	tim	725	rabsq = constrainedDsqr[i];
496			diffsq = rabsq - pabsq;
497	mmeineke	567
498	tim	725	// the original rattle code from alan tidesley
499			if (fabs(diffsq) > (tol * rabsq * 2)){
500			rab[0] = oldPos[ax] - oldPos[bx];
501			rab[1] = oldPos[ay] - oldPos[by];
502			rab[2] = oldPos[az] - oldPos[bz];
503	mmeineke	558
504	tim	725	info->wrapVector(rab);
505	mmeineke	567
506	tim	725	rpab = rab[0] * pab[0] + rab[1] * pab[1] + rab[2] * pab[2];
507	mmeineke	558
508	tim	725	rpabsq = rpab * rpab;
509	mmeineke	558
510	mmeineke	563
511	tim	725	if (rpabsq < (rabsq * -diffsq)){
512	mmeineke	558	#ifdef IS_MPI
513	tim	725	a = atoms[a]->getGlobalIndex();
514			b = atoms[b]->getGlobalIndex();
515	mmeineke	558	#endif //is_mpi
516	tim	725	sprintf(painCave.errMsg,
517			"Constraint failure in constrainA at atom %d and %d.\n", a,
518			b);
519			painCave.isFatal = 1;
520			simError();
521			}
522	mmeineke	558
523	tim	725	rma = 1.0 / atoms[a]->getMass();
524			rmb = 1.0 / atoms[b]->getMass();
525	mmeineke	567
526	tim	725	gab = diffsq / (2.0 * (rma + rmb) * rpab);
527	mmeineke	567
528	mmeineke	572	dx = rab[0] * gab;
529			dy = rab[1] * gab;
530			dz = rab[2] * gab;
531	mmeineke	558
532	tim	725	posA[0] += rma * dx;
533			posA[1] += rma * dy;
534			posA[2] += rma * dz;
535	mmeineke	558
536	tim	725	atoms[a]->setPos(posA);
537	mmeineke	558
538	tim	725	posB[0] -= rmb * dx;
539			posB[1] -= rmb * dy;
540			posB[2] -= rmb * dz;
541	gezelter	600
542	tim	725	atoms[b]->setPos(posB);
543	gezelter	600
544	mmeineke	558	dx = dx / dt;
545			dy = dy / dt;
546			dz = dz / dt;
547
548	tim	725	atoms[a]->getVel(velA);
549	mmeineke	558
550	tim	725	velA[0] += rma * dx;
551			velA[1] += rma * dy;
552			velA[2] += rma * dz;
553	mmeineke	558
554	tim	725	atoms[a]->setVel(velA);
555	gezelter	600
556	tim	725	atoms[b]->getVel(velB);
557	gezelter	600
558	tim	725	velB[0] -= rmb * dx;
559			velB[1] -= rmb * dy;
560			velB[2] -= rmb * dz;
561	gezelter	600
562	tim	725	atoms[b]->setVel(velB);
563	gezelter	600
564	tim	725	moving[a] = 1;
565			moving[b] = 1;
566			done = 0;
567			}
568	mmeineke	558	}
569			}
570	tim	725
571			for (i = 0; i < nAtoms; i++){
572	mmeineke	558	moved[i] = moving[i];
573			moving[i] = 0;
574			}
575
576			iteration++;
577			}
578
579	tim	725	if (!done){
580			sprintf(painCave.errMsg,
581			"Constraint failure in constrainA, too many iterations: %d\n",
582			iteration);
583	mmeineke	558	painCave.isFatal = 1;
584			simError();
585			}
586	mmeineke	768
587	mmeineke	558	}
588
589	tim	725	template<typename T> void Integrator<T>::constrainB(void){
590	mmeineke	787	int i, j;
591	mmeineke	558	int done;
592	gezelter	600	double posA[3], posB[3];
593			double velA[3], velB[3];
594	mmeineke	558	double vxab, vyab, vzab;
595	mmeineke	572	double rab[3];
596	mmeineke	563	int a, b, ax, ay, az, bx, by, bz;
597	mmeineke	558	double rma, rmb;
598			double dx, dy, dz;
599	mmeineke	787	double rvab;
600	mmeineke	558	double gab;
601			int iteration;
602
603	tim	725	for (i = 0; i < nAtoms; i++){
604	mmeineke	558	moving[i] = 0;
605			moved[i] = 1;
606			}
607
608			done = 0;
609	mmeineke	561	iteration = 0;
610	tim	725	while (!done && (iteration < maxIteration)){
611	mmeineke	567	done = 1;
612
613	tim	725	for (i = 0; i < nConstrained; i++){
614	mmeineke	558	a = constrainedA[i];
615			b = constrainedB[i];
616
617	tim	725	ax = (a * 3) + 0;
618			ay = (a * 3) + 1;
619			az = (a * 3) + 2;
620	mmeineke	563
621	tim	725	bx = (b * 3) + 0;
622			by = (b * 3) + 1;
623			bz = (b * 3) + 2;
624	mmeineke	563
625	tim	725	if (moved[a] \|\| moved[b]){
626			atoms[a]->getVel(velA);
627			atoms[b]->getVel(velB);
628	mmeineke	558
629	tim	725	vxab = velA[0] - velB[0];
630			vyab = velA[1] - velB[1];
631			vzab = velA[2] - velB[2];
632	gezelter	600
633	tim	725	atoms[a]->getPos(posA);
634			atoms[b]->getPos(posB);
635	gezelter	600
636	tim	725	for (j = 0; j < 3; j++)
637	gezelter	600	rab[j] = posA[j] - posB[j];
638	mmeineke	558
639	tim	725	info->wrapVector(rab);
640	mmeineke	558
641	tim	725	rma = 1.0 / atoms[a]->getMass();
642			rmb = 1.0 / atoms[b]->getMass();
643	mmeineke	558
644	tim	725	rvab = rab[0] * vxab + rab[1] * vyab + rab[2] * vzab;
645	gezelter	600
646	tim	725	gab = -rvab / ((rma + rmb) * constrainedDsqr[i]);
647	gezelter	600
648	tim	725	if (fabs(gab) > tol){
649			dx = rab[0] * gab;
650			dy = rab[1] * gab;
651			dz = rab[2] * gab;
652
653			velA[0] += rma * dx;
654			velA[1] += rma * dy;
655			velA[2] += rma * dz;
656
657			atoms[a]->setVel(velA);
658
659			velB[0] -= rmb * dx;
660			velB[1] -= rmb * dy;
661			velB[2] -= rmb * dz;
662
663			atoms[b]->setVel(velB);
664
665			moving[a] = 1;
666			moving[b] = 1;
667			done = 0;
668			}
669	mmeineke	558	}
670			}
671
672	tim	725	for (i = 0; i < nAtoms; i++){
673	mmeineke	558	moved[i] = moving[i];
674			moving[i] = 0;
675			}
676	tim	725
677	mmeineke	558	iteration++;
678			}
679
680	tim	725	if (!done){
681			sprintf(painCave.errMsg,
682			"Constraint failure in constrainB, too many iterations: %d\n",
683			iteration);
684	mmeineke	558	painCave.isFatal = 1;
685			simError();
686	tim	725	}
687	mmeineke	558	}
688
689	mmeineke	778	template<typename T> void Integrator<T>::rotationPropagation
690			( DirectionalAtom* dAtom, double ji[3] ){
691
692			double angle;
693			double A[3][3], I[3][3];
694
695			// use the angular velocities to propagate the rotation matrix a
696			// full time step
697
698			dAtom->getA(A);
699			dAtom->getI(I);
700	tim	837
701			// rotate about the x-axis
702	mmeineke	778	angle = dt2 * ji[0] / I[0][0];
703	tim	837	this->rotate( 1, 2, angle, ji, A );
704
705	mmeineke	778	// rotate about the y-axis
706			angle = dt2 * ji[1] / I[1][1];
707			this->rotate( 2, 0, angle, ji, A );
708	tim	837
709	mmeineke	778	// rotate about the z-axis
710			angle = dt * ji[2] / I[2][2];
711			this->rotate( 0, 1, angle, ji, A);
712	tim	837
713	mmeineke	778	// rotate about the y-axis
714			angle = dt2 * ji[1] / I[1][1];
715			this->rotate( 2, 0, angle, ji, A );
716	tim	837
717	mmeineke	778	// rotate about the x-axis
718			angle = dt2 * ji[0] / I[0][0];
719			this->rotate( 1, 2, angle, ji, A );
720	tim	837
721			dAtom->setA( A );
722	mmeineke	778	}
723
724	tim	725	template<typename T> void Integrator<T>::rotate(int axes1, int axes2,
725			double angle, double ji[3],
726			double A[3][3]){
727			int i, j, k;
728	mmeineke	558	double sinAngle;
729			double cosAngle;
730			double angleSqr;
731			double angleSqrOver4;
732			double top, bottom;
733			double rot[3][3];
734			double tempA[3][3];
735			double tempJ[3];
736
737			// initialize the tempA
738
739	tim	725	for (i = 0; i < 3; i++){
740			for (j = 0; j < 3; j++){
741	gezelter	600	tempA[j][i] = A[i][j];
742	mmeineke	558	}
743			}
744
745			// initialize the tempJ
746
747	tim	725	for (i = 0; i < 3; i++)
748			tempJ[i] = ji[i];
749
750	mmeineke	558	// initalize rot as a unit matrix
751
752			rot[0][0] = 1.0;
753			rot[0][1] = 0.0;
754			rot[0][2] = 0.0;
755
756			rot[1][0] = 0.0;
757			rot[1][1] = 1.0;
758			rot[1][2] = 0.0;
759	tim	725
760	mmeineke	558	rot[2][0] = 0.0;
761			rot[2][1] = 0.0;
762			rot[2][2] = 1.0;
763	tim	725
764	mmeineke	558	// use a small angle aproximation for sin and cosine
765
766	tim	725	angleSqr = angle * angle;
767	mmeineke	558	angleSqrOver4 = angleSqr / 4.0;
768			top = 1.0 - angleSqrOver4;
769			bottom = 1.0 + angleSqrOver4;
770
771			cosAngle = top / bottom;
772			sinAngle = angle / bottom;
773
774			rot[axes1][axes1] = cosAngle;
775			rot[axes2][axes2] = cosAngle;
776
777			rot[axes1][axes2] = sinAngle;
778			rot[axes2][axes1] = -sinAngle;
779	tim	725
780	mmeineke	558	// rotate the momentum acoording to: ji[] = rot[][] * ji[]
781	tim	725
782			for (i = 0; i < 3; i++){
783	mmeineke	558	ji[i] = 0.0;
784	tim	725	for (k = 0; k < 3; k++){
785	mmeineke	558	ji[i] += rot[i][k] * tempJ[k];
786			}
787			}
788
789	tim	837	// rotate the Rotation matrix acording to:
790	mmeineke	558	// A[][] = A[][] * transpose(rot[][])
791
792
793	mmeineke	561	// NOte for as yet unknown reason, we are performing the
794	mmeineke	558	// calculation as:
795			// transpose(A[][]) = transpose(A[][]) * transpose(rot[][])
796
797	tim	725	for (i = 0; i < 3; i++){
798			for (j = 0; j < 3; j++){
799	gezelter	600	A[j][i] = 0.0;
800	tim	725	for (k = 0; k < 3; k++){
801			A[j][i] += tempA[i][k] * rot[j][k];
802	mmeineke	558	}
803			}
804			}
805			}
806	tim	677
807	tim	725	template<typename T> void Integrator<T>::calcForce(int calcPot, int calcStress){
808			myFF->doForces(calcPot, calcStress);
809	tim	677	}
810
811			template<typename T> void Integrator<T>::thermalize(){
812	tim	725	tStats->velocitize();
813	tim	677	}
814	tim	763
815			template<typename T> double Integrator<T>::getConservedQuantity(void){
816			return tStats->getTotalE();
817	mmeineke	768	}
818	tim	837	template<typename T> string Integrator<T>::getAdditionalParameters(void){
819			//By default, return a null string
820			//The reason we use string instead of char* is that if we use char*, we will
821			//return a pointer point to local variable which might cause problem
822			return string();
823			}