OOPSE/libmdtools/StuntDouble.cpp

#include "StuntDouble.hpp"
#include "Atom.hpp"
#include "DirectionalAtom.hpp"
#include "RigidBody.hpp"
#include "simError.h"

/*   
        "Don't move, or you're dead! Stand up! Captain, we've got them!"
     
        "Spectacular stunt, my friends, but all for naught. Turn around
         please. Ha. What a pity. What a pity. So, Princess, you thought
         you could outwit the imperious forces of...."

        "You idiots! These are not them. You've captured their stunt
         doubles! Search the area. Find them! Find them!"

      StuntDouble is a very strange idea.  A StuntDouble stands in for
      some object that can be manipulated by the Integrators or
      Minimizers.  Some of the manipulable objects are Atoms, some are
      DirectionalAtoms, and some are RigidBodies.  StuntDouble
      provides an interface for the Integrators and Minimizers to use,
      and does some preliminary sanity checking so that the program
      doesn't try to do something stupid like torque an Atom.  (The
      quotes above are from Spaceballs...)

*/

StuntDouble::~StuntDouble(){
  map<string, GenericData*>::iterator iter;

  for(iter = properties.begin(); iter != properties.end(); ++iter ){
    delete iter->second;
    properties.erase(iter);
  }
    
}

int StuntDouble::getObjType(){
  return objType;
}

double StuntDouble::getMass(){
  switch (objType)
    {
    case OT_ATOM :
    case OT_DATOM:      
      return ((Atom*)this)->getMass();
      break;
    case OT_RIGIDBODY:
      return ((RigidBody*)this)->getMass();
      break;      
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::getMass.\n",
               objType );
      painCave.isFatal = 1;
      simError();     
      return 0.0;
    }
}


void StuntDouble::getPos(double pos[3]){
  switch (objType)
    {
    case OT_ATOM :
    case OT_DATOM:      
      ((Atom*)this)->getPos(pos);
      break;
    case OT_RIGIDBODY:
      ((RigidBody*)this)->getPos(pos);
      break;      
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::getPos.\n",
               objType );
      painCave.isFatal = 1;
      simError();     
    }  
}

void StuntDouble::getVel(double vel[3]){
  switch (objType)
    {
    case OT_ATOM :
    case OT_DATOM:      
      ((Atom*)this)->getVel(vel);
      break;
    case OT_RIGIDBODY:
      ((RigidBody*)this)->getVel(vel);
      break;      
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::getVel.\n",
               objType );
      painCave.isFatal = 1;
      simError();     
    }  
}

void StuntDouble::getFrc(double frc[3]){
  switch (objType)
    {
    case OT_ATOM :
    case OT_DATOM:      
      ((Atom*)this)->getFrc(frc);
      break;
    case OT_RIGIDBODY:
      ((RigidBody*)this)->getFrc(frc);
      break;      
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::getFrc.\n",
               objType );
      painCave.isFatal = 1;
      simError();     
    }  
}


void StuntDouble::setPos(double pos[3]){
  switch (objType)
    {
    case OT_ATOM :
    case OT_DATOM:      
      ((Atom*)this)->setPos(pos);
      break;
    case OT_RIGIDBODY:
      ((RigidBody*)this)->setPos(pos);
      break;      
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::setPos.\n",
               objType );
      painCave.isFatal = 1;
      simError();     
    }  
}

void StuntDouble::setVel(double vel[3]){

  switch (objType)
    {
    case OT_ATOM :
    case OT_DATOM:      
      ((Atom*)this)->setVel(vel);
      break;
    case OT_RIGIDBODY:
      ((RigidBody*)this)->setVel(vel);
      break;      
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::setVel.\n",
               objType );
      painCave.isFatal = 1;
      simError();     
    }  
}

void StuntDouble::setFrc(double frc[3]){

  switch (objType)
    {
    case OT_ATOM :
    case OT_DATOM:      
      ((Atom*)this)->setFrc(frc);
      break;
    case OT_RIGIDBODY:
      ((RigidBody*)this)->setFrc(frc);
      break;      
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::setFrc.\n",
               objType );
      painCave.isFatal = 1;
      simError();     
    }  
}

void StuntDouble::addFrc(double frc[3]){
  switch (objType)
    {
    case OT_ATOM :
    case OT_DATOM:      
      ((Atom*)this)->addFrc(frc);
      break;
    case OT_RIGIDBODY:
      ((RigidBody*)this)->addFrc(frc);
      break;      
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::addFrc.\n",
               objType );
      painCave.isFatal = 1;
      simError();     
    }  
}

void StuntDouble::getA(double A[3][3]){
  switch (objType) 
    {
    case OT_ATOM:
      sprintf( painCave.errMsg,
               "StuntDouble::getA was called for a regular atom.\n"
               "\tRegular Atoms don't have rotation matrices.  Be smarter.\n");
      painCave.isFatal = 0;
      simError();
      // Return unit matrix
      A[0][0] = 1;  A[0][1] = 0;  A[0][2] = 0;
      A[1][0] = 0;  A[1][1] = 1;  A[1][2] = 0;
      A[2][0] = 0;  A[2][1] = 0;  A[2][2] = 1;
      break;
    case OT_DATOM:
      ((DirectionalAtom*)this)->getA(A);
    break;
    case OT_RIGIDBODY:
      ((RigidBody*)this)->getA(A);
    break;
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::getA.\n",
               objType );
      painCave.isFatal = 1;
      simError();     
  }
}

