src/visitors/AtomVisitor.cpp

#include <cstring>
#include "visitors/AtomVisitor.hpp"
#include "primitives/DirectionalAtom.hpp"
#include "math/MatVec3.h"
#include "primitives/RigidBody.hpp"

namespace oopse {

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;
}    

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