rpc/fts/analyzer/AverageListAnalyzer.h

#ifndef RPC_AVERAGE_LIST_ANALYZER_H
#define RPC_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 "Analyzer.h"
#include <util/accumulators/Average.h>           // member
 
namespace Pscf {
namespace Rpc
{
 
   template <int D> class System;
   template <int D> class Simulator;
 
   using namespace Util;

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

      AverageListAnalyzer(Simulator<D>& simulator, System<D>& system);

      virtual ~AverageListAnalyzer();

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

      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;
 
      using Analyzer<D>::interval;
      using Analyzer<D>::isAtInterval;
      using Analyzer<D>::outputFileName;
 
   protected:
 
      using ParamComposite::read;
      using ParamComposite::readOptional;
      using Analyzer<D>::setClassName;
      using Analyzer<D>::readInterval;

      void setName(int i, std::string name);

      void initializeAccumulators(int nValue);

      void clearAccumulators();

      virtual void compute() = 0;

      void setValue(int i, double value);

      double value(int i) const;

      void updateAccumulators(long iStep);

      void outputAccumulators();

      Simulator<D>& simulator();

      System<D>& system();

      std::ofstream outputFile_;
 
   private:

      DArray<Average> accumulators_;

      DArray<double> values_;

      DArray<std::string> names_;

      Simulator<D>* simulatorPtr_;     

      System<D>* systemPtr_;
 
      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_; }
   
   // Get parent Simulator object.
   template <int D>
   inline Simulator<D>& AverageListAnalyzer<D>::simulator()
   {  return *simulatorPtr_; }
 
   #ifndef RPC_AVERAGE_LIST_ANALYZER_TPP
   // Suppress implicit instantiation
   extern template class AverageListAnalyzer<1>;
   extern template class AverageListAnalyzer<2>;
   extern template class AverageListAnalyzer<3>;
   #endif
 
}
}
#endif