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 Size FLUSH_TO_DISK_FREQUENCY;
  };


  BALL_CREATE(SnapShotManager)

  


  SnapShotManager();

  SnapShotManager(System* my_system, TrajectoryFile* my_snapshot_file = 0);

  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);

  bool setup(System* my_system, 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