ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/test/brains/StuntDouble.hpp
(Generate patch)

Comparing trunk/test/brains/StuntDouble.hpp (file contents):
Revision 151 by tim, Mon Oct 25 22:46:19 2004 UTC vs.
Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC

# Line 1 | Line 1
1   /*
2 < * Copyright (C) 2000-2004  Object Oriented Parallel Simulation Engine (OOPSE) project
2 > * Copyright (C) 2000-2009  The Open Molecular Dynamics Engine (OpenMD) project
3   *
4 < * Contact: oopse@oopse.org
4 > * Contact: gezelter@openscience.org
5   *
6   * This program is free software; you can redistribute it and/or
7   * modify it under the terms of the GNU Lesser General Public License
# Line 35 | Line 35
35  
36   #include <vector>
37  
38 < #include <core/BaseVisitor.hpp>
39 < #include <math/Quaternion.hpp>
40 < #include <math/SquareMatrix3.hpp>
41 < #include <math/Vector3.hpp>
42 < #include <utils/PropertyMap.hpp>
38 > #include "visitors/BaseVisitor.hpp"
39 > #include "math/Quaternion.hpp"
40 > #include "math/SquareMatrix3.hpp"
41 > #include "math/Vector3.hpp"
42 > #include "utils/PropertyMap.hpp"
43 > #include "brains/SnapshotManager.hpp"
44 > namespace OpenMD{
45  
44 – namespace oopse{
46  
46 –
47    
48    /**
49     * @class StuntDouble StuntDouble.hpp "Primitives/StuntDouble.hpp"
# Line 80 | Line 80 | namespace oopse{
80           * Sets the global index of this stuntdouble.
81           * @param new global index to be set
82           */
83 <        void setGlobalIndex(int index) {
83 >        int setGlobalIndex(int index) {
84              return globalIndex_;
85          }
86          
# Line 136 | Line 136 | namespace oopse{
136           * Returns the previous position of this stuntdouble
137           * @return the position of this stuntdouble
138           */    
139 <        void Vector3d getPrevPos() {
140 <            return (snapshotMan_->getPrevSnapshot())->storage_->position[LocalIndex_];
139 >        Vector3d getPrevPos() {
140 >            return ((snapshotMan_->getPrevSnapshot())->*storage_).position[localIndex_];
141          }
142        
143          /**
144           * Returns the current position of this stuntdouble
145           * @return the position of this stuntdouble
146           */    
147 <        void Vector3d getPos() {
148 <            return (snapshotMan_->getCurrentSnapshot())->storage_->position[LocalIndex_];
147 >        Vector3d getPos() {
148 >            return ((snapshotMan_->getCurrentSnapshot())->*storage_).position[localIndex_];
149          }
150  
151         /**
# Line 154 | Line 154 | namespace oopse{
154           * @param snapshotNo
155           */    
156          Vector3d getPos(int snapshotNo) {
157 <            return (snapshotMan_->getSnapshot(snapShotNo))->storage_->position[LocalIndex_];
157 >            return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).position[localIndex_];
158          }
159  
160         /**
# Line 163 | Line 163 | namespace oopse{
163           * @see #getPos
164           */        
165         void setPrevPos(const Vector3d& pos) {
166 <            (snapshotMan_->getPrevSnapshot())->storage_->position[LocalIndex_] = pos;
166 >            ((snapshotMan_->getPrevSnapshot())->*storage_).position[localIndex_] = pos;
167         }
168        
169         /**
# Line 171 | Line 171 | namespace oopse{
171           * @param pos  new position
172           */        
173          void setPos(const Vector3d& pos) {
174 <            (snapshotMan_->getCurrentSnapshot())->storage_->position[LocalIndex_] = pos;
174 >            ((snapshotMan_->getCurrentSnapshot())->*storage_).position[localIndex_] = pos;
175          }
176  
177         /**
# Line 181 | Line 181 | namespace oopse{
181           * @see #getPos
182           */        
183          void setPos(const Vector3d& pos, int snapshotNo) {
184 <            (snapshotMan_->getSnapshot(snapshotNo))->storage_->position[LocalIndex_] = pos;
184 >            ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).position[localIndex_] = pos;
185          }
186        
187         /**
# Line 189 | Line 189 | namespace oopse{
189           * @return the velocity of this stuntdouble
190           */    
191          Vector3d getPrevVel() {
192 <            return (snapshotMan_->getPrevSnapshot())->storage_->velocity[LocalIndex_];
192 >            return ((snapshotMan_->getPrevSnapshot())->*storage_).velocity[localIndex_];
193          }
194        
195          /**
# Line 197 | Line 197 | namespace oopse{
197           * @return the velocity of this stuntdouble
198           */    
199          Vector3d getVel() {
200 <            return (snapshotMan_->getCurrentSnapshot())->storage_->velocity[LocalIndex_];
200 >            return ((snapshotMan_->getCurrentSnapshot())->*storage_).velocity[localIndex_];
201          }
202  
203         /**
# Line 206 | Line 206 | namespace oopse{
206           * @param snapshotNo
207           */    
208           Vector3d getVel(int snapshotNo) {
209 <            return (snapshotMan_->getSnapshot(snapShotNo))->storage_->velocity[LocalIndex_];
209 >            return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).velocity[localIndex_];
210          }
211  
212         /**
# Line 215 | Line 215 | namespace oopse{
215           * @see #getVel
216           */        
217         void setPrevVel(const Vector3d& vel) {
218 <            (snapshotMan_->getPrevSnapshot())->storage_->velocity[LocalIndex_] = vel;
218 >            ((snapshotMan_->getPrevSnapshot())->*storage_).velocity[localIndex_] = vel;
219         }
220        
221         /**
# Line 223 | Line 223 | namespace oopse{
223           * @param vel  new velocity
224           */        
225          void setVel(const Vector3d& vel) {
226 <            (snapshotMan_->getCurrentSnapshot())->storage_->velocity[LocalIndex_] = vel;
226 >            ((snapshotMan_->getCurrentSnapshot())->*storage_).velocity[localIndex_] = vel;
227          }
228  
229         /**
# Line 233 | Line 233 | namespace oopse{
233           * @see #getVel
234           */        
235          void setVel(const Vector3d& vel, int snapshotNo) {
236 <            (snapshotMan_->getSnapshot(snapshotNo))->storage_->velocity[LocalIndex_] = vel;
236 >            ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).velocity[localIndex_] = vel;
237          }
238  
239         /**
# Line 241 | Line 241 | namespace oopse{
241           * @return the rotation matrix of this stuntdouble
242           */    
243          RotMat3x3d getPrevA() {
244 <            return (snapshotMan_->getPrevSnapshot())->storage_->aMat[LocalIndex_];
244 >            return ((snapshotMan_->getPrevSnapshot())->*storage_).aMat[localIndex_];
245          }
246        
247          /**
# Line 249 | Line 249 | namespace oopse{
249           * @return the rotation matrix of this stuntdouble
250           */    
251          RotMat3x3d getA() {
252 <            return (snapshotMan_->getCurrentSnapshot())->storage_->aMat[LocalIndex_];
252 >            return ((snapshotMan_->getCurrentSnapshot())->*storage_).aMat[localIndex_];
253          }
254  
255         /**
# Line 259 | Line 259 | namespace oopse{
259           * @param snapshotNo
260           */    
261           RotMat3x3d getA(int snapshotNo) {
262 <            return (snapshotMan_->getSnapshot(snapShotNo))->storage_->aMat[LocalIndex_];
262 >            return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).aMat[localIndex_];
263          }
264  
265         /**
# Line 267 | Line 267 | namespace oopse{
267           * @param a  new rotation matrix
268           * @see #getA
269           */        
270 <       void setPrevA(const RotMat3x3d& a) {
271 <            (snapshotMan_->getPrevSnapshot())->storage_->aMat[LocalIndex_] = a;
270 >       virtual void setPrevA(const RotMat3x3d& a) {
271 >            ((snapshotMan_->getPrevSnapshot())->*storage_).aMat[localIndex_] = a;
272         }
273        
274         /**
275           * Sets  the current rotation matrix of this stuntdouble
276           * @param a  new rotation matrix
277           */        
278 <        void setA(const RotMat3x3d& a) {
279 <            (snapshotMan_->getCurrentSnapshot())->storage_->aMat[LocalIndex_] = a;
278 >        virtual void setA(const RotMat3x3d& a) {
279 >            ((snapshotMan_->getCurrentSnapshot())->*storage_).aMat[localIndex_] = a;
280          }
281  
282         /**
# Line 285 | Line 285 | namespace oopse{
285           * @param snapshotNo
286           * @see #getA
287           */        
288 <        void setA(const RotMat3x3d& a, int snapshotNo) {
289 <            (snapshotMan_->getSnapshot(snapshotNo))->storage_->aMat[LocalIndex_] = a;
288 >        virtual void setA(const RotMat3x3d& a, int snapshotNo) {
289 >            ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).aMat[localIndex_] = a;
290          }      
291  
292         /**
293 <         * Returns the previous angular momentum of this stuntdouble
293 >         * Returns the previous angular momentum of this stuntdouble (body-fixed).
294           * @return the angular momentum of this stuntdouble
295           */    
296          Vector3d getPrevJ() {
297 <            return (snapshotMan_->getPrevSnapshot())->storage_->angularMomentum[LocalIndex_];
297 >            return ((snapshotMan_->getPrevSnapshot())->*storage_).angularMomentum[localIndex_];
298          }
299        
300          /**
301 <         * Returns the current angular momentum of this stuntdouble
301 >         * Returns the current angular momentum of this stuntdouble (body -fixed).
302           * @return the angular momentum of this stuntdouble
303           */    
304          Vector3d getJ() {
305 <            return (snapshotMan_->getCurrentSnapshot())->storage_->angularMomentum[LocalIndex_];
305 >            return ((snapshotMan_->getCurrentSnapshot())->*storage_).angularMomentum[localIndex_];
306          }
307  
308         /**
309 <         * Returns the angular momentum of this stuntdouble in specified snapshot
309 >         * Returns the angular momentum of this stuntdouble in specified snapshot (body-fixed).
310           * @return the angular momentum of this stuntdouble
311           * @param snapshotNo
312           */    
313           Vector3d getJ(int snapshotNo) {
314 <            return (snapshotMan_->getSnapshot(snapShotNo))->storage_->angularMomentum[LocalIndex_];
314 >            return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).angularMomentum[localIndex_];
315          }
316  
317         /**
318 <         * Sets  the previous angular momentum of this stuntdouble
318 >         * Sets  the previous angular momentum of this stuntdouble (body-fixed).
319           * @param angMom  new angular momentum
320           * @see #getJ
321           */        
322         void setPrevJ(const Vector3d& angMom) {
323 <            (snapshotMan_->getPrevSnapshot())->storage_->angularMomentum[LocalIndex_] = angMom;
323 >            ((snapshotMan_->getPrevSnapshot())->*storage_).angularMomentum[localIndex_] = angMom;
324         }
325        
326         /**
327 <         * Sets  the current angular momentum of this stuntdouble
327 >         * Sets  the current angular momentum of this stuntdouble (body-fixed).
328           * @param angMom  new angular momentum
329           */        
330          void setJ(const Vector3d& angMom) {
331 <            (snapshotMan_->getCurrentSnapshot())->storage_->angularMomentum[LocalIndex_] = angMom;
331 >            ((snapshotMan_->getCurrentSnapshot())->*storage_).angularMomentum[localIndex_] = angMom;
332          }
333  
334         /**
335 <         * Sets the angular momentum of this stuntdouble in specified snapshot
335 >         * Sets the angular momentum of this stuntdouble in specified snapshot(body-fixed).
336           * @param angMom angular momentum to be set
337           * @param snapshotNo
338           * @see #getJ
339           */        
340          void setJ(const Vector3d& angMom, int snapshotNo) {
341 <            (snapshotMan_->getSnapshot(snapshotNo))->storage_->angularMomentum[LocalIndex_] = angMom;
341 >            ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).angularMomentum[localIndex_] = angMom;
342          }
343          
344         /**
# Line 346 | Line 346 | namespace oopse{
346           * @return the quaternion of this stuntdouble
347           */    
348          Quat4d getPrevQ() {
349 <            return (snapshotMan_->getPrevSnapshot())->storage_->aMat[LocalIndex_].toQuaternion();
349 >            return ((snapshotMan_->getPrevSnapshot())->*storage_).aMat[localIndex_].toQuaternion();
350          }
351        
352          /**
# Line 354 | Line 354 | namespace oopse{
354           * @return the quaternion of this stuntdouble
355           */    
356          Quat4d getQ() {
357 <            return (snapshotMan_->getCurrentSnapshot())->storage_->aMat[LocalIndex_].toQuaternion();
357 >            return ((snapshotMan_->getCurrentSnapshot())->*storage_).aMat[localIndex_].toQuaternion();
358          }
359  
360         /**
# Line 363 | Line 363 | namespace oopse{
363           * @param snapshotNo
364           */    
365           Quat4d getQ(int snapshotNo) {
366 <            return (snapshotMan_->getSnapshot(snapShotNo))->storage_->aMat[LocalIndex_].toQuaternion();
366 >            return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).aMat[localIndex_].toQuaternion();
367          }
368  
369         /**
370           * Sets  the previous quaternion of this stuntdouble
371           * @param q  new quaternion
372 <         * @see #getQ
372 >         * @note actual storage data is rotation matrix
373           */        
374         void setPrevQ(const Quat4d& q) {
375 <            (snapshotMan_->getPrevSnapshot())->storage_->aMat[LocalIndex_] = q;
375 >            ((snapshotMan_->getPrevSnapshot())->*storage_).aMat[localIndex_] = q;
376         }
377        
378         /**
379           * Sets  the current quaternion of this stuntdouble
380           * @param q  new quaternion
381 +         * @note actual storage data is rotation matrix
382           */        
383          void setQ(const Quat4d& q) {
384 <            (snapshotMan_->getCurrentSnapshot())->storage_->aMat[LocalIndex_] = q;
384 >            ((snapshotMan_->getCurrentSnapshot())->*storage_).aMat[localIndex_] = q;
385          }
386  
387         /**
# Line 388 | Line 389 | namespace oopse{
389           *
390           * @param q quaternion to be set
391           * @param snapshotNo
392 <         * @see #getQ
392 >         * @note actual storage data is rotation matrix
393           */        
394          void setQ(const Quat4d& q, int snapshotNo) {
395 <            (snapshotMan_->getSnapshot(snapshotNo))->storage_->aMat[LocalIndex_] = q;
395 >            ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).aMat[localIndex_] = q;
396          }
397  
398         /**
# Line 399 | Line 400 | namespace oopse{
400           * @return the euler angles of this stuntdouble
401           */    
402          Vector3d getPrevEuler() {
403 <            return (snapshotMan_->getPrevSnapshot())->storage_->aMat[LocalIndex_].toEulerAngles();
403 >            return ((snapshotMan_->getPrevSnapshot())->*storage_).aMat[localIndex_].toEulerAngles();
404          }
405        
406          /**
# Line 407 | Line 408 | namespace oopse{
408           * @return the euler angles of this stuntdouble
409           */    
410          Vector3d getEuler() {
411 <            return (snapshotMan_->getCurrentSnapshot())->storage_->aMat[LocalIndex_].toEulerAngles();
411 >            return ((snapshotMan_->getCurrentSnapshot())->*storage_).aMat[localIndex_].toEulerAngles();
412          }
413  
414         /**
415 <         * Returns the euler angles of this stuntdouble in specified snapshot
415 <         *
415 >         * Returns the euler angles of this stuntdouble in specified snapshot.
416           * @return the euler angles of this stuntdouble
417           * @param snapshotNo
418           */    
419           Vector3d getEuler(int snapshotNo) {
420 <            return (snapshotMan_->getSnapshot(snapShotNo))->storage_->aMat[LocalIndex_].toEulerAngles();
420 >            return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).aMat[localIndex_].toEulerAngles();
421          }
422  
423         /**
424 <         * Sets  the previous euler angles of this stuntdouble
425 <         *
424 >         * Sets  the previous euler angles of this stuntdouble.
425           * @param euler  new euler angles
426           * @see #getEuler
427 +         * @note actual storage data is rotation matrix        
428           */        
429         void setPrevEuler(const Vector3d& euler) {
430 <            (snapshotMan_->getPrevSnapshot())->storage_->aMat[LocalIndex_] = euler;
430 >            ((snapshotMan_->getPrevSnapshot())->*storage_).aMat[localIndex_] = euler;
431         }
432        
433         /**
# Line 435 | Line 435 | namespace oopse{
435           * @param euler  new euler angles
436           */        
437          void setEuler(const Vector3d& euler) {
438 <            (snapshotMan_->getCurrentSnapshot())->storage_->aMat[LocalIndex_] = euler;
438 >            ((snapshotMan_->getCurrentSnapshot())->*storage_).aMat[localIndex_] = euler;
439          }
440  
441         /**
# Line 443 | Line 443 | namespace oopse{
443           *
444           * @param euler euler angles to be set
445           * @param snapshotNo
446 <         * @see #getEuler
446 >         * @note actual storage data is rotation matrix                  
447           */        
448          void setEuler(const Vector3d& euler, int snapshotNo) {
449 <            (snapshotMan_->getSnapshot(snapshotNo))->storage_->aMat[LocalIndex_] = euler;
449 >            ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).aMat[localIndex_] = euler;
450          }
451 +      
452 +       /**
453 +         * Returns the previous unit vectors of this stuntdouble
454 +         * @return the unit vectors of this stuntdouble
455 +         */    
456 +        Vector3d getPrevUnitVector() {
457 +            return ((snapshotMan_->getPrevSnapshot())->*storage_).unitVector[localIndex_];
458 +        }
459 +      
460 +        /**
461 +         * Returns the current unit vectors of this stuntdouble
462 +         * @return the unit vectors of this stuntdouble
463 +         */    
464 +        Vector3d getUnitVector() {
465 +            return ((snapshotMan_->getCurrentSnapshot())->*storage_).unitVector[localIndex_];
466 +        }
467  
468         /**
469 +         * Returns the unit vectors of this stuntdouble in specified snapshot
470 +         *
471 +         * @return the unit vectors of this stuntdouble
472 +         * @param snapshotNo
473 +         */    
474 +         Vector3d getUnitVector(int snapshotNo) {
475 +            return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).unitVector[localIndex_];
476 +        }
477 +
478 +       /**
479           * Returns the previous force of this stuntdouble
480           * @return the force of this stuntdouble
481           */    
482          Vector3d getPrevFrc() {
483 <            return (snapshotMan_->getPrevSnapshot())->storage_->force[LocalIndex_];
483 >            return ((snapshotMan_->getPrevSnapshot())->*storage_).force[localIndex_];
484          }
485        
486          /**
# Line 462 | Line 488 | namespace oopse{
488           * @return the force of this stuntdouble
489           */    
490          Vector3d getFrc() {
491 <            return (snapshotMan_->getCurrentSnapshot())->storage_->force[LocalIndex_];
491 >            return ((snapshotMan_->getCurrentSnapshot())->*storage_).force[localIndex_];
492          }
493  
494         /**
# Line 472 | Line 498 | namespace oopse{
498           * @param snapshotNo
499           */    
500           Vector3d getFrc(int snapshotNo) {
501 <            return (snapshotMan_->getSnapshot(snapShotNo))->storage_->force[LocalIndex_];
501 >            return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).force[localIndex_];
502          }
503  
504         /**
# Line 482 | Line 508 | namespace oopse{
508           * @see #getFrc
509           */        
510         void setPrevFrc(const Vector3d& frc) {
511 <            (snapshotMan_->getPrevSnapshot())->storage_->force[LocalIndex_] = frc;
511 >            ((snapshotMan_->getPrevSnapshot())->*storage_).force[localIndex_] = frc;
512         }
513        
514         /**
# Line 490 | Line 516 | namespace oopse{
516           * @param frc  new force
517           */        
518          void setFrc(const Vector3d& frc) {
519 <            (snapshotMan_->getCurrentSnapshot())->storage_->force[LocalIndex_] = frc;
519 >            ((snapshotMan_->getCurrentSnapshot())->*storage_).force[localIndex_] = frc;
520          }
521  
522         /**
# Line 501 | Line 527 | namespace oopse{
527           * @see #getFrc
528           */        
529          void setFrc(const Vector3d& frc, int snapshotNo) {
530 <            (snapshotMan_->getSnapshot(snapshotNo))->storage_->force[LocalIndex_] = frc;
530 >            ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).force[localIndex_] = frc;
531          }
532  
533         /**
# Line 510 | Line 536 | namespace oopse{
536           * @param frc  new force
537           * @see #getFrc
538           */        
539 <       void setPrevFrc(const Vector3d& frc) {
540 <            (snapshotMan_->getPrevSnapshot())->storage_->force[LocalIndex_] += frc;
539 >       void addPrevFrc(const Vector3d& frc) {
540 >            ((snapshotMan_->getPrevSnapshot())->*storage_).force[localIndex_] += frc;
541         }
542        
543         /**
544           * Adds force into the current force of this stuntdouble
545           * @param frc  new force
546           */        
547 <        void setFrc(const Vector3d& frc) {
548 <            (snapshotMan_->getCurrentSnapshot())->storage_->force[LocalIndex_] += frc;
547 >        void addFrc(const Vector3d& frc) {
548 >            ((snapshotMan_->getCurrentSnapshot())->*storage_).force[localIndex_] += frc;
549          }
550  
551         /**
# Line 529 | Line 555 | namespace oopse{
555           * @param snapshotNo
556           * @see #getFrc
557           */        
558 <        void setFrc(const Vector3d& frc, int snapshotNo) {
559 <            (snapshotMan_->getSnapshot(snapshotNo))->storage_->force[LocalIndex_] += frc;
558 >        void addFrc(const Vector3d& frc, int snapshotNo) {
559 >            ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).force[localIndex_] += frc;
560          }
561  
562         /**
# Line 538 | Line 564 | namespace oopse{
564           * @return the torque of this stuntdouble
565           */    
566          Vector3d getPrevTrq() {
567 <            return (snapshotMan_->getPrevSnapshot())->storage_->torque[LocalIndex_];
567 >            return ((snapshotMan_->getPrevSnapshot())->*storage_).torque[localIndex_];
568          }
569        
570          /**
# Line 546 | Line 572 | namespace oopse{
572           * @return the torque of this stuntdouble
573           */    
574          Vector3d getTrq() {
575 <            return (snapshotMan_->getCurrentSnapshot())->storage_->torque[LocalIndex_];
575 >            return ((snapshotMan_->getCurrentSnapshot())->*storage_).torque[localIndex_];
576          }
577  
578         /**
# Line 556 | Line 582 | namespace oopse{
582           * @param snapshotNo
583           */    
584           Vector3d getTrq(int snapshotNo) {
585 <            return (snapshotMan_->getSnapshot(snapShotNo))->storage_->torque[LocalIndex_];
585 >            return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).torque[localIndex_];
586          }
587  
588         /**
# Line 566 | Line 592 | namespace oopse{
592           * @see #getTrq
593           */        
594         void setPrevTrq(const Vector3d& trq) {
595 <            (snapshotMan_->getPrevSnapshot())->storage_->torque[LocalIndex_] = trq;
595 >            ((snapshotMan_->getPrevSnapshot())->*storage_).torque[localIndex_] = trq;
596         }
597        
598         /**
# Line 574 | Line 600 | namespace oopse{
600           * @param trq  new torque
601           */        
602          void setTrq(const Vector3d& trq) {
603 <            (snapshotMan_->getCurrentSnapshot())->storage_->torque[LocalIndex_] = trq;
603 >            ((snapshotMan_->getCurrentSnapshot())->*storage_).torque[localIndex_] = trq;
604          }
605  
606         /**
# Line 585 | Line 611 | namespace oopse{
611           * @see #getTrq
612           */        
613          void setTrq(const Vector3d& trq, int snapshotNo) {
614 <            (snapshotMan_->getSnapshot(snapshotNo))->storage_->torque[LocalIndex_] = trq;
614 >            ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).torque[localIndex_] = trq;
615          }
616  
617         /**
# Line 595 | Line 621 | namespace oopse{
621           * @see #getTrq
622           */        
623         void addPrevTrq(const Vector3d& trq) {
624 <            (snapshotMan_->getPrevSnapshot())->storage_->torque[LocalIndex_] += trq;
624 >            ((snapshotMan_->getPrevSnapshot())->*storage_).torque[localIndex_] += trq;
625         }
626        
627         /**
# Line 603 | Line 629 | namespace oopse{
629           * @param trq  new torque
630           */        
631          void addTrq(const Vector3d& trq) {
632 <            (snapshotMan_->getCurrentSnapshot())->storage_->torque[LocalIndex_] += trq;
632 >            ((snapshotMan_->getCurrentSnapshot())->*storage_).torque[localIndex_] += trq;
633          }
634  
635         /**
# Line 614 | Line 640 | namespace oopse{
640           * @see #getTrq
641           */        
642          void addTrq(const Vector3d& trq, int snapshotNo) {
643 <            (snapshotMan_->getSnapshot(snapshotNo))->storage_->torque[LocalIndex_] += trq;
643 >            ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).torque[localIndex_] += trq;
644          }      
645  
646  
# Line 622 | Line 648 | namespace oopse{
648           * Returns the previous z-angle of this stuntdouble
649           * @return the z-angle of this stuntdouble
650           */    
651 <        Vector3d getPrevZangle() {
652 <            return (snapshotMan_->getPrevSnapshot())->storage_->zAngle[LocalIndex_];
651 >        double getPrevZangle() {
652 >            return ((snapshotMan_->getPrevSnapshot())->*storage_).zAngle[localIndex_];
653          }
654        
655          /**
656           * Returns the current z-angle of this stuntdouble
657           * @return the z-angle of this stuntdouble
658           */    
659 <        Vector3d getZangle() {
660 <            return (snapshotMan_->getCurrentSnapshot())->storage_->zAngle[LocalIndex_];
659 >        double getZangle() {
660 >            return ((snapshotMan_->getCurrentSnapshot())->*storage_).zAngle[localIndex_];
661          }
662  
663         /**
# Line 639 | Line 665 | namespace oopse{
665           * @return the z-angle of this stuntdouble
666           * @param snapshotNo
667           */    
668 <         Vector3d getZangle(int snapshotNo) {
669 <            return (snapshotMan_->getSnapshot(snapShotNo))->storage_->zAngle[LocalIndex_];
668 >         double getZangle(int snapshotNo) {
669 >            return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).zAngle[localIndex_];
670          }
671  
672         /**
# Line 648 | Line 674 | namespace oopse{
674           * @param angle  new z-angle
675           * @see #getZangle
676           */        
677 <       void setPrevZangle(const Vector3d& angle) {
678 <            (snapshotMan_->getPrevSnapshot())->storage_->zAngle[LocalIndex_] = angle;
677 >       void setPrevZangle(double angle) {
678 >            ((snapshotMan_->getPrevSnapshot())->*storage_).zAngle[localIndex_] = angle;
679         }
680        
681         /**
682           * Sets  the current z-angle of this stuntdouble
683           * @param angle  new z-angle
684           */        
685 <        void setZangle(const Vector3d& angle) {
686 <            (snapshotMan_->getCurrentSnapshot())->storage_->zAngle[LocalIndex_] = angle;
685 >        void setZangle(double angle) {
686 >            ((snapshotMan_->getCurrentSnapshot())->*storage_).zAngle[localIndex_] = angle;
687          }
688  
689         /**
# Line 666 | Line 692 | namespace oopse{
692           * @param snapshotNo
693           * @see #getZangle
694           */        
695 <        void setZangle(const Vector3d& angle, int snapshotNo) {
696 <            (snapshotMan_->getSnapshot(snapshotNo))->storage_->zAngle[LocalIndex_] = angle;
695 >        void setZangle(double angle, int snapshotNo) {
696 >            ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).zAngle[localIndex_] = angle;
697          }
698  
699         /**
# Line 675 | Line 701 | namespace oopse{
701           * @param angle  new z-angle
702           * @see #getZangle
703           */        
704 <       void addPrevZangle(const Vector3d& angle) {
705 <            (snapshotMan_->getPrevSnapshot())->storage_->zAngle[LocalIndex_] += angle;
704 >       void addPrevZangle(double angle) {
705 >            ((snapshotMan_->getPrevSnapshot())->*storage_).zAngle[localIndex_] += angle;
706         }
707        
708         /**
709           * Adds z-angle into the current z-angle of this stuntdouble
710           * @param angle  new z-angle
711           */        
712 <        void addZangle(const Vector3d& angle) {
713 <            (snapshotMan_->getCurrentSnapshot())->storage_->zAngle[LocalIndex_] += angle;
712 >        void addZangle(double angle) {
713 >            ((snapshotMan_->getCurrentSnapshot())->*storage_).zAngle[localIndex_] += angle;
714          }
715  
716         /**
# Line 693 | Line 719 | namespace oopse{
719           * @param snapshotNo
720           * @see #getZangle
721           */        
722 <        void addZangle(const Vector3d& angle, int snapshotNo) {
723 <            (snapshotMan_->getSnapshot(snapshotNo))->storage_->zAngle[LocalIndex_] += angle;
722 >        void addZangle(double angle, int snapshotNo) {
723 >            ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).zAngle[localIndex_] += angle;
724          }      
725  
726 +        /** Set the force of this stuntdouble to zero */
727 +        virtual void zeroForces();
728         /**
729           * Returns the inertia tensor of this stuntdouble
730           * @return the inertia tensor of this stuntdouble
703 –         * @see #setI
731           */
732          virtual Mat3x3d getI() = 0;
733  
734         /**
708 –         * Sets the inertia tensor of this stuntdouble
709 –         * @param trq new inertia tensor
710 –         * @see #getI
711 –         */      
712 –        virtual void setI(Mat3x3d& I) = 0;
713 –
714 –       /**
735           * Returns the gradient of this stuntdouble
736 <         * @return the inertia tensor of this stuntdouble
717 <         * @see #setI
736 >         * @return the gradient of this stuntdouble
737           */
738          virtual std::vector<double> getGrad() = 0;
739  
# Line 761 | Line 780 | namespace oopse{
780          void setType(const std::string& name);
781  
782          /**
783 <         * Converts a lab fixed vector to a body fixed vector
784 <         * @v lab fixed vector. On return, it will store body fixed vector
783 >         * Converts a lab fixed vector to a body fixed vector.
784 >         * @return body fixed vector
785 >         * @param v lab fixed vector
786           */
787 <        void lab2Body(Vector3d& v);
787 >        Vector3d lab2Body(const Vector3d& v);
788  
789          /**
790 <         * Converts a body fixed vector to a lab fixed vector
791 <         * @v body fixed vector. On return, it will store lab fixed vector
790 >         * Converts a body fixed vector to a lab fixed vector.
791 >         * @return corresponding lab fixed vector
792 >         * @param v body fixed vector
793           */
794 <        void body2Lab(Vector3d& v);
794 >        Vector3d body2Lab(const Vector3d& v);
795          /**
796           * <p>
797           * The purpose of the Visitor Pattern is to encapsulate an operation that you want to perform on
# Line 819 | Line 840 | namespace oopse{
840           * @return a pointer point to property with propName. If no property named propName
841           * exists, return NULL
842           */      
843 <        GenericData* getPropertyByName(std:string& propName);
843 >        GenericData* getPropertyByName(std::string& propName);
844  
845      protected:
846          
847 <        StuntDouble();
847 >        StuntDouble(ObjectType objType, DataStoragePointer storage);
848          
849          StuntDouble(const StuntDouble& sd);
850          StuntDouble& operator=(const StuntDouble& sd);
# Line 836 | Line 857 | namespace oopse{
857          DataStoragePointer storage_;
858          SnapshotManager* snapshotMan_;
859          
839 –    private:
840 –        
860          int globalIndex_;
861          int localIndex_;
862 +        
863 +    private:
864  
865          std::string name_;
866  
# Line 848 | Line 869 | namespace oopse{
869          PropertyMap properties_;
870      };
871  
872 < }//end namespace oopse
872 > }//end namespace OpenMD
873   #endif //ifndef _STUNTDOUBLE_HPP_

Diff Legend

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