[WIP] Electrostatics joshs development

CMakeLists.txt

@@ -41,6 +41,9 @@ include(GNUInstallDirs)
 option(ENABLE_TESTING "Build and enable testing stuff" OFF)
 if(ENABLE_TESTING)
   enable_testing()
+  include(FindPackageHandleStandardArgs)
+  find_program(VALGRIND_EXECUTABLE "valgrind")
+  find_package_handle_standard_args(VALGRIND REQUIRED_VARS VALGRIND_EXECUTABLE)
 endif(ENABLE_TESTING)
 
 ########################################################################

include/votca/csg/CMakeLists.txt

@@ -1,2 +1,4 @@
-file(GLOB_RECURSE VOTCA_HEADERS *.h potentialfunctions/*.h)
+file(GLOB VOTCA_HEADERS *.h potentialfunctions/*.h)
+file(GLOB IO_HEADERS io/*.h) 
 install(FILES ${VOTCA_HEADERS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/votca/csg)
+install(FILES ${IO_HEADERS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/votca/csg/io)

include/votca/csg/atomcgconverter.h

@@ -0,0 +1,217 @@
+/*
+ * Copyright 2009-2019 The VOTCA Development Team (http://www.votca.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#pragma once
+#ifndef VOTCA_CSG_ATOMTOCGCONVERTER_H
+#define VOTCA_CSG_ATOMTOCGCONVERTER_H
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "beadmap.h"
+#include "cgmoleculestencil.h"
+#include "exclusionlist.h"
+#include "molecule.h"
+#include <boost/bimap.hpp>
+#include <votca/tools/property.h>
+#include <votca/tools/types.h>
+
+namespace votca {
+namespace csg {
+
+/**
+ * @brief Converter class provides methods for converting a atomistic molecule
+ * to a coarse grained molecule
+ *
+ * Note the converter should not have ownership of any of the topology objects
+ * because it should be able to convert between any topology object as long as
+ * it has the stencil, this means that for each operation that it performs
+ * an atomistic (input) object and a coarse grained (output) object must be
+ * provided.
+ */
+class AtomCGConverter {
+ public:
+  /// Constructor
+  AtomCGConverter(std::vector<std::string> ignore_atom_mol_types);
+
+  /// Define parameterless constructor
+  AtomCGConverter(){};
+
+  /**
+   * @brief Loads the .xml file describing the cg molecule
+   *
+   * Will load the information from the cg.xml file and create a stencil from
+   * the input. For each cg molecule defined.
+   *
+   * @param[in] filename should be an .xml file
+   */
+  void LoadMoleculeStencil(const std::string &filename);
+
+  /**
+   * @brief Provided the atomic type of the molecule returns the cg type of the
+   * molecule
+   *
+   * @param[in] atomistic_mol_type
+   *
+   * @return cg molecule type as a string
+   */
+  const std::string &getCGMoleculeType(const std::string &atom_mol_type) const;
+
+  /**
+   * @brief Provided the cg type of the molecule returns the atomic type of the
+   * molecule
+   *
+   * @param cg_mol_type
+   *
+   * @return atomistic molecule type as a string
+   */
+  const std::string &getAtomisticMoleculeType(
+      const std::string &cg_mol_type) const;
+
+  /**
+   * @brief Converts a atomic topology to a coarsegrained topology
+   *
+   * @param atomic_top_in
+   * @param cg_top_out
+   */
+  Topology Convert(const Topology &atom_top_in);
+
+  /**
+   * @brief Updates the cg topology object using the atomistic topology
+   *
+   * The properties updated include the time step, bead positions, forces and
+   * velocities etc...
+   *
+   * New molecules and beads are not created with this method, if the atomistic
+   * topology and the cg topology are inconsistent an error should occur. As an
+   * example if the atomistic topology contains a molecule that does not have
+   * a corresponding sister/brother molecule in the coarse grained description
+   * an error should be thrown.
+   *
+   * @param atomic_top_in
+   * @param cg_top_out
+   */
+  void Update(const Topology &atom_top_in, Topology &cg_top_out) const;
+
+  /**
+   * @brief Returns the atomisitc beads that make up a given coarse grained
+   * bead in a particular molecule
+   *
+   * @param cg_mol_type
+   * @param cg_bead_type
+   *
+   * @return vector of the atomistic bead names in the coarse grained bead
+   * specified
+   */
+  std::vector<std::string> getAtomicBeadNamesOfCGBead(
+      const std::string &cg_mol_type, const std::string &cg_bead_type) const;
+
+  /**
+   * @brief Determines if an atomisitic molecule of the provided type exists
+   *
+   * @param atom_mol_type
+   *
+   * @return true or false
+   */
+  bool AtomisticMoleculeTypeExist(const std::string &atom_mol_type) const
+      noexcept;
+
+ private:
+  std::map<int, std::map<int, std::vector<std::pair<std::string, int>>>>
+      cgmolid_cgbeadid_atombeadnames_and_ids_;
+
+  std::unordered_set<std::string> atom_mol_types_to_ignore_;
+  /**
+   * @brief Atomic and cg bimap stores the relationship between the two types
+   * of molecules
+   */
+  boost::bimap<std::string, std::string> atom_and_cg_mol_types_;
+
+  /**
+   * @brief Stores the stencil of the cg molecule
+   *
+   * string is the cg_mol_type
+   */
+  std::unordered_map<std::string, CGMoleculeStencil> cg_mol_and_stencil_;
+
+  // First string atomic_molecule_type
+  // Second string cg_mol_type
+  // The molecule map
+  std::unordered_map<std::string,
+                     std::unordered_map<std::string, AtomToCGMoleculeMapper>>
+      mol_names_and_maps_;
+
+  /**
+   * @brief Maps a atomistic molecule to a cg molecule and adds it to the cg
+   * topology
+   *
+   * Note that the cg and atomistic descriptions should have the same molecule
+   * ids, this means that the molecule ids will remain consistent between the
+   * coarse grained and atomistic descriptions.
+   *
+   * @param[in] atomistic_mol
+   * @param[in,out] cg_top_out
+   */
+  //  void ConvertAtomisticMoleculeToCGAndAddToCGTopology_(
+  Molecule &CoarseGrainMolecule_(const Topology &atom_top, Topology &cg_top_out,
+                                 const Molecule &atom_mol);
+
+  /**
+   * @brief
+   *
+   * Must pass all the atomic molecules bead ids in, the bead ids must increase
+   * in magnitude in correlation to how the .xml files are defined
+   *
+   * @param cg_or_atomic_mol_type
+   * @param atomic_bead_ids
+   *
+   * @return
+   */
+  std::unordered_map<int, std::string> MapAtomicBeadIdsToAtomicBeadNames_(
+      const std::string &cg_or_atom_mol_type,
+      const std::vector<int> &atom_bead_ids) const;
+
+  bool CheckThatBeadCountAndInteractionTypeAreConsistent_(
+      const std::string &interaction_type, const size_t &bead_count) const
+      noexcept;
+
+  std::vector<CGBeadStencil> ParseBeads_(tools::Property &options);
+
+  std::vector<CGInteractionStencil> ParseBonded_(tools::Property &options);
+
+  void ParseBeadMaps_(
+      tools::Property &options_in,
+      std::unordered_map<std::string, CGBeadStencil> &bead_maps_info);
+
+  std::map<int, std::vector<std::pair<std::string, int>>>
+      MapAtomicBeadsToCGBeads_(const Topology &atom_top, Topology &cg_top_out,
+                               Molecule &cg_mol,
+                               const CGMoleculeStencil &stencil) const;
+
+  void CreateInteractions_(Topology &cg_top_out, Molecule &cg_mol,
+                           const CGMoleculeStencil &stencil) const;
+
+  std::map<int, std::vector<std::pair<std::string, int>>>
+      MapAtomicMoleculeToCGMolecule_(const Topology &atom_top,
+                                     Topology &cg_top_out, const int &mol_id);
+};
+
+}  // namespace csg
+}  // namespace votca
+
+#endif  // VOTCA_CSG_ATOMTOCGCONVERTER_H

