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 275 by tim, Wed Jan 26 15:15:09 2005 UTC vs.
Revision 989 by tim, Sat Jun 17 17:02:33 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 +                                                        c1[2] = -halfLen;
259 +              c2[2] = -halfLen /2;
260 +              c3[2] = halfLen/2;
261 +              c4[2] = halfLen;
262 +                
263 +            }
264 +            
265 +              else {
266 +                    sprintf( painCave.errMsg,
267 +                           "Can not cast GenericData to GayBerneParam\n");
268 +                    painCave.severity = OOPSE_ERROR;
269 +                    painCave.isFatal = 1;
270 +                    simError();          
271 +        }            
272 +    }
273 +
274 +
275      data = datom->getPropertyByName("ATOMDATA");
276      if(data != NULL){
277 <        atomData = dynamic_cast<AtomData*>(data);  
278 <        if(atomData == NULL){
279 <            std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
280 <            atomData = new AtomData;
281 <            haveAtomData = false;      
282 <        } else {
283 <            haveAtomData = true;
284 <        }
277 >      atomData = dynamic_cast<AtomData*>(data);  
278 >      if(atomData == NULL){
279 >        std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
280 >        atomData = new AtomData;
281 >        haveAtomData = false;      
282 >      } else {
283 >        haveAtomData = true;
284 >      }
285      } else {
286 <        atomData = new AtomData;
287 <        haveAtomData = false;
286 >      atomData = new AtomData;
287 >      haveAtomData = false;
288      }
289    
290    
# Line 268 | Line 297 | void LinearAtomVisitor::visit(DirectionalAtom* datom){
297  
298      newVec = rotTrans * c1;
299      atomInfo = new AtomInfo;
300 <    atomInfo->AtomType = "C";
300 >    atomInfo->atomTypeName = "C";
301      atomInfo->pos[0] = pos[0] + newVec[0];
302      atomInfo->pos[1] = pos[1] + newVec[1];
303      atomInfo->pos[2] = pos[2] + newVec[2];
# Line 279 | Line 308 | void LinearAtomVisitor::visit(DirectionalAtom* datom){
308  
309      newVec = rotTrans * c2;
310      atomInfo = new AtomInfo;
311 <    atomInfo->AtomType = "C";
311 >    atomInfo->atomTypeName = "C";
312      atomInfo->pos[0] = pos[0] + newVec[0];
313      atomInfo->pos[1] = pos[1] + newVec[1];
314      atomInfo->pos[2] = pos[2] + newVec[2];
# Line 290 | Line 319 | void LinearAtomVisitor::visit(DirectionalAtom* datom){
319  
320      newVec = rotTrans * c3;
321      atomInfo = new AtomInfo;
322 <    atomInfo->AtomType = "C";
322 >    atomInfo->atomTypeName = "C";
323      atomInfo->pos[0] = pos[0] + newVec[0];
324      atomInfo->pos[1] = pos[1] + newVec[1];
325      atomInfo->pos[2] = pos[2] + newVec[2];
# Line 301 | Line 330 | void LinearAtomVisitor::visit(DirectionalAtom* datom){
330  
331      newVec = rotTrans * c4;
332      atomInfo = new AtomInfo;
333 <    atomInfo->AtomType = "C";
333 >    atomInfo->atomTypeName = "C";
334      atomInfo->pos[0] = pos[0] + newVec[0];
335      atomInfo->pos[1] = pos[1] + newVec[1];
336      atomInfo->pos[2] = pos[2] + newVec[2];
# Line 313 | Line 342 | void LinearAtomVisitor::visit(DirectionalAtom* datom){
342      //add atom data into atom's property
343  
344      if(!haveAtomData){
345 <        atomData->setID("ATOMDATA");
346 <        datom->addProperty(atomData);
345 >      atomData->setID("ATOMDATA");
346 >      datom->addProperty(atomData);
347      }
348  
349      setVisited(datom);
350  
351 < }
351 >  }
352  
353 < const std::string LinearAtomVisitor::toString(){
354 <  char buffer[65535];
355 <  std::string result;
353 >  const std::string LinearAtomVisitor::toString(){
354 >    char buffer[65535];
355 >    std::string result;
356    
357 <  sprintf(buffer ,"------------------------------------------------------------------\n");
358 <  result += buffer;
357 >    sprintf(buffer ,"------------------------------------------------------------------\n");
358 >    result += buffer;
359  
360 <  sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
361 <  result += buffer;
360 >    sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
361 >    result += buffer;
362  
363 <  sprintf(buffer , "Visitor Description: Convert linear into 4 different atoms\n");
364 <  result += buffer;
336 <
337 <  sprintf(buffer ,"------------------------------------------------------------------\n");
338 <  result += buffer;
363 >    sprintf(buffer , "Visitor Description: Convert linear into 4 different atoms\n");
364 >    result += buffer;
365  
366 <  return result;
367 < }
366 >    sprintf(buffer ,"------------------------------------------------------------------\n");
367 >    result += buffer;
368  
369 < //----------------------------------------------------------------------------//
369 >    return result;
370 >  }
371  
372 < void DefaultAtomVisitor::visit(Atom *atom) {
372 >  bool GBLipidAtomVisitor::isGBLipidAtom(const std::string& atomType){
373 >    std::set<std::string>::iterator strIter;
374 >    strIter = GBLipidAtomType.find(atomType);
375 >
376 >    return strIter != GBLipidAtomType.end() ? true : false;
377 >  }
378 >
379 >  void GBLipidAtomVisitor::visit(DirectionalAtom* datom){
380 >    std::vector<AtomInfo*> atoms;
381 >    //we need to convert linear into 4 different atoms
382 >    Vector3d c1(0.0, 0.0, -6.25);
383 >    Vector3d c2(0.0, 0.0, -2.1);
384 >    Vector3d c3(0.0, 0.0,  2.1);
385 >    Vector3d c4(0.0, 0.0,  6.25);
386 >    RotMat3x3d rotMatrix;
387 >    RotMat3x3d rotTrans;
388 >    AtomInfo* atomInfo;
389 >    Vector3d pos;
390 >    Vector3d newVec;
391 >    Quat4d q;
392 >    AtomData* atomData;
393 >    GenericData* data;
394 >    bool haveAtomData;
395 >
396 >    //if atom is not GBlipid atom, just skip it
397 >    if(!isGBLipidAtom(datom->getType()))
398 >      return;
399 >
400 >    data = datom->getPropertyByName("ATOMDATA");
401 >    if(data != NULL){
402 >      atomData = dynamic_cast<AtomData*>(data);  
403 >      if(atomData == NULL){
404 >        std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
405 >        atomData = new AtomData;
406 >        haveAtomData = false;      
407 >      } else {
408 >        haveAtomData = true;
409 >      }
410 >    } else {
411 >      atomData = new AtomData;
412 >      haveAtomData = false;
413 >    }
414 >  
415 >  
416 >    pos = datom->getPos();
417 >    q = datom->getQ();
418 >    rotMatrix = datom->getA();
419 >
420 >    // We need A^T to convert from body-fixed to space-fixed:  
421 >    rotTrans = rotMatrix.transpose();
422 >
423 >    newVec = rotTrans * c1;
424 >    atomInfo = new AtomInfo;
425 >    atomInfo->atomTypeName = "K";
426 >    atomInfo->pos[0] = pos[0] + newVec[0];
427 >    atomInfo->pos[1] = pos[1] + newVec[1];
428 >    atomInfo->pos[2] = pos[2] + newVec[2];
429 >    atomInfo->dipole[0] = 0.0;
430 >    atomInfo->dipole[1] = 0.0;
431 >    atomInfo->dipole[2] = 0.0;
432 >    atomData->addAtomInfo(atomInfo);
433 >
434 >    newVec = rotTrans * c2;
435 >    atomInfo = new AtomInfo;
436 >    atomInfo->atomTypeName = "K";
437 >    atomInfo->pos[0] = pos[0] + newVec[0];
438 >    atomInfo->pos[1] = pos[1] + newVec[1];
439 >    atomInfo->pos[2] = pos[2] + newVec[2];
440 >    atomInfo->dipole[0] = 0.0;
441 >    atomInfo->dipole[1] = 0.0;
442 >    atomInfo->dipole[2] = 0.0;
443 >    atomData->addAtomInfo(atomInfo);
444 >
445 >    newVec = rotTrans * c3;
446 >    atomInfo = new AtomInfo;
447 >    atomInfo->atomTypeName = "K";
448 >    atomInfo->pos[0] = pos[0] + newVec[0];
449 >    atomInfo->pos[1] = pos[1] + newVec[1];
450 >    atomInfo->pos[2] = pos[2] + newVec[2];
451 >    atomInfo->dipole[0] = 0.0;
452 >    atomInfo->dipole[1] = 0.0;
453 >    atomInfo->dipole[2] = 0.0;
454 >    atomData->addAtomInfo(atomInfo);
455 >
456 >    newVec = rotTrans * c4;
457 >    atomInfo = new AtomInfo;
458 >    atomInfo->atomTypeName = "K";
459 >    atomInfo->pos[0] = pos[0] + newVec[0];
460 >    atomInfo->pos[1] = pos[1] + newVec[1];
461 >    atomInfo->pos[2] = pos[2] + newVec[2];
462 >    atomInfo->dipole[0] = 0.0;
463 >    atomInfo->dipole[1] = 0.0;
464 >    atomInfo->dipole[2] = 0.0;
465 >    atomData->addAtomInfo(atomInfo);
466 >
467 >    //add atom data into atom's property
468 >
469 >    if(!haveAtomData){
470 >      atomData->setID("ATOMDATA");
471 >      datom->addProperty(atomData);
472 >    }
473 >
474 >    setVisited(datom);
475 >
476 >  }
477 >
478 >  const std::string GBLipidAtomVisitor::toString(){
479 >    char buffer[65535];
480 >    std::string result;
481 >  
482 >    sprintf(buffer ,"------------------------------------------------------------------\n");
483 >    result += buffer;
484 >
485 >    sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
486 >    result += buffer;
487 >
488 >    sprintf(buffer , "Visitor Description: Convert GBlipid into 4 different K atoms\n");
489 >    result += buffer;
490 >
491 >    sprintf(buffer ,"------------------------------------------------------------------\n");
492 >    result += buffer;
493 >
494 >    return result;
495 >  }
496 >
497 >  //----------------------------------------------------------------------------//
498 >
499 >  void DefaultAtomVisitor::visit(Atom *atom) {
500      AtomData *atomData;
501      AtomInfo *atomInfo;
502      Vector3d  pos;
503  
504      if (isVisited(atom))
505 <        return;
505 >      return;
506  
507      atomInfo = new AtomInfo;
508  
# Line 356 | Line 510 | void DefaultAtomVisitor::visit(Atom *atom) {
510      atomData->setID("ATOMDATA");
511  
512      pos = atom->getPos();
513 <    atomInfo->AtomType = atom->getType();
513 >    atomInfo->atomTypeName = atom->getType();
514      atomInfo->pos[0] = pos[0];
515      atomInfo->pos[1] = pos[1];
516      atomInfo->pos[2] = pos[2];
# Line 369 | Line 523 | void DefaultAtomVisitor::visit(Atom *atom) {
523      atom->addProperty(atomData);
524  
525      setVisited(atom);
526 < }
526 >  }
527  
528 < void DefaultAtomVisitor::visit(DirectionalAtom *datom) {
528 >  void DefaultAtomVisitor::visit(DirectionalAtom *datom) {
529      AtomData *atomData;
530      AtomInfo *atomInfo;
531      Vector3d  pos;
532      Vector3d  u;
533  
534      if (isVisited(datom))
535 <        return;
535 >      return;
536  
537      pos = datom->getPos();
538 <    u = datom->getElectroFrame().getColumn(2);
539 <
538 >    if (datom->getAtomType()->isGayBerne()) {
539 >        u = datom->getA().transpose()*V3Z;        
540 >    } else if (datom->getAtomType()->isMultipole()) {
541 >        u = datom->getElectroFrame().getColumn(2);
542 >    }
543      atomData = new AtomData;
544      atomData->setID("ATOMDATA");
545      atomInfo = new AtomInfo;
546  
547 <    atomInfo->AtomType = datom->getType();
547 >    atomInfo->atomTypeName = datom->getType();
548      atomInfo->pos[0] = pos[0];
549      atomInfo->pos[1] = pos[1];
550      atomInfo->pos[2] = pos[2];
# Line 400 | Line 557 | void DefaultAtomVisitor::visit(DirectionalAtom *datom)
557      datom->addProperty(atomData);
558  
559      setVisited(datom);
560 < }
560 >  }
561  
562 < const std::string DefaultAtomVisitor::toString() {
562 >  const std::string DefaultAtomVisitor::toString() {
563      char   buffer[65535];
564      std::string result;
565  
# Line 422 | Line 579 | const std::string DefaultAtomVisitor::toString() {
579      result += buffer;
580  
581      return result;
582 < }
582 >  }
583   } //namespace oopse

Diff Legend

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