Control.h

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
 
#pragma once
 
// MOOSE includes
#include "MooseObject.h"
#include "ControllableParameter.h"
#include "TransientInterface.h"
#include "SetupInterface.h"
#include "FunctionInterface.h"
#include "UserObjectInterface.h"
#include "PostprocessorInterface.h"
#include "VectorPostprocessorInterface.h"
#include "PerfGraphInterface.h"
#include "ReporterInterface.h"
 
class FEProblemBase;
class InputParameterWarehouse;
 
class Control : public MooseObject,
                protected PerfGraphInterface,
                public TransientInterface,
                public SetupInterface,
                public FunctionInterface,
                public UserObjectInterface,
                public Restartable,
                protected PostprocessorInterface,
                protected VectorPostprocessorInterface,
                protected ReporterInterface
{
public:
  static InputParameters validParams();
 
  Control(const InputParameters & parameters);
 
  virtual ~Control() {}
 
  virtual void execute() = 0;
 
  static MultiMooseEnum getExecuteOptions();
 
  std::vector<std::string> & getDependencies() { return _depends_on; }
 
protected:
  FEProblemBase & _fe_problem;
 
  std::vector<std::string> _depends_on;
 
  bool hasControllableParameterByName(const std::string & name) const;
 
 
  ControllableParameter getControllableParameter(const std::string & param_name);
  ControllableParameter getControllableParameterByName(const std::string & param_name);
  ControllableParameter getControllableParameterByName(const std::string & tag,
                                                       const std::string & object_name,
                                                       const std::string & param_name);
  ControllableParameter getControllableParameterByName(const MooseObjectName & object_name,
                                                       const std::string & param_name);
  ControllableParameter getControllableParameterByName(const MooseObjectParameterName & param_name);
 
 
  template <typename T>
  T getControllableValue(const std::string & name, bool warn_when_values_differ = true);
 
  template <typename T>
  T getControllableValueByName(const std::string & name, bool warn_when_values_differ = true);
 
  template <typename T>
  T getControllableValueByName(const std::string & object_name,
                               const std::string & param_name,
                               bool warn_when_values_differ = true);
 
  template <typename T>
  T getControllableValueByName(const MooseObjectName & object_name,
                               const std::string & param_name,
                               bool warn_when_values_differ = true);
 
  template <typename T>
  T getControllableValueByName(const std::string & tag,
                               const std::string & object_name,
                               const std::string & param_name,
                               bool warn_when_values_differ = true);
 
  template <typename T>
  T getControllableValueByName(const MooseObjectParameterName & desired,
                               bool warn_when_values_differ = true);
 
 
  template <typename T>
  void setControllableValue(const std::string & name, const T & value);
 
  template <typename T>
  void setControllableValueByName(const std::string & name, const T & value);
 
  template <typename T>
  void setControllableValueByName(const std::string & object_name,
                                  const std::string & param_name,
                                  const T & value);
 
  template <typename T>
  void setControllableValueByName(const MooseObjectName & object_name,
                                  const std::string & param_name,
                                  const T & value);
 
  template <typename T>
  void setControllableValueByName(const std::string & tag,
                                  const std::string & object_name,
                                  const std::string & param_name,
                                  const T & value);
 
  template <typename T>
  void setControllableValueByName(const MooseObjectParameterName & name, const T & value);
 
private:
  InputParameterWarehouse & _input_parameter_warehouse;
};
 
template <typename T>
T
Control::getControllableValue(const std::string & name, bool warn_when_values_differ)
{
  return getControllableValueByName<T>(getParam<std::string>(name), warn_when_values_differ);
}
 
template <typename T>
T
Control::getControllableValueByName(const std::string & name, bool warn_when_values_differ)
{
  MooseObjectParameterName desired(name);
  ControllableParameter helper = getControllableParameterByName(desired);
  return helper.get<T>(true, warn_when_values_differ)[0];
}
 
template <typename T>
T
Control::getControllableValueByName(const std::string & object_name,
                                    const std::string & param_name,
                                    bool warn_when_values_differ)
{
  MooseObjectParameterName desired(MooseObjectName(object_name), param_name);
  ControllableParameter helper = getControllableParameterByName(desired);
  return helper.get<T>(true, warn_when_values_differ)[0];
}
 
template <typename T>
T
Control::getControllableValueByName(const MooseObjectName & object_name,
                                    const std::string & param_name,
                                    bool warn_when_values_differ)
{
  MooseObjectParameterName desired(object_name, param_name);
  ControllableParameter helper = getControllableParameterByName(desired);
  return helper.get<T>(true, warn_when_values_differ)[0];
}
 
template <typename T>
T
Control::getControllableValueByName(const std::string & tag,
                                    const std::string & object_name,
                                    const std::string & param_name,
                                    bool warn_when_values_differ)
{
  MooseObjectParameterName desired(tag, object_name, param_name);
  ControllableParameter helper = getControllableParameterByName(desired);
  return helper.get<T>(true, warn_when_values_differ)[0];
}
 
template <typename T>
T
Control::getControllableValueByName(const MooseObjectParameterName & desired,
                                    bool warn_when_values_differ)
{
  ControllableParameter helper = getControllableParameterByName(desired);
  return helper.get<T>(true, warn_when_values_differ)[0];
}
 
template <typename T>
void
Control::setControllableValueByName(const MooseObjectParameterName & desired, const T & value)
{
  ControllableParameter helper = getControllableParameterByName(desired);
  helper.set<T>(value);
}
 
template <typename T>
void
Control::setControllableValue(const std::string & name, const T & value)
{
  setControllableValueByName<T>(getParam<std::string>(name), value);
}
 
template <typename T>
void
Control::setControllableValueByName(const std::string & name, const T & value)
{
  MooseObjectParameterName desired(name);
  ControllableParameter helper = getControllableParameterByName(desired);
  helper.set<T>(value);
}
 
template <typename T>
void
Control::setControllableValueByName(const std::string & object_name,
                                    const std::string & param_name,
                                    const T & value)
{
  MooseObjectParameterName desired(MooseObjectName(object_name), param_name);
  ControllableParameter helper = getControllableParameterByName(desired);
  helper.set<T>(value);
}
 
template <typename T>
void
Control::setControllableValueByName(const MooseObjectName & object_name,
                                    const std::string & param_name,
                                    const T & value)
{
  MooseObjectParameterName desired(object_name, param_name);
  ControllableParameter helper = getControllableParameterByName(desired);
  helper.set<T>(value);
}
 
template <typename T>
void
Control::setControllableValueByName(const std::string & tag,
                                    const std::string & object_name,
                                    const std::string & param_name,
                                    const T & value)
{
  MooseObjectParameterName desired(tag, object_name, param_name);
  ControllableParameter helper = getControllableParameterByName(desired);
  helper.set<T>(value);
}