ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/visitors/AtomVisitor.cpp
Revision: 1244
Committed: Wed May 14 21:04:13 2008 UTC (16 years, 11 months ago) by xsun
Original Path: trunk/src/visitors/AtomVisitor.cpp
File size: 26581 byte(s)
Log Message:
Committing changes made to AtomVisitor to render xyz2pov scenes

File Contents

# User Rev Content
1 gezelter 507 /*
2 gezelter 246 * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3     *
4     * The University of Notre Dame grants you ("Licensee") a
5     * non-exclusive, royalty free, license to use, modify and
6     * redistribute this software in source and binary code form, provided
7     * that the following conditions are met:
8     *
9     * 1. Acknowledgement of the program authors must be made in any
10     * publication of scientific results based in part on use of the
11     * program. An acceptable form of acknowledgement is citation of
12     * the article in which the program was described (Matthew
13     * A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14     * J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15     * Parallel Simulation Engine for Molecular Dynamics,"
16     * J. Comput. Chem. 26, pp. 252-271 (2005))
17     *
18     * 2. Redistributions of source code must retain the above copyright
19     * notice, this list of conditions and the following disclaimer.
20     *
21     * 3. Redistributions in binary form must reproduce the above copyright
22     * notice, this list of conditions and the following disclaimer in the
23     * documentation and/or other materials provided with the
24     * distribution.
25     *
26     * This software is provided "AS IS," without a warranty of any
27     * kind. All express or implied conditions, representations and
28     * warranties, including any implied warranty of merchantability,
29     * fitness for a particular purpose or non-infringement, are hereby
30     * excluded. The University of Notre Dame and its licensors shall not
31     * be liable for any damages suffered by licensee as a result of
32     * using, modifying or distributing the software or its
33     * derivatives. In no event will the University of Notre Dame or its
34     * licensors be liable for any lost revenue, profit or data, or for
35     * direct, indirect, special, consequential, incidental or punitive
36     * damages, however caused and regardless of the theory of liability,
37     * arising out of the use of or inability to use software, even if the
38     * University of Notre Dame has been advised of the possibility of
39     * such damages.
40     */
41    
42 gezelter 2 #include <cstring>
43 tim 3 #include "visitors/AtomVisitor.hpp"
44     #include "primitives/DirectionalAtom.hpp"
45     #include "primitives/RigidBody.hpp"
46 gezelter 2
47 tim 132 namespace oopse {
48 gezelter 507 void BaseAtomVisitor::visit(RigidBody *rb) {
49     //vector<Atom*> myAtoms;
50     //vector<Atom*>::iterator atomIter;
51 tim 132
52 gezelter 507 //myAtoms = rb->getAtoms();
53 gezelter 2
54 gezelter 507 //for(atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter)
55     // (*atomIter)->accept(this);
56     }
57 gezelter 2
58 gezelter 507 void BaseAtomVisitor::setVisited(Atom *atom) {
59 gezelter 246 GenericData *data;
60     data = atom->getPropertyByName("VISITED");
61 gezelter 2
62 gezelter 246 //if visited property is not existed, add it as new property
63     if (data == NULL) {
64 gezelter 507 data = new GenericData();
65     data->setID("VISITED");
66     atom->addProperty(data);
67 gezelter 246 }
68 gezelter 507 }
69 gezelter 2
70 gezelter 507 bool BaseAtomVisitor::isVisited(Atom *atom) {
71 gezelter 246 GenericData *data;
72     data = atom->getPropertyByName("VISITED");
73     return data == NULL ? false : true;
74 gezelter 507 }
75 gezelter 2
76 gezelter 507 bool SSDAtomVisitor::isSSDAtom(const std::string&atomType) {
77 tim 247 std::set<std::string>::iterator strIter;
78     strIter = ssdAtomType.find(atomType);
79     return strIter != ssdAtomType.end() ? true : false;
80 gezelter 507 }
81 gezelter 2
82 gezelter 507 void SSDAtomVisitor::visit(DirectionalAtom *datom) {
83 tim 247 std::vector<AtomInfo*>atoms;
84 gezelter 2
85 chrisfen 1008 //we need to convert SSD into 4 different atoms
86     //one oxygen atom, two hydrogen atoms and one pseudo atom which is the center of
87     //the mass of the water with a dipole moment
88 gezelter 246 Vector3d h1(0.0, -0.75695, 0.5206);
89     Vector3d h2(0.0, 0.75695, 0.5206);
90     Vector3d ox(0.0, 0.0, -0.0654);
91     Vector3d u(0, 0, 1);
92     RotMat3x3d rotMatrix;
93     RotMat3x3d rotTrans;
94     AtomInfo * atomInfo;
95     Vector3d pos;
96     Vector3d newVec;
97     Quat4d q;
98     AtomData * atomData;
99     GenericData *data;
100     bool haveAtomData;
101 gezelter 2
102 gezelter 246 //if atom is not SSD atom, just skip it
103     if (!isSSDAtom(datom->getType()))
104 gezelter 507 return;
105 gezelter 2
106 gezelter 246 data = datom->getPropertyByName("ATOMDATA");
107 gezelter 2
108 gezelter 246 if (data != NULL) {
109 gezelter 507 atomData = dynamic_cast<AtomData *>(data);
110 gezelter 246
111 gezelter 507 if (atomData == NULL) {
112     std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
113     atomData = new AtomData;
114     haveAtomData = false;
115     } else
116     haveAtomData = true;
117 gezelter 246 } else {
118 gezelter 507 atomData = new AtomData;
119     haveAtomData = false;
120 gezelter 2 }
121    
122 gezelter 246 pos = datom->getPos();
123     q = datom->getQ();
124     rotMatrix = datom->getA();
125 gezelter 2
126 gezelter 246 // We need A^T to convert from body-fixed to space-fixed:
127     //transposeMat3(rotMatrix, rotTrans);
128     rotTrans = rotMatrix.transpose();
129 gezelter 2
130 gezelter 246 //center of mass of the water molecule
131     //matVecMul3(rotTrans, u, newVec);
132     newVec = rotTrans * u;
133 gezelter 2
134 gezelter 246 atomInfo = new AtomInfo;
135 gezelter 407 atomInfo->atomTypeName = "X";
136 gezelter 246 atomInfo->pos[0] = pos[0];
137     atomInfo->pos[1] = pos[1];
138     atomInfo->pos[2] = pos[2];
139     atomInfo->dipole[0] = newVec[0];
140     atomInfo->dipole[1] = newVec[1];
141     atomInfo->dipole[2] = newVec[2];
142 gezelter 2
143 gezelter 246 atomData->addAtomInfo(atomInfo);
144 gezelter 2
145 gezelter 246 //oxygen
146     //matVecMul3(rotTrans, ox, newVec);
147     newVec = rotTrans * ox;
148 gezelter 2
149 gezelter 246 atomInfo = new AtomInfo;
150 gezelter 407 atomInfo->atomTypeName = "O";
151 gezelter 246 atomInfo->pos[0] = pos[0] + newVec[0];
152     atomInfo->pos[1] = pos[1] + newVec[1];
153     atomInfo->pos[2] = pos[2] + newVec[2];
154     atomInfo->dipole[0] = 0.0;
155     atomInfo->dipole[1] = 0.0;
156     atomInfo->dipole[2] = 0.0;
157     atomData->addAtomInfo(atomInfo);
158 gezelter 2
159 gezelter 246 //hydrogen1
160     //matVecMul3(rotTrans, h1, newVec);
161     newVec = rotTrans * h1;
162     atomInfo = new AtomInfo;
163 gezelter 407 atomInfo->atomTypeName = "H";
164 gezelter 246 atomInfo->pos[0] = pos[0] + newVec[0];
165     atomInfo->pos[1] = pos[1] + newVec[1];
166     atomInfo->pos[2] = pos[2] + newVec[2];
167     atomInfo->dipole[0] = 0.0;
168     atomInfo->dipole[1] = 0.0;
169     atomInfo->dipole[2] = 0.0;
170     atomData->addAtomInfo(atomInfo);
171 gezelter 2
172 gezelter 246 //hydrogen2
173     //matVecMul3(rotTrans, h2, newVec);
174     newVec = rotTrans * h2;
175     atomInfo = new AtomInfo;
176 gezelter 407 atomInfo->atomTypeName = "H";
177 gezelter 246 atomInfo->pos[0] = pos[0] + newVec[0];
178     atomInfo->pos[1] = pos[1] + newVec[1];
179     atomInfo->pos[2] = pos[2] + newVec[2];
180     atomInfo->dipole[0] = 0.0;
181     atomInfo->dipole[1] = 0.0;
182     atomInfo->dipole[2] = 0.0;
183     atomData->addAtomInfo(atomInfo);
184 gezelter 2
185 gezelter 246 //add atom data into atom's property
186    
187     if (!haveAtomData) {
188 gezelter 507 atomData->setID("ATOMDATA");
189     datom->addProperty(atomData);
190 gezelter 246 }
191    
192     setVisited(datom);
193 gezelter 507 }
194 gezelter 2
195 gezelter 507 const std::string SSDAtomVisitor::toString() {
196 gezelter 246 char buffer[65535];
197     std::string result;
198 gezelter 2
199 gezelter 246 sprintf(buffer,
200     "------------------------------------------------------------------\n");
201     result += buffer;
202 gezelter 2
203 gezelter 246 sprintf(buffer, "Visitor name: %s\n", visitorName.c_str());
204     result += buffer;
205 gezelter 2
206 gezelter 246 sprintf(buffer,
207     "Visitor Description: Convert SSD into 4 different atoms\n");
208     result += buffer;
209 gezelter 2
210 gezelter 246 sprintf(buffer,
211     "------------------------------------------------------------------\n");
212     result += buffer;
213    
214     return result;
215 gezelter 507 }
216 gezelter 2
217 chrisfen 1008
218     bool TREDAtomVisitor::isTREDAtom(const std::string&atomType) {
219     std::set<std::string>::iterator strIter;
220     strIter = tredAtomType.find(atomType);
221     return strIter != tredAtomType.end() ? true : false;
222     }
223    
224     void TREDAtomVisitor::visit(DirectionalAtom *datom) {
225     std::vector<AtomInfo*>atoms;
226    
227     // we need to convert a TRED into 4 different atoms:
228     // one oxygen atom, two hydrogen atoms, and one atom which is the center of
229     // the mass of the water with a dipole moment
230     Vector3d h1(0.0, -0.75695, 0.5206);
231     Vector3d h2(0.0, 0.75695, 0.5206);
232     Vector3d ox(0.0, 0.0, -0.0654);
233     Vector3d u(0, 0, 1);
234     RotMat3x3d rotMatrix;
235     RotMat3x3d rotTrans;
236     AtomInfo * atomInfo;
237     Vector3d pos;
238     Vector3d newVec;
239     Quat4d q;
240     AtomData * atomData;
241     GenericData *data;
242     bool haveAtomData;
243    
244     // if the atom is not a TRED atom, skip it
245     if (!isTREDAtom(datom->getType()))
246     return;
247    
248     data = datom->getPropertyByName("ATOMDATA");
249    
250     if (data != NULL) {
251     atomData = dynamic_cast<AtomData *>(data);
252    
253     if (atomData == NULL) {
254     std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
255     atomData = new AtomData;
256     haveAtomData = false;
257     } else
258     haveAtomData = true;
259     } else {
260     atomData = new AtomData;
261     haveAtomData = false;
262     }
263    
264     pos = datom->getPos();
265     q = datom->getQ();
266     rotMatrix = datom->getA();
267    
268     // We need A^T to convert from body-fixed to space-fixed:
269     // transposeMat3(rotMatrix, rotTrans);
270     rotTrans = rotMatrix.transpose();
271    
272     // center of mass of the water molecule
273     // matVecMul3(rotTrans, u, newVec);
274     newVec = rotTrans * u;
275    
276     atomInfo = new AtomInfo;
277     atomInfo->atomTypeName = "TRED";
278     atomInfo->pos[0] = pos[0];
279     atomInfo->pos[1] = pos[1];
280     atomInfo->pos[2] = pos[2];
281     atomInfo->dipole[0] = newVec[0];
282     atomInfo->dipole[1] = newVec[1];
283     atomInfo->dipole[2] = newVec[2];
284    
285     atomData->addAtomInfo(atomInfo);
286    
287     // oxygen
288     // matVecMul3(rotTrans, ox, newVec);
289     newVec = rotTrans * ox;
290    
291     atomInfo = new AtomInfo;
292     atomInfo->atomTypeName = "O";
293     atomInfo->pos[0] = pos[0] + newVec[0];
294     atomInfo->pos[1] = pos[1] + newVec[1];
295     atomInfo->pos[2] = pos[2] + newVec[2];
296     atomInfo->dipole[0] = 0.0;
297     atomInfo->dipole[1] = 0.0;
298     atomInfo->dipole[2] = 0.0;
299     atomData->addAtomInfo(atomInfo);
300    
301     // hydrogen1
302     // matVecMul3(rotTrans, h1, newVec);
303     newVec = rotTrans * h1;
304     atomInfo = new AtomInfo;
305     atomInfo->atomTypeName = "H";
306     atomInfo->pos[0] = pos[0] + newVec[0];
307     atomInfo->pos[1] = pos[1] + newVec[1];
308     atomInfo->pos[2] = pos[2] + newVec[2];
309     atomInfo->dipole[0] = 0.0;
310     atomInfo->dipole[1] = 0.0;
311     atomInfo->dipole[2] = 0.0;
312     atomData->addAtomInfo(atomInfo);
313    
314     // hydrogen2
315     // matVecMul3(rotTrans, h2, newVec);
316     newVec = rotTrans * h2;
317     atomInfo = new AtomInfo;
318     atomInfo->atomTypeName = "H";
319     atomInfo->pos[0] = pos[0] + newVec[0];
320     atomInfo->pos[1] = pos[1] + newVec[1];
321     atomInfo->pos[2] = pos[2] + newVec[2];
322     atomInfo->dipole[0] = 0.0;
323     atomInfo->dipole[1] = 0.0;
324     atomInfo->dipole[2] = 0.0;
325     atomData->addAtomInfo(atomInfo);
326    
327     // add atom data into atom's property
328    
329     if (!haveAtomData) {
330     atomData->setID("ATOMDATA");
331     datom->addProperty(atomData);
332     }
333    
334     setVisited(datom);
335     }
336    
337     const std::string TREDAtomVisitor::toString() {
338     char buffer[65535];
339     std::string result;
340    
341     sprintf(buffer,
342     "------------------------------------------------------------------\n");
343     result += buffer;
344    
345     sprintf(buffer, "Visitor name: %s\n", visitorName.c_str());
346     result += buffer;
347    
348     sprintf(buffer,
349     "Visitor Description: Convert the TRED atom into 4 different atoms\n");
350     result += buffer;
351    
352     sprintf(buffer,
353     "------------------------------------------------------------------\n");
354     result += buffer;
355    
356     return result;
357     }
358    
359    
360 gezelter 507 bool LinearAtomVisitor::isLinearAtom(const std::string& atomType){
361 tim 247 std::set<std::string>::iterator strIter;
362     strIter = linearAtomType.find(atomType);
363    
364     return strIter != linearAtomType.end() ? true : false;
365 gezelter 507 }
366 chrisfen 211
367 tim 954 void LinearAtomVisitor::addGayBerneAtomType(const std::string& atomType){
368     linearAtomType.insert(atomType);
369     }
370    
371 gezelter 507 void LinearAtomVisitor::visit(DirectionalAtom* datom){
372 tim 247 std::vector<AtomInfo*> atoms;
373     //we need to convert linear into 4 different atoms
374     Vector3d c1(0.0, 0.0, -1.8);
375     Vector3d c2(0.0, 0.0, -0.6);
376     Vector3d c3(0.0, 0.0, 0.6);
377     Vector3d c4(0.0, 0.0, 1.8);
378     RotMat3x3d rotMatrix;
379     RotMat3x3d rotTrans;
380     AtomInfo* atomInfo;
381     Vector3d pos;
382     Vector3d newVec;
383     Quat4d q;
384     AtomData* atomData;
385     GenericData* data;
386     bool haveAtomData;
387 tim 989 AtomType* atomType;
388 chrisfen 1008 //if atom is not linear atom, just skip it
389 tim 989 if(!isLinearAtom(datom->getType()) || !datom->getAtomType()->isGayBerne())
390 gezelter 507 return;
391 chrisfen 211
392 tim 989 //setup GayBerne type in fortran side
393     data = datom->getAtomType()->getPropertyByName("GayBerne");
394     if (data != NULL) {
395     GayBerneParamGenericData* gayBerneData = dynamic_cast<GayBerneParamGenericData*>(data);
396    
397     if (gayBerneData != NULL) {
398     GayBerneParam gayBerneParam = gayBerneData->getData();
399    
400 chrisfen 992 // double halfLen = gayBerneParam.GB_sigma * gayBerneParam.GB_l2b_ratio/2.0;
401     double halfLen = gayBerneParam.GB_l/2.0;
402     c1[2] = -halfLen;
403 tim 989 c2[2] = -halfLen /2;
404     c3[2] = halfLen/2;
405     c4[2] = halfLen;
406    
407     }
408    
409     else {
410     sprintf( painCave.errMsg,
411     "Can not cast GenericData to GayBerneParam\n");
412     painCave.severity = OOPSE_ERROR;
413     painCave.isFatal = 1;
414     simError();
415     }
416     }
417    
418    
419 tim 247 data = datom->getPropertyByName("ATOMDATA");
420     if(data != NULL){
421 gezelter 507 atomData = dynamic_cast<AtomData*>(data);
422     if(atomData == NULL){
423     std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
424     atomData = new AtomData;
425     haveAtomData = false;
426     } else {
427     haveAtomData = true;
428     }
429 tim 247 } else {
430 gezelter 507 atomData = new AtomData;
431     haveAtomData = false;
432 chrisfen 211 }
433    
434    
435 tim 247 pos = datom->getPos();
436     q = datom->getQ();
437     rotMatrix = datom->getA();
438 chrisfen 211
439 tim 247 // We need A^T to convert from body-fixed to space-fixed:
440     rotTrans = rotMatrix.transpose();
441 chrisfen 211
442 tim 247 newVec = rotTrans * c1;
443     atomInfo = new AtomInfo;
444 gezelter 407 atomInfo->atomTypeName = "C";
445 tim 247 atomInfo->pos[0] = pos[0] + newVec[0];
446     atomInfo->pos[1] = pos[1] + newVec[1];
447     atomInfo->pos[2] = pos[2] + newVec[2];
448     atomInfo->dipole[0] = 0.0;
449     atomInfo->dipole[1] = 0.0;
450     atomInfo->dipole[2] = 0.0;
451     atomData->addAtomInfo(atomInfo);
452 chrisfen 211
453 tim 247 newVec = rotTrans * c2;
454     atomInfo = new AtomInfo;
455 gezelter 407 atomInfo->atomTypeName = "C";
456 tim 247 atomInfo->pos[0] = pos[0] + newVec[0];
457     atomInfo->pos[1] = pos[1] + newVec[1];
458     atomInfo->pos[2] = pos[2] + newVec[2];
459     atomInfo->dipole[0] = 0.0;
460     atomInfo->dipole[1] = 0.0;
461     atomInfo->dipole[2] = 0.0;
462     atomData->addAtomInfo(atomInfo);
463 chrisfen 211
464 tim 247 newVec = rotTrans * c3;
465     atomInfo = new AtomInfo;
466 gezelter 407 atomInfo->atomTypeName = "C";
467 tim 247 atomInfo->pos[0] = pos[0] + newVec[0];
468     atomInfo->pos[1] = pos[1] + newVec[1];
469     atomInfo->pos[2] = pos[2] + newVec[2];
470     atomInfo->dipole[0] = 0.0;
471     atomInfo->dipole[1] = 0.0;
472     atomInfo->dipole[2] = 0.0;
473     atomData->addAtomInfo(atomInfo);
474 chrisfen 211
475 tim 247 newVec = rotTrans * c4;
476     atomInfo = new AtomInfo;
477 gezelter 407 atomInfo->atomTypeName = "C";
478 tim 247 atomInfo->pos[0] = pos[0] + newVec[0];
479     atomInfo->pos[1] = pos[1] + newVec[1];
480     atomInfo->pos[2] = pos[2] + newVec[2];
481     atomInfo->dipole[0] = 0.0;
482     atomInfo->dipole[1] = 0.0;
483     atomInfo->dipole[2] = 0.0;
484     atomData->addAtomInfo(atomInfo);
485 chrisfen 211
486 tim 247 //add atom data into atom's property
487 chrisfen 211
488 tim 247 if(!haveAtomData){
489 gezelter 507 atomData->setID("ATOMDATA");
490     datom->addProperty(atomData);
491 tim 247 }
492 chrisfen 211
493 tim 247 setVisited(datom);
494    
495 gezelter 507 }
496 chrisfen 211
497 gezelter 507 const std::string LinearAtomVisitor::toString(){
498     char buffer[65535];
499     std::string result;
500 chrisfen 211
501 gezelter 507 sprintf(buffer ,"------------------------------------------------------------------\n");
502     result += buffer;
503 chrisfen 211
504 gezelter 507 sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
505     result += buffer;
506 chrisfen 211
507 gezelter 507 sprintf(buffer , "Visitor Description: Convert linear into 4 different atoms\n");
508     result += buffer;
509 chrisfen 211
510 gezelter 507 sprintf(buffer ,"------------------------------------------------------------------\n");
511     result += buffer;
512 chrisfen 211
513 gezelter 507 return result;
514     }
515 chrisfen 211
516 xsun 881 bool GBLipidAtomVisitor::isGBLipidAtom(const std::string& atomType){
517     std::set<std::string>::iterator strIter;
518     strIter = GBLipidAtomType.find(atomType);
519    
520     return strIter != GBLipidAtomType.end() ? true : false;
521     }
522    
523     void GBLipidAtomVisitor::visit(DirectionalAtom* datom){
524     std::vector<AtomInfo*> atoms;
525 xsun 1219 Vector3d c1(0.0, 0.0, 0.0);
526     Vector3d c2(0.0, 0.0, 1.0);
527 xsun 881 RotMat3x3d rotMatrix;
528     RotMat3x3d rotTrans;
529     AtomInfo* atomInfo;
530     Vector3d pos;
531     Vector3d newVec;
532 xsun 1219 Vector3d dVec;
533 xsun 881 Quat4d q;
534     AtomData* atomData;
535     GenericData* data;
536     bool haveAtomData;
537    
538     //if atom is not GBlipid atom, just skip it
539     if(!isGBLipidAtom(datom->getType()))
540     return;
541    
542     data = datom->getPropertyByName("ATOMDATA");
543     if(data != NULL){
544     atomData = dynamic_cast<AtomData*>(data);
545     if(atomData == NULL){
546     std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
547     atomData = new AtomData;
548     haveAtomData = false;
549     } else {
550     haveAtomData = true;
551     }
552     } else {
553     atomData = new AtomData;
554     haveAtomData = false;
555     }
556    
557    
558     pos = datom->getPos();
559     q = datom->getQ();
560     rotMatrix = datom->getA();
561    
562     // We need A^T to convert from body-fixed to space-fixed:
563     rotTrans = rotMatrix.transpose();
564    
565     newVec = rotTrans * c1;
566 xsun 1219 dVec = rotTrans * c2;
567 xsun 881 atomInfo = new AtomInfo;
568 xsun 1219 atomInfo->atomTypeName = "GB";
569     atomInfo->pos[0] = pos[0] + newVec[0];
570     atomInfo->pos[1] = pos[1] + newVec[1];
571     atomInfo->pos[2] = pos[2] + newVec[2];
572     atomInfo->dipole[0] = dVec[0];
573     atomInfo->dipole[1] = dVec[1];
574     atomInfo->dipole[2] = dVec[2];
575     atomInfo->hasVector = true;
576     atomInfo->charge = 3.0;
577     atomInfo->hasCharge = true;
578     atomData->addAtomInfo(atomInfo);
579    
580     //add atom data into atom's property
581    
582     if(!haveAtomData){
583     atomData->setID("ATOMDATA");
584     datom->addProperty(atomData);
585     }
586    
587     setVisited(datom);
588    
589     }
590    
591     const std::string GBLipidAtomVisitor::toString(){
592     char buffer[65535];
593     std::string result;
594    
595     sprintf(buffer ,"------------------------------------------------------------------\n");
596     result += buffer;
597    
598     sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
599     result += buffer;
600    
601 xsun 1244 sprintf(buffer , "Visitor Description: Convert GBlipid into xyz-formatted atom for use with xyz2pov\n");
602 xsun 1219 result += buffer;
603    
604     sprintf(buffer ,"------------------------------------------------------------------\n");
605     result += buffer;
606    
607     return result;
608     }
609    
610     bool Ring5gbAtomVisitor::isRing5gbAtom(const std::string& atomType){
611     std::set<std::string>::iterator strIter;
612     strIter = Ring5gbAtomType.find(atomType);
613    
614     return strIter != Ring5gbAtomType.end() ? true : false;
615     }
616    
617     void Ring5gbAtomVisitor::visit(DirectionalAtom* datom){
618     std::vector<AtomInfo*> atoms;
619     //we need to convert linear into 4 different atoms
620     Vector3d c1(0.0, 0.0, -5.5);
621     Vector3d c2(0.0, 0.0, -1.8);
622     Vector3d c3(0.0, 0.0, 1.8);
623     Vector3d c4(0.0, 0.0, 5.5);
624     RotMat3x3d rotMatrix;
625     RotMat3x3d rotTrans;
626     AtomInfo* atomInfo;
627     Vector3d pos;
628     Vector3d newVec;
629     Vector3d dVec;
630     Quat4d q;
631     AtomData* atomData;
632     GenericData* data;
633     bool haveAtomData;
634    
635     //if atom is not Ring5GB atom, just skip it
636     if(!isRing5gbAtom(datom->getType()))
637     return;
638    
639     data = datom->getPropertyByName("ATOMDATA");
640     if(data != NULL){
641     atomData = dynamic_cast<AtomData*>(data);
642     if(atomData == NULL){
643     std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
644     atomData = new AtomData;
645     haveAtomData = false;
646     } else {
647     haveAtomData = true;
648     }
649     } else {
650     atomData = new AtomData;
651     haveAtomData = false;
652     }
653    
654    
655     pos = datom->getPos();
656     q = datom->getQ();
657     rotMatrix = datom->getA();
658    
659     // We need A^T to convert from body-fixed to space-fixed:
660     rotTrans = rotMatrix.transpose();
661    
662     newVec = rotTrans * c1;
663     atomInfo = new AtomInfo;
664 xsun 881 atomInfo->atomTypeName = "K";
665     atomInfo->pos[0] = pos[0] + newVec[0];
666     atomInfo->pos[1] = pos[1] + newVec[1];
667     atomInfo->pos[2] = pos[2] + newVec[2];
668     atomInfo->dipole[0] = 0.0;
669     atomInfo->dipole[1] = 0.0;
670     atomInfo->dipole[2] = 0.0;
671     atomData->addAtomInfo(atomInfo);
672    
673     newVec = rotTrans * c2;
674     atomInfo = new AtomInfo;
675     atomInfo->atomTypeName = "K";
676     atomInfo->pos[0] = pos[0] + newVec[0];
677     atomInfo->pos[1] = pos[1] + newVec[1];
678     atomInfo->pos[2] = pos[2] + newVec[2];
679     atomInfo->dipole[0] = 0.0;
680     atomInfo->dipole[1] = 0.0;
681     atomInfo->dipole[2] = 0.0;
682     atomData->addAtomInfo(atomInfo);
683    
684     newVec = rotTrans * c3;
685     atomInfo = new AtomInfo;
686     atomInfo->atomTypeName = "K";
687     atomInfo->pos[0] = pos[0] + newVec[0];
688     atomInfo->pos[1] = pos[1] + newVec[1];
689     atomInfo->pos[2] = pos[2] + newVec[2];
690     atomInfo->dipole[0] = 0.0;
691     atomInfo->dipole[1] = 0.0;
692     atomInfo->dipole[2] = 0.0;
693     atomData->addAtomInfo(atomInfo);
694    
695     newVec = rotTrans * c4;
696     atomInfo = new AtomInfo;
697     atomInfo->atomTypeName = "K";
698     atomInfo->pos[0] = pos[0] + newVec[0];
699     atomInfo->pos[1] = pos[1] + newVec[1];
700     atomInfo->pos[2] = pos[2] + newVec[2];
701     atomInfo->dipole[0] = 0.0;
702     atomInfo->dipole[1] = 0.0;
703     atomInfo->dipole[2] = 0.0;
704     atomData->addAtomInfo(atomInfo);
705    
706     //add atom data into atom's property
707    
708     if(!haveAtomData){
709     atomData->setID("ATOMDATA");
710     datom->addProperty(atomData);
711     }
712    
713     setVisited(datom);
714    
715     }
716    
717 xsun 1219 const std::string Ring5gbAtomVisitor::toString(){
718 xsun 881 char buffer[65535];
719     std::string result;
720    
721     sprintf(buffer ,"------------------------------------------------------------------\n");
722     result += buffer;
723    
724     sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
725     result += buffer;
726    
727 xsun 1219 sprintf(buffer , "Visitor Description: Convert Ring5GB into 4 different K atoms\n");
728 xsun 881 result += buffer;
729    
730     sprintf(buffer ,"------------------------------------------------------------------\n");
731     result += buffer;
732    
733     return result;
734     }
735    
736 xsun 1219 bool HeadAtomVisitor::isHeadAtom(const std::string& atomType){
737     std::set<std::string>::iterator strIter;
738     strIter = HeadAtomType.find(atomType);
739    
740     return strIter != HeadAtomType.end() ? true : false;
741     }
742    
743     void HeadAtomVisitor::visit(DirectionalAtom* datom){
744     std::vector<AtomInfo*> atoms;
745     //we need to convert linear into 2 different atoms
746     Vector3d c1(0.0, 0.0, -1.5);
747     Vector3d c2(0.0, 0.0, 1.5);
748     RotMat3x3d rotMatrix;
749     RotMat3x3d rotTrans;
750     AtomInfo* atomInfo;
751     Vector3d pos;
752     Vector3d newVec;
753     Vector3d dVec;
754     Quat4d q;
755     AtomData* atomData;
756     GenericData* data;
757     bool haveAtomData;
758    
759     //if atom is not Head atom, just skip it
760     if(!isHeadAtom(datom->getType()))
761     return;
762    
763     data = datom->getPropertyByName("ATOMDATA");
764     if(data != NULL){
765     atomData = dynamic_cast<AtomData*>(data);
766     if(atomData == NULL){
767     std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
768     atomData = new AtomData;
769     haveAtomData = false;
770     } else {
771     haveAtomData = true;
772     }
773     } else {
774     atomData = new AtomData;
775     haveAtomData = false;
776     }
777    
778    
779     pos = datom->getPos();
780     q = datom->getQ();
781     rotMatrix = datom->getA();
782    
783     // We need A^T to convert from body-fixed to space-fixed:
784     rotTrans = rotMatrix.transpose();
785    
786     newVec = rotTrans * c1;
787     atomInfo = new AtomInfo;
788     atomInfo->atomTypeName = "C";
789     atomInfo->pos[0] = pos[0] + newVec[0];
790     atomInfo->pos[1] = pos[1] + newVec[1];
791     atomInfo->pos[2] = pos[2] + newVec[2];
792     atomInfo->dipole[0] = 0.0;
793     atomInfo->dipole[1] = 0.0;
794     atomInfo->dipole[2] = 0.0;
795     atomData->addAtomInfo(atomInfo);
796    
797     newVec = rotTrans * c2;
798     atomInfo = new AtomInfo;
799     atomInfo->atomTypeName = "O";
800     atomInfo->pos[0] = pos[0] + newVec[0];
801     atomInfo->pos[1] = pos[1] + newVec[1];
802     atomInfo->pos[2] = pos[2] + newVec[2];
803     atomInfo->dipole[0] = 0.0;
804     atomInfo->dipole[1] = 0.0;
805     atomInfo->dipole[2] = 0.0;
806     atomData->addAtomInfo(atomInfo);
807    
808     //add atom data into atom's property
809    
810     if(!haveAtomData){
811     atomData->setID("ATOMDATA");
812     datom->addProperty(atomData);
813     }
814    
815     setVisited(datom);
816    
817     }
818    
819     const std::string HeadAtomVisitor::toString(){
820     char buffer[65535];
821     std::string result;
822    
823     sprintf(buffer ,"------------------------------------------------------------------\n");
824     result += buffer;
825    
826     sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
827     result += buffer;
828    
829     sprintf(buffer , "Visitor Description: Convert HEAD into C atom and O atom\n");
830     result += buffer;
831    
832     sprintf(buffer ,"------------------------------------------------------------------\n");
833     result += buffer;
834    
835     return result;
836     }
837    
838    
839 gezelter 507 //----------------------------------------------------------------------------//
840 gezelter 2
841 gezelter 507 void DefaultAtomVisitor::visit(Atom *atom) {
842 gezelter 246 AtomData *atomData;
843     AtomInfo *atomInfo;
844     Vector3d pos;
845 gezelter 2
846 gezelter 246 if (isVisited(atom))
847 gezelter 507 return;
848 gezelter 2
849 gezelter 246 atomInfo = new AtomInfo;
850 gezelter 2
851 gezelter 246 atomData = new AtomData;
852     atomData->setID("ATOMDATA");
853 gezelter 2
854 gezelter 246 pos = atom->getPos();
855 gezelter 407 atomInfo->atomTypeName = atom->getType();
856 gezelter 246 atomInfo->pos[0] = pos[0];
857     atomInfo->pos[1] = pos[1];
858     atomInfo->pos[2] = pos[2];
859     atomInfo->dipole[0] = 0.0;
860     atomInfo->dipole[1] = 0.0;
861     atomInfo->dipole[2] = 0.0;
862 gezelter 2
863 gezelter 246 atomData->addAtomInfo(atomInfo);
864 gezelter 2
865 gezelter 246 atom->addProperty(atomData);
866    
867     setVisited(atom);
868 gezelter 507 }
869 gezelter 2
870 gezelter 507 void DefaultAtomVisitor::visit(DirectionalAtom *datom) {
871 gezelter 246 AtomData *atomData;
872     AtomInfo *atomInfo;
873     Vector3d pos;
874     Vector3d u;
875 gezelter 2
876 gezelter 246 if (isVisited(datom))
877 gezelter 507 return;
878 gezelter 2
879 gezelter 246 pos = datom->getPos();
880 tim 989 if (datom->getAtomType()->isGayBerne()) {
881     u = datom->getA().transpose()*V3Z;
882     } else if (datom->getAtomType()->isMultipole()) {
883     u = datom->getElectroFrame().getColumn(2);
884     }
885 gezelter 246 atomData = new AtomData;
886     atomData->setID("ATOMDATA");
887     atomInfo = new AtomInfo;
888 gezelter 2
889 gezelter 407 atomInfo->atomTypeName = datom->getType();
890 gezelter 246 atomInfo->pos[0] = pos[0];
891     atomInfo->pos[1] = pos[1];
892     atomInfo->pos[2] = pos[2];
893     atomInfo->dipole[0] = u[0];
894     atomInfo->dipole[1] = u[1];
895     atomInfo->dipole[2] = u[2];
896    
897     atomData->addAtomInfo(atomInfo);
898    
899     datom->addProperty(atomData);
900    
901     setVisited(datom);
902 gezelter 507 }
903 gezelter 2
904 gezelter 507 const std::string DefaultAtomVisitor::toString() {
905 gezelter 246 char buffer[65535];
906     std::string result;
907 gezelter 2
908 gezelter 246 sprintf(buffer,
909     "------------------------------------------------------------------\n");
910     result += buffer;
911 gezelter 2
912 gezelter 246 sprintf(buffer, "Visitor name: %s\n", visitorName.c_str());
913     result += buffer;
914 gezelter 2
915 gezelter 246 sprintf(buffer,
916     "Visitor Description: copy atom infomation into atom data\n");
917     result += buffer;
918 gezelter 2
919 gezelter 246 sprintf(buffer,
920     "------------------------------------------------------------------\n");
921     result += buffer;
922 gezelter 2
923 gezelter 246 return result;
924 gezelter 507 }
925 gezelter 246 } //namespace oopse

Properties

Name Value
svn:executable *