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