ViewFactorRayStudy.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 "RayTracingStudy.h"

#include "RayTracingAngularQuadrature.h"

class ViewFactorRayStudy : public RayTracingStudy
{
public:
  ViewFactorRayStudy(const InputParameters & parameters);

  static InputParameters validParams();

  void initialSetup() override;

  struct StartElem
  {
    StartElem() {}

    StartElem(const Elem * elem,
              const Elem * start_elem,
              const unsigned short int incoming_side,
              const BoundaryID bnd_id,
              const std::vector<Point> & points,
              const std::vector<Real> & weights)
      : _elem(elem),
        _start_elem(start_elem),
        _incoming_side(incoming_side),
        _bnd_id(bnd_id),
        _points(points),
        _weights(weights)
    {
      mooseAssert(_points.size() == _weights.size(), "Point and weight size not equal");
    }

    const Elem * _elem;
    const Elem * _start_elem;
    unsigned short int _incoming_side;
    BoundaryID _bnd_id;
    std::vector<Point> _points;
    std::vector<Real> _weights;
  };

  void addToViewFactorInfo(Real value,
                           const BoundaryID from_id,
                           const BoundaryID to_id,
                           const THREAD_ID tid);

  Real viewFactorInfo(const BoundaryID from_id, const BoundaryID to_id) const;

  RayDataIndex rayIndexStartBndID() const { return _ray_index_start_bnd_id; }
  RayDataIndex rayIndexStartTotalWeight() const { return _ray_index_start_total_weight; }

protected:
  void generateRays() override;
  void preExecuteStudy() override;
  void postExecuteStudy() override;

  void generateStartElems();

  const std::vector<BoundaryID> _bnd_ids_vec;
  const std::set<BoundaryID> _bnd_ids;

  const MooseEnum _internal_convention;

  const RayDataIndex _ray_index_start_bnd_id;
  const RayDataIndex _ray_index_start_total_weight;

  const std::unique_ptr<libMesh::FEBase> _fe_face;
  const std::unique_ptr<libMesh::QBase> _q_face;

  // Whether or not the mesh is 3D
  const bool _is_3d;

private:
  std::vector<std::unordered_map<BoundaryID, std::unordered_map<BoundaryID, Real>>>
      _threaded_vf_info;
  std::map<BoundaryID, std::map<BoundaryID, Real>> _vf_info;

  std::vector<StartElem> _start_elems;

  std::vector<Real> _2d_aq_angles;
  std::vector<Real> _2d_aq_weights;
  std::unique_ptr<RayTracingAngularQuadrature> _3d_aq;
  std::size_t _num_dir;
};

namespace libMesh
{
namespace Parallel
{
template <>
class Packing<ViewFactorRayStudy::StartElem>
{
public:
  typedef Real buffer_type;

  static unsigned int packing_size(const std::size_t num_points);

  static unsigned int packed_size(typename std::vector<Real>::const_iterator in);

  static unsigned int packable_size(const ViewFactorRayStudy::StartElem & start_elem, const void *);

  template <typename Iter, typename Context>
  static void pack(const ViewFactorRayStudy::StartElem & object, Iter data_out, const Context *);

  template <typename BufferIter, typename Context>
  static ViewFactorRayStudy::StartElem unpack(BufferIter in, Context *);
};

} // namespace Parallel

} // namespace libMesh