void StuntDouble::setA(double A[3][3]){
  switch (objType) 
    {
    case OT_ATOM:
      sprintf( painCave.errMsg,
               "StuntDouble::setA was called for a regular atom.\n"
               "\tRegular Atoms don't have rotation matrices.  Be smarter.\n");
      painCave.isFatal = 1;
      simError();
      break;
    case OT_DATOM:
      ((DirectionalAtom*)this)->setA(A);
    break;
    case OT_RIGIDBODY:
      ((RigidBody*)this)->setA(A);
    break;
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::setA.\n",
               objType );
      painCave.isFatal = 1;
      simError();     
    }
}

void StuntDouble::getJ(double j[3]){
  switch (objType) 
    {
    case OT_ATOM:
      sprintf( painCave.errMsg,
               "StuntDouble::getJ was called for a regular atom.\n"
               "\tRegular Atoms don't have angular momentum.  Be smarter.\n");
      painCave.isFatal = 0;
      simError();
      // Return zeros.
      j[0] = 0;
      j[1] = 0;
      j[2] = 0;
      break;
    case OT_DATOM:
      ((DirectionalAtom*)this)->getJ(j);
    break;
    case OT_RIGIDBODY:
      ((RigidBody*)this)->getJ(j);
    break;
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::getJ.\n",
               objType );
      painCave.isFatal = 1;
      simError();     
  }
}

void StuntDouble::setJ(double j[3]){
  switch (objType) 
    {
    case OT_ATOM:
      sprintf( painCave.errMsg,
               "StuntDouble::setJ was called for a regular atom.\n"
               "\tRegular Atoms don't have angular momentum.  Be smarter.\n");
      painCave.isFatal = 1;
      simError();
      break;
    case OT_DATOM:
      ((DirectionalAtom*)this)->setJ(j);
    break;
    case OT_RIGIDBODY:
      ((RigidBody*)this)->setJ(j);
    break;
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::setJ.\n",
               objType );
      painCave.isFatal = 1;
      simError();     
    }
}

void StuntDouble::getQ(double q[4] ){
  switch (objType) 
    {
    case OT_ATOM:
      sprintf( painCave.errMsg,
               "StuntDouble::getJ was called for a regular atom.\n"
               "\tRegular Atoms don't have angular momentum.  Be smarter.\n");
      painCave.isFatal = 0;
      simError();
      // Return zeros.
      q[0] = 0;
      q[1] = 0;
      q[2] = 0;
      q[3] = 0;
      break;
    case OT_DATOM:
      ((DirectionalAtom*)this)->getQ(q);
    break;
    case OT_RIGIDBODY:
      ((RigidBody*)this)->getQ(q);
    break;
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::getJ.\n",
               objType );
      painCave.isFatal = 1;
      simError();     
  }
}

void StuntDouble::setQ(double q[4] ){
  switch (objType) 
    {
    case OT_ATOM:
      sprintf( painCave.errMsg,
               "StuntDouble::setJ was called for a regular atom.\n"
               "\tRegular Atoms don't have angular momentum.  Be smarter.\n");
      painCave.isFatal = 1;
      simError();
      break;
    case OT_DATOM:
      ((DirectionalAtom*)this)->setJ(q);
    break;
    case OT_RIGIDBODY:
      ((RigidBody*)this)->setJ(q);
    break;
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::setJ.\n",
               objType );
      painCave.isFatal = 1;
      simError();     
    }
}
void StuntDouble::getTrq(double trq[3]){
  switch (objType) 
    {
    case OT_ATOM:
      sprintf( painCave.errMsg,
               "StuntDouble::getTrq was called for a regular atom.\n"
               "\tRegular Atoms don't have torques.  Be smarter.\n");
      painCave.isFatal = 0;
      simError();
      // Return zeros.
      trq[0] = 0;
      trq[1] = 0;
      trq[2] = 0;
      break;
    case OT_DATOM:
      ((DirectionalAtom*)this)->getTrq(trq);
    break;
    case OT_RIGIDBODY:
      ((RigidBody*)this)->getTrq(trq);
    break;
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::getTrq.\n",
               objType );
      painCave.isFatal = 1;
      simError();     
  }
}

void StuntDouble::setTrq(double trq[3]){
  switch (objType) 
    {
    case OT_ATOM:
      sprintf( painCave.errMsg,
               "StuntDouble::setTrq was called for a regular atom.\n"
               "\tRegular Atoms don't have torques.  Be smarter.\n");
      painCave.isFatal = 1;
      simError();
      break;
    case OT_DATOM:
      ((DirectionalAtom*)this)->setTrq(trq);
    break;
    case OT_RIGIDBODY:
      ((RigidBody*)this)->setTrq(trq);
    break;
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::addTrq.\n",
               objType );
      painCave.isFatal = 1;
      simError();     
    }
}

