ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/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 954 by tim, Wed May 10 01:44:48 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 241 | Line 244 | void LinearAtomVisitor::visit(DirectionalAtom* datom){
244  
245      //if atom is not SSD atom, just skip it
246      if(!isLinearAtom(datom->getType()))
247 <        return;
247 >      return;
248  
249      data = datom->getPropertyByName("ATOMDATA");
250      if(data != NULL){
251 <        atomData = dynamic_cast<AtomData*>(data);  
252 <        if(atomData == NULL){
253 <            std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
254 <            atomData = new AtomData;
255 <            haveAtomData = false;      
256 <        } else {
257 <            haveAtomData = true;
258 <        }
251 >      atomData = dynamic_cast<AtomData*>(data);  
252 >      if(atomData == NULL){
253 >        std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
254 >        atomData = new AtomData;
255 >        haveAtomData = false;      
256 >      } else {
257 >        haveAtomData = true;
258 >      }
259      } else {
260 <        atomData = new AtomData;
261 <        haveAtomData = false;
260 >      atomData = new AtomData;
261 >      haveAtomData = false;
262      }
263    
264    
# Line 268 | Line 271 | void LinearAtomVisitor::visit(DirectionalAtom* datom){
271  
272      newVec = rotTrans * c1;
273      atomInfo = new AtomInfo;
274 <    atomInfo->AtomType = "C";
274 >    atomInfo->atomTypeName = "C";
275      atomInfo->pos[0] = pos[0] + newVec[0];
276      atomInfo->pos[1] = pos[1] + newVec[1];
277      atomInfo->pos[2] = pos[2] + newVec[2];
# Line 279 | Line 282 | void LinearAtomVisitor::visit(DirectionalAtom* datom){
282  
283      newVec = rotTrans * c2;
284      atomInfo = new AtomInfo;
285 <    atomInfo->AtomType = "C";
285 >    atomInfo->atomTypeName = "C";
286      atomInfo->pos[0] = pos[0] + newVec[0];
287      atomInfo->pos[1] = pos[1] + newVec[1];
288      atomInfo->pos[2] = pos[2] + newVec[2];
# Line 290 | Line 293 | void LinearAtomVisitor::visit(DirectionalAtom* datom){
293  
294      newVec = rotTrans * c3;
295      atomInfo = new AtomInfo;
296 <    atomInfo->AtomType = "C";
296 >    atomInfo->atomTypeName = "C";
297      atomInfo->pos[0] = pos[0] + newVec[0];
298      atomInfo->pos[1] = pos[1] + newVec[1];
299      atomInfo->pos[2] = pos[2] + newVec[2];
# Line 301 | Line 304 | void LinearAtomVisitor::visit(DirectionalAtom* datom){
304  
305      newVec = rotTrans * c4;
306      atomInfo = new AtomInfo;
307 <    atomInfo->AtomType = "C";
307 >    atomInfo->atomTypeName = "C";
308      atomInfo->pos[0] = pos[0] + newVec[0];
309      atomInfo->pos[1] = pos[1] + newVec[1];
310      atomInfo->pos[2] = pos[2] + newVec[2];
# Line 313 | Line 316 | void LinearAtomVisitor::visit(DirectionalAtom* datom){
316      //add atom data into atom's property
317  
318      if(!haveAtomData){
319 <        atomData->setID("ATOMDATA");
320 <        datom->addProperty(atomData);
319 >      atomData->setID("ATOMDATA");
320 >      datom->addProperty(atomData);
321      }
322  
323      setVisited(datom);
324  
325 < }
325 >  }
326  
327 < const std::string LinearAtomVisitor::toString(){
328 <  char buffer[65535];
329 <  std::string result;
327 >  const std::string LinearAtomVisitor::toString(){
328 >    char buffer[65535];
329 >    std::string result;
330    
331 <  sprintf(buffer ,"------------------------------------------------------------------\n");
332 <  result += buffer;
331 >    sprintf(buffer ,"------------------------------------------------------------------\n");
332 >    result += buffer;
333  
334 <  sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
335 <  result += buffer;
334 >    sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
335 >    result += buffer;
336  
337 <  sprintf(buffer , "Visitor Description: Convert linear into 4 different atoms\n");
338 <  result += buffer;
337 >    sprintf(buffer , "Visitor Description: Convert linear into 4 different atoms\n");
338 >    result += buffer;
339  
340 <  sprintf(buffer ,"------------------------------------------------------------------\n");
341 <  result += buffer;
340 >    sprintf(buffer ,"------------------------------------------------------------------\n");
341 >    result += buffer;
342  
343 <  return result;
344 < }
343 >    return result;
344 >  }
345  
346 < //----------------------------------------------------------------------------//
346 >  bool GBLipidAtomVisitor::isGBLipidAtom(const std::string& atomType){
347 >    std::set<std::string>::iterator strIter;
348 >    strIter = GBLipidAtomType.find(atomType);
349  
350 < void DefaultAtomVisitor::visit(Atom *atom) {
350 >    return strIter != GBLipidAtomType.end() ? true : false;
351 >  }
352 >
353 >  void GBLipidAtomVisitor::visit(DirectionalAtom* datom){
354 >    std::vector<AtomInfo*> atoms;
355 >    //we need to convert linear into 4 different atoms
356 >    Vector3d c1(0.0, 0.0, -6.25);
357 >    Vector3d c2(0.0, 0.0, -2.1);
358 >    Vector3d c3(0.0, 0.0,  2.1);
359 >    Vector3d c4(0.0, 0.0,  6.25);
360 >    RotMat3x3d rotMatrix;
361 >    RotMat3x3d rotTrans;
362 >    AtomInfo* atomInfo;
363 >    Vector3d pos;
364 >    Vector3d newVec;
365 >    Quat4d q;
366 >    AtomData* atomData;
367 >    GenericData* data;
368 >    bool haveAtomData;
369 >
370 >    //if atom is not GBlipid atom, just skip it
371 >    if(!isGBLipidAtom(datom->getType()))
372 >      return;
373 >
374 >    data = datom->getPropertyByName("ATOMDATA");
375 >    if(data != NULL){
376 >      atomData = dynamic_cast<AtomData*>(data);  
377 >      if(atomData == NULL){
378 >        std::cerr << "can not get Atom Data from " << datom->getType() << std::endl;
379 >        atomData = new AtomData;
380 >        haveAtomData = false;      
381 >      } else {
382 >        haveAtomData = true;
383 >      }
384 >    } else {
385 >      atomData = new AtomData;
386 >      haveAtomData = false;
387 >    }
388 >  
389 >  
390 >    pos = datom->getPos();
391 >    q = datom->getQ();
392 >    rotMatrix = datom->getA();
393 >
394 >    // We need A^T to convert from body-fixed to space-fixed:  
395 >    rotTrans = rotMatrix.transpose();
396 >
397 >    newVec = rotTrans * c1;
398 >    atomInfo = new AtomInfo;
399 >    atomInfo->atomTypeName = "K";
400 >    atomInfo->pos[0] = pos[0] + newVec[0];
401 >    atomInfo->pos[1] = pos[1] + newVec[1];
402 >    atomInfo->pos[2] = pos[2] + newVec[2];
403 >    atomInfo->dipole[0] = 0.0;
404 >    atomInfo->dipole[1] = 0.0;
405 >    atomInfo->dipole[2] = 0.0;
406 >    atomData->addAtomInfo(atomInfo);
407 >
408 >    newVec = rotTrans * c2;
409 >    atomInfo = new AtomInfo;
410 >    atomInfo->atomTypeName = "K";
411 >    atomInfo->pos[0] = pos[0] + newVec[0];
412 >    atomInfo->pos[1] = pos[1] + newVec[1];
413 >    atomInfo->pos[2] = pos[2] + newVec[2];
414 >    atomInfo->dipole[0] = 0.0;
415 >    atomInfo->dipole[1] = 0.0;
416 >    atomInfo->dipole[2] = 0.0;
417 >    atomData->addAtomInfo(atomInfo);
418 >
419 >    newVec = rotTrans * c3;
420 >    atomInfo = new AtomInfo;
421 >    atomInfo->atomTypeName = "K";
422 >    atomInfo->pos[0] = pos[0] + newVec[0];
423 >    atomInfo->pos[1] = pos[1] + newVec[1];
424 >    atomInfo->pos[2] = pos[2] + newVec[2];
425 >    atomInfo->dipole[0] = 0.0;
426 >    atomInfo->dipole[1] = 0.0;
427 >    atomInfo->dipole[2] = 0.0;
428 >    atomData->addAtomInfo(atomInfo);
429 >
430 >    newVec = rotTrans * c4;
431 >    atomInfo = new AtomInfo;
432 >    atomInfo->atomTypeName = "K";
433 >    atomInfo->pos[0] = pos[0] + newVec[0];
434 >    atomInfo->pos[1] = pos[1] + newVec[1];
435 >    atomInfo->pos[2] = pos[2] + newVec[2];
436 >    atomInfo->dipole[0] = 0.0;
437 >    atomInfo->dipole[1] = 0.0;
438 >    atomInfo->dipole[2] = 0.0;
439 >    atomData->addAtomInfo(atomInfo);
440 >
441 >    //add atom data into atom's property
442 >
443 >    if(!haveAtomData){
444 >      atomData->setID("ATOMDATA");
445 >      datom->addProperty(atomData);
446 >    }
447 >
448 >    setVisited(datom);
449 >
450 >  }
451 >
452 >  const std::string GBLipidAtomVisitor::toString(){
453 >    char buffer[65535];
454 >    std::string result;
455 >  
456 >    sprintf(buffer ,"------------------------------------------------------------------\n");
457 >    result += buffer;
458 >
459 >    sprintf(buffer ,"Visitor name: %s\n", visitorName.c_str());
460 >    result += buffer;
461 >
462 >    sprintf(buffer , "Visitor Description: Convert GBlipid into 4 different K atoms\n");
463 >    result += buffer;
464 >
465 >    sprintf(buffer ,"------------------------------------------------------------------\n");
466 >    result += buffer;
467 >
468 >    return result;
469 >  }
470 >
471 >  //----------------------------------------------------------------------------//
472 >
473 >  void DefaultAtomVisitor::visit(Atom *atom) {
474      AtomData *atomData;
475      AtomInfo *atomInfo;
476      Vector3d  pos;
477  
478      if (isVisited(atom))
479 <        return;
479 >      return;
480  
481      atomInfo = new AtomInfo;
482  
# Line 356 | Line 484 | void DefaultAtomVisitor::visit(Atom *atom) {
484      atomData->setID("ATOMDATA");
485  
486      pos = atom->getPos();
487 <    atomInfo->AtomType = atom->getType();
487 >    atomInfo->atomTypeName = atom->getType();
488      atomInfo->pos[0] = pos[0];
489      atomInfo->pos[1] = pos[1];
490      atomInfo->pos[2] = pos[2];
# Line 369 | Line 497 | void DefaultAtomVisitor::visit(Atom *atom) {
497      atom->addProperty(atomData);
498  
499      setVisited(atom);
500 < }
500 >  }
501  
502 < void DefaultAtomVisitor::visit(DirectionalAtom *datom) {
502 >  void DefaultAtomVisitor::visit(DirectionalAtom *datom) {
503      AtomData *atomData;
504      AtomInfo *atomInfo;
505      Vector3d  pos;
506      Vector3d  u;
507  
508      if (isVisited(datom))
509 <        return;
509 >      return;
510  
511      pos = datom->getPos();
512 <    u = datom->getElectroFrame().getColumn(3);
512 >    u = datom->getElectroFrame().getColumn(2);
513  
514      atomData = new AtomData;
515      atomData->setID("ATOMDATA");
516      atomInfo = new AtomInfo;
517  
518 <    atomInfo->AtomType = datom->getType();
518 >    atomInfo->atomTypeName = datom->getType();
519      atomInfo->pos[0] = pos[0];
520      atomInfo->pos[1] = pos[1];
521      atomInfo->pos[2] = pos[2];
# Line 400 | Line 528 | void DefaultAtomVisitor::visit(DirectionalAtom *datom)
528      datom->addProperty(atomData);
529  
530      setVisited(datom);
531 < }
531 >  }
532  
533 < const std::string DefaultAtomVisitor::toString() {
533 >  const std::string DefaultAtomVisitor::toString() {
534      char   buffer[65535];
535      std::string result;
536  
# Line 422 | Line 550 | const std::string DefaultAtomVisitor::toString() {
550      result += buffer;
551  
552      return result;
553 < }
553 >  }
554   } //namespace oopse

Diff Legend

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