SpaceGroup.h

#ifndef PRDC_SPACE_GROUP_H
#define PRDC_SPACE_GROUP_H
 
/*
* Simpatico - Simulation Package for Polymeric and Molecular Liquids
*
* Copyright 2015 - 2025, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include <prdc/crystal/SpaceSymmetry.h>
#include <prdc/crystal/SymmetryGroup.h>
#include <pscf/math/IntVec.h>
#include <util/containers/FSArray.h>
#include <util/param/Label.h>
#include <iostream>
 
namespace Pscf {
namespace Prdc {
 
   using namespace Util;

   template <int D>
   class SpaceGroup : public SymmetryGroup< SpaceSymmetry<D> >
   {
 
   public:

      bool 
      hasInversionCenter(typename SpaceSymmetry<D>::Translation& center) 
      const;

      void 
      shiftOrigin(typename SpaceSymmetry<D>::Translation const & origin);

      void checkMeshDimensions(IntVec<D> const & dimensions) const;
 
      // Using declarations for some inherited functions
      using SymmetryGroup< SpaceSymmetry <D> >::size;
 
   };
 
   // Template function definition
 
   template <int D>
   std::ostream& operator << (std::ostream& out, SpaceGroup<D> const & g)
   {
      int size = g.size();
      out << "dim  " << D << std::endl;
      out << "size " << size << std::endl;
      for (int i = 0; i < size; ++i) {
         out << std::endl;
         out << g[i];
      }
      return out;
   }
 
   template <int D>
   std::istream& operator >> (std::istream& in, SpaceGroup<D>& g)
   {
      int dim, size;
      in >> Label("dim") >> dim;
      UTIL_CHECK(D == dim);
      in >> Label("size") >> size;
 
      SpaceSymmetry<D> s;
      g.clear();
      for (int i = 0; i < size; ++i) {
         in >> s;
         g.add(s);
      }
      return in;
   }

   template <int D>
   void readGroup(std::string groupName, SpaceGroup<D>& group);

   template <int D>
   void writeGroup(std::string filename, SpaceGroup<D> const & group);
 
   #ifndef PRDC_SPACE_GROUP_TPP
   extern template class SpaceGroup<1>;
   extern template class SpaceGroup<2>;
   extern template class SpaceGroup<3>;
   extern template void readGroup(std::string, SpaceGroup<1>& );
   extern template void readGroup(std::string, SpaceGroup<2>& );
   extern template void readGroup(std::string, SpaceGroup<3>& );
   extern template void writeGroup(std::string, SpaceGroup<1> const &);
   extern template void writeGroup(std::string, SpaceGroup<2> const &);
   extern template void writeGroup(std::string, SpaceGroup<3> const &);
   #endif
 
}
}
#endif