Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2025-03-13 09:29:13 

0001 /// @file TransformationSpecializations.icc
0002 /// @author Script generated.
0003 
0004 #ifndef VECGEOM_NO_SPECIALIZATION
0005 if (trans_code == translation::kGeneric && rot_code == 0x1b1) {
0006   return VolumeType::template Create<translation::kGeneric, 0x1b1>(logical_volume, transformation,
0007 #ifdef VECCORE_CUDA
0008                                                                    id, copy_no, child_id,
0009 #endif
0010                                                                    placement);
0011 }
0012 if (trans_code == translation::kIdentity && rot_code == 0x1b1) {
0013   return VolumeType::template Create<translation::kIdentity, 0x1b1>(logical_volume, transformation,
0014 #ifdef VECCORE_CUDA
0015                                                                     id, copy_no, child_id,
0016 #endif
0017                                                                     placement);
0018 }
0019 if (trans_code == translation::kGeneric && rot_code == 0x18e) {
0020   return VolumeType::template Create<translation::kGeneric, 0x18e>(logical_volume, transformation,
0021 #ifdef VECCORE_CUDA
0022                                                                    id, copy_no, child_id,
0023 #endif
0024                                                                    placement);
0025 }
0026 if (trans_code == translation::kIdentity && rot_code == 0x18e) {
0027   return VolumeType::template Create<translation::kIdentity, 0x18e>(logical_volume, transformation,
0028 #ifdef VECCORE_CUDA
0029                                                                     id, copy_no, child_id,
0030 #endif
0031                                                                     placement);
0032 }
0033 if (trans_code == translation::kGeneric && rot_code == 0x076) {
0034   return VolumeType::template Create<translation::kGeneric, 0x076>(logical_volume, transformation,
0035 #ifdef VECCORE_CUDA
0036                                                                    id, copy_no, child_id,
0037 #endif
0038                                                                    placement);
0039 }
0040 if (trans_code == translation::kIdentity && rot_code == 0x076) {
0041   return VolumeType::template Create<translation::kIdentity, 0x076>(logical_volume, transformation,
0042 #ifdef VECCORE_CUDA
0043                                                                     id, copy_no, child_id,
0044 #endif
0045                                                                     placement);
0046 }
0047 if (trans_code == translation::kGeneric && rot_code == 0x16a) {
0048   return VolumeType::template Create<translation::kGeneric, 0x16a>(logical_volume, transformation,
0049 #ifdef VECCORE_CUDA
0050                                                                    id, copy_no, child_id,
0051 #endif
0052                                                                    placement);
0053 }
0054 if (trans_code == translation::kIdentity && rot_code == 0x16a) {
0055   return VolumeType::template Create<translation::kIdentity, 0x16a>(logical_volume, transformation,
0056 #ifdef VECCORE_CUDA
0057                                                                     id, copy_no, child_id,
0058 #endif
0059                                                                     placement);
0060 }
0061 if (trans_code == translation::kGeneric && rot_code == 0x155) {
0062   return VolumeType::template Create<translation::kGeneric, 0x155>(logical_volume, transformation,
0063 #ifdef VECCORE_CUDA
0064                                                                    id, copy_no, child_id,
0065 #endif
0066                                                                    placement);
0067 }
0068 if (trans_code == translation::kIdentity && rot_code == 0x155) {
0069   return VolumeType::template Create<translation::kIdentity, 0x155>(logical_volume, transformation,
0070 #ifdef VECCORE_CUDA
0071                                                                     id, copy_no, child_id,
0072 #endif
0073                                                                     placement);
0074 }
0075 if (trans_code == translation::kGeneric && rot_code == 0x0ad) {
0076   return VolumeType::template Create<translation::kGeneric, 0x0ad>(logical_volume, transformation,
0077 #ifdef VECCORE_CUDA
0078                                                                    id, copy_no, child_id,
0079 #endif
0080                                                                    placement);
0081 }
0082 if (trans_code == translation::kIdentity && rot_code == 0x0ad) {
0083   return VolumeType::template Create<translation::kIdentity, 0x0ad>(logical_volume, transformation,
0084 #ifdef VECCORE_CUDA
0085                                                                     id, copy_no, child_id,
0086 #endif
0087                                                                     placement);
0088 }
0089 if (trans_code == translation::kGeneric && rot_code == 0x0dc) {
0090   return VolumeType::template Create<translation::kGeneric, 0x0dc>(logical_volume, transformation,
0091 #ifdef VECCORE_CUDA
0092                                                                    id, copy_no, child_id,
0093 #endif
0094                                                                    placement);
0095 }
0096 if (trans_code == translation::kIdentity && rot_code == 0x0dc) {
0097   return VolumeType::template Create<translation::kIdentity, 0x0dc>(logical_volume, transformation,
0098 #ifdef VECCORE_CUDA
0099                                                                     id, copy_no, child_id,
0100 #endif
0101                                                                     placement);
0102 }
0103 if (trans_code == translation::kGeneric && rot_code == 0x0e3) {
0104   return VolumeType::template Create<translation::kGeneric, 0x0e3>(logical_volume, transformation,
0105 #ifdef VECCORE_CUDA
0106                                                                    id, copy_no, child_id,
0107 #endif
0108                                                                    placement);
0109 }
0110 if (trans_code == translation::kIdentity && rot_code == 0x0e3) {
0111   return VolumeType::template Create<translation::kIdentity, 0x0e3>(logical_volume, transformation,
0112 #ifdef VECCORE_CUDA
0113                                                                     id, copy_no, child_id,
0114 #endif
0115                                                                     placement);
0116 }
0117 if (trans_code == translation::kGeneric && rot_code == 0x11b) {
0118   return VolumeType::template Create<translation::kGeneric, 0x11b>(logical_volume, transformation,
0119 #ifdef VECCORE_CUDA
0120                                                                    id, copy_no, child_id,
0121 #endif
0122                                                                    placement);
0123 }
0124 if (trans_code == translation::kIdentity && rot_code == 0x11b) {
0125   return VolumeType::template Create<translation::kIdentity, 0x11b>(logical_volume, transformation,
0126 #ifdef VECCORE_CUDA
0127                                                                     id, copy_no, child_id,
0128 #endif
0129                                                                     placement);
0130 }
0131 if (trans_code == translation::kGeneric && rot_code == 0x0a1) {
0132   return VolumeType::template Create<translation::kGeneric, 0x0a1>(logical_volume, transformation,
0133 #ifdef VECCORE_CUDA
0134                                                                    id, copy_no, child_id,
0135 #endif
0136                                                                    placement);
0137 }
0138 if (trans_code == translation::kIdentity && rot_code == 0x0a1) {
0139   return VolumeType::template Create<translation::kIdentity, 0x0a1>(logical_volume, transformation,
0140 #ifdef VECCORE_CUDA
0141                                                                     id, copy_no, child_id,
0142 #endif
0143                                                                     placement);
0144 }
0145 if (trans_code == translation::kGeneric && rot_code == 0x10a) {
0146   return VolumeType::template Create<translation::kGeneric, 0x10a>(logical_volume, transformation,
0147 #ifdef VECCORE_CUDA
0148                                                                    id, copy_no, child_id,
0149 #endif
0150                                                                    placement);
0151 }
0152 if (trans_code == translation::kIdentity && rot_code == 0x10a) {
0153   return VolumeType::template Create<translation::kIdentity, 0x10a>(logical_volume, transformation,
0154 #ifdef VECCORE_CUDA
0155                                                                     id, copy_no, child_id,
0156 #endif
0157                                                                     placement);
0158 }
0159 if (trans_code == translation::kGeneric && rot_code == 0x046) {
0160   return VolumeType::template Create<translation::kGeneric, 0x046>(logical_volume, transformation,
0161 #ifdef VECCORE_CUDA
0162                                                                    id, copy_no, child_id,
0163 #endif
0164                                                                    placement);
0165 }
0166 if (trans_code == translation::kIdentity && rot_code == 0x046) {
0167   return VolumeType::template Create<translation::kIdentity, 0x046>(logical_volume, transformation,
0168 #ifdef VECCORE_CUDA
0169                                                                     id, copy_no, child_id,
0170 #endif
0171                                                                     placement);
0172 }
0173 if (trans_code == translation::kGeneric && rot_code == 0x062) {
0174   return VolumeType::template Create<translation::kGeneric, 0x062>(logical_volume, transformation,
0175 #ifdef VECCORE_CUDA
0176                                                                    id, copy_no, child_id,
0177 #endif
0178                                                                    placement);
0179 }
0180 if (trans_code == translation::kIdentity && rot_code == 0x062) {
0181   return VolumeType::template Create<translation::kIdentity, 0x062>(logical_volume, transformation,
0182 #ifdef VECCORE_CUDA
0183                                                                     id, copy_no, child_id,
0184 #endif
0185                                                                     placement);
0186 }
0187 if (trans_code == translation::kGeneric && rot_code == 0x054) {
0188   return VolumeType::template Create<translation::kGeneric, 0x054>(logical_volume, transformation,
0189 #ifdef VECCORE_CUDA
0190                                                                    id, copy_no, child_id,
0191 #endif
0192                                                                    placement);
0193 }
0194 if (trans_code == translation::kIdentity && rot_code == 0x054) {
0195   return VolumeType::template Create<translation::kIdentity, 0x054>(logical_volume, transformation,
0196 #ifdef VECCORE_CUDA
0197                                                                     id, copy_no, child_id,
0198 #endif
0199                                                                     placement);
0200 }
0201 if (trans_code == translation::kGeneric && rot_code == 0x111) {
0202   return VolumeType::template Create<translation::kGeneric, 0x111>(logical_volume, transformation,
0203 #ifdef VECCORE_CUDA
0204                                                                    id, copy_no, child_id,
0205 #endif
0206                                                                    placement);
0207 }
0208 if (trans_code == translation::kIdentity && rot_code == 0x111) {
0209   return VolumeType::template Create<translation::kIdentity, 0x111>(logical_volume, transformation,
0210 #ifdef VECCORE_CUDA
0211                                                                     id, copy_no, child_id,
0212 #endif
0213                                                                     placement);
0214 }
0215 if (trans_code == translation::kGeneric && rot_code == 0x200) {
0216   return VolumeType::template Create<translation::kGeneric, 0x200>(logical_volume, transformation,
0217 #ifdef VECCORE_CUDA
0218                                                                    id, copy_no, child_id,
0219 #endif
0220                                                                    placement);
0221 }
0222 if (trans_code == translation::kIdentity && rot_code == 0x200) {
0223   return VolumeType::template Create<translation::kIdentity, 0x200>(logical_volume, transformation,
0224 #ifdef VECCORE_CUDA
0225                                                                     id, copy_no, child_id,
0226 #endif
0227                                                                     placement);
0228 }
0229 #endif // No specialization
0230 
0231 return VolumeType::template Create<translation::kGeneric, rotation::kGeneric>(logical_volume, transformation,
0232 #ifdef VECCORE_CUDA
0233                                                                               id, copy_no, child_id,
0234 #endif
0235                                                                               placement);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!