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 // This example is provided by the Geant4-DNA 26 // This example is provided by the Geant4-DNA collaboration 27 // Any report or published results obtained us 27 // Any report or published results obtained using the Geant4-DNA software 28 // shall cite the following Geant4-DNA collabo 28 // shall cite the following Geant4-DNA collaboration publication: 29 // Med. Phys. 37 (2010) 4692-4708 29 // Med. Phys. 37 (2010) 4692-4708 30 // and papers 30 // and papers 31 // M. Batmunkh et al. J Radiat Res Appl Sci 8 31 // M. Batmunkh et al. J Radiat Res Appl Sci 8 (2015) 498-507 32 // O. Belov et al. Physica Medica 32 (2016) 15 32 // O. Belov et al. Physica Medica 32 (2016) 1510-1520 33 // The Geant4-DNA web site is available at htt 33 // The Geant4-DNA web site is available at http://geant4-dna.org 34 // << 34 // 35 // ------------------------------------------- 35 // ------------------------------------------------------------------- 36 // November 2016 36 // November 2016 37 // ------------------------------------------- 37 // ------------------------------------------------------------------- 38 // 38 // 39 // 39 // 40 /// \file ITTrackingInteractivity.hh 40 /// \file ITTrackingInteractivity.hh 41 /// \brief Implementation of the ITTrackingInt 41 /// \brief Implementation of the ITTrackingInteractivity class 42 42 43 #include "ITTrackingInteractivity.hh" 43 #include "ITTrackingInteractivity.hh" 44 << 45 #include "G4Event.hh" << 46 #include "G4EventManager.hh" << 47 #include "G4IT.hh" << 48 #include "G4RichTrajectory.hh" << 49 #include "G4SmoothTrajectory.hh" << 50 #include "G4TrackingInformation.hh" 44 #include "G4TrackingInformation.hh" >> 45 #include "G4VTrajectory.hh" 51 #include "G4Trajectory.hh" 46 #include "G4Trajectory.hh" 52 #include "G4UserSteppingAction.hh" << 47 #include "G4SmoothTrajectory.hh" >> 48 #include "G4RichTrajectory.hh" 53 #include "G4UserTrackingAction.hh" 49 #include "G4UserTrackingAction.hh" >> 50 #include "G4UserSteppingAction.hh" >> 51 #include "G4IT.hh" >> 52 #include "G4EventManager.hh" >> 53 #include "G4Event.hh" 54 #include "G4VSteppingVerbose.hh" 54 #include "G4VSteppingVerbose.hh" 55 #include "G4VTrajectory.hh" << 56 #include "G4VisManager.hh" 55 #include "G4VisManager.hh" 57 56 58 class G4Trajectory_Lock 57 class G4Trajectory_Lock 59 { 58 { 60 friend class ITTrackingInteractivity; << 59 friend class ITTrackingInteractivity; 61 60 62 G4Trajectory_Lock() : fpTrajectory(0) { ; << 61 G4Trajectory_Lock(): fpTrajectory(0) >> 62 {;} 63 63 64 ~G4Trajectory_Lock() { ; } << 64 ~G4Trajectory_Lock() >> 65 {;} 65 66 66 G4VTrajectory* fpTrajectory; << 67 G4VTrajectory* fpTrajectory; 67 }; 68 }; 68 69 69 ITTrackingInteractivity::ITTrackingInteractivi 70 ITTrackingInteractivity::ITTrackingInteractivity() 70 { 71 { 71 fStoreTrajectory = 0; 72 fStoreTrajectory = 0; 72 fVerboseLevel = 0; 73 fVerboseLevel = 0; 73 74 74 fpUserTrackingAction = 0; << 75 fpUserTrackingAction = 0; 75 fpUserSteppingAction = 0; 76 fpUserSteppingAction = 0; 76 77 77 //////////////////////////// 78 //////////////////////////// 78 // In case you want to use same tracking/ste 79 // In case you want to use same tracking/stepping action 79 // for normal and IT stepping 80 // for normal and IT stepping 80 /* 81 /* 81 fpUserTrackingAction = 82 fpUserTrackingAction = 82 trackingManager->GetUserTrackingAction() 83 trackingManager->GetUserTrackingAction(); 83 fpUserSteppingAction = 84 fpUserSteppingAction = 84 G4EventManager::GetEventManager()->GetUs 85 G4EventManager::GetEventManager()->GetUserSteppingAction(); 85 */ 86 */ 86 //////////////////////////// 87 //////////////////////////// 87 } 88 } 88 89 89 //....oooOO0OOooo........oooOO0OOooo........oo 90 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 90 91 91 ITTrackingInteractivity::~ITTrackingInteractiv 92 ITTrackingInteractivity::~ITTrackingInteractivity() 92 { 93 { 93 G4EventManager* eventManager = G4EventManage << 94 G4EventManager* eventManager = >> 95 G4EventManager::GetEventManager(); 94 96 95 if (eventManager) { << 97 if (eventManager) 96 G4UserTrackingAction* std_trackAct = event << 98 { 97 if (fpUserTrackingAction != std_trackAct & << 99 G4UserTrackingAction* std_trackAct = 98 << 100 eventManager->GetUserTrackingAction(); 99 G4UserSteppingAction* std_stepAct = eventM << 101 if(fpUserTrackingAction != std_trackAct && fpUserTrackingAction) 100 if (fpUserSteppingAction != std_stepAct && << 102 delete fpUserTrackingAction; >> 103 >> 104 G4UserSteppingAction* std_stepAct = >> 105 eventManager->GetUserSteppingAction(); >> 106 if(fpUserSteppingAction != std_stepAct && fpUserSteppingAction) >> 107 delete fpUserSteppingAction; 101 } 108 } 102 else { << 109 else 103 if (fpUserSteppingAction) { << 110 { >> 111 if(fpUserSteppingAction) >> 112 { 104 delete fpUserSteppingAction; 113 delete fpUserSteppingAction; 105 } 114 } 106 << 115 107 if (fpUserTrackingAction) { << 116 if(fpUserTrackingAction) >> 117 { 108 delete fpUserTrackingAction; 118 delete fpUserTrackingAction; 109 } 119 } 110 } 120 } 111 } 121 } 112 122 113 //....oooOO0OOooo........oooOO0OOooo........oo 123 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 114 124 115 void ITTrackingInteractivity::Initialize() 125 void ITTrackingInteractivity::Initialize() 116 { 126 { 117 G4TrackingManager* trackingManager = G4Event << 127 G4TrackingManager* trackingManager = >> 128 G4EventManager::GetEventManager()->GetTrackingManager(); 118 fStoreTrajectory = trackingManager->GetStore 129 fStoreTrajectory = trackingManager->GetStoreTrajectory(); 119 fVerboseLevel = trackingManager->GetVerboseL 130 fVerboseLevel = trackingManager->GetVerboseLevel(); 120 } 131 } 121 132 122 //....oooOO0OOooo........oooOO0OOooo........oo 133 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 123 134 124 void ITTrackingInteractivity::StartTracking(G4 135 void ITTrackingInteractivity::StartTracking(G4Track* track) 125 { 136 { 126 #ifdef G4VERBOSE 137 #ifdef G4VERBOSE 127 if (fVerboseLevel) { << 138 if(fVerboseLevel) >> 139 { 128 TrackBanner(track, "G4ITTrackingManager::S 140 TrackBanner(track, "G4ITTrackingManager::StartTracking : "); 129 } 141 } 130 #endif 142 #endif 131 143 132 if (fVerboseLevel > 0 && (G4VSteppingVerbose << 144 if(fVerboseLevel>0 && (G4VSteppingVerbose::GetSilent()!=1) ) >> 145 TrackBanner(track); 133 146 134 // Pre tracking user intervention process. 147 // Pre tracking user intervention process. 135 if (fpUserTrackingAction != 0) { << 148 if( fpUserTrackingAction != 0 ) { 136 fpUserTrackingAction->PreUserTrackingActio 149 fpUserTrackingAction->PreUserTrackingAction(track); 137 } 150 } 138 // #ifdef G4_STORE_TRAJECTORY << 151 //#ifdef G4_STORE_TRAJECTORY 139 G4TrackingInformation* trackingInfo = GetIT( 152 G4TrackingInformation* trackingInfo = GetIT(track)->GetTrackingInfo(); 140 G4Trajectory_Lock* trajectory_lock = trackin << 153 G4Trajectory_Lock* trajectory_lock = >> 154 trackingInfo->GetTrajectory_Lock(); 141 155 142 // Construct a trajectory if it is requested 156 // Construct a trajectory if it is requested 143 if (fStoreTrajectory && (!trajectory_lock)) << 157 if(fStoreTrajectory&&(!trajectory_lock)) >> 158 { 144 trajectory_lock = new G4Trajectory_Lock(); 159 trajectory_lock = new G4Trajectory_Lock(); 145 trackingInfo->SetTrajectory_Lock(trajector 160 trackingInfo->SetTrajectory_Lock(trajectory_lock); 146 G4VTrajectory* trajectory = 0; 161 G4VTrajectory* trajectory = 0; 147 // default trajectory concrete class objec 162 // default trajectory concrete class object 148 switch (fStoreTrajectory) { 163 switch (fStoreTrajectory) { 149 default: 164 default: 150 case 1: << 165 case 1: trajectory = new G4Trajectory(track); break; 151 trajectory = new G4Trajectory(track); << 166 case 2: trajectory = new G4SmoothTrajectory(track); break; 152 break; << 167 case 3: trajectory = new G4RichTrajectory(track); break; 153 case 2: << 154 trajectory = new G4SmoothTrajectory(tr << 155 break; << 156 case 3: << 157 trajectory = new G4RichTrajectory(trac << 158 break; << 159 } 168 } 160 trajectory_lock->fpTrajectory = trajectory 169 trajectory_lock->fpTrajectory = trajectory; 161 } 170 } 162 // #endif << 171 //#endif 163 } 172 } 164 173 165 //....oooOO0OOooo........oooOO0OOooo........oo 174 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 166 175 167 void ITTrackingInteractivity::AppendStep(G4Tra << 176 void >> 177 ITTrackingInteractivity::AppendStep(G4Track* track, G4Step* step) 168 { 178 { 169 //////////////////////////// 179 //////////////////////////// 170 // If you want to use sensitive detector 180 // If you want to use sensitive detector 171 /* 181 /* 172 G4VPhysicalVolume* currentVolume = 182 G4VPhysicalVolume* currentVolume = 173 step->GetPreStepPoint()->GetPhysicalVolume 183 step->GetPreStepPoint()->GetPhysicalVolume(); 174 G4SteppingControl stepControlFlag = step- 184 G4SteppingControl stepControlFlag = step->GetControlFlag(); 175 185 176 if( currentVolume != 0 && stepControlFlag 186 if( currentVolume != 0 && stepControlFlag != AvoidHitInvocation) 177 { 187 { 178 G4VSensitiveDetector* sensitive = step 188 G4VSensitiveDetector* sensitive = step->GetPreStepPoint()-> 179 GetSensitiveDetector(); 189 GetSensitiveDetector(); 180 if( sensitive != 0 ) 190 if( sensitive != 0 ) 181 { 191 { 182 sensitive->Hit(fpStep); 192 sensitive->Hit(fpStep); 183 } 193 } 184 } 194 } 185 */ 195 */ 186 //////////////////////////// 196 //////////////////////////// 187 197 188 if (fpUserSteppingAction) fpUserSteppingActi << 198 if(fpUserSteppingAction) >> 199 fpUserSteppingAction->UserSteppingAction(step); 189 200 190 //////////////////////////// 201 //////////////////////////// 191 // If you want to use regional stepping acti 202 // If you want to use regional stepping action 192 /* 203 /* 193 G4UserSteppingAction* regionalAction 204 G4UserSteppingAction* regionalAction 194 = fpStep->GetPreStepPoint()->GetPh 205 = fpStep->GetPreStepPoint()->GetPhysicalVolume()-> 195 GetLogicalVolume()->GetRegio 206 GetLogicalVolume()->GetRegion()-> 196 GetRegionalSteppingAction(); 207 GetRegionalSteppingAction(); 197 if( regionalAction ) regionalAction->UserS 208 if( regionalAction ) regionalAction->UserSteppingAction(fpStep); 198 */ 209 */ 199 //////////////////////////// 210 //////////////////////////// 200 211 201 if (fStoreTrajectory) { << 212 if(fStoreTrajectory) 202 G4TrackingInformation* trackingInfo = GetI << 213 { 203 G4Trajectory_Lock* trajectory_lock = track << 214 G4TrackingInformation* trackingInfo = >> 215 GetIT(track)->GetTrackingInfo(); >> 216 G4Trajectory_Lock* trajectory_lock = >> 217 trackingInfo->GetTrajectory_Lock(); 204 trajectory_lock->fpTrajectory->AppendStep( 218 trajectory_lock->fpTrajectory->AppendStep(step); 205 } 219 } 206 } 220 } 207 221 208 //....oooOO0OOooo........oooOO0OOooo........oo 222 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 209 223 210 void ITTrackingInteractivity::EndTracking(G4Tr 224 void ITTrackingInteractivity::EndTracking(G4Track* track) 211 { 225 { 212 #ifdef G4VERBOSE 226 #ifdef G4VERBOSE 213 if (fVerboseLevel) { << 227 if(fVerboseLevel) >> 228 { 214 TrackBanner(track, "G4ITTrackingManager::E 229 TrackBanner(track, "G4ITTrackingManager::EndTracking : "); 215 } 230 } 216 #endif 231 #endif 217 // Post tracking user intervention process. 232 // Post tracking user intervention process. 218 if (fpUserTrackingAction != 0) { << 233 if( fpUserTrackingAction != 0 ) { 219 fpUserTrackingAction->PostUserTrackingActi 234 fpUserTrackingAction->PostUserTrackingAction(track); 220 } 235 } 221 236 222 // #ifdef G4_STORE_TRAJECTORY << 237 //#ifdef G4_STORE_TRAJECTORY 223 G4TrackingInformation* trackingInfo = GetIT( << 238 G4TrackingInformation* trackingInfo = 224 G4Trajectory_Lock* trajectory_lock = trackin << 239 GetIT(track)->GetTrackingInfo(); >> 240 G4Trajectory_Lock* trajectory_lock = >> 241 trackingInfo->GetTrajectory_Lock(); 225 242 226 if (trajectory_lock) { << 243 if(trajectory_lock) >> 244 { 227 G4VTrajectory*& trajectory = trajectory_lo 245 G4VTrajectory*& trajectory = trajectory_lock->fpTrajectory; 228 246 229 if (fStoreTrajectory && trajectory) { << 247 if(fStoreTrajectory && trajectory) >> 248 { >> 249 230 #ifdef G4VERBOSE 250 #ifdef G4VERBOSE 231 if (fVerboseLevel > 10) trajectory->Show << 251 if(fVerboseLevel>10) trajectory->ShowTrajectory(); 232 #endif 252 #endif 233 G4TrackStatus istop = track->GetTrackSta 253 G4TrackStatus istop = track->GetTrackStatus(); 234 254 235 if (trajectory && (istop != fStopButAliv << 255 if (trajectory && (istop != fStopButAlive) && (istop != fSuspend)) 236 G4Event* currentEvent = G4EventManager << 256 { >> 257 G4Event* currentEvent = G4EventManager::GetEventManager() >> 258 ->GetNonconstCurrentEvent(); 237 259 238 if (currentEvent) { << 260 if (currentEvent) 239 G4TrajectoryContainer* trajectoryCon << 261 { >> 262 G4TrajectoryContainer* trajectoryContainer = currentEvent >> 263 ->GetTrajectoryContainer(); 240 264 241 if (!trajectoryContainer) { << 265 if (!trajectoryContainer) >> 266 { 242 trajectoryContainer = new G4Trajec 267 trajectoryContainer = new G4TrajectoryContainer; 243 currentEvent->SetTrajectoryContain 268 currentEvent->SetTrajectoryContainer(trajectoryContainer); 244 } 269 } 245 trajectoryContainer->insert(trajecto 270 trajectoryContainer->insert(trajectory); 246 } 271 } 247 else { << 272 else >> 273 { 248 fTrajectories.push_back(trajectory); 274 fTrajectories.push_back(trajectory); 249 } 275 } 250 } 276 } 251 } 277 } 252 // Destruct the trajectory if it was creat 278 // Destruct the trajectory if it was created 253 else if ((!fStoreTrajectory) && trajectory << 279 else if( (!fStoreTrajectory)&&trajectory ) { 254 delete trajectory; 280 delete trajectory; 255 trajectory = 0; 281 trajectory = 0; 256 } 282 } 257 delete trajectory_lock; 283 delete trajectory_lock; 258 trackingInfo->SetTrajectory_Lock(0); 284 trackingInfo->SetTrajectory_Lock(0); 259 } 285 } 260 // #endif << 286 //#endif 261 } 287 } 262 288 263 void ITTrackingInteractivity::Finalize() 289 void ITTrackingInteractivity::Finalize() 264 { 290 { 265 for (std::vector<G4VTrajectory*>::iterator i << 291 for (std::vector<G4VTrajectory*>::iterator it = fTrajectories.begin(); 266 it++) << 292 it != fTrajectories.end(); it++) 267 { 293 { 268 G4VisManager::GetConcreteInstance()->Draw( 294 G4VisManager::GetConcreteInstance()->Draw(**it); 269 } 295 } 270 } 296 } 271 297