molecularDynamics.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: molecularDynamics.h,v 1.33 2005/12/23 17:01:53 amoll Exp $
//

// MolecularDynamics: A base class for molecular dynamics simulations    
// Useful MD classes must be derived from this class.

#ifndef BALL_MOLMEC_MDSIMULATION_MOLECULARDYNAMICS_H
#define BALL_MOLMEC_MDSIMULATION_MOLECULARDYNAMICS_H

#ifndef BALL_COMMON_H
# include <BALL/common.h>
#endif

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

#ifndef BALL_MOLMEC_COMMON_ATOMVECTOR_H
# include <BALL/MOLMEC/COMMON/atomVector.h>
#endif

#include <vector>

namespace BALL
{
  // Some forward decls
  class SnapShotManager;
  class ForceField;
  class System;

  class BALL_EXPORT MolecularDynamics
  {
    public:
    
    struct BALL_EXPORT Option
    {

      static const char* MAXIMAL_NUMBER_OF_ITERATIONS;

      static const char* MAXIMAL_SIMULATION_TIME; 

      static const char* NUMBER_OF_ITERATION;

      static const char* ENERGY_OUTPUT_FREQUENCY;

      static const char* SNAPSHOT_FREQUENCY;

      static const char* TIME_STEP;

      static const char* REFERENCE_TEMPERATURE;

      static const char* BATH_RELAXATION_TIME;

      static const char* CURRENT_TIME;
    };

    struct BALL_EXPORT Default
    {

      static const Size MAXIMAL_NUMBER_OF_ITERATIONS;

      static const double  MAXIMAL_SIMULATION_TIME; 

      static const Size NUMBER_OF_ITERATION;

      static const Size ENERGY_OUTPUT_FREQUENCY;

      static const Size SNAPSHOT_FREQUENCY;

      static const double TIME_STEP;

      static const double REFERENCE_TEMPERATURE;

      static const double BATH_RELAXATION_TIME;

      static const double CURRENT_TIME;
    };


    BALL_CREATE(MolecularDynamics)

    
    MolecularDynamics();

    MolecularDynamics(ForceField& force_field);

    MolecularDynamics(const MolecularDynamics& rhs);

    virtual ~MolecularDynamics();



    const MolecularDynamics& operator =(const MolecularDynamics& rhs);

    void set(const MolecularDynamics& rhs);
      


    bool isValid() const;



    virtual bool setup(ForceField& force_field, SnapShotManager* snapshot_man);

    virtual bool setup(ForceField& forcefield, SnapShotManager* snapshot_man, const Options& myoptions);

    virtual bool specificSetup();



    void setNumberOfIteration(Size number);

    void setMaximalNumberOfIterations(Size number);

    void setMaximalSimulationTime(double time);    

    virtual void setTimeStep(double step);

    void setReferenceTemperature(double temperature);

    void setCurrentTime(double time);

    void setEnergyOutputFrequency(Size number);

    void setSnapShotFrequency(Size number);

    Size getEnergyOutputFrequency() const;

    Size getNumberOfIterations() const;

    Size getMaximalNumberOfIterations() const;

    double getMaximalSimulationTime() const;

    double getTimeStep() const; 

    Size getSnapShotFrequency() const;

    double getTemperature() const;

    double getTime() const;

    double getTotalEnergy() const;

    double getPotentialEnergy() const;

    double getKineticEnergy() const;

    ForceField* getForceField() const;

    bool simulate(bool restart = false);

    bool simulateTime(double simulation_time, bool restart = false);

    virtual bool simulateIterations(Size number, bool restart = false);

    void enableEnergyAbortCondition(bool state);

    bool energyAbortConditionEnabled() const;

    void setEnergyToAbort(float value);
    
    float getEnergyToAbort() const;
    


    Options options;

    protected:

    /*_ @name Protected Methods 
    */
    //_@{

    /*_ A method for calculating the
        current temperature in the system
    */
    void updateInstantaneousTemperature();

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

    /*_  The boolean variable indicates if the setup of the 
         molecular dynamics has been successful 
    */
    bool valid_;

    /*_  The force field the MD class is bound to          
    */
    ForceField* force_field_ptr_;

    /*_  The system the MD class is bound to
    */
    System* system_ptr_;

    /*_  The list of atoms. The simulation will be carried out for these atoms 
    */
    AtomVector atom_vector_;

    /*_  The current iteration number  
    */
    Size number_of_iteration_;

    /*_  The maximal number of iterations to be simulated when
         calling the simulate() method. 
    */
    Size maximal_number_of_iterations_;

    /*_  The time step in picoseconds                  
    */
    double time_step_;

    /*_  The reference temperature in Kelvin 
    */
    double reference_temperature_;

    /*_  The current(kinetic) temperatue in Kelvin 
    */
    double current_temperature_;

    /*_  The current kinetic energy  in kJ/mol
    */
    double kinetic_energy_;

    /*_  The current total energy in kJ/mol
    */
    double total_energy_;

    /*_  The current time of the MD run                 
    */
    double current_time_;

    /*_  Frequency of energy output(i.e. after how many iterations) 
    */
    Size energy_output_frequency_;

    /*_  Frequency of taking snapshots(i.e. after how many iterations) 
    */
    Size snapshot_frequency_;

    /*_  The Snapshot Manager that is used for taking snapshots
    */
    SnapShotManager* snapshot_manager_ptr_;

    //_ 
    bool abort_by_energy_enabled_;
    
    //_ 
    float abort_energy_;

    //_@}
    
  };  // end of class MolecularDynamics 
}  // end of namespace Ball

#endif // BALL_MOLMEC_MDSIMULATION_MOLECULARDYNAMICS_H