OOPSE-1.0/libmdtools/AtomVisitor.cpp

#include <cstring>
#include "AtomVisitor.hpp"
#include "DirectionalAtom.hpp"
#include "MatVec3.h"
#include "RigidBody.hpp"

void BaseAtomVisitor::visit(RigidBody* rb){
  //vector<Atom*> myAtoms;
  //vector<Atom*>::iterator atomIter;

  //myAtoms = rb->getAtoms();
  
  //for(atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter)
  //  (*atomIter)->accept(this);
}

void BaseAtomVisitor::setVisited(Atom* atom){
  GenericData* data;
  data = atom->getProperty("VISITED");

  //if visited property is not existed, add it as new property
  if(data == NULL){
    data = new GenericData();
    data->setID("VISITED");
    atom->addProperty(data);  
  }
}

bool BaseAtomVisitor::isVisited(Atom* atom){
  GenericData* data;
  data = atom->getProperty("VISITED");
  return data == NULL ?  false : true;
}

bool SSDAtomVisitor::isSSDAtom(const string& atomType){
  vector<string>::iterator strIter;
  
  for(strIter = ssdAtomType.begin(); strIter != ssdAtomType.end(); ++strIter)
   if(*strIter == atomType)
    return true;
  
  return false;  
}

void SSDAtomVisitor::visit(DirectionalAtom* datom){

  vector<AtomInfo*> atoms;

  //we need to convert SSD into 4 differnet atoms
  //one oxygen atom, two hydrogen atoms and one pseudo atom which is the center of the mass
  //of the water with a dipole moment
  double h1[3] = {0.0, -0.75695, 0.5206};
  double h2[3] = {0.0, 0.75695, 0.5206};
  double ox[3] = {0.0, 0.0, -0.0654};
  double u[3] = {0, 0, 1};
  double rotMatrix[3][3];
  double rotTrans[3][3];
  AtomInfo* atomInfo;
  double pos[3];
  double newVec[3];
  double q[4];
  AtomData* atomData;
  GenericData* data;
  bool haveAtomData;
  
  //if atom is not SSD atom, just skip it
  if(!isSSDAtom(datom->getType()))
    return;

  data = datom->getProperty("ATOMDATA");
  if(data != NULL){

    atomData = dynamic_cast<AtomData*>(data);  
    if(atomData == NULL){
      cerr << "can not get Atom Data from " << datom->getType() << endl;
      atomData = new AtomData; 
      haveAtomData = false;      
    }
    else
      haveAtomData = true;
  }
  else{
    atomData = new AtomData;
    haveAtomData = false;
  }
   
  
  datom->getPos(pos);
  datom->getQ(q);
  datom->getA(rotMatrix);

  // We need A^T to convert from body-fixed to space-fixed:
  transposeMat3(rotMatrix, rotTrans);
  
  //center of mass of the water molecule
  matVecMul3(rotTrans, u, newVec);
  atomInfo = new AtomInfo;
  atomInfo->AtomType = "X";
  atomInfo->pos[0] = pos[0];
  atomInfo->pos[1] = pos[1];
  atomInfo->pos[2] = pos[2];
  atomInfo->dipole[0] = newVec[0];
  atomInfo->dipole[1] = newVec[1];
  atomInfo->dipole[2] = newVec[2];

  atomData->addAtomInfo(atomInfo);

  //oxygen
  matVecMul3(rotTrans, ox, newVec);
  atomInfo = new AtomInfo;
  atomInfo->AtomType = "O";
  atomInfo->pos[0] = pos[0] + newVec[0];
  atomInfo->pos[1] = pos[1] + newVec[1];
  atomInfo->pos[2] = pos[2] + newVec[2];
  atomInfo->dipole[0] = 0.0;
  atomInfo->dipole[1] = 0.0;
  atomInfo->dipole[2] = 0.0;
  atomData->addAtomInfo(atomInfo);


  //hydrogen1
    matVecMul3(rotTrans, h1, newVec);
  atomInfo = new AtomInfo;
  atomInfo->AtomType = "H";
  atomInfo->pos[0] = pos[0] + newVec[0];
  atomInfo->pos[1] = pos[1] + newVec[1];
  atomInfo->pos[2] = pos[2] + newVec[2];
  atomInfo->dipole[0] = 0.0;
  atomInfo->dipole[1] = 0.0;
  atomInfo->dipole[2] = 0.0;
  atomData->addAtomInfo(atomInfo);

  //hydrogen2
  matVecMul3(rotTrans, h2, newVec);
  atomInfo = new AtomInfo;
  atomInfo->AtomType = "H";
  atomInfo->pos[0] = pos[0] + newVec[0];
  atomInfo->pos[1] = pos[1] + newVec[1];
  atomInfo->pos[2] = pos[2] + newVec[2];
  atomInfo->dipole[0] = 0.0;
  atomInfo->dipole[1] = 0.0;
  atomInfo->dipole[2] = 0.0;
  atomData->addAtomInfo(atomInfo);

  //add atom data into atom's property

  if(!haveAtomData){
    atomData->setID("ATOMDATA");
    datom->addProperty(atomData);
  }

  setVisited(datom);

}

