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 // G4TrackingManager class implementation 26 // G4TrackingManager class implementation 27 // 27 // 28 // Contact: 28 // Contact: 29 // Questions and comments to this code shoul 29 // Questions and comments to this code should be sent to 30 // Katsuya Amako (e-mail: Katsuya.Amako@k 30 // Katsuya Amako (e-mail: Katsuya.Amako@kek.jp) 31 // Takashi Sasaki (e-mail: Takashi.Sasaki@ 31 // Takashi Sasaki (e-mail: Takashi.Sasaki@kek.jp) 32 // ------------------------------------------- 32 // -------------------------------------------------------------------- 33 33 34 #include "G4TrackingManager.hh" 34 #include "G4TrackingManager.hh" 35 35 36 #include "G4Trajectory.hh" << 36 #include "G4Profiler.hh" 37 #include "G4RichTrajectory.hh" 37 #include "G4RichTrajectory.hh" 38 #include "G4SmoothTrajectory.hh" 38 #include "G4SmoothTrajectory.hh" >> 39 #include "G4TiMemory.hh" >> 40 #include "G4Trajectory.hh" 39 #include "G4ios.hh" 41 #include "G4ios.hh" 40 42 41 ////////////////////////////////////// 43 ////////////////////////////////////// 42 G4TrackingManager::G4TrackingManager() 44 G4TrackingManager::G4TrackingManager() 43 ////////////////////////////////////// 45 ////////////////////////////////////// 44 { 46 { 45 messenger = new G4TrackingMessenger(this); 47 messenger = new G4TrackingMessenger(this); 46 fpSteppingManager = new G4SteppingManager(); 48 fpSteppingManager = new G4SteppingManager(); 47 } 49 } 48 50 49 /////////////////////////////////////// 51 /////////////////////////////////////// 50 G4TrackingManager::~G4TrackingManager() 52 G4TrackingManager::~G4TrackingManager() 51 /////////////////////////////////////// 53 /////////////////////////////////////// 52 { 54 { 53 delete messenger; 55 delete messenger; 54 delete fpSteppingManager; 56 delete fpSteppingManager; 55 delete fpUserTrackingAction; 57 delete fpUserTrackingAction; 56 } 58 } 57 59 58 ////////////////////////////////////////////// 60 //////////////////////////////////////////////////////////////// 59 void G4TrackingManager::ProcessOneTrack(G4Trac 61 void G4TrackingManager::ProcessOneTrack(G4Track* apValueG4Track) 60 ////////////////////////////////////////////// 62 //////////////////////////////////////////////////////////////// 61 { 63 { 62 // Receiving a G4Track from the EventManager 64 // Receiving a G4Track from the EventManager, this funciton has the 63 // responsibility to trace the track till it 65 // responsibility to trace the track till it stops 64 66 65 fpTrack = apValueG4Track; 67 fpTrack = apValueG4Track; 66 EventIsAborted = false; 68 EventIsAborted = false; 67 69 68 // Clear secondary particle vector 70 // Clear secondary particle vector 69 // 71 // 70 for (auto& itr : *GimmeSecondaries()) { 72 for (auto& itr : *GimmeSecondaries()) { 71 delete itr; 73 delete itr; 72 } 74 } 73 GimmeSecondaries()->clear(); 75 GimmeSecondaries()->clear(); 74 76 75 if (verboseLevel > 0 && (G4VSteppingVerbose: 77 if (verboseLevel > 0 && (G4VSteppingVerbose::GetSilent() != 1)) TrackBanner(); 76 78 77 // Give SteppingManger the pointer to the tr 79 // Give SteppingManger the pointer to the track which will be tracked 78 // 80 // 79 fpSteppingManager->SetInitialStep(fpTrack); 81 fpSteppingManager->SetInitialStep(fpTrack); 80 82 81 // Pre tracking user intervention process 83 // Pre tracking user intervention process 82 84 83 fpTrajectory = nullptr; 85 fpTrajectory = nullptr; 84 if (fpUserTrackingAction != nullptr) { 86 if (fpUserTrackingAction != nullptr) { 85 fpUserTrackingAction->PreUserTrackingActio 87 fpUserTrackingAction->PreUserTrackingAction(fpTrack); 86 } 88 } 87 89 88 // we need this to scope the G4Track::Profil 90 // we need this to scope the G4Track::ProfilerConfig b/t 89 // the PreUserTrackingAction and PostUserTra 91 // the PreUserTrackingAction and PostUserTrackingAction 90 { 92 { >> 93 #if defined(GEANT4_USE_TIMEMORY) >> 94 ProfilerConfig profiler{fpTrack}; >> 95 #endif >> 96 91 #ifdef G4_STORE_TRAJECTORY 97 #ifdef G4_STORE_TRAJECTORY 92 // Construct a trajectory if it is request 98 // Construct a trajectory if it is requested 93 // 99 // 94 if ((StoreTrajectory != 0) && (fpTrajector 100 if ((StoreTrajectory != 0) && (fpTrajectory == nullptr)) { 95 // default trajectory concrete class obj 101 // default trajectory concrete class object 96 switch (StoreTrajectory) { 102 switch (StoreTrajectory) { 97 default: 103 default: 98 case 1: 104 case 1: 99 fpTrajectory = new G4Trajectory(fpTr 105 fpTrajectory = new G4Trajectory(fpTrack); 100 break; 106 break; 101 case 2: 107 case 2: 102 fpTrajectory = new G4SmoothTrajector 108 fpTrajectory = new G4SmoothTrajectory(fpTrack); 103 break; 109 break; 104 case 3: 110 case 3: 105 fpTrajectory = new G4RichTrajectory( 111 fpTrajectory = new G4RichTrajectory(fpTrack); 106 break; 112 break; 107 case 4: 113 case 4: 108 fpTrajectory = new G4RichTrajectory( 114 fpTrajectory = new G4RichTrajectory(fpTrack); 109 break; 115 break; 110 } 116 } 111 } 117 } 112 #endif 118 #endif 113 119 114 // Give SteppingManger the maxmimum number 120 // Give SteppingManger the maxmimum number of processes 115 fpSteppingManager->GetProcessNumber(); 121 fpSteppingManager->GetProcessNumber(); 116 122 117 // Give track the pointer to the Step 123 // Give track the pointer to the Step 118 fpTrack->SetStep(fpSteppingManager->GetSte 124 fpTrack->SetStep(fpSteppingManager->GetStep()); 119 125 120 // Inform beginning of tracking to physics 126 // Inform beginning of tracking to physics processes 121 fpTrack->GetDefinition()->GetProcessManage 127 fpTrack->GetDefinition()->GetProcessManager()->StartTracking(fpTrack); 122 128 123 // Track the particle Step-by-Step while i 129 // Track the particle Step-by-Step while it is alive 124 // 130 // 125 while ((fpTrack->GetTrackStatus() == fAliv 131 while ((fpTrack->GetTrackStatus() == fAlive) || (fpTrack->GetTrackStatus() == fStopButAlive)) { 126 fpTrack->IncrementCurrentStepNumber(); 132 fpTrack->IncrementCurrentStepNumber(); 127 fpSteppingManager->Stepping(); 133 fpSteppingManager->Stepping(); 128 #ifdef G4_STORE_TRAJECTORY 134 #ifdef G4_STORE_TRAJECTORY 129 if (StoreTrajectory != 0) { 135 if (StoreTrajectory != 0) { 130 fpTrajectory->AppendStep(fpSteppingMan 136 fpTrajectory->AppendStep(fpSteppingManager->GetStep()); 131 } 137 } 132 #endif 138 #endif 133 if (EventIsAborted) { 139 if (EventIsAborted) { 134 fpTrack->SetTrackStatus(fKillTrackAndS 140 fpTrack->SetTrackStatus(fKillTrackAndSecondaries); 135 } 141 } 136 } 142 } 137 // Inform end of tracking to physics proce 143 // Inform end of tracking to physics processes 138 fpTrack->GetDefinition()->GetProcessManage 144 fpTrack->GetDefinition()->GetProcessManager()->EndTracking(); 139 } 145 } 140 146 141 // Post tracking user intervention process. 147 // Post tracking user intervention process. 142 if (fpUserTrackingAction != nullptr) { 148 if (fpUserTrackingAction != nullptr) { 143 fpUserTrackingAction->PostUserTrackingActi 149 fpUserTrackingAction->PostUserTrackingAction(fpTrack); 144 } 150 } 145 151 146 // Destruct the trajectory if it was created 152 // Destruct the trajectory if it was created 147 #ifdef G4VERBOSE 153 #ifdef G4VERBOSE 148 if ((StoreTrajectory != 0) && verboseLevel > 154 if ((StoreTrajectory != 0) && verboseLevel > 10) { 149 fpTrajectory->ShowTrajectory(); 155 fpTrajectory->ShowTrajectory(); 150 } 156 } 151 #endif 157 #endif 152 if ((StoreTrajectory == 0) && (fpTrajectory 158 if ((StoreTrajectory == 0) && (fpTrajectory != nullptr)) { 153 delete fpTrajectory; 159 delete fpTrajectory; 154 fpTrajectory = nullptr; 160 fpTrajectory = nullptr; 155 } 161 } 156 } 162 } 157 163 158 ////////////////////////////////////// 164 ////////////////////////////////////// 159 void G4TrackingManager::SetTrajectory(G4VTraje 165 void G4TrackingManager::SetTrajectory(G4VTrajectory* aTrajectory) 160 ////////////////////////////////////// 166 ////////////////////////////////////// 161 { 167 { 162 #ifndef G4_STORE_TRAJECTORY 168 #ifndef G4_STORE_TRAJECTORY 163 G4Exception("G4TrackingManager::SetTrajector 169 G4Exception("G4TrackingManager::SetTrajectory()", "Tracking0015", FatalException, 164 "Invoked without G4_STORE_TRAJECTORY optio 170 "Invoked without G4_STORE_TRAJECTORY option set!"); 165 #endif 171 #endif 166 fpTrajectory = aTrajectory; 172 fpTrajectory = aTrajectory; 167 } 173 } 168 174 169 ////////////////////////////////////// 175 ////////////////////////////////////// 170 void G4TrackingManager::EventAborted() 176 void G4TrackingManager::EventAborted() 171 ////////////////////////////////////// 177 ////////////////////////////////////// 172 { 178 { 173 fpTrack->SetTrackStatus(fKillTrackAndSeconda 179 fpTrack->SetTrackStatus(fKillTrackAndSecondaries); 174 EventIsAborted = true; 180 EventIsAborted = true; 175 } 181 } 176 182 177 ////////////////////////////////////// 183 ////////////////////////////////////// 178 void G4TrackingManager::TrackBanner() 184 void G4TrackingManager::TrackBanner() 179 ////////////////////////////////////// 185 ////////////////////////////////////// 180 { 186 { 181 G4cout << G4endl; 187 G4cout << G4endl; 182 G4cout << "********************************* 188 G4cout << "*******************************************************" 183 << "********************************* 189 << "**************************************************" << G4endl; 184 G4cout << "* G4Track Information: " 190 G4cout << "* G4Track Information: " 185 << " Particle = " << fpTrack->GetDef 191 << " Particle = " << fpTrack->GetDefinition()->GetParticleName() << "," 186 << " Track ID = " << fpTrack->GetTr 192 << " Track ID = " << fpTrack->GetTrackID() << "," 187 << " Parent ID = " << fpTrack->GetP 193 << " Parent ID = " << fpTrack->GetParentID() << G4endl; 188 G4cout << "********************************* 194 G4cout << "*******************************************************" 189 << "********************************* 195 << "**************************************************" << G4endl; 190 G4cout << G4endl; 196 G4cout << G4endl; 191 } 197 } 192 << 193 ////////////////////////////////////// << 194 void G4TrackingManager::SetStoreTrajectory(G4i << 195 ////////////////////////////////////// << 196 { << 197 StoreTrajectory = value; << 198 } << 199 << 200 198