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 THMMesh;
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() { 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);

  void addSimVariable(bool nl,
                      const VariableName & name,
                      libMesh::FEType fe_type,
                      const std::vector<SubdomainName> & subdomain_names,
                      Real scaling_factor = 1.0);

  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();

  ThermalHydraulicsApp & getApp() { return _thm_app; }

  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()) {}
  };

  THMMesh & _thm_mesh;

  FEProblemBase & _fe_problem;

  ThermalHydraulicsApp & _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.");
}