rpg/fts/analyzer/AverageListAnalyzer.h

#ifndef RPG_AVERAGE_LIST_ANALYZER_H
#define RPG_AVERAGE_LIST_ANALYZER_H
 
/*
* PSCF - Polymer Self-Consistent Field Theory
*
* Copyright 2016 - 2022, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include "Analyzer.h"
#include <util/accumulators/Average.h>           // member
 
namespace Pscf {
namespace Rpg
{
 
   template <int D> class System;
 
   using namespace Util;
 
   template <int D>
   class AverageListAnalyzer : public Analyzer<D>
   {
 
   public:
 
      AverageListAnalyzer(System<D>& system);
 
      virtual ~AverageListAnalyzer();
 
      virtual void readParameters(std::istream& in);
 
      #if 0
      virtual void loadParameters(Serializable::IArchive &ar);
 
      virtual void save(Serializable::OArchive &ar);
      #endif
 
      virtual void clear();
 
      virtual void setup();
 
      virtual void sample(long iStep);
 
      virtual void output();
 
      int nSamplePerOutput() const;
 
      int nValue() const;
 
      const std::string& name(int i) const;
 
      const Average& accumulator(int i) const;
 
      System<D>* systemPtr_;
 
      using Analyzer<D>::interval;
      using Analyzer<D>::isAtInterval;
      using Analyzer<D>::outputFileName;
      using ParamComposite::read;
      using ParamComposite::readOptional;
 
   protected:
 
      using Analyzer<D>::setClassName;
      using Analyzer<D>::readInterval;
 
      void initializeAccumulators(int nValue);
 
      void clearAccumulators();
 
      void setName(int i, std::string name);
 
      void setValue(int i, double value);
 
      virtual void compute() = 0;
 
      double value(int i) const;
 
      void updateAccumulators(long iStep);
 
      void outputAccumulators();
 
      System<D>& system();
 
      // Output file stream
      std::ofstream outputFile_;
 
   private:
 
      DArray<Average> accumulators_;
 
      DArray<double> values_;
 
      DArray<std::string> names_;
 
      int nSamplePerOutput_;
 
      int nValue_;
 
      bool hasAccumulators_;
 
   };
 
   // Inline functions
 
   /*
   * Get nSamplePerOutput.
   */
   template <int D>
   inline int AverageListAnalyzer<D>::nSamplePerOutput() const
   {  return nSamplePerOutput_; }
 
   /*
   * Get nValue (number of variables).
   */
   template <int D>
   inline int AverageListAnalyzer<D>::nValue() const
   {
      UTIL_CHECK(hasAccumulators_);
      return nValue_;
   }
 
   /*
   * Get current value of a variable, set by compute function.
   */
   template <int D>
   inline double AverageListAnalyzer<D>::value(int i) const
   {
      UTIL_CHECK(hasAccumulators_);
      UTIL_CHECK(i >= 0 && i < nValue_);
      return values_[i];
   }
 
   /*
   * Get name of specific variable.
   */
   template <int D>
   inline const std::string& AverageListAnalyzer<D>::name(int i) const
   {
      UTIL_CHECK(hasAccumulators_);
      UTIL_CHECK(i >= 0 && i < nValue_);
      return names_[i];
   }
 
   /*
   * Get accumulator associated with a variable.
   */
   template <int D>
   inline const Average& AverageListAnalyzer<D>::accumulator(int i) const
   {
      UTIL_CHECK(hasAccumulators_);
      UTIL_CHECK(i >= 0 && i < nValue_);
      return accumulators_[i];
   }
 
   /*
   * Set current value of a variable.
   */
   template <int D>
   inline void AverageListAnalyzer<D>::setValue(int i, double value)
   {
      UTIL_CHECK(hasAccumulators_);
      UTIL_CHECK(i >= 0 && i < nValue_);
      values_[i] = value;
   }
 
   // Get the parent system.
   template <int D>
   inline System<D>& AverageListAnalyzer<D>::system()
   {  return *systemPtr_; }
 
   #ifndef RPG_AVERAGE_LIST_ANALYZER_TPP
   // Suppress implicit instantiation
   extern template class AverageListAnalyzer<1>;
   extern template class AverageListAnalyzer<2>;
   extern template class AverageListAnalyzer<3>;
   #endif
 
}
}
#endif