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 "ComparisonPostprocessor.h"
      11             : 
      12             : InputParameters
      13       28686 : ComparisonPostprocessor::validParams()
      14             : {
      15       28686 :   InputParameters params = GeneralPostprocessor::validParams();
      16             : 
      17       28686 :   MooseEnum comparison_type("equals greater_than_equals less_than_equals greater_than less_than");
      18       28686 :   params.addRequiredParam<MooseEnum>("comparison_type",
      19             :                                      comparison_type,
      20       57372 :                                      "The type of comparison to perform. Options are: " +
      21       57372 :                                          comparison_type.getRawNames());
      22             : 
      23       86058 :   params.addParam<Real>("absolute_tolerance",
      24       57372 :                         libMesh::TOLERANCE * libMesh::TOLERANCE,
      25             :                         "Absolute tolerance used in comparisons");
      26             : 
      27       57372 :   return params;
      28       28686 : }
      29             : 
      30          78 : ComparisonPostprocessor::ComparisonPostprocessor(const InputParameters & parameters)
      31             :   : GeneralPostprocessor(parameters),
      32             : 
      33          78 :     _comparison_type(getParam<MooseEnum>("comparison_type").getEnum<ComparisonType>()),
      34         156 :     _absolute_tolerance(getParam<Real>("absolute_tolerance"))
      35             : {
      36          78 : }
      37             : 
      38             : bool
      39         168 : ComparisonPostprocessor::comparisonIsTrue(const Real & a, const Real & b) const
      40             : {
      41         168 :   switch (_comparison_type)
      42             :   {
      43          36 :     case ComparisonType::EQUALS:
      44          36 :       return MooseUtils::absoluteFuzzyEqual(a, b, _absolute_tolerance);
      45             : 
      46          36 :     case ComparisonType::GREATER_THAN_EQUALS:
      47          36 :       return MooseUtils::absoluteFuzzyGreaterEqual(a, b, _absolute_tolerance);
      48             : 
      49          36 :     case ComparisonType::LESS_THAN_EQUALS:
      50          36 :       return MooseUtils::absoluteFuzzyLessEqual(a, b, _absolute_tolerance);
      51             : 
      52          48 :     case ComparisonType::GREATER_THAN:
      53          48 :       return MooseUtils::absoluteFuzzyGreaterThan(a, b, _absolute_tolerance);
      54             : 
      55          12 :     case ComparisonType::LESS_THAN:
      56          12 :       return MooseUtils::absoluteFuzzyLessThan(a, b, _absolute_tolerance);
      57             : 
      58           0 :     default:
      59           0 :       mooseError("Invalid comparison type.");
      60             :   }
      61             : }