include/votca/csg/basebead.h

@@ -15,17 +15,14 @@
  *
  */
 
+#pragma once
 #ifndef _VOTCA_CSG_BASEBEAD_H
 #define _VOTCA_CSG_BASEBEAD_H
 
 #include <assert.h>
 #include <memory>
-#include <votca/csg/moleculeitem.h>
-#include <votca/csg/topologyitem.h>
+#include <votca/tools/constants.h>
 #include <votca/tools/eigen.h>
-#include <votca/tools/identity.h>
-#include <votca/tools/name.h>
-namespace TOOLS = votca::tools;
 
 namespace votca {
 namespace csg {
@@ -46,49 +43,48 @@ class BaseBead {
   virtual ~BaseBead() {}
 
   /// Gets the id of the bead
-  int getId() const { return id_.getId(); }
+  int getId() const noexcept { return id_; }
 
   /// Sets the id of the bead
-  void setId(int id) { id_.setId(id); }
-
-  /// Gets the name of the bead
-  std::string getName() const { return name_.getName(); }
-
-  /// Sets the name of the bead
-  void setName(std::string name) { return name_.setName(name); }
+  void setId(int id) noexcept { id_ = id; }
 
   /// Sets the molecule the bead is attached too
-  void setMolecule(Molecule *molecule) { molecule_item_.setMolecule(molecule); }
+  void setMoleculeId(int molecule_id) noexcept { molecule_id_ = molecule_id; }
 
   /// Gets the molecule pointer the bead is attached too
-  Molecule *getMolecule() const { return molecule_item_.getMolecule(); }
-
-  /// Gets the topology pointer the bead is attached too
-  Topology *getParent() const { return topology_item_.getParent(); }
+  int getMoleculeId() const noexcept { return molecule_id_; }
 
   /**
    * get the bead type
    * \return const string
    */
-  virtual const std::string getType() const { return type_.getName(); }
+  virtual const std::string getType() const noexcept { return type_; }
 
   /**
    * set the bead type
    * \param bead type object
    */
-  virtual void setType(std::string type) { type_.setName(type); }
+  virtual void setType(std::string type) noexcept { type_ = type; }
+
+  /**
+   * @brief Returns the element type of the bead
+   *
+   * @return either the element symbol i.e. "Si" for silcon or unassigned if it
+   * has not been specified.
+   */
+  std::string getElement() const noexcept { return element_symbol_; }
 
   /**
    * get the mass of the base bead
    * \return - base bead mass
    */
-  virtual const double &getMass() const { return mass_; }
+  virtual const double &getMass() const noexcept { return mass_; }
 
   /**
    * set the mass of the base bead
    * \param - base bead mass
    */
-  virtual void setMass(const double &m) { mass_ = m; }
+  virtual void setMass(const double &m) noexcept { mass_ = m; }
 
   /**
    * set the position of the base bead
@@ -112,25 +108,20 @@ class BaseBead {
   }
 
   /** does this configuration store positions? */
-  bool HasPos() const { return bead_position_set_; }
+  bool HasPos() const noexcept { return bead_position_set_; }
 
   /** set has position to true */
-  void HasPos(bool true_or_false) { bead_position_set_ = true_or_false; }
+  void HasPos(bool true_or_false) noexcept {
+    bead_position_set_ = true_or_false;
+  }
 
  protected:
-  BaseBead()
-      : topology_item_(nullptr),
-        molecule_item_(nullptr),
-        mass_(0.0),
-        bead_position_set_(false){};
-
-  TopologyItem topology_item_;
-  MoleculeItem molecule_item_;
-
-  TOOLS::Identity<int> id_;
-  TOOLS::Name name_;
-  TOOLS::Name type_;
+  BaseBead() : mass_(0.0), bead_position_set_(false){};
 
+  int molecule_id_ = tools::topology_constants::unassigned_molecule_id;
+  int id_ = tools::topology_constants::unassigned_bead_id;
+  std::string type_ = tools::topology_constants::unassigned_bead_type;
+  std::string element_symbol_ = tools::topology_constants::unassigned_element;
   double mass_;
   Eigen::Vector3d bead_position_;