ThermocoupleSensorPostprocessor.C

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#include "ThermocoupleSensorPostprocessor.h"
#include "GeneralSensorPostprocessor.h"
#include "Function.h"
#include "MooseRandom.h"
#include "LinearInterpolation.h"
#include "SplineInterpolation.h"
 
registerMooseObject("MiscApp", ThermocoupleSensorPostprocessor);
 
InputParameters
ThermocoupleSensorPostprocessor::validParams()
{
  InputParameters params = GeneralSensorPostprocessor::validParams();
  params.addClassDescription("This is a ThermocoupleSensorPostprocessor for various classes of "
                             "thermocouples, described by the 'thermocouple_type' parameter");
  params.addParam<Real>("proportional_weight", 0, "The weight assigned to the proportional term");
  params.addParam<Real>("integral_weight", 1, "The weight assigned to the integral term");
  return params;
}
 
ThermocoupleSensorPostprocessor::ThermocoupleSensorPostprocessor(const InputParameters & parameters)
  : GeneralSensorPostprocessor(parameters)
{
  if (isParamSetByUser("R_function"))
    mooseError("In thermocouple postprocessor R function is fixed. If you want to change it, use "
               "GeneralSensorPostprocessor.");
}
 
void
ThermocoupleSensorPostprocessor::initialize()
{
  // setting seed for random number generator
  _rng.seed(_seed);
  Real drift_value = _drift_function.value(_t);
  Real efficiency_value = _efficiency_function.value(_t);
  Real signalToNoise_value = _signalToNoise_function.value(_t);
  Real noise_std_dev = _noise_std_dev_function.value(_t);
  Real noise_value = _rng.randNormal(0, noise_std_dev);
  Real uncertainty_std_dev = _uncertainty_std_dev_function.value(_t);
  Real uncertainty_value = _rng.randNormal(0, uncertainty_std_dev);
 
  // if the problem is steady-state
  if (!_fe_problem.isTransient())
    _sensor_value = drift_value +
                    efficiency_value * (_input_signal + signalToNoise_value * noise_value) +
                    uncertainty_value;
 
  // if the problem is transient
  else
  {
    // Remove last element if we are repeating the timestep
    mooseAssert(_t_step_old <= _t_step,
                "The old time step needs to be behind or the same as the current time step.");
    if (_t_step_old == _t_step)
    {
      _time_values.pop_back();
      _input_signal_values.pop_back();
      _integrand.pop_back();
    }
 
    _delay_value = _delay_function.value(_t);
    _time_values.push_back(_t);
    _input_signal_values.push_back(_input_signal);
 
    // Check if the size is greater than 500
    if (_time_values.size() > 500 && _input_signal_values.size() > _vector_size)
    {
      // Remove the first 10 elements
      _time_values.erase(_time_values.begin(), _time_values.begin() + 10);
      _input_signal_values.erase(_input_signal_values.begin(), _input_signal_values.begin() + 10);
    }
    Real _input_signal_delayed = getDelayedInputSignal();
 
    // computing integral term
    Real term_for_integration = _input_signal + signalToNoise_value * noise_value;
    _integrand.push_back(term_for_integration);
    _integration_value = getIntegral(_integrand);
 
    // output
    Real proportional_value = _input_signal_delayed + signalToNoise_value * noise_value;
    _sensor_value = drift_value +
                    efficiency_value * (_proportional_weight * proportional_value +
                                        _integral_weight * _integration_value) +
                    uncertainty_value;
 
    // Update old time step
    _t_step_old = _t_step;
  }
}
 
PostprocessorValue
ThermocoupleSensorPostprocessor::getValue() const
{
  return _sensor_value;
}
 
vector<Real>
ThermocoupleSensorPostprocessor::getRVector()
{
  _R_function_values.clear();
  // computing vector of exponential term
  for (const auto i : index_range(_time_values))
    _R_function_values.push_back(exp(-(_t - _time_values[i]) / _delay_value) / _delay_value);
  return _R_function_values;
}