const string SSDAtomVisitor::toString(){
  char buffer[65535];
  string result;
  
  sprintf(buffer ,"------------------------------------------------------------------\n");
  result += buffer;

  sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
  result += buffer;

  sprintf(buffer , "Visitor Description: Convert SSD into 4 different atoms\n");
  result += buffer;

  sprintf(buffer ,"------------------------------------------------------------------\n");
  result += buffer;

  return result;
}

//----------------------------------------------------------------------------//

void DefaultAtomVisitor::visit(Atom* atom){
  AtomData* atomData;
  AtomInfo* atomInfo;
  double pos[3];

  if(isVisited(atom))
    return;

 atomInfo =new AtomInfo;

  atomData = new AtomData; 
  atomData->setID("ATOMDATA");
 
  atom->getPos(pos);
  atomInfo->AtomType = atom->getType();
  atomInfo->pos[0] = pos[0];
  atomInfo->pos[1] = pos[1];
  atomInfo->pos[2] = pos[2];
  atomInfo->dipole[0] = 0.0;
  atomInfo->dipole[1] = 0.0;
  atomInfo->dipole[2] = 0.0;


  atomData->addAtomInfo(atomInfo);
  
  atom->addProperty(atomData);

  setVisited(atom);
}
void DefaultAtomVisitor::visit(DirectionalAtom* datom){
  AtomData* atomData;
  AtomInfo* atomInfo;
  double pos[3];
  double u[3];

  if(isVisited(datom))
    return;
  
  datom->getPos(pos);
  datom->getU(u);

  atomData = new AtomData; 
  atomData->setID("ATOMDATA");
  atomInfo =new AtomInfo;
  
  atomInfo->AtomType = datom->getType();
  atomInfo->pos[0] = pos[0];
  atomInfo->pos[1] = pos[1];
  atomInfo->pos[2] = pos[2];
  atomInfo->dipole[0] = u[0];
  atomInfo->dipole[1] = u[1];
  atomInfo->dipole[2] = u[2];  

  atomData->addAtomInfo(atomInfo);

  datom->addProperty(atomData);

  setVisited(datom);
}


