Geant4 Cross Reference |
1 // 1 // 2 // ******************************************* 2 // ******************************************************************** 3 // * License and Disclaimer << 3 // * DISCLAIMER * 4 // * 4 // * * 5 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers * 6 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which * 7 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: * 8 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license * 9 // * include a list of copyright holders. << 10 // * 9 // * * 11 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing * 12 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this * 13 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, * 14 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its * 15 // * use. Please see the license in the file << 14 // * use. * 16 // * for the full disclaimer and the limitatio << 17 // * 15 // * * 18 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the * 19 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. * 20 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work * 21 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this * 22 // * use in resulting scientific publicati << 20 // * statement, and all its terms. * 23 // * acceptance of all terms of the Geant4 Sof << 24 // ******************************************* 21 // ******************************************************************** 25 // 22 // 26 // G4ParticleChangeForDecay class implementati << 27 // 23 // 28 // Author: Hisaya Kurashige, 23 March 1998 << 24 // $Id: G4ParticleChangeForDecay.cc,v 1.9 2003/06/19 14:45:07 gunter Exp $ 29 // ------------------------------------------- << 25 // GEANT4 tag $Name: geant4-06-00-patch-01 $ >> 26 // >> 27 // >> 28 // -------------------------------------------------------------- >> 29 // GEANT 4 class implementation file >> 30 // >> 31 // >> 32 // >> 33 // ------------------------------------------------------------ >> 34 // Implemented for the new scheme 23 Mar. 1998 H.Kurahige >> 35 // Remove modification of energy/momentum 20 Jul, 1998 H.Kurashige >> 36 // -------------------------------------------------------------- 30 37 31 #include "G4ParticleChangeForDecay.hh" 38 #include "G4ParticleChangeForDecay.hh" 32 #include "G4SystemOfUnits.hh" << 33 #include "G4Track.hh" 39 #include "G4Track.hh" 34 #include "G4Step.hh" 40 #include "G4Step.hh" >> 41 #include "G4TrackFastVector.hh" 35 #include "G4DynamicParticle.hh" 42 #include "G4DynamicParticle.hh" 36 #include "G4ExceptionSeverity.hh" 43 #include "G4ExceptionSeverity.hh" 37 44 38 // ------------------------------------------- << 45 G4ParticleChangeForDecay::G4ParticleChangeForDecay():G4VParticleChange() 39 G4ParticleChangeForDecay::G4ParticleChangeForD << 46 { 40 {} << 47 #ifdef G4VERBOSE >> 48 if (verboseLevel>2) { >> 49 G4cout << "G4ParticleChangeForDecay::G4ParticleChangeForDecay() " << G4endl; >> 50 } >> 51 #endif >> 52 } 41 53 42 // ------------------------------------------- << 54 G4ParticleChangeForDecay::~G4ParticleChangeForDecay() 43 void G4ParticleChangeForDecay::Initialize(cons << 44 { 55 { 45 // use base class's method at first << 56 #ifdef G4VERBOSE 46 G4VParticleChange::Initialize(track); << 57 if (verboseLevel>2) { >> 58 G4cout << "G4ParticleChangeForDecay::~G4ParticleChangeForDecay() " << G4endl; >> 59 } >> 60 #endif >> 61 } 47 62 48 // set TimeChange equal to local time of the << 63 // copy and assignment operators are implemented as "shallow copy" 49 theLocalTime0 = theTimeChange = track.GetLoc << 64 G4ParticleChangeForDecay::G4ParticleChangeForDecay(const G4ParticleChangeForDecay &right): G4VParticleChange(right) >> 65 { >> 66 theTimeChange = right.theTimeChange; >> 67 } 50 68 51 // set initial Local/Global time of the pare << 52 theGlobalTime0 = track.GetGlobalTime(); << 53 69 54 // set the Polarization equal to those of th << 70 G4ParticleChangeForDecay & G4ParticleChangeForDecay::operator=(const G4ParticleChangeForDecay &right) 55 thePolarizationChange = track.GetDynamicPart << 71 { >> 72 if (this != &right){ >> 73 theListOfSecondaries = right.theListOfSecondaries; >> 74 theSizeOftheListOfSecondaries = right.theSizeOftheListOfSecondaries; >> 75 theNumberOfSecondaries = right.theNumberOfSecondaries; >> 76 theStatusChange = right.theStatusChange; >> 77 theTrueStepLength = right.theTrueStepLength; >> 78 theLocalEnergyDeposit = right.theLocalEnergyDeposit; >> 79 theSteppingControlFlag = right.theSteppingControlFlag; >> 80 >> 81 theTimeChange = right.theTimeChange; >> 82 } >> 83 return *this; 56 } 84 } 57 85 58 // ------------------------------------------- << 86 G4bool G4ParticleChangeForDecay::operator==(const G4ParticleChangeForDecay &right) const 59 G4Step* G4ParticleChangeForDecay::UpdateStepFo << 60 { 87 { 61 G4StepPoint* pPostStepPoint = pStep->GetPost << 88 return ((G4VParticleChange *)this == (G4VParticleChange *) &right); >> 89 } 62 90 63 if(isParentWeightProposed) << 91 G4bool G4ParticleChangeForDecay::operator!=(const G4ParticleChangeForDecay &right) const 64 { << 92 { 65 pPostStepPoint->SetWeight(theParentWeight) << 93 return ((G4VParticleChange *)this != (G4VParticleChange *) &right); 66 } << 94 } 67 // update polarization << 95 68 pPostStepPoint->SetPolarization(thePolarizat << 96 //---------------------------------------------------------------- >> 97 // methods for Initialization >> 98 // >> 99 void G4ParticleChangeForDecay::Initialize(const G4Track& track) >> 100 { >> 101 // use base class's method at first >> 102 G4VParticleChange::Initialize(track); >> 103 >> 104 // set Time e equal to those of the parent track >> 105 theTimeChange = track.GetGlobalTime(); >> 106 } 69 107 70 // update the G4Step specific attributes << 108 //---------------------------------------------------------------- >> 109 // methods for updating G4Step >> 110 // >> 111 >> 112 G4Step* G4ParticleChangeForDecay::UpdateStepForPostStep(G4Step* pStep) >> 113 { >> 114 // Update the G4Step specific attributes 71 return UpdateStepInfo(pStep); 115 return UpdateStepInfo(pStep); 72 } 116 } 73 117 74 // ------------------------------------------- << 118 75 G4Step* G4ParticleChangeForDecay::UpdateStepFo 119 G4Step* G4ParticleChangeForDecay::UpdateStepForAtRest(G4Step* pStep) 76 { << 120 { 77 // A physics process always calculates the f 121 // A physics process always calculates the final state of the particle 78 122 79 G4StepPoint* pPostStepPoint = pStep->GetPost << 123 G4StepPoint* pPreStepPoint = pStep->GetPreStepPoint(); 80 << 124 G4StepPoint* pPostStepPoint = pStep->GetPostStepPoint(); 81 // update polarization << 125 82 pPostStepPoint->SetPolarization(thePolarizat << 83 << 84 // update time 126 // update time 85 pPostStepPoint->SetGlobalTime(GetGlobalTime( << 127 pPostStepPoint->SetGlobalTime( theTimeChange ); 86 pPostStepPoint->SetLocalTime(theTimeChange); << 128 pPostStepPoint->AddLocalTime( theTimeChange 87 pPostStepPoint->AddProperTime(theTimeChange << 129 - pPreStepPoint->GetGlobalTime()); >> 130 pPostStepPoint->AddProperTime( theTimeChange >> 131 - pPreStepPoint->GetGlobalTime()); >> 132 88 133 89 #ifdef G4VERBOSE 134 #ifdef G4VERBOSE 90 if(debugFlag) { CheckIt(*theCurrentTrack); } << 135 G4Track* aTrack = pStep->GetTrack(); >> 136 if (debugFlag) CheckIt(*aTrack); 91 #endif 137 #endif 92 138 93 if(isParentWeightProposed) << 139 // Update the G4Step specific attributes 94 pPostStepPoint->SetWeight(theParentWeight) << 95 << 96 // Update the G4Step specific attributes << 97 return UpdateStepInfo(pStep); 140 return UpdateStepInfo(pStep); 98 } 141 } 99 142 100 // ------------------------------------------- << 101 void G4ParticleChangeForDecay::DumpInfo() cons 143 void G4ParticleChangeForDecay::DumpInfo() const 102 { 144 { 103 // Show header << 145 // Show header 104 G4VParticleChange::DumpInfo(); 146 G4VParticleChange::DumpInfo(); 105 147 106 G4long oldprc = G4cout.precision(8); << 148 G4cout.precision(3); 107 G4cout << " --------------------------- << 149 G4cout << " Time (ns) : " 108 G4cout << " G4ParticleChangeForDecay prop << 150 << std::setw(20) << theTimeChange/ns 109 G4cout << " Proposed local Time (ns): " < << 151 << G4endl; 110 << theTimeChange / ns << G4endl; << 111 G4cout << " Initial local Time (ns) : " < << 112 << theLocalTime0 / ns << G4endl; << 113 G4cout << " Initial global Time (ns): " < << 114 << theGlobalTime0 / ns << G4endl; << 115 G4cout << " Current global Time (ns): " < << 116 << theCurrentTrack->GetGlobalTime() / << 117 G4cout.precision(oldprc); << 118 } 152 } 119 153 120 // ------------------------------------------- << 121 G4bool G4ParticleChangeForDecay::CheckIt(const 154 G4bool G4ParticleChangeForDecay::CheckIt(const G4Track& aTrack) 122 { 155 { 123 // local time should not go back << 156 G4bool exitWithError = false; 124 G4bool itsOK = true; << 157 125 if(theTimeChange < theLocalTime0) << 158 G4double accuracy; 126 { << 159 127 itsOK = false; << 160 // global time should not go back 128 ++nError; << 161 G4bool itsOK =true; >> 162 accuracy = -1.0*(theTimeChange - aTrack.GetGlobalTime())/ns; >> 163 if (accuracy > accuracyForWarning) { 129 #ifdef G4VERBOSE 164 #ifdef G4VERBOSE 130 if(nError < maxError) << 165 G4cout << " G4ParticleChangeForDecay::CheckIt : "; 131 { << 166 G4cout << "the global time goes back !!" << G4endl; 132 G4cout << " G4ParticleChangeForDecay::C << 167 G4cout << " Difference: " << accuracy << "[ns] " <<G4endl; 133 G4cout << "the local time goes back !!" << 134 << " Difference: " << (theTimeChange << 135 << "[ns] " << G4endl; << 136 G4cout << "initial local time " << theLo << 137 << "initial global time " << theGlobalT << 138 << G4endl; << 139 } << 140 #endif 168 #endif 141 theTimeChange = theLocalTime0; << 169 itsOK = false; >> 170 if (accuracy > accuracyForException) exitWithError = true; 142 } 171 } 143 172 144 if(!itsOK) << 173 // dump out information of this particle change 145 { << 146 if(nError < maxError) << 147 { << 148 #ifdef G4VERBOSE 174 #ifdef G4VERBOSE 149 // dump out information of this particle << 175 if (!itsOK) { 150 DumpInfo(); << 176 G4cout << " G4ParticleChangeForDecay::CheckIt " <<G4endl; >> 177 DumpInfo(); >> 178 } 151 #endif 179 #endif 152 G4Exception("G4ParticleChangeForDecay::C << 180 153 JustWarning, "time is illega << 181 // Exit with error 154 } << 182 if (exitWithError) { >> 183 G4Exception("G4ParticleChangeForDecay::CheckIt", >> 184 "500", >> 185 EventMustBeAborted, >> 186 "time was illegal"); >> 187 } >> 188 >> 189 // correction >> 190 if (!itsOK) { >> 191 theTimeChange = aTrack.GetGlobalTime(); 155 } 192 } 156 193 157 return (itsOK) && G4VParticleChange::CheckIt << 194 itsOK = (itsOK) && G4VParticleChange::CheckIt(aTrack); >> 195 return itsOK; 158 } 196 } >> 197 >> 198 >> 199 >> 200 >> 201 159 202