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 // G4SmartTrackStack class implementation << 27 // 26 // 28 // Author: S.Kamperis - 4 October 2012 << 27 // 29 // ------------------------------------------- << 30 28 31 #include "G4SmartTrackStack.hh" 29 #include "G4SmartTrackStack.hh" 32 #include "G4VTrajectory.hh" 30 #include "G4VTrajectory.hh" 33 #include "G4Track.hh" 31 #include "G4Track.hh" 34 32 35 void G4SmartTrackStack::dumpStatistics() 33 void G4SmartTrackStack::dumpStatistics() 36 { 34 { 37 // Print to stderr so that we can split stat << 35 // Print to stderr so that we can split stats output from normal 38 // output of Geant4 which is typically being << 36 // output of Geant4 which is typically being printed to stdout 39 for (G4int i=0; i<nTurn; ++i) << 37 for (int i = 0; i < nTurn; i++) { 40 { << 38 G4cerr << stacks[i]->GetNTrack() << " "; 41 G4cerr << stacks[i]->GetNTrack() << " "; << 39 G4cerr << stacks[i]->getTotalEnergy() << " "; 42 G4cerr << stacks[i]->getTotalEnergy() << " << 40 } 43 } << 41 G4cerr << G4endl; 44 G4cerr << G4endl; << 42 } >> 43 >> 44 G4SmartTrackStack::G4SmartTrackStack() >> 45 :fTurn(0), nTurn(5), maxNTracks(0), nTracks(0) >> 46 { >> 47 for(int i=0;i<nTurn;i++) >> 48 { >> 49 stacks[i] = new G4TrackStack(5000); >> 50 energies[i] = 0.; >> 51 } 45 } 52 } 46 53 47 G4SmartTrackStack::G4SmartTrackStack() << 54 G4SmartTrackStack::~G4SmartTrackStack() 48 { 55 { 49 for(G4int i=0; i<nTurn; ++i) << 56 for (int i = 0; i < nTurn; i++) { 50 { << 57 delete stacks[i]; 51 stacks[i] = new G4TrackStack(5000); << 58 } 52 energies[i] = 0.; << 53 } << 54 } 59 } 55 60 56 G4SmartTrackStack::~G4SmartTrackStack() << 61 const G4SmartTrackStack & 57 { << 62 G4SmartTrackStack::operator=(const G4SmartTrackStack &) { 58 for (auto* sp : stacks) << 63 return *this; 59 { << 64 } 60 delete sp; << 65 61 } << 66 G4bool G4SmartTrackStack::operator==(const G4SmartTrackStack &right) const { >> 67 return (this==&right); >> 68 } >> 69 >> 70 G4bool G4SmartTrackStack::operator!=(const G4SmartTrackStack &right) const { >> 71 return (this!=&right); 62 } 72 } 63 73 64 void G4SmartTrackStack::TransferTo(G4TrackStac 74 void G4SmartTrackStack::TransferTo(G4TrackStack* aStack) 65 { 75 { 66 for (auto* sp : stacks) << 76 for (int i = 0; i < nTurn; i++) { 67 { << 77 stacks[i]->TransferTo(aStack); 68 sp->TransferTo(aStack); << 78 } 69 } << 70 nTracks = 0; 79 nTracks = 0; 71 } 80 } 72 81 73 G4StackedTrack G4SmartTrackStack::PopFromStack 82 G4StackedTrack G4SmartTrackStack::PopFromStack() 74 { 83 { 75 G4StackedTrack aStackedTrack; << 84 G4StackedTrack aStackedTrack; 76 85 77 if (nTracks != 0) << 86 if (nTracks) { 78 { << 87 while (true) { 79 while (true) << 88 if (stacks[fTurn]->GetNTrack()) { 80 { << 89 aStackedTrack = stacks[fTurn]->PopFromStack(); 81 if (stacks[fTurn]->GetNTrack() != 0u) << 90 energies[fTurn] -= aStackedTrack.GetTrack()->GetDynamicParticle()->GetTotalEnergy(); 82 { << 91 nTracks--; 83 aStackedTrack = stacks[fTurn]->PopFrom << 84 energies[fTurn] -= aStackedTrack.GetTr << 85 --nTracks; << 86 break; 92 break; 87 } << 93 } else { 88 << 94 fTurn = (fTurn+1) % nTurn; 89 fTurn = (fTurn+1) % nTurn; << 95 } 90 } << 96 } 91 } << 97 } 92 98 93 return aStackedTrack; << 99 // dumpStatistics(); >> 100 return aStackedTrack; 94 } 101 } 95 102 96 enum << 103 enum { 97 { << 98 electronCode = 11, positronCode = -11, gamma 104 electronCode = 11, positronCode = -11, gammaCode = 22, neutronCode = 2112 99 }; 105 }; 100 106 101 void G4SmartTrackStack::PushToStack( const G4S 107 void G4SmartTrackStack::PushToStack( const G4StackedTrack& aStackedTrack ) 102 { 108 { 103 109 104 G4int iDest = 0; 110 G4int iDest = 0; 105 if (aStackedTrack.GetTrack()->GetParentID() << 111 if (aStackedTrack.GetTrack()->GetParentID()) { 106 { << 107 G4int code = aStackedTrack.GetTrack()->Get 112 G4int code = aStackedTrack.GetTrack()->GetDynamicParticle()->GetPDGcode(); 108 if (code == electronCode) 113 if (code == electronCode) 109 iDest = 2; 114 iDest = 2; 110 else if (code == gammaCode) 115 else if (code == gammaCode) 111 iDest = 3; 116 iDest = 3; 112 else if (code == positronCode) 117 else if (code == positronCode) 113 iDest = 4; 118 iDest = 4; 114 else if (code == neutronCode) 119 else if (code == neutronCode) 115 iDest = 1; 120 iDest = 1; 116 } << 121 } else { 117 else << 118 { << 119 // We have a primary track, which should g 122 // We have a primary track, which should go first. 120 fTurn = 0; // reseting the turn 123 fTurn = 0; // reseting the turn 121 } 124 } 122 stacks[iDest]->PushToStack(aStackedTrack); 125 stacks[iDest]->PushToStack(aStackedTrack); 123 energies[iDest] += aStackedTrack.GetTrack()- 126 energies[iDest] += aStackedTrack.GetTrack()->GetDynamicParticle()->GetTotalEnergy(); 124 ++nTracks; << 127 nTracks++; 125 128 126 G4long dy1 = stacks[iDest]->GetNTrack() - st << 129 G4int dy1 = stacks[iDest]->GetNTrack() - stacks[iDest]->GetSafetyValve1(); 127 G4long dy2 = stacks[fTurn]->GetNTrack() - st << 130 G4int dy2 = stacks[fTurn]->GetNTrack() - stacks[fTurn]->GetSafetyValve2(); 128 131 129 if (dy1 > 0 || dy1 > dy2 || 132 if (dy1 > 0 || dy1 > dy2 || 130 (iDest == 2 && 133 (iDest == 2 && 131 stacks[iDest]->GetNTrack() < 50 && ener << 134 stacks[iDest]->GetNTrack() < 50 && energies[iDest] < energies[fTurn])) { 132 { << 135 fTurn = iDest; 133 fTurn = iDest; << 136 } 134 } << 135 137 136 if (nTracks > maxNTracks) maxNTracks = nTrac 138 if (nTracks > maxNTracks) maxNTracks = nTracks; 137 } 139 } 138 140 139 void G4SmartTrackStack::clear() 141 void G4SmartTrackStack::clear() 140 { 142 { 141 for (G4int i = 0; i < nTurn; ++i) << 143 for (int i = 0; i < nTurn; i++) { 142 { << 143 stacks[i]->clear(); 144 stacks[i]->clear(); 144 energies[i] = 0.0; 145 energies[i] = 0.0; 145 fTurn = 0; 146 fTurn = 0; 146 } 147 } 147 nTracks = 0; 148 nTracks = 0; 148 } 149 } 149 150 150 void G4SmartTrackStack::clearAndDestroy() 151 void G4SmartTrackStack::clearAndDestroy() 151 { 152 { 152 for (G4int i = 0; i < nTurn; ++i) << 153 for (int i = 0; i < nTurn; i++) { 153 { << 154 stacks[i]->clearAndDestroy(); 154 stacks[i]->clearAndDestroy(); 155 energies[i] = 0.0; 155 energies[i] = 0.0; 156 fTurn = 0; 156 fTurn = 0; 157 } 157 } 158 nTracks = 0; 158 nTracks = 0; 159 } 159 } 160 160