hillclimber 0.1.6__cp313-cp313-macosx_15_0_x86_64.whl

plumed/_lib/include/plumed/tools/PDB.h

@@ -0,0 +1,154 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2011-2023 The plumed team
+   (see the PEOPLE file at the root of the distribution for a list of names)
+
+   See http://www.plumed.org for more information.
+
+   This file is part of plumed, version 2.
+
+   plumed 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 of the License, or
+   (at your option) any later version.
+
+   plumed 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 plumed.  If not, see <http://www.gnu.org/licenses/>.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+#ifndef __PLUMED_tools_PDB_h
+#define __PLUMED_tools_PDB_h
+
+#include "AtomNumber.h"
+#include "Vector.h"
+#include <vector>
+#include <string>
+#include <map>
+#include "Tensor.h"
+
+
+namespace PLMD {
+
+class GenericMolInfo;
+class OFile;
+class Log;
+
+/// Minimalistic pdb parser.
+/// Contain positions, atomic indexes, occupancy and beta.
+/// We should also add other info (e.g. residue name etc).
+class PDB {
+  std::vector<unsigned> block_ends;
+  std::vector<std::string> atomsymb, chain;
+  std::vector<unsigned> residue;
+  std::vector<Vector> positions;
+  std::vector<double> occupancy;
+  std::vector<double> beta;
+  std::vector<AtomNumber> numbers;
+  std::map<AtomNumber,unsigned> number2index;
+  std::vector<std::string> residuenames;
+  std::string mtype;
+  std::vector<std::string> flags;
+  std::vector<std::string> argnames;
+  std::map<std::string,std::vector<double> > arg_data;
+  Vector BoxXYZ,BoxABG;
+  Tensor Box;
+public:
+/// Read the pdb from a file, scaling positions by a factor scale
+  bool read(const std::string&file,bool naturalUnits,double scale);
+/// Read from a file pointer
+  bool readFromFilepointer(FILE *fp,bool naturalUnits,double scale);
+/// Access to the position array
+  const std::vector<Vector>     & getPositions()const;
+/// Access to the occupancy array
+  const std::vector<double>     & getOccupancy()const;
+/// Access to the beta array
+  const std::vector<double>     & getBeta()const;
+/// Access to the indexes
+  const std::vector<AtomNumber> & getAtomNumbers()const;
+///
+  std::vector<std::string> getArgumentNames()const;
+/// Add data to argnames map
+  void addRemark( std::vector<std::string>& v1 );
+/// Returns the number of atoms
+  unsigned                        size()const;
+/// Get the names of all the chains in the pdb file
+  void getChainNames( std::vector<std::string>& chains ) const;
+/// Get the residues in each of the chains
+  void getResidueRange( const std::string& chainname, unsigned& res_start, unsigned& res_end, std::string& errmsg ) const;
+/// Get the atoms in each of the chains
+  void getAtomRange( const std::string& chainname, AtomNumber& a_start, AtomNumber& a_end, std::string& errmsg ) const;
+/// Get the chain ID that a particular residue is a part of
+  std::string getChainID(const unsigned& resnumber) const;
+/// Get the chain ID from atom number
+  std::string getChainID(AtomNumber a) const;
+///use the log to dump information
+  friend Log& operator<<(Log& ostr, const PDB& pdb);
+/// return the name of a specific atom
+  std::string getAtomName(AtomNumber a) const;
+/// return the residue number for a specific atom
+  unsigned getResidueNumber(AtomNumber a) const;
+/// return the residue name for a specific atom
+  std::string getResidueName(AtomNumber a) const;
+/// get the name of the resnum'th residue
+  std::string getResidueName(const unsigned& resnum ) const;
+/// get the name of the resnum'th residue of chain
+/// Chain=="*" matches any chain and makes it equivalent to getResidueName
+  std::string getResidueName(const unsigned& resnum,const std::string& chain ) const;
+/// Check if any of the residues are named name
+  bool checkForResidue( const std::string& name ) const ;
+/// Check if any of the atoms are named atom
+  bool checkForAtom( const std::string& name ) const ;
+/// Check if specific atom exists
+  bool checkForAtom( AtomNumber a ) const ;
+/// Return the atom named aname from residue number resnum
+  AtomNumber getNamedAtomFromResidue( const std::string& aname, const unsigned& resnum ) const;
+/// Return the atom named aname from residue number resnum and chain.
+/// Chain=="*" matches any chain and makes it equivalent to getNamedAtomFromResidue.
+  AtomNumber getNamedAtomFromResidueAndChain( const std::string& aname, const unsigned& resnum, const std::string& chain ) const;
+/// Check if the properties that are required are in this pdb this is used in PLMD::mapping::Mapping
+//  bool hasRequiredProperties( const std::vector<std::string>& inproperties );
+/// This is used in PLMD::analysis::AnalysisWithDataCollection to add the sizes of the domains for PLMD::MultiRMSD
+  void addBlockEnd( const unsigned& end );
+/// This is used in PLMD::analysis::AnalysisWithDataCollection to add the numbers of the atoms
+  void setAtomNumbers( const std::vector<AtomNumber>& atoms );
+/// This is used in PLMD::analysis::AnalysisWithDataCollection to set the atom positions
+  void setAtomPositions( const std::vector<Vector>& pos );
+/// Set the argument names that you would like to use
+  void setArgumentNames( const std::vector<std::string>& argument_names );
+/// This is used in PLMD::analysis::AnalysisWithDataCollection to set the argument values
+  void setArgumentValue( const std::string& argname, const double& val );
+/// Get the value of one of the arguments in the PDB file
+  bool getArgumentValue( const std::string& name, std::vector<double>& value ) const ;
+/// Access to the atoms of a residue
+  std::vector<AtomNumber> getAtomsInResidue(const unsigned& resnum,const std::string& chainid)const;
+/// Access to the atoms of a chain
+  std::vector<AtomNumber> getAtomsInChain(const std::string& chainid)const;
+/// Get the extents of the blocks containing the atoms
+  const std::vector<unsigned> & getAtomBlockEnds() const ;
+/// Get the number of blocks of atoms in the pdb
+  unsigned getNumberOfAtomBlocks() const ;
+/// Set the position array
+  void setPositions(const std::vector<Vector> &v);
+/// Access to the position array
+  Vector getPosition(AtomNumber a)const;
+/// Print out a PDB object
+  void print( const double& lunits, GenericMolInfo* mymoldat, OFile& ofile, const std::string& fmt );
+/// Does the PDB have this flag
+  bool hasFlag( const std::string& fname ) const ;
+/// Get the metric type
+  std::string getMtype() const ;
+/// Returns box axis lengths
+  const Vector & getBoxAxs()const;
+/// Returns box axis angles
+  const Vector & getBoxAng()const;
+/// Returns box axis vectors
+  const Tensor & getBoxVec()const;
+/// Return true if the residue name is one of the allowed reisude names e.g. one of the 20 amino acids for proteins
+  bool allowedResidue( const std::string& type, const std::string& residuename ) const;
+};
+
+}
+#endif

