src/primitives/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::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::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:	2
Committed:	Fri Sep 24 04:16:43 2004 UTC (20 years, 7 months ago) by gezelter
File size:	17080 byte(s)
Log Message:	Import of OOPSE v. 2.0
#	User	Rev	Content
1	gezelter	2	#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			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			}
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
142			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			void StuntDouble::addFrc(double frc[3]){
161			switch (objType)
162			{
163			case OT_ATOM :
164			case OT_DATOM:
165			((Atom*)this)->addFrc(frc);
166			break;
167			case OT_RIGIDBODY:
168			((RigidBody*)this)->addFrc(frc);
169			break;
170			default:
171			sprintf( painCave.errMsg,
172			"Unrecognized ObjType (%d) in StuntDouble::addFrc.\n",
173			objType );
174			painCave.isFatal = 1;
175			simError();
176			}
177			}
178
179			void StuntDouble::getA(double A[3][3]){
180			switch (objType)
181			{
182			case OT_ATOM:
183			sprintf( painCave.errMsg,
184			"StuntDouble::getA was called for a regular atom.\n"
185			"\tRegular Atoms don't have rotation matrices. Be smarter.\n");
186			painCave.isFatal = 0;
187			simError();
188			// Return unit matrix
189			A[0][0] = 1; A[0][1] = 0; A[0][2] = 0;
190			A[1][0] = 0; A[1][1] = 1; A[1][2] = 0;
191			A[2][0] = 0; A[2][1] = 0; A[2][2] = 1;
192			break;
193			case OT_DATOM:
194			((DirectionalAtom*)this)->getA(A);
195			break;
196			case OT_RIGIDBODY:
197			((RigidBody*)this)->getA(A);
198			break;
199			default:
200			sprintf( painCave.errMsg,
201			"Unrecognized ObjType (%d) in StuntDouble::getA.\n",
202			objType );
203			painCave.isFatal = 1;
204			simError();
205			}
206			}
207
208			void StuntDouble::setA(double A[3][3]){
209			switch (objType)
210			{
211			case OT_ATOM:
212			sprintf( painCave.errMsg,
213			"StuntDouble::setA was called for a regular atom.\n"
214			"\tRegular Atoms don't have rotation matrices. Be smarter.\n");
215			painCave.isFatal = 1;
216			simError();
217			break;
218			case OT_DATOM:
219			((DirectionalAtom*)this)->setA(A);
220			break;
221			case OT_RIGIDBODY:
222			((RigidBody*)this)->setA(A);
223			break;
224			default:
225			sprintf( painCave.errMsg,
226			"Unrecognized ObjType (%d) in StuntDouble::setA.\n",
227			objType );
228			painCave.isFatal = 1;
229			simError();
230			}
231			}
232
233			void StuntDouble::getJ(double j[3]){
234			switch (objType)
235			{
236			case OT_ATOM:
237			sprintf( painCave.errMsg,
238			"StuntDouble::getJ was called for a regular atom.\n"
239			"\tRegular Atoms don't have angular momentum. Be smarter.\n");
240			painCave.isFatal = 0;
241			simError();
242			// Return zeros.
243			j[0] = 0;
244			j[1] = 0;
245			j[2] = 0;
246			break;
247			case OT_DATOM:
248			((DirectionalAtom*)this)->getJ(j);
249			break;
250			case OT_RIGIDBODY:
251			((RigidBody*)this)->getJ(j);
252			break;
253			default:
254			sprintf( painCave.errMsg,
255			"Unrecognized ObjType (%d) in StuntDouble::getJ.\n",
256			objType );
257			painCave.isFatal = 1;
258			simError();
259			}
260			}
261
262			void StuntDouble::setJ(double j[3]){
263			switch (objType)
264			{
265			case OT_ATOM:
266			sprintf( painCave.errMsg,
267			"StuntDouble::setJ was called for a regular atom.\n"
268			"\tRegular Atoms don't have angular momentum. Be smarter.\n");
269			painCave.isFatal = 1;
270			simError();
271			break;
272			case OT_DATOM:
273			((DirectionalAtom*)this)->setJ(j);
274			break;
275			case OT_RIGIDBODY:
276			((RigidBody*)this)->setJ(j);
277			break;
278			default:
279			sprintf( painCave.errMsg,
280			"Unrecognized ObjType (%d) in StuntDouble::setJ.\n",
281			objType );
282			painCave.isFatal = 1;
283			simError();
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			{
344			case OT_ATOM:
345			sprintf( painCave.errMsg,
346			"StuntDouble::getTrq was called for a regular atom.\n"
347			"\tRegular Atoms don't have torques. Be smarter.\n");
348			painCave.isFatal = 0;
349			simError();
350			// Return zeros.
351			trq[0] = 0;
352			trq[1] = 0;
353			trq[2] = 0;
354			break;
355			case OT_DATOM:
356			((DirectionalAtom*)this)->getTrq(trq);
357			break;
358			case OT_RIGIDBODY:
359			((RigidBody*)this)->getTrq(trq);
360			break;
361			default:
362			sprintf( painCave.errMsg,
363			"Unrecognized ObjType (%d) in StuntDouble::getTrq.\n",
364			objType );
365			painCave.isFatal = 1;
366			simError();
367			}
368			}
369
370			void StuntDouble::addTrq(double trq[3]){
371			switch (objType)
372			{
373			case OT_ATOM:
374			sprintf( painCave.errMsg,
375			"StuntDouble::addTrq was called for a regular atom.\n"
376			"\tRegular Atoms don't have torques. Be smarter.\n");
377			painCave.isFatal = 1;
378			simError();
379			break;
380			case OT_DATOM:
381			((DirectionalAtom*)this)->addTrq(trq);
382			break;
383			case OT_RIGIDBODY:
384			((RigidBody*)this)->addTrq(trq);
385			break;
386			default:
387			sprintf( painCave.errMsg,
388			"Unrecognized ObjType (%d) in StuntDouble::addTrq.\n",
389			objType );
390			painCave.isFatal = 1;
391			simError();
392			}
393			}
394
395			void StuntDouble::getI(double I[3][3]){
396			switch (objType)
397			{
398			case OT_ATOM:
399			sprintf( painCave.errMsg,
400			"StuntDouble::getI was called for a regular atom.\n"
401			"\tRegular Atoms don't have moments of inertia. Be smarter.\n");
402			painCave.isFatal = 0;
403			simError();
404			// Return zero matrix
405			I[0][0] = 0; I[0][1] = 0; I[0][2] = 0;
406			I[1][0] = 0; I[1][1] = 0; I[1][2] = 0;
407			I[2][0] = 0; I[2][1] = 0; I[2][2] = 0;
408			break;
409			case OT_DATOM:
410			((DirectionalAtom*)this)->getI(I);
411			break;
412			case OT_RIGIDBODY:
413			((RigidBody*)this)->getI(I);
414			break;
415			default:
416			sprintf( painCave.errMsg,
417			"Unrecognized ObjType (%d) in StuntDouble::getI.\n",
418			objType );
419			painCave.isFatal = 1;
420			simError();
421			}
422			}
423
424			void StuntDouble::lab2Body(double vec[3]){
425			switch (objType)
426			{
427			case OT_ATOM:
428			sprintf( painCave.errMsg,
429			"StuntDouble::lab2Body was called for a regular atom.\n"
430			"\tRegular Atoms don't have reference frames. Be smarter.\n");
431			painCave.isFatal = 0;
432			simError();
433			break;
434			case OT_DATOM:
435			((DirectionalAtom*)this)->lab2Body(vec);
436			break;
437			case OT_RIGIDBODY:
438			((RigidBody*)this)->lab2Body(vec);
439			break;
440			default:
441			sprintf( painCave.errMsg,
442			"Unrecognized ObjType (%d) in StuntDouble::lab2Body.\n",
443			objType );
444			painCave.isFatal = 1;
445			simError();
446			}
447			}
448
449			void StuntDouble::getGrad(double grad[6]){
450			double frc[3];
451
452			switch (objType)
453			{
454			case OT_ATOM:
455			sprintf( painCave.errMsg,
456			"StuntDouble::getGrad was called for a regular atom.\n"
457			"\tRegular Atoms don't have 6 coordinates. Be smarter.\n");
458			painCave.isFatal = 0;
459			simError();
460			((Atom*)this)->getFrc(frc);
461			grad[0] = -frc[0];
462			grad[1] = -frc[1];
463			grad[2] = -frc[2];
464			grad[3] = 0.0;
465			grad[4] = 0.0;
466			grad[5] = 0.0;
467			break;
468			case OT_DATOM:
469			((DirectionalAtom*)this)->getGrad(grad);
470			break;
471			case OT_RIGIDBODY:
472			((RigidBody*)this)->getGrad(grad);
473			break;
474			default:
475			sprintf( painCave.errMsg,
476			"Unrecognized ObjType (%d) in StuntDouble::getGrad.\n",
477			objType );
478			painCave.isFatal = 1;
479			simError();
480			}
481			}
482
483			void StuntDouble::setEuler(double phi, double theta, double psi){
484			switch (objType)
485			{
486			case OT_ATOM:
487			sprintf( painCave.errMsg,
488			"StuntDouble::setEuler was called for a regular atom.\n"
489			"\tRegular Atoms don't have Euler Angles. Be smarter.\n");
490			painCave.isFatal = 1;
491			simError();
492			break;
493			case OT_DATOM:
494			((DirectionalAtom*)this)->setEuler(phi, theta, psi);
495			break;
496			case OT_RIGIDBODY:
497			((RigidBody*)this)->setEuler(phi, theta, psi);
498			break;
499			default:
500			sprintf( painCave.errMsg,
501			"Unrecognized ObjType (%d) in StuntDouble::setA.\n",
502			objType );
503			painCave.isFatal = 1;
504			simError();
505			}
506			}
507
508			void StuntDouble::getEulerAngles(double eulers[3]){
509			switch (objType)
510			{
511			case OT_ATOM:
512			sprintf( painCave.errMsg,
513			"StuntDouble::getEulerAngles was called for a regular atom.\n"
514			"\tRegular Atoms don't have Euler angles. Be smarter.\n");
515			painCave.isFatal = 0;
516			simError();
517			// Return zeros.
518			eulers[0] = 0;
519			eulers[1] = 0;
520			eulers[2] = 0;
521			break;
522			case OT_DATOM:
523			((DirectionalAtom*)this)->getEulerAngles(eulers);
524			break;
525			case OT_RIGIDBODY:
526			((RigidBody*)this)->getEulerAngles(eulers);
527			break;
528			default:
529			sprintf( painCave.errMsg,
530			"Unrecognized ObjType (%d) in StuntDouble::getEulerAngles.\n",
531			objType );
532			painCave.isFatal = 1;
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			}