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             : #include "TimeExtremeValue.h"
      11             : 
      12             : #include <algorithm>
      13             : #include <limits>
      14             : 
      15             : registerMooseObject("MooseApp", TimeExtremeValue);
      16             : 
      17             : InputParameters
      18       14457 : TimeExtremeValue::validParams()
      19             : {
      20             :   // Define the min/max enumeration
      21       14457 :   MooseEnum type_options("max=0 min=1 abs_max=2 abs_min=3", "max");
      22             : 
      23             :   // Define the extreme value/time enumeration
      24       14457 :   MooseEnum output_type_options("extreme_value=0 time=1", "extreme_value");
      25             : 
      26             :   // Define the parameters
      27       14457 :   InputParameters params = GeneralPostprocessor::validParams();
      28       14457 :   params.addParam<MooseEnum>("value_type",
      29             :                              type_options,
      30             :                              "Type of extreme value to return."
      31             :                              "'max' returns the maximum value."
      32             :                              "'min' returns the minimum value."
      33             :                              "'abs_max' returns the maximum absolute value."
      34             :                              "'abs_min' returns the minimum absolute value.");
      35       14457 :   params.addParam<MooseEnum>("output_type",
      36             :                              output_type_options,
      37             :                              "Output to return. 'extreme_value' returns the extreme_value. 'time' "
      38             :                              "returns the time at which the extreme_value occurred.");
      39       14457 :   params.addRequiredParam<PostprocessorName>(
      40             :       "postprocessor", "The name of the postprocessor used for reporting time extreme values");
      41       14457 :   params.addClassDescription(
      42             :       "A postprocessor for reporting the extreme value of another postprocessor over time.");
      43             : 
      44       28914 :   return params;
      45       14457 : }
      46             : 
      47          96 : TimeExtremeValue::TimeExtremeValue(const InputParameters & parameters)
      48             :   : GeneralPostprocessor(parameters),
      49          96 :     _postprocessor(getPostprocessorValue("postprocessor")),
      50          96 :     _type(getParam<MooseEnum>("value_type").getEnum<ExtremeType>()),
      51          96 :     _output_type(getParam<MooseEnum>("output_type").getEnum<OutputType>()),
      52          96 :     _value(declareRestartableData<Real>("value")),
      53         192 :     _time(declareRestartableData<Real>("time"))
      54             : {
      55          96 :   if (!_app.isRecovering())
      56             :   {
      57          86 :     switch (_type)
      58             :     {
      59          54 :       case ExtremeType::MAX:
      60          54 :         _value = -std::numeric_limits<Real>::max();
      61          54 :         break;
      62             : 
      63           0 :       case ExtremeType::MIN:
      64           0 :         _value = std::numeric_limits<Real>::max();
      65           0 :         break;
      66             : 
      67          32 :       case ExtremeType::ABS_MAX:
      68             :         // the max absolute value of anything is greater than or equal to 0
      69          32 :         _value = 0;
      70          32 :         break;
      71             : 
      72           0 :       case ExtremeType::ABS_MIN:
      73             :         // the min absolute value of anything is less than this
      74           0 :         _value = std::numeric_limits<Real>::max();
      75           0 :         break;
      76             : 
      77           0 :       default:
      78           0 :         mooseError("Unrecognzed ExtremeType");
      79             : 
      80             :         _time = 0; // Time has to be greater than or equal to zero.
      81             :     }
      82             :   }
      83          96 : }
      84             : 
      85             : void
      86         818 : TimeExtremeValue::execute()
      87             : {
      88         818 :   switch (_type)
      89             :   {
      90         530 :     case ExtremeType::MAX:
      91         530 :       _value = std::max(_value, _postprocessor);
      92         530 :       _time = (_value == _postprocessor) ? _t : _time;
      93         530 :       break;
      94             : 
      95           0 :     case ExtremeType::MIN:
      96           0 :       _value = std::min(_value, _postprocessor);
      97           0 :       _time = (_value == _postprocessor) ? _t : _time;
      98           0 :       break;
      99             : 
     100         288 :     case ExtremeType::ABS_MAX:
     101         288 :       _value = std::max(_value, std::abs(_postprocessor));
     102         288 :       _time = (_value == std::abs(_postprocessor)) ? _t : _time;
     103         288 :       break;
     104             : 
     105           0 :     case ExtremeType::ABS_MIN:
     106           0 :       _value = std::min(_value, std::abs(_postprocessor));
     107           0 :       _time = (_value == std::abs(_postprocessor)) ? _t : _time;
     108           0 :       break;
     109             : 
     110           0 :     default:
     111           0 :       mooseError("Unrecognized ExtremeType");
     112             :   }
     113         818 : }
     114             : 
     115             : Real
     116         818 : TimeExtremeValue::getValue() const
     117             : {
     118         818 :   if (_output_type == OutputType::EXTREME_VALUE)
     119         697 :     return _value;
     120             :   else
     121         121 :     return _time;
     122             : }