volumes/kernel/TBooleanMinusImplementation.h

0001 /*
0002  * TBooleanMinusImplementation.h
0003  *
0004  *  Created on: Aug 13, 2014
0005  *      Author: swenzel
0006  */
0007
0008 #ifndef TBOOLEANMINUSIMPLEMENTATION_H_
0009 #define TBOOLEANMINUSIMPLEMENTATION_H_
0010
0011 #include "VecGeom/base/Vector3D.h"
0012 #include "VecGeom/volumes/TUnplacedBooleanMinusVolume.h"
0013
0014 namespace VECGEOM_NAMESPACE {
0015
0016 template <typename LeftPlacedType_t, typename RightPlacedType_t>
0017 struct TBooleanMinusImplementation {
0018
0019   template <typename Backend>
0020   VECGEOM_FORCE_INLINE VECCORE_ATT_HOST_DEVICE static void UnplacedContains(
0021       TUnplacedBooleanMinusVolume const &unplaced, Vector3D<typename Backend::precision_v> const &localPoint,
0022       typename Backend::bool_v &inside);
0023
0024   template <typename Backend>
0025   VECGEOM_FORCE_INLINE VECCORE_ATT_HOST_DEVICE static void Contains(
0026       TUnplacedBooleanMinusVolume const &unplaced, Transformation3D const &transformation,
0027       Vector3D<typename Backend::precision_v> const &point, Vector3D<typename Backend::precision_v> &localPoint,
0028       typename Backend::bool_v &inside);
0029
0030   template <typename Backend>
0031   VECGEOM_FORCE_INLINE VECCORE_ATT_HOST_DEVICE static void Inside(TUnplacedBooleanMinusVolume const &unplaced,
0032                                                                   Transformation3D const &transformation,
0033                                                                   Vector3D<typename Backend::precision_v> const &point,
0034                                                                   typename Backend::inside_v &inside);
0035
0036   template <typename Backend>
0037   VECGEOM_FORCE_INLINE VECCORE_ATT_HOST_DEVICE static void DistanceToIn(
0038       TUnplacedBooleanMinusVolume const &unplaced, Transformation3D const &transformation,
0039       Vector3D<typename Backend::precision_v> const &point, Vector3D<typename Backend::precision_v> const &direction,
0040       typename Backend::precision_v const &stepMax, typename Backend::precision_v &distance);
0041
0042   template <typename Backend>
0043   VECGEOM_FORCE_INLINE VECCORE_ATT_HOST_DEVICE static void DistanceToOut(
0044       TUnplacedBooleanMinusVolume const &unplaced, Vector3D<typename Backend::precision_v> const &point,
0045       Vector3D<typename Backend::precision_v> const &direction, typename Backend::precision_v const &stepMax,
0046       typename Backend::precision_v &distance);
0047
0048   template <typename Backend>
0049   VECGEOM_FORCE_INLINE VECCORE_ATT_HOST_DEVICE static void SafetyToIn(
0050       TUnplacedBooleanMinusVolume const &unplaced, Transformation3D const &transformation,
0051       Vector3D<typename Backend::precision_v> const &point, typename Backend::precision_v &safety);
0052
0053   template <typename Backend>
0054   VECGEOM_FORCE_INLINE VECCORE_ATT_HOST_DEVICE static void SafetyToOut(
0055       TUnplacedBooleanMinusVolume const &unplaced, Vector3D<typename Backend::precision_v> const &point,
0056       typename Backend::precision_v &safety);
0057
0058   template <typename Backend>
0059   VECGEOM_FORCE_INLINE VECCORE_ATT_HOST_DEVICE static void ContainsKernel(
0060       TUnplacedBooleanMinusVolume const &unplaced, Vector3D<typename Backend::precision_v> const &point,
0061       typename Backend::bool_v &inside);
0062
0063   template <typename Backend>
0064   VECGEOM_FORCE_INLINE VECCORE_ATT_HOST_DEVICE static void InsideKernel(
0065       TUnplacedBooleanMinusVolume const &unplaced, Vector3D<typename Backend::precision_v> const &point,
0066       typename Backend::inside_v &inside);
0067
0068   template <typename Backend>
0069   VECGEOM_FORCE_INLINE VECCORE_ATT_HOST_DEVICE static void DistanceToInKernel(
0070       TUnplacedBooleanMinusVolume const &unplaced, Vector3D<typename Backend::precision_v> const &point,
0071       Vector3D<typename Backend::precision_v> const &direction, typename Backend::precision_v const &stepMax,
0072       typename Backend::precision_v &distance);
0073
0074   template <typename Backend>
0075   VECGEOM_FORCE_INLINE VECCORE_ATT_HOST_DEVICE static void DistanceToOutKernel(
0076       TUnplacedBooleanMinusVolume const &unplaced, Vector3D<typename Backend::precision_v> const &point,
0077       Vector3D<typename Backend::precision_v> const &direction, typename Backend::precision_v const &stepMax,
0078       typename Backend::precision_v &distance);
0079
0080   template <typename Backend>
0081   VECGEOM_FORCE_INLINE VECCORE_ATT_HOST_DEVICE static void SafetyToInKernel(
0082       TUnplacedBooleanMinusVolume const &unplaced, Vector3D<typename Backend::precision_v> const &point,
0083       typename Backend::precision_v &safety);
0084
0085   template <typename Backend>
0086   VECGEOM_FORCE_INLINE VECCORE_ATT_HOST_DEVICE static void SafetyToOutKernel(
0087       TUnplacedBooleanMinusVolume const &unplaced, Vector3D<typename Backend::precision_v> const &point,
0088       typename Backend::precision_v &safety);
0089
0090   template <typename Backend>
0091   VECGEOM_FORCE_INLINE VECCORE_ATT_HOST_DEVICE static void NormalKernel(
0092       TUnplacedBooleanMinusVolume const &unplaced, Vector3D<typename Backend::precision_v> const &point,
0093       Vector3D<typename Backend::precision_v> &normal, typename Backend::bool_v &valid);
0094
0095 }; // End struct TBooleanMinusImplementation
0096
0097 template <typename LeftPlacedType_t, typename RightPlacedType_t>
0098 template <typename Backend>
0099 VECCORE_ATT_HOST_DEVICE void TBooleanMinusImplementation<LeftPlacedType_t, RightPlacedType_t>::UnplacedContains(
0100     TUnplacedBooleanMinusVolume const &unplaced, Vector3D<typename Backend::precision_v> const &localPoint,
0101     typename Backend::bool_v &inside)
0102 {
0103
0104   ContainsKernel<Backend>(unplaced, localPoint, inside);
0105 }
0106
0107 template <typename LeftPlacedType_t, typename RightPlacedType_t>
0108 template <typename Backend>
0109 VECCORE_ATT_HOST_DEVICE void TBooleanMinusImplementation<LeftPlacedType_t, RightPlacedType_t>::Contains(
0110     TUnplacedBooleanMinusVolume const &unplaced, Transformation3D const &transformation,
0111     Vector3D<typename Backend::precision_v> const &point, Vector3D<typename Backend::precision_v> &localPoint,
0112     typename Backend::bool_v &inside)
0113 {
0114
0115   localPoint = transformation.Transform(point);
0116   UnplacedContains<Backend>(unplaced, localPoint, inside);
0117 }
0118
0119 template <typename LeftPlacedType_t, typename RightPlacedType_t>
0120 template <typename Backend>
0121 VECCORE_ATT_HOST_DEVICE void TBooleanMinusImplementation<LeftPlacedType_t, RightPlacedType_t>::Inside(
0122     TUnplacedBooleanMinusVolume const &unplaced, Transformation3D const &transformation,
0123     Vector3D<typename Backend::precision_v> const &point, typename Backend::inside_v &inside)
0124 {
0125
0126   InsideKernel<Backend>(unplaced, transformation.Transform(point), inside);
0127 }
0128
0129 template <typename LeftPlacedType_t, typename RightPlacedType_t>
0130 template <typename Backend>
0131 VECCORE_ATT_HOST_DEVICE void TBooleanMinusImplementation<LeftPlacedType_t, RightPlacedType_t>::DistanceToIn(
0132     TUnplacedBooleanMinusVolume const &unplaced, Transformation3D const &transformation,
0133     Vector3D<typename Backend::precision_v> const &point, Vector3D<typename Backend::precision_v> const &direction,
0134     typename Backend::precision_v const &stepMax, typename Backend::precision_v &distance)
0135 {
0136
0137   DistanceToInKernel<Backend>(unplaced, transformation.Transform(point), transformation.TransformDirection(direction),
0138                               stepMax, distance);
0139 }
0140
0141 template <typename LeftPlacedType_t, typename RightPlacedType_t>
0142 template <typename Backend>
0143 VECCORE_ATT_HOST_DEVICE void TBooleanMinusImplementation<LeftPlacedType_t, RightPlacedType_t>::DistanceToOut(
0144     TUnplacedBooleanMinusVolume const &unplaced, Vector3D<typename Backend::precision_v> const &point,
0145     Vector3D<typename Backend::precision_v> const &direction, typename Backend::precision_v const &stepMax,
0146     typename Backend::precision_v &distance)
0147 {
0148
0149   DistanceToOutKernel<Backend>(unplaced, point, direction, stepMax, distance);
0150 }
0151
0152 template <typename LeftPlacedType_t, typename RightPlacedType_t>
0153 template <typename Backend>
0154 VECGEOM_FORCE_INLINE VECCORE_ATT_HOST_DEVICE void TBooleanMinusImplementation<
0155     LeftPlacedType_t, RightPlacedType_t>::SafetyToIn(TUnplacedBooleanMinusVolume const &unplaced,
0156                                                      Transformation3D const &transformation,
0157                                                      Vector3D<typename Backend::precision_v> const &point,
0158                                                      typename Backend::precision_v &safety)
0159 {
0160
0161   SafetyToInKernel<Backend>(unplaced, transformation.Transform(point), safety);
0162 }
0163
0164 template <typename LeftPlacedType_t, typename RightPlacedType_t>
0165 template <class Backend>
0166 VECGEOM_FORCE_INLINE VECCORE_ATT_HOST_DEVICE void TBooleanMinusImplementation<
0167     LeftPlacedType_t, RightPlacedType_t>::SafetyToOut(TUnplacedBooleanMinusVolume const &unplaced,
0168                                                       Vector3D<typename Backend::precision_v> const &point,
0169                                                       typename Backend::precision_v &safety)
0170 {
0171
0172   SafetyToOutKernel<Backend>(unplaced, point, safety);
0173 }
0174
0175 template <typename LeftPlacedType_t, typename RightPlacedType_t>
0176 template <typename Backend>
0177 VECCORE_ATT_HOST_DEVICE void TBooleanMinusImplementation<LeftPlacedType_t, RightPlacedType_t>::ContainsKernel(
0178     TUnplacedBooleanMinusVolume const &unplaced, Vector3D<typename Backend::precision_v> const &localPoint,
0179     typename Backend::bool_v &inside)
0180 {
0181
0182   // now just use the Contains functionality
0183   // of Unplaced and its left and right components
0184   // Find if a subtraction of two shapes contains a given point
0185
0186   // have to figure this out
0187   Vector3D<typename Backend::precision_v> tmp;
0188   LeftPlacedType_t::Implementation::template Contains<Backend>(
0189       *((LeftPlacedType_t *)unplaced.fLeftVolume)->GetUnplacedVolume(), *unplaced.fLeftVolume->transformation(),
0190       localPoint, tmp, inside);
0191
0192   //   TUnplacedBooleanMinusVolume const &unplaced,
0193   //        Transformation3D const &transformation,
0194   //        Vector3D<typename Backend::precision_v> const &point,
0195   //        Vector3D<typename Backend::precision_v> &localPoint,
0196   //        typename Backend::bool_v &inside
0197   //
0198
0199   if (vecCore::MaskEmpty(inside)) return;
0200
0201   typename Backend::bool_v rightInside;
0202   RightPlacedType_t::Implementation::template Contains<Backend>(
0203       *((RightPlacedType_t *)unplaced.fRightVolume)->GetUnplacedVolume(), *unplaced.fRightVolume->transformation(),
0204       localPoint, tmp, rightInside);
0205
0206   inside &= !rightInside;
0207 }
0208
0209 template <typename LeftPlacedType_t, typename RightPlacedType_t>
0210 template <typename Backend>
0211 VECCORE_ATT_HOST_DEVICE void TBooleanMinusImplementation<LeftPlacedType_t, RightPlacedType_t>::InsideKernel(
0212     TUnplacedBooleanMinusVolume const &unplaced, Vector3D<typename Backend::precision_v> const &point,
0213     typename Backend::inside_v &inside)
0214 {
0215
0216   // now use the Inside functionality of left and right components
0217
0218   // going to be a bit more complicated due to Surface states
0219 }
0220
0221 template <typename LeftPlacedType_t, typename RightPlacedType_t>
0222 template <typename Backend>
0223 VECCORE_ATT_HOST_DEVICE void TBooleanMinusImplementation<LeftPlacedType_t, RightPlacedType_t>::DistanceToInKernel(
0224     TUnplacedBooleanMinusVolume const &unplaced, Vector3D<typename Backend::precision_v> const &point,
0225     Vector3D<typename Backend::precision_v> const &direction, typename Backend::precision_v const &stepMax,
0226     typename Backend::precision_v &distance)
0227 {
0228
0229   typedef typename Backend::precision_v Float_t;
0230   typedef typename Backend::bool_v Bool_t;
0231 }
0232 #include <iostream>
0233 template <typename LeftPlacedType_t, typename RightPlacedType_t>
0234 template <typename Backend>
0235 VECCORE_ATT_HOST_DEVICE void TBooleanMinusImplementation<LeftPlacedType_t, RightPlacedType_t>::DistanceToOutKernel(
0236     TUnplacedBooleanMinusVolume const &unplaced, Vector3D<typename Backend::precision_v> const &point,
0237     Vector3D<typename Backend::precision_v> const &direction, typename Backend::precision_v const &stepMax,
0238     typename Backend::precision_v &distance)
0239 {
0240
0241   typedef typename Backend::precision_v Float_t;
0242   typedef typename Backend::bool_v Bool_t;
0243
0244   // how can we force to inline this ?
0245   // Left is an unplaced shape; but it could be a complicated one
0246
0247   // what happens if LeftType is VPlacedVolume itself?
0248   // For the SOA case: is it better to push SOA down or do ONE loop around?
0249   // distance = unplaced.fLeftVolume->Unplaced_t::LeftType::DistanceToOut( point, direction, stepMax );
0250   // Float_t dinright = unplaced.fRightVolume->Unplaced_t::RightType::DistanceToIn( point, direction, stepMax );
0251
0252   // we need a template specialization for this in case we have LeftType or RightType equals to
0253   // VPlacedVolume
0254
0255   LeftPlacedType_t::Implementation::template DistanceToOut<Backend>(
0256       *((LeftPlacedType_t *)unplaced.fLeftVolume)->GetUnplacedVolume(), point, direction, stepMax, distance);
0257   Float_t dinright(kInfLength);
0258   RightPlacedType_t::Implementation::template DistanceToIn<Backend>(
0259       *((RightPlacedType_t *)unplaced.fRightVolume)->GetUnplacedVolume(), *unplaced.fRightVolume->transformation(),
0260       point, direction, stepMax, dinright);
0261   distance = Min(distance, dinright);
0262   return;
0263 }
0264
0265 template <typename LeftPlacedType_t, typename RightPlacedType_t>
0266 template <typename Backend>
0267 VECCORE_ATT_HOST_DEVICE void TBooleanMinusImplementation<LeftPlacedType_t, RightPlacedType_t>::SafetyToInKernel(
0268     TUnplacedBooleanMinusVolume const &unplaced, Vector3D<typename Backend::precision_v> const &point,
0269     typename Backend::precision_v &safety)
0270 {
0271 }
0272
0273 template <typename LeftPlacedType_t, typename RightPlacedType_t>
0274 template <typename Backend>
0275 VECCORE_ATT_HOST_DEVICE void TBooleanMinusImplementation<LeftPlacedType_t, RightPlacedType_t>::SafetyToOutKernel(
0276     TUnplacedBooleanMinusVolume const &unplaced, Vector3D<typename Backend::precision_v> const &point,
0277     typename Backend::precision_v &safety)
0278 {
0279
0280   typedef typename Backend::bool_v Bool_t;
0281   typedef typename Backend::precision_v Float_t;
0282
0283   LeftPlacedType_t::Implementation::template SafetyToOut<Backend>(
0284       *((LeftPlacedType_t *)unplaced.fLeftVolume)->GetUnplacedVolume(), point, safety);
0285   Float_t safetyright(kInfLength);
0286   RightPlacedType_t::Implementation::template SafetyToIn<Backend>(
0287       *((RightPlacedType_t *)unplaced.fRightVolume)->GetUnplacedVolume(), *unplaced.fRightVolume->transformation(),
0288       point, safetyright);
0289   safety = Min(safety, safetyright);
0290   return;
0291 }
0292
0293 template <typename LeftPlacedType_t, typename RightPlacedType_t>
0294 template <typename Backend>
0295 VECCORE_ATT_HOST_DEVICE void TBooleanMinusImplementation<LeftPlacedType_t, RightPlacedType_t>::NormalKernel(
0296     TUnplacedBooleanMinusVolume const &unplaced, Vector3D<typename Backend::precision_v> const &point,
0297     Vector3D<typename Backend::precision_v> &normal, typename Backend::bool_v &valid)
0298 {
0299   // TBDONE
0300 }
0301
0302 } // namespace VECGEOM_NAMESPACE
0303
0304 #endif /* TBOOLEANMINUSIMPLEMENTATION_H_ */