Component.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 "THMObject.h"
#include "FlowModel.h"
#include "THMProblem.h"
#include "InputParameterWarehouse.h"
#include "LoggingInterface.h"
#include "NamingInterface.h"
#include "ADFunctorInterface.h"

class THMProblem;
class THMMesh;
class ThermalHydraulicsApp;
class Convergence;

class Component : public THMObject,
                  public LoggingInterface,
                  public NamingInterface,
                  public ADFunctorInterface
{
public:
  Component(const InputParameters & parameters);

  enum EComponentSetupStatus
  {
    CREATED,               
    MESH_PREPARED,         
    INITIALIZED_PRIMARY,   
    INITIALIZED_SECONDARY, 
    CHECKED                
  };

  std::string stringify(EComponentSetupStatus status) const;

  const std::string & cname() const;

  Component * parent() { return _parent; }

  const THMMesh & constMesh() const { return _mesh; }

  THMMesh & mesh();

  THMProblem & getTHMProblem() const;

  template <typename T>
  bool hasParam(const std::string & name) const;

  const std::vector<std::string> & getDependencies() const { return _dependencies; }

  void executeInit();

  void executeInitSecondary();

  void executeCheck() const;

  void executeSetupMesh();

  virtual void addRelationshipManagers(Moose::RelationshipManagerType /*input_rm_type*/) {}

  virtual void addVariables() {}

  virtual void addMooseObjects() {}

  virtual Convergence * getNonlinearConvergence() const;

  template <typename T>
  const T & getComponent(const std::string & name) const;

  template <typename T>
  const T & getComponentByName(const std::string & cname) const;

  template <typename T>
  bool hasComponent(const std::string & name) const;

  template <typename T>
  bool hasComponentByName(const std::string & cname) const;

  void connectObject(const InputParameters & obj_params,
                     const std::string & obj_name,
                     const std::string & param) const;
  void connectObject(const InputParameters & obj_params,
                     const std::string & obj_name,
                     const std::string & comp_param,
                     const std::string & obj_param) const;

  void checkSetupStatus(const EComponentSetupStatus & status) const;

  void checkComponentExistsByName(const std::string & comp_name) const;

  template <typename T>
  void checkComponentOfTypeExists(const std::string & param) const;

  template <typename T>
  void checkComponentOfTypeExistsByName(const std::string & comp_name) const;

  template <typename... Args>
  void logError(Args &&... args) const
  {
    logComponentError(cname(), std::forward<Args>(args)...);
  }

  template <typename... Args>
  void logWarning(Args &&... args) const
  {
    logComponentWarning(cname(), std::forward<Args>(args)...);
  }

  void addDependency(const std::string & dependency);

  template <typename T>
  T getEnumParam(const std::string & param, bool log_error = true) const;

  bool problemIsTransient() const { return getTHMProblem().isTransient(); }

  const std::vector<dof_id_type> & getNodeIDs() const;

  const std::vector<dof_id_type> & getElementIDs() const;

  virtual const std::vector<SubdomainName> & getSubdomainNames() const;

  virtual const std::vector<Moose::CoordinateSystemType> & getCoordSysTypes() const;

  template <typename T>
  void insistParameterExists(const std::string & function_name,
                             const std::string & param_name) const;

  template <typename T>
  void checkParameterValueLessThan(const std::string & param, const T & value_max) const;

  template <typename T>
  void checkSizeLessThan(const std::string & param, const unsigned int & n_entries) const;

  template <typename T>
  void checkSizeGreaterThan(const std::string & param, const unsigned int & n_entries) const;

  template <typename T1, typename T2>
  void checkEqualSize(const std::string & param1, const std::string & param2) const;

  template <typename T>
  void checkSizeEqualsValue(const std::string & param, const unsigned int & n_entries) const;

  template <typename T>
  void checkSizeEqualsValue(const std::string & param,
                            const unsigned int & n_entries,
                            const std::string & description) const;

  template <typename T1, typename T2>
  void checkSizeEqualsParameterValue(const std::string & param1, const std::string & param2) const;

  void checkMutuallyExclusiveParameters(const std::vector<std::string> & params,
                                        bool need_one_specified = true) const;

protected:
  virtual void init() {}

  virtual void initSecondary() {}

  virtual void check() const {}

  virtual void setupMesh() {}

  void addRelationshipManagersFromParameters(const InputParameters & moose_object_pars);

  Node * addNode(const Point & pt);
  Elem * addNodeElement(dof_id_type node);

  virtual void
  setSubdomainInfo(SubdomainID subdomain_id,
                   const std::string & subdomain_name,
                   const Moose::CoordinateSystemType & coord_system = Moose::COORD_XYZ);

  void addNonlinearStepFunctorMaterial(const std::string & functor_name,
                                       const std::string & property,
                                       bool functor_is_ad);

  void addMaximumFunctorPostprocessor(const std::string & functor_name,
                                      const std::string & pp_name,
                                      const Real normalization,
                                      const std::vector<SubdomainName> & subdomains);

  void addMultiPostprocessorConvergence(const std::vector<PostprocessorName> & postprocessors,
                                        const std::vector<std::string> & descriptions,
                                        const std::vector<Real> & tolerances);

  std::string nonlinearConvergenceName() const { return genName(name(), "nlconv"); }

  Component * _parent;

  THMProblem & _sim;

  Factory & _factory;

  const Real & _zero;

  THMMesh & _mesh;

  std::vector<dof_id_type> _node_ids;
  std::vector<dof_id_type> _elem_ids;

  std::vector<SubdomainID> _subdomain_ids;
  std::vector<SubdomainName> _subdomain_names;
  std::vector<Moose::CoordinateSystemType> _coord_sys;

private:
  void
  addRelationshipManager(const InputParameters & moose_object_pars,
                         std::string rm_name,
                         Moose::RelationshipManagerType rm_type,
                         Moose::RelationshipManagerInputParameterCallback rm_input_parameter_func,
                         Moose::RMSystemType sys_type = Moose::RMSystemType::NONE);

  mutable EComponentSetupStatus _component_setup_status;

  std::vector<std::string> _dependencies;

public:
  static InputParameters validParams();
};

