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...)

*/

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::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();     
  }
}
Revision:	1097
Committed:	Mon Apr 12 20:32:20 2004 UTC (20 years, 2 months ago) by gezelter
File size:	12407 byte(s)
Log Message:	Changes for RigidBody dynamics (Somewhat extensive)
#	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	int StuntDouble::getObjType(){
29	return objType;
30	}
31
32	double StuntDouble::getMass(){
33	switch (objType)
34	{
35	case OT_ATOM :
36	case OT_DATOM:
37	return ((Atom*)this)->getMass();
38	break;
39	case OT_RIGIDBODY:
40	return ((RigidBody*)this)->getMass();
41	break;
42	default:
43	sprintf( painCave.errMsg,
44	"Unrecognized ObjType (%d) in StuntDouble::getMass.\n",
45	objType );
46	painCave.isFatal = 1;
47	simError();
48	return 0.0;
49	}
50	}
51
52
53	void StuntDouble::getPos(double pos[3]){
54	switch (objType)
55	{
56	case OT_ATOM :
57	case OT_DATOM:
58	((Atom*)this)->getPos(pos);
59	break;
60	case OT_RIGIDBODY:
61	((RigidBody*)this)->getPos(pos);
62	break;
63	default:
64	sprintf( painCave.errMsg,
65	"Unrecognized ObjType (%d) in StuntDouble::getPos.\n",
66	objType );
67	painCave.isFatal = 1;
68	simError();
69	}
70	}
71
72	void StuntDouble::getVel(double vel[3]){
73	switch (objType)
74	{
75	case OT_ATOM :
76	case OT_DATOM:
77	((Atom*)this)->getVel(vel);
78	break;
79	case OT_RIGIDBODY:
80	((RigidBody*)this)->getVel(vel);
81	break;
82	default:
83	sprintf( painCave.errMsg,
84	"Unrecognized ObjType (%d) in StuntDouble::getVel.\n",
85	objType );
86	painCave.isFatal = 1;
87	simError();
88	}
89	}
90
91	void StuntDouble::getFrc(double frc[3]){
92	switch (objType)
93	{
94	case OT_ATOM :
95	case OT_DATOM:
96	((Atom*)this)->getFrc(frc);
97	break;
98	case OT_RIGIDBODY:
99	((RigidBody*)this)->getFrc(frc);
100	break;
101	default:
102	sprintf( painCave.errMsg,
103	"Unrecognized ObjType (%d) in StuntDouble::getFrc.\n",
104	objType );
105	painCave.isFatal = 1;
106	simError();
107	}
108	}
109
110
111	void StuntDouble::setPos(double pos[3]){
112	switch (objType)
113	{
114	case OT_ATOM :
115	case OT_DATOM:
116	((Atom*)this)->setPos(pos);
117	break;
118	case OT_RIGIDBODY:
119	((RigidBody*)this)->setPos(pos);
120	break;
121	default:
122	sprintf( painCave.errMsg,
123	"Unrecognized ObjType (%d) in StuntDouble::setPos.\n",
124	objType );
125	painCave.isFatal = 1;
126	simError();
127	}
128	}
129
130	void StuntDouble::setVel(double vel[3]){
131	switch (objType)
132	{
133	case OT_ATOM :
134	case OT_DATOM:
135	((Atom*)this)->setVel(vel);
136	break;
137	case OT_RIGIDBODY:
138	((RigidBody*)this)->setVel(vel);
139	break;
140	default:
141	sprintf( painCave.errMsg,
142	"Unrecognized ObjType (%d) in StuntDouble::setVel.\n",
143	objType );
144	painCave.isFatal = 1;
145	simError();
146	}
147	}
148
149	void StuntDouble::addFrc(double frc[3]){
150	switch (objType)
151	{
152	case OT_ATOM :
153	case OT_DATOM:
154	((Atom*)this)->addFrc(frc);
155	break;
156	case OT_RIGIDBODY:
157	((RigidBody*)this)->addFrc(frc);
158	break;
159	default:
160	sprintf( painCave.errMsg,
161	"Unrecognized ObjType (%d) in StuntDouble::addFrc.\n",
162	objType );
163	painCave.isFatal = 1;
164	simError();
165	}
166	}
167
168	void StuntDouble::getA(double A[3][3]){
169	switch (objType)
170	{
171	case OT_ATOM:
172	sprintf( painCave.errMsg,
173	"StuntDouble::getA was called for a regular atom.\n"
174	"\tRegular Atoms don't have rotation matrices. Be smarter.\n");
175	painCave.isFatal = 0;
176	simError();
177	// Return unit matrix
178	A[0][0] = 1; A[0][1] = 0; A[0][2] = 0;
179	A[1][0] = 0; A[1][1] = 1; A[1][2] = 0;
180	A[2][0] = 0; A[2][1] = 0; A[2][2] = 1;
181	break;
182	case OT_DATOM:
183	((DirectionalAtom*)this)->getA(A);
184	break;
185	case OT_RIGIDBODY:
186	((RigidBody*)this)->getA(A);
187	break;
188	default:
189	sprintf( painCave.errMsg,
190	"Unrecognized ObjType (%d) in StuntDouble::getA.\n",
191	objType );
192	painCave.isFatal = 1;
193	simError();
194	}
195	}
196
197	void StuntDouble::setA(double A[3][3]){
198	switch (objType)
199	{
200	case OT_ATOM:
201	sprintf( painCave.errMsg,
202	"StuntDouble::setA was called for a regular atom.\n"
203	"\tRegular Atoms don't have rotation matrices. Be smarter.\n");
204	painCave.isFatal = 1;
205	simError();
206	break;
207	case OT_DATOM:
208	((DirectionalAtom*)this)->setA(A);
209	break;
210	case OT_RIGIDBODY:
211	((RigidBody*)this)->setA(A);
212	break;
213	default:
214	sprintf( painCave.errMsg,
215	"Unrecognized ObjType (%d) in StuntDouble::setA.\n",
216	objType );
217	painCave.isFatal = 1;
218	simError();
219	}
220	}
221
222	void StuntDouble::getJ(double j[3]){
223	switch (objType)
224	{
225	case OT_ATOM:
226	sprintf( painCave.errMsg,
227	"StuntDouble::getJ was called for a regular atom.\n"
228	"\tRegular Atoms don't have angular momentum. Be smarter.\n");
229	painCave.isFatal = 0;
230	simError();
231	// Return zeros.
232	j[0] = 0;
233	j[1] = 0;
234	j[2] = 0;
235	break;
236	case OT_DATOM:
237	((DirectionalAtom*)this)->getJ(j);
238	break;
239	case OT_RIGIDBODY:
240	((RigidBody*)this)->getJ(j);
241	break;
242	default:
243	sprintf( painCave.errMsg,
244	"Unrecognized ObjType (%d) in StuntDouble::getJ.\n",
245	objType );
246	painCave.isFatal = 1;
247	simError();
248	}
249	}
250
251	void StuntDouble::setJ(double j[3]){
252	switch (objType)
253	{
254	case OT_ATOM:
255	sprintf( painCave.errMsg,
256	"StuntDouble::setJ was called for a regular atom.\n"
257	"\tRegular Atoms don't have angular momentum. Be smarter.\n");
258	painCave.isFatal = 1;
259	simError();
260	break;
261	case OT_DATOM:
262	((DirectionalAtom*)this)->setJ(j);
263	break;
264	case OT_RIGIDBODY:
265	((RigidBody*)this)->setJ(j);
266	break;
267	default:
268	sprintf( painCave.errMsg,
269	"Unrecognized ObjType (%d) in StuntDouble::setJ.\n",
270	objType );
271	painCave.isFatal = 1;
272	simError();
273	}
274	}
275
276	void StuntDouble::getTrq(double trq[3]){
277	switch (objType)
278	{
279	case OT_ATOM:
280	sprintf( painCave.errMsg,
281	"StuntDouble::getTrq was called for a regular atom.\n"
282	"\tRegular Atoms don't have torques. Be smarter.\n");
283	painCave.isFatal = 0;
284	simError();
285	// Return zeros.
286	trq[0] = 0;
287	trq[1] = 0;
288	trq[2] = 0;
289	break;
290	case OT_DATOM:
291	((DirectionalAtom*)this)->getTrq(trq);
292	break;
293	case OT_RIGIDBODY:
294	((RigidBody*)this)->getTrq(trq);
295	break;
296	default:
297	sprintf( painCave.errMsg,
298	"Unrecognized ObjType (%d) in StuntDouble::getTrq.\n",
299	objType );
300	painCave.isFatal = 1;
301	simError();
302	}
303	}
304
305	void StuntDouble::addTrq(double trq[3]){
306	switch (objType)
307	{
308	case OT_ATOM:
309	sprintf( painCave.errMsg,
310	"StuntDouble::addTrq was called for a regular atom.\n"
311	"\tRegular Atoms don't have torques. Be smarter.\n");
312	painCave.isFatal = 1;
313	simError();
314	break;
315	case OT_DATOM:
316	((DirectionalAtom*)this)->addTrq(trq);
317	break;
318	case OT_RIGIDBODY:
319	((RigidBody*)this)->addTrq(trq);
320	break;
321	default:
322	sprintf( painCave.errMsg,
323	"Unrecognized ObjType (%d) in StuntDouble::addTrq.\n",
324	objType );
325	painCave.isFatal = 1;
326	simError();
327	}
328	}
329
330	void StuntDouble::getI(double I[3][3]){
331	switch (objType)
332	{
333	case OT_ATOM:
334	sprintf( painCave.errMsg,
335	"StuntDouble::getI was called for a regular atom.\n"
336	"\tRegular Atoms don't have moments of inertia. Be smarter.\n");
337	painCave.isFatal = 0;
338	simError();
339	// Return zero matrix
340	I[0][0] = 0; I[0][1] = 0; I[0][2] = 0;
341	I[1][0] = 0; I[1][1] = 0; I[1][2] = 0;
342	I[2][0] = 0; I[2][1] = 0; I[2][2] = 0;
343	break;
344	case OT_DATOM:
345	((DirectionalAtom*)this)->getI(I);
346	break;
347	case OT_RIGIDBODY:
348	((RigidBody*)this)->getI(I);
349	break;
350	default:
351	sprintf( painCave.errMsg,
352	"Unrecognized ObjType (%d) in StuntDouble::getI.\n",
353	objType );
354	painCave.isFatal = 1;
355	simError();
356	}
357	}
358
359	void StuntDouble::lab2Body(double vec[3]){
360	switch (objType)
361	{
362	case OT_ATOM:
363	sprintf( painCave.errMsg,
364	"StuntDouble::lab2Body was called for a regular atom.\n"
365	"\tRegular Atoms don't have reference frames. Be smarter.\n");
366	painCave.isFatal = 0;
367	simError();
368	break;
369	case OT_DATOM:
370	((DirectionalAtom*)this)->lab2Body(vec);
371	break;
372	case OT_RIGIDBODY:
373	((RigidBody*)this)->lab2Body(vec);
374	break;
375	default:
376	sprintf( painCave.errMsg,
377	"Unrecognized ObjType (%d) in StuntDouble::lab2Body.\n",
378	objType );
379	painCave.isFatal = 1;
380	simError();
381	}
382	}
383
384	void StuntDouble::getGrad(double grad[6]){
385	double frc[3];
386
387	switch (objType)
388	{
389	case OT_ATOM:
390	sprintf( painCave.errMsg,
391	"StuntDouble::getGrad was called for a regular atom.\n"
392	"\tRegular Atoms don't have 6 coordinates. Be smarter.\n");
393	painCave.isFatal = 0;
394	simError();
395	((Atom*)this)->getFrc(frc);
396	grad[0] = -frc[0];
397	grad[1] = -frc[1];
398	grad[2] = -frc[2];
399	grad[3] = 0.0;
400	grad[4] = 0.0;
401	grad[5] = 0.0;
402	break;
403	case OT_DATOM:
404	((DirectionalAtom*)this)->getGrad(grad);
405	break;
406	case OT_RIGIDBODY:
407	((RigidBody*)this)->getGrad(grad);
408	break;
409	default:
410	sprintf( painCave.errMsg,
411	"Unrecognized ObjType (%d) in StuntDouble::getGrad.\n",
412	objType );
413	painCave.isFatal = 1;
414	simError();
415	}
416	}
417
418	void StuntDouble::setEuler(double phi, double theta, double psi){
419	switch (objType)
420	{
421	case OT_ATOM:
422	sprintf( painCave.errMsg,
423	"StuntDouble::setEuler was called for a regular atom.\n"
424	"\tRegular Atoms don't have Euler Angles. Be smarter.\n");
425	painCave.isFatal = 1;
426	simError();
427	break;
428	case OT_DATOM:
429	((DirectionalAtom*)this)->setEuler(phi, theta, psi);
430	break;
431	case OT_RIGIDBODY:
432	((RigidBody*)this)->setEuler(phi, theta, psi);
433	break;
434	default:
435	sprintf( painCave.errMsg,
436	"Unrecognized ObjType (%d) in StuntDouble::setA.\n",
437	objType );
438	painCave.isFatal = 1;
439	simError();
440	}
441	}
442
443	void StuntDouble::getEulerAngles(double eulers[3]){
444	switch (objType)
445	{
446	case OT_ATOM:
447	sprintf( painCave.errMsg,
448	"StuntDouble::getEulerAngles was called for a regular atom.\n"
449	"\tRegular Atoms don't have Euler angles. Be smarter.\n");
450	painCave.isFatal = 0;
451	simError();
452	// Return zeros.
453	eulers[0] = 0;
454	eulers[1] = 0;
455	eulers[2] = 0;
456	break;
457	case OT_DATOM:
458	((DirectionalAtom*)this)->getEulerAngles(eulers);
459	break;
460	case OT_RIGIDBODY:
461	((RigidBody*)this)->getEulerAngles(eulers);
462	break;
463	default:
464	sprintf( painCave.errMsg,
465	"Unrecognized ObjType (%d) in StuntDouble::getEulerAngles.\n",
466	objType );
467	painCave.isFatal = 1;
468	simError();
469	}
470	}