RayKernelBase.C

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

#include "RayKernelBase.h"

// Local includes
#include "RayTracingStudy.h"
#include "TraceRay.h"

InputParameters
RayKernelBase::validParams()
{
  auto params = RayTracingObject::validParams();
  params += BlockRestrictable::validParams();
  params += RandomInterface::validParams();
  params += MaterialPropertyInterface::validParams();

  params.addParam<std::vector<std::string>>("depends_on",
                                            "Other RayKernels that this RayKernel depends on");

  params.registerBase("RayKernel");
  params.registerSystemAttributeName("RayKernel");

  // Allows for a RayKernel to request that it needs a reinit on its segment
  // We have this so that for RayKernels that still need qps and weights but do not
  // have any active variables or materials can still call reinitSegment()
  params.addPrivateParam<bool>("_need_segment_reinit", false);

  return params;
}

RayKernelBase::RayKernelBase(const InputParameters & params)
  : RayTracingObject(params),
    CoupleableMooseVariableDependencyIntermediateInterface(this, false),
    BlockRestrictable(this),
    RandomInterface(params, _fe_problem, _tid, false),
    MaterialPropertyInterface(this, blockIDs(), Moose::EMPTY_BOUNDARY_IDS),
    Restartable(this, "RayKernels"),
    _current_segment_start(_trace_ray.currentIncomingPoint()),
    _current_segment_end(_trace_ray.currentIntersectionPoint()),
    _current_segment_length(_trace_ray.currentIntersectionDistance()),
    _current_incoming_side(_trace_ray.currentIncomingSide()),
    _need_segment_reinit(getParam<bool>("_need_segment_reinit"))
{
  // Add dependencies
  if (isParamValid("depends_on"))
    for (const auto & name : getParam<std::vector<std::string>>("depends_on"))
      dependsOn(name);

  // Stateful material properties are not allowed on RayKernels
  statefulPropertiesAllowed(false);
}

RayKernelBase::~RayKernelBase() {}

void
RayKernelBase::changeRayStartDirection(const Point & start, const Point & direction)
{
  mooseAssert(_study.currentlyPropagating(), "Should not change Ray outside of tracing");

  const auto & ray = currentRay();

  if (!ray->shouldContinue())
  {
    if (ray->endSet() && ray->atEnd())
      mooseError("Cannot changeRayStartDirection() for a Ray that should not continue.\n\n",
                 "It has also hit its user-set end point.\n\n",
                 ray->getInfo());
    else
      mooseError("Cannot changeRayStartDirection() for a Ray that should not continue.\n\n",
                 ray->getInfo());
  }

  if (ray->trajectoryChanged())
    mooseError("Cannot change a Ray's trajectory when its trajectory has already been changed\n\n",
               ray->getInfo());

  if (ray->endSet())
    mooseError("Cannot change the direction of a Ray whose end point is set upon generation "
               "(via setStartingEndPoint()).\n\n",
               ray->getInfo());

  if (_study.verifyRays() && !_current_elem->contains_point(start))
    mooseError("A Ray's start point was changed within a RayKernel, and said start point\n",
               "is not within the element that the RayKernel was executed on.\n\n",
               ray->getInfo());

  ray->changeStartDirection(start, direction, Ray::ChangeStartDirectionKey());
}

std::shared_ptr<Ray>
RayKernelBase::acquireRay(const Point & start, const Point & direction)
{
  mooseAssert(_study.currentlyPropagating(), "Should not be getting a Ray while not propagating");

  // Acquire a Ray with the proper sizes and a unique ID, and set the start info
  std::shared_ptr<Ray> ray =
      _study.acquireRayDuringTrace(_tid, RayTracingStudy::AcquireMoveDuringTraceKey());
  ray->setStart(start, _current_elem, RayTracingCommon::invalid_side);
  ray->setStartingDirection(direction);

  return ray;
}

void
RayKernelBase::moveRayToBuffer(std::shared_ptr<Ray> & ray)
{
  mooseAssert(_study.currentlyPropagating(),
              "Should not move Rays into buffer while not propagating");

  _study.moveRayToBufferDuringTrace(ray, _tid, RayTracingStudy::AcquireMoveDuringTraceKey());
}

void
RayKernelBase::preTrace()
{
}

void
RayKernelBase::postTrace()
{
}