UnitCell.h

#ifndef PSCF_UNIT_CELL_H
#define PSCF_UNIT_CELL_H
 
/*
* PSCF - Polymer Self-Consistent Field Theory
*
* Copyright 2016 - 2022, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include "UnitCellBase.h"
#include <iostream>
#include <iomanip>
 
namespace Pscf
{
 
   using namespace Util;
 
   template <int D>
   class UnitCell : public UnitCellBase<D>
   {};
 
   // Function declations (friends of explicit instantiations)
 
   template <int D>
   std::istream& operator >> (std::istream& in, UnitCell<D>& cell);
 
   template <int D>
   std::ostream& operator << (std::ostream& out, UnitCell<D> const& cell);
 
   template <class Archive, int D>
   void 
   serialize(Archive& ar, UnitCell<D>& cell, const unsigned int version);
 
   template <int D>
   void readUnitCellHeader(std::istream& in, UnitCell<D>& cell);
 
   template <int D>
   void writeUnitCellHeader(std::ostream& out, UnitCell<D> const& cell);
 
   /*
   * Read common part of field header (fortran PSCF format).
   *
   * \param ver1  major file format version number (output)
   * \param ver2  major file format version number (output)
   * \param cell  UnitCell<D> object (output)
   * \param groupName  string identifier for space group (output)
   * \param nMonomer  number of monomers (output)
   * \ingroup Pscf_Crystal_Module
   */
   template <int D>
   void readFieldHeader(std::istream& in, int& ver1, int& ver2, 
                        UnitCell<D>& cell, std::string& groupName,
                        int& nMonomer);
 
   /*
   * Write common part of field header (fortran PSCF format).
   *
   * \param ver1  major file format version number (input)
   * \param ver2  major file format version number (input)
   * \param cell  UnitCell<D> object (input)
   * \param groupName  string identifier for space group (input)
   * \param nMonomer  number of monomers (input)
   * \ingroup Pscf_Crystal_Module
   */
   template <int D>
   void writeFieldHeader(std::ostream &out, int ver1, int ver2,
                         UnitCell<D> const & cell,
                         std::string const & groupName,
                         int nMonomer);
 
   // 1D Unit Cell
 
   template <>
   class UnitCell<1> : public UnitCellBase<1>
   {
   public:
 
      enum LatticeSystem {Lamellar, Null};
 
      UnitCell();
 
      UnitCell<1>& operator = (const UnitCell<1>& other);
 
      void set(UnitCell<1>::LatticeSystem lattice);
 
      void set(UnitCell<1>::LatticeSystem lattice, 
               FSArray<double, 6> const & parameters);
 
      LatticeSystem lattice() const
      {  return lattice_; }
 
      using UnitCellBase<1>::isInitialized;
 
   private:
 
      // Lattice type (lamellar or Null)
      LatticeSystem lattice_;
 
      // Set number of parameters required to describe current lattice type
      void setNParameter();
 
      // Set all internal data after setting parameter values
      void setBasis();
 
      // Private and unimplemented to prevent copy construction.
      UnitCell(UnitCell<1> const &);
 
   // friends:
 
      template <int D>
      friend std::istream& operator >> (std::istream&, UnitCell<D>& );
 
      template <int D>
      friend std::ostream& operator << (std::ostream&, UnitCell<D> const&);
 
      template <class Archive, int D>
      friend void serialize(Archive& , UnitCell<D>& , const unsigned int);
 
      template <int D>
      friend void readUnitCellHeader(std::istream&, UnitCell<D>& );
 
      template <int D>
      friend void writeUnitCellHeader(std::ostream&, UnitCell<D> const&);
 
   };
 
   std::istream& operator >> (std::istream& in,
                              UnitCell<1>::LatticeSystem& lattice);
 
   std::ostream& operator << (std::ostream& out,
                              UnitCell<1>::LatticeSystem lattice);
 
   template <class Archive>
   inline 
   void serialize(Archive& ar, UnitCell<1>::LatticeSystem& lattice, 
                  const unsigned int version)
   {  serializeEnum(ar, lattice, version); }
 
 
   // 2D Unit Cell
 
   template <>
   class UnitCell<2> : public UnitCellBase<2>
   {
   public:
 
      enum LatticeSystem {Square, Rectangular, Rhombic, Hexagonal,
                          Oblique, Null};
 
      UnitCell();
 
      UnitCell<2>& operator = (const UnitCell<2>& other);
 
      void set(UnitCell<2>::LatticeSystem lattice);
 
      void set(UnitCell<2>::LatticeSystem lattice, 
               FSArray<double, 6> const & parameters);
 
      LatticeSystem lattice() const
      {  return lattice_; }
 
   private:
 
      // Lattice system (square, rectangular, etc.)
      LatticeSystem lattice_;
 
      // Set number of parameters required to describe current lattice type
      void setNParameter();
 
      // Set all internal data after setting parameter values
      void setBasis();
 
      // Private and unimplemented to prevent copy construction.
      UnitCell(UnitCell<2> const &);
 
   // friends:
 
      template <int D>
      friend std::istream& operator >> (std::istream&, UnitCell<D>& );
 
      template <int D>
      friend std::ostream& operator << (std::ostream&, UnitCell<D> const&);
 
      template <class Archive, int D>
      friend void serialize(Archive& , UnitCell<D>& , const unsigned int );
 
      template <int D>
      friend void readUnitCellHeader(std::istream&, UnitCell<D>& );
 
      template <int D>
      friend void writeUnitCellHeader(std::ostream&, UnitCell<D> const&);
 
   };
 
   std::istream& operator >> (std::istream& in,
                              UnitCell<2>::LatticeSystem& lattice);
 
   std::ostream& operator << (std::ostream& out,
                              UnitCell<2>::LatticeSystem lattice);
 
   template <class Archive>
   inline 
   void serialize(Archive& ar, UnitCell<2>::LatticeSystem& lattice, 
                  const unsigned int version)
   {  serializeEnum(ar, lattice, version); }
 
 
   // 3D crystal unit cell
 
   template <>
   class UnitCell<3> : public UnitCellBase<3>
   {
   public:
 
      enum LatticeSystem {Cubic, Tetragonal, Orthorhombic, Monoclinic,
                          Triclinic, Rhombohedral, Hexagonal, Null};
 
      UnitCell();
 
      UnitCell<3>& operator = (const UnitCell<3>& other);
 
      void set(UnitCell<3>::LatticeSystem lattice);
 
      void set(UnitCell<3>::LatticeSystem lattice, 
               FSArray<double, 6> const & parameters);
 
      LatticeSystem lattice() const
      {  return lattice_; }
 
   private:
 
      LatticeSystem lattice_;
 
      // Set number of parameters required to describe current lattice type
      void setNParameter();
 
      // Set all internal data after setting parameter values
      void setBasis();
 
      // Private and unimplemented to prevent copy construction.
      UnitCell(UnitCell<3> const &);
 
   // friends:
 
      template <int D>
      friend std::istream& operator >> (std::istream&, UnitCell<D>& );
 
      template <int D>
      friend std::ostream& operator << (std::ostream&, UnitCell<D> const&);
 
      template <class Archive, int D>
      friend void serialize(Archive& , UnitCell<D>& , const unsigned int);
 
      template <int D>
      friend void readUnitCellHeader(std::istream&, UnitCell<D>& );
 
      template <int D>
      friend void writeUnitCellHeader(std::ostream&, UnitCell<D> const&);
 
   };
 
   std::istream& operator >> (std::istream& in,
                              UnitCell<3>::LatticeSystem& lattice);
 
   std::ostream& operator << (std::ostream& out,
                              UnitCell<3>::LatticeSystem lattice);
 
   template <class Archive>
   inline 
   void serialize(Archive& ar, UnitCell<3>::LatticeSystem& lattice, 
                  const unsigned int version)
   {  serializeEnum(ar, lattice, version); }
 
}
 
#include "UnitCell.tpp"
#endif