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 "LayeredExtremumMaterialProperty.h"
      11             : 
      12             : #include "libmesh/mesh_tools.h"
      13             : 
      14             : registerMooseObject("MooseApp", LayeredExtremumMaterialProperty);
      15             : 
      16             : InputParameters
      17       14315 : LayeredExtremumMaterialProperty::validParams()
      18             : {
      19       14315 :   InputParameters params = ElementExtremeMaterialProperty::validParams();
      20       14315 :   params += LayeredBase::validParams();
      21       14315 :   params.addClassDescription("Compute material property extrema over layers.");
      22       14315 :   params.registerBase("UserObject");
      23             : 
      24       14315 :   return params;
      25           0 : }
      26             : 
      27          26 : LayeredExtremumMaterialProperty::LayeredExtremumMaterialProperty(const InputParameters & parameters)
      28          26 :   : ElementExtremeMaterialProperty(parameters), LayeredBase(parameters)
      29             : {
      30          26 : }
      31             : 
      32             : void
      33          24 : LayeredExtremumMaterialProperty::initialize()
      34             : {
      35          24 :   ElementExtremeMaterialProperty::initialize();
      36          24 :   LayeredBase::initialize();
      37             : 
      38             :   // Initialize layer values
      39         264 :   for (const auto layer : make_range(_num_layers))
      40         240 :     setLayerValue(
      41         240 :         layer, _type == MIN ? std::numeric_limits<Real>::max() : -std::numeric_limits<Real>::max());
      42          24 : }
      43             : 
      44             : void
      45        1248 : LayeredExtremumMaterialProperty::execute()
      46             : {
      47             :   // Do not keep track of the layer extremum with _value
      48        1248 :   ElementExtremeMaterialProperty::initialize();
      49        1248 :   ElementExtremeMaterialProperty::execute();
      50        1248 :   const auto layer = getLayer(_current_elem->vertex_average());
      51             : 
      52        1248 :   setLayerValue(layer, extreme_value(getLayerValue(layer), _value));
      53        1248 : }
      54             : 
      55             : Real
      56        1268 : LayeredExtremumMaterialProperty::extreme_value(const Real a, const Real b) const
      57             : {
      58        1268 :   if (_type == MIN)
      59         634 :     return std::min(a, b);
      60             :   else
      61         634 :     return std::max(a, b);
      62             : }
      63             : 
      64             : void
      65          22 : LayeredExtremumMaterialProperty::finalize()
      66             : {
      67          22 :   if (_type == MIN)
      68          11 :     comm().min(_layer_values);
      69             :   else
      70          11 :     comm().max(_layer_values);
      71          22 :   comm().max(_layer_has_value);
      72             : 
      73          22 :   if (_cumulative)
      74             :   {
      75             :     Real value =
      76           0 :         _type == MIN ? std::numeric_limits<Real>::max() : -std::numeric_limits<Real>::max();
      77             : 
      78           0 :     if (_positive_cumulative_direction)
      79           0 :       for (unsigned i = 0; i < _num_layers; i++)
      80             :       {
      81           0 :         value = extreme_value(value, getLayerValue(i));
      82           0 :         setLayerValue(i, value);
      83             :       }
      84             :     else
      85           0 :       for (int i = _num_layers - 1; i >= 0; i--)
      86             :       {
      87           0 :         value = extreme_value(value, getLayerValue(i));
      88           0 :         setLayerValue(i, value);
      89             :       }
      90             :   }
      91          22 : }
      92             : 
      93             : void
      94           2 : LayeredExtremumMaterialProperty::threadJoin(const UserObject & y)
      95             : {
      96           2 :   const auto & lb = static_cast<const LayeredExtremumMaterialProperty &>(y);
      97          22 :   for (const auto i : make_range(_num_layers))
      98          20 :     if (lb.layerHasValue(i))
      99          20 :       setLayerValue(i, extreme_value(getLayerValue(i), lb.getLayerValue(i)));
     100           2 : }
     101             : 
     102             : const std::vector<Point>
     103          24 : LayeredExtremumMaterialProperty::spatialPoints() const
     104             : {
     105          24 :   std::vector<Point> points;
     106             : 
     107         264 :   for (const auto & l : _layer_centers)
     108             :   {
     109         240 :     Point pt(0.0, 0.0, 0.0);
     110         240 :     pt(_direction) = l;
     111         240 :     points.push_back(pt);
     112             :   }
     113             : 
     114          24 :   return points;
     115           0 : }