ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libmdtools/StuntDouble.cpp
(Generate patch)

Comparing trunk/OOPSE/libmdtools/StuntDouble.cpp (file contents):
Revision 1097 by gezelter, Mon Apr 12 20:32:20 2004 UTC vs.
Revision 1253 by gezelter, Tue Jun 8 16:49:46 2004 UTC

# Line 25 | Line 25
25  
26   */
27  
28 + StuntDouble::~StuntDouble(){
29 +  map<string, GenericData*>::iterator iter;
30 +
31 +  for(iter = properties.begin(); iter != properties.end(); ++iter ){
32 +    delete iter->second;
33 +    properties.erase(iter);
34 +  }
35 +    
36 + }
37 +
38   int StuntDouble::getObjType(){
39    return objType;
40   }
# Line 128 | Line 138 | void StuntDouble::setVel(double vel[3]){
138   }
139  
140   void StuntDouble::setVel(double vel[3]){
141 +
142    switch (objType)
143      {
144      case OT_ATOM :
# Line 273 | Line 284 | void StuntDouble::setJ(double j[3]){
284      }
285   }
286  
287 + void StuntDouble::getQ(double q[4] ){
288 +  switch (objType)
289 +    {
290 +    case OT_ATOM:
291 +      sprintf( painCave.errMsg,
292 +               "StuntDouble::getJ was called for a regular atom.\n"
293 +               "\tRegular Atoms don't have angular momentum.  Be smarter.\n");
294 +      painCave.isFatal = 0;
295 +      simError();
296 +      // Return zeros.
297 +      q[0] = 0;
298 +      q[1] = 0;
299 +      q[2] = 0;
300 +      q[3] = 0;
301 +      break;
302 +    case OT_DATOM:
303 +      ((DirectionalAtom*)this)->getQ(q);
304 +    break;
305 +    case OT_RIGIDBODY:
306 +      ((RigidBody*)this)->getQ(q);
307 +    break;
308 +    default:
309 +      sprintf( painCave.errMsg,
310 +               "Unrecognized ObjType (%d) in StuntDouble::getJ.\n",
311 +               objType );
312 +      painCave.isFatal = 1;
313 +      simError();    
314 +  }
315 + }
316 +
317 + void StuntDouble::setQ(double q[4] ){
318 +  switch (objType)
319 +    {
320 +    case OT_ATOM:
321 +      sprintf( painCave.errMsg,
322 +               "StuntDouble::setJ was called for a regular atom.\n"
323 +               "\tRegular Atoms don't have angular momentum.  Be smarter.\n");
324 +      painCave.isFatal = 1;
325 +      simError();
326 +      break;
327 +    case OT_DATOM:
328 +      ((DirectionalAtom*)this)->setJ(q);
329 +    break;
330 +    case OT_RIGIDBODY:
331 +      ((RigidBody*)this)->setJ(q);
332 +    break;
333 +    default:
334 +      sprintf( painCave.errMsg,
335 +               "Unrecognized ObjType (%d) in StuntDouble::setJ.\n",
336 +               objType );
337 +      painCave.isFatal = 1;
338 +      simError();    
339 +    }
340 + }
341   void StuntDouble::getTrq(double trq[3]){
342    switch (objType)
343      {
# Line 468 | Line 533 | void StuntDouble::getEulerAngles(double eulers[3]){
533        simError();    
534    }
535   }
536 +
537 + double StuntDouble::getZangle(){
538 +  switch (objType)
539 +    {
540 +    case OT_ATOM:
541 +      sprintf( painCave.errMsg,
542 +               "StuntDouble::getZangle was called for a regular atom.\n"
543 +               "\tRegular Atoms don't have zAngles.  Be smarter.\n");
544 +      painCave.isFatal = 0;
545 +      simError();
546 +      // Return zeros.
547 +      return 0;
548 +      break;
549 +    case OT_DATOM:
550 +      return ((DirectionalAtom*)this)->getZangle();
551 +    break;
552 +    case OT_RIGIDBODY:
553 +      return ((RigidBody*)this)->getZangle();
554 +    break;
555 +    default:
556 +      sprintf( painCave.errMsg,
557 +               "Unrecognized ObjType (%d) in StuntDouble::getZangle.\n",
558 +               objType );
559 +      painCave.isFatal = 1;
560 +      simError();    
561 +      return 0;
562 +  }
563 + }
564 +
565 + void StuntDouble::setZangle(double zAngle){
566 +  switch (objType)
567 +    {
568 +    case OT_ATOM:
569 +      sprintf( painCave.errMsg,
570 +               "StuntDouble::setZangle was called for a regular atom.\n"
571 +               "\tRegular Atoms don't have zAngles.  Be smarter.\n");
572 +      painCave.isFatal = 1;
573 +      simError();
574 +      break;
575 +    case OT_DATOM:
576 +      ((DirectionalAtom*)this)->setZangle(zAngle);
577 +    break;
578 +    case OT_RIGIDBODY:
579 +      ((RigidBody*)this)->setZangle(zAngle);
580 +    break;
581 +    default:
582 +      sprintf( painCave.errMsg,
583 +               "Unrecognized ObjType (%d) in StuntDouble::setZangle.\n",
584 +               objType );
585 +      painCave.isFatal = 1;
586 +      simError();    
587 +    }
588 + }
589 +
590 + void StuntDouble::addZangle(double zAngle){
591 +  switch (objType)
592 +    {
593 +    case OT_ATOM:
594 +      sprintf( painCave.errMsg,
595 +               "StuntDouble::addZangle was called for a regular atom.\n"
596 +               "\tRegular Atoms don't have zAngles.  Be smarter.\n");
597 +      painCave.isFatal = 1;
598 +      simError();
599 +      break;
600 +    case OT_DATOM:
601 +      ((DirectionalAtom*)this)->addZangle(zAngle);
602 +    break;
603 +    case OT_RIGIDBODY:
604 +      ((RigidBody*)this)->addZangle(zAngle);
605 +    break;
606 +    default:
607 +      sprintf( painCave.errMsg,
608 +               "Unrecognized ObjType (%d) in StuntDouble::addZangle.\n",
609 +               objType );
610 +      painCave.isFatal = 1;
611 +      simError();    
612 +    }
613 + }
614 +
615 + void StuntDouble::addProperty(GenericData* data){
616 +  map<string, GenericData*>::iterator result;
617 +  result = properties.find(data->getID());
618 +  
619 +  //we can't simply use  properties[prop->getID()] = prop,
620 +  //it will cause memory leak if we already contain a propery which has the same name of prop
621 +  
622 +  if(result != properties.end()){
623 +    delete (*result).second;
624 +    (*result).second = data;      
625 +  }
626 +  else
627 +    properties[data->getID()] = data;
628 +
629 +  
630 + }
631 + void StuntDouble::removeProperty(const string& propName){
632 +  map<string, GenericData*>::iterator result;
633 +    
634 +  result = properties.find(propName);
635 +  
636 +  if(result != properties.end()){
637 +    delete result->second;
638 +    properties.erase(result);
639 +    
640 +  }
641 +  
642 + }
643 + GenericData* StuntDouble::getProperty(const string& propName){
644 +  map<string, GenericData*>::iterator result;
645 +  
646 +  
647 +  result = properties.find(propName);
648 +  
649 +  if(result != properties.end())
650 +    return (*result).second;  
651 +  else  
652 +    return NULL;    
653 + }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines