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