void StuntDouble::addTrq(double trq[3]){
  switch (objType) 
    {
    case OT_ATOM:
      sprintf( painCave.errMsg,
               "StuntDouble::addTrq was called for a regular atom.\n"
               "\tRegular Atoms don't have torques.  Be smarter.\n");
      painCave.isFatal = 1;
      simError();
      break;
    case OT_DATOM:
      ((DirectionalAtom*)this)->addTrq(trq);
    break;
    case OT_RIGIDBODY:
      ((RigidBody*)this)->addTrq(trq);
    break;
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::addTrq.\n",
               objType );
      painCave.isFatal = 1;
      simError();     
    }
}

void StuntDouble::getI(double I[3][3]){
  switch (objType) 
    {
    case OT_ATOM:
      sprintf( painCave.errMsg,
               "StuntDouble::getI was called for a regular atom.\n"
               "\tRegular Atoms don't have moments of inertia.  Be smarter.\n");
      painCave.isFatal = 0;
      simError();
      // Return zero matrix
      I[0][0] = 0;  I[0][1] = 0;  I[0][2] = 0;
      I[1][0] = 0;  I[1][1] = 0;  I[1][2] = 0;
      I[2][0] = 0;  I[2][1] = 0;  I[2][2] = 0;
      break;
    case OT_DATOM:
      ((DirectionalAtom*)this)->getI(I);
    break;
    case OT_RIGIDBODY:
      ((RigidBody*)this)->getI(I);
    break;
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::getI.\n",
               objType );
      painCave.isFatal = 1;
      simError();     
  }
}

void StuntDouble::lab2Body(double vec[3]){
  switch (objType) 
    {
    case OT_ATOM:
      sprintf( painCave.errMsg,
               "StuntDouble::lab2Body was called for a regular atom.\n"
               "\tRegular Atoms don't have reference frames.  Be smarter.\n");
      painCave.isFatal = 0;
      simError();
      break;
    case OT_DATOM:
      ((DirectionalAtom*)this)->lab2Body(vec);
    break;
    case OT_RIGIDBODY:
      ((RigidBody*)this)->lab2Body(vec);
    break;
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::lab2Body.\n",
               objType );
      painCave.isFatal = 1;
      simError();     
  }
}

void StuntDouble::getGrad(double grad[6]){
  double frc[3];

  switch (objType) 
    {
    case OT_ATOM:
      sprintf( painCave.errMsg,
               "StuntDouble::getGrad was called for a regular atom.\n"
               "\tRegular Atoms don't have 6 coordinates.  Be smarter.\n");
      painCave.isFatal = 0;
      simError();
      ((Atom*)this)->getFrc(frc);
      grad[0] = -frc[0];
      grad[1] = -frc[1];
      grad[2] = -frc[2];
      grad[3] = 0.0;
      grad[4] = 0.0;
      grad[5] = 0.0;
      break;
    case OT_DATOM:
      ((DirectionalAtom*)this)->getGrad(grad);
    break;
    case OT_RIGIDBODY:
      ((RigidBody*)this)->getGrad(grad);
    break;
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::getGrad.\n",
               objType );
      painCave.isFatal = 1;
      simError();     
  }
}

void StuntDouble::setEuler(double phi, double theta, double psi){
  switch (objType) 
    {
    case OT_ATOM:
      sprintf( painCave.errMsg,
               "StuntDouble::setEuler was called for a regular atom.\n"
               "\tRegular Atoms don't have Euler Angles.  Be smarter.\n");
      painCave.isFatal = 1;
      simError();
      break;
    case OT_DATOM:
      ((DirectionalAtom*)this)->setEuler(phi, theta, psi);
    break;
    case OT_RIGIDBODY:
      ((RigidBody*)this)->setEuler(phi, theta, psi);
    break;
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::setA.\n",
               objType );
      painCave.isFatal = 1;
      simError();     
    }
}

void StuntDouble::getEulerAngles(double eulers[3]){
  switch (objType) 
    {
    case OT_ATOM:
      sprintf( painCave.errMsg,
               "StuntDouble::getEulerAngles was called for a regular atom.\n"
               "\tRegular Atoms don't have Euler angles.  Be smarter.\n");
      painCave.isFatal = 0;
      simError();
      // Return zeros.
      eulers[0] = 0;
      eulers[1] = 0;
      eulers[2] = 0;
      break;
    case OT_DATOM:
      ((DirectionalAtom*)this)->getEulerAngles(eulers);
    break;
    case OT_RIGIDBODY:
      ((RigidBody*)this)->getEulerAngles(eulers);
    break;
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::getEulerAngles.\n",
               objType );
      painCave.isFatal = 1;
      simError();     
  }
}

