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(); ){
    delete iter->second;
    iter = 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:	1234
Committed:	Fri Jun 4 03:15:31 2004 UTC (20 years, 1 month ago) by tim
File size:	17079 byte(s)
Log Message:	new rattle algorithm is working
#	Content
1	#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(); ){
32	delete iter->second;
33	iter = 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	switch (objType)
142	{
143	case OT_ATOM :
144	case OT_DATOM:
145	((Atom*)this)->setVel(vel);
146	break;
147	case OT_RIGIDBODY:
148	((RigidBody*)this)->setVel(vel);
149	break;
150	default:
151	sprintf( painCave.errMsg,
152	"Unrecognized ObjType (%d) in StuntDouble::setVel.\n",
153	objType );
154	painCave.isFatal = 1;
155	simError();
156	}
157	}
158
159	void StuntDouble::addFrc(double frc[3]){
160	switch (objType)
161	{
162	case OT_ATOM :
163	case OT_DATOM:
164	((Atom*)this)->addFrc(frc);
165	break;
166	case OT_RIGIDBODY:
167	((RigidBody*)this)->addFrc(frc);
168	break;
169	default:
170	sprintf( painCave.errMsg,
171	"Unrecognized ObjType (%d) in StuntDouble::addFrc.\n",
172	objType );
173	painCave.isFatal = 1;
174	simError();
175	}
176	}
177
178	void StuntDouble::getA(double A[3][3]){
179	switch (objType)
180	{
181	case OT_ATOM:
182	sprintf( painCave.errMsg,
183	"StuntDouble::getA was called for a regular atom.\n"
184	"\tRegular Atoms don't have rotation matrices. Be smarter.\n");
185	painCave.isFatal = 0;
186	simError();
187	// Return unit matrix
188	A[0][0] = 1; A[0][1] = 0; A[0][2] = 0;
189	A[1][0] = 0; A[1][1] = 1; A[1][2] = 0;
190	A[2][0] = 0; A[2][1] = 0; A[2][2] = 1;
191	break;
192	case OT_DATOM:
193	((DirectionalAtom*)this)->getA(A);
194	break;
195	case OT_RIGIDBODY:
196	((RigidBody*)this)->getA(A);
197	break;
198	default:
199	sprintf( painCave.errMsg,
200	"Unrecognized ObjType (%d) in StuntDouble::getA.\n",
201	objType );
202	painCave.isFatal = 1;
203	simError();
204	}
205	}
206
207	void StuntDouble::setA(double A[3][3]){
208	switch (objType)
209	{
210	case OT_ATOM:
211	sprintf( painCave.errMsg,
212	"StuntDouble::setA was called for a regular atom.\n"
213	"\tRegular Atoms don't have rotation matrices. Be smarter.\n");
214	painCave.isFatal = 1;
215	simError();
216	break;
217	case OT_DATOM:
218	((DirectionalAtom*)this)->setA(A);
219	break;
220	case OT_RIGIDBODY:
221	((RigidBody*)this)->setA(A);
222	break;
223	default:
224	sprintf( painCave.errMsg,
225	"Unrecognized ObjType (%d) in StuntDouble::setA.\n",
226	objType );
227	painCave.isFatal = 1;
228	simError();
229	}
230	}
231
232	void StuntDouble::getJ(double j[3]){
233	switch (objType)
234	{
235	case OT_ATOM:
236	sprintf( painCave.errMsg,
237	"StuntDouble::getJ was called for a regular atom.\n"
238	"\tRegular Atoms don't have angular momentum. Be smarter.\n");
239	painCave.isFatal = 0;
240	simError();
241	// Return zeros.
242	j[0] = 0;
243	j[1] = 0;
244	j[2] = 0;
245	break;
246	case OT_DATOM:
247	((DirectionalAtom*)this)->getJ(j);
248	break;
249	case OT_RIGIDBODY:
250	((RigidBody*)this)->getJ(j);
251	break;
252	default:
253	sprintf( painCave.errMsg,
254	"Unrecognized ObjType (%d) in StuntDouble::getJ.\n",
255	objType );
256	painCave.isFatal = 1;
257	simError();
258	}
259	}
260
261	void StuntDouble::setJ(double j[3]){
262	switch (objType)
263	{
264	case OT_ATOM:
265	sprintf( painCave.errMsg,
266	"StuntDouble::setJ was called for a regular atom.\n"
267	"\tRegular Atoms don't have angular momentum. Be smarter.\n");
268	painCave.isFatal = 1;
269	simError();
270	break;
271	case OT_DATOM:
272	((DirectionalAtom*)this)->setJ(j);
273	break;
274	case OT_RIGIDBODY:
275	((RigidBody*)this)->setJ(j);
276	break;
277	default:
278	sprintf( painCave.errMsg,
279	"Unrecognized ObjType (%d) in StuntDouble::setJ.\n",
280	objType );
281	painCave.isFatal = 1;
282	simError();
283	}
284	}
285
286	void StuntDouble::getQ(double q[4] ){
287	switch (objType)
288	{
289	case OT_ATOM:
290	sprintf( painCave.errMsg,
291	"StuntDouble::getJ was called for a regular atom.\n"
292	"\tRegular Atoms don't have angular momentum. Be smarter.\n");
293	painCave.isFatal = 0;
294	simError();
295	// Return zeros.
296	q[0] = 0;
297	q[1] = 0;
298	q[2] = 0;
299	q[3] = 0;
300	break;
301	case OT_DATOM:
302	((DirectionalAtom*)this)->getQ(q);
303	break;
304	case OT_RIGIDBODY:
305	((RigidBody*)this)->getQ(q);
306	break;
307	default:
308	sprintf( painCave.errMsg,
309	"Unrecognized ObjType (%d) in StuntDouble::getJ.\n",
310	objType );
311	painCave.isFatal = 1;
312	simError();
313	}
314	}
315
316	void StuntDouble::setQ(double q[4] ){
317	switch (objType)
318	{
319	case OT_ATOM:
320	sprintf( painCave.errMsg,
321	"StuntDouble::setJ was called for a regular atom.\n"
322	"\tRegular Atoms don't have angular momentum. Be smarter.\n");
323	painCave.isFatal = 1;
324	simError();
325	break;
326	case OT_DATOM:
327	((DirectionalAtom*)this)->setJ(q);
328	break;
329	case OT_RIGIDBODY:
330	((RigidBody*)this)->setJ(q);
331	break;
332	default:
333	sprintf( painCave.errMsg,
334	"Unrecognized ObjType (%d) in StuntDouble::setJ.\n",
335	objType );
336	painCave.isFatal = 1;
337	simError();
338	}
339	}
340	void StuntDouble::getTrq(double trq[3]){
341	switch (objType)
342	{
343	case OT_ATOM:
344	sprintf( painCave.errMsg,
345	"StuntDouble::getTrq was called for a regular atom.\n"
346	"\tRegular Atoms don't have torques. Be smarter.\n");
347	painCave.isFatal = 0;
348	simError();
349	// Return zeros.
350	trq[0] = 0;
351	trq[1] = 0;
352	trq[2] = 0;
353	break;
354	case OT_DATOM:
355	((DirectionalAtom*)this)->getTrq(trq);
356	break;
357	case OT_RIGIDBODY:
358	((RigidBody*)this)->getTrq(trq);
359	break;
360	default:
361	sprintf( painCave.errMsg,
362	"Unrecognized ObjType (%d) in StuntDouble::getTrq.\n",
363	objType );
364	painCave.isFatal = 1;
365	simError();
366	}
367	}
368
369	void StuntDouble::addTrq(double trq[3]){
370	switch (objType)
371	{
372	case OT_ATOM:
373	sprintf( painCave.errMsg,
374	"StuntDouble::addTrq was called for a regular atom.\n"
375	"\tRegular Atoms don't have torques. Be smarter.\n");
376	painCave.isFatal = 1;
377	simError();
378	break;
379	case OT_DATOM:
380	((DirectionalAtom*)this)->addTrq(trq);
381	break;
382	case OT_RIGIDBODY:
383	((RigidBody*)this)->addTrq(trq);
384	break;
385	default:
386	sprintf( painCave.errMsg,
387	"Unrecognized ObjType (%d) in StuntDouble::addTrq.\n",
388	objType );
389	painCave.isFatal = 1;
390	simError();
391	}
392	}
393
394	void StuntDouble::getI(double I[3][3]){
395	switch (objType)
396	{
397	case OT_ATOM:
398	sprintf( painCave.errMsg,
399	"StuntDouble::getI was called for a regular atom.\n"
400	"\tRegular Atoms don't have moments of inertia. Be smarter.\n");
401	painCave.isFatal = 0;
402	simError();
403	// Return zero matrix
404	I[0][0] = 0; I[0][1] = 0; I[0][2] = 0;
405	I[1][0] = 0; I[1][1] = 0; I[1][2] = 0;
406	I[2][0] = 0; I[2][1] = 0; I[2][2] = 0;
407	break;
408	case OT_DATOM:
409	((DirectionalAtom*)this)->getI(I);
410	break;
411	case OT_RIGIDBODY:
412	((RigidBody*)this)->getI(I);
413	break;
414	default:
415	sprintf( painCave.errMsg,
416	"Unrecognized ObjType (%d) in StuntDouble::getI.\n",
417	objType );
418	painCave.isFatal = 1;
419	simError();
420	}
421	}
422
423	void StuntDouble::lab2Body(double vec[3]){
424	switch (objType)
425	{
426	case OT_ATOM:
427	sprintf( painCave.errMsg,
428	"StuntDouble::lab2Body was called for a regular atom.\n"
429	"\tRegular Atoms don't have reference frames. Be smarter.\n");
430	painCave.isFatal = 0;
431	simError();
432	break;
433	case OT_DATOM:
434	((DirectionalAtom*)this)->lab2Body(vec);
435	break;
436	case OT_RIGIDBODY:
437	((RigidBody*)this)->lab2Body(vec);
438	break;
439	default:
440	sprintf( painCave.errMsg,
441	"Unrecognized ObjType (%d) in StuntDouble::lab2Body.\n",
442	objType );
443	painCave.isFatal = 1;
444	simError();
445	}
446	}
447
448	void StuntDouble::getGrad(double grad[6]){
449	double frc[3];
450
451	switch (objType)
452	{
453	case OT_ATOM:
454	sprintf( painCave.errMsg,
455	"StuntDouble::getGrad was called for a regular atom.\n"
456	"\tRegular Atoms don't have 6 coordinates. Be smarter.\n");
457	painCave.isFatal = 0;
458	simError();
459	((Atom*)this)->getFrc(frc);
460	grad[0] = -frc[0];
461	grad[1] = -frc[1];
462	grad[2] = -frc[2];
463	grad[3] = 0.0;
464	grad[4] = 0.0;
465	grad[5] = 0.0;
466	break;
467	case OT_DATOM:
468	((DirectionalAtom*)this)->getGrad(grad);
469	break;
470	case OT_RIGIDBODY:
471	((RigidBody*)this)->getGrad(grad);
472	break;
473	default:
474	sprintf( painCave.errMsg,
475	"Unrecognized ObjType (%d) in StuntDouble::getGrad.\n",
476	objType );
477	painCave.isFatal = 1;
478	simError();
479	}
480	}
481
482	void StuntDouble::setEuler(double phi, double theta, double psi){
483	switch (objType)
484	{
485	case OT_ATOM:
486	sprintf( painCave.errMsg,
487	"StuntDouble::setEuler was called for a regular atom.\n"
488	"\tRegular Atoms don't have Euler Angles. Be smarter.\n");
489	painCave.isFatal = 1;
490	simError();
491	break;
492	case OT_DATOM:
493	((DirectionalAtom*)this)->setEuler(phi, theta, psi);
494	break;
495	case OT_RIGIDBODY:
496	((RigidBody*)this)->setEuler(phi, theta, psi);
497	break;
498	default:
499	sprintf( painCave.errMsg,
500	"Unrecognized ObjType (%d) in StuntDouble::setA.\n",
501	objType );
502	painCave.isFatal = 1;
503	simError();
504	}
505	}
506
507	void StuntDouble::getEulerAngles(double eulers[3]){
508	switch (objType)
509	{
510	case OT_ATOM:
511	sprintf( painCave.errMsg,
512	"StuntDouble::getEulerAngles was called for a regular atom.\n"
513	"\tRegular Atoms don't have Euler angles. Be smarter.\n");
514	painCave.isFatal = 0;
515	simError();
516	// Return zeros.
517	eulers[0] = 0;
518	eulers[1] = 0;
519	eulers[2] = 0;
520	break;
521	case OT_DATOM:
522	((DirectionalAtom*)this)->getEulerAngles(eulers);
523	break;
524	case OT_RIGIDBODY:
525	((RigidBody*)this)->getEulerAngles(eulers);
526	break;
527	default:
528	sprintf( painCave.errMsg,
529	"Unrecognized ObjType (%d) in StuntDouble::getEulerAngles.\n",
530	objType );
531	painCave.isFatal = 1;
532	simError();
533	}
534	}
535
536	double StuntDouble::getZangle(){
537	switch (objType)
538	{
539	case OT_ATOM:
540	sprintf( painCave.errMsg,
541	"StuntDouble::getZangle was called for a regular atom.\n"
542	"\tRegular Atoms don't have zAngles. Be smarter.\n");
543	painCave.isFatal = 0;
544	simError();
545	// Return zeros.
546	return 0;
547	break;
548	case OT_DATOM:
549	return ((DirectionalAtom*)this)->getZangle();
550	break;
551	case OT_RIGIDBODY:
552	return ((RigidBody*)this)->getZangle();
553	break;
554	default:
555	sprintf( painCave.errMsg,
556	"Unrecognized ObjType (%d) in StuntDouble::getZangle.\n",
557	objType );
558	painCave.isFatal = 1;
559	simError();
560	return 0;
561	}
562	}
563
564	void StuntDouble::setZangle(double zAngle){
565	switch (objType)
566	{
567	case OT_ATOM:
568	sprintf( painCave.errMsg,
569	"StuntDouble::setZangle was called for a regular atom.\n"
570	"\tRegular Atoms don't have zAngles. Be smarter.\n");
571	painCave.isFatal = 1;
572	simError();
573	break;
574	case OT_DATOM:
575	((DirectionalAtom*)this)->setZangle(zAngle);
576	break;
577	case OT_RIGIDBODY:
578	((RigidBody*)this)->setZangle(zAngle);
579	break;
580	default:
581	sprintf( painCave.errMsg,
582	"Unrecognized ObjType (%d) in StuntDouble::setZangle.\n",
583	objType );
584	painCave.isFatal = 1;
585	simError();
586	}
587	}
588
589	void StuntDouble::addZangle(double zAngle){
590	switch (objType)
591	{
592	case OT_ATOM:
593	sprintf( painCave.errMsg,
594	"StuntDouble::addZangle was called for a regular atom.\n"
595	"\tRegular Atoms don't have zAngles. Be smarter.\n");
596	painCave.isFatal = 1;
597	simError();
598	break;
599	case OT_DATOM:
600	((DirectionalAtom*)this)->addZangle(zAngle);
601	break;
602	case OT_RIGIDBODY:
603	((RigidBody*)this)->addZangle(zAngle);
604	break;
605	default:
606	sprintf( painCave.errMsg,
607	"Unrecognized ObjType (%d) in StuntDouble::addZangle.\n",
608	objType );
609	painCave.isFatal = 1;
610	simError();
611	}
612	}
613
614	void StuntDouble::addProperty(GenericData* data){
615	map<string, GenericData*>::iterator result;
616	result = properties.find(data->getID());
617
618	//we can't simply use properties[prop->getID()] = prop,
619	//it will cause memory leak if we already contain a propery which has the same name of prop
620
621	if(result != properties.end()){
622	delete (*result).second;
623	(*result).second = data;
624	}
625	else
626	properties[data->getID()] = data;
627
628
629	}
630	void StuntDouble::removeProperty(const string& propName){
631	map<string, GenericData*>::iterator result;
632
633	result = properties.find(propName);
634
635	if(result != properties.end()){
636	delete result->second;
637	properties.erase(result);
638
639	}
640
641	}
642	GenericData* StuntDouble::getProperty(const string& propName){
643	map<string, GenericData*>::iterator result;
644
645
646	result = properties.find(propName);
647
648	if(result != properties.end())
649	return (*result).second;
650	else
651	return NULL;
652	}