ddMd/analyzers/trajectory/TrajectoryWriter.h

#ifndef DDMD_TRAJECTORY_WRITER_H
#define DDMD_TRAJECTORY_WRITER_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 <ddMd/analyzers/Analyzer.h>         // base class
#include <ddMd/storage/AtomStorage.h>       
#ifdef SIMP_BOND
#include <ddMd/storage/BondStorage.h>               
#endif
#ifdef SIMP_ANGLE
#include <ddMd/storage/AngleStorage.h>               
#endif
#ifdef SIMP_DIHEDRAL
#include <ddMd/storage/DihedralStorage.h>               
#endif
#include <simp/boundary/Boundary.h>         // typedef

namespace DdMd
{

   class Simulation;
   class Domain;
   class AtomCollector;
   template <int N> class GroupCollector;

   using namespace Util;
   using namespace Simp;

   class TrajectoryWriter : public Analyzer
   {
   
   public:
   
      TrajectoryWriter(Simulation& simulation, bool isBinary = false);
   
      virtual ~TrajectoryWriter()
      {} 
   
      virtual void readParameters(std::istream& in);
   
      virtual void loadParameters(Serializable::IArchive &ar);

      virtual void save(Serializable::OArchive &ar);

      virtual void setup();

      virtual void sample(long iStep);

      virtual void clear();
  
      virtual void output();

   protected:

      bool isBinary() const;

      virtual void writeHeader(std::ofstream& out)
      {};

      virtual void writeFrame(std::ofstream& out, long iStep) = 0;

      Domain& domain();

      Boundary& boundary();
   
      AtomStorage& atomStorage();
   
      AtomCollector& atomCollector();

      #ifdef SIMP_BOND

      BondStorage& bondStorage();
  
      GroupCollector<2>& bondCollector();
      #endif

      #ifdef SIMP_ANGLE

      AngleStorage& angleStorage();

      GroupCollector<3>& angleCollector();
      #endif

      #ifdef SIMP_DIHEDRAL

      DihedralStorage& dihedralStorage();

      GroupCollector<4>& dihedralCollector();
      #endif

   private:
 
      // Output file stream
      std::ofstream outputFile_;

      long isInitialized_;
  
      bool isBinary_;

      // Pointers to associated Domain.
      Domain* domainPtr_;

      // Pointers to associated Boundary.
      Boundary* boundaryPtr_;

      // Pointers to storage objects.
      AtomStorage* atomStoragePtr_;
      #ifdef SIMP_BOND
      BondStorage* bondStoragePtr_;
      #endif
      #ifdef SIMP_ANGLE
      AngleStorage* angleStoragePtr_;
      #endif
      #ifdef SIMP_DIHEDRAL
      DihedralStorage* dihedralStoragePtr_;
      #endif

   };

   // Inline method definitions

   inline bool TrajectoryWriter::isBinary() const
   {  return isBinary_; }

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

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

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

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

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

   inline GroupCollector<2>& TrajectoryWriter::bondCollector()
   {  return bondStoragePtr_->collector(); }
   #endif

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

   inline GroupCollector<3>& TrajectoryWriter::angleCollector()
   {  return angleStoragePtr_->collector(); }
   #endif

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

   inline GroupCollector<4>& TrajectoryWriter::dihedralCollector()
   {  return dihedralStoragePtr_->collector(); }
   #endif

}
#endif