Geant4 Cross Reference |
1 // 1 // 2 // ******************************************* 2 // ******************************************************************** 3 // * License and Disclaimer 3 // * License and Disclaimer * 4 // * 4 // * * 5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of * 6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and * 7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file * 8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These * 9 // * include a list of copyright holders. 9 // * include a list of copyright holders. * 10 // * 10 // * * 11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing * 12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this * 13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, * 14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its * 15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above * 16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. * 17 // * 17 // * * 18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and * 19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. * 20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or * 21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its * 22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your * 23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. * 24 // ******************************************* 24 // ******************************************************************** 25 // 25 // >> 26 // $Id: G4IT.cc 102637 2017-02-10 11:08:17Z gcosmo $ 26 // 27 // 27 // Author: Mathieu Karamitros (kara (AT) cenbg 28 // Author: Mathieu Karamitros (kara (AT) cenbg . in2p3 . fr) 28 // 29 // 29 // History: 30 // History: 30 // ----------- 31 // ----------- 31 // 10 Oct 2011 M.Karamitros created 32 // 10 Oct 2011 M.Karamitros created 32 // 33 // 33 // ------------------------------------------- 34 // ------------------------------------------------------------------- 34 35 35 #include "G4IT.hh" 36 #include "G4IT.hh" 36 #include "G4KDTree.hh" 37 #include "G4KDTree.hh" 37 #include "G4ITBox.hh" 38 #include "G4ITBox.hh" 38 #include "G4Track.hh" 39 #include "G4Track.hh" 39 #include "G4TrackList.hh" 40 #include "G4TrackList.hh" 40 #include "G4TrackingInformation.hh" 41 #include "G4TrackingInformation.hh" 41 42 42 using namespace std; 43 using namespace std; 43 44 44 //-------------------------------------------- 45 //------------------------------------------------------------------------------ 45 // 46 // 46 // Static functions 47 // Static functions 47 // 48 // 48 G4IT* GetIT(const G4Track* track) 49 G4IT* GetIT(const G4Track* track) 49 { 50 { 50 return (dynamic_cast<G4IT*>(track->GetUserIn 51 return (dynamic_cast<G4IT*>(track->GetUserInformation())); 51 } 52 } 52 53 53 G4IT* GetIT(const G4Track& track) 54 G4IT* GetIT(const G4Track& track) 54 { 55 { 55 return (dynamic_cast<G4IT*>(track.GetUserInf 56 return (dynamic_cast<G4IT*>(track.GetUserInformation())); 56 } 57 } 57 58 58 template<> 59 template<> 59 G4KDNode<G4IT>::~G4KDNode(){ 60 G4KDNode<G4IT>::~G4KDNode(){ 60 fPoint->SetNode(nullptr); 61 fPoint->SetNode(nullptr); 61 } 62 } 62 63 63 //-------------------------------------------- 64 //------------------------------------------------------------------------------ 64 // 65 // 65 // Constructors / Destructors 66 // Constructors / Destructors 66 // 67 // 67 G4IT::G4IT() : 68 G4IT::G4IT() : 68 G4VUserTrackInformation("G4IT"), 69 G4VUserTrackInformation("G4IT"), 69 fpTrack(nullptr), 70 fpTrack(nullptr), 70 fpPreviousIT(nullptr), 71 fpPreviousIT(nullptr), 71 fpNextIT(nullptr), 72 fpNextIT(nullptr), 72 fpTrackingInformation(new G4TrackingInform 73 fpTrackingInformation(new G4TrackingInformation()) 73 { 74 { 74 fpITBox = nullptr; 75 fpITBox = nullptr; 75 fpKDNode = nullptr; 76 fpKDNode = nullptr; 76 fpTrackNode = nullptr; 77 fpTrackNode = nullptr; 77 fParentID_A = 0; 78 fParentID_A = 0; 78 fParentID_B = 0; 79 fParentID_B = 0; 79 } 80 } 80 81 81 // Use only by inheriting classes 82 // Use only by inheriting classes 82 G4IT::G4IT(const G4IT& /*right*/) : 83 G4IT::G4IT(const G4IT& /*right*/) : 83 G4VUserTrackInformation("G4IT"), 84 G4VUserTrackInformation("G4IT"), 84 fpTrack(nullptr), 85 fpTrack(nullptr), 85 fpPreviousIT(nullptr), 86 fpPreviousIT(nullptr), 86 fpNextIT(nullptr), 87 fpNextIT(nullptr), 87 fpTrackingInformation(new G4TrackingInform 88 fpTrackingInformation(new G4TrackingInformation()) 88 { 89 { 89 fpITBox = nullptr; 90 fpITBox = nullptr; 90 fpKDNode = nullptr; 91 fpKDNode = nullptr; 91 fpTrackNode = nullptr; 92 fpTrackNode = nullptr; 92 fParentID_A = 0; 93 fParentID_A = 0; 93 fParentID_B = 0; 94 fParentID_B = 0; 94 } 95 } 95 96 96 // Should not be used 97 // Should not be used 97 G4IT& G4IT::operator=(const G4IT& right) 98 G4IT& G4IT::operator=(const G4IT& right) 98 { 99 { 99 G4ExceptionDescription exceptionDescription; 100 G4ExceptionDescription exceptionDescription; 100 exceptionDescription 101 exceptionDescription 101 << "The assignment operator of G4IT shou 102 << "The assignment operator of G4IT should not be used, " 102 "this feature is not supported." 103 "this feature is not supported." 103 << "If really needed, please contact the 104 << "If really needed, please contact the developers."; 104 G4Exception("G4IT::operator=(const G4IT& rig 105 G4Exception("G4IT::operator=(const G4IT& right)", 105 "G4IT001", 106 "G4IT001", 106 FatalException, 107 FatalException, 107 exceptionDescription); 108 exceptionDescription); 108 109 109 if (this == &right) return *this; 110 if (this == &right) return *this; 110 111 111 fpTrack = nullptr; 112 fpTrack = nullptr; 112 fpITBox = nullptr; 113 fpITBox = nullptr; 113 fpPreviousIT = nullptr; 114 fpPreviousIT = nullptr; 114 fpNextIT = nullptr; 115 fpNextIT = nullptr; 115 fpKDNode = nullptr; 116 fpKDNode = nullptr; 116 fParentID_A = 0; 117 fParentID_A = 0; 117 fParentID_B = 0; 118 fParentID_B = 0; 118 fpTrackingInformation = nullptr; 119 fpTrackingInformation = nullptr; 119 fpTrackNode = nullptr; 120 fpTrackNode = nullptr; 120 121 121 return *this; 122 return *this; 122 } 123 } 123 124 124 G4IT::G4IT(G4Track * aTrack) : 125 G4IT::G4IT(G4Track * aTrack) : 125 G4VUserTrackInformation("G4IT"), 126 G4VUserTrackInformation("G4IT"), 126 fpPreviousIT(nullptr), << 127 fpPreviousIT(0), 127 fpNextIT(nullptr), << 128 fpNextIT(0), 128 fpTrackingInformation(new G4TrackingInform 129 fpTrackingInformation(new G4TrackingInformation()) 129 { 130 { 130 fpITBox = nullptr; << 131 fpITBox = 0; 131 fpTrack = aTrack; 132 fpTrack = aTrack; 132 fpKDNode = nullptr; 133 fpKDNode = nullptr; 133 fpTrackNode = nullptr; 134 fpTrackNode = nullptr; 134 fParentID_A = 0; 135 fParentID_A = 0; 135 fParentID_B = 0; 136 fParentID_B = 0; 136 RecordCurrentPositionNTime(); 137 RecordCurrentPositionNTime(); 137 } 138 } 138 139 139 void G4IT::TakeOutBox() 140 void G4IT::TakeOutBox() 140 { 141 { 141 if(fpITBox != nullptr) << 142 if(fpITBox) 142 { 143 { 143 fpITBox->Extract(this); 144 fpITBox->Extract(this); 144 fpITBox = nullptr; 145 fpITBox = nullptr; 145 } 146 } 146 147 147 if(fpTrackNode != nullptr) << 148 if(fpTrackNode) 148 { 149 { 149 delete fpTrackNode; 150 delete fpTrackNode; 150 fpTrackNode = nullptr; 151 fpTrackNode = nullptr; 151 } 152 } 152 153 153 if(fpKDNode != nullptr) << 154 if(fpKDNode) 154 { 155 { 155 InactiveNode(fpKDNode); 156 InactiveNode(fpKDNode); 156 fpKDNode = nullptr; 157 fpKDNode = nullptr; 157 } 158 } 158 } 159 } 159 160 160 G4IT::~G4IT() 161 G4IT::~G4IT() 161 { 162 { 162 TakeOutBox(); 163 TakeOutBox(); 163 164 164 if(fpTrackingInformation != nullptr) << 165 if(fpTrackingInformation) 165 { 166 { 166 delete fpTrackingInformation; 167 delete fpTrackingInformation; 167 fpTrackingInformation = nullptr; 168 fpTrackingInformation = nullptr; 168 } 169 } 169 170 170 // Note : 171 // Note : 171 // G4ITTrackingManager will delete fTrackNode. 172 // G4ITTrackingManager will delete fTrackNode. 172 // fKDNode will be deleted when the KDTree is 173 // fKDNode will be deleted when the KDTree is rebuilt 173 } 174 } 174 175 175 //-------------------------------------------- 176 //------------------------------------------------------------------------------ 176 /// 177 /// 177 // Methods 178 // Methods 178 /// 179 /// 179 180 180 G4bool G4IT::operator<(const G4IT& right) cons 181 G4bool G4IT::operator<(const G4IT& right) const 181 { 182 { 182 if (GetITType() == right.GetITType()) 183 if (GetITType() == right.GetITType()) 183 { 184 { 184 return (this->diff(right)); 185 return (this->diff(right)); 185 } 186 } 186 << 187 else 187 return (GetITType() < right.GetITType()); << 188 { 188 << 189 return (GetITType() < right.GetITType()); >> 190 } >> 191 return false; 189 } 192 } 190 193 191 G4bool G4IT::operator==(const G4IT& right) con 194 G4bool G4IT::operator==(const G4IT& right) const 192 { 195 { 193 if (GetITType() == right.GetITType()) 196 if (GetITType() == right.GetITType()) 194 { 197 { 195 return this->equal(right); 198 return this->equal(right); 196 } 199 } 197 return false; 200 return false; 198 } 201 } 199 202 200 G4bool G4IT::operator!=(const G4IT& right) con 203 G4bool G4IT::operator!=(const G4IT& right) const 201 { 204 { 202 return !(this->operator==(right)); 205 return !(this->operator==(right)); 203 } 206 } 204 207 205 double G4IT::operator[](int i) const 208 double G4IT::operator[](int i) const 206 { 209 { 207 return fpTrack->GetPosition()[i]; 210 return fpTrack->GetPosition()[i]; 208 } 211 } 209 212 210 //-------------------------------------------- 213 //------------------------------------------------------------------------------ 211 214 212 const G4ThreeVector& G4IT::GetPosition() const 215 const G4ThreeVector& G4IT::GetPosition() const 213 { 216 { 214 if (fpTrack != nullptr) return GetTrack()->G << 217 if (fpTrack) return GetTrack()->GetPosition(); 215 return *(new G4ThreeVector()); 218 return *(new G4ThreeVector()); 216 } 219 } 217 220 218 void G4IT::RecordCurrentPositionNTime() 221 void G4IT::RecordCurrentPositionNTime() 219 { 222 { 220 if (fpTrack != nullptr) << 223 if (fpTrack) 221 { 224 { 222 fpTrackingInformation->RecordCurrentPositi 225 fpTrackingInformation->RecordCurrentPositionNTime(fpTrack); 223 } 226 } 224 } 227 } 225 228 226 G4double G4IT::GetPreStepGlobalTime() const 229 G4double G4IT::GetPreStepGlobalTime() const 227 { 230 { 228 return fpTrackingInformation->GetPreStepGlob 231 return fpTrackingInformation->GetPreStepGlobalTime(); 229 } 232 } 230 233 231 G4double G4IT::GetPreStepLocalTime() const 234 G4double G4IT::GetPreStepLocalTime() const 232 { 235 { 233 return fpTrackingInformation->GetPreStepLoca 236 return fpTrackingInformation->GetPreStepLocalTime(); 234 } 237 } 235 238 236 const G4ThreeVector& G4IT::GetPreStepPosition( 239 const G4ThreeVector& G4IT::GetPreStepPosition() const 237 { 240 { 238 return fpTrackingInformation->GetPreStepPosi 241 return fpTrackingInformation->GetPreStepPosition(); 239 } 242 } 240 243 241 244