Line data    Source code

       1             : /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
       2             :    Copyright (c) 2016-2021 The VES code team
       3             :    (see the PEOPLE-VES file at the root of this folder for a list of names)
       4             : 
       5             :    See http://www.ves-code.org for more information.
       6             : 
       7             :    This file is part of VES code module.
       8             : 
       9             :    The VES code module is free software: you can redistribute it and/or modify
      10             :    it under the terms of the GNU Lesser General Public License as published by
      11             :    the Free Software Foundation, either version 3 of the License, or
      12             :    (at your option) any later version.
      13             : 
      14             :    The VES code module is distributed in the hope that it will be useful,
      15             :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      16             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      17             :    GNU Lesser General Public License for more details.
      18             : 
      19             :    You should have received a copy of the GNU Lesser General Public License
      20             :    along with the VES code module.  If not, see <http://www.gnu.org/licenses/>.
      21             : +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
      22             : #ifndef __PLUMED_ves_TargetDistribution_h
      23             : #define __PLUMED_ves_TargetDistribution_h
      24             : 
      25             : #include "core/Action.h"
      26             : 
      27             : #include <vector>
      28             : #include <string>
      29             : #include <cmath>
      30             : #include <memory>
      31             : 
      32             : #define PLUMED_VES_TARGETDISTRIBUTION_INIT(ao) TargetDistribution(ao)
      33             : 
      34             : namespace PLMD {
      35             : 
      36             : /**
      37             : \ingroup INHERIT
      38             : Abstract base class for implenting new target distributions.
      39             : */
      40             : 
      41             : class Action;
      42             : class Grid;
      43             : class Value;
      44             : class Keywords;
      45             : 
      46             : namespace ves {
      47             : 
      48             : class TargetDistModifer;
      49             : class VesBias;
      50             : 
      51             : class TargetDistribution :
      52             :   public Action {
      53             : private:
      54             :   enum TargetDistType {
      55             :     static_targetdist,
      56             :     dynamic_targetdist
      57             :   } type_;
      58             :   //
      59             :   bool force_normalization_;
      60             :   bool check_normalization_;
      61             :   bool check_nonnegative_;
      62             :   bool check_nan_inf_;
      63             :   bool shift_targetdist_to_zero_;
      64             :   // dimension of the distribution
      65             :   unsigned int dimension_;
      66             :   // grid parameters
      67             :   std::vector<Value*> grid_args_;
      68             :   //
      69             :   std::unique_ptr<Grid> targetdist_grid_pntr_;
      70             :   std::unique_ptr<Grid> log_targetdist_grid_pntr_;
      71             :   //
      72             :   std::vector<std::unique_ptr<TargetDistModifer>> targetdist_modifer_pntrs_;
      73             :   //
      74             :   Action* action_pntr_;
      75             :   VesBias* vesbias_pntr_;
      76             :   //
      77             :   bool needs_bias_grid_;
      78             :   bool needs_bias_withoutcutoff_grid_;
      79             :   bool needs_fes_grid_;
      80             :   //
      81             :   Grid* bias_grid_pntr_;
      82             :   Grid* bias_withoutcutoff_grid_pntr_;
      83             :   Grid* fes_grid_pntr_;
      84             :   //
      85             :   bool static_grid_calculated;
      86             :   //
      87             :   bool allow_bias_cutoff_;
      88             :   bool bias_cutoff_active_;
      89             :   //
      90             :   void calculateStaticDistributionGrid();
      91             :   void updateBiasCutoffForTargetDistGrid();
      92             :   void checkNanAndInf();
      93             : protected:
      94             :   void setStatic() {
      95             :     type_=static_targetdist;
      96             :   }
      97             :   void setDynamic() {
      98          41 :     type_=dynamic_targetdist;
      99           2 :   }
     100             :   // set the that target distribution is normalized
     101             :   void setForcedNormalization() {
     102          80 :     force_normalization_=true;
     103          80 :     check_normalization_=false;
     104           7 :   }
     105             :   void unsetForcedNormalization() {
     106             :     force_normalization_=false;
     107             :     check_normalization_=true;
     108             :   };
     109             :   //
     110             :   void setBiasGridNeeded() {
     111           0 :     needs_bias_grid_=true;
     112           0 :   }
     113             :   void setBiasWithoutCutoffGridNeeded() {
     114           3 :     needs_bias_withoutcutoff_grid_=true;
     115             :   }
     116             :   void setFesGridNeeded() {
     117          38 :     needs_fes_grid_=true;
     118           5 :   }
     119             :   //
     120             :   VesBias* getPntrToVesBias() const;
     121             :   Action* getPntrToAction() const;
     122             :   //
     123         287 :   virtual void setupAdditionalGrids(const std::vector<Value*>&, const std::vector<std::string>&, const std::vector<std::string>&, const std::vector<unsigned int>&) {}
     124             :   //
     125             :   void normalizeTargetDistGrid();
     126             :   //
     127             :   Grid& targetDistGrid() const {
     128             :     return *targetdist_grid_pntr_;
     129             :   }
     130             :   Grid& logTargetDistGrid() const {
     131             :     return *log_targetdist_grid_pntr_;
     132             :   }
     133             :   //
     134             :   Grid* getBiasGridPntr() const {
     135             :     return bias_grid_pntr_;
     136             :   }
     137             :   Grid* getBiasWithoutCutoffGridPntr() const {
     138        2624 :     return bias_withoutcutoff_grid_pntr_;
     139             :   }
     140             :   Grid* getFesGridPntr() const {
     141    11814078 :     return fes_grid_pntr_;
     142             :   }
     143             :   //
     144             :   double getBeta() const;
     145             :   //
     146             :   void applyTargetDistModiferToGrid(TargetDistModifer* modifer_pntr);
     147             :   //
     148             :   void setMinimumOfTargetDistGridToZero();
     149             :   void updateLogTargetDistGrid();
     150             :   //
     151         368 :   virtual void updateGrid() {
     152         368 :     calculateStaticDistributionGrid();
     153         368 :   }
     154             : public:
     155             :   static void registerKeywords(Keywords&);
     156             :   explicit TargetDistribution(const ActionOptions&);
     157             :   ~TargetDistribution();
     158             :   //
     159             :   bool isStatic() const {
     160             :     return type_==static_targetdist;
     161             :   }
     162             :   bool isDynamic() const {
     163         602 :     return type_==dynamic_targetdist;
     164             :   }
     165             :   // is the target distribution normalize or not
     166             :   bool forcedNormalization() const {
     167             :     return force_normalization_;
     168             :   };
     169             :   bool isTargetDistGridShiftedToZero() const {
     170        5194 :     return shift_targetdist_to_zero_;
     171             :   }
     172             :   //
     173             :   bool biasGridNeeded() const {
     174         466 :     return needs_bias_grid_;
     175             :   }
     176             :   bool biasWithoutCutoffGridNeeded() const {
     177          45 :     return needs_bias_withoutcutoff_grid_;
     178             :   }
     179             :   bool fesGridNeeded()  const {
     180         466 :     return needs_fes_grid_;
     181             :   }
     182             :   //
     183             :   void allowBiasCutoff() {
     184             :     allow_bias_cutoff_=true;
     185             :   }
     186             :   void doNotAllowBiasCutoff() {
     187             :     allow_bias_cutoff_=false;
     188             :   }
     189             :   bool isBiasCutoffAllowed() const {
     190             :     return allow_bias_cutoff_;
     191             :   }
     192             :   bool biasCutoffActive() const {
     193             :     return bias_cutoff_active_;
     194             :   }
     195             :   //
     196             :   void setDimension(const unsigned int dimension);
     197             :   unsigned getDimension() const {
     198      506318 :     return dimension_;
     199             :   }
     200             :   //
     201             :   virtual void linkVesBias(VesBias*);
     202             :   virtual void linkAction(Action*);
     203             :   //
     204             :   virtual void linkBiasGrid(Grid*);
     205             :   virtual void linkBiasWithoutCutoffGrid(Grid*);
     206             :   virtual void linkFesGrid(Grid*);
     207             :   //
     208             :   void setupBiasCutoff();
     209             :   //
     210             :   Grid* getTargetDistGridPntr() const {
     211             :     return targetdist_grid_pntr_.get();
     212             :   }
     213             :   Grid* getLogTargetDistGridPntr() const {
     214             :     return log_targetdist_grid_pntr_.get();
     215             :   }
     216             :   //
     217             :   void clearLogTargetDistGrid();
     218             :   // calculate the target distribution itself
     219             :   virtual double getValue(const std::vector<double>&) const = 0;
     220             :   //
     221             :   void setupGrids(const std::vector<Value*>&, const std::vector<std::string>&, const std::vector<std::string>&, const std::vector<unsigned int>&);
     222             :   //
     223             :   Grid getMarginal(const std::vector<std::string>&);
     224             :   //
     225             :   void updateTargetDist();
     226             :   //
     227             :   void readInRestartTargetDistGrid(const std::string&);
     228             :   //
     229             :   static double integrateGrid(const Grid*);
     230             :   static double normalizeGrid(Grid*);
     231             :   static Grid getMarginalDistributionGrid(Grid*, const std::vector<std::string>&);
     232             :   // empty standard action stuff
     233           0 :   void update() override {};
     234           0 :   void apply() override {};
     235           0 :   void calculate() override {};
     236             : };
     237             : 
     238             : 
     239             : inline
     240             : VesBias* TargetDistribution::getPntrToVesBias() const {
     241             :   plumed_massert(vesbias_pntr_!=NULL,"the VES bias has not been linked");
     242             :   return vesbias_pntr_;
     243             : }
     244             : 
     245             : 
     246             : inline
     247             : Action* TargetDistribution::getPntrToAction() const {
     248             :   plumed_massert(action_pntr_!=NULL,"the action has not been linked");
     249             :   return action_pntr_;
     250             : }
     251             : 
     252             : 
     253             : inline
     254          90 : void TargetDistribution::normalizeTargetDistGrid() {
     255          90 :   double normalization = normalizeGrid(targetdist_grid_pntr_.get());
     256          90 :   if(normalization<0.0) {
     257           0 :     plumed_merror(getName()+": something went wrong trying to normalize the target distribution, integrating over it gives a negative value.");
     258             :   }
     259          90 : }
     260             : 
     261             : 
     262             : 
     263             : 
     264             : }
     265             : }
     266             : #endif