| 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 // 26 //
27 // Author: Mathieu Karamitros (kara (AT) cenbg 27 // Author: Mathieu Karamitros (kara (AT) cenbg . in2p3 . fr)
28 // 28 //
29 // History: 29 // History:
30 // ----------- 30 // -----------
31 // 10 Oct 2011 M.Karamitros created 31 // 10 Oct 2011 M.Karamitros created
32 // 32 //
33 // ------------------------------------------- 33 // -------------------------------------------------------------------
34 34
35 #include "G4IT.hh" 35 #include "G4IT.hh"
36 #include "G4KDTree.hh" 36 #include "G4KDTree.hh"
37 #include "G4ITBox.hh" 37 #include "G4ITBox.hh"
38 #include "G4Track.hh" 38 #include "G4Track.hh"
39 #include "G4TrackList.hh" 39 #include "G4TrackList.hh"
40 #include "G4TrackingInformation.hh" 40 #include "G4TrackingInformation.hh"
41 41
42 using namespace std; 42 using namespace std;
43 43
44 //-------------------------------------------- 44 //------------------------------------------------------------------------------
45 // 45 //
46 // Static functions 46 // Static functions
47 // 47 //
48 G4IT* GetIT(const G4Track* track) 48 G4IT* GetIT(const G4Track* track)
49 { 49 {
50 return (dynamic_cast<G4IT*>(track->GetUserIn 50 return (dynamic_cast<G4IT*>(track->GetUserInformation()));
51 } 51 }
52 52
53 G4IT* GetIT(const G4Track& track) 53 G4IT* GetIT(const G4Track& track)
54 { 54 {
55 return (dynamic_cast<G4IT*>(track.GetUserInf 55 return (dynamic_cast<G4IT*>(track.GetUserInformation()));
56 } 56 }
57 57
58 template<> 58 template<>
59 G4KDNode<G4IT>::~G4KDNode(){ 59 G4KDNode<G4IT>::~G4KDNode(){
60 fPoint->SetNode(nullptr); 60 fPoint->SetNode(nullptr);
61 } 61 }
62 62
63 //-------------------------------------------- 63 //------------------------------------------------------------------------------
64 // 64 //
65 // Constructors / Destructors 65 // Constructors / Destructors
66 // 66 //
67 G4IT::G4IT() : 67 G4IT::G4IT() :
68 G4VUserTrackInformation("G4IT"), 68 G4VUserTrackInformation("G4IT"),
69 fpTrack(nullptr), 69 fpTrack(nullptr),
70 fpPreviousIT(nullptr), 70 fpPreviousIT(nullptr),
71 fpNextIT(nullptr), 71 fpNextIT(nullptr),
72 fpTrackingInformation(new G4TrackingInform 72 fpTrackingInformation(new G4TrackingInformation())
73 { 73 {
74 fpITBox = nullptr; 74 fpITBox = nullptr;
75 fpKDNode = nullptr; 75 fpKDNode = nullptr;
76 fpTrackNode = nullptr; 76 fpTrackNode = nullptr;
77 fParentID_A = 0; 77 fParentID_A = 0;
78 fParentID_B = 0; 78 fParentID_B = 0;
79 } 79 }
80 80
81 // Use only by inheriting classes 81 // Use only by inheriting classes
82 G4IT::G4IT(const G4IT& /*right*/) : 82 G4IT::G4IT(const G4IT& /*right*/) :
83 G4VUserTrackInformation("G4IT"), 83 G4VUserTrackInformation("G4IT"),
84 fpTrack(nullptr), 84 fpTrack(nullptr),
85 fpPreviousIT(nullptr), 85 fpPreviousIT(nullptr),
86 fpNextIT(nullptr), 86 fpNextIT(nullptr),
87 fpTrackingInformation(new G4TrackingInform 87 fpTrackingInformation(new G4TrackingInformation())
88 { 88 {
89 fpITBox = nullptr; 89 fpITBox = nullptr;
90 fpKDNode = nullptr; 90 fpKDNode = nullptr;
91 fpTrackNode = nullptr; 91 fpTrackNode = nullptr;
92 fParentID_A = 0; 92 fParentID_A = 0;
93 fParentID_B = 0; 93 fParentID_B = 0;
94 } 94 }
95 95
96 // Should not be used 96 // Should not be used
97 G4IT& G4IT::operator=(const G4IT& right) 97 G4IT& G4IT::operator=(const G4IT& right)
98 { 98 {
99 G4ExceptionDescription exceptionDescription; 99 G4ExceptionDescription exceptionDescription;
100 exceptionDescription 100 exceptionDescription
101 << "The assignment operator of G4IT shou 101 << "The assignment operator of G4IT should not be used, "
102 "this feature is not supported." 102 "this feature is not supported."
103 << "If really needed, please contact the 103 << "If really needed, please contact the developers.";
104 G4Exception("G4IT::operator=(const G4IT& rig 104 G4Exception("G4IT::operator=(const G4IT& right)",
105 "G4IT001", 105 "G4IT001",
106 FatalException, 106 FatalException,
107 exceptionDescription); 107 exceptionDescription);
108 108
109 if (this == &right) return *this; 109 if (this == &right) return *this;
110 110
111 fpTrack = nullptr; 111 fpTrack = nullptr;
112 fpITBox = nullptr; 112 fpITBox = nullptr;
113 fpPreviousIT = nullptr; 113 fpPreviousIT = nullptr;
114 fpNextIT = nullptr; 114 fpNextIT = nullptr;
115 fpKDNode = nullptr; 115 fpKDNode = nullptr;
116 fParentID_A = 0; 116 fParentID_A = 0;
117 fParentID_B = 0; 117 fParentID_B = 0;
118 fpTrackingInformation = nullptr; 118 fpTrackingInformation = nullptr;
119 fpTrackNode = nullptr; 119 fpTrackNode = nullptr;
120 120
121 return *this; 121 return *this;
122 } 122 }
123 123
124 G4IT::G4IT(G4Track * aTrack) : 124 G4IT::G4IT(G4Track * aTrack) :
125 G4VUserTrackInformation("G4IT"), 125 G4VUserTrackInformation("G4IT"),
126 fpPreviousIT(nullptr), << 126 fpPreviousIT(0),
127 fpNextIT(nullptr), << 127 fpNextIT(0),
128 fpTrackingInformation(new G4TrackingInform 128 fpTrackingInformation(new G4TrackingInformation())
129 { 129 {
130 fpITBox = nullptr; << 130 fpITBox = 0;
131 fpTrack = aTrack; 131 fpTrack = aTrack;
132 fpKDNode = nullptr; 132 fpKDNode = nullptr;
133 fpTrackNode = nullptr; 133 fpTrackNode = nullptr;
134 fParentID_A = 0; 134 fParentID_A = 0;
135 fParentID_B = 0; 135 fParentID_B = 0;
136 RecordCurrentPositionNTime(); 136 RecordCurrentPositionNTime();
137 } 137 }
138 138
139 void G4IT::TakeOutBox() 139 void G4IT::TakeOutBox()
140 { 140 {
141 if(fpITBox != nullptr) << 141 if(fpITBox)
142 { 142 {
143 fpITBox->Extract(this); 143 fpITBox->Extract(this);
144 fpITBox = nullptr; 144 fpITBox = nullptr;
145 } 145 }
146 146
147 if(fpTrackNode != nullptr) << 147 if(fpTrackNode)
148 { 148 {
149 delete fpTrackNode; 149 delete fpTrackNode;
150 fpTrackNode = nullptr; 150 fpTrackNode = nullptr;
151 } 151 }
152 152
153 if(fpKDNode != nullptr) << 153 if(fpKDNode)
154 { 154 {
155 InactiveNode(fpKDNode); 155 InactiveNode(fpKDNode);
156 fpKDNode = nullptr; 156 fpKDNode = nullptr;
157 } 157 }
158 } 158 }
159 159
160 G4IT::~G4IT() 160 G4IT::~G4IT()
161 { 161 {
162 TakeOutBox(); 162 TakeOutBox();
163 163
164 if(fpTrackingInformation != nullptr) << 164 if(fpTrackingInformation)
165 { 165 {
166 delete fpTrackingInformation; 166 delete fpTrackingInformation;
167 fpTrackingInformation = nullptr; 167 fpTrackingInformation = nullptr;
168 } 168 }
169 169
170 // Note : 170 // Note :
171 // G4ITTrackingManager will delete fTrackNode. 171 // G4ITTrackingManager will delete fTrackNode.
172 // fKDNode will be deleted when the KDTree is 172 // fKDNode will be deleted when the KDTree is rebuilt
173 } 173 }
174 174
175 //-------------------------------------------- 175 //------------------------------------------------------------------------------
176 /// 176 ///
177 // Methods 177 // Methods
178 /// 178 ///
179 179
180 G4bool G4IT::operator<(const G4IT& right) cons 180 G4bool G4IT::operator<(const G4IT& right) const
181 { 181 {
182 if (GetITType() == right.GetITType()) 182 if (GetITType() == right.GetITType())
183 { 183 {
184 return (this->diff(right)); 184 return (this->diff(right));
185 } 185 }
186 << 186 else
187 return (GetITType() < right.GetITType()); << 187 {
188 << 188 return (GetITType() < right.GetITType());
>> 189 }
>> 190 return false;
189 } 191 }
190 192
191 G4bool G4IT::operator==(const G4IT& right) con 193 G4bool G4IT::operator==(const G4IT& right) const
192 { 194 {
193 if (GetITType() == right.GetITType()) 195 if (GetITType() == right.GetITType())
194 { 196 {
195 return this->equal(right); 197 return this->equal(right);
196 } 198 }
197 return false; 199 return false;
198 } 200 }
199 201
200 G4bool G4IT::operator!=(const G4IT& right) con 202 G4bool G4IT::operator!=(const G4IT& right) const
201 { 203 {
202 return !(this->operator==(right)); 204 return !(this->operator==(right));
203 } 205 }
204 206
205 double G4IT::operator[](int i) const 207 double G4IT::operator[](int i) const
206 { 208 {
207 return fpTrack->GetPosition()[i]; 209 return fpTrack->GetPosition()[i];
208 } 210 }
209 211
210 //-------------------------------------------- 212 //------------------------------------------------------------------------------
211 213
212 const G4ThreeVector& G4IT::GetPosition() const 214 const G4ThreeVector& G4IT::GetPosition() const
213 { 215 {
214 if (fpTrack != nullptr) return GetTrack()->G << 216 if (fpTrack) return GetTrack()->GetPosition();
215 return *(new G4ThreeVector()); 217 return *(new G4ThreeVector());
216 } 218 }
217 219
218 void G4IT::RecordCurrentPositionNTime() 220 void G4IT::RecordCurrentPositionNTime()
219 { 221 {
220 if (fpTrack != nullptr) << 222 if (fpTrack)
221 { 223 {
222 fpTrackingInformation->RecordCurrentPositi 224 fpTrackingInformation->RecordCurrentPositionNTime(fpTrack);
223 } 225 }
224 } 226 }
225 227
226 G4double G4IT::GetPreStepGlobalTime() const 228 G4double G4IT::GetPreStepGlobalTime() const
227 { 229 {
228 return fpTrackingInformation->GetPreStepGlob 230 return fpTrackingInformation->GetPreStepGlobalTime();
229 } 231 }
230 232
231 G4double G4IT::GetPreStepLocalTime() const 233 G4double G4IT::GetPreStepLocalTime() const
232 { 234 {
233 return fpTrackingInformation->GetPreStepLoca 235 return fpTrackingInformation->GetPreStepLocalTime();
234 } 236 }
235 237
236 const G4ThreeVector& G4IT::GetPreStepPosition( 238 const G4ThreeVector& G4IT::GetPreStepPosition() const
237 { 239 {
238 return fpTrackingInformation->GetPreStepPosi 240 return fpTrackingInformation->GetPreStepPosition();
239 } 241 }
240 242
241 243