UnitCell.h

#ifndef PRDC_UNIT_CELL_H
#define PRDC_UNIT_CELL_H
 
/*
* PSCF - Polymer Self-Consistent Field
*
* Copyright 2015 - 2025, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include "UnitCellBase.h"
#include <util/format/Dbl.h>
 
#include <iostream>
#include <iomanip>
 
namespace Pscf {
namespace Prdc {
 
   using namespace Util;

   template <int D>
   class UnitCell : public UnitCellBase<D>
   {};
 
   // Function template declarations 

   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);
 
   // 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_; }

      double volume() const;
 
      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_; }

      double volume() const;
 
   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_; }

      double volume() const;
 
   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);
 
   // General Function Templates
 
   /*
   * Serialize to/from an archive.
   */
   template <class Archive, int D>
   void serialize(Archive& ar, UnitCell<D>& cell, 
                  const unsigned int version)
   {
      serializeEnum(ar, cell.lattice_, version);
      ar & cell.nParameter_;
      for (int i = 0; i < cell.nParameter_; ++i) {
         ar & cell.parameters_[i];
      }
   }
 
   template <class Archive>
   inline 
   void serialize(Archive& ar, UnitCell<3>::LatticeSystem& lattice, 
                  const unsigned int version)
   {  serializeEnum(ar, lattice, version); }
 
 
   // UnitCell stream IO operator template definitions
 
   template <int D>
   std::istream& operator >> (std::istream& in,
                              UnitCell<D>& cell)
   {
      typename UnitCell<D>::LatticeSystem lattice;
      in >> lattice;
      cell.set(lattice);
      for (int i = 0; i < cell.nParameter_; ++i) {
         in >> cell.parameters_[i];
      }
      cell.setLattice();
      return in;
   }
 
   template <int D>
   std::ostream& operator << (std::ostream& out,
                              UnitCell<D> const & cell)
   {
      out << cell.lattice_;
      for (int i = 0; i < cell.nParameter_; ++i) {
         out << Dbl(cell.parameters_[i], 18, 10);
      }
      return out;
   }
 
   #ifndef PRDC_UNIT_CELL_TPP
   // Suppress implicit instantiation
 
   extern template class UnitCell<1>;
   extern template class UnitCell<2>;
   extern template class UnitCell<3>;
 
   extern std::ostream& operator << (std::ostream& out, 
                                     UnitCell<1>::LatticeSystem lattice);
   extern std::ostream& operator << (std::ostream& out, 
                                     UnitCell<2>::LatticeSystem lattice);
   extern std::ostream& operator << (std::ostream& out, 
                                     UnitCell<3>::LatticeSystem lattice);
 
   extern std::istream& operator >> (std::istream& in, 
                                UnitCell<1>::LatticeSystem const& lattice);
   extern std::istream& operator >> (std::istream& in, 
                                UnitCell<2>::LatticeSystem const& lattice);
   extern std::istream& operator >> (std::istream& in, 
                                UnitCell<3>::LatticeSystem const& lattice);
   #endif
 
}
}
#endif