ViewVC Help

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

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

Comparing:
trunk/src/primitives/StuntDouble.hpp (file contents), Revision 963 by tim, Wed May 17 21:51:42 2006 UTC vs.
branches/development/src/primitives/StuntDouble.hpp (file contents), Revision 1702 by kstocke1, Thu Apr 5 19:49:59 2012 UTC

#	Line 6 | Line 6
6		* redistribute this software in source and binary code form, provided
7		* that the following conditions are met:
8		*
9	<	* 1. Acknowledgement of the program authors must be made in any
10	<	*    publication of scientific results based in part on use of the
11	<	*    program.  An acceptable form of acknowledgement is citation of
12	<	*    the article in which the program was described (Matthew
13	<	*    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14	<	*    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15	<	*    Parallel Simulation Engine for Molecular Dynamics,"
16	<	*    J. Comput. Chem. 26, pp. 252-271 (2005))
17	<	*
18	<	* 2. Redistributions of source code must retain the above copyright
9	>	* 1. Redistributions of source code must retain the above copyright
10		*    notice, this list of conditions and the following disclaimer.
11		*
12	<	* 3. Redistributions in binary form must reproduce the above copyright
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.
#	Line 37 | Line 28
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		/**
#	Line 58 | Line 59
59		#include "utils/PropertyMap.hpp"
60		#include "brains/Snapshot.hpp"
61		#include "brains/SnapshotManager.hpp"
62	<	namespace oopse{
62	>	namespace OpenMD{
63
64
65
#	Line 83 | Line 84 | namespace oopse{
84		* doesn't try to do something stupid like torque an Atom (The
85		* quotes above are from Spaceballs...)
86		*
87	<	* @note the dynamic data of stuntdouble will be stored outside of the class
87	>	* @note the dynamic data of stuntDouble will be stored outside of the class
88		*/
89		class StuntDouble{
90		public:
#	Line 97 | Line 98 | namespace oopse{
98		virtual ~StuntDouble();
99
100		/**
101	<	* Returns the global index of this stuntRealType.
102	<	* @return  the global index of this stuntdouble
101	>	* Returns the global index of this stuntDouble.
102	>	* @return  the global index of this stuntDouble
103		*/
104		int getGlobalIndex() {
105		return globalIndex_;
106		}
107
108		/**
109	<	* Sets the global index of this stuntRealType.
109	>	* Sets the global index of this stuntDouble.
110		* @param new global index to be set
111		*/
112		void setGlobalIndex(int index) {
113		globalIndex_ = index;
114		}
115	<
115	>
116		/**
117	<	* Returns the local index of this stuntdouble
118	<	* @return the local index of this stuntdouble
117	>	* Returns the local index of this stuntDouble
118	>	* @return the local index of this stuntDouble
119		*/
120		int getLocalIndex() {
121		return localIndex_;
122		}
123
124		/**
125	<	* Sets the local index of this stuntdouble
125	>	* Sets the local index of this stuntDouble
126		* @param index new index to be set
127		*/
128		void setLocalIndex(int index) {
129		localIndex_ = index;
130		}
131	+
132	+	int getGlobalIntegrableObjectIndex(){
133	+	return globalIntegrableObjectIndex_;
134	+	}
135	+	void setGlobalIntegrableObjectIndex(int index) {
136	+	globalIntegrableObjectIndex_ = index;
137	+	}
138
139		/**
140	<	* Sets the Snapshot Manager of this stuntdouble
140	>	* Sets the Snapshot Manager of this stuntDouble
141		*/
142		void setSnapshotManager(SnapshotManager* sman) {
143		snapshotMan_ = sman;
144		}
145
146		/**
147	<	* Tests if this stuntdouble is an atom
148	<	* @return true is this stuntdouble is an atom(or a directional atom), return false otherwise
147	>	* Tests if this stuntDouble is an atom
148	>	* @return true is this stuntDouble is an atom(or a directional atom), return false otherwise
149		*/
150		bool isAtom(){
151		return objType_ == otAtom || objType_ == otDAtom;
152		}
153
154		/**
155	<	* Tests if this stuntdouble is an directional atom
156	<	* @return true if this stuntdouble is an directional atom, return false otherwise
155	>	* Tests if this stuntDouble is an directional atom
156	>	* @return true if this stuntDouble is an directional atom, return false otherwise
157		*/
158		bool isDirectionalAtom(){
159		return objType_ == otDAtom;
160		}
161
162		/**
163	<	* Tests if this stuntdouble is a rigid body.
164	<	* @return true if this stuntdouble is a rigid body, otherwise return false
163	>	* Tests if this stuntDouble is a rigid body.
164	>	* @return true if this stuntDouble is a rigid body, otherwise return false
165		*/
166		bool isRigidBody(){
167		return objType_ == otRigidBody;
168		}
169
170		/**
171	<	* Tests if this stuntdouble is a directional one.
172	<	* @return true is this stuntdouble is a directional atom or a rigid body, return false otherwise
171	>	* Tests if this stuntDouble is a directional one.
172	>	* @return true is this stuntDouble is a directional atom or a rigid body, return false otherwise
173		*/
174		bool isDirectional(){
175		return isDirectionalAtom() || isRigidBody();
#	Line 191 | Line 199 | namespace oopse{
199		}
200
201		/**
202	<	* Returns the previous position of this stuntdouble
203	<	* @return the position of this stuntdouble
202	>	* Returns the previous position of this stuntDouble
203	>	* @return the position of this stuntDouble
204		*/
205		Vector3d getPrevPos() {
206		return ((snapshotMan_->getPrevSnapshot())->*storage_).position[localIndex_];
207		}
208
209		/**
210	<	* Returns the current position of this stuntdouble
211	<	* @return the position of this stuntdouble
210	>	* Returns the current position of this stuntDouble
211	>	* @return the position of this stuntDouble
212		*/
213		Vector3d getPos() {
214		return ((snapshotMan_->getCurrentSnapshot())->*storage_).position[localIndex_];
215		}
216
217		/**
218	<	* Returns the position of this stuntdouble in specified snapshot
219	<	* @return the position of this stuntdouble
218	>	* Returns the position of this stuntDouble in specified snapshot
219	>	* @return the position of this stuntDouble
220		* @param snapshotNo
221		*/
222		Vector3d getPos(int snapshotNo) {
#	Line 216 | Line 224 | namespace oopse{
224		}
225
226		/**
227	<	* Sets  the previous position of this stuntdouble
227	>	* Sets  the previous position of this stuntDouble
228		* @param pos  new position
229		* @see #getPos
230		*/
#	Line 225 | Line 233 | namespace oopse{
233		}
234
235		/**
236	<	* Sets  the current position of this stuntdouble
236	>	* Sets  the current position of this stuntDouble
237		* @param pos  new position
238		*/
239		void setPos(const Vector3d& pos) {
#	Line 235 | Line 243 | namespace oopse{
243		}
244
245		/**
246	<	* Sets  the position of this stuntdouble in specified snapshot
246	>	* Sets  the position of this stuntDouble in specified snapshot
247		* @param pos position to be set
248		* @param snapshotNo
249		* @see #getPos
#	Line 247 | Line 255 | namespace oopse{
255		}
256
257		/**
258	<	* Returns the previous velocity of this stuntdouble
259	<	* @return the velocity of this stuntdouble
258	>	* Returns the previous velocity of this stuntDouble
259	>	* @return the velocity of this stuntDouble
260		*/
261		Vector3d getPrevVel() {
262		return ((snapshotMan_->getPrevSnapshot())->*storage_).velocity[localIndex_];
263		}
264
265		/**
266	<	* Returns the current velocity of this stuntdouble
267	<	* @return the velocity of this stuntdouble
266	>	* Returns the current velocity of this stuntDouble
267	>	* @return the velocity of this stuntDouble
268		*/
269		Vector3d getVel() {
270		return ((snapshotMan_->getCurrentSnapshot())->*storage_).velocity[localIndex_];
271		}
272
273		/**
274	<	* Returns the velocity of this stuntdouble in specified snapshot
275	<	* @return the velocity of this stuntdouble
274	>	* Returns the velocity of this stuntDouble in specified snapshot
275	>	* @return the velocity of this stuntDouble
276		* @param snapshotNo
277		*/
278		Vector3d getVel(int snapshotNo) {
#	Line 272 | Line 280 | namespace oopse{
280		}
281
282		/**
283	<	* Sets  the previous velocity of this stuntdouble
283	>	* Sets  the previous velocity of this stuntDouble
284		* @param vel  new velocity
285		* @see #getVel
286		*/
#	Line 281 | Line 289 | namespace oopse{
289		}
290
291		/**
292	<	* Sets  the current velocity of this stuntdouble
292	>	* Sets  the current velocity of this stuntDouble
293		* @param vel  new velocity
294		*/
295		void setVel(const Vector3d& vel) {
#	Line 289 | Line 297 | namespace oopse{
297		}
298
299		/**
300	<	* Sets  the velocity of this stuntdouble in specified snapshot
300	>	* Sets  the velocity of this stuntDouble in specified snapshot
301		* @param vel velocity to be set
302		* @param snapshotNo
303		* @see #getVel
#	Line 299 | Line 307 | namespace oopse{
307		}
308
309		/**
310	<	* Returns the previous rotation matrix of this stuntdouble
311	<	* @return the rotation matrix of this stuntdouble
310	>	* Returns the previous rotation matrix of this stuntDouble
311	>	* @return the rotation matrix of this stuntDouble
312		*/
313		RotMat3x3d getPrevA() {
314		return ((snapshotMan_->getPrevSnapshot())->*storage_).aMat[localIndex_];
315		}
316
317		/**
318	<	* Returns the current rotation matrix of this stuntdouble
319	<	* @return the rotation matrix of this stuntdouble
318	>	* Returns the current rotation matrix of this stuntDouble
319	>	* @return the rotation matrix of this stuntDouble
320		*/
321		RotMat3x3d getA() {
322		return ((snapshotMan_->getCurrentSnapshot())->*storage_).aMat[localIndex_];
323		}
324
325		/**
326	<	* Returns the rotation matrix of this stuntdouble in specified snapshot
326	>	* Returns the rotation matrix of this stuntDouble in specified snapshot
327		*
328	<	* @return the rotation matrix of this stuntdouble
328	>	* @return the rotation matrix of this stuntDouble
329		* @param snapshotNo
330		*/
331		RotMat3x3d getA(int snapshotNo) {
#	Line 325 | Line 333 | namespace oopse{
333		}
334
335		/**
336	<	* Sets  the previous rotation matrix of this stuntdouble
336	>	* Sets  the previous rotation matrix of this stuntDouble
337		* @param a  new rotation matrix
338		* @see #getA
339		*/
#	Line 334 | Line 342 | namespace oopse{
342		}
343
344		/**
345	<	* Sets  the current rotation matrix of this stuntdouble
345	>	* Sets  the current rotation matrix of this stuntDouble
346		* @param a  new rotation matrix
347		*/
348		virtual void setA(const RotMat3x3d& a) {
#	Line 342 | Line 350 | namespace oopse{
350		}
351
352		/**
353	<	* Sets  the rotation matrix of this stuntdouble in specified snapshot
353	>	* Sets  the rotation matrix of this stuntDouble in specified snapshot
354		* @param a rotation matrix to be set
355		* @param snapshotNo
356		* @see #getA
#	Line 352 | Line 360 | namespace oopse{
360		}
361
362		/**
363	<	* Returns the previous angular momentum of this stuntdouble (body-fixed).
364	<	* @return the angular momentum of this stuntdouble
363	>	* Returns the previous angular momentum of this stuntDouble (body-fixed).
364	>	* @return the angular momentum of this stuntDouble
365		*/
366		Vector3d getPrevJ() {
367		return ((snapshotMan_->getPrevSnapshot())->*storage_).angularMomentum[localIndex_];
368		}
369
370		/**
371	<	* Returns the current angular momentum of this stuntdouble (body -fixed).
372	<	* @return the angular momentum of this stuntdouble
371	>	* Returns the current angular momentum of this stuntDouble (body -fixed).
372	>	* @return the angular momentum of this stuntDouble
373		*/
374		Vector3d getJ() {
375		return ((snapshotMan_->getCurrentSnapshot())->*storage_).angularMomentum[localIndex_];
376		}
377
378		/**
379	<	* Returns the angular momentum of this stuntdouble in specified snapshot (body-fixed).
380	<	* @return the angular momentum of this stuntdouble
379	>	* Returns the angular momentum of this stuntDouble in specified snapshot (body-fixed).
380	>	* @return the angular momentum of this stuntDouble
381		* @param snapshotNo
382		*/
383		Vector3d getJ(int snapshotNo) {
#	Line 377 | Line 385 | namespace oopse{
385		}
386
387		/**
388	<	* Sets  the previous angular momentum of this stuntdouble (body-fixed).
388	>	* Sets  the previous angular momentum of this stuntDouble (body-fixed).
389		* @param angMom  new angular momentum
390		* @see #getJ
391		*/
#	Line 386 | Line 394 | namespace oopse{
394		}
395
396		/**
397	<	* Sets  the current angular momentum of this stuntdouble (body-fixed).
397	>	* Sets  the current angular momentum of this stuntDouble (body-fixed).
398		* @param angMom  new angular momentum
399		*/
400		void setJ(const Vector3d& angMom) {
#	Line 394 | Line 402 | namespace oopse{
402		}
403
404		/**
405	<	* Sets the angular momentum of this stuntdouble in specified snapshot(body-fixed).
405	>	* Sets the angular momentum of this stuntDouble in specified snapshot(body-fixed).
406		* @param angMom angular momentum to be set
407		* @param snapshotNo
408		* @see #getJ
#	Line 402 | Line 410 | namespace oopse{
410		void setJ(const Vector3d& angMom, int snapshotNo) {
411		((snapshotMan_->getSnapshot(snapshotNo))->*storage_).angularMomentum[localIndex_] = angMom;
412		}
413	<
413	>
414		/**
415	<	* Returns the previous quaternion of this stuntdouble
416	<	* @return the quaternion of this stuntdouble
415	>	* Returns system Center of Mass for stuntDouble frame from snapshot
416	>	*
417	>	*/
418	>	Vector3d getCOM(){
419	>	return (snapshotMan_->getCurrentSnapshot())->getCOM();
420	>	}
421	>
422	>	/**
423	>	* Returns system Center of Mass velocity for stuntDouble frame from snapshot
424	>	*
425	>	*/
426	>
427	>	Vector3d getCOMvel(){
428	>	return (snapshotMan_->getCurrentSnapshot())->getCOMvel();
429	>	}
430	>
431	>	/**
432	>	* Returns system Center of Mass angular momentum for stuntDouble frame from snapshot
433	>	*
434	>	*/
435	>	Vector3d getCOMw(){
436	>	return (snapshotMan_->getCurrentSnapshot())->getCOMw();
437	>	}
438	>
439	>	/**
440	>	* Returns system Center of Mass for stuntDouble frame from snapshot
441	>	*
442	>	*/
443	>	Vector3d getCOM(int snapshotNo){
444	>	return (snapshotMan_->getSnapshot(snapshotNo))->getCOM();
445	>	}
446	>
447	>	/**
448	>	* Returns system Center of Mass velocity for stuntDouble frame from snapshot
449	>	*
450	>	*/
451	>
452	>	Vector3d getCOMvel(int snapshotNo){
453	>	return (snapshotMan_->getSnapshot(snapshotNo))->getCOMvel();
454	>	}
455	>
456	>	/**
457	>	* Returns system Center of Mass angular momentum for stuntDouble frame from snapshot
458	>	*
459	>	*/
460	>	Vector3d getCOMw(int snapshotNo){
461	>	return (snapshotMan_->getSnapshot(snapshotNo))->getCOMw();
462	>	}
463	>
464	>	/**
465	>	* Returns the previous quaternion of this stuntDouble
466	>	* @return the quaternion of this stuntDouble
467		*/
468		Quat4d getPrevQ() {
469		return ((snapshotMan_->getPrevSnapshot())->*storage_).aMat[localIndex_].toQuaternion();
470		}
471
472		/**
473	<	* Returns the current quaternion of this stuntdouble
474	<	* @return the quaternion of this stuntdouble
473	>	* Returns the current quaternion of this stuntDouble
474	>	* @return the quaternion of this stuntDouble
475		*/
476		Quat4d getQ() {
477		return ((snapshotMan_->getCurrentSnapshot())->*storage_).aMat[localIndex_].toQuaternion();
478		}
479
480		/**
481	<	* Returns the quaternion of this stuntdouble in specified snapshot
482	<	* @return the quaternion of this stuntdouble
481	>	* Returns the quaternion of this stuntDouble in specified snapshot
482	>	* @return the quaternion of this stuntDouble
483		* @param snapshotNo
484		*/
485		Quat4d getQ(int snapshotNo) {
#	Line 429 | Line 487 | namespace oopse{
487		}
488
489		/**
490	<	* Sets  the previous quaternion of this stuntdouble
490	>	* Sets  the previous quaternion of this stuntDouble
491		* @param q  new quaternion
492		* @note actual storage data is rotation matrix
493		*/
#	Line 438 | Line 496 | namespace oopse{
496		}
497
498		/**
499	<	* Sets  the current quaternion of this stuntdouble
499	>	* Sets  the current quaternion of this stuntDouble
500		* @param q  new quaternion
501		* @note actual storage data is rotation matrix
502		*/
#	Line 447 | Line 505 | namespace oopse{
505		}
506
507		/**
508	<	* Sets  the quaternion of this stuntdouble in specified snapshot
508	>	* Sets  the quaternion of this stuntDouble in specified snapshot
509		*
510		* @param q quaternion to be set
511		* @param snapshotNo
#	Line 458 | Line 516 | namespace oopse{
516		}
517
518		/**
519	<	* Returns the previous euler angles of this stuntdouble
520	<	* @return the euler angles of this stuntdouble
519	>	* Returns the previous euler angles of this stuntDouble
520	>	* @return the euler angles of this stuntDouble
521		*/
522		Vector3d getPrevEuler() {
523		return ((snapshotMan_->getPrevSnapshot())->*storage_).aMat[localIndex_].toEulerAngles();
524		}
525
526		/**
527	<	* Returns the current euler angles of this stuntdouble
528	<	* @return the euler angles of this stuntdouble
527	>	* Returns the current euler angles of this stuntDouble
528	>	* @return the euler angles of this stuntDouble
529		*/
530		Vector3d getEuler() {
531		return ((snapshotMan_->getCurrentSnapshot())->*storage_).aMat[localIndex_].toEulerAngles();
532		}
533
534		/**
535	<	* Returns the euler angles of this stuntdouble in specified snapshot.
536	<	* @return the euler angles of this stuntdouble
535	>	* Returns the euler angles of this stuntDouble in specified snapshot.
536	>	* @return the euler angles of this stuntDouble
537		* @param snapshotNo
538		*/
539		Vector3d getEuler(int snapshotNo) {
#	Line 483 | Line 541 | namespace oopse{
541		}
542
543		/**
544	<	* Sets  the previous euler angles of this stuntRealType.
544	>	* Sets  the previous euler angles of this stuntDouble.
545		* @param euler  new euler angles
546		* @see #getEuler
547		* @note actual storage data is rotation matrix
#	Line 493 | Line 551 | namespace oopse{
551		}
552
553		/**
554	<	* Sets  the current euler angles of this stuntdouble
554	>	* Sets  the current euler angles of this stuntDouble
555		* @param euler  new euler angles
556		*/
557		void setEuler(const Vector3d& euler) {
#	Line 501 | Line 559 | namespace oopse{
559		}
560
561		/**
562	<	* Sets  the euler angles  of this stuntdouble in specified snapshot
562	>	* Sets  the euler angles  of this stuntDouble in specified snapshot
563		*
564		* @param euler euler angles to be set
565		* @param snapshotNo
#	Line 512 | Line 570 | namespace oopse{
570		}
571
572		/**
573	<	* Returns the previous unit vectors of this stuntdouble
574	<	* @return the unit vectors of this stuntdouble
573	>	* Returns the previous unit vectors of this stuntDouble
574	>	* @return the unit vectors of this stuntDouble
575		*/
576		RotMat3x3d getPrevElectroFrame() {
577		return ((snapshotMan_->getPrevSnapshot())->*storage_).electroFrame[localIndex_];
578		}
579
580		/**
581	<	* Returns the current unit vectors of this stuntdouble
582	<	* @return the unit vectors of this stuntdouble
581	>	* Returns the current unit vectors of this stuntDouble
582	>	* @return the unit vectors of this stuntDouble
583		*/
584		RotMat3x3d getElectroFrame() {
585		return ((snapshotMan_->getCurrentSnapshot())->*storage_).electroFrame[localIndex_];
586		}
587
588		/**
589	<	* Returns the unit vectors of this stuntdouble in specified snapshot
589	>	* Returns the unit vectors of this stuntDouble in specified snapshot
590		*
591	<	* @return the unit vectors of this stuntdouble
591	>	* @return the unit vectors of this stuntDouble
592		* @param snapshotNo
593		*/
594		RotMat3x3d getElectroFrame(int snapshotNo) {
#	Line 538 | Line 596 | namespace oopse{
596		}
597
598		/**
599	<	* Returns the previous force of this stuntdouble
600	<	* @return the force of this stuntdouble
599	>	* Returns the previous force of this stuntDouble
600	>	* @return the force of this stuntDouble
601		*/
602		Vector3d getPrevFrc() {
603		return ((snapshotMan_->getPrevSnapshot())->*storage_).force[localIndex_];
604		}
605
606		/**
607	<	* Returns the current force of this stuntdouble
608	<	* @return the force of this stuntdouble
607	>	* Returns the current force of this stuntDouble
608	>	* @return the force of this stuntDouble
609		*/
610		Vector3d getFrc() {
611		return ((snapshotMan_->getCurrentSnapshot())->*storage_).force[localIndex_];
612		}
613
614		/**
615	<	* Returns the force of this stuntdouble in specified snapshot
615	>	* Returns the force of this stuntDouble in specified snapshot
616		*
617	<	* @return the force of this stuntdouble
617	>	* @return the force of this stuntDouble
618		* @param snapshotNo
619		*/
620		Vector3d getFrc(int snapshotNo) {
#	Line 564 | Line 622 | namespace oopse{
622		}
623
624		/**
625	<	* Sets  the previous force of this stuntdouble
625	>	* Sets  the previous force of this stuntDouble
626		*
627		* @param frc  new force
628		* @see #getFrc
#	Line 574 | Line 632 | namespace oopse{
632		}
633
634		/**
635	<	* Sets  the current force of this stuntdouble
635	>	* Sets  the current force of this stuntDouble
636		* @param frc  new force
637		*/
638		void setFrc(const Vector3d& frc) {
#	Line 582 | Line 640 | namespace oopse{
640		}
641
642		/**
643	<	* Sets  the force of this stuntdouble in specified snapshot
643	>	* Sets  the force of this stuntDouble in specified snapshot
644		*
645		* @param frc force to be set
646		* @param snapshotNo
#	Line 593 | Line 651 | namespace oopse{
651		}
652
653		/**
654	<	* Adds force into the previous force of this stuntdouble
654	>	* Adds force into the previous force of this stuntDouble
655		*
656		* @param frc  new force
657		* @see #getFrc
#	Line 603 | Line 661 | namespace oopse{
661		}
662
663		/**
664	<	* Adds force into the current force of this stuntdouble
664	>	* Adds force into the current force of this stuntDouble
665		* @param frc  new force
666		*/
667		void addFrc(const Vector3d& frc) {
#	Line 611 | Line 669 | namespace oopse{
669		}
670
671		/**
672	<	* Adds force into the force of this stuntdouble in specified snapshot
672	>	* Adds force into the force of this stuntDouble in specified snapshot
673		*
674		* @param frc force to be set
675		* @param snapshotNo
#	Line 622 | Line 680 | namespace oopse{
680		}
681
682		/**
683	<	* Returns the previous torque of this stuntdouble
684	<	* @return the torque of this stuntdouble
683	>	* Returns the previous torque of this stuntDouble
684	>	* @return the torque of this stuntDouble
685		*/
686		Vector3d getPrevTrq() {
687		return ((snapshotMan_->getPrevSnapshot())->*storage_).torque[localIndex_];
688		}
689
690		/**
691	<	* Returns the current torque of this stuntdouble
692	<	* @return the torque of this stuntdouble
691	>	* Returns the current torque of this stuntDouble
692	>	* @return the torque of this stuntDouble
693		*/
694		Vector3d getTrq() {
695		return ((snapshotMan_->getCurrentSnapshot())->*storage_).torque[localIndex_];
696		}
697
698		/**
699	<	* Returns the torque of this stuntdouble in specified snapshot
699	>	* Returns the torque of this stuntDouble in specified snapshot
700		*
701	<	* @return the torque of this stuntdouble
701	>	* @return the torque of this stuntDouble
702		* @param snapshotNo
703		*/
704		Vector3d getTrq(int snapshotNo) {
#	Line 648 | Line 706 | namespace oopse{
706		}
707
708		/**
709	<	* Sets  the previous torque of this stuntdouble
709	>	* Sets  the previous torque of this stuntDouble
710		*
711		* @param trq  new torque
712		* @see #getTrq
#	Line 658 | Line 716 | namespace oopse{
716		}
717
718		/**
719	<	* Sets  the current torque of this stuntdouble
719	>	* Sets  the current torque of this stuntDouble
720		* @param trq  new torque
721		*/
722		void setTrq(const Vector3d& trq) {
#	Line 666 | Line 724 | namespace oopse{
724		}
725
726		/**
727	<	* Sets  the torque of this stuntdouble in specified snapshot
727	>	* Sets  the torque of this stuntDouble in specified snapshot
728		*
729		* @param trq torque to be set
730		* @param snapshotNo
#	Line 677 | Line 735 | namespace oopse{
735		}
736
737		/**
738	<	* Adds torque into the previous torque of this stuntdouble
738	>	* Adds torque into the previous torque of this stuntDouble
739		*
740		* @param trq  new torque
741		* @see #getTrq
#	Line 687 | Line 745 | namespace oopse{
745		}
746
747		/**
748	<	* Adds torque into the current torque of this stuntdouble
748	>	* Adds torque into the current torque of this stuntDouble
749		* @param trq  new torque
750		*/
751		void addTrq(const Vector3d& trq) {
#	Line 695 | Line 753 | namespace oopse{
753		}
754
755		/**
756	<	* Adds torque into the torque of this stuntdouble in specified snapshot
756	>	* Adds torque into the torque of this stuntDouble in specified snapshot
757		*
758		* @param trq torque to be add
759		* @param snapshotNo
#	Line 706 | Line 764 | namespace oopse{
764		}
765
766
767	+
768		/**
769	<	* Returns the previous z-angle of this stuntdouble
770	<	* @return the z-angle of this stuntdouble
769	>	* Returns the previous particlePot of this stuntDouble
770	>	* @return the particlePot of this stuntDouble
771	>	*/
772	>	RealType getPrevParticlePot() {
773	>	return ((snapshotMan_->getPrevSnapshot())->*storage_).particlePot[localIndex_];
774	>	}
775	>
776	>	/**
777	>	* Returns the current particlePot of this stuntDouble
778	>	* @return the particlePot of this stuntDouble
779	>	*/
780	>	RealType getParticlePot() {
781	>	return ((snapshotMan_->getCurrentSnapshot())->*storage_).particlePot[localIndex_];
782	>	}
783	>
784	>	/**
785	>	* Returns the particlePot of this stuntDouble in specified snapshot
786	>	*
787	>	* @return the particlePot of this stuntDouble
788	>	* @param snapshotNo
789	>	*/
790	>	RealType getParticlePot(int snapshotNo) {
791	>	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).particlePot[localIndex_];
792	>	}
793	>
794	>	/**
795	>	* Sets  the previous particlePot of this stuntDouble
796	>	*
797	>	* @param particlePot  new particlePot
798	>	* @see #getParticlePot
799	>	*/
800	>	void setPrevParticlePot(const RealType& particlePot) {
801	>	((snapshotMan_->getPrevSnapshot())->*storage_).particlePot[localIndex_] = particlePot;
802	>	}
803	>
804	>	/**
805	>	* Sets  the current particlePot of this stuntDouble
806	>	* @param particlePot  new particlePot
807	>	*/
808	>	void setParticlePot(const RealType& particlePot) {
809	>	((snapshotMan_->getCurrentSnapshot())->*storage_).particlePot[localIndex_] = particlePot;
810	>	}
811	>
812	>	/**
813	>	* Sets  the particlePot of this stuntDouble in specified snapshot
814	>	*
815	>	* @param particlePot particlePot to be set
816	>	* @param snapshotNo
817	>	* @see #getParticlePot
818	>	*/
819	>	void setParticlePot(const RealType& particlePot, int snapshotNo) {
820	>	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).particlePot[localIndex_] = particlePot;
821	>	}
822	>
823	>	/**
824	>	* Adds particlePot into the previous particlePot of this stuntDouble
825	>	*
826	>	* @param particlePot  new particlePot
827	>	* @see #getParticlePot
828	>	*/
829	>	void addPrevParticlePot(const RealType& particlePot) {
830	>	((snapshotMan_->getPrevSnapshot())->*storage_).particlePot[localIndex_] += particlePot;
831	>	}
832	>
833	>	/**
834	>	* Adds particlePot into the current particlePot of this stuntDouble
835	>	* @param particlePot  new particlePot
836	>	*/
837	>	void addParticlePot(const RealType& particlePot) {
838	>	((snapshotMan_->getCurrentSnapshot())->*storage_).particlePot[localIndex_] += particlePot;
839	>	}
840	>
841	>	/**
842	>	* Adds particlePot into the particlePot of this stuntDouble in specified snapshot
843	>	*
844	>	* @param particlePot particlePot to be add
845	>	* @param snapshotNo
846	>	* @see #getParticlePot
847	>	*/
848	>	void addParticlePot(const RealType& particlePot, int snapshotNo) {
849	>	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).particlePot[localIndex_] += particlePot;
850	>	}
851	>
852	>
853	>	/**
854	>	* Returns the previous z-angle of this stuntDouble
855	>	* @return the z-angle of this stuntDouble
856		*/
857		RealType getPrevZangle() {
858		return ((snapshotMan_->getPrevSnapshot())->*storage_).zAngle[localIndex_];
859		}
860
861		/**
862	<	* Returns the current z-angle of this stuntdouble
863	<	* @return the z-angle of this stuntdouble
862	>	* Returns the current z-angle of this stuntDouble
863	>	* @return the z-angle of this stuntDouble
864		*/
865		RealType getZangle() {
866		return ((snapshotMan_->getCurrentSnapshot())->*storage_).zAngle[localIndex_];
867		}
868
869		/**
870	<	* Returns the z-angle of this stuntdouble in specified snapshot
871	<	* @return the z-angle of this stuntdouble
870	>	* Returns the z-angle of this stuntDouble in specified snapshot
871	>	* @return the z-angle of this stuntDouble
872		* @param snapshotNo
873		*/
874		RealType getZangle(int snapshotNo) {
#	Line 732 | Line 876 | namespace oopse{
876		}
877
878		/**
879	<	* Sets  the previous z-angle of this stuntdouble
879	>	* Sets  the previous z-angle of this stuntDouble
880		* @param angle  new z-angle
881		* @see #getZangle
882		*/
#	Line 741 | Line 885 | namespace oopse{
885		}
886
887		/**
888	<	* Sets  the current z-angle of this stuntdouble
888	>	* Sets  the current z-angle of this stuntDouble
889		* @param angle  new z-angle
890		*/
891		void setZangle(RealType angle) {
#	Line 749 | Line 893 | namespace oopse{
893		}
894
895		/**
896	<	* Sets  the z-angle of this stuntdouble in specified snapshot
896	>	* Sets  the z-angle of this stuntDouble in specified snapshot
897		* @param angle z-angle to be set
898		* @param snapshotNo
899		* @see #getZangle
#	Line 759 | Line 903 | namespace oopse{
903		}
904
905		/**
906	<	* Adds z-angle into the previous z-angle of this stuntdouble
906	>	* Adds z-angle into the previous z-angle of this stuntDouble
907		* @param angle  new z-angle
908		* @see #getZangle
909		*/
#	Line 768 | Line 912 | namespace oopse{
912		}
913
914		/**
915	<	* Adds z-angle into the current z-angle of this stuntdouble
915	>	* Adds z-angle into the current z-angle of this stuntDouble
916		* @param angle  new z-angle
917		*/
918		void addZangle(RealType angle) {
#	Line 776 | Line 920 | namespace oopse{
920		}
921
922		/**
923	<	* Adds z-angle into the z-angle of this stuntdouble in specified snapshot
923	>	* Adds z-angle into the z-angle of this stuntDouble in specified snapshot
924		* @param angle z-angle to be add
925		* @param snapshotNo
926		* @see #getZangle
#	Line 785 | Line 929 | namespace oopse{
929		((snapshotMan_->getSnapshot(snapshotNo))->*storage_).zAngle[localIndex_] += angle;
930		}
931
932	<	/** Set the force of this stuntdouble to zero */
932	>	/** Set the force of this stuntDouble to zero */
933		void zeroForcesAndTorques();
934		/**
935	<	* Returns the inertia tensor of this stuntdouble
936	<	* @return the inertia tensor of this stuntdouble
935	>	* Returns the inertia tensor of this stuntDouble
936	>	* @return the inertia tensor of this stuntDouble
937		*/
938		virtual Mat3x3d getI() = 0;
939
940		/**
941	<	* Returns the gradient of this stuntdouble
942	<	* @return the gradient of this stuntdouble
941	>	* Returns the gradient of this stuntDouble
942	>	* @return the gradient of this stuntDouble
943		*/
944		virtual std::vector<RealType> getGrad() = 0;
945
946		/**
947	<	* Tests the  if this stuntdouble is a  linear rigidbody
947	>	* Tests the  if this stuntDouble is a  linear rigidbody
948		*
949	<	* @return true if this stuntdouble is a  linear rigidbody, otherwise return false
949	>	* @return true if this stuntDouble is a  linear rigidbody, otherwise return false
950		* @note atom and directional atom will always return false
951		*
952		* @see #linearAxis
#	Line 822 | Line 966 | namespace oopse{
966		return linearAxis_;
967		}
968
969	<	/** Returns the mass of this stuntdouble */
969	>	/** Returns the mass of this stuntDouble */
970		RealType getMass() {
971		return mass_;
972		}
#	Line 835 | Line 979 | namespace oopse{
979		mass_ = mass;
980		}
981
982	<	/** Returns the name of this stuntdouble */
982	>	/** Returns the name of this stuntDouble */
983		virtual std::string getType() = 0;
984
985	<	/** Sets the name of this stuntRealType*/
985	>	/** Sets the name of this stuntDouble*/
986		virtual void setType(const std::string& name) {}
987
988		/**
#	Line 866 | Line 1010 | namespace oopse{
1010		Vector3d body2Lab(const Vector3d& v, int frame){
1011		return getA(frame).transpose() * v;
1012		}
1013	+
1014		/**
1015		* <p>
1016	<	* The purpose of the Visitor Pattern is to encapsulate an operation that you want to perform on
1017	<	* the elements of a data structure. In this way, you can change the operation being performed
1018	<	* on a structure without the need of changing the classes of the elements that you are operating
1019	<	* on. Using a Visitor pattern allows you to decouple the classes for the data structure and the
1020	<	* algorithms used upon them
1016	>	* The purpose of the Visitor Pattern is to encapsulate an
1017	>	* operation that you want to perform on the elements of a data
1018	>	* structure. In this way, you can change the operation being
1019	>	* performed on a structure without the need of changing the
1020	>	* classes of the elements that you are operating on. Using a
1021	>	* Visitor pattern allows you to decouple the classes for the data
1022	>	* structure and the algorithms used upon them
1023		* </p>
1024		* @param v visitor
1025		*/
#	Line 932 | Line 1079 | namespace oopse{
1079
1080
1081		int globalIndex_;
1082	+	int globalIntegrableObjectIndex_;
1083		int localIndex_;
1084
1085
#	Line 942 | Line 1090 | namespace oopse{
1090		PropertyMap properties_;
1091		};
1092
1093	<	}//end namespace oopse
1093	>	}//end namespace OpenMD
1094		#endif //PRIMITIVES_STUNTDOUBLE_HPP

Comparing:
trunk/src/primitives/StuntDouble.hpp (property svn:keywords), Revision 963 by tim, Wed May 17 21:51:42 2006 UTC vs.
branches/development/src/primitives/StuntDouble.hpp (property svn:keywords), Revision 1702 by kstocke1, Thu Apr 5 19:49:59 2012 UTC

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

Diff Legend

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