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->getPropertyByName("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->getPropertyByName("VISITED");
    return data == NULL ? false : true;
}

bool SSDAtomVisitor::isSSDAtom(const std::string&atomType) {
    std::vector<std::string>::iterator strIter;

    for( strIter = ssdAtomType.begin(); strIter != ssdAtomType.end();
        ++strIter )
  if (*strIter == atomType)
      return true;

    return false;
}

void SSDAtomVisitor::visit(DirectionalAtom *datom) {
    std::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
    Vector3d h1(0.0, -0.75695, 0.5206);
    Vector3d h2(0.0, 0.75695, 0.5206);
    Vector3d ox(0.0, 0.0, -0.0654);
    Vector3d u(0, 0, 1);
    RotMat3x3d   rotMatrix;
    RotMat3x3d   rotTrans;
    AtomInfo *   atomInfo;
    Vector3d     pos;
    Vector3d     newVec;
    Quat4d       q;
    AtomData *   atomData;
    GenericData *data;
    bool         haveAtomData;

    //if atom is not SSD atom, just skip it
    if (!isSSDAtom(datom->getType()))
        return;

    data = datom->getPropertyByName("ATOMDATA");

    if (data != NULL) {
        atomData = dynamic_cast<AtomData *>(data);

        if (atomData == NULL) {
            std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
            atomData = new AtomData;
            haveAtomData = false;
        } else
            haveAtomData = true;
    } else {
        atomData = new AtomData;
        haveAtomData = false;
    }

    pos = datom->getPos();
    q = datom->getQ();
    rotMatrix = datom->getA();

    // We need A^T to convert from body-fixed to space-fixed:
    //transposeMat3(rotMatrix, rotTrans);
    rotTrans = rotMatrix.transpose();

    //center of mass of the water molecule
    //matVecMul3(rotTrans, u, newVec);
    newVec = rotTrans * u;

    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);
    newVec = rotTrans * ox;

    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);
    newVec = rotTrans * h1;
    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);
    newVec = rotTrans * h2;
    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 std::string SSDAtomVisitor::toString() {
    char   buffer[65535];
    std::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;
    Vector3d  pos;

    if (isVisited(atom))
        return;

    atomInfo = new AtomInfo;

    atomData = new AtomData;
    atomData->setID("ATOMDATA");

    pos = atom->getPos();
    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;
    Vector3d  pos;
    Vector3d  u;

    if (isVisited(datom))
        return;

    pos = datom->getPos();
    u = datom->getElectroFrame().getColumn(3);

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