template <typename T>
bool
Component::hasParam(const std::string & name) const
{
  return parameters().have_parameter<T>(name);
}

template <typename T>
const T &
Component::getComponent(const std::string & pname) const
{
  const std::string & comp_name = getParam<std::string>(pname);
  return getComponentByName<T>(comp_name);
}

template <typename T>
const T &
Component::getComponentByName(const std::string & comp_name) const
{
  return _sim.getComponentByName<T>(comp_name);
}

template <typename T>
bool
Component::hasComponent(const std::string & pname) const
{
  const std::string & comp_name = getParam<std::string>(pname);
  return hasComponentByName<T>(comp_name);
}

template <typename T>
bool
Component::hasComponentByName(const std::string & comp_name) const
{
  if (_sim.hasComponentOfType<T>(comp_name))
    return true;
  else
    return false;
}

template <typename T>
T
Component::getEnumParam(const std::string & param, bool log_error) const
{
  const MooseEnum & moose_enum = getParam<MooseEnum>(param);
  const T value = THM::stringToEnum<T>(moose_enum);
  if (log_error && static_cast<int>(value) < 0) // cast necessary for scoped enums
  {
    // Get the keys from the MooseEnum. Unfortunately, this returns a list of
    // *all* keys, including the invalid key that was supplied. Thus, that key
    // needs to be manually excluded below.
    const std::vector<std::string> & keys = moose_enum.getNames();

    // Create the string of keys to go in the error message. The last element of
    // keys is skipped because the invalid key should always be last.
    std::string keys_string = "{";
    for (unsigned int i = 0; i < keys.size() - 1; ++i)
    {
      if (i != 0)
        keys_string += ",";
      keys_string += "'" + keys[i] + "'";
    }
    keys_string += "}";

    logError("The parameter '" + param + "' was given an invalid value ('" +
             std::string(moose_enum) + "'). Valid values (case-insensitive) are " + keys_string);
  }

  return value;
}

template <typename T>
void
Component::insistParameterExists(const std::string & function_name,
                                 const std::string & param_name) const
{
  if (!hasParam<T>(param_name))
    mooseError(name(),
               ": Calling ",
               function_name,
               " failed, parameter '",
               param_name,
               "' does not exist or does not have the type you requested. Double check your "
               "spelling and/or type of the parameter.");
}

