ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/OpenMD/branches/development/src/primitives/StuntDouble.cpp

Comparing:
trunk/src/primitives/StuntDouble.cpp (file contents), Revision 2 by gezelter, Fri Sep 24 04:16:43 2004 UTC vs.
branches/development/src/primitives/StuntDouble.cpp (file contents), Revision 1665 by gezelter, Tue Nov 22 20:38:56 2011 UTC

#	Line 1 | Line 1
1	<	#include "StuntDouble.hpp"
2	<	#include "Atom.hpp"
3	<	#include "DirectionalAtom.hpp"
4	<	#include "RigidBody.hpp"
5	<	#include "simError.h"
1	>	/*
2	>	* Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3	>	*
4	>	* The University of Notre Dame grants you ("Licensee") a
5	>	* non-exclusive, royalty free, license to use, modify and
6	>	* redistribute this software in source and binary code form, provided
7	>	* that the following conditions are met:
8	>	*
9	>	* 1. Redistributions of source code must retain the above copyright
10	>	*    notice, this list of conditions and the following disclaimer.
11	>	*
12	>	* 2. Redistributions in binary form must reproduce the above copyright
13	>	*    notice, this list of conditions and the following disclaimer in the
14	>	*    documentation and/or other materials provided with the
15	>	*    distribution.
16	>	*
17	>	* This software is provided "AS IS," without a warranty of any
18	>	* kind. All express or implied conditions, representations and
19	>	* warranties, including any implied warranty of merchantability,
20	>	* fitness for a particular purpose or non-infringement, are hereby
21	>	* excluded.  The University of Notre Dame and its licensors shall not
22	>	* be liable for any damages suffered by licensee as a result of
23	>	* using, modifying or distributing the software or its
24	>	* derivatives. In no event will the University of Notre Dame or its
25	>	* licensors be liable for any lost revenue, profit or data, or for
26	>	* direct, indirect, special, consequential, incidental or punitive
27	>	* damages, however caused and regardless of the theory of liability,
28	>	* arising out of the use of or inability to use software, even if the
29	>	* University of Notre Dame has been advised of the possibility of
30	>	* such damages.
31	>	*
32	>	* SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
33	>	* research, please cite the appropriate papers when you publish your
34	>	* work.  Good starting points are:
35	>	*
36	>	* [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).
37	>	* [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).
38	>	* [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).
39	>	* [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
40	>	* [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41	>	*/
42	>
43	>	/**
44	>	* @file StuntDouble.cpp
45	>	* @author    tlin
46	>	* @date  10/22/2004
47	>	* @version 1.0
48	>	*/
49
50	<	/*
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...."
50	>	#include "primitives/StuntDouble.hpp"
51
52	<	"You idiots! These are not them. You've captured their stunt
15	<	doubles! Search the area. Find them! Find them!"
52	>	namespace OpenMD {
53
54	<	StuntDouble is a very strange idea.  A StuntDouble stands in for
55	<	some object that can be manipulated by the Integrators or
56	<	Minimizers.  Some of the manipulable objects are Atoms, some are
57	<	DirectionalAtoms, and some are RigidBodies.  StuntDouble
58	<	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...)
54	>	StuntDouble::StuntDouble(ObjectType objType, DataStoragePointer storage) :
55	>	objType_(objType), storage_(storage), snapshotMan_(NULL),
56	>	linear_(false), linearAxis_(-1), globalIndex_(-1), localIndex_(-1),
57	>	globalIntegrableObjectIndex_(-1){
58	>	}
59
60	<	*/
60	>	StuntDouble::~StuntDouble() {
61
62	<	StuntDouble::~StuntDouble(){
29	<	map<string, GenericData*>::iterator iter;
62	>	}
63
64	<	for(iter = properties.begin(); iter != properties.end(); ++iter ){
65	<	delete iter->second;
66	<	properties.erase(iter);
64	>	void StuntDouble::zeroForcesAndTorques() {
65	>	setFrc(V3Zero);
66	>	setTrq(V3Zero);
67	>	setParticlePot(0.0);
68		}
69	<
70	<	}
69	>	void StuntDouble::addProperty(GenericData* genData) {
70	>	properties_.addProperty(genData);
71	>	}
72
73	<	int StuntDouble::getObjType(){
74	<	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();
73	>	void StuntDouble::removeProperty(const std::string& propName) {
74	>	properties_.removeProperty(propName);
75		}
206	–	}
76
77	<	void StuntDouble::setA(double A[3][3]){
78	<	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();
77	>	void StuntDouble::clearProperties() {
78	>	properties_.clearProperties();
79		}
260	–	}
80
81	<	void StuntDouble::setJ(double j[3]){
82	<	switch (objType)
83	<	{
84	<	case OT_ATOM:
85	<	sprintf( painCave.errMsg,
86	<	"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();
81	>	std::vector<std::string> StuntDouble::getPropertyNames() {
82	>	return properties_.getPropertyNames();
83	>	}
84	>
85	>	std::vector<GenericData*> StuntDouble::getProperties() {
86	>	return properties_.getProperties();
87		}
315	–	}
88
89	<	void StuntDouble::setQ(double q[4] ){
90	<	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();
89	>	GenericData* StuntDouble::getPropertyByName(const std::string& propName) {
90	>	return properties_.getPropertyByName(propName);
91		}
368	–	}
92
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	–	}
93
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	–	}
94		}
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	–	}

Comparing:
trunk/src/primitives/StuntDouble.cpp (property svn:keywords), Revision 2 by gezelter, Fri Sep 24 04:16:43 2004 UTC vs.
branches/development/src/primitives/StuntDouble.cpp (property svn:keywords), Revision 1665 by gezelter, Tue Nov 22 20:38:56 2011 UTC

#	Line 0 | Line 1
1	+	Author Id Revision Date

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines