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 507 by gezelter, Fri Apr 15 22:04:00 2005 UTC vs.
Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC

# Line 6 | Line 6
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
9 > * 1. Redistributions of source code must retain the above copyright
10   *    notice, this list of conditions and the following disclaimer.
11   *
12 < * 3. Redistributions in binary form must reproduce the above copyright
12 > * 2. Redistributions in binary form must reproduce the above copyright
13   *    notice, this list of conditions and the following disclaimer in the
14   *    documentation and/or other materials provided with the
15   *    distribution.
# Line 37 | Line 28
28   * arising out of the use of or inability to use software, even if the
29   * University of Notre Dame has been advised of the possibility of
30   * such damages.
31 + *
32 + * SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
33 + * research, please cite the appropriate papers when you publish your
34 + * work.  Good starting points are:
35 + *                                                                      
36 + * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).            
37 + * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
38 + * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).          
39 + * [4]  Vardeman & Gezelter, in progress (2009).                        
40   */
41  
42   #include <cstring>
# Line 44 | Line 44
44   #include "primitives/DirectionalAtom.hpp"
45   #include "primitives/RigidBody.hpp"
46  
47 < namespace oopse {
47 > namespace OpenMD {
48    void BaseAtomVisitor::visit(RigidBody *rb) {
49      //vector<Atom*> myAtoms;
50      //vector<Atom*>::iterator atomIter;
# Line 82 | Line 82 | namespace oopse {
82    void SSDAtomVisitor::visit(DirectionalAtom *datom) {
83      std::vector<AtomInfo*>atoms;
84  
85 <    //we need to convert SSD into 4 differnet atoms
86 <    //one oxygen atom, two hydrogen atoms and one pseudo atom which is the center of the mass
87 <    //of the water with a dipole moment
85 >    //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      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);
# Line 205 | Line 205 | namespace oopse {
205  
206      sprintf(buffer,
207              "Visitor Description: Convert SSD into 4 different atoms\n");
208 +    result += buffer;
209 +
210 +    sprintf(buffer,
211 +            "------------------------------------------------------------------\n");
212 +    result += buffer;
213 +
214 +    return result;
215 +  }
216 +
217 +
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    bool LinearAtomVisitor::isLinearAtom(const std::string& atomType){
361      std::set<std::string>::iterator strIter;
362      strIter = linearAtomType.find(atomType);
# Line 221 | Line 364 | namespace oopse {
364      return strIter != linearAtomType.end() ? true : false;
365    }
366  
367 +  void LinearAtomVisitor::addGayBerneAtomType(const std::string& atomType){
368 +   linearAtomType.insert(atomType);
369 +  }
370 +
371    void LinearAtomVisitor::visit(DirectionalAtom* datom){
372      std::vector<AtomInfo*> atoms;
373      //we need to convert linear into 4 different atoms
# Line 237 | Line 384 | namespace oopse {
384      AtomData* atomData;
385      GenericData* data;
386      bool haveAtomData;
387 <
388 <    //if atom is not SSD atom, just skip it
242 <    if(!isLinearAtom(datom->getType()))
387 >    //if atom is not linear atom, just skip it
388 >    if(!isLinearAtom(datom->getType()) || !datom->getAtomType()->isGayBerne())
389        return;
390  
391 +    //setup GayBerne type in fortran side
392 +    data = datom->getAtomType()->getPropertyByName("GayBerne");
393 +    if (data != NULL) {
394 +       GayBerneParamGenericData* gayBerneData = dynamic_cast<GayBerneParamGenericData*>(data);
395 +
396 +       if (gayBerneData != NULL) {
397 +           GayBerneParam gayBerneParam = gayBerneData->getData();
398 +
399 +                          // double halfLen = gayBerneParam.GB_sigma * gayBerneParam.GB_l2b_ratio/2.0;
400 +                          double halfLen = gayBerneParam.GB_l/2.0;
401 +                          c1[2] = -halfLen;
402 +              c2[2] = -halfLen /2;
403 +              c3[2] = halfLen/2;
404 +              c4[2] = halfLen;
405 +                
406 +            }
407 +            
408 +              else {
409 +                    sprintf( painCave.errMsg,
410 +                           "Can not cast GenericData to GayBerneParam\n");
411 +                    painCave.severity = OPENMD_ERROR;
412 +                    painCave.isFatal = 1;
413 +                    simError();          
414 +        }            
415 +    }
416 +
417 +
418      data = datom->getPropertyByName("ATOMDATA");
419      if(data != NULL){
420        atomData = dynamic_cast<AtomData*>(data);  
# Line 339 | Line 512 | namespace oopse {
512      return result;
513    }
514  
515 +  bool GBLipidAtomVisitor::isGBLipidAtom(const std::string& atomType){
516 +    std::set<std::string>::iterator strIter;
517 +    strIter = GBLipidAtomType.find(atomType);
518 +
519 +    return strIter != GBLipidAtomType.end() ? true : false;
520 +  }
521 +
522 +  void GBLipidAtomVisitor::visit(DirectionalAtom* datom){
523 +    std::vector<AtomInfo*> atoms;
524 +    Vector3d c1(0.0, 0.0, 0.0);
525 +    Vector3d c2(0.0, 0.0, 1.0);
526 +    RotMat3x3d rotMatrix;
527 +    RotMat3x3d rotTrans;
528 +    AtomInfo* atomInfo;
529 +    Vector3d pos;
530 +    Vector3d newVec;
531 +    Vector3d dVec;
532 +    Quat4d q;
533 +    AtomData* atomData;
534 +    GenericData* data;
535 +    bool haveAtomData;
536 +
537 +    //if atom is not GBlipid atom, just skip it
538 +    if(!isGBLipidAtom(datom->getType()))
539 +      return;
540 +
541 +    data = datom->getPropertyByName("ATOMDATA");
542 +    if(data != NULL){
543 +      atomData = dynamic_cast<AtomData*>(data);  
544 +      if(atomData == NULL){
545 +        std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
546 +        atomData = new AtomData;
547 +        haveAtomData = false;      
548 +      } else {
549 +        haveAtomData = true;
550 +      }
551 +    } else {
552 +      atomData = new AtomData;
553 +      haveAtomData = false;
554 +    }
555 +  
556 +  
557 +    pos = datom->getPos();
558 +    q = datom->getQ();
559 +    rotMatrix = datom->getA();
560 +
561 +    // We need A^T to convert from body-fixed to space-fixed:  
562 +    rotTrans = rotMatrix.transpose();
563 +
564 +    newVec = rotTrans * c1;
565 +    dVec = rotTrans * c2;
566 +    atomInfo = new AtomInfo;
567 +    atomInfo->atomTypeName = "GB";
568 +    atomInfo->pos[0] = pos[0] + newVec[0];
569 +    atomInfo->pos[1] = pos[1] + newVec[1];
570 +    atomInfo->pos[2] = pos[2] + newVec[2];
571 +    atomInfo->dipole[0] = dVec[0];
572 +    atomInfo->dipole[1] = dVec[1];
573 +    atomInfo->dipole[2] = dVec[2];
574 +    atomInfo->hasVector = true;
575 +    atomInfo->charge = 3.0;
576 +    atomInfo->hasCharge = true;
577 +    atomData->addAtomInfo(atomInfo);
578 +
579 +    //add atom data into atom's property
580 +
581 +    if(!haveAtomData){
582 +      atomData->setID("ATOMDATA");
583 +      datom->addProperty(atomData);
584 +    }
585 +
586 +    setVisited(datom);
587 +
588 +  }
589 +
590 +  const std::string GBLipidAtomVisitor::toString(){
591 +    char buffer[65535];
592 +    std::string result;
593 +  
594 +    sprintf(buffer ,"------------------------------------------------------------------\n");
595 +    result += buffer;
596 +
597 +    sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
598 +    result += buffer;
599 +
600 +    sprintf(buffer , "Visitor Description: Convert GBlipid into xyz-formatted atom for use with xyz2pov\n");
601 +    result += buffer;
602 +
603 +    sprintf(buffer ,"------------------------------------------------------------------\n");
604 +    result += buffer;
605 +
606 +    return result;
607 +  }
608 +
609 +  bool Ring5gbAtomVisitor::isRing5gbAtom(const std::string& atomType){
610 +    std::set<std::string>::iterator strIter;
611 +    strIter = Ring5gbAtomType.find(atomType);
612 +
613 +    return strIter != Ring5gbAtomType.end() ? true : false;
614 +  }
615 +
616 +  void Ring5gbAtomVisitor::visit(DirectionalAtom* datom){
617 +    std::vector<AtomInfo*> atoms;
618 +    //we need to convert linear into 4 different atoms
619 +    Vector3d c1(0.0, 0.0, -5.5);
620 +    Vector3d c2(0.0, 0.0, -1.8);
621 +    Vector3d c3(0.0, 0.0,  1.8);
622 +    Vector3d c4(0.0, 0.0,  5.5);
623 +    RotMat3x3d rotMatrix;
624 +    RotMat3x3d rotTrans;
625 +    AtomInfo* atomInfo;
626 +    Vector3d pos;
627 +    Vector3d newVec;
628 +    Vector3d dVec;
629 +    Quat4d q;
630 +    AtomData* atomData;
631 +    GenericData* data;
632 +    bool haveAtomData;
633 +
634 +    //if atom is not Ring5GB atom, just skip it
635 +    if(!isRing5gbAtom(datom->getType()))
636 +      return;
637 +
638 +    data = datom->getPropertyByName("ATOMDATA");
639 +    if(data != NULL){
640 +      atomData = dynamic_cast<AtomData*>(data);  
641 +      if(atomData == NULL){
642 +        std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
643 +        atomData = new AtomData;
644 +        haveAtomData = false;      
645 +      } else {
646 +        haveAtomData = true;
647 +      }
648 +    } else {
649 +      atomData = new AtomData;
650 +      haveAtomData = false;
651 +    }
652 +  
653 +  
654 +    pos = datom->getPos();
655 +    q = datom->getQ();
656 +    rotMatrix = datom->getA();
657 +
658 +    // We need A^T to convert from body-fixed to space-fixed:  
659 +    rotTrans = rotMatrix.transpose();
660 +
661 +    newVec = rotTrans * c1;
662 +    atomInfo = new AtomInfo;
663 +    atomInfo->atomTypeName = "K";
664 +    atomInfo->pos[0] = pos[0] + newVec[0];
665 +    atomInfo->pos[1] = pos[1] + newVec[1];
666 +    atomInfo->pos[2] = pos[2] + newVec[2];
667 +    atomInfo->dipole[0] = 0.0;
668 +    atomInfo->dipole[1] = 0.0;
669 +    atomInfo->dipole[2] = 0.0;
670 +    atomData->addAtomInfo(atomInfo);
671 +
672 +    newVec = rotTrans * c2;
673 +    atomInfo = new AtomInfo;
674 +    atomInfo->atomTypeName = "K";
675 +    atomInfo->pos[0] = pos[0] + newVec[0];
676 +    atomInfo->pos[1] = pos[1] + newVec[1];
677 +    atomInfo->pos[2] = pos[2] + newVec[2];
678 +    atomInfo->dipole[0] = 0.0;
679 +    atomInfo->dipole[1] = 0.0;
680 +    atomInfo->dipole[2] = 0.0;
681 +    atomData->addAtomInfo(atomInfo);
682 +
683 +    newVec = rotTrans * c3;
684 +    atomInfo = new AtomInfo;
685 +    atomInfo->atomTypeName = "K";
686 +    atomInfo->pos[0] = pos[0] + newVec[0];
687 +    atomInfo->pos[1] = pos[1] + newVec[1];
688 +    atomInfo->pos[2] = pos[2] + newVec[2];
689 +    atomInfo->dipole[0] = 0.0;
690 +    atomInfo->dipole[1] = 0.0;
691 +    atomInfo->dipole[2] = 0.0;
692 +    atomData->addAtomInfo(atomInfo);
693 +
694 +    newVec = rotTrans * c4;
695 +    atomInfo = new AtomInfo;
696 +    atomInfo->atomTypeName = "K";
697 +    atomInfo->pos[0] = pos[0] + newVec[0];
698 +    atomInfo->pos[1] = pos[1] + newVec[1];
699 +    atomInfo->pos[2] = pos[2] + newVec[2];
700 +    atomInfo->dipole[0] = 0.0;
701 +    atomInfo->dipole[1] = 0.0;
702 +    atomInfo->dipole[2] = 0.0;
703 +    atomData->addAtomInfo(atomInfo);
704 +
705 +    //add atom data into atom's property
706 +
707 +    if(!haveAtomData){
708 +      atomData->setID("ATOMDATA");
709 +      datom->addProperty(atomData);
710 +    }
711 +
712 +    setVisited(datom);
713 +
714 +  }
715 +
716 +  const std::string Ring5gbAtomVisitor::toString(){
717 +    char buffer[65535];
718 +    std::string result;
719 +  
720 +    sprintf(buffer ,"------------------------------------------------------------------\n");
721 +    result += buffer;
722 +
723 +    sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
724 +    result += buffer;
725 +
726 +    sprintf(buffer , "Visitor Description: Convert Ring5GB into 4 different K atoms\n");
727 +    result += buffer;
728 +
729 +    sprintf(buffer ,"------------------------------------------------------------------\n");
730 +    result += buffer;
731 +
732 +    return result;
733 +  }
734 +
735 +  bool HeadAtomVisitor::isHeadAtom(const std::string& atomType){
736 +    std::set<std::string>::iterator strIter;
737 +    strIter = HeadAtomType.find(atomType);
738 +
739 +    return strIter != HeadAtomType.end() ? true : false;
740 +  }
741 +
742 +  void HeadAtomVisitor::visit(DirectionalAtom* datom){
743 +    std::vector<AtomInfo*> atoms;
744 +    //we need to convert linear into 2 different atoms
745 +    Vector3d c1(0.0, 0.0, -1.5);
746 +    Vector3d c2(0.0, 0.0, 1.5);
747 +    RotMat3x3d rotMatrix;
748 +    RotMat3x3d rotTrans;
749 +    AtomInfo* atomInfo;
750 +    Vector3d pos;
751 +    Vector3d newVec;
752 +    Vector3d dVec;
753 +    Quat4d q;
754 +    AtomData* atomData;
755 +    GenericData* data;
756 +    bool haveAtomData;
757 +
758 +    //if atom is not Head atom, just skip it
759 +    if(!isHeadAtom(datom->getType()))
760 +      return;
761 +
762 +    data = datom->getPropertyByName("ATOMDATA");
763 +    if(data != NULL){
764 +      atomData = dynamic_cast<AtomData*>(data);  
765 +      if(atomData == NULL){
766 +        std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
767 +        atomData = new AtomData;
768 +        haveAtomData = false;      
769 +      } else {
770 +        haveAtomData = true;
771 +      }
772 +    } else {
773 +      atomData = new AtomData;
774 +      haveAtomData = false;
775 +    }
776 +  
777 +  
778 +    pos = datom->getPos();
779 +    q = datom->getQ();
780 +    rotMatrix = datom->getA();
781 +
782 +    // We need A^T to convert from body-fixed to space-fixed:  
783 +    rotTrans = rotMatrix.transpose();
784 +
785 +    newVec = rotTrans * c1;
786 +    atomInfo = new AtomInfo;
787 +    atomInfo->atomTypeName = "C";
788 +    atomInfo->pos[0] = pos[0] + newVec[0];
789 +    atomInfo->pos[1] = pos[1] + newVec[1];
790 +    atomInfo->pos[2] = pos[2] + newVec[2];
791 +    atomInfo->dipole[0] = 0.0;
792 +    atomInfo->dipole[1] = 0.0;
793 +    atomInfo->dipole[2] = 0.0;
794 +    atomData->addAtomInfo(atomInfo);
795 +
796 +    newVec = rotTrans * c2;
797 +    atomInfo = new AtomInfo;
798 +    atomInfo->atomTypeName = "O";
799 +    atomInfo->pos[0] = pos[0] + newVec[0];
800 +    atomInfo->pos[1] = pos[1] + newVec[1];
801 +    atomInfo->pos[2] = pos[2] + newVec[2];
802 +    atomInfo->dipole[0] = 0.0;
803 +    atomInfo->dipole[1] = 0.0;
804 +    atomInfo->dipole[2] = 0.0;
805 +    atomData->addAtomInfo(atomInfo);
806 +
807 +    //add atom data into atom's property
808 +
809 +    if(!haveAtomData){
810 +      atomData->setID("ATOMDATA");
811 +      datom->addProperty(atomData);
812 +    }
813 +
814 +    setVisited(datom);
815 +
816 +  }
817 +
818 +  const std::string HeadAtomVisitor::toString(){
819 +    char buffer[65535];
820 +    std::string result;
821 +  
822 +    sprintf(buffer ,"------------------------------------------------------------------\n");
823 +    result += buffer;
824 +
825 +    sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
826 +    result += buffer;
827 +
828 +    sprintf(buffer , "Visitor Description: Convert HEAD into C atom and O atom\n");
829 +    result += buffer;
830 +
831 +    sprintf(buffer ,"------------------------------------------------------------------\n");
832 +    result += buffer;
833 +
834 +    return result;
835 +  }
836 +
837 +
838    //----------------------------------------------------------------------------//
839  
840    void DefaultAtomVisitor::visit(Atom *atom) {
# Line 380 | Line 876 | namespace oopse {
876        return;
877  
878      pos = datom->getPos();
879 <    u = datom->getElectroFrame().getColumn(2);
880 <
879 >    if (datom->getAtomType()->isGayBerne()) {
880 >        u = datom->getA().transpose()*V3Z;        
881 >    } else if (datom->getAtomType()->isMultipole()) {
882 >        u = datom->getElectroFrame().getColumn(2);
883 >    }
884      atomData = new AtomData;
885      atomData->setID("ATOMDATA");
886      atomInfo = new AtomInfo;
# Line 422 | Line 921 | namespace oopse {
921  
922      return result;
923    }
924 < } //namespace oopse
924 > } //namespace OpenMD

Diff Legend

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