kernel/shapetypes/ConeTypes.h

0001 /*
0002  * @file ConeTypes.h
0003  * @purpose Contains all cone types
0004  * @author Sandro Wenzel
0005  *
0006  * 140514 Sandro Wenzel  - Created
0007  * 180303 Guilherme Lima - Adapted for specialization and unplaced shape factory
0008  *
0009  */
0010
0011 #ifndef VECGEOM_VOLUMES_KERNEL_SHAPETYPES_CONETYPES_H_
0012 #define VECGEOM_VOLUMES_KERNEL_SHAPETYPES_CONETYPES_H_
0013
0014 //#include "VecGeom/volumes/UnplacedCone.h"
0015 //#include "VecGeom/volumes/ConeStruct.h"
0016
0017 namespace vecgeom {
0018
0019 VECGEOM_DEVICE_DECLARE_NS_CONV(ConeTypes, struct, UniversalCone, UniversalCone);
0020
0021 #ifndef VECGEOM_NO_SPECIALIZATION
0022
0023 VECGEOM_DEVICE_DECLARE_NS_CONV(ConeTypes, struct, NonHollowCone, UniversalCone);
0024 VECGEOM_DEVICE_DECLARE_NS_CONV(ConeTypes, struct, NonHollowConeWithSmallerThanPiSector, UniversalCone);
0025 VECGEOM_DEVICE_DECLARE_NS_CONV(ConeTypes, struct, NonHollowConeWithBiggerThanPiSector, UniversalCone);
0026 VECGEOM_DEVICE_DECLARE_NS_CONV(ConeTypes, struct, NonHollowConeWithPiSector, UniversalCone);
0027
0028 VECGEOM_DEVICE_DECLARE_NS_CONV(ConeTypes, struct, HollowCone, UniversalCone);
0029 VECGEOM_DEVICE_DECLARE_NS_CONV(ConeTypes, struct, HollowConeWithSmallerThanPiSector, UniversalCone);
0030 VECGEOM_DEVICE_DECLARE_NS_CONV(ConeTypes, struct, HollowConeWithBiggerThanPiSector, UniversalCone);
0031 VECGEOM_DEVICE_DECLARE_NS_CONV(ConeTypes, struct, HollowConeWithPiSector, UniversalCone);
0032
0033 #endif // VECGEOM_NO_SPECIALIZATION
0034
0035 inline namespace VECGEOM_IMPL_NAMESPACE {
0036 namespace ConeTypes {
0037
0038 #define DEFINE_CONE_TYPE(name)                      \
0039   struct name {                                     \
0040     VECCORE_ATT_HOST_DEVICE                         \
0041     static char const *toString() { return #name; } \
0042   }
0043
0044 // A cone that encompasses all cases - not specialized and will do extra checks at runtime
0045 DEFINE_CONE_TYPE(UniversalCone);
0046
0047 //#ifndef VECGEOM_NO_SPECIALIZATION
0048
0049 // A cone not having rmin or phi sector
0050 DEFINE_CONE_TYPE(NonHollowCone);
0051 // A cone without rmin but with a phi sector smaller than pi
0052 DEFINE_CONE_TYPE(NonHollowConeWithSmallerThanPiSector);
0053 // A cone without rmin but with a phi sector greater than pi
0054 DEFINE_CONE_TYPE(NonHollowConeWithBiggerThanPiSector);
0055 // A cone without rmin but with a phi sector equal to pi
0056 DEFINE_CONE_TYPE(NonHollowConeWithPiSector);
0057
0058 // A cone with rmin and no phi sector
0059 DEFINE_CONE_TYPE(HollowCone);
0060 // A cone with rmin and a phi sector smaller than pi
0061 DEFINE_CONE_TYPE(HollowConeWithSmallerThanPiSector);
0062 // A cone with rmin and a phi sector greater than pi
0063 DEFINE_CONE_TYPE(HollowConeWithBiggerThanPiSector);
0064 // A cone with rmin and a phi sector equal to pi
0065 DEFINE_CONE_TYPE(HollowConeWithPiSector);
0066
0067 //#endif // VECGEOM_NO_SPECIALIZATION
0068
0069 #undef DEFINE_CONE_TYPE
0070
0071 // Mapping of cone types to certain characteristics
0072 enum ETreatmentType { kYes = 0, kNo, kUnknown };
0073
0074 // asking for phi treatment
0075 template <typename T>
0076 struct NeedsPhiTreatment {
0077   static const ETreatmentType value = kYes;
0078 };
0079
0080 #ifndef VECGEOM_NO_SPECIALIZATION
0081
0082 template <>
0083 struct NeedsPhiTreatment<NonHollowCone> {
0084   static const ETreatmentType value = kNo;
0085 };
0086 template <>
0087 struct NeedsPhiTreatment<HollowCone> {
0088   static const ETreatmentType value = kNo;
0089 };
0090
0091 #endif // VECGEOM_NO_SPECIALIZATION
0092
0093 template <>
0094 struct NeedsPhiTreatment<UniversalCone> {
0095   static const ETreatmentType value = kUnknown;
0096 };
0097
0098 template <typename T, typename UnplacedCone>
0099 VECGEOM_FORCE_INLINE
0100 VECCORE_ATT_HOST_DEVICE
0101 bool checkPhiTreatment(const UnplacedCone &cone)
0102 {
0103   if (NeedsPhiTreatment<T>::value != kUnknown)
0104     return NeedsPhiTreatment<T>::value == kYes;
0105   else
0106     return cone.fDPhi < vecgeom::kTwoPi;
0107 }
0108
0109 // asking for rmin treatment
0110 template <typename T>
0111 struct NeedsRminTreatment {
0112   static const ETreatmentType value = kYes;
0113 };
0114
0115 #ifndef VECGEOM_NO_SPECIALIZATION
0116
0117 template <>
0118 struct NeedsRminTreatment<NonHollowCone> {
0119   static const ETreatmentType value = kNo;
0120 };
0121 template <>
0122 struct NeedsRminTreatment<NonHollowConeWithSmallerThanPiSector> {
0123   static const ETreatmentType value = kNo;
0124 };
0125 template <>
0126 struct NeedsRminTreatment<NonHollowConeWithBiggerThanPiSector> {
0127   static const ETreatmentType value = kNo;
0128 };
0129 template <>
0130 struct NeedsRminTreatment<NonHollowConeWithPiSector> {
0131   static const ETreatmentType value = kNo;
0132 };
0133
0134 #endif // VECGEOM_NO_SPECIALIZATION
0135
0136 template <>
0137 struct NeedsRminTreatment<UniversalCone> {
0138   static const ETreatmentType value = kUnknown;
0139 };
0140
0141 template <typename T, typename UnplacedCone>
0142 VECGEOM_FORCE_INLINE
0143 VECCORE_ATT_HOST_DEVICE
0144 bool checkRminTreatment(const UnplacedCone &cone)
0145 {
0146   if (NeedsRminTreatment<T>::value != kUnknown)
0147     return NeedsRminTreatment<T>::value == kYes;
0148   else
0149     // return cone.GetRmin1() > 0 || cone.GetRmin2() > 0;
0150     return cone.fRmin1 > 0 || cone.fRmin2 > 0;
0151 }
0152
0153 // sector size
0154 enum EAngleType { kNoAngle = 0, kSmallerThanPi, kOnePi, kBiggerThanPi, kUnknownAngle };
0155
0156 template <typename T>
0157 struct SectorType {
0158   static const EAngleType value = kNoAngle;
0159 };
0160
0161 template <>
0162 struct SectorType<UniversalCone> {
0163   static const EAngleType value = kUnknownAngle;
0164 };
0165
0166 #ifndef VECGEOM_NO_SPECIALIZATION
0167
0168 template <>
0169 struct SectorType<NonHollowConeWithSmallerThanPiSector> {
0170   static const EAngleType value = kSmallerThanPi;
0171 };
0172
0173 template <>
0174 struct SectorType<NonHollowConeWithPiSector> {
0175   static const EAngleType value = kOnePi;
0176 };
0177
0178 template <>
0179 struct SectorType<NonHollowConeWithBiggerThanPiSector> {
0180   static const EAngleType value = kBiggerThanPi;
0181 };
0182 template <>
0183 struct SectorType<HollowConeWithSmallerThanPiSector> {
0184   static const EAngleType value = kSmallerThanPi;
0185 };
0186
0187 template <>
0188 struct SectorType<HollowConeWithPiSector> {
0189   static const EAngleType value = kOnePi;
0190 };
0191
0192 template <>
0193 struct SectorType<HollowConeWithBiggerThanPiSector> {
0194   static const EAngleType value = kBiggerThanPi;
0195 };
0196
0197 #endif // VECGEOM_NO_SPECIALIZATION
0198
0199 } // End namespace CONETYPES
0200 } // End VECGEOM_IMPL_NAMESPACE
0201 } // End global namespace vecgeom
0202
0203 #endif // VECGEOM_VOLUMES_KERNEL_SHAPETYPES_CONETYPES_H_