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