BatchMeshGeneratorAction.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 BatchMeshGeneratorAction : public Action,
                                 public InputParametersChecksUtils<BatchMeshGeneratorAction>
{
public:
  static InputParameters validParams();

  BatchMeshGeneratorAction(const InputParameters & params);

  virtual void act() override final;

  enum class MultiBatchParamsMethod
  {
    corresponding,
    cartesian_product
  };

  enum class ParameterType
  {
    BOOL,
    REAL,
    SHORT,
    USHORT,
    INT,
    UINT,
    LONG,
    ULONG,
    LONGLONG,
    ULONGLONG,
    DOFIDTYPE,
    BDRYIDTYPE,
    SDIDTYPE,
    STRING,
    SDNAME,
    BDRYNAME,
    MGNAME,
    MFNAME,
    ENUM,
    REALVECTORVALUE,
    POINT
  };

protected:
  virtual void addMeshGenerators();
  const std::string _mesh_generator_type;
  const std::string _mesh_name_prefix;
  const std::vector<std::string> _batch_scalar_input_param_names;
  const std::vector<ParameterType> _batch_scalar_input_param_types;
  std::vector<std::vector<std::string>> _batch_scalar_input_param_values;
  const std::vector<std::string> _batch_vector_input_param_names;
  const std::vector<ParameterType> _batch_vector_input_param_types;
  std::vector<std::vector<std::vector<std::string>>> _batch_vector_input_param_values;
  const MultiBatchParamsMethod _multi_batch_params_method;
  const std::vector<std::string> _fixed_scalar_input_param_names;
  const std::vector<ParameterType> _fixed_scalar_input_param_types;
  std::vector<std::string> _fixed_scalar_input_param_values;
  const std::vector<std::string> _fixed_vector_input_param_names;
  const std::vector<ParameterType> _fixed_vector_input_param_types;
  std::vector<std::vector<std::string>> _fixed_vector_input_param_values;
  const bool _use_decomposed_index;

  void setScalarParams(InputParameters & params,
                       const std::string & param_name,
                       const ParameterType & param_type,
                       const std::string & param_value) const;

  void setVectorParams(InputParameters & params,
                       const std::string & param_name,
                       const ParameterType & param_type,
                       const std::vector<std::string> & param_value) const;

  template <typename T>
  void convertAndSetNumericVector(InputParameters & params,
                                  const std::string & param_name,
                                  const std::vector<std::string> & param_value) const;

  template <typename T>
  void convertAndSetCompoundRealScalarVector(InputParameters & params,
                                             const std::string & param_name,
                                             const std::vector<std::string> & param_value) const;

  template <typename T>
  void convertAndSetStringLikeVector(InputParameters & params,
                                     const std::string & param_name,
                                     const std::vector<std::string> & param_value) const;

  void checkInputParametersTypes(const InputParameters & params,
                                 const std::string & action_input_param_name,
                                 const std::vector<std::string> & param_names,
                                 const std::vector<ParameterType> & param_types,
                                 const bool & is_vector = false) const;

  template <typename T>
  void checkInputParameterType(const InputParameters & params,
                               const std::string & action_input_param_name,
                               const std::string & param_name,
                               const bool & is_vector) const;

  template <typename T>
  T convertStringToCompoundRealScalar(const std::string & str) const;

  bool isCompoundRealScalarType(const ParameterType & param_type) const;
};