ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/visitors/AtomVisitor.cpp
(Generate patch)

Comparing trunk/src/visitors/AtomVisitor.cpp (file contents):
Revision 247 by tim, Wed Jan 12 23:15:37 2005 UTC vs.
Revision 992 by chrisfen, Wed Jun 21 18:28:27 2006 UTC

# Line 1 | Line 1
1 < /*
1 > /*
2   * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3   *
4   * The University of Notre Dame grants you ("Licensee") a
# Line 42 | Line 42
42   #include <cstring>
43   #include "visitors/AtomVisitor.hpp"
44   #include "primitives/DirectionalAtom.hpp"
45 – #include "math/MatVec3.h"
45   #include "primitives/RigidBody.hpp"
46  
47   namespace oopse {
48 < void BaseAtomVisitor::visit(RigidBody *rb) {
49 < //vector<Atom*> myAtoms;
50 < //vector<Atom*>::iterator atomIter;
48 >  void BaseAtomVisitor::visit(RigidBody *rb) {
49 >    //vector<Atom*> myAtoms;
50 >    //vector<Atom*>::iterator atomIter;
51  
52 < //myAtoms = rb->getAtoms();
52 >    //myAtoms = rb->getAtoms();
53  
54 < //for(atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter)
55 < //  (*atomIter)->accept(this);
56 <    }
54 >    //for(atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter)
55 >    //  (*atomIter)->accept(this);
56 >  }
57  
58 < void BaseAtomVisitor::setVisited(Atom *atom) {
58 >  void BaseAtomVisitor::setVisited(Atom *atom) {
59      GenericData *data;
60      data = atom->getPropertyByName("VISITED");
61  
62      //if visited property is not existed, add it as new property
63      if (data == NULL) {
64 <        data = new GenericData();
65 <        data->setID("VISITED");
66 <        atom->addProperty(data);
64 >      data = new GenericData();
65 >      data->setID("VISITED");
66 >      atom->addProperty(data);
67      }
68 < }
68 >  }
69  
70 < bool BaseAtomVisitor::isVisited(Atom *atom) {
70 >  bool BaseAtomVisitor::isVisited(Atom *atom) {
71      GenericData *data;
72      data = atom->getPropertyByName("VISITED");
73      return data == NULL ? false : true;
74 < }
74 >  }
75  
76 < bool SSDAtomVisitor::isSSDAtom(const std::string&atomType) {
76 >  bool SSDAtomVisitor::isSSDAtom(const std::string&atomType) {
77      std::set<std::string>::iterator strIter;
78      strIter = ssdAtomType.find(atomType);
79      return strIter != ssdAtomType.end() ? true : false;
80 < }
80 >  }
81  
82 < void SSDAtomVisitor::visit(DirectionalAtom *datom) {
82 >  void SSDAtomVisitor::visit(DirectionalAtom *datom) {
83      std::vector<AtomInfo*>atoms;
84  
85      //we need to convert SSD into 4 differnet atoms
# Line 102 | Line 101 | void SSDAtomVisitor::visit(DirectionalAtom *datom) {
101  
102      //if atom is not SSD atom, just skip it
103      if (!isSSDAtom(datom->getType()))
104 <        return;
104 >      return;
105  
106      data = datom->getPropertyByName("ATOMDATA");
107  
108      if (data != NULL) {
109 <        atomData = dynamic_cast<AtomData *>(data);
109 >      atomData = dynamic_cast<AtomData *>(data);
110  
111 <        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;
111 >      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      } else {
118 <        atomData = new AtomData;
119 <        haveAtomData = false;
118 >      atomData = new AtomData;
119 >      haveAtomData = false;
120      }
121  
122      pos = datom->getPos();
# Line 133 | Line 132 | void SSDAtomVisitor::visit(DirectionalAtom *datom) {
132      newVec = rotTrans * u;
133  
134      atomInfo = new AtomInfo;
135 <    atomInfo->AtomType = "X";
135 >    atomInfo->atomTypeName = "X";
136      atomInfo->pos[0] = pos[0];
137      atomInfo->pos[1] = pos[1];
138      atomInfo->pos[2] = pos[2];
# Line 148 | Line 147 | void SSDAtomVisitor::visit(DirectionalAtom *datom) {
147      newVec = rotTrans * ox;
148  
149      atomInfo = new AtomInfo;
150 <    atomInfo->AtomType = "O";
150 >    atomInfo->atomTypeName = "O";
151      atomInfo->pos[0] = pos[0] + newVec[0];
152      atomInfo->pos[1] = pos[1] + newVec[1];
153      atomInfo->pos[2] = pos[2] + newVec[2];
# Line 161 | Line 160 | void SSDAtomVisitor::visit(DirectionalAtom *datom) {
160      //matVecMul3(rotTrans, h1, newVec);
161      newVec = rotTrans * h1;
162      atomInfo = new AtomInfo;
163 <    atomInfo->AtomType = "H";
163 >    atomInfo->atomTypeName = "H";
164      atomInfo->pos[0] = pos[0] + newVec[0];
165      atomInfo->pos[1] = pos[1] + newVec[1];
166      atomInfo->pos[2] = pos[2] + newVec[2];
# Line 174 | Line 173 | void SSDAtomVisitor::visit(DirectionalAtom *datom) {
173      //matVecMul3(rotTrans, h2, newVec);
174      newVec = rotTrans * h2;
175      atomInfo = new AtomInfo;
176 <    atomInfo->AtomType = "H";
176 >    atomInfo->atomTypeName = "H";
177      atomInfo->pos[0] = pos[0] + newVec[0];
178      atomInfo->pos[1] = pos[1] + newVec[1];
179      atomInfo->pos[2] = pos[2] + newVec[2];
# Line 186 | Line 185 | void SSDAtomVisitor::visit(DirectionalAtom *datom) {
185      //add atom data into atom's property
186  
187      if (!haveAtomData) {
188 <        atomData->setID("ATOMDATA");
189 <        datom->addProperty(atomData);
188 >      atomData->setID("ATOMDATA");
189 >      datom->addProperty(atomData);
190      }
191  
192      setVisited(datom);
193 < }
193 >  }
194  
195 < const std::string SSDAtomVisitor::toString() {
195 >  const std::string SSDAtomVisitor::toString() {
196      char   buffer[65535];
197      std::string result;
198  
# Line 213 | Line 212 | const std::string SSDAtomVisitor::toString() {
212      result += buffer;
213  
214      return result;
215 < }
215 >  }
216  
217 < bool LinearAtomVisitor::isLinearAtom(const std::string& atomType){
217 >  bool LinearAtomVisitor::isLinearAtom(const std::string& atomType){
218      std::set<std::string>::iterator strIter;
219      strIter = linearAtomType.find(atomType);
220  
221      return strIter != linearAtomType.end() ? true : false;
222 < }
222 >  }
223  
224 < void LinearAtomVisitor::visit(DirectionalAtom* datom){
224 >  void LinearAtomVisitor::addGayBerneAtomType(const std::string& atomType){
225 >   linearAtomType.insert(atomType);
226 >  }
227 >
228 >  void LinearAtomVisitor::visit(DirectionalAtom* datom){
229      std::vector<AtomInfo*> atoms;
230      //we need to convert linear into 4 different atoms
231      Vector3d c1(0.0, 0.0, -1.8);
# Line 238 | Line 241 | void LinearAtomVisitor::visit(DirectionalAtom* datom){
241      AtomData* atomData;
242      GenericData* data;
243      bool haveAtomData;
244 <
244 >    AtomType* atomType;
245      //if atom is not SSD atom, just skip it
246 <    if(!isLinearAtom(datom->getType()))
247 <        return;
246 >    if(!isLinearAtom(datom->getType()) || !datom->getAtomType()->isGayBerne())
247 >      return;
248  
249 +    //setup GayBerne type in fortran side
250 +    data = datom->getAtomType()->getPropertyByName("GayBerne");
251 +    if (data != NULL) {
252 +       GayBerneParamGenericData* gayBerneData = dynamic_cast<GayBerneParamGenericData*>(data);
253 +
254 +       if (gayBerneData != NULL) {
255 +           GayBerneParam gayBerneParam = gayBerneData->getData();
256 +
257 +                          // double halfLen = gayBerneParam.GB_sigma * gayBerneParam.GB_l2b_ratio/2.0;
258 +                          double halfLen = gayBerneParam.GB_l/2.0;
259 +                          c1[2] = -halfLen;
260 +              c2[2] = -halfLen /2;
261 +              c3[2] = halfLen/2;
262 +              c4[2] = halfLen;
263 +                
264 +            }
265 +            
266 +              else {
267 +                    sprintf( painCave.errMsg,
268 +                           "Can not cast GenericData to GayBerneParam\n");
269 +                    painCave.severity = OOPSE_ERROR;
270 +                    painCave.isFatal = 1;
271 +                    simError();          
272 +        }            
273 +    }
274 +
275 +
276      data = datom->getPropertyByName("ATOMDATA");
277      if(data != NULL){
278 <        atomData = dynamic_cast<AtomData*>(data);  
279 <        if(atomData == NULL){
280 <            std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
281 <            atomData = new AtomData;
282 <            haveAtomData = false;      
283 <        } else {
284 <            haveAtomData = true;
285 <        }
278 >      atomData = dynamic_cast<AtomData*>(data);  
279 >      if(atomData == NULL){
280 >        std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
281 >        atomData = new AtomData;
282 >        haveAtomData = false;      
283 >      } else {
284 >        haveAtomData = true;
285 >      }
286      } else {
287 <        atomData = new AtomData;
288 <        haveAtomData = false;
287 >      atomData = new AtomData;
288 >      haveAtomData = false;
289      }
290    
291    
# Line 268 | Line 298 | void LinearAtomVisitor::visit(DirectionalAtom* datom){
298  
299      newVec = rotTrans * c1;
300      atomInfo = new AtomInfo;
301 <    atomInfo->AtomType = "C";
301 >    atomInfo->atomTypeName = "C";
302      atomInfo->pos[0] = pos[0] + newVec[0];
303      atomInfo->pos[1] = pos[1] + newVec[1];
304      atomInfo->pos[2] = pos[2] + newVec[2];
# Line 279 | Line 309 | void LinearAtomVisitor::visit(DirectionalAtom* datom){
309  
310      newVec = rotTrans * c2;
311      atomInfo = new AtomInfo;
312 <    atomInfo->AtomType = "C";
312 >    atomInfo->atomTypeName = "C";
313      atomInfo->pos[0] = pos[0] + newVec[0];
314      atomInfo->pos[1] = pos[1] + newVec[1];
315      atomInfo->pos[2] = pos[2] + newVec[2];
# Line 290 | Line 320 | void LinearAtomVisitor::visit(DirectionalAtom* datom){
320  
321      newVec = rotTrans * c3;
322      atomInfo = new AtomInfo;
323 <    atomInfo->AtomType = "C";
323 >    atomInfo->atomTypeName = "C";
324      atomInfo->pos[0] = pos[0] + newVec[0];
325      atomInfo->pos[1] = pos[1] + newVec[1];
326      atomInfo->pos[2] = pos[2] + newVec[2];
# Line 301 | Line 331 | void LinearAtomVisitor::visit(DirectionalAtom* datom){
331  
332      newVec = rotTrans * c4;
333      atomInfo = new AtomInfo;
334 <    atomInfo->AtomType = "C";
334 >    atomInfo->atomTypeName = "C";
335      atomInfo->pos[0] = pos[0] + newVec[0];
336      atomInfo->pos[1] = pos[1] + newVec[1];
337      atomInfo->pos[2] = pos[2] + newVec[2];
# Line 313 | Line 343 | void LinearAtomVisitor::visit(DirectionalAtom* datom){
343      //add atom data into atom's property
344  
345      if(!haveAtomData){
346 <        atomData->setID("ATOMDATA");
347 <        datom->addProperty(atomData);
346 >      atomData->setID("ATOMDATA");
347 >      datom->addProperty(atomData);
348      }
349  
350      setVisited(datom);
351  
352 < }
352 >  }
353  
354 < const std::string LinearAtomVisitor::toString(){
355 <  char buffer[65535];
356 <  std::string result;
354 >  const std::string LinearAtomVisitor::toString(){
355 >    char buffer[65535];
356 >    std::string result;
357    
358 <  sprintf(buffer ,"------------------------------------------------------------------\n");
359 <  result += buffer;
358 >    sprintf(buffer ,"------------------------------------------------------------------\n");
359 >    result += buffer;
360  
361 <  sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
362 <  result += buffer;
361 >    sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
362 >    result += buffer;
363  
364 <  sprintf(buffer , "Visitor Description: Convert linear into 4 different atoms\n");
365 <  result += buffer;
336 <
337 <  sprintf(buffer ,"------------------------------------------------------------------\n");
338 <  result += buffer;
364 >    sprintf(buffer , "Visitor Description: Convert linear into 4 different atoms\n");
365 >    result += buffer;
366  
367 <  return result;
368 < }
367 >    sprintf(buffer ,"------------------------------------------------------------------\n");
368 >    result += buffer;
369  
370 < //----------------------------------------------------------------------------//
370 >    return result;
371 >  }
372  
373 < void DefaultAtomVisitor::visit(Atom *atom) {
373 >  bool GBLipidAtomVisitor::isGBLipidAtom(const std::string& atomType){
374 >    std::set<std::string>::iterator strIter;
375 >    strIter = GBLipidAtomType.find(atomType);
376 >
377 >    return strIter != GBLipidAtomType.end() ? true : false;
378 >  }
379 >
380 >  void GBLipidAtomVisitor::visit(DirectionalAtom* datom){
381 >    std::vector<AtomInfo*> atoms;
382 >    //we need to convert linear into 4 different atoms
383 >    Vector3d c1(0.0, 0.0, -6.25);
384 >    Vector3d c2(0.0, 0.0, -2.1);
385 >    Vector3d c3(0.0, 0.0,  2.1);
386 >    Vector3d c4(0.0, 0.0,  6.25);
387 >    RotMat3x3d rotMatrix;
388 >    RotMat3x3d rotTrans;
389 >    AtomInfo* atomInfo;
390 >    Vector3d pos;
391 >    Vector3d newVec;
392 >    Quat4d q;
393 >    AtomData* atomData;
394 >    GenericData* data;
395 >    bool haveAtomData;
396 >
397 >    //if atom is not GBlipid atom, just skip it
398 >    if(!isGBLipidAtom(datom->getType()))
399 >      return;
400 >
401 >    data = datom->getPropertyByName("ATOMDATA");
402 >    if(data != NULL){
403 >      atomData = dynamic_cast<AtomData*>(data);  
404 >      if(atomData == NULL){
405 >        std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
406 >        atomData = new AtomData;
407 >        haveAtomData = false;      
408 >      } else {
409 >        haveAtomData = true;
410 >      }
411 >    } else {
412 >      atomData = new AtomData;
413 >      haveAtomData = false;
414 >    }
415 >  
416 >  
417 >    pos = datom->getPos();
418 >    q = datom->getQ();
419 >    rotMatrix = datom->getA();
420 >
421 >    // We need A^T to convert from body-fixed to space-fixed:  
422 >    rotTrans = rotMatrix.transpose();
423 >
424 >    newVec = rotTrans * c1;
425 >    atomInfo = new AtomInfo;
426 >    atomInfo->atomTypeName = "K";
427 >    atomInfo->pos[0] = pos[0] + newVec[0];
428 >    atomInfo->pos[1] = pos[1] + newVec[1];
429 >    atomInfo->pos[2] = pos[2] + newVec[2];
430 >    atomInfo->dipole[0] = 0.0;
431 >    atomInfo->dipole[1] = 0.0;
432 >    atomInfo->dipole[2] = 0.0;
433 >    atomData->addAtomInfo(atomInfo);
434 >
435 >    newVec = rotTrans * c2;
436 >    atomInfo = new AtomInfo;
437 >    atomInfo->atomTypeName = "K";
438 >    atomInfo->pos[0] = pos[0] + newVec[0];
439 >    atomInfo->pos[1] = pos[1] + newVec[1];
440 >    atomInfo->pos[2] = pos[2] + newVec[2];
441 >    atomInfo->dipole[0] = 0.0;
442 >    atomInfo->dipole[1] = 0.0;
443 >    atomInfo->dipole[2] = 0.0;
444 >    atomData->addAtomInfo(atomInfo);
445 >
446 >    newVec = rotTrans * c3;
447 >    atomInfo = new AtomInfo;
448 >    atomInfo->atomTypeName = "K";
449 >    atomInfo->pos[0] = pos[0] + newVec[0];
450 >    atomInfo->pos[1] = pos[1] + newVec[1];
451 >    atomInfo->pos[2] = pos[2] + newVec[2];
452 >    atomInfo->dipole[0] = 0.0;
453 >    atomInfo->dipole[1] = 0.0;
454 >    atomInfo->dipole[2] = 0.0;
455 >    atomData->addAtomInfo(atomInfo);
456 >
457 >    newVec = rotTrans * c4;
458 >    atomInfo = new AtomInfo;
459 >    atomInfo->atomTypeName = "K";
460 >    atomInfo->pos[0] = pos[0] + newVec[0];
461 >    atomInfo->pos[1] = pos[1] + newVec[1];
462 >    atomInfo->pos[2] = pos[2] + newVec[2];
463 >    atomInfo->dipole[0] = 0.0;
464 >    atomInfo->dipole[1] = 0.0;
465 >    atomInfo->dipole[2] = 0.0;
466 >    atomData->addAtomInfo(atomInfo);
467 >
468 >    //add atom data into atom's property
469 >
470 >    if(!haveAtomData){
471 >      atomData->setID("ATOMDATA");
472 >      datom->addProperty(atomData);
473 >    }
474 >
475 >    setVisited(datom);
476 >
477 >  }
478 >
479 >  const std::string GBLipidAtomVisitor::toString(){
480 >    char buffer[65535];
481 >    std::string result;
482 >  
483 >    sprintf(buffer ,"------------------------------------------------------------------\n");
484 >    result += buffer;
485 >
486 >    sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
487 >    result += buffer;
488 >
489 >    sprintf(buffer , "Visitor Description: Convert GBlipid into 4 different K atoms\n");
490 >    result += buffer;
491 >
492 >    sprintf(buffer ,"------------------------------------------------------------------\n");
493 >    result += buffer;
494 >
495 >    return result;
496 >  }
497 >
498 >  //----------------------------------------------------------------------------//
499 >
500 >  void DefaultAtomVisitor::visit(Atom *atom) {
501      AtomData *atomData;
502      AtomInfo *atomInfo;
503      Vector3d  pos;
504  
505      if (isVisited(atom))
506 <        return;
506 >      return;
507  
508      atomInfo = new AtomInfo;
509  
# Line 356 | Line 511 | void DefaultAtomVisitor::visit(Atom *atom) {
511      atomData->setID("ATOMDATA");
512  
513      pos = atom->getPos();
514 <    atomInfo->AtomType = atom->getType();
514 >    atomInfo->atomTypeName = atom->getType();
515      atomInfo->pos[0] = pos[0];
516      atomInfo->pos[1] = pos[1];
517      atomInfo->pos[2] = pos[2];
# Line 369 | Line 524 | void DefaultAtomVisitor::visit(Atom *atom) {
524      atom->addProperty(atomData);
525  
526      setVisited(atom);
527 < }
527 >  }
528  
529 < void DefaultAtomVisitor::visit(DirectionalAtom *datom) {
529 >  void DefaultAtomVisitor::visit(DirectionalAtom *datom) {
530      AtomData *atomData;
531      AtomInfo *atomInfo;
532      Vector3d  pos;
533      Vector3d  u;
534  
535      if (isVisited(datom))
536 <        return;
536 >      return;
537  
538      pos = datom->getPos();
539 <    u = datom->getElectroFrame().getColumn(3);
540 <
539 >    if (datom->getAtomType()->isGayBerne()) {
540 >        u = datom->getA().transpose()*V3Z;        
541 >    } else if (datom->getAtomType()->isMultipole()) {
542 >        u = datom->getElectroFrame().getColumn(2);
543 >    }
544      atomData = new AtomData;
545      atomData->setID("ATOMDATA");
546      atomInfo = new AtomInfo;
547  
548 <    atomInfo->AtomType = datom->getType();
548 >    atomInfo->atomTypeName = datom->getType();
549      atomInfo->pos[0] = pos[0];
550      atomInfo->pos[1] = pos[1];
551      atomInfo->pos[2] = pos[2];
# Line 400 | Line 558 | void DefaultAtomVisitor::visit(DirectionalAtom *datom)
558      datom->addProperty(atomData);
559  
560      setVisited(datom);
561 < }
561 >  }
562  
563 < const std::string DefaultAtomVisitor::toString() {
563 >  const std::string DefaultAtomVisitor::toString() {
564      char   buffer[65535];
565      std::string result;
566  
# Line 422 | Line 580 | const std::string DefaultAtomVisitor::toString() {
580      result += buffer;
581  
582      return result;
583 < }
583 >  }
584   } //namespace oopse

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines