TriPinHexAssemblyGenerator.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 "PolygonMeshGeneratorBase.h"
 
class TriPinHexAssemblyGenerator : public PolygonMeshGeneratorBase
{
public:
  static InputParameters validParams();
 
  TriPinHexAssemblyGenerator(const InputParameters & parameters);
 
  std::unique_ptr<MeshBase> generate() override;
 
protected:
  const std::vector<std::vector<Real>> _ring_radii;
  const std::vector<bool> _has_rings;
  const std::vector<std::vector<unsigned int>> _ring_intervals;
  const std::vector<std::vector<subdomain_id_type>> _ring_block_ids;
  const std::vector<std::vector<SubdomainName>> _ring_block_names;
  const PolygonSizeStyle _hexagon_size_style;
  const Real _side_length;
  const Real _ring_offset;
  const bool _preserve_volumes;
  const enum class AssmOrient { pin_up, pin_down } _assembly_orientation;
  const unsigned int _num_sectors_per_side;
  const unsigned int _background_intervals;
  const std::vector<subdomain_id_type> _background_block_ids;
  const std::vector<SubdomainName> _background_block_names;
  const boundary_id_type _external_boundary_id;
  const std::string _external_boundary_name;
  const std::string _pin_id_name;
  const std::vector<dof_id_type> _pin_id_values;
  dof_id_type & _node_id_background_meta;
 
  std::unique_ptr<ReplicatedMesh>
  buildSinglePinSection(const Real side_length,
                        const Real ring_offset,
                        const std::vector<Real> ring_radii,
                        const std::vector<unsigned int> ring_intervals,
                        const bool has_rings,
                        const bool preserve_volumes,
                        const unsigned int num_sectors_per_side,
                        const unsigned int background_intervals,
                        const std::vector<subdomain_id_type> block_ids_new,
                        dof_id_type & node_id_background_meta);
 
private:
  template <typename T>
  std::vector<std::vector<T>> getRingParamValues(const std::string & param_name) const;
};
 
template <typename T>
std::vector<std::vector<T>>
TriPinHexAssemblyGenerator::getRingParamValues(const std::string & param_name) const
{
  std::vector<std::vector<T>> value = {{}, {}, {}};
 
  if (isParamValid(param_name))
  {
    const auto & param_value = getParam<std::vector<std::vector<T>>>(param_name);
    if (param_value.size() == 1)
      value = {param_value[0], param_value[0], param_value[0]};
    else if (param_value.size() == 3)
      value = param_value;
    else if (param_value.size() != 0) // override case where you want to unset it
      paramError(param_name, "This parameter must have a size of one or three.");
  }
 
  return value;
}