double StuntDouble::getZangle(){
  switch (objType) 
    {
    case OT_ATOM:
      sprintf( painCave.errMsg,
               "StuntDouble::getZangle was called for a regular atom.\n"
               "\tRegular Atoms don't have zAngles.  Be smarter.\n");
      painCave.isFatal = 0;
      simError();
      // Return zeros.
      return 0;
      break;
    case OT_DATOM:
      return ((DirectionalAtom*)this)->getZangle();
    break;
    case OT_RIGIDBODY:
      return ((RigidBody*)this)->getZangle();
    break;
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::getZangle.\n",
               objType );
      painCave.isFatal = 1;
      simError();    
      return 0;
  }
}

void StuntDouble::setZangle(double zAngle){
  switch (objType) 
    {
    case OT_ATOM:
      sprintf( painCave.errMsg,
               "StuntDouble::setZangle was called for a regular atom.\n"
               "\tRegular Atoms don't have zAngles.  Be smarter.\n");
      painCave.isFatal = 1;
      simError();
      break;
    case OT_DATOM:
      ((DirectionalAtom*)this)->setZangle(zAngle);
    break;
    case OT_RIGIDBODY:
      ((RigidBody*)this)->setZangle(zAngle);
    break;
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::setZangle.\n",
               objType );
      painCave.isFatal = 1;
      simError();     
    }
}

void StuntDouble::addZangle(double zAngle){
  switch (objType) 
    {
    case OT_ATOM:
      sprintf( painCave.errMsg,
               "StuntDouble::addZangle was called for a regular atom.\n"
               "\tRegular Atoms don't have zAngles.  Be smarter.\n");
      painCave.isFatal = 1;
      simError();
      break;
    case OT_DATOM:
      ((DirectionalAtom*)this)->addZangle(zAngle);
    break;
    case OT_RIGIDBODY:
      ((RigidBody*)this)->addZangle(zAngle);
    break;
    default:
      sprintf( painCave.errMsg,
               "Unrecognized ObjType (%d) in StuntDouble::addZangle.\n",
               objType );
      painCave.isFatal = 1;
      simError();     
    }
}

