ddMd/analyzers/Analyzer.h

#ifndef DDMD_ANALYZER_H
#define DDMD_ANALYZER_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 <util/misc/FileMaster.h>           // member variable

#include <string>
#include <iostream>
#include <fstream>

namespace DdMd
{

   using namespace Util;
   class Simulation;

   class Analyzer : public ParamComposite
   {

   public:

      // Non-static Methods

      Analyzer(Simulation& simulation);

      virtual ~Analyzer();

      virtual void setup()
      {}

      virtual void clear()
      {}

      virtual void sample(long iStep) = 0;

      virtual void output()
      {}

      virtual void loadParameters(Serializable::IArchive &ar)
      {}

      virtual void save(Serializable::OArchive &ar)
      {}
  
      int interval() const;

      bool isAtInterval(long counter) const;

      // Static members

      static long baseInterval;

      static void initStatic();

   protected:

      void readInterval(std::istream &in);

      void loadInterval(Serializable::IArchive &ar);

      void saveInterval(Serializable::OArchive &ar);

      void readOutputFileName(std::istream &in);

      void loadOutputFileName(Serializable::IArchive &ar);

      void saveOutputFileName(Serializable::OArchive &ar);

      Simulation& simulation();

      const std::string& outputFileName() const;

      std::string outputFileName(const std::string& suffix) const;

   private:

      std::string outputFileName_;

      Simulation* simulationPtr_;

      long   interval_;

   };

   // Inline methods

   /*
   * Return interval value.
   */
   inline int Analyzer::interval() const
   {  return interval_; }

   /*
   * Return true iff the counter parameter is a multiple of the interval.
   */
   inline bool Analyzer::isAtInterval(long counter) const
   {  return (counter%interval_ == 0); }

   /*
   * Get the outputFileName string.
   */
   inline const std::string& Analyzer::outputFileName() const
   {  return outputFileName_; }

   /*
   * Get the parent Simulation by reference.
   */
   inline Simulation& Analyzer::simulation()
   {  return *simulationPtr_; }


}
#endif