ChainControl.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
 
#include "Control.h"
#include "ChainControlData.h"
#include "ChainControlDataSystem.h"
#include "MooseUtils.h"
 
class ChainControl : public Control
{
public:
  static InputParameters validParams();
 
  ChainControl(const InputParameters & parameters);
 
  virtual void init() {}
 
  const std::vector<std::string> & getChainControlDataDependencies() const
  {
    return _control_data_depends_on;
  }
 
protected:
  template <typename T>
  T & declareChainControlData(const std::string & data_name, bool apply_object_prefix = true);
 
  template <typename T>
  const T & getChainControlData(const std::string & param);
 
  template <typename T>
  const T & getChainControlDataOld(const std::string & param);
 
  template <typename T>
  const T & getChainControlDataByName(const std::string & data_name);
 
  template <typename T>
  const T & getChainControlDataOldByName(const std::string & data_name);
 
  void addChainControlDataDependency(const std::string & data_name);
 
  std::string fullControlDataName(const std::string & data_name,
                                  bool apply_object_prefix = true) const;
 
  std::vector<std::string> _control_data_depends_on;
 
private:
  ChainControlDataSystem & getChainControlDataSystem();
};
 
template <typename T>
T &
ChainControl::declareChainControlData(const std::string & data_name, bool apply_object_prefix)
{
  const std::string full_data_name = fullControlDataName(data_name, apply_object_prefix);
  auto & data = getChainControlDataSystem().declareChainControlData<T>(full_data_name, *this);
  return data.set();
}
 
template <typename T>
const T &
ChainControl::getChainControlData(const std::string & param)
{
  return getChainControlDataByName<T>(getParam<std::string>(param));
}
 
template <typename T>
const T &
ChainControl::getChainControlDataOld(const std::string & param)
{
  return getChainControlDataOldByName<T>(getParam<std::string>(param));
}
 
template <typename T>
const T &
ChainControl::getChainControlDataByName(const std::string & data_name)
{
  auto & system = getChainControlDataSystem();
 
  if (system.hasChainControlData(data_name) && !system.hasChainControlDataOfType<T>(data_name))
    mooseError("The chain control data '",
               data_name,
               "' has the type '",
               system.getChainControlDataMap().at(data_name)->type(),
               "', but this chain control requires its type to be '",
               MooseUtils::prettyCppType<T>(),
               "'.");
 
  auto & data = system.getChainControlData<T>(data_name);
 
  addChainControlDataDependency(data_name);
 
  return data.get();
}
 
template <typename T>
const T &
ChainControl::getChainControlDataOldByName(const std::string & data_name)
{
  auto & data = getChainControlDataSystem().getChainControlData<T>(data_name);
 
  return data.getOld();
}