Simulation.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 "ThermalHydraulicsApp.h"
#include "FlowModel.h"
#include "Logger.h"
#include "ControlData.h"
#include "LoggingInterface.h"
#include "NamingInterface.h"
#include "libmesh/parallel_object.h"
 
class ActionWarehouse;
class Component;
class ClosuresBase;
class MooseMesh;
class THMProblem;
 
class Simulation : public libMesh::ParallelObject, public LoggingInterface, public NamingInterface
{
public:
  static void setComponentVariableOrder(const VariableName & var, int index);
 
  Simulation(FEProblemBase & fe_problem, const InputParameters & params);
  virtual ~Simulation();
 
  const libMesh::FEType & getFlowFEType() const { return _flow_fe_type; }
 
  virtual void setupQuadrature();
 
  virtual void initSimulation();
 
  virtual void initComponents();
 
  void identifyLoops();
 
  void printComponentLoops() const;
 
  virtual void run();
 
  virtual void
  addComponent(const std::string & type, const std::string & name, InputParameters params);
 
  bool hasComponent(const std::string & name) const;
 
  template <typename T>
  bool hasComponentOfType(const std::string & name) const;
 
  template <typename T>
  const T & getComponentByName(const std::string & name) const;
 
  const std::vector<std::shared_ptr<Component>> & getComponents() const { return _components; }
 
  virtual void
  addClosures(const std::string & type, const std::string & name, InputParameters params);
 
  bool hasClosures(const std::string & name) const;
 
  std::shared_ptr<ClosuresBase> getClosures(const std::string & name) const;
 
  void addSimVariable(bool nl,
                      const VariableName & name,
                      libMesh::FEType fe_type,
                      Real scaling_factor = 1.0,
                      const SolverSystemName & solver_sys = "nl0");
 
  void addSimVariable(bool nl,
                      const VariableName & name,
                      libMesh::FEType fe_type,
                      const std::vector<SubdomainName> & subdomain_names,
                      Real scaling_factor = 1.0,
                      const SolverSystemName & solver_sys = "nl0");
 
  void addSimVariable(bool nl,
                      const std::string & var_type,
                      const VariableName & name,
                      const InputParameters & params);
 
  void checkVariableNameLength(const std::string & name) const;
 
  void addConstantIC(const VariableName & var_name,
                     Real value,
                     const std::vector<SubdomainName> & block_names);
  void addFunctionIC(const VariableName & var_name,
                     const std::string & func_name,
                     const std::vector<SubdomainName> & block_names);
  void addConstantScalarIC(const VariableName & var_name, Real value);
  void addComponentScalarIC(const VariableName & var_name, const std::vector<Real> & value);
 
  void addSimInitialCondition(const std::string & type,
                              const std::string & name,
                              InputParameters params);
 
  void addControl(const std::string & type, const std::string & name, InputParameters params);
 
  void addFileOutputter(const std::string & name);
  void addScreenOutputter(const std::string & name);
 
  std::vector<OutputName> getOutputsVector(const std::string & key) const;
 
  virtual void buildMesh();
 
  virtual void addVariables();
 
  virtual void addMooseObjects();
 
  virtual void setupMesh();
 
  virtual void integrityCheck() const;
 
  virtual void advanceState();
 
  virtual void controlDataIntegrityCheck();
 
  virtual void couplingMatrixIntegrityCheck() const;
 
  template <typename T>
  bool hasControlData(const std::string & name)
  {
    if (_control_data.find(name) == _control_data.end())
      return false;
    else
      return dynamic_cast<ControlData<T> *>(_control_data[name]) != NULL;
  }
 
  template <typename T>
  ControlData<T> * getControlData(const std::string & name)
  {
    ControlData<T> * data = nullptr;
    if (_control_data.find(name) == _control_data.end())
    {
      data = new ControlData<T>(_thm_app, name);
      _control_data[name] = data;
    }
    else
      data = dynamic_cast<ControlData<T> *>(_control_data[name]);
 
    return data;
  }
 
  template <typename T>
  ControlData<T> * declareControlData(const std::string & name, THMControl * ctrl)
  {
    ControlData<T> * data = getControlData<T>(name);
    if (!data->getDeclared())
    {
      // Mark the data for error checking
      data->setDeclared();
      data->setControl(ctrl);
    }
    else
      logError("Trying to declare '", name, "', but it was already declared.");
 
    return data;
  }
 
  const bool & getImplicitTimeIntegrationFlag() { return _implicit_time_integration; }
 
  bool hasInitialConditionsFromFile() const;
 
  Logger & log() { return _log; }
 
  void setCheckJacobian(bool state) { _check_jacobian = state; }
 
  virtual void augmentSparsity(const dof_id_type & elem_id1, const dof_id_type & elem_id2);
 
  bool getVectorValuedVelocity() { return _output_vector_velocity; }
 
  void setVectorValuedVelocity(bool vector_velocity) { _output_vector_velocity = vector_velocity; }
 
  void addRelationshipManagers();
 
protected:
  struct VariableInfo
  {
    bool _nl;
    std::string _var_type;
    InputParameters _params;
 
    VariableInfo() : _params(emptyInputParameters()) {}
  };
 
  MooseMesh & _thm_mesh;
 
  FEProblemBase & _fe_problem;
 
  MooseApp & _thm_app;
 
  Factory & _thm_factory;
 
  std::vector<std::shared_ptr<Component>> _components;
  std::map<std::string, std::shared_ptr<Component>> _comp_by_name;
  std::map<std::string, std::string> _component_name_to_loop_name;
  std::map<std::string, THM::FlowModelID> _loop_name_to_model_id;
 
  std::map<std::string, std::shared_ptr<ClosuresBase>> _closures_by_name;
 
  std::map<VariableName, VariableInfo> _vars;
 
  struct ICInfo
  {
    std::string _type;
    InputParameters _params;
 
    ICInfo() : _params(emptyInputParameters()) {}
    ICInfo(const std::string & type, const InputParameters & params) : _type(type), _params(params)
    {
    }
  };
  std::map<std::string, ICInfo> _ics;
 
  const InputParameters & _thm_pars;
 
  libMesh::FEType _flow_fe_type;
 
  void setupEquations();
 
  void setupInitialConditionsFromFile();
 
  void setupInitialConditionObjects();
 
  void setupCoordinateSystem();
 
  void setupCriticalHeatFluxTable();
 
  std::vector<OutputName> _outputters_all;
  std::vector<OutputName> _outputters_file;
  std::vector<OutputName> _outputters_screen;
 
  std::map<std::string, ControlDataValue *> _control_data;
 
  bool _implicit_time_integration;
 
  Logger _log;
 
  bool _check_jacobian;
 
  std::map<dof_id_type, std::vector<dof_id_type>> _sparsity_elem_augmentation;
 
  bool _output_vector_velocity;
 
public:
  Real _zero;
 
private:
  std::vector<VariableName> sortAddedComponentVariables() const;
 
  static std::map<VariableName, int> _component_variable_order_map;
};
 
template <typename T>
bool
Simulation::hasComponentOfType(const std::string & name) const
{
  auto it = _comp_by_name.find(name);
  if (it != _comp_by_name.end())
    return dynamic_cast<T *>((it->second).get()) != nullptr;
  else
    return false;
}
 
template <typename T>
const T &
Simulation::getComponentByName(const std::string & name) const
{
  auto it = _comp_by_name.find(name);
  if (it != _comp_by_name.end())
    return *dynamic_cast<T *>((it->second).get());
  else
    mooseError("Component '",
               name,
               "' does not exist in the simulation. Use hasComponent or "
               "checkComponnetByName before calling getComponent.");
}