src/programs/alexandria/poldata.h

   1 /*
   2  * This source file is part of the Alexandria Chemistry Toolkit.
   3  *
   4  * Copyright (C) 2014-2020
   5  *
   6  * Developers:
   7  *             Mohammad Mehdi Ghahremanpour,
   8  *             Paul J. van Maaren,
   9  *             David van der Spoel (Project leader)
  10  *
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU General Public License
  13  * as published by the Free Software Foundation; either version 2
  14  * of the License, or (at your option) any later version.
  15  *
  16  * This program 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
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor,
  24  * Boston, MA  02110-1301, USA.
  25  */
  26
  27 /*! \internal \brief
  28  * Implements part of the alexandria program.
  29  * \author Mohammad Mehdi Ghahremanpour <mohammad.ghahremanpour@icm.uu.se>
  30  * \author David van der Spoel <david.vanderspoel@icm.uu.se>
  31  */
  32
  33
  34 #ifndef POLDATA_H
  35 #define POLDATA_H
  36
  37 #include <algorithm>
  38 #include <vector>
  39
  40 #include "gromacs/utility/stringutil.h"
  41
  42 #include "chargemodel.h"
  43 #include "poldata_low.h"
  44 #include "stringutil.h"
  45
  46 /* This source code file is part of the Alexandria project */
  47
  48 struct t_commrec;
  49
  50 namespace alexandria
  51 {
  52
  53 class Poldata
  54 {
  55     public:
  56
  57         Poldata() {};
  58
  59         /*! \brief
  60          * Set the file name gentop.dat
  61          *
  62          */
  63         void  setFilename(const std::string &fn2);
  64
  65         /*! \brief
  66          * Set the force field version
  67          * \param[in] version Force field version
  68          */
  69         void setVersion(const std::string &version)
  70         {
  71             alexandriaVersion_ = version;
  72         }
  73
  74         /*! \brief
  75          * Get the force field version
  76          * \return Force field version
  77          */
  78         const std::string &getVersion() const
  79         {
  80             return alexandriaVersion_;
  81         }
  82
  83         /*! \brief
  84          * Set the potential energy function for VDW interaction.
  85          * The VDW potentials supported by Alexandria are LJ, Buckingham, and Wang_Buckingham.
  86          *
  87          * \param[in] func  The name of the VDW potential function
  88          */
  89         void  setVdwFunction(const std::string &func);
  90
  91         /*! \brief
  92          * Set the combination rule
  93          *
  94          */
  95         void setCombinationRule(const std::string &func);
  96
  97         /*! \brief
  98          * Set relative dielectric constant
  99          *
 100          */
 101         void setEpsilonR(double epsilonR) { gtEpsilonR_ = epsilonR; }
 102
 103         /*! \brief
 104          * Set the number of exclusion
 105          */
 106         void setNexcl(int nexcl) { nexcl_ = nexcl; }
 107
 108         /*! \brief
 109          * Add the atom types used in Alexandria FF
 110          *
 111          **\param[in] elem          The element of the atom type
 112          **\param[in] desc          The description of the atom type
 113          **\param[in] atype         The atom type defined for this element in Alexandria FF
 114          **\param[in] ptype         The polarizability type defined for this element in Alexandria FF
 115          **\param[in] btype         The bond type defined for elem in Alexandria FF
 116          **\param[in] ztype         The zeta type defined for elem in Alexandria FF
 117          **\param[in] fixvdw        Are these parameters mutable?
 118          **\param[in] vdwparams     The VDW parameters for elem in Alexandria FF. The number of VDW parameters is 2 for LJ and 3 for
 119          *                         Buckingham and Wang_Buckingham potentials
 120          **\param[in] ref_enthalpy  The reference enthalpy for elem
 121          */
 122         void  addAtype(const std::string &elem,
 123                        const std::string &desc,
 124                        const std::string &atype,
 125                        const std::string &ptype,
 126                        const std::string &btype,
 127                        const std::string &ztype,
 128                        bool               fixvdw,
 129                        std::string       &vdwparams,
 130                        const std::string &ref_enthalpy);
 131
 132         /*! \brief
 133          *  Add the polarizability types
 134          *
 135          **\param[in] ptype           The name specifying the polarizability type in Alexandria FF
 136          **\param[in] miller          Miller polarizability type
 137          **\param[in] bosque          Bosque polarizability type
 138          **\param[in] polarizability  The calulated value of polarizability
 139          **\param[in] sigPol          The uncertainty of the calculated polarizability
 140          */
 141         void  addPtype(const std::string &ptype,
 142                        const std::string &miller,
 143                        const std::string &bosque,
 144                        double             polarizability,
 145                        double             sigPol);
 146
 147         void  addVsite(const std::string &atype,
 148                        const std::string &type,
 149                        int                number,
 150                        double             distance,
 151                        double             angle,
 152                        int                ncontrolatoms);
 153
 154         /*! \brief
 155          * Set the value and the associated error for the given poltype
 156          *
 157          **\param[in] ptype            Polarizabilty type
 158          **\param[in] polarizability   The value of polarizabilty
 159          **\param[in] sigPol           The error
 160          */
 161         bool setPtypePolarizability(const std::string &ptype,
 162                                     double             polarizability,
 163                                     double             sigPol);
 164
 165         /*! \brief
 166          * Set the unit of polarizability.
 167          */
 168         void setPolarUnit(const std::string &polarUnit)
 169         {
 170             alexandriaPolarUnit_ = polarUnit;
 171         }
 172
 173         /*! \brief
 174          * Set the reference polarizability value.
 175          */
 176         void setPolarRef(const std::string &polarRef)
 177         {
 178             alexandriaPolarRef_ = polarRef;
 179         }
 180
 181         /*! \brief
 182          * Set the vsite angle unit.
 183          */
 184         void setVsite_angle_unit(const std::string &angle_unit)
 185         {
 186             vsite_angle_unit_ = angle_unit;
 187         }
 188
 189         /*! \brief
 190          * Set the vsite angle unit.
 191          */
 192         void setVsite_length_unit(const std::string &length_unit)
 193         {
 194             vsite_length_unit_ = length_unit;
 195         }
 196
 197         std::vector<Vsite> &getVsite() {return vsite_; }
 198
 199         int getVdwFtype() const { return gtVdwFtype_; }
 200
 201         int getNexcl() const { return nexcl_; }
 202
 203         size_t getNatypes() const { return alexandria_.size(); }
 204
 205         size_t getNptypes() const { return ptype_.size(); }
 206
 207         /*! \brief
 208          * Return the reference enthalpy for the given atom type
 209          *
 210          **\param[in] atype Atom type
 211          **\param[ou] Href  Reference enthalpy
 212          */
 213         bool getAtypeRefEnthalpy(const std::string &atype,
 214                                  double            *Href) const;
 215
 216         /*! \brief
 217          * Return the combination rule
 218          *
 219          */
 220         const std::string &getCombinationRule() const { return gtCombinationRule_; }
 221
 222         /*! \brief
 223          * Return the combination rule.
 224          */
 225         int  getCombRule() const { return gtCombRule_; }
 226
 227         /*! \brief
 228          * Return the relative dielectric constant
 229          */
 230         double getEpsilonR() const { return gtEpsilonR_; }
 231
 232         std::string  getGeometry(std::string gtBrule);
 233
 234         /*! \brief
 235          * Return the discription corresponding to the atom type
 236          *
 237          * \param[in] atype  Atom Type
 238          */
 239         const std::string &getDesc(const std::string &atype) const;
 240
 241         /*! \brief
 242          * Return the element name corresponding to the atom type
 243          *
 244          * \param[in] atype  Atom Type
 245          */
 246         const std::string &getElem(const std::string &atype) const;
 247
 248         /*! \brief
 249          * Return the element name corresponding to the zeta type
 250          *
 251          * \param[in] ztype  zeta Type
 252          */
 253         const std::string &ztype2elem(const std::string &ztype) const;
 254
 255         std::vector<std::string> ztype_names() const;
 256
 257         /*! \brief
 258          * Return the charge corresponding to the atyom type
 259          * from the gentop.dat file
 260          *
 261          * \param[in] atype  Atom type
 262          */
 263         std::string  getCharge(  std::string atype);
 264
 265         std::vector<Ffatype> &getAtypes() {return alexandria_; }
 266
 267         FfatypeIterator getAtypeBegin() { return alexandria_.begin(); }
 268
 269         FfatypeIterator getAtypeEnd() { return alexandria_.end(); }
 270
 271         FfatypeConstIterator getAtypeBegin() const { return alexandria_.begin(); }
 272
 273         FfatypeConstIterator getAtypeEnd() const { return alexandria_.end(); }
 274
 275         /*! \brief
 276          * Return the iterator corresponding to the atom type
 277          *
 278          * \param[in] atype  Atom Type
 279          */
 280         FfatypeIterator findAtype(const std::string &atype)
 281         {
 282             return std::find_if(alexandria_.begin(), alexandria_.end(),
 283                                 [atype](Ffatype const &f)
 284                                 { return (atype == f.getType()); });
 285         }
 286
 287         /*! \brief
 288          * Return the const_iterator corresponding to the atom type
 289          *
 290          * \param[in] atype  Atom Type
 291          */
 292         FfatypeConstIterator findAtype(const std::string &atype) const
 293         {
 294             return std::find_if(alexandria_.begin(), alexandria_.end(),
 295                                 [atype](Ffatype const &f)
 296                                 { return (atype == f.getType()); });
 297         }
 298
 299         /*! \brief
 300          * Return the atom type corresponding to the bond type
 301          *
 302          * \param[in] btype  Bond Type
 303          */
 304         FfatypeIterator btypeToAtype(const std::string &btype)
 305         {
 306             return std::find_if(alexandria_.begin(), alexandria_.end(),
 307                                 [btype](Ffatype const &f)
 308                                 { return (btype == f.getBtype()); });
 309         }
 310
 311         /*! \brief
 312          * Return true if a given bond type exists in Alexandria
 313          *
 314          * \param[in] btype  Bond Type
 315          */
 316         bool haveBtype(const std::string &btype)
 317         {
 318             return (btypeToAtype(btype) != alexandria_.end());
 319         }
 320
 321         /*! \brief
 322          * Return the atom type corresponding to the polarizability type
 323          *
 324          * \param[in] ptype  Polarizability Type
 325          */
 326         FfatypeConstIterator ptypeToAtype(const std::string &ptype) const
 327         {
 328             return std::find_if(alexandria_.begin(), alexandria_.end(),
 329                                 [ptype](Ffatype const &f)
 330                                 { return (ptype == f.getPtype()); });
 331         }
 332
 333         PtypeConstIterator getPtypeBegin() const { return ptype_.begin(); }
 334
 335         PtypeConstIterator getPtypeEnd() const { return ptype_.end(); }
 336
 337         VsiteIterator getVsiteBegin()  { return vsite_.begin(); }
 338
 339         VsiteConstIterator getVsiteBegin()  const { return vsite_.begin(); }
 340
 341         VsiteIterator getVsiteEnd() { return vsite_.end(); }
 342
 343         VsiteConstIterator getVsiteEnd() const { return vsite_.end(); }
 344
 345         VsiteIterator findVsite(std::string  atype)
 346         {
 347
 348             return std::find_if(vsite_.begin(), vsite_.end(),
 349                                 [atype](const Vsite &vs)
 350                                 {
 351                                     return (atype == vs.atype());
 352                                 });
 353         }
 354
 355         VsiteConstIterator findVsite(std::string atype) const
 356         {
 357
 358             return std::find_if(vsite_.begin(), vsite_.end(),
 359                                 [atype](const Vsite &vs)
 360                                 {
 361                                     return (atype == vs.atype());
 362                                 });
 363         }
 364
 365         /*! \brief
 366          * Return the iterator corresponding to the polarizability type
 367          *
 368          * \param[in] ptype  Polarizability Type
 369          */
 370         PtypeIterator findPtype(const std::string &ptype)
 371         {
 372             return std::find_if(ptype_.begin(), ptype_.end(),
 373                                 [ptype](Ptype const &p)
 374                                 { return (ptype == p.getType()); });
 375         }
 376
 377
 378         /*! \brief
 379          * Return the poltype corresponding to atype and true if successful
 380          *
 381          * \param[in]  atype  Atom type
 382          * \param[out] ptype  Polarizability type.
 383          */
 384         bool atypeToPtype(const std::string &atype,
 385                           std::string       &ptype) const;
 386
 387         /*! \brief
 388          * Return the poltype corresponding to ztype and true if successful
 389          *
 390          * \param[in]  ztype  Zeta type
 391          * \param[out] ptype  Polarizability type.
 392          */
 393         bool ztypeToPtype(const std::string &ztype,
 394                           std::string       &ptype) const;
 395
 396         /*! \brief
 397          * Return the bond type corresponding to atom type and true if successful
 398          *
 399          * \param[in]  atype  Atom type
 400          * \param[out] btype  Polarizability type.
 401          */
 402         bool atypeToBtype(const std::string &atype,
 403                           std::string       &btype) const;
 404
 405
 406         /* Return 1 if OK, 0 if not found */
 407         bool getPtypePol(const std::string &ptype,
 408                          double *polarizability,
 409                          double *sigPol) const;
 410
 411         bool getAtypePol(const std::string &atype,
 412                          double *polarizability,
 413                          double *sigPol) const;
 414
 415         bool getZtypePol(const std::string &ztype,
 416                          double *polarizability,
 417                          double *sigPol) const;
 418
 419         void addMiller(const std::string &miller,
 420                        int                atomnumber,
 421                        double             tauAhc,
 422                        double             alphaAhp,
 423                        const std::string &alexandria_equiv);
 424
 425         /* Return true if "miller" was found */
 426         bool getMillerPol(const std::string &miller,
 427                           int               *atomnumber,
 428                           double            *tauAhc,
 429                           double            *alphaAhp,
 430                           std::string       &alexandria_equiv) const;
 431
 432         MillerIterator getMillerBegin() { return miller_.begin(); }
 433
 434         MillerIterator getMillerEnd() { return miller_.end(); }
 435
 436         MillerConstIterator getMillerBegin() const { return miller_.begin(); }
 437
 438         MillerConstIterator getMillerEnd() const { return miller_.end(); }
 439
 440         void setMillerFlags(const std::string &tauUnit,
 441                             const std::string &ahpUnit,
 442                             const std::string &ref)
 443         {
 444             millerTauUnit_ = tauUnit;
 445             millerAhpUnit_ = ahpUnit;
 446             millerRef_     = ref;
 447         }
 448
 449         void getMillerFlags(std::string &tauUnit,
 450                             std::string &ahpUnit,
 451                             std::string &ref) const
 452         {
 453             tauUnit = millerTauUnit_;
 454             ahpUnit = millerAhpUnit_;
 455             ref     = millerRef_;
 456         }
 457
 458         /*! \brief
 459          * Convert poltype to miller name. Return true if found
 460          */
 461         bool ptypeToMiller(const std::string &ptype,
 462                            std::string       &mil_type) const;
 463
 464         void  addBosque(const std::string &bosque,
 465                         double             polarizability)
 466         {
 467             Bosque bos(bosque, polarizability);
 468             bosque_.push_back(bos);
 469         }
 470
 471         BosqueIterator getBosqueBegin() { return bosque_.begin(); }
 472
 473         BosqueIterator getBosqueEnd() { return bosque_.end(); }
 474
 475         BosqueConstIterator getBosqueBegin() const { return bosque_.begin(); }
 476
 477         BosqueConstIterator getBosqueEnd() const { return bosque_.end(); }
 478
 479         void setBosqueFlags(const std::string &polarUnit,
 480                             const std::string &ref)
 481         {
 482             bosquePolarUnit_ = polarUnit;
 483             bosqueRef_       = ref;
 484         }
 485
 486         void getBosqueFlags(std::string &polarUnit,
 487                             std::string &ref) const
 488         {
 489             polarUnit = bosquePolarUnit_;
 490             ref       = bosqueRef_;
 491         }
 492
 493         /*! \brief
 494          * Convert poltype to bosque name.  Return true if found.
 495          */
 496         bool ptypeToBosque(const std::string &ptype,
 497                            std::string       &bosque) const;
 498
 499         bool getBosquePol(const std::string &bosque,
 500                           double            *polarizability) const;
 501
 502         /* Return true on success or false otherwise */
 503
 504         /*! \brief
 505          * Add a new force list. The routine checks for duplicate itypes
 506          * and will not add a second block of a certain type is one is
 507          * present already.
 508          * \param[in] forces
 509          */
 510         void addForces(const ListedForces &forces);
 511
 512         size_t nforces() const { return forces_.size(); }
 513
 514         ListedForces &lastForces() { return forces_.back(); }
 515
 516         const ListedForces &lastForces() const { return forces_.back(); }
 517
 518         ListedForcesIterator forcesBegin() { return forces_.begin(); }
 519
 520         ListedForcesIterator forcesEnd() { return forces_.end(); }
 521
 522         ListedForcesConstIterator forcesBegin() const { return forces_.begin(); }
 523
 524         ListedForcesConstIterator forcesEnd() const { return forces_.end(); }
 525
 526         ListedForcesIterator findForces(InteractionType iType)
 527         {
 528             return std::find_if(forces_.begin(), forces_.end(),
 529                                 [iType](ListedForces const &forces)
 530                                 { return (iType == forces.iType()); });
 531         }
 532
 533         ListedForcesConstIterator findForces(InteractionType iType) const
 534         {
 535             return std::find_if(forces_.begin(), forces_.end(),
 536                                 [iType](ListedForces const &forces)
 537                                 {return (iType == forces.iType()); });
 538         }
 539
 540         bool findForce(std::vector<std::string> &atoms,
 541                        ListedForceIterator      *force);
 542
 543
 544         bool findForce(const std::vector<std::string> &atoms,
 545                        ListedForceConstIterator       *force) const;
 546
 547         bool findForce(std::vector<std::string> &atoms,
 548                        ListedForceIterator      *force,
 549                        size_t                    bondOrder);
 550
 551
 552         bool findForce(const std::vector<std::string> &atoms,
 553                        ListedForceConstIterator       *force,
 554                        size_t                          bondOrder) const;
 555
 556         bool searchForce(std::vector<std::string> &atoms,
 557                          std::string              &params,
 558                          double                   *refValue,
 559                          double                   *sigma,
 560                          size_t                   *ntrain) const;
 561
 562         bool searchForceIType(std::vector<std::string> &atoms,
 563                          std::string              &params,
 564                          double                   *refValue,
 565                          double                   *sigma,
 566                          size_t                   *ntrain,
 567                          InteractionType           iType) const;
 568
 569         bool searchForceBondOrder(std::vector<std::string> &atoms,
 570                          std::string              &params,
 571                          double                   *refValue,
 572                          double                   *sigma,
 573                          size_t                   *ntrain,
 574                          size_t                    bondorder) const;
 575
 576         bool searchForceBondOrderIType(std::vector<std::string> &atoms,
 577                          std::string              &params,
 578                          double                   *refValue,
 579                          double                   *sigma,
 580                          size_t                   *ntrain,
 581                          size_t                    bondorder,
 582                          InteractionType           iType) const;
 583
 584         const std::string &getVdwFunction() const { return gtVdwFunction_; }
 585
 586         const std::string &getPolarUnit() const { return alexandriaPolarUnit_; }
 587
 588         const std::string &getPolarRef() const { return alexandriaPolarRef_; }
 589
 590         const std::string &getVsite_angle_unit() const { return vsite_angle_unit_; }
 591
 592         const std::string &getVsite_length_unit() const { return vsite_length_unit_; }
 593
 594         void addSymcharges(const std::string &central,
 595                            const std::string &attached,
 596                            int                numattach);
 597
 598         SymchargesIterator getSymchargesBegin() { return symcharges_.begin(); }
 599
 600         SymchargesIterator getSymchargesEnd() { return symcharges_.end(); }
 601
 602         SymchargesConstIterator getSymchargesBegin() const { return symcharges_.begin(); }
 603
 604         SymchargesConstIterator getSymchargesEnd() const { return symcharges_.end(); }
 605
 606         //! Return number of eemprops
 607         size_t getNumprops() const { return eep_.size();}
 608
 609         //! Return whether there is polarizability support for atype
 610         int havePolSupport(const std::string &atype) const;
 611
 612         bool haveEemSupport(const std::string &name,
 613                             gmx_bool           bAllowZeroParameters) const;
 614
 615         double getJ00(const std::string &name) const;
 616
 617         int getNzeta(const std::string &atype) const;
 618
 619         double getZeta(const std::string &name, int zz) const;
 620
 621         const char *getQstr(const std::string &name) const;
 622
 623         const char *getRowstr(const std::string &name) const;
 624
 625         double getQ(const std::string &name,
 626                     int                zz) const;
 627
 628         int getRow(const std::string &name,
 629                    int                zz) const;
 630
 631         double getChi0(const std::string &name) const;
 632
 633         const char *getOpts(const std::string &name) const;
 634
 635         void  addEemprops(Eemprops eep) { eep_.push_back(eep); }
 636
 637         EempropsConstIterator BeginEemprops() const { return eep_.begin(); }
 638
 639         EempropsConstIterator EndEemprops() const { return eep_.end(); }
 640
 641         EempropsIterator BeginEemprops() { return eep_.begin(); }
 642
 643         EempropsIterator EndEemprops() { return eep_.end(); }
 644
 645         /*! \brief Find the EEM properties
 646          *
 647          * Find the EEM properties corresponding to an atom type.
 648          * \param[in] atype     The Alexandria atom type
 649          * \returns   An iterator pointing to the right EEMprops
 650          *            structure or EndEemprops in case the atom type
 651          *            is not found.
 652          */
 653         EempropsConstIterator atype2Eem(const std::string &atype) const
 654         {
 655             auto eic = mapAtypeToEempropsConstIterator_.find(atype);
 656             if (eic != mapAtypeToEempropsConstIterator_.end())
 657             {
 658                 return eic->second;
 659             }
 660             else
 661             {
 662                 return EndEemprops();
 663             }
 664         }
 665
 666         EempropsIterator atype2Eem(const std::string &atype)
 667         {
 668             auto eic = mapAtypeToEempropsIterator_.find(atype);
 669             if (eic != mapAtypeToEempropsIterator_.end())
 670             {
 671                 return eic->second;
 672             }
 673             else
 674             {
 675                 return EndEemprops();
 676             }
 677         }
 678
 679         /*! \brief Find the EEM properties
 680          *
 681          * Find the EEM properties corresponding to a zeta type.
 682          * \param[in] atype     The Alexandria atom type
 683          * \returns   An iterator pointing to the right EEMprops
 684          *            structure or EndEemprops in case the atom type
 685          *            is not found.
 686          */
 687         EempropsConstIterator ztype2Eem(const std::string &ztype) const
 688         {
 689             auto eic = mapZtypeToEempropsConstIterator_.find(ztype);
 690             if (eic != mapZtypeToEempropsConstIterator_.end())
 691             {
 692                 return eic->second;
 693             }
 694             else
 695             {
 696                 return EndEemprops();
 697             }
 698         }
 699
 700         EempropsIterator ztype2Eem(const std::string &ztype)
 701         {
 702             auto eic = mapZtypeToEempropsIterator_.find(ztype);
 703             if (eic != mapZtypeToEempropsIterator_.end())
 704             {
 705                 return eic->second;
 706             }
 707             else
 708             {
 709                 return EndEemprops();
 710             }
 711         }
 712
 713
 714         //! Return the charge distribution model used
 715         ChargeModel getChargeModel() const { return ChargeModel_; }
 716
 717         //! Set the charge distribution model used
 718         void setChargeModel(ChargeModel eqdModel) { ChargeModel_ = eqdModel; }
 719
 720         //! Set the charge distribution model used
 721         void setChargeModel(const std::string eqdModel)
 722         {
 723             ChargeModel_ = name2eemtype(eqdModel);
 724         }
 725
 726         //! Return the array of eemprops
 727         std::vector<Eemprops> &getEemprops() {return eep_; }
 728
 729         //! Set the reference for EEM property calculations
 730         void  setEpref(const std::string &epref) { eepReference_ = epref; }
 731
 732         //! Get the reference for EEM property calculations
 733         const std::string &getEpref() const { return eepReference_; }
 734
 735         //! Spread from master to slave nodes
 736         void  broadcast(const t_commrec *cr);
 737
 738         //! Spread eemprop from master to slave nodes
 739         void broadcast_eemprop(const t_commrec *cr);
 740
 741         //! Spread ptype from master to slave nodes
 742         void broadcast_ptype(const t_commrec *cr);
 743
 744         CommunicationStatus Send(const t_commrec *cr, int dest);
 745
 746         CommunicationStatus Receive(const t_commrec *cr, int src);
 747
 748         //! \brief Make tables using std::map to prevent searching
 749         void makeMappings();
 750
 751         //! \brief Check internal consistency of data structures
 752         void checkConsistency(FILE *fplog) const;
 753     private:
 754         std::string                           filename_;
 755         std::vector<Ptype>                    ptype_;
 756         std::vector<Ffatype>                  alexandria_;
 757         std::vector<Vsite>                    vsite_;
 758         std::vector<std::string>              btype_;
 759         std::string                           alexandriaPolarUnit_;
 760         std::string                           alexandriaPolarRef_;
 761         std::string                           alexandriaVersion_;
 762         std::string                           vsite_angle_unit_;
 763         std::string                           vsite_length_unit_;
 764         int                                   nexcl_;
 765         std::string                           gtVdwFunction_, gtCombinationRule_;
 766         int                                   gtVdwFtype_, gtCombRule_;
 767         double                                gtEpsilonR_ = 1.0;
 768         std::vector<ListedForces>             forces_;
 769         std::vector<Miller>                   miller_;
 770         std::string                           millerTauUnit_, millerAhpUnit_;
 771         std::string                           millerRef_;
 772         std::vector<Bosque>                   bosque_;
 773         std::string                           bosquePolarUnit_;
 774         std::string                           bosqueRef_;
 775         std::vector<Symcharges>               symcharges_;
 776         std::vector<Eemprops>                 eep_;
 777         std::string                           eepReference_;
 778         ChargeModel                           ChargeModel_ = eqdACM_g;
 779
 780         void addBtype(const std::string &btype);
 781
 782         gmx_bool strcasestrStart(std::string needle, std::string haystack);
 783
 784         template<class Type>
 785         int indexOfPointInVector(Type * pointer, std::vector<Type> vector)
 786         {
 787             return (pointer - &(vector[0]));
 788         }
 789
 790         std::map<std::string, EempropsConstIterator> mapAtypeToEempropsConstIterator_;
 791         std::map<std::string, EempropsIterator> mapAtypeToEempropsIterator_;
 792         std::map<std::string, EempropsConstIterator> mapZtypeToEempropsConstIterator_;
 793         std::map<std::string, EempropsIterator> mapZtypeToEempropsIterator_;
 794 };
 795
 796 }
 797 #endif