volumes/kernel/ScaledShapeImplementation.h

0001 /// @file ScaledShapeImplementation.h
0002 /// @author Mihaela Gheata (mihaela.gheata@cern.ch)
0003
0004 #ifndef VECGEOM_VOLUMES_KERNEL_SCALEDSHAPEIMPLEMENTATION_H_
0005 #define VECGEOM_VOLUMES_KERNEL_SCALEDSHAPEIMPLEMENTATION_H_
0006
0007 #include "VecGeom/volumes/kernel/GenericKernels.h"
0008 #include "VecGeom/base/Vector3D.h"
0009 #include "VecGeom/volumes/ScaledShapeStruct.h"
0010
0011 #include <cstdio>
0012
0013 namespace vecgeom {
0014
0015 VECGEOM_DEVICE_FORWARD_DECLARE(struct ScaledShapeImplementation;);
0016 VECGEOM_DEVICE_DECLARE_CONV(struct, ScaledShapeImplementation);
0017
0018 inline namespace VECGEOM_IMPL_NAMESPACE {
0019
0020 class PlacedScaledShape;
0021 class UnplacedScaledShape;
0022
0023 // template <typename T>
0024 // struct ScaledShapeStruct;
0025
0026 struct ScaledShapeImplementation {
0027
0028   using PlacedShape_t    = PlacedScaledShape;
0029   using UnplacedStruct_t = ScaledShapeStruct<Precision>;
0030   using UnplacedVolume_t = UnplacedScaledShape;
0031
0032   template <typename Real_v, typename Bool_v>
0033   VECGEOM_FORCE_INLINE VECCORE_ATT_HOST_DEVICE static void Contains(UnplacedStruct_t const &unplaced,
0034                                                                     Vector3D<Real_v> const &point, Bool_v &inside);
0035
0036   template <typename Real_v, typename Inside_t>
0037   VECGEOM_FORCE_INLINE VECCORE_ATT_HOST_DEVICE static void Inside(UnplacedStruct_t const &unplaced,
0038                                                                   Vector3D<Real_v> const &point, Inside_t &inside);
0039
0040   template <typename Real_v>
0041   VECGEOM_FORCE_INLINE VECCORE_ATT_HOST_DEVICE static void DistanceToIn(UnplacedStruct_t const &unplaced,
0042                                                                         Vector3D<Real_v> const &point,
0043                                                                         Vector3D<Real_v> const &direction,
0044                                                                         Real_v const &stepMax, Real_v &distance);
0045
0046   template <typename Real_v>
0047   VECGEOM_FORCE_INLINE VECCORE_ATT_HOST_DEVICE static void DistanceToOut(UnplacedStruct_t const &unplaced,
0048                                                                          Vector3D<Real_v> const &point,
0049                                                                          Vector3D<Real_v> const &direction,
0050                                                                          Real_v const &stepMax, Real_v &distance);
0051
0052   template <typename Real_v>
0053   VECGEOM_FORCE_INLINE VECCORE_ATT_HOST_DEVICE static void SafetyToIn(UnplacedStruct_t const &unplaced,
0054                                                                       Vector3D<Real_v> const &point, Real_v &safety);
0055
0056   template <typename Real_v>
0057   VECGEOM_FORCE_INLINE VECCORE_ATT_HOST_DEVICE static void SafetyToOut(UnplacedStruct_t const &unplaced,
0058                                                                        Vector3D<Real_v> const &point, Real_v &safety);
0059
0060   template <typename Real_v>
0061   VECGEOM_FORCE_INLINE VECCORE_ATT_HOST_DEVICE static void NormalKernel(UnplacedStruct_t const &unplaced,
0062                                                                         Vector3D<Real_v> const &point,
0063                                                                         Vector3D<Real_v> &normal,
0064                                                                         vecCore::Mask_v<Real_v> &valid);
0065
0066 }; // End struct ScaledShapeImplementation
0067
0068 // Implementations start here
0069
0070 template <typename Real_v, typename Bool_v>
0071 VECCORE_ATT_HOST_DEVICE void ScaledShapeImplementation::Contains(UnplacedStruct_t const &unplaced,
0072                                                                  Vector3D<Real_v> const &point, Bool_v &inside)
0073 {
0074
0075   // Transform local point to unscaled shape frame
0076   Vector3D<Real_v> ulocalPoint;
0077   unplaced.fScale.Transform(point, ulocalPoint);
0078
0079   // Now call Contains for the unscaled shape
0080   inside = unplaced.fPlaced->Contains(ulocalPoint);
0081 }
0082
0083 template <typename Real_v, typename Inside_t>
0084 VECCORE_ATT_HOST_DEVICE void ScaledShapeImplementation::Inside(UnplacedStruct_t const &unplaced,
0085                                                                Vector3D<Real_v> const &point, Inside_t &inside)
0086 {
0087
0088   // Transform local point to unscaled shape frame
0089   Vector3D<Real_v> ulocalPoint;
0090   unplaced.fScale.Transform(point, ulocalPoint);
0091
0092   // Now call Inside for the unscaled shape
0093   inside = unplaced.fPlaced->Inside(ulocalPoint);
0094 }
0095
0096 template <typename Real_v>
0097 VECCORE_ATT_HOST_DEVICE void ScaledShapeImplementation::DistanceToIn(UnplacedStruct_t const &unplaced,
0098                                                                      Vector3D<Real_v> const &point,
0099                                                                      Vector3D<Real_v> const &direction,
0100                                                                      Real_v const &stepMax, Real_v &distance)
0101 {
0102
0103   // Transform point, direction and stepMax to unscaled shape frame
0104   Vector3D<Real_v> ulocalPoint;
0105   unplaced.fScale.Transform(point, ulocalPoint);
0106
0107   // Direction is un-normalized after scale transformation
0108   Vector3D<Real_v> ulocalDir;
0109   unplaced.fScale.Transform(direction, ulocalDir);
0110   ulocalDir.Normalize();
0111
0112   auto ustepMax = unplaced.fScale.TransformDistance(stepMax, direction);
0113
0114   // Compute distance in unscaled system
0115   distance = unplaced.fPlaced->DistanceToIn(ulocalPoint, ulocalDir, ustepMax);
0116
0117   // Convert distance back to master (leave unchanged if it was infinity)
0118   vecCore__MaskedAssignFunc(distance, distance < InfinityLength<Real_v>(),
0119                             unplaced.fScale.InverseTransformDistance(distance, ulocalDir));
0120 }
0121
0122 template <typename Real_v>
0123 VECCORE_ATT_HOST_DEVICE void ScaledShapeImplementation::DistanceToOut(UnplacedStruct_t const &unplaced,
0124                                                                       Vector3D<Real_v> const &point,
0125                                                                       Vector3D<Real_v> const &direction,
0126                                                                       Real_v const &stepMax, Real_v &distance)
0127 {
0128
0129   // Transform point, direction and stepMax to unscaled shape frame
0130   Vector3D<Real_v> ulocalPoint;
0131   unplaced.fScale.Transform(point, ulocalPoint);
0132
0133   // Direction is un-normalized after scale transformation
0134   Vector3D<Real_v> ulocalDir;
0135   unplaced.fScale.Transform(direction, ulocalDir);
0136   ulocalDir.Normalize();
0137
0138   auto ustepMax = unplaced.fScale.TransformDistance(stepMax, direction);
0139
0140   // Compute distance in unscaled system
0141   distance = unplaced.fPlaced->DistanceToOut(ulocalPoint, ulocalDir, ustepMax);
0142
0143   // Convert distance back to master (leave unchanged if it was infinity)
0144   vecCore__MaskedAssignFunc(distance, distance < InfinityLength<Real_v>(),
0145                             unplaced.fScale.InverseTransformDistance(distance, ulocalDir));
0146 }
0147
0148 template <typename Real_v>
0149 VECCORE_ATT_HOST_DEVICE void ScaledShapeImplementation::SafetyToIn(UnplacedStruct_t const &unplaced,
0150                                                                    Vector3D<Real_v> const &point, Real_v &safety)
0151 {
0152
0153   // Transform point to unscaled shape frame
0154   Vector3D<Real_v> ulocalPoint;
0155   unplaced.fScale.Transform(point, ulocalPoint);
0156
0157   // Compute unscaled safety, then scale it.
0158   safety = unplaced.fPlaced->SafetyToIn(ulocalPoint);
0159   safety = unplaced.fScale.InverseTransformSafety(safety);
0160 }
0161
0162 template <typename Real_v>
0163 VECCORE_ATT_HOST_DEVICE void ScaledShapeImplementation::SafetyToOut(UnplacedStruct_t const &unplaced,
0164                                                                     Vector3D<Real_v> const &point, Real_v &safety)
0165 {
0166
0167   // Transform point to unscaled shape frame
0168   Vector3D<Real_v> ulocalPoint;
0169   unplaced.fScale.Transform(point, ulocalPoint);
0170
0171   // Compute unscaled safety, then scale it.
0172   safety = unplaced.fPlaced->SafetyToOut(ulocalPoint);
0173   safety = unplaced.fScale.InverseTransformSafety(safety);
0174 }
0175
0176 template <typename Real_v>
0177 VECCORE_ATT_HOST_DEVICE void ScaledShapeImplementation::NormalKernel(UnplacedStruct_t const &unplaced,
0178                                                                      Vector3D<Real_v> const &point,
0179                                                                      Vector3D<Real_v> &normal,
0180                                                                      vecCore::Mask_v<Real_v> &valid)
0181 {
0182
0183   // Transform point to unscaled shape frame
0184   Vector3D<Real_v> ulocalPoint;
0185   unplaced.fScale.Transform(point, ulocalPoint);
0186
0187   // Compute normal in unscaled frame
0188   Vector3D<Real_v> ulocalNorm;
0189   valid = unplaced.fPlaced->Normal(ulocalPoint, ulocalNorm);
0190
0191   // Convert normal to scaled frame
0192   unplaced.fScale.InverseTransformNormal(ulocalNorm, normal);
0193   normal.Normalize(); // <- Is this actually needed? PlacedVolume::Normal is supposed to return normalized normal
0194 }
0195 } // namespace VECGEOM_IMPL_NAMESPACE
0196 } // namespace vecgeom
0197
0198 #endif // VECGEOM_VOLUMES_KERNEL_SCALEDSHAPEIMPLEMENTATION_H_