Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #pragma once
      11             : 
      12             : #include "GeneralReporter.h"
      13             : 
      14             : class AccumulatedValueBase;
      15             : template <typename T>
      16             : class AccumulatedValue;
      17             : 
      18             : class AccumulateReporter : public GeneralReporter
      19             : {
      20             : public:
      21             :   static InputParameters validParams();
      22             :   AccumulateReporter(const InputParameters & parameters);
      23         254 :   virtual void initialize() override {}
      24             :   virtual void execute() override;
      25         254 :   virtual void finalize() override {}
      26             :   virtual void declareLateValues() override;
      27             : 
      28             : protected:
      29             :   /**
      30             :    * Helper for declaring an accumulative reporter value
      31             :    * This will fill in _accumulated_values if the reporter value is found
      32             :    */
      33             :   template <typename T>
      34             :   bool declareAccumulateHelper(const ReporterName & rname);
      35             : 
      36             :   /// Vector of accumulated value objects
      37             :   std::vector<std::unique_ptr<AccumulatedValueBase>> _accumulated_values;
      38             : };
      39             : 
      40             : template <typename T>
      41             : bool
      42         448 : AccumulateReporter::declareAccumulateHelper(const ReporterName & rname)
      43             : {
      44         448 :   const ReporterData & rdata = _fe_problem.getReporterData();
      45             : 
      46         448 :   if (!rdata.hasReporterValue<T>(rname))
      47         344 :     return false;
      48             : 
      49         104 :   const auto & pmode = rdata.getReporterMode(rname);
      50         104 :   ReporterMode rmode = REPORTER_MODE_UNSET;
      51         104 :   if (pmode == REPORTER_MODE_ROOT)
      52           0 :     rmode = REPORTER_MODE_ROOT;
      53         104 :   else if (pmode == REPORTER_MODE_REPLICATED)
      54          12 :     rmode = REPORTER_MODE_REPLICATED;
      55          92 :   else if (pmode == REPORTER_MODE_DISTRIBUTED)
      56           0 :     rmode = REPORTER_MODE_DISTRIBUTED;
      57         104 :   const T & val = getReporterValueByName<T>(rname);
      58             :   std::vector<T> & acc_val =
      59         104 :       declareValueByName<std::vector<T>>(rname.getObjectName() + ":" + rname.getValueName(), rmode);
      60             : 
      61         104 :   _accumulated_values.push_back(std::make_unique<AccumulatedValue<T>>(val, acc_val));
      62         104 :   return true;
      63         104 : }
      64             : 
      65             : class AccumulatedValueBase
      66             : {
      67             : public:
      68         102 :   virtual ~AccumulatedValueBase() = default;
      69             : 
      70             :   virtual void accumulate(unsigned int index) = 0;
      71             : };
      72             : 
      73             : template <typename T>
      74             : class AccumulatedValue : public AccumulatedValueBase
      75             : {
      76             : public:
      77         104 :   AccumulatedValue(const T & val, std::vector<T> & acc_val)
      78         104 :     : AccumulatedValueBase(), _val(val), _acc_val(acc_val)
      79             :   {
      80         104 :   }
      81             : 
      82        1564 :   virtual void accumulate(unsigned int index) override
      83             :   {
      84        1564 :     if (_acc_val.size() <= index)
      85         684 :       _acc_val.resize(index + 1, _val);
      86             :     else
      87         880 :       _acc_val[index] = _val;
      88        1564 :   }
      89             : 
      90             : private:
      91             :   const T & _val;
      92             :   std::vector<T> & _acc_val;
      93             : };