ActionComponent.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 "Action.h"
#include "ActionWarehouse.h"
#include "InputParametersChecksUtils.h"

class PhysicsBase;
class FEProblemBase;

#define registerActionComponent(app_name, component_name)                                          \
  registerMooseAction(app_name, component_name, "list_component")

class ActionComponent : public Action, public InputParametersChecksUtils<ActionComponent>
{
public:
  static InputParameters validParams();

  ActionComponent(const InputParameters & params);

  virtual void act() override final;

  const std::vector<MeshGeneratorName> & meshGeneratorNames() const { return _mg_names; }

  const std::vector<SubdomainName> & blocks() const { return _blocks; }

  virtual const std::vector<BoundaryName> & outerSurfaceBoundaries() const
  {
    mooseError("Not implemented");
  };

  virtual Real volume() const { mooseError("Volume routine is not implemented"); }

  virtual Real outerSurfaceArea() const { mooseError("Outer surface area is not implemented"); }

  unsigned int dimension() const { return _dimension; }

protected:
  // The default implementation of these routines will do nothing as we do not expect all Components
  // to be defining an object of every type
  // These routines are to help define a strictly geometrical component
  virtual void addMeshGenerators() {}
  virtual void addPositionsObject() {}
  virtual void addUserObjects() {}
  virtual void setupComponent() {}

  // These routines can help define a component that also defines a Physics
  virtual void addSolverVariables() {}
  virtual void addPhysics() {}
  virtual void addMaterials() {}
  virtual void checkIntegrity() {}

  virtual void actOnAdditionalTasks() {}

  void addRequiredTask(const std::string & task) { _required_tasks.insert(task); }

  void checkRequiredTasks() const;

  FEProblemBase & getProblem()
  {
    mooseAssert(_awh.problemBase().get(), "There should be a problem");
    return *_awh.problemBase().get();
  }

  Factory & getFactory() const { return _factory; }

  unsigned int _dimension;

  std::vector<MeshGeneratorName> _mg_names;

  std::vector<SubdomainName> _blocks;

  std::vector<BoundaryName> _outer_boundaries;

  const bool _verbose;

  std::set<std::string> _required_tasks;
};