plumed/_lib/include/plumed/tools/Pbc.h

@@ -0,0 +1,139 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2011-2023 The plumed team
+   (see the PEOPLE file at the root of the distribution for a list of names)
+
+   See http://www.plumed.org for more information.
+
+   This file is part of plumed, version 2.
+
+   plumed 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 of the License, or
+   (at your option) any later version.
+
+   plumed 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 plumed.  If not, see <http://www.gnu.org/licenses/>.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+#ifndef __PLUMED_tools_Pbc_h
+#define __PLUMED_tools_Pbc_h
+
+#include "Vector.h"
+#include "Tensor.h"
+#include "../small_vector/small_vector.h"
+#include "View.h"
+#include "View2D.h"
+#include <vector>
+#include <cstddef>
+#include <limits>
+
+namespace PLMD {
+
+template <std::size_t N=3>
+using MemoryView=View<double,N>;
+
+template < std::size_t N=helpers::dynamic_extent, std::size_t STRIDE=3>
+using mdMemoryView = View2D<double,N,STRIDE>;
+
+using VectorView = mdMemoryView<helpers::dynamic_extent, 3>;
+
+/*
+Tool to deal with periodic boundary conditions.
+
+This class is useful to apply periodic boundary conditions on interatomic
+distances. It stores privately information about reduced lattice vectors
+*/
+class Pbc {
+/// Type of box
+  enum {unset,orthorombic,generic} type;
+/// This is the maximum expected size for general boxes.
+/// I found this empirically by manually modifying regtest basic/rt-make-1
+/// Since it uses randomly generated boxes it should be correct.
+/// In any case, this is just used as a hint for small_vector,
+/// which will then switch to heap allocations if more shifts are needed
+  static constexpr unsigned maxshiftsize=6;
+/// Box
+  Tensor box;
+/// Inverse box
+  Tensor invBox;
+/// Reduced box.
+/// This is a set of lattice vectors generating the same lattice
+/// but "minimally skewed". Useful to optimize image search.
+  Tensor reduced;
+/// Inverse of the reduced box
+  Tensor invReduced;
+/// List of shifts that should be attempted.
+/// Depending on the sign of the scaled coordinates representing
+/// a distance vector, a different set of shifts must be tried.
+  gch::small_vector<Vector,maxshiftsize> shifts[2][2][2];
+/// Alternative representation for orthorombic cells.
+/// Not really used, but could be used to optimize search in
+/// orthorombic cells.
+  Vector diag,hdiag,mdiag;
+/// Build list of shifts.
+/// This is expensive, and must be called only when box is
+/// reset. It allows building a minimal set of shifts
+/// depending on the sign of the scaled coordinates representing
+/// a distance vector.
+  void buildShifts(gch::small_vector<Vector,maxshiftsize> shifts[2][2][2])const;
+public:
+///Helper function for moving the class to an openacc device
+  void toACCDevice()const ;
+///Helper function for cleaning the memory of the class from an openacc device
+  void removeFromACCDevice() const;
+/// Constructor
+  Pbc();
+/// Compute modulo of (v2-v1), using or not pbc depending on bool pbc.
+  double distance( const bool pbc, const Vector& v1, const Vector& v2 ) const;
+/// Computes v2-v1, using minimal image convention
+/// if specified, also returns the number of attempted shifts
+#pragma acc routine seq
+  Vector distance(const Vector&, const Vector&)const;
+/// Computes v2-v1, using minimal image convention
+/// if specified, also returns the number of attempted shifts
+  Vector distance(const Vector&, const Vector&,int*nshifts)const;
+/// Apply PBC to a set of positions or distance vectors
+#pragma acc routine seq
+  void apply(VectorView dlist, unsigned max_index=0) const;
+#pragma acc routine seq
+  void apply(std::vector<Vector>&dlist, unsigned max_index=0) const;
+/// Set the lattice vectors.
+/// b[i][j] is the j-th component of the i-th vector
+  void setBox(const Tensor&b);
+/// Returns the box
+#pragma acc routine seq
+  const Tensor& getBox()const;
+/// Returns the inverse matrix of box.
+/// Thus: pbc.getInvBox() == inverse(pbc.getBox()).
+#pragma acc routine seq
+  const Tensor& getInvBox()const;
+/// Transform a vector in real space to a vector in scaled coordinates.
+/// Thus:pbc.realToScaled(v) == matmul(transpose(inverse(pbc.getBox(),v)));
+#pragma acc routine seq
+  Vector realToScaled(const Vector&)const;
+/// Transform a vector in scaled coordinates to a vector in real space.
+/// Thus:pbc.scaledToRead(v) == matmul(transpose(pbc.getBox()),v);
+#pragma acc routine seq
+  Vector scaledToReal(const Vector&)const;
+/// Returns true if the box vectors are orthogonal
+#pragma acc routine seq
+  bool isOrthorombic()const;
+/// Full search (for testing).
+/// Perform a full search on vector
+  void fullSearch(Vector&)const;
+/// Returns true if box is set and non zero
+  bool isSet()const;
+};
+
+inline
+bool Pbc::isSet()const {
+  return type!=unset;
+}
+
+}
+
+#endif

