src/gromacs/pulling/pull_internal.h

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 1991-2000, University of Groningen, The Netherlands.
   5  * Copyright (c) 2001-2004, The GROMACS development team.
   6  * Copyright (c) 2013,2014,2015,2016,2018, by the GROMACS development team, led by
   7  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   8  * and including many others, as listed in the AUTHORS file in the
   9  * top-level source directory and at http://www.gromacs.org.
  10  *
  11  * GROMACS is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public License
  13  * as published by the Free Software Foundation; either version 2.1
  14  * of the License, or (at your option) any later version.
  15  *
  16  * GROMACS is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with GROMACS; if not, see
  23  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  24  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  25  *
  26  * If you want to redistribute modifications to GROMACS, please
  27  * consider that scientific software is very special. Version
  28  * control is crucial - bugs must be traceable. We will be happy to
  29  * consider code for inclusion in the official distribution, but
  30  * derived work must not be called official GROMACS. Details are found
  31  * in the README & COPYING files - if they are missing, get the
  32  * official version at http://www.gromacs.org.
  33  *
  34  * To help us fund GROMACS development, we humbly ask that you cite
  35  * the research papers on the package. Check out http://www.gromacs.org.
  36  */
  37
  38 /*! \internal \file
  39  *
  40  *
  41  * \brief
  42  * This file contains datatypes and function declarations for internal
  43    use in the pull code.
  44  *
  45  * \author Berk Hess
  46  */
  47
  48 #ifndef GMX_PULLING_PULL_INTERNAL_H
  49 #define GMX_PULLING_PULL_INTERNAL_H
  50
  51 #include "config.h"
  52
  53 #include <memory>
  54 #include <vector>
  55
  56 #include "gromacs/domdec/localatomset.h"
  57 #include "gromacs/mdtypes/pull-params.h"
  58 #include "gromacs/utility/gmxmpi.h"
  59
  60 /*! \brief Determines up to what local atom count a pull group gets processed single-threaded.
  61  *
  62  * We set this limit to 1 with debug to catch bugs.
  63  * On Haswell with GCC 5 the cross-over point is around 400 atoms,
  64  * independent of thread count and hyper-threading.
  65  */
  66 #ifdef NDEBUG
  67 static const int c_pullMaxNumLocalAtomsSingleThreaded = 100;
  68 #else
  69 static const int c_pullMaxNumLocalAtomsSingleThreaded = 1;
  70 #endif
  71
  72 enum {
  73     epgrppbcNONE, epgrppbcREFAT, epgrppbcCOS
  74 };
  75
  76 /*! \internal
  77  * \brief Pull group data used during pulling
  78  */
  79 struct pull_group_work_t
  80 {
  81     /*! \brief Constructor
  82      *
  83      * \param[in] params   The group parameters set by the user
  84      * \param[in] atomSet  The global to local atom set manager
  85      */
  86     pull_group_work_t(const t_pull_group &params,
  87                       gmx::LocalAtomSet   atomSet);
  88
  89     /* Data only modified at initialization */
  90     const t_pull_group params;        /**< The pull group parameters */
  91     const int          epgrppbc;      /**< The type of pbc for this pull group, see enum above */
  92     bool               needToCalcCom; /**< Do we need to calculate the COM? (Not for group 0 or if only used as cylinder group) */
  93     std::vector<real>  globalWeights; /**< Weights per atom set by the user and/or mass/friction coefficients, if empty all weights are equal */
  94
  95     /* Data modified only at init or at domain decomposition */
  96     gmx::LocalAtomSet                  atomSet;       /**< Global to local atom set mapper */
  97     std::vector<real>                  localWeights;  /**< Weights for the local atoms */
  98     std::unique_ptr<gmx::LocalAtomSet> pbcAtomSet;    /**< Keeps index of the pbc reference atom.
  99                                                            The stored LocalAtomSet consists of exactly one atom when pbc reference atom is required.
 100                                                            When no pbc refence atom is used, this pointer shall be null. */
 101
 102     /* Data, potentially, changed at every pull call */
 103     real                                  mwscale; /**< mass*weight scaling factor 1/sum w m */
 104     real                                  wscale;  /**< scaling factor for the weights: sum w m/sum w w m */
 105     real                                  invtm;   /**< inverse total mass of the group: 1/wscale sum w m */
 106     std::vector < gmx::BasicVector < double>> mdw; /**< mass*gradient(weight) for atoms */
 107     std::vector<double>                   dv;      /**< distance to the other group(s) along vec */
 108     dvec                                  x;       /**< COM before update */
 109     dvec                                  xp;      /**< COM after update before constraining */
 110 };
 111
 112 /* Struct describing the instantaneous spatial layout of a pull coordinate */
 113 struct PullCoordSpatialData
 114 {
 115     dvec          dr01;       /* The direction vector of group 1 relative to group 0 */
 116     dvec          dr23;       /* The direction vector of group 3 relative to group 2 */
 117     dvec          dr45;       /* The direction vector of group 5 relative to group 4 */
 118     dvec          vec;        /* The pull direction */
 119     double        vec_len;    /* Length of vec for direction-relative */
 120     dvec          ffrad;      /* conversion factor from vec to radial force */
 121     double        cyl_dev;    /* The deviation from the reference position */
 122     dvec          planevec_m; /* Normal of plane for groups 0, 1, 2, 3 for geometry dihedral */
 123     dvec          planevec_n; /* Normal of plane for groups 2, 3, 4, 5 for geometry dihedral */
 124
 125     double        value;      /* The current value of the coordinate, units of nm or rad */
 126 };
 127
 128 /* Struct with parameters and force evaluation local data for a pull coordinate */
 129 struct pull_coord_work_t
 130 {
 131     /* Constructor */
 132     pull_coord_work_t(const t_pull_coord &params) :
 133         params(params),
 134         value_ref(0),
 135         spatialData(),
 136         scalarForce(0),
 137         bExternalPotentialProviderHasBeenRegistered(false)
 138     {
 139     }
 140
 141     const t_pull_coord    params;      /* Pull coordinate parameters */
 142
 143     double                value_ref;   /* The reference value, usually init+rate*t, units of nm or rad */
 144
 145     PullCoordSpatialData  spatialData; /* Data defining the current geometry */
 146
 147     double                scalarForce; /* Scalar force for this cooordinate */
 148
 149     /* For external-potential coordinates only, for checking if a provider has been registered */
 150     bool          bExternalPotentialProviderHasBeenRegistered;
 151 };
 152
 153 /* Struct for storing vectorial forces for a pull coordinate */
 154 struct PullCoordVectorForces
 155 {
 156     dvec force01; /* Force due to the pulling/constraining for groups 0, 1 */
 157     dvec force23; /* Force for groups 2 and 3 */
 158     dvec force45; /* Force for groups 4 and 5 */
 159 };
 160
 161 /* Struct for sums over (local) atoms in a pull group */
 162 struct ComSums
 163 {
 164     /* For normal weighting */
 165     double sum_wm;    /* Sum of weight*mass        */
 166     double sum_wwm;   /* Sum of weight*weight*mass */
 167     dvec   sum_wmx;   /* Sum of weight*mass*x      */
 168     dvec   sum_wmxp;  /* Sum of weight*mass*xp     */
 169
 170     /* For cosine weighting */
 171     double sum_cm;    /* Sum of cos(x)*mass          */
 172     double sum_sm;    /* Sum of sin(x)*mass          */
 173     double sum_ccm;   /* Sum of cos(x)*cos(x)*mass   */
 174     double sum_csm;   /* Sum of cos(x)*sin(x)*mass   */
 175     double sum_ssm;   /* Sum of sin(x)*sin(x)*mass   */
 176     double sum_cmp;   /* Sum of cos(xp)*sin(xp)*mass */
 177     double sum_smp;   /* Sum of sin(xp)*sin(xp)*mass */
 178
 179     /* Dummy data to ensure adjacent elements in an array are separated
 180      * by a cache line size, max 128 bytes.
 181      * TODO: Replace this by some automated mechanism.
 182      */
 183     int    dummy[32];
 184 };
 185
 186 /*! \brief The cylinder buffer needs 9 elements per group */
 187 static constexpr int c_cylinderBufferStride = 9;
 188
 189 struct pull_comm_t
 190 {
 191     gmx_bool    bParticipateAll; /* Do all ranks always participate in pulling? */
 192     gmx_bool    bParticipate;    /* Does our rank participate in pulling? */
 193 #if GMX_MPI
 194     MPI_Comm    mpi_comm_com;    /* Communicator for pulling */
 195 #endif
 196     int         nparticipate;    /* The number of ranks participating */
 197     bool        isMasterRank;    /* Tells whether our rank is the master rank and thus should add the pull virial */
 198
 199     int64_t     setup_count;     /* The number of decomposition calls */
 200     int64_t     must_count;      /* The last count our rank needed to be part */
 201
 202     /* Buffers for parallel reductions */
 203     std::vector<gmx::RVec>                pbcAtomBuffer;  /* COM calculation buffer */
 204     std::vector < gmx::BasicVector < double>> comBuffer;  /* COM calculation buffer */
 205     std::vector<double>                   cylinderBuffer; /* cylinder ref. groups calculation buffer */
 206 };
 207
 208 struct pull_t
 209 {
 210     /* Global parameters */
 211     pull_params_t      params;       /* The pull parameters, from inputrec */
 212
 213     gmx_bool           bPotential;   /* Are there coordinates with potential? */
 214     gmx_bool           bConstraint;  /* Are there constrained coordinates? */
 215     gmx_bool           bAngle;       /* Are there angle geometry coordinates? */
 216
 217     int                ePBC;         /* the boundary conditions */
 218     int                npbcdim;      /* do pbc in dims 0 <= dim < npbcdim */
 219     gmx_bool           bRefAt;       /* do we need reference atoms for a group COM ? */
 220     int                cosdim;       /* dimension for cosine weighting, -1 if none */
 221     gmx_bool           bCylinder;    /* Is group 0 a cylinder group? */
 222
 223     /* Parameters + dynamic data for groups */
 224     std::vector<pull_group_work_t>  group;  /* The pull group param and work data */
 225     std::vector<pull_group_work_t>  dyna;   /* Dynamic groups for geom=cylinder */
 226
 227     /* Parameters + dynamic data for coordinates */
 228     std::vector<pull_coord_work_t> coord;  /* The pull group param and work data */
 229
 230     /* Global dynamic data */
 231     gmx_bool             bSetPBCatoms; /* Do we need to set x_pbc for the groups? */
 232
 233     int                  nthreads;     /* Number of threads used by the pull code */
 234     std::vector<ComSums> comSums;      /* Work array for summing for COM, 1 entry per thread */
 235
 236     pull_comm_t          comm;         /* Communication parameters, communicator and buffers */
 237
 238     FILE                *out_x;        /* Output file for pull data */
 239     FILE                *out_f;        /* Output file for pull data */
 240
 241     /* The number of coordinates using an external potential */
 242     int                numCoordinatesWithExternalPotential;
 243     /* Counter for checking external potential registration */
 244     int                numUnregisteredExternalPotentials;
 245     /* */
 246     int                numExternalPotentialsStillToBeAppliedThisStep;
 247 };
 248
 249 #endif