ddMd/configIos/ConfigIo.h

#ifndef DDMD_CONFIG_IO_H
#define DDMD_CONFIG_IO_H

/*
* Simpatico - Simulation Package for Polymeric and Molecular Liquids
*
* Copyright 2010 - 2017, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/

#include <util/param/ParamComposite.h>           // base class

#include <ddMd/storage/AtomStorage.h>            // member
#ifdef SIMP_BOND
#include <ddMd/storage/BondStorage.h>            // inline function
#endif 
#ifdef SIMP_ANGLE
#include <ddMd/storage/AngleStorage.h>           // inline function
#endif 
#ifdef SIMP_DIHEDRAL
#include <ddMd/storage/DihedralStorage.h>        // inline function
#endif 
#include <simp/boundary/Boundary.h>              // typedef
#include <util/containers/DArray.h>              // member

#include <ddMd/chemistry/MaskPolicy.h>

namespace DdMd
{

   class Simulation;
   class Domain;
   class Buffer;
   template <int N> class GroupStorage;
   template <int N> class GroupDistributor;
   template <int N> class GroupCollector;

   using namespace Util;
   using namespace Simp;

   class ConfigIo  : public ParamComposite
   {

   public:

      ConfigIo();

      ConfigIo(Simulation& simulation);

      virtual ~ConfigIo();

      void associate(Domain& domain, Boundary& boundary,
                     AtomStorage& atomStorage,
                     #ifdef SIMP_BOND
                     BondStorage& bondStorage,
                     #endif
                     #ifdef SIMP_ANGLE
                     AngleStorage& angleStorage,
                     #endif
                     #ifdef SIMP_DIHEDRAL
                     DihedralStorage& dihedralStorage,
                     #endif
                     Buffer& buffer);


      virtual void readConfig(std::ifstream& file, MaskPolicy maskPolicy) = 0;

      virtual void writeConfig(std::ofstream& file) = 0;

   protected:

      void setAtomMasks();

      Domain& domain();

      Boundary& boundary();
   
      AtomStorage& atomStorage();
   
      AtomDistributor& atomDistributor();

      AtomCollector& atomCollector();

      #ifdef SIMP_BOND

      BondStorage& bondStorage();
  
      GroupDistributor<2>& bondDistributor();

      GroupCollector<2>& bondCollector();
      #endif

      #ifdef SIMP_ANGLE

      AngleStorage& angleStorage();

      GroupDistributor<3>& angleDistributor();

      GroupCollector<3>& angleCollector();
      #endif

      #ifdef SIMP_DIHEDRAL

      DihedralStorage& dihedralStorage();

      GroupDistributor<4>& dihedralDistributor();

      GroupCollector<4>& dihedralCollector();
      #endif

   private:

      // Pointers to associated objects.
      Domain* domainPtr_;
      Boundary* boundaryPtr_;
      AtomStorage* atomStoragePtr_;
      #ifdef SIMP_BOND
      BondStorage* bondStoragePtr_;
      #endif
      #ifdef SIMP_ANGLE
      AngleStorage* angleStoragePtr_;
      #endif
      #ifdef SIMP_DIHEDRAL
      DihedralStorage* dihedralStoragePtr_;
      #endif

      template <int N>
      int readGroups(std::ifstream& file, 
                     const char* sectionLabel, const char* nGroupLabel,
                     GroupDistributor<N>& distributor);

      template <int N>
      int writeGroups(std::ofstream& file, 
                      const char* sectionLabel, const char* nGroupLabel,
                      GroupStorage<N>& storage, GroupCollector<N>& collector);

   };

   // Inline method definitions

   inline Domain& ConfigIo::domain()
   {  return *domainPtr_; }

   inline Boundary& ConfigIo::boundary()
   {  return *boundaryPtr_; }

   inline AtomStorage& ConfigIo::atomStorage()
   {  return *atomStoragePtr_; }

   inline AtomDistributor& ConfigIo::atomDistributor()
   {  return atomStoragePtr_->distributor(); }

   inline AtomCollector& ConfigIo::atomCollector()
   {  return atomStoragePtr_->collector(); }

   #ifdef SIMP_BOND
   inline BondStorage& ConfigIo::bondStorage()
   {  
      assert(bondStoragePtr_);
      return *bondStoragePtr_; 
   }

   inline GroupDistributor<2>& ConfigIo::bondDistributor()
   {  return bondStorage().distributor(); }

   inline GroupCollector<2>& ConfigIo::bondCollector()
   {  return bondStorage().collector(); }
   #endif

   #ifdef SIMP_ANGLE
   inline AngleStorage& ConfigIo::angleStorage()
   {
      assert(angleStoragePtr_);  
      return *angleStoragePtr_; 
   }

   inline GroupDistributor<3>& ConfigIo::angleDistributor()
   {  return angleStorage().distributor(); }

   inline GroupCollector<3>& ConfigIo::angleCollector()
   {  return angleStorage().collector(); }
   #endif

   #ifdef SIMP_DIHEDRAL
   inline DihedralStorage& ConfigIo::dihedralStorage()
   {
      assert(dihedralStoragePtr_);  
      return *dihedralStoragePtr_; 
   }

   inline GroupDistributor<4>& ConfigIo::dihedralDistributor()
   {  return dihedralStorage().distributor(); }

   inline GroupCollector<4>& ConfigIo::dihedralCollector()
   {  return dihedralStorage().collector(); }
   #endif

}
#endif