rpg/fts/analyzer/Analyzer.h

#ifndef RPG_ANALYZER_H
#define RPG_ANALYZER_H
 
#include <util/param/ParamComposite.h>      // base class
#include <util/misc/FileMaster.h>           // member variable
 
#include <string>
#include <iostream>
#include <fstream>
 
namespace Pscf {
namespace Rpg {
 
   using namespace Util;
 
   template <int D>
   class Analyzer : public ParamComposite
   {
 
   public:
 
      Analyzer();
 
      virtual ~Analyzer();
 
      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:
 
      void setFileMaster(FileMaster& fileMaster);
 
      void readInterval(std::istream &in);
 
      void readOutputFileName(std::istream &in);
 
      FileMaster& fileMaster();
 
      const std::string& outputFileName() const;
 
      std::string outputFileName(const std::string& suffix) const;
 
   private:
 
      long interval_;
 
      std::string outputFileName_;
      
      FileMaster* fileMasterPtr_;
 
   };
 
   // Inline methods
 
   /*
   * Return interval value.
   */
   template <int D>
   inline int Analyzer<D>::interval() const
   {  return interval_; }
 
   /*
   * Return true iff the counter parameter is a multiple of the interval.
   */
   template <int D>
   inline bool Analyzer<D>::isAtInterval(long counter) const
   {  return (counter%interval_ == 0); }
 
   /*
   * Get the outputFileName string.
   */
   template <int D>
   inline const std::string& Analyzer<D>::outputFileName() const
   {  return outputFileName_; }
 
   // Method template
 
   #if 0
   /*
   * Serialize to/from an archive. 
   */
   template <class Archive>
   void Analyzer<D>::serialize(Archive& ar, const unsigned int version)
   {
      ar & interval_;
      ar & outputFileName_;
   }
   #endif
 
   #ifndef RPG_ANALYZER_TPP
   // Suppress implicit instantiation
   extern template class Analyzer<1>;
   extern template class Analyzer<2>;
   extern template class Analyzer<3>;
   #endif
 
}
}
#endif