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 989 by tim, Sat Jun 17 17:02:33 2006 UTC vs.
Revision 1244 by xsun, Wed May 14 21:04:13 2008 UTC

# 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 242 | Line 385 | namespace oopse {
385      GenericData* data;
386      bool haveAtomData;
387      AtomType* atomType;
388 <    //if atom is not SSD atom, just skip it
388 >    //if atom is not linear atom, just skip it
389      if(!isLinearAtom(datom->getType()) || !datom->getAtomType()->isGayBerne())
390        return;
391  
# Line 254 | Line 397 | namespace oopse {
397         if (gayBerneData != NULL) {
398             GayBerneParam gayBerneParam = gayBerneData->getData();
399  
400 <                                          double halfLen = gayBerneParam.GB_sigma * gayBerneParam.GB_l2b_ratio/2.0;
401 <                                                        c1[2] = -halfLen;
400 >                          // double halfLen = gayBerneParam.GB_sigma * gayBerneParam.GB_l2b_ratio/2.0;
401 >                          double halfLen = gayBerneParam.GB_l/2.0;
402 >                          c1[2] = -halfLen;
403                c2[2] = -halfLen /2;
404                c3[2] = halfLen/2;
405                c4[2] = halfLen;
# Line 378 | Line 522 | namespace oopse {
522  
523    void GBLipidAtomVisitor::visit(DirectionalAtom* datom){
524      std::vector<AtomInfo*> atoms;
525 <    //we need to convert linear into 4 different atoms
526 <    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);
525 >    Vector3d c1(0.0, 0.0, 0.0);
526 >    Vector3d c2(0.0, 0.0, 1.0);
527      RotMat3x3d rotMatrix;
528      RotMat3x3d rotTrans;
529      AtomInfo* atomInfo;
530      Vector3d pos;
531      Vector3d newVec;
532 +    Vector3d dVec;
533      Quat4d q;
534      AtomData* atomData;
535      GenericData* data;
# Line 395 | Line 537 | namespace oopse {
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 +    dVec = rotTrans * c2;
567 +    atomInfo = new AtomInfo;
568 +    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 +    sprintf(buffer , "Visitor Description: Convert GBlipid into xyz-formatted atom for use with xyz2pov\n");
602 +    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");
# Line 475 | Line 714 | namespace oopse {
714  
715    }
716  
717 <  const std::string GBLipidAtomVisitor::toString(){
717 >  const std::string Ring5gbAtomVisitor::toString(){
718      char buffer[65535];
719      std::string result;
720    
# Line 485 | Line 724 | namespace oopse {
724      sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
725      result += buffer;
726  
727 <    sprintf(buffer , "Visitor Description: Convert GBlipid into 4 different K atoms\n");
727 >    sprintf(buffer , "Visitor Description: Convert Ring5GB into 4 different K atoms\n");
728      result += buffer;
729  
730      sprintf(buffer ,"------------------------------------------------------------------\n");
# Line 494 | Line 733 | namespace oopse {
733      return result;
734    }
735  
736 +  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    //----------------------------------------------------------------------------//
840  
841    void DefaultAtomVisitor::visit(Atom *atom) {

Diff Legend

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