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"

class FEProblemBase;
class InputParameterWarehouse;

class Control : public MooseObject,
                protected PerfGraphInterface,
                public TransientInterface,
                public SetupInterface,
                public FunctionInterface,
                public UserObjectInterface,
                public Restartable,
                protected PostprocessorInterface,
                protected VectorPostprocessorInterface
{
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);
}