plumed/_lib/include/plumed/tools/PlumedHandle.h

@@ -0,0 +1,105 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2018-2023 The plumed team
+   (see the PEOPLE file at the root of the distribution for a list of names)
+
+   See http://www.plumed.org for more information.
+
+   This file is part of plumed, version 2.
+
+   plumed 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 of the License, or
+   (at your option) any later version.
+
+   plumed 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 plumed.  If not, see <http://www.gnu.org/licenses/>.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+#ifndef __PLUMED_tools_PlumedHandle_h
+#define __PLUMED_tools_PlumedHandle_h
+#include "../core/PlumedMainInitializer.h"
+#include "../core/WithCmd.h"
+#include "TypesafePtr.h"
+#include <memory>
+
+namespace PLMD {
+
+class PlumedMain;
+
+/**
+Tiny local class to load a PLUMED kernel.
+
+Maps command to either a loaded PLUMED kernel or to the present one.
+It provides a wrapper around the official interface located at wrapper/Plumed.h,
+with some changes.
+Differences are:
+- It does not use the `PLUMED_KERNEL` env var. Indeed, it would not make sense to use it,
+  since this class is meant to load different kernels.
+- It does not implement interoperability with C/FORTRAN interfaces.
+- It does not implement global versions (e.g. PLMD::Plumed::gcmd).
+- It does not implement PLMD::Plumed::valid. If kernel cannot be loaded, its constructor throws.
+  This will make sure that once constructed the object is usable.
+
+In its implementation, this class uses the PLMD::Plumed class in wrapper/Plumed.h and thus
+has the same capability to load PLUMED kernels of any version (starting with 2.0).
+It can also be created without passing any kernel path. In that case it refers to the current one
+(the one to which this class belongs).
+
+The following syntax creates a handle referring to the current kernel
+\verbatim
+PlumedHandle p;
+// Alternatively:
+// auto p=PlumedHandle();
+p.cmd("init");
+\endverbatim
+
+The following syntax instead creates a handle referring to a loaded kernel
+\verbatim
+PlumedHandle p(PlumedHandle::dlopen("/path/to/libplumedkernel.so");
+// Alternatively:
+// auto p=PlumedHandle::dlopen("/path/to/libplumedkernel.so");
+p.cmd("init");
+\endverbatim
+
+Notice that if there are problems loading the kernel an exception is thrown.
+Thus, once constructed the object is guaranteed to be functional.
+
+*/
+class PlumedHandle :
+  public WithCmd {
+/// Pointer to PlumedMain.
+/// Used when using the current kernel in order to avoid unneeded indirections.
+  std::unique_ptr<PlumedMain> local;
+/// Pointer to loaded Plumed object;
+  void* loaded=nullptr;
+/// Constructor using the path to a kernel.
+/// I keep it private to avoid confusion wrt the
+/// similar constructor of PLMD::Plumed that accepts a string (conversion from FORTRAN).
+  explicit PlumedHandle(const char* path);
+public:
+/// Default constructor.
+/// Maps following commands to the current kernel.
+  PlumedHandle();
+/// Construct a PlumedHandle given the path to a kernel.
+/// It just uses the private constructor PlumedHandle(const char* path).
+  static PlumedHandle dlopen(const char* path);
+/// Destructor.
+/// In case a kernel was dlopened, it dlcloses it.
+/// I make it virtual for future extensibility, though this is not necessary now.
+  virtual ~PlumedHandle();
+/// Move constructor.
+  PlumedHandle(PlumedHandle && other) noexcept;
+/// Move assignment.
+  PlumedHandle & operator=(PlumedHandle && other) noexcept;
+/// Execute cmd.
+  void cmd(std::string_view key,const TypesafePtr & ptr) override;
+/// Bring in the possibility to pass shape/nelem
+  using WithCmd::cmd;
+};
+
+}
+#endif