fts/analyzer/AverageListAnalyzer.h

#ifndef RP_AVERAGE_LIST_ANALYZER_H
#define RP_AVERAGE_LIST_ANALYZER_H
 
/*
* PSCF - Polymer Self-Consistent Field
*
* Copyright 2015 - 2025, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include <util/accumulators/Average.h>   // member
#include <util/global.h>
 
namespace Pscf {
namespace Rp {
 
   using namespace Util;

   template <int D, class T>
   class AverageListAnalyzer : public T::Analyzer
   {
 
   public:

      AverageListAnalyzer(typename T::Simulator& simulator, 
                          typename T::System& system);

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

      void setup() override;

      void sample(long iStep) override;

      void output() override;

      int nSamplePerOutput() const;

      int nValue() const;

      const std::string& name(int i) const;

      const Average& accumulator(int i) const;
 
   protected:

      std::ofstream outputFile_;

      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();
 
      using AnalyzerT = typename T::Analyzer;
      using AnalyzerT::simulator;
      using AnalyzerT::system;
 
   private:

      DArray<Average> accumulators_;

      DArray<double> values_;

      DArray<std::string> names_;

      int nSamplePerOutput_;

      int nValue_;

      bool hasAccumulators_;
 
   };
 
   // Inline functions
 
   /*
   * Get nSamplePerOutput.
   */
   template <int D, class T> inline
   int AverageListAnalyzer<D,T>::nSamplePerOutput() const
   {  return nSamplePerOutput_; }
 
   /*
   * Get nValue (number of variables).
   */
   template <int D, class T> inline
   int AverageListAnalyzer<D,T>::nValue() const
   {
      UTIL_CHECK(hasAccumulators_);
      return nValue_;
   }
 
   /*
   * Get current value of a variable, set by compute function.
   */
   template <int D, class T> inline
   double AverageListAnalyzer<D,T>::value(int i) const
   {
      UTIL_CHECK(hasAccumulators_);
      UTIL_CHECK(i >= 0 && i < nValue_);
      return values_[i];
   }
 
   /*
   * Get name of specific variable.
   */
   template <int D, class T> inline
   const std::string& AverageListAnalyzer<D,T>::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, class T> inline
   const Average& AverageListAnalyzer<D,T>::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, class T> inline
   void AverageListAnalyzer<D,T>::setValue(int i, double value)
   {
      UTIL_CHECK(hasAccumulators_);
      UTIL_CHECK(i >= 0 && i < nValue_);
      values_[i] = value;
   }
 
}
}
#endif