snapShotManager.h

Go to the documentation of this file.

  // -*- Mode: C++; tab-width: 2; -*-
  // vi: set ts=2:
  //
  // $Id: snapShotManager.h,v 1.19.20.1 2007/05/10 10:51:04 amoll Exp $
  //

#ifndef BALL_MOLMEC_COMMON_SNAPSHOTMANAGER_H
#define BALL_MOLMEC_COMMON_SNAPSHOTMANAGER_H

#ifndef BALL_MOLMEC_COMMON_SNAPSHOT_H
# include <BALL/MOLMEC/COMMON/snapShot.h>
#endif

#ifndef BALL_DATATYPE_OPTIONS_H
# include <BALL/DATATYPE/options.h>
#endif

#ifndef BALL_SYSTEM_FILE_H
# include <BALL/SYSTEM/file.h>
#endif

namespace BALL
{
  class TrajectoryFile;
  class System;
  class ForceField;

class BALL_EXPORT SnapShotManager
{
  public:

  struct BALL_EXPORT Option
  {
    static const char* FLUSH_TO_DISK_FREQUENCY; 
  };

  struct BALL_EXPORT Default
  {
    static const unsigned int FLUSH_TO_DISK_FREQUENCY; 
  }; 


  BALL_CREATE(SnapShotManager)

  


  SnapShotManager()
    ;

  SnapShotManager(System* my_system, const ForceField* my_force_field,
                  TrajectoryFile* my_snapshot_file)
    ;

  SnapShotManager 
    (System* my_system, const ForceField* my_force_field,
     const Options& my_options, TrajectoryFile* file)
    ;

  SnapShotManager(const SnapShotManager& manager)
    ;

  virtual ~SnapShotManager()
    ;



  bool setup(System* my_system, const ForceField* my_forcefield,
      TrajectoryFile* my_snapshot_file)
    ;

  virtual bool setup()
    ;



  const SnapShotManager& operator = (const SnapShotManager& manager)
    ;

  virtual void clear()
    ;




  virtual bool isValid() const
    ;




  void setSystem(System* my_system)
    ;

  System* getSystem() const
    ;

  void setForceField(const ForceField* my_ff)
    ;

  const ForceField* getForceField() const
    ;

  void setTrajectoryFile(TrajectoryFile* my_file)
    ;

  TrajectoryFile* getTrajectoryFile() const
    ;

  void setFlushToDiskFrequency(Size number)
    ;

  Size getFlushToDiskFrequency() const
    ;

  virtual void takeSnapShot()
    throw(File::CannotWrite);

  virtual bool applySnapShot(Size number)
    ;

  virtual bool applyFirstSnapShot()
    ;

  virtual bool applyNextSnapShot()
    ;

  virtual bool applyLastSnapShot()
    ;

  virtual void flushToDisk()
    throw(File::CannotWrite);

  Size getNumberOfSnapShotsInBuffer()
     { return  snapshot_buffer_.size();}

  Position getCurrentSnapshotNumber() const
     { return current_snapshot_ + 1;}

  bool readFromFile()
    ;

  void clearBuffer()
    ;




  Options options; 

  //_ @name Protected Attributes
  //_@{
  
  protected:

  //_ The system to which the SnapshotManager is bound
  System* system_ptr_; 

  //_ The force field of the current system
  const ForceField* force_field_ptr_; 

  //_ A vector containing those snapshot objects currently in memory
  vector<SnapShot> snapshot_buffer_; 

  //_ The trajectory file where the data is saved in
  TrajectoryFile* trajectory_file_ptr_;

  /*_ The frequency of saving snapshots in memory to disk.
      After flush_to_disk_frequency_ iterations, a save is done. 
  */
  Size flush_to_disk_frequency_; 

  //_ Number of taken SnapShot sine last flushToDisk
  Size buffer_counter_;

  //_ Number of the current SnapShot (used with buffer_)
  Position current_snapshot_;

  //_@}
  /*_ @name Protected methods
  */
  //_@{

  /*_ Calculate the kinetic energy 
  */
  double calculateKineticEnergy_();

  //_@}

}; // end of class SnapshotManager 

} // namespace
#endif //  BALL_MOLMEC_COMMON_SNAPSHOTMANAGER_H