snapShot.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

// This file contains the definitions of the classes 
// SnapshotManager and Snapshot. 
// They can be used to obtain snapshots from an MD simulation or an energy 
// minimisation.
// A snapshot contains atom positions, velocities, forces and potential energy. 


#ifndef BALL_MOLMEC_COMMON_SNAPSHOT_H
#define BALL_MOLMEC_COMMON_SNAPSHOT_H
 
#ifndef BALL_MATHS_VECTOR3_H
# include <BALL/MATHS/vector3.h>
#endif

namespace BALL
{
  class System;

  class BALL_EXPORT SnapShot
  {

    public:

    BALL_CREATE(SnapShot)

    


    SnapShot();

    SnapShot(const SnapShot& snapshot);

    virtual ~SnapShot();



    const SnapShot& operator = (const SnapShot& snapshot);

    virtual void clear();



    bool operator == (const SnapShot& snapshot) const;

    bool isValid() const;



    void setIndex(Size index);

    Size getIndex() const;

    void setNumberOfAtoms(Size number_of_atoms);

    Size getNumberOfAtoms() const;

    void setPotentialEnergy(DoubleReal potential_energy);

    DoubleReal getPotentialEnergy() const;

    void setKineticEnergy(DoubleReal kinetic_energy);

    DoubleReal getKineticEnergy() const;

    void setAtomPositions(const ::std::vector<Vector3>& atom_postions);

    const ::std::vector<Vector3>& getAtomPositions() const;

    void setAtomVelocities(const ::std::vector<Vector3>& atom_velocities);

    const ::std::vector<Vector3>& getAtomVelocities() const;

    void setAtomForces(const ::std::vector<Vector3>& atom_forces);

    const ::std::vector<Vector3>& getAtomForces() const;



    void takeSnapShot(const System& system)
      throw(Exception::OutOfMemory);

    void applySnapShot(System& system) const;

    void getAtomPositions(const System& system)
      throw(Exception::OutOfMemory);

    void setAtomPositions(System& system) const;

    void getAtomVelocities(const System& system)
      throw(Exception::OutOfMemory);

    void setAtomVelocitites(System& system) const;

    void getAtomForces(const System& system)
      throw(Exception::OutOfMemory);

    void setAtomForces(System& system) const;


    protected:

    //_ @name Protected Attributes

    //_ The index of the current snapshot object. Valid indices start at 1.
    Size index_;

    /*_ The number of atoms of the underlying system. The system being
        snapshot must always be the same, especially with respect to
        the number of atoms. 
    */
    Size number_of_atoms_;

    /*_ The potential energy in the system when the snapshot is taken.
        Only contributions from selected atoms are considered. 
    */
    double potential_energy_;

    /*_ The  kinetic energy due to electrostatic interactions. 
        Only contributions from selected atoms are considered. 
    */
    double kinetic_energy_;

    //_ An STL vector with the positions of all atoms 
    vector<Vector3> atom_positions_;

    //_ An STL vector with the velocities of all atoms 
    vector<Vector3> atom_velocities_;

    //_ An STL vector with the forces of all atoms 
    vector<Vector3> atom_forces_;


  }; // Snapshot 

  ::std::ostream& operator << (::std::ostream& os, const SnapShot& ss);

  ::std::istream& operator >> (::std::istream& is, SnapShot& ss);

} // end of namespace BALL  

#endif // BALL_MOLMEC_COMMON_SNAPSHOT_H