RayTracingObject.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"

// MOOSE includes
#include "MooseObject.h"
#include "SetupInterface.h"
#include "FunctionInterface.h"
#include "PostprocessorInterface.h"
#include "VectorPostprocessorInterface.h"
#include "MeshChangedInterface.h"
#include "TransientInterface.h"
#include "UserObjectInterface.h"
#include "DependencyResolverInterface.h"

// Local includes
#include "ElemExtrema.h"

// Forward declarations
class AuxiliarySystem;
class NonlinearSystemBase;
class TraceRay;

class RayTracingObject : public MooseObject,
                         public SetupInterface,
                         public FunctionInterface,
                         public PostprocessorInterface,
                         public VectorPostprocessorInterface,
                         public MeshChangedInterface,
                         public TransientInterface,
                         public UserObjectInterface,
                         public DependencyResolverInterface
{
public:
  RayTracingObject(const InputParameters & params);

  static InputParameters validParams();

  const std::set<std::string> & getRequestedItems() override { return _depend_names; }
  const std::set<std::string> & getSuppliedItems() override { return _supplied_names; }

  RayTracingStudy & study() { return _study; }
  const RayTracingStudy & study() const { return _study; }

  template <typename T>
  T & getStudy();

  virtual void preExecuteStudy(){};
  virtual void postExecuteStudy(){};

protected:
  const std::shared_ptr<Ray> & currentRay() const { return *_current_ray; }

  void dependsOn(const std::string name) { _depend_names.insert(name); }

  NonlinearSystemBase * getNonlinearSystem();

  const THREAD_ID _tid;

  FEProblemBase & _fe_problem;

  RayTracingStudy & _study;
  const TraceRay & _trace_ray;

  NonlinearSystemBase * _nl;
  AuxiliarySystem & _aux;

  MooseMesh & _mesh;

  const Elem * const & _current_elem;
  const SubdomainID & _current_subdomain_id;
  const unsigned short & _current_intersected_side;
  const ElemExtrema & _current_intersected_extrema;

private:
  std::set<std::string> _depend_names;
  std::set<std::string> _supplied_names;

  const std::shared_ptr<Ray> * const & _current_ray;
};

template <typename T>
T &
RayTracingObject::getStudy()
{
  static_assert(std::is_base_of<RayTracingStudy, T>::value, "Not derived from a RayTracingStudy");

  if (T * cast_study = dynamic_cast<T *>(&_study))
    return *cast_study;

  std::stringstream err;
  err << "Supplied study of type " << _study.type() << " is not the required study type "
      << MooseUtils::prettyCppType<T>();
  if (isParamValid("study"))
    paramError("study", err.str());
  else
    mooseError(err.str());
}

#define usingRayTracingObjectMembers                                                               \
  usingMooseObjectMembers;                                                                         \
  usingFunctionInterfaceMembers;                                                                   \
  usingPostprocessorInterfaceMembers;                                                              \
  usingTransientInterfaceMembers;                                                                  \
  using RayTracingObject::currentRay