void StuntDouble::addProperty(GenericData* data){
  map<string, GenericData*>::iterator result;
  result = properties.find(data->getID());
  
  //we can't simply use  properties[prop->getID()] = prop,
  //it will cause memory leak if we already contain a propery which has the same name of prop
  
  if(result != properties.end()){
    delete (*result).second;
    (*result).second = data;      
  }
  else
    properties[data->getID()] = data;

  
}
void StuntDouble::removeProperty(const string& propName){
  map<string, GenericData*>::iterator result;
    
  result = properties.find(propName);
  
  if(result != properties.end()){
    delete result->second;
    properties.erase(result);
    
  }
  
}
GenericData* StuntDouble::getProperty(const string& propName){
  map<string, GenericData*>::iterator result;
  
  
  result = properties.find(propName);
  
  if(result != properties.end()) 
    return (*result).second;  
  else   
    return NULL;    
}
Revision:	1452
Committed:	Mon Aug 23 15:11:36 2004 UTC (19 years, 10 months ago) by tim
File size:	18187 byte(s)
Log Message:	* empty log message *
#	User	Rev	Content
1	gezelter	1097	#include "StuntDouble.hpp"
2			#include "Atom.hpp"
3			#include "DirectionalAtom.hpp"
4			#include "RigidBody.hpp"
5			#include "simError.h"
6
7			/*
8			"Don't move, or you're dead! Stand up! Captain, we've got them!"
9
10			"Spectacular stunt, my friends, but all for naught. Turn around
11			please. Ha. What a pity. What a pity. So, Princess, you thought
12			you could outwit the imperious forces of...."
13
14			"You idiots! These are not them. You've captured their stunt
15			doubles! Search the area. Find them! Find them!"
16
17			StuntDouble is a very strange idea. A StuntDouble stands in for
18			some object that can be manipulated by the Integrators or
19			Minimizers. Some of the manipulable objects are Atoms, some are
20			DirectionalAtoms, and some are RigidBodies. StuntDouble
21			provides an interface for the Integrators and Minimizers to use,
22			and does some preliminary sanity checking so that the program
23			doesn't try to do something stupid like torque an Atom. (The
24			quotes above are from Spaceballs...)
25
26			*/
27
28	tim	1234	StuntDouble::~StuntDouble(){
29			map<string, GenericData*>::iterator iter;
30
31	gezelter	1250	for(iter = properties.begin(); iter != properties.end(); ++iter ){
32	tim	1234	delete iter->second;
33	gezelter	1250	properties.erase(iter);
34	tim	1234	}
35
36			}
37
38	gezelter	1097	int StuntDouble::getObjType(){
39			return objType;
40			}
41
42			double StuntDouble::getMass(){
43			switch (objType)
44			{
45			case OT_ATOM :
46			case OT_DATOM:
47			return ((Atom*)this)->getMass();
48			break;
49			case OT_RIGIDBODY:
50			return ((RigidBody*)this)->getMass();
51			break;
52			default:
53			sprintf( painCave.errMsg,
54			"Unrecognized ObjType (%d) in StuntDouble::getMass.\n",
55			objType );
56			painCave.isFatal = 1;
57			simError();
58			return 0.0;
59			}
60			}
61
62
63			void StuntDouble::getPos(double pos[3]){
64			switch (objType)
65			{
66			case OT_ATOM :
67			case OT_DATOM:
68			((Atom*)this)->getPos(pos);
69			break;
70			case OT_RIGIDBODY:
71			((RigidBody*)this)->getPos(pos);
72			break;
73			default:
74			sprintf( painCave.errMsg,
75			"Unrecognized ObjType (%d) in StuntDouble::getPos.\n",
76			objType );
77			painCave.isFatal = 1;
78			simError();
79			}
80			}
81
82			void StuntDouble::getVel(double vel[3]){
83			switch (objType)
84			{
85			case OT_ATOM :
86			case OT_DATOM:
87			((Atom*)this)->getVel(vel);
88			break;
89			case OT_RIGIDBODY:
90			((RigidBody*)this)->getVel(vel);
91			break;
92			default:
93			sprintf( painCave.errMsg,
94			"Unrecognized ObjType (%d) in StuntDouble::getVel.\n",
95			objType );
96			painCave.isFatal = 1;
97			simError();
98			}
99			}
100
101			void StuntDouble::getFrc(double frc[3]){
102			switch (objType)
103			{
104			case OT_ATOM :
105			case OT_DATOM:
106			((Atom*)this)->getFrc(frc);
107			break;
108			case OT_RIGIDBODY:
109			((RigidBody*)this)->getFrc(frc);
110			break;
111			default:
112			sprintf( painCave.errMsg,
113			"Unrecognized ObjType (%d) in StuntDouble::getFrc.\n",
114			objType );
115			painCave.isFatal = 1;
116			simError();
117			}
118			}
119
120
121			void StuntDouble::setPos(double pos[3]){
122			switch (objType)
123			{
124			case OT_ATOM :
125			case OT_DATOM:
126			((Atom*)this)->setPos(pos);
127			break;
128			case OT_RIGIDBODY:
129			((RigidBody*)this)->setPos(pos);
130			break;
131			default:
132			sprintf( painCave.errMsg,
133			"Unrecognized ObjType (%d) in StuntDouble::setPos.\n",
134			objType );
135			painCave.isFatal = 1;
136			simError();
137			}
138			}
139
140			void StuntDouble::setVel(double vel[3]){
141	gezelter	1253
142	gezelter	1097	switch (objType)
143			{
144			case OT_ATOM :
145			case OT_DATOM:
146			((Atom*)this)->setVel(vel);
147			break;
148			case OT_RIGIDBODY:
149			((RigidBody*)this)->setVel(vel);
150			break;
151			default:
152			sprintf( painCave.errMsg,
153			"Unrecognized ObjType (%d) in StuntDouble::setVel.\n",
154			objType );
155			painCave.isFatal = 1;
156			simError();
157			}
158			}
159
160	tim	1452	void StuntDouble::setFrc(double frc[3]){
161
162			switch (objType)
163			{
164			case OT_ATOM :
165			case OT_DATOM:
166			((Atom*)this)->setFrc(frc);
167			break;
168			case OT_RIGIDBODY:
169			((RigidBody*)this)->setFrc(frc);
170			break;
171			default:
172			sprintf( painCave.errMsg,
173			"Unrecognized ObjType (%d) in StuntDouble::setFrc.\n",
174			objType );
175			painCave.isFatal = 1;
176			simError();
177			}
178			}
179
180	gezelter	1097	void StuntDouble::addFrc(double frc[3]){
181			switch (objType)
182			{
183			case OT_ATOM :
184			case OT_DATOM:
185			((Atom*)this)->addFrc(frc);
186			break;
187			case OT_RIGIDBODY:
188			((RigidBody*)this)->addFrc(frc);
189			break;
190			default:
191			sprintf( painCave.errMsg,
192			"Unrecognized ObjType (%d) in StuntDouble::addFrc.\n",
193			objType );
194			painCave.isFatal = 1;
195			simError();
196			}
197			}
198
199			void StuntDouble::getA(double A[3][3]){
200			switch (objType)
201			{
202			case OT_ATOM:
203			sprintf( painCave.errMsg,
204			"StuntDouble::getA was called for a regular atom.\n"
205			"\tRegular Atoms don't have rotation matrices. Be smarter.\n");
206			painCave.isFatal = 0;
207			simError();
208			// Return unit matrix
209			A[0][0] = 1; A[0][1] = 0; A[0][2] = 0;
210			A[1][0] = 0; A[1][1] = 1; A[1][2] = 0;
211			A[2][0] = 0; A[2][1] = 0; A[2][2] = 1;
212			break;
213			case OT_DATOM:
214			((DirectionalAtom*)this)->getA(A);
215			break;
216			case OT_RIGIDBODY:
217			((RigidBody*)this)->getA(A);
218			break;
219			default:
220			sprintf( painCave.errMsg,
221			"Unrecognized ObjType (%d) in StuntDouble::getA.\n",
222			objType );
223			painCave.isFatal = 1;
224			simError();
225			}
226			}
227
228			void StuntDouble::setA(double A[3][3]){
229			switch (objType)
230			{
231			case OT_ATOM:
232			sprintf( painCave.errMsg,
233			"StuntDouble::setA was called for a regular atom.\n"
234			"\tRegular Atoms don't have rotation matrices. Be smarter.\n");
235			painCave.isFatal = 1;
236			simError();
237			break;
238			case OT_DATOM:
239			((DirectionalAtom*)this)->setA(A);
240			break;
241			case OT_RIGIDBODY:
242			((RigidBody*)this)->setA(A);
243			break;
244			default:
245			sprintf( painCave.errMsg,
246			"Unrecognized ObjType (%d) in StuntDouble::setA.\n",
247			objType );
248			painCave.isFatal = 1;
249			simError();
250			}
251			}
252
253			void StuntDouble::getJ(double j[3]){
254			switch (objType)
255			{
256			case OT_ATOM:
257			sprintf( painCave.errMsg,
258			"StuntDouble::getJ was called for a regular atom.\n"
259			"\tRegular Atoms don't have angular momentum. Be smarter.\n");
260			painCave.isFatal = 0;
261			simError();
262			// Return zeros.
263			j[0] = 0;
264			j[1] = 0;
265			j[2] = 0;
266			break;
267			case OT_DATOM:
268			((DirectionalAtom*)this)->getJ(j);
269			break;
270			case OT_RIGIDBODY:
271			((RigidBody*)this)->getJ(j);
272			break;
273			default:
274			sprintf( painCave.errMsg,
275			"Unrecognized ObjType (%d) in StuntDouble::getJ.\n",
276			objType );
277			painCave.isFatal = 1;
278			simError();
279			}
280			}
281
282			void StuntDouble::setJ(double j[3]){
283			switch (objType)
284			{
285			case OT_ATOM:
286			sprintf( painCave.errMsg,
287			"StuntDouble::setJ was called for a regular atom.\n"
288			"\tRegular Atoms don't have angular momentum. Be smarter.\n");
289			painCave.isFatal = 1;
290			simError();
291			break;
292			case OT_DATOM:
293			((DirectionalAtom*)this)->setJ(j);
294			break;
295			case OT_RIGIDBODY:
296			((RigidBody*)this)->setJ(j);
297			break;
298			default:
299			sprintf( painCave.errMsg,
300			"Unrecognized ObjType (%d) in StuntDouble::setJ.\n",
301			objType );
302			painCave.isFatal = 1;
303			simError();
304			}
305			}
306
307	tim	1108	void StuntDouble::getQ(double q[4] ){
308			switch (objType)
309			{
310			case OT_ATOM:
311			sprintf( painCave.errMsg,
312			"StuntDouble::getJ was called for a regular atom.\n"
313			"\tRegular Atoms don't have angular momentum. Be smarter.\n");
314			painCave.isFatal = 0;
315			simError();
316			// Return zeros.
317			q[0] = 0;
318			q[1] = 0;
319			q[2] = 0;
320			q[3] = 0;
321			break;
322			case OT_DATOM:
323			((DirectionalAtom*)this)->getQ(q);
324			break;
325			case OT_RIGIDBODY:
326			((RigidBody*)this)->getQ(q);
327			break;
328			default:
329			sprintf( painCave.errMsg,
330			"Unrecognized ObjType (%d) in StuntDouble::getJ.\n",
331			objType );
332			painCave.isFatal = 1;
333			simError();
334			}
335			}
336
337			void StuntDouble::setQ(double q[4] ){
338			switch (objType)
339			{
340			case OT_ATOM:
341			sprintf( painCave.errMsg,
342			"StuntDouble::setJ was called for a regular atom.\n"
343			"\tRegular Atoms don't have angular momentum. Be smarter.\n");
344			painCave.isFatal = 1;
345			simError();
346			break;
347			case OT_DATOM:
348			((DirectionalAtom*)this)->setJ(q);
349			break;
350			case OT_RIGIDBODY:
351			((RigidBody*)this)->setJ(q);
352			break;
353			default:
354			sprintf( painCave.errMsg,
355			"Unrecognized ObjType (%d) in StuntDouble::setJ.\n",
356			objType );
357			painCave.isFatal = 1;
358			simError();
359			}
360			}
361	gezelter	1097	void StuntDouble::getTrq(double trq[3]){
362			switch (objType)
363			{
364			case OT_ATOM:
365			sprintf( painCave.errMsg,
366			"StuntDouble::getTrq was called for a regular atom.\n"
367			"\tRegular Atoms don't have torques. Be smarter.\n");
368			painCave.isFatal = 0;
369			simError();
370			// Return zeros.
371			trq[0] = 0;
372			trq[1] = 0;
373			trq[2] = 0;
374			break;
375			case OT_DATOM:
376			((DirectionalAtom*)this)->getTrq(trq);
377			break;
378			case OT_RIGIDBODY:
379			((RigidBody*)this)->getTrq(trq);
380			break;
381			default:
382			sprintf( painCave.errMsg,
383			"Unrecognized ObjType (%d) in StuntDouble::getTrq.\n",
384			objType );
385			painCave.isFatal = 1;
386			simError();
387			}
388			}
389
390	tim	1452	void StuntDouble::setTrq(double trq[3]){
391			switch (objType)
392			{
393			case OT_ATOM:
394			sprintf( painCave.errMsg,
395			"StuntDouble::setTrq was called for a regular atom.\n"
396			"\tRegular Atoms don't have torques. Be smarter.\n");
397			painCave.isFatal = 1;
398			simError();
399			break;
400			case OT_DATOM:
401			((DirectionalAtom*)this)->setTrq(trq);
402			break;
403			case OT_RIGIDBODY:
404			((RigidBody*)this)->setTrq(trq);
405			break;
406			default:
407			sprintf( painCave.errMsg,
408			"Unrecognized ObjType (%d) in StuntDouble::addTrq.\n",
409			objType );
410			painCave.isFatal = 1;
411			simError();
412			}
413			}
414
415	gezelter	1097	void StuntDouble::addTrq(double trq[3]){
416			switch (objType)
417			{
418			case OT_ATOM:
419			sprintf( painCave.errMsg,
420			"StuntDouble::addTrq was called for a regular atom.\n"
421			"\tRegular Atoms don't have torques. Be smarter.\n");
422			painCave.isFatal = 1;
423			simError();
424			break;
425			case OT_DATOM:
426			((DirectionalAtom*)this)->addTrq(trq);
427			break;
428			case OT_RIGIDBODY:
429			((RigidBody*)this)->addTrq(trq);
430			break;
431			default:
432			sprintf( painCave.errMsg,
433			"Unrecognized ObjType (%d) in StuntDouble::addTrq.\n",
434			objType );
435			painCave.isFatal = 1;
436			simError();
437			}
438			}
439
440			void StuntDouble::getI(double I[3][3]){
441			switch (objType)
442			{
443			case OT_ATOM:
444			sprintf( painCave.errMsg,
445			"StuntDouble::getI was called for a regular atom.\n"
446			"\tRegular Atoms don't have moments of inertia. Be smarter.\n");
447			painCave.isFatal = 0;
448			simError();
449			// Return zero matrix
450			I[0][0] = 0; I[0][1] = 0; I[0][2] = 0;
451			I[1][0] = 0; I[1][1] = 0; I[1][2] = 0;
452			I[2][0] = 0; I[2][1] = 0; I[2][2] = 0;
453			break;
454			case OT_DATOM:
455			((DirectionalAtom*)this)->getI(I);
456			break;
457			case OT_RIGIDBODY:
458			((RigidBody*)this)->getI(I);
459			break;
460			default:
461			sprintf( painCave.errMsg,
462			"Unrecognized ObjType (%d) in StuntDouble::getI.\n",
463			objType );
464			painCave.isFatal = 1;
465			simError();
466			}
467			}
468
469			void StuntDouble::lab2Body(double vec[3]){
470			switch (objType)
471			{
472			case OT_ATOM:
473			sprintf( painCave.errMsg,
474			"StuntDouble::lab2Body was called for a regular atom.\n"
475			"\tRegular Atoms don't have reference frames. Be smarter.\n");
476			painCave.isFatal = 0;
477			simError();
478			break;
479			case OT_DATOM:
480			((DirectionalAtom*)this)->lab2Body(vec);
481			break;
482			case OT_RIGIDBODY:
483			((RigidBody*)this)->lab2Body(vec);
484			break;
485			default:
486			sprintf( painCave.errMsg,
487			"Unrecognized ObjType (%d) in StuntDouble::lab2Body.\n",
488			objType );
489			painCave.isFatal = 1;
490			simError();
491			}
492			}
493
494			void StuntDouble::getGrad(double grad[6]){
495			double frc[3];
496
497			switch (objType)
498			{
499			case OT_ATOM:
500			sprintf( painCave.errMsg,
501			"StuntDouble::getGrad was called for a regular atom.\n"
502			"\tRegular Atoms don't have 6 coordinates. Be smarter.\n");
503			painCave.isFatal = 0;
504			simError();
505			((Atom*)this)->getFrc(frc);
506			grad[0] = -frc[0];
507			grad[1] = -frc[1];
508			grad[2] = -frc[2];
509			grad[3] = 0.0;
510			grad[4] = 0.0;
511			grad[5] = 0.0;
512			break;
513			case OT_DATOM:
514			((DirectionalAtom*)this)->getGrad(grad);
515			break;
516			case OT_RIGIDBODY:
517			((RigidBody*)this)->getGrad(grad);
518			break;
519			default:
520			sprintf( painCave.errMsg,
521			"Unrecognized ObjType (%d) in StuntDouble::getGrad.\n",
522			objType );
523			painCave.isFatal = 1;
524			simError();
525			}
526			}
527
528			void StuntDouble::setEuler(double phi, double theta, double psi){
529			switch (objType)
530			{
531			case OT_ATOM:
532			sprintf( painCave.errMsg,
533			"StuntDouble::setEuler was called for a regular atom.\n"
534			"\tRegular Atoms don't have Euler Angles. Be smarter.\n");
535			painCave.isFatal = 1;
536			simError();
537			break;
538			case OT_DATOM:
539			((DirectionalAtom*)this)->setEuler(phi, theta, psi);
540			break;
541			case OT_RIGIDBODY:
542			((RigidBody*)this)->setEuler(phi, theta, psi);
543			break;
544			default:
545			sprintf( painCave.errMsg,
546			"Unrecognized ObjType (%d) in StuntDouble::setA.\n",
547			objType );
548			painCave.isFatal = 1;
549			simError();
550			}
551			}
552
553			void StuntDouble::getEulerAngles(double eulers[3]){
554			switch (objType)
555			{
556			case OT_ATOM:
557			sprintf( painCave.errMsg,
558			"StuntDouble::getEulerAngles was called for a regular atom.\n"
559			"\tRegular Atoms don't have Euler angles. Be smarter.\n");
560			painCave.isFatal = 0;
561			simError();
562			// Return zeros.
563			eulers[0] = 0;
564			eulers[1] = 0;
565			eulers[2] = 0;
566			break;
567			case OT_DATOM:
568			((DirectionalAtom*)this)->getEulerAngles(eulers);
569			break;
570			case OT_RIGIDBODY:
571			((RigidBody*)this)->getEulerAngles(eulers);
572			break;
573			default:
574			sprintf( painCave.errMsg,
575			"Unrecognized ObjType (%d) in StuntDouble::getEulerAngles.\n",
576			objType );
577			painCave.isFatal = 1;
578			simError();
579			}
580			}
581	tim	1118
582	chrisfen	1187	double StuntDouble::getZangle(){
583			switch (objType)
584			{
585			case OT_ATOM:
586			sprintf( painCave.errMsg,
587			"StuntDouble::getZangle was called for a regular atom.\n"
588			"\tRegular Atoms don't have zAngles. Be smarter.\n");
589			painCave.isFatal = 0;
590			simError();
591			// Return zeros.
592			return 0;
593			break;
594			case OT_DATOM:
595			return ((DirectionalAtom*)this)->getZangle();
596			break;
597			case OT_RIGIDBODY:
598			return ((RigidBody*)this)->getZangle();
599			break;
600			default:
601			sprintf( painCave.errMsg,
602			"Unrecognized ObjType (%d) in StuntDouble::getZangle.\n",
603			objType );
604			painCave.isFatal = 1;
605			simError();
606			return 0;
607			}
608			}
609
610			void StuntDouble::setZangle(double zAngle){
611			switch (objType)
612			{
613			case OT_ATOM:
614			sprintf( painCave.errMsg,
615			"StuntDouble::setZangle was called for a regular atom.\n"
616			"\tRegular Atoms don't have zAngles. Be smarter.\n");
617			painCave.isFatal = 1;
618			simError();
619			break;
620			case OT_DATOM:
621			((DirectionalAtom*)this)->setZangle(zAngle);
622			break;
623			case OT_RIGIDBODY:
624			((RigidBody*)this)->setZangle(zAngle);
625			break;
626			default:
627			sprintf( painCave.errMsg,
628			"Unrecognized ObjType (%d) in StuntDouble::setZangle.\n",
629			objType );
630			painCave.isFatal = 1;
631			simError();
632			}
633			}
634
635			void StuntDouble::addZangle(double zAngle){
636			switch (objType)
637			{
638			case OT_ATOM:
639			sprintf( painCave.errMsg,
640			"StuntDouble::addZangle was called for a regular atom.\n"
641			"\tRegular Atoms don't have zAngles. Be smarter.\n");
642			painCave.isFatal = 1;
643			simError();
644			break;
645			case OT_DATOM:
646			((DirectionalAtom*)this)->addZangle(zAngle);
647			break;
648			case OT_RIGIDBODY:
649			((RigidBody*)this)->addZangle(zAngle);
650			break;
651			default:
652			sprintf( painCave.errMsg,
653			"Unrecognized ObjType (%d) in StuntDouble::addZangle.\n",
654			objType );
655			painCave.isFatal = 1;
656			simError();
657			}
658			}
659
660	tim	1118	void StuntDouble::addProperty(GenericData* data){
661			map<string, GenericData*>::iterator result;
662			result = properties.find(data->getID());
663
664			//we can't simply use properties[prop->getID()] = prop,
665			//it will cause memory leak if we already contain a propery which has the same name of prop
666
667			if(result != properties.end()){
668			delete (*result).second;
669			(*result).second = data;
670			}
671			else
672			properties[data->getID()] = data;
673
674
675			}
676			void StuntDouble::removeProperty(const string& propName){
677			map<string, GenericData*>::iterator result;
678
679			result = properties.find(propName);
680
681	tim	1234	if(result != properties.end()){
682			delete result->second;
683	tim	1118	properties.erase(result);
684	tim	1234
685			}
686	tim	1118
687			}
688			GenericData* StuntDouble::getProperty(const string& propName){
689			map<string, GenericData*>::iterator result;
690
691
692			result = properties.find(propName);
693
694			if(result != properties.end())
695			return (*result).second;
696			else
697			return NULL;
698	chrisfen	1187	}