template <typename T>
void
Component::checkComponentOfTypeExists(const std::string & param) const
{
  insistParameterExists<std::string>(__FUNCTION__, param);

  const std::string & comp_name = getParam<std::string>(param);
  checkComponentOfTypeExistsByName<T>(comp_name);
}

template <typename T>
void
Component::checkComponentOfTypeExistsByName(const std::string & comp_name) const
{
  if (!_sim.hasComponentOfType<T>(comp_name))
  {
    if (_sim.hasComponent(comp_name))
      logError("The component '", comp_name, "' is not of type '", demangle(typeid(T).name()), "'");
    else
      logError("The component '", comp_name, "' does not exist");
  }
}

template <typename T>
void
Component::checkParameterValueLessThan(const std::string & param, const T & value_max) const
{
  insistParameterExists<T>(__FUNCTION__, param);

  const auto & value = getParam<T>(param);
  if (value >= value_max)
    logError("The value of parameter '", param, "' (", value, ") must be less than ", value_max);
}

template <typename T>
void
Component::checkSizeLessThan(const std::string & param, const unsigned int & n_entries) const
{
  insistParameterExists<std::vector<T>>(__FUNCTION__, param);

  const auto & value = getParam<std::vector<T>>(param);
  if (value.size() >= n_entries)
    logError("The number of entries in the parameter '",
             param,
             "' (",
             value.size(),
             ") must be less than ",
             n_entries);
}

template <typename T>
void
Component::checkSizeGreaterThan(const std::string & param, const unsigned int & n_entries) const
{
  insistParameterExists<std::vector<T>>(__FUNCTION__, param);

  const auto & value = getParam<std::vector<T>>(param);
  if (value.size() <= n_entries)
    logError("The number of entries in the parameter '",
             param,
             "' (",
             value.size(),
             ") must be greater than ",
             n_entries);
}

template <typename T1, typename T2>
void
Component::checkEqualSize(const std::string & param1, const std::string & param2) const
{
  insistParameterExists<std::vector<T1>>(__FUNCTION__, param1);
  insistParameterExists<std::vector<T2>>(__FUNCTION__, param2);

  const auto & value1 = getParam<std::vector<T1>>(param1);
  const auto & value2 = getParam<std::vector<T2>>(param2);
  if (value1.size() != value2.size())
    logError("The number of entries in parameter '",
             param1,
             "' (",
             value1.size(),
             ") must equal the number of entries of parameter '",
             param2,
             "' (",
             value2.size(),
             ")");
}

template <typename T>
void
Component::checkSizeEqualsValue(const std::string & param, const unsigned int & n_entries) const
{
  insistParameterExists<std::vector<T>>(__FUNCTION__, param);

  const auto & param_value = getParam<std::vector<T>>(param);
  if (param_value.size() != n_entries)
    logError("The number of entries in parameter '",
             param,
             "' (",
             param_value.size(),
             ") must be equal to ",
             n_entries);
}

template <typename T>
void
Component::checkSizeEqualsValue(const std::string & param,
                                const unsigned int & n_entries,
                                const std::string & description) const
{
  insistParameterExists<std::vector<T>>(__FUNCTION__, param);

  const auto & param_value = getParam<std::vector<T>>(param);
  if (param_value.size() != n_entries)
    logError("The number of entries in parameter '",
             param,
             "' (",
             param_value.size(),
             ") must be equal to ",
             description,
             " (",
             n_entries,
             ")");
}

template <typename T1, typename T2>
void
Component::checkSizeEqualsParameterValue(const std::string & param1,
                                         const std::string & param2) const
{
  insistParameterExists<std::vector<T1>>(__FUNCTION__, param1);
  insistParameterExists<T2>(__FUNCTION__, param2);

  const auto & value1 = getParam<std::vector<T1>>(param1);
  const auto & value2 = getParam<T2>(param2);
  if (value1.size() != value2)
    logError("The number of entries in parameter '",
             param1,
             "' (",
             value1.size(),
             ") must be equal to the value of parameter '",
             param2,
             "' (",
             value2,
             ")");
}