const string DefaultAtomVisitor::toString(){
  char buffer[65535];
  string result;
  
  sprintf(buffer ,"------------------------------------------------------------------\n");
  result += buffer;

  sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
  result += buffer;

  sprintf(buffer , "Visitor Description: copy atom infomation into atom data\n");
  result += buffer;

  sprintf(buffer ,"------------------------------------------------------------------\n");
  result += buffer;

  return result;
}    
Revision:	1379
Committed:	Fri Jul 23 15:35:12 2004 UTC (19 years, 11 months ago) by tim
File size:	6164 byte(s)
Log Message:	support SSD_E SSD_RF SSD1
#	User	Rev	Content
1	gezelter	1334	#include <cstring>
2			#include "AtomVisitor.hpp"
3			#include "DirectionalAtom.hpp"
4			#include "MatVec3.h"
5			#include "RigidBody.hpp"
6
7			void BaseAtomVisitor::visit(RigidBody* rb){
8			//vector<Atom*> myAtoms;
9			//vector<Atom*>::iterator atomIter;
10
11			//myAtoms = rb->getAtoms();
12
13			//for(atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter)
14			// (*atomIter)->accept(this);
15			}
16
17			void BaseAtomVisitor::setVisited(Atom* atom){
18			GenericData* data;
19			data = atom->getProperty("VISITED");
20
21			//if visited property is not existed, add it as new property
22			if(data == NULL){
23			data = new GenericData();
24			data->setID("VISITED");
25			atom->addProperty(data);
26			}
27			}
28
29			bool BaseAtomVisitor::isVisited(Atom* atom){
30			GenericData* data;
31			data = atom->getProperty("VISITED");
32			return data == NULL ? false : true;
33			}
34
35	tim	1379	bool SSDAtomVisitor::isSSDAtom(const string& atomType){
36			vector<string>::iterator strIter;
37
38			for(strIter = ssdAtomType.begin(); strIter != ssdAtomType.end(); ++strIter)
39			if(*strIter == atomType)
40			return true;
41
42			return false;
43			}
44
45	gezelter	1334	void SSDAtomVisitor::visit(DirectionalAtom* datom){
46
47			vector<AtomInfo*> atoms;
48
49			//we need to convert SSD into 4 differnet atoms
50			//one oxygen atom, two hydrogen atoms and one pseudo atom which is the center of the mass
51			//of the water with a dipole moment
52			double h1[3] = {0.0, -0.75695, 0.5206};
53			double h2[3] = {0.0, 0.75695, 0.5206};
54			double ox[3] = {0.0, 0.0, -0.0654};
55			double u[3] = {0, 0, 1};
56			double rotMatrix[3][3];
57			double rotTrans[3][3];
58			AtomInfo* atomInfo;
59			double pos[3];
60			double newVec[3];
61			double q[4];
62			AtomData* atomData;
63			GenericData* data;
64			bool haveAtomData;
65
66			//if atom is not SSD atom, just skip it
67	tim	1379	if(!isSSDAtom(datom->getType()))
68	gezelter	1334	return;
69
70			data = datom->getProperty("ATOMDATA");
71			if(data != NULL){
72
73			atomData = dynamic_cast<AtomData*>(data);
74			if(atomData == NULL){
75			cerr << "can not get Atom Data from " << datom->getType() << endl;
76			atomData = new AtomData;
77			haveAtomData = false;
78			}
79			else
80			haveAtomData = true;
81			}
82			else{
83			atomData = new AtomData;
84			haveAtomData = false;
85			}
86
87
88			datom->getPos(pos);
89			datom->getQ(q);
90			datom->getA(rotMatrix);
91
92			// We need A^T to convert from body-fixed to space-fixed:
93			transposeMat3(rotMatrix, rotTrans);
94
95			//center of mass of the water molecule
96			matVecMul3(rotTrans, u, newVec);
97			atomInfo = new AtomInfo;
98			atomInfo->AtomType = "X";
99			atomInfo->pos[0] = pos[0];
100			atomInfo->pos[1] = pos[1];
101			atomInfo->pos[2] = pos[2];
102			atomInfo->dipole[0] = newVec[0];
103			atomInfo->dipole[1] = newVec[1];
104			atomInfo->dipole[2] = newVec[2];
105
106			atomData->addAtomInfo(atomInfo);
107
108			//oxygen
109			matVecMul3(rotTrans, ox, newVec);
110			atomInfo = new AtomInfo;
111			atomInfo->AtomType = "O";
112			atomInfo->pos[0] = pos[0] + newVec[0];
113			atomInfo->pos[1] = pos[1] + newVec[1];
114			atomInfo->pos[2] = pos[2] + newVec[2];
115			atomInfo->dipole[0] = 0.0;
116			atomInfo->dipole[1] = 0.0;
117			atomInfo->dipole[2] = 0.0;
118			atomData->addAtomInfo(atomInfo);
119
120
121			//hydrogen1
122			matVecMul3(rotTrans, h1, newVec);
123			atomInfo = new AtomInfo;
124			atomInfo->AtomType = "H";
125			atomInfo->pos[0] = pos[0] + newVec[0];
126			atomInfo->pos[1] = pos[1] + newVec[1];
127			atomInfo->pos[2] = pos[2] + newVec[2];
128			atomInfo->dipole[0] = 0.0;
129			atomInfo->dipole[1] = 0.0;
130			atomInfo->dipole[2] = 0.0;
131			atomData->addAtomInfo(atomInfo);
132
133			//hydrogen2
134			matVecMul3(rotTrans, h2, newVec);
135			atomInfo = new AtomInfo;
136			atomInfo->AtomType = "H";
137			atomInfo->pos[0] = pos[0] + newVec[0];
138			atomInfo->pos[1] = pos[1] + newVec[1];
139			atomInfo->pos[2] = pos[2] + newVec[2];
140			atomInfo->dipole[0] = 0.0;
141			atomInfo->dipole[1] = 0.0;
142			atomInfo->dipole[2] = 0.0;
143			atomData->addAtomInfo(atomInfo);
144
145			//add atom data into atom's property
146
147			if(!haveAtomData){
148			atomData->setID("ATOMDATA");
149			datom->addProperty(atomData);
150			}
151
152			setVisited(datom);
153
154			}
155
156			const string SSDAtomVisitor::toString(){
157			char buffer[65535];
158			string result;
159
160			sprintf(buffer ,"------------------------------------------------------------------\n");
161			result += buffer;
162
163			sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
164			result += buffer;
165
166			sprintf(buffer , "Visitor Description: Convert SSD into 4 different atoms\n");
167			result += buffer;
168
169			sprintf(buffer ,"------------------------------------------------------------------\n");
170			result += buffer;
171
172			return result;
173			}
174
175			//----------------------------------------------------------------------------//
176
177			void DefaultAtomVisitor::visit(Atom* atom){
178			AtomData* atomData;
179			AtomInfo* atomInfo;
180			double pos[3];
181
182			if(isVisited(atom))
183			return;
184
185			atomInfo =new AtomInfo;
186
187			atomData = new AtomData;
188			atomData->setID("ATOMDATA");
189
190			atom->getPos(pos);
191			atomInfo->AtomType = atom->getType();
192			atomInfo->pos[0] = pos[0];
193			atomInfo->pos[1] = pos[1];
194			atomInfo->pos[2] = pos[2];
195			atomInfo->dipole[0] = 0.0;
196			atomInfo->dipole[1] = 0.0;
197			atomInfo->dipole[2] = 0.0;
198
199
200			atomData->addAtomInfo(atomInfo);
201
202			atom->addProperty(atomData);
203
204			setVisited(atom);
205			}
206			void DefaultAtomVisitor::visit(DirectionalAtom* datom){
207			AtomData* atomData;
208			AtomInfo* atomInfo;
209			double pos[3];
210			double u[3];
211
212			if(isVisited(datom))
213			return;
214
215			datom->getPos(pos);
216			datom->getU(u);
217
218			atomData = new AtomData;
219			atomData->setID("ATOMDATA");
220			atomInfo =new AtomInfo;
221
222			atomInfo->AtomType = datom->getType();
223			atomInfo->pos[0] = pos[0];
224			atomInfo->pos[1] = pos[1];
225			atomInfo->pos[2] = pos[2];
226			atomInfo->dipole[0] = u[0];
227			atomInfo->dipole[1] = u[1];
228			atomInfo->dipole[2] = u[2];
229
230			atomData->addAtomInfo(atomInfo);
231
232			datom->addProperty(atomData);
233
234			setVisited(datom);
235			}
236
237
238			const string DefaultAtomVisitor::toString(){
239			char buffer[65535];
240			string result;
241
242			sprintf(buffer ,"------------------------------------------------------------------\n");
243			result += buffer;
244
245			sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
246			result += buffer;
247
248			sprintf(buffer , "Visitor Description: copy atom infomation into atom data\n");
249			result += buffer;
250
251			sprintf(buffer ,"------------------------------------------------------------------\n");
252			result += buffer;
253
254			return result;
255			}