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 "PIDChainControl.h"
      11             : #include "MooseUtils.h"
      12             : 
      13             : registerMooseObject("MooseApp", PIDChainControl);
      14             : 
      15             : InputParameters
      16       14289 : PIDChainControl::validParams()
      17             : {
      18       14289 :   InputParameters params = ChainControl::validParams();
      19             : 
      20       14289 :   params.addClassDescription("Implements a proportional-integral-derivative (PID) controller.");
      21             : 
      22       14289 :   params.addRequiredParam<std::string>("input", "Input control data");
      23       14289 :   params.addRequiredParam<std::string>("set_point", "Set point control data");
      24       14289 :   params.addParam<Real>("initial_integral", 0.0, "Initial value for the integral component");
      25       14289 :   params.addRequiredParam<Real>("K_p", "Coefficient for the proportional term");
      26       14289 :   params.addRequiredParam<Real>("K_i", "Coefficient for the integral term");
      27       14289 :   params.addRequiredParam<Real>("K_d", "Coefficient for the derivative term");
      28             : 
      29       14289 :   return params;
      30           0 : }
      31             : 
      32          12 : PIDChainControl::PIDChainControl(const InputParameters & parameters)
      33             :   : ChainControl(parameters),
      34          12 :     _input(getChainControlData<Real>("input")),
      35          12 :     _set_point(getChainControlData<Real>("set_point")),
      36          12 :     _K_p(getParam<Real>("K_p")),
      37          12 :     _K_i(getParam<Real>("K_i")),
      38          12 :     _K_d(getParam<Real>("K_d")),
      39          12 :     _error(declareChainControlData<Real>("error")),
      40          12 :     _error_old(getChainControlDataOldByName<Real>(fullControlDataName("error"))),
      41          12 :     _proportional(declareChainControlData<Real>("proportional")),
      42          12 :     _integral(declareChainControlData<Real>("integral")),
      43          12 :     _integral_old(getChainControlDataOldByName<Real>(fullControlDataName("integral"))),
      44          12 :     _derivative(declareChainControlData<Real>("derivative")),
      45          12 :     _output(declareChainControlData<Real>("value")),
      46          24 :     _previous_time(declareRestartableData<Real>("previous_time"))
      47             : {
      48          12 :   _integral = getParam<Real>("initial_integral");
      49          12 :   _previous_time = std::numeric_limits<Real>::max();
      50          12 : }
      51             : 
      52             : void
      53         562 : PIDChainControl::execute()
      54             : {
      55         562 :   if (!MooseUtils::absoluteFuzzyEqual(_t, _previous_time))
      56         561 :     updateValues();
      57             : 
      58         562 :   _previous_time = _t;
      59         562 : }
      60             : 
      61             : void
      62         561 : PIDChainControl::updateValues()
      63             : {
      64         561 :   _error = _set_point - _input;
      65             : 
      66         561 :   _proportional = _K_p * _error;
      67         561 :   _integral = _integral_old + _K_i * (_error * _dt);
      68         561 :   if (MooseUtils::absoluteFuzzyEqual(_dt, 0.0))
      69          11 :     _derivative = 0.0;
      70             :   else
      71         550 :     _derivative = _K_d * (_error - _error_old) / _dt;
      72             : 
      73         561 :   _output = _proportional + _integral + _derivative;
      74         561 : }