Configuration.h

#ifndef TOOLS_CONFIGURATION_H
#define TOOLS_CONFIGURATION_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 <tools/chemistry/Atom.h>             // member (template argument)
#include <tools/chemistry/Group.h>            // member (template argument)
#include <tools/chemistry/Species.h>          // member (template argument)
#include <tools/storage/AtomStorage.h>        // member 
#include <tools/storage/GroupStorage.h>       // member (template)
#include <simp/boundary/Boundary.h>           // member 
#include <util/containers/DArray.h>           // member (template)
#include <util/containers/DSArray.h>          // member (template)
#include <util/containers/ArrayIterator.h>    // inline function


namespace Tools 
{

   using namespace Util;
   using namespace Simp;

   class Configuration : public ParamComposite 
   {

   public:

      typedef ArrayIterator<Atom> AtomIterator;
      typedef ArrayIterator<Group <2> > BondIterator;
      typedef ArrayIterator<Group <3> > AngleIterator;
      typedef ArrayIterator<Group <4> > DihedralIterator;
      typedef ArrayIterator<Group <4> > ImproperIterator;

      Configuration();

      ~Configuration();

      using ParamComposite::readParam;

      void readParam(const char* filename);

      void readParameters(std::istream& in);

      void clear();
  
      // Accessors for members (non-const reference)

      Boundary& boundary();

      AtomStorage& atoms();

      #ifdef SIMP_BOND
      GroupStorage<2>& bonds();
      #endif

      #ifdef SIMP_ANGLE
      GroupStorage<3>& angles();
      #endif

      #ifdef SIMP_DIHEDRAL
      GroupStorage<4>& dihedrals();

      GroupStorage<4>& impropers();
      #endif

      int nSpecies() const;

      Species& species(int i);

   private:
     
      Boundary boundary_;

      AtomStorage atoms_;

      #ifdef SIMP_BOND
      GroupStorage<2> bonds_;
      #endif

      #ifdef SIMP_ANGLE
      GroupStorage<3> angles_;
      #endif

      #ifdef SIMP_DIHEDRAL
      GroupStorage<4> dihedrals_;

      GroupStorage<4> impropers_;
      #endif

      DArray<Species> species_;

      int atomCapacity_;

      #ifdef SIMP_BOND
      int bondCapacity_;
      #endif

      #ifdef SIMP_ANGLE
      int angleCapacity_;
      #endif

      #ifdef SIMP_DIHEDRAL
      int dihedralCapacity_;

      int improperCapacity_;
      #endif

      int nSpecies_;

   };

   // Inline functions

   /*
   * Return the Boundary by reference.
   */
   inline Boundary& Configuration::boundary() 
   {  return boundary_; }

   inline AtomStorage& Configuration::atoms()
   {  return atoms_; }

   #ifdef SIMP_BOND
   inline GroupStorage<2>& Configuration::bonds()
   {  return bonds_; }
   #endif

   #ifdef SIMP_ANGLE
   inline GroupStorage<3>& Configuration::angles()
   {  return angles_; }
   #endif

   #ifdef SIMP_DIHEDRAL
   inline GroupStorage<4>& Configuration::dihedrals()
   {  return dihedrals_; }

   inline GroupStorage<4>& Configuration::impropers()
   {  return impropers_; }
   #endif

   inline int Configuration::nSpecies() const
   {  return nSpecies_; }

   inline Species& Configuration::species(int i)
   {  return species_[i]; }

}
#endif