fts/analyzer/Analyzer.h

#ifndef RP_ANALYZER_H
#define RP_ANALYZER_H
 
#include <util/param/ParamComposite.h>      // base class
#include <string>
#include <iostream>
 
// Forward declaration
namespace Util {
   class FileMaster;
}
 
namespace Pscf {
namespace Rp {
 
   using namespace Util;

   template <int D, class SimT, class SysT>
   class Analyzer : public ParamComposite
   {
 
   public:
 
      // Protected constructor and destructor (see below).

      virtual void readParameters(std::istream& in);

      virtual void setup()
      {}

      virtual void sample(long iStep) = 0;

      virtual void output()
      {}

      int interval() const;

      bool isAtInterval(long counter) const;
 
      // Static members

      static long baseInterval;

      static void initStatic();
 
   protected:

      Analyzer(SimT& simulator, SysT& system);

      ~Analyzer() = default;

      void setFileMaster(FileMaster& fileMaster);

      void readInterval(std::istream& in);

      void readOutputFileName(std::istream& in);

      SimT& simulator();

      SysT& system();

      FileMaster& fileMaster();

      std::string const & outputFileName() const;

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

      long interval_;

      std::string outputFileName_;

      SimT* simulatorPtr_;

      SysT* systemPtr_;

      FileMaster* fileMasterPtr_;
 
   };
 
   // Inline member functions
 
   /*
   * Get the interval value.
   */
   template <int D, class SimT, class SysT> inline
   int Analyzer<D,SimT,SysT>::interval() const
   {  return interval_; }
 
   /*
   * Return true iff counter is a multiple of the interval.
   */
   template <int D, class SimT, class SysT> inline
   bool Analyzer<D,SimT,SysT>::isAtInterval(long counter) const
   {  return (counter%interval_ == 0); }
 
   /*
   * Get the outputFileName string.
   */
   template <int D, class SimT, class SysT> inline
   std::string const & Analyzer<D,SimT,SysT>::outputFileName() const
   {  return outputFileName_; }
 
   /*
   * Get the parent Simulator by reference.
   */
   template <int D, class SimT, class SysT> inline
   SimT& Analyzer<D,SimT,SysT>::simulator()
   {
      UTIL_ASSERT(simulatorPtr_);
      return *simulatorPtr_;
   }
 
   /*
   * Get the parent System by reference.
   */
   template <int D, class SimT, class SysT> inline
   SysT& Analyzer<D,SimT,SysT>::system()
   {
      UTIL_ASSERT(systemPtr_);
      return *systemPtr_;
   }
 
} // namespace Rp
} // namespace Pscf
#endif