simulation.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// This file is part of the OpenStructure project <www.openstructure.org>
//
// Copyright (C) 2008-2020 by the OpenStructure authors
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License as published by the Free
// Software Foundation; either version 3.0 of the License, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
// details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this library; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//------------------------------------------------------------------------------
 
#ifndef OST_MM_SIMULATION_HH
#define OST_MM_SIMULATION_HH
 
#include <vector>
#include <map>
 
#include <ost/mol/mol.hh>
#include <ost/mol/mm/system_creator.hh>
#include <ost/mol/mm/topology.hh>
#include <ost/mol/mm/topology_creator.hh>
#include <ost/mol/mm/settings.hh>
#include <ost/mol/mm/modeller.hh>
#include <ost/geom/vec3.hh>
#include <ost/mol/mm/observer.hh>
#include <ost/mol/mm/state_extractor.hh>
#include <ost/mol/mm/steep.hh>
 
#include <time.h>
 
namespace OpenMM{
  class Integrator;
  class Context;//hacky way of telling the Context and Integrator 
                //are around.
                //will be included in source file to avoid
                //dependencies on external libraries
}
 
namespace ost { namespace mol{ namespace mm{
 
class Simulation;
 
typedef boost::shared_ptr<OpenMM::Integrator> IntegratorPtr;
typedef boost::shared_ptr<OpenMM::Context> ContextPtr;
typedef boost::shared_ptr<Simulation> SimulationPtr;
 
class Simulation {
 
public:
 
  Simulation(const ost::mol::EntityHandle& handle, 
             const SettingsPtr settings);
 
  Simulation(const ost::mol::mm::TopologyPtr top,
             const ost::mol::EntityHandle& handle,
             const SettingsPtr settings);
 
  void Save(const String& filename);
 
  static SimulationPtr Load(const String& filename, SettingsPtr settings);
 
  static bool IsPlatformAvailable(const SettingsPtr settings);
 
  ost::mol::EntityHandle GetEntity() { return ent_; }
 
  geom::Vec3List GetPositions(bool enforce_periodic_box = false, bool in_angstrom = true);
 
  geom::Vec3List GetVelocities();
 
  geom::Vec3List GetForces();
 
  void SetPositions(const geom::Vec3List& positions, bool in_angstrom = true);
 
  void SetVelocities(geom::Vec3List& velocities);
 
  void UpdatePositions(bool enforce_periodic_box = false);
 
  bool ApplySD(Real tolerance = 100, int max_iterations = 1000);
 
  void ApplyLBFGS(Real tolerance = 1, int max_iterations = 1000);
 
  Real GetEnergy();
 
  Real GetPotentialEnergy();
 
  Real GetKineticEnergy();
 
  TopologyPtr GetTopology() { return top_; }
 
  void Steps(int steps);
 
  void Register(ObserverPtr o);
 
  void ResetHarmonicBond(uint index, Real bond_length, Real force_constant);
 
  void ResetHarmonicAngle(uint index, Real angle, Real force_constant);
 
  void ResetUreyBradleyAngle(uint index, Real angle, Real angle_force_constant, Real bond_length, Real bond_force_constant);
 
  void ResetPeriodicDihedral(uint index, int multiplicity, Real phase, Real force_constant);
 
  void ResetPeriodicImproper(uint index, int multiplicity, Real phase, Real force_constant);
 
  void ResetHarmonicImproper(uint index, Real phase, Real force_constant);
 
  void ResetLJPair(uint index, Real sigma, Real epsilon);
 
  void ResetDistanceConstraint(uint index, Real constraint_length);
 
  void ResetHarmonicPositionRestraint(uint index, const geom::Vec3& ref_position, Real k,
                                      Real x_scale = 1.0, Real y_scale = 1.0, Real z_scale = 1.0);
 
  void ResetHarmonicDistanceRestraint(uint index, Real length, Real force_constant);
 
  void ResetLJ(uint index, Real sigma, Real epsilon);
 
  void ResetGBSA(uint index, Real radius, Real scaling);
 
  void ResetCharge(uint index, Real charge);
 
  void ResetMass(uint index, Real mass);
 
  void AddPositionConstraint(uint index);
 
  void AddPositionConstraints(const std::vector<uint>& index);
 
  void ResetPositionConstraints();
 
  geom::Vec3 GetPeriodicBoxExtents();
 
  void SetPeriodicBoxExtents(geom::Vec3& vec);
 
private:
 
  Simulation() { } //hidden constructor... 
 
  void Init(const ost::mol::mm::TopologyPtr top, 
            const ost::mol::EntityHandle& ent,
            const SettingsPtr settings);
 
  int TimeToNextNotification();
 
  void ReinitializeContext();
 
  // loads plugins from directory for OpenMM BUT only once per unique path!
  static void EnsurePluginsLoaded(const String& plugin_path);
 
  SystemPtr system_;
  IntegratorPtr integrator_;
  ContextPtr context_;
  TopologyPtr top_;
  std::vector<ObserverPtr> observers_;
  std::vector<int> time_to_notify_;
  std::map<FuncType,uint> system_force_mapper_;
  ost::mol::EntityHandle ent_;
  ost::mol::AtomHandleList atom_list_;
};
 
}}} //ns
 
#endif