energyMinimizer.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: energyMinimizer.h,v 1.44.20.3 2007/08/07 09:12:33 aleru Exp $
//

// Energy Minimizer: A class for minimizing the energy of molecular systems

#ifndef BALL_MOLMEC_MINIMIZATION_ENERGYMINIMIZER_H
#define BALL_MOLMEC_MINIMIZATION_ENERGYMINIMIZER_H

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

#ifndef BALL_MOLMEC_COMMON_GRADIENT_H
# include <BALL/MOLMEC/COMMON/gradient.h>
#endif

namespace BALL 
{
  class ForceField;
  class SnapShotManager;
  
  class BALL_EXPORT EnergyMinimizer
  {
    public:
    
      
      struct BALL_EXPORT Option
      {
        static const char* MAXIMAL_NUMBER_OF_ITERATIONS;
        
        static const char* ENERGY_OUTPUT_FREQUENCY;
        
        static const char* SNAPSHOT_FREQUENCY;
        
        static const char* NUMBER_OF_ITERATION;
        
        static const char* ENERGY_DIFFERENCE_BOUND;
        
        static const char* MAX_SAME_ENERGY;
        
        static const char* MAX_GRADIENT;
        
        static const char* MAXIMUM_DISPLACEMENT;
      };
      
      struct BALL_EXPORT Default
      {
        static Size MAXIMAL_NUMBER_OF_ITERATIONS;
        
        static Size ENERGY_OUTPUT_FREQUENCY;
        
        static Size SNAPSHOT_FREQUENCY;
        
        static Size NUMBER_OF_ITERATION;
        
        static float ENERGY_DIFFERENCE_BOUND;
        
        static Size MAX_SAME_ENERGY; 
        
        static float MAX_GRADIENT;
        
        static float MAXIMUM_DISPLACEMENT;
      };
      

      
      BALL_CREATE(EnergyMinimizer)
      
      
      EnergyMinimizer();
      
      EnergyMinimizer(ForceField& force_field);
      
      EnergyMinimizer(ForceField& force_field, const Options& options);
      
      EnergyMinimizer(const EnergyMinimizer& energy_minimizer);
      
      virtual ~EnergyMinimizer();
      

      
      const EnergyMinimizer&  operator=(const EnergyMinimizer& energy_minimizer);
      
      
      bool operator == (const EnergyMinimizer& energy_minimizer) ;
      
      
      bool isValid() const;
      

      
      bool setup(ForceField& force_field);
      
      bool setup(ForceField& force_field, SnapShotManager *ssm);
      
      bool setup(ForceField& force_field, 
                 SnapShotManager *ssm, const Options& options);
      
      bool setup(ForceField& force_field, const Options& options);
      
      virtual bool specificSetup();
      

      
      virtual bool isConverged() const;
      
      virtual double findStep();
      
      virtual void updateDirection();
      
      virtual double updateEnergy();
      
      virtual void updateForces();
      
      void storeGradientEnergy();
      
      virtual void printEnergy() const;
      
      virtual void takeSnapShot() const;
      
      virtual void finishIteration();
      
      Size getNumberOfIterations() const;
      
      Gradient& getDirection();
      
      Gradient& getGradient();
      
      Gradient& getInitialGradient();
      
      double getEnergy() const;
      
      double& getEnergy();
      
      double getInitialEnergy() const;
      
      double& getInitialEnergy();
      
      void setNumberOfIterations(Size number_of_iterations);
      
      Size getMaxNumberOfIterations() const;
      
      void setMaxNumberOfIterations(Size number_of_iterations);
      
      void  setMaxSameEnergy(Size number);
      
      Size getMaxSameEnergy() const;
      
      void setEnergyOutputFrequency(Size  energy_output_frequency);
      
      Size getEnergyOutputFrequency() const;
      
      void setEnergyDifferenceBound(float energy_difference_bound);
      
      float getEnergyDifferenceBound() const;
      
      void setMaxGradient(float max_gradient);
      
      float getMaxGradient() const;
      
      void  setMaximumDisplacement(float maximum_displacement);
      
      float getMaximumDisplacement() const;
      
      void setSnapShotFrequency(Size snapshot_frequency);
      
      Size getSnapShotFrequency() const;
      
      ForceField* getForceField();
      
      Size getForceUpdateCounter() const ;
      
      Size getEnergyUpdateCounter() const ;
      
      virtual bool  minimize(Size steps = 0, bool resume = false);
      
      void enableEnergyAbortCondition(bool state);
      
      bool energyAbortConditionEnabled() const;
      
      void setEnergyToAbort(float value);
      
      float getEnergyToAbort() const;
      
      bool wasAborted() const ;
      

      
      Options options;
      
    protected:
      
      
      Gradient initial_grad_;
      
      Gradient current_grad_;
      
      double initial_energy_;
      
      double current_energy_;
      
      Gradient old_grad_;
      
      double old_energy_;
      
      Gradient direction_;
     
      bool valid_;
      
      SnapShotManager* snapshot_; 
      
      ForceField* force_field_;
      
      Size number_of_iterations_;
      
      Size maximal_number_of_iterations_;
      
      Size energy_output_frequency_;
      
      Size snapshot_frequency_;
      
      double energy_difference_bound_;
      
      double max_gradient_;
      
      Size max_same_energy_;
      
      Size same_energy_counter_;
      
      float maximum_displacement_;
      
      Size force_update_counter_;
      
      Size energy_update_counter_;
      
      float cutlo_;
      
      double step_;
      
      //_ 
      bool abort_by_energy_enabled_;
      
      //_ 
      float abort_energy_;
      
      //_
      bool aborted_;
      
    //_@}
  };
  
} // namespace Ball

#endif // BALL_MOLMEC_MINIMIZATION_ENERGYMINIMIZER_H