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         270 :   virtual void initialize() override {}
      24             :   virtual void execute() override;
      25         270 :   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         484 : AccumulateReporter::declareAccumulateHelper(const ReporterName & rname)
      43             : {
      44         484 :   const ReporterData & rdata = _fe_problem.getReporterData();
      45             : 
      46         484 :   if (!rdata.hasReporterValue<T>(rname))
      47         372 :     return false;
      48             : 
      49         112 :   const auto & pmode = rdata.getReporterMode(rname);
      50         112 :   ReporterMode rmode = REPORTER_MODE_UNSET;
      51         112 :   if (pmode == REPORTER_MODE_ROOT)
      52           0 :     rmode = REPORTER_MODE_ROOT;
      53         112 :   else if (pmode == REPORTER_MODE_REPLICATED)
      54          13 :     rmode = REPORTER_MODE_REPLICATED;
      55          99 :   else if (pmode == REPORTER_MODE_DISTRIBUTED)
      56           0 :     rmode = REPORTER_MODE_DISTRIBUTED;
      57         112 :   const T & val = getReporterValueByName<T>(rname);
      58             :   std::vector<T> & acc_val =
      59         112 :       declareValueByName<std::vector<T>>(rname.getObjectName() + ":" + rname.getValueName(), rmode);
      60             : 
      61         112 :   _accumulated_values.push_back(std::make_unique<AccumulatedValue<T>>(val, acc_val));
      62         112 :   return true;
      63         112 : }
      64             : 
      65             : class AccumulatedValueBase
      66             : {
      67             : public:
      68         110 :   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         112 :   AccumulatedValue(const T & val, std::vector<T> & acc_val)
      78         112 :     : AccumulatedValueBase(), _val(val), _acc_val(acc_val)
      79             :   {
      80         112 :   }
      81             : 
      82        1692 :   virtual void accumulate(unsigned int index) override
      83             :   {
      84        1692 :     if (_acc_val.size() <= index)
      85         732 :       _acc_val.resize(index + 1, _val);
      86             :     else
      87         960 :       _acc_val[index] = _val;
      88        1692 :   }
      89             : 
      90             : private:
      91             :   const T & _val;
      92             :   std::vector<T> & _acc_val;
      93             : };