DumpObjectsProblem.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 "FEProblemBase.h"

class DumpObjectsNonlinearSystem;

#define captureDump(method_name, path)                                                             \
  void method_name(                                                                                \
      const std::string & type, const std::string & name, InputParameters & parameters) override   \
  {                                                                                                \
    dumpObjectHelper(path, type, name, parameters);                                                \
    FEProblemBase::method_name(type, name, parameters);                                            \
  }

#define captureDumpUO(method_name, path)                                                           \
  std::vector<std::shared_ptr<UserObject>> method_name(                                            \
      const std::string & type, const std::string & name, InputParameters & parameters) override   \
  {                                                                                                \
    dumpObjectHelper(path, type, name, parameters);                                                \
    FEProblemBase::method_name(type, name, parameters);                                            \
    return std::vector<std::shared_ptr<UserObject>>();                                             \
  }

class DumpObjectsProblem : public FEProblemBase
{
public:
  static InputParameters validParams();

  DumpObjectsProblem(const InputParameters & parameters);

  using FEProblemBase::addAuxVariable;
  using FEProblemBase::addVariable;

  void dumpGeneratedSyntax(const std::string path);
  void dumpAllGeneratedSyntax() const;

  virtual void solve(unsigned int /*nl_sys_num*/) override {}
  virtual void solveLinearSystem(unsigned int /*linear_sys_num*/,
                                 const Moose::PetscSupport::PetscOptions *) override
  {
  }

  // output data (we expect to call this from the DumpObjectsAction)
  void printObjects();

  virtual void initialSetup() override;
  virtual void advanceState() override {}
  virtual void timestepSetup() override {}
  virtual void execute(const ExecFlagType & /*exec_type*/) override {}
  virtual void outputStep(ExecFlagType /*type*/) override {}
  virtual void updateActiveObjects() override {}
  virtual void onTimestepEnd() override {}
  virtual void computeIndicators() override {}
  virtual void computeMarkers() override {}
  virtual bool adaptMesh() override { return false; }
  virtual void addLineSearch(const InputParameters & /*parameters*/) override {}

protected:
  void dumpObjectHelper(const std::string & system,
                        const std::string & type,
                        const std::string & name,
                        const InputParameters & parameters);

  void dumpVariableHelper(const std::string & system,
                          const std::string & var_name,
                          libMesh::FEFamily family,
                          Order order,
                          Real scale_factor,
                          const std::set<SubdomainID> * const active_subdomains);

  std::string deduceNecessaryParameters(const std::string & type,
                                        const InputParameters & parameters);

  std::map<std::string, std::string> stringifyParameters(const InputParameters & parameters);

  std::map<std::string, std::map<std::string, std::string>> _generated_syntax;

  const bool _include_all_user_specified_params;

public:
  // clang-format off
  captureDump(addAuxKernel,           "AuxKernels")
  captureDump(addAuxScalarKernel,     "AuxScalarKernels")
  captureDump(addAuxVariable,         "AuxVariables")
  captureDump(addBoundaryCondition,   "BCs")
  captureDump(addConstraint,          "Constraints")
  captureDump(addConvergence,         "Convergence")
  captureDump(addDamper,              "Dampers")
  captureDump(addDGKernel,            "DGKernels")
  captureDump(addDiracKernel,         "DiracKernels")
  captureDump(addDistribution,        "Distributions")
  captureDump(addFunction,            "Functions")
  captureDump(addFunctorMaterial,     "FunctorMaterials")
  captureDump(addFVBC,                "FVBCs")
  captureDump(addFVInitialCondition,  "FVICs")
  captureDump(addFVInterfaceKernel,   "FVInterfaceKernels")
  captureDump(addFVKernel,            "FVKernels")
  captureDump(addHDGKernel,           "HDGKernels")
  captureDump(addIndicator,           "Adaptivity/Indicators")
  captureDump(addInitialCondition,    "ICs")
  captureDump(addInterfaceKernel,     "InterfaceKernels")
  captureDump(addKernel,              "Kernels")
  captureDump(addLinearFVBC,          "LinearFVBCs")
  captureDump(addLinearFVKernel,      "LinearFVKernels")
  captureDump(addMarker,              "Adaptivity/Markers")
  captureDump(addMaterial,            "Materials")
  captureDump(addMeshDivision,        "MeshDivisions")
  captureDump(addMultiApp,            "MultiApps")
  captureDump(addNodalKernel,         "NodalKernels")
  captureDump(addPostprocessor,       "Postprocessors")
  captureDump(addPredictor,           "Executioner/Predictor")
  captureDump(addSampler,             "Samplers")
  captureDump(addScalarKernel,        "ScalarKernels")
  captureDump(addTransfer,            "Transfers")
  captureDump(addTimeIntegrator,      "Executioner/TimeIntegrators")
  captureDumpUO(addUserObject,        "UserObjects")
  captureDump(addVariable,            "Variables")
  captureDump(addVectorPostprocessor, "VectorPostprocessors")
  // clang-format off
};