| 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 // G4VProcess class implementation 26 // G4VProcess class implementation
27 // 27 //
28 // Authors: 28 // Authors:
29 // - 2 December 1995, G.Cosmo - First implemen 29 // - 2 December 1995, G.Cosmo - First implementation, based on object model
30 // - 18 December 1996, H.Kurashige - New Physi 30 // - 18 December 1996, H.Kurashige - New Physics scheme
31 // ------------------------------------------- 31 // --------------------------------------------------------------------
32 32
33 #include "G4VProcess.hh" 33 #include "G4VProcess.hh"
34 34
35 #include "G4PhysicalConstants.hh" 35 #include "G4PhysicalConstants.hh"
36 #include "G4SystemOfUnits.hh" 36 #include "G4SystemOfUnits.hh"
37 37
38 #include "G4ProcessTable.hh" 38 #include "G4ProcessTable.hh"
39 #include "G4PhysicsTable.hh" 39 #include "G4PhysicsTable.hh"
40 #include "G4MaterialTable.hh" 40 #include "G4MaterialTable.hh"
41 #include "G4ElementTable.hh" 41 #include "G4ElementTable.hh"
42 #include "G4ElementVector.hh" 42 #include "G4ElementVector.hh"
43 #include "G4Log.hh" 43 #include "G4Log.hh"
44 44
45 // ------------------------------------------- 45 // --------------------------------------------------------------------
46 G4VProcess::G4VProcess(const G4String& aName, 46 G4VProcess::G4VProcess(const G4String& aName, G4ProcessType aType )
47 : theProcessName(aName), theProcessType(aTyp 47 : theProcessName(aName), theProcessType(aType)
48 { 48 {
49 pParticleChange = &aParticleChange; 49 pParticleChange = &aParticleChange;
50 fProcessTable = G4ProcessTable::GetProcessTa 50 fProcessTable = G4ProcessTable::GetProcessTable();
51 fProcessTable->RegisterProcess(this); 51 fProcessTable->RegisterProcess(this);
52 } 52 }
53 53
54 // ------------------------------------------- 54 // --------------------------------------------------------------------
55 G4VProcess::G4VProcess() 55 G4VProcess::G4VProcess()
56 { 56 {
57 } 57 }
58 58
59 // ------------------------------------------- 59 // --------------------------------------------------------------------
60 G4VProcess::~G4VProcess() 60 G4VProcess::~G4VProcess()
61 { 61 {
62 fProcessTable->DeRegisterProcess(this); 62 fProcessTable->DeRegisterProcess(this);
63 } 63 }
64 64
65 // ------------------------------------------- 65 // --------------------------------------------------------------------
66 G4VProcess::G4VProcess(const G4VProcess& right 66 G4VProcess::G4VProcess(const G4VProcess& right)
67 : theProcessName(right.theProcessName), 67 : theProcessName(right.theProcessName),
68 theProcessType(right.theProcessType), 68 theProcessType(right.theProcessType),
69 theProcessSubType(right.theProcessSubType) 69 theProcessSubType(right.theProcessSubType),
70 verboseLevel(right.verboseLevel), 70 verboseLevel(right.verboseLevel),
71 enableAtRestDoIt(right.enableAtRestDoIt), 71 enableAtRestDoIt(right.enableAtRestDoIt),
72 enableAlongStepDoIt(right.enableAlongStepD 72 enableAlongStepDoIt(right.enableAlongStepDoIt),
73 enablePostStepDoIt(right.enablePostStepDoI 73 enablePostStepDoIt(right.enablePostStepDoIt),
74 masterProcessShadow(right.masterProcessSha 74 masterProcessShadow(right.masterProcessShadow),
75 fProcessTable(right.fProcessTable) 75 fProcessTable(right.fProcessTable)
76 { 76 {
77 } 77 }
78 78
79 // ------------------------------------------- 79 // --------------------------------------------------------------------
80 void G4VProcess::ResetNumberOfInteractionLengt 80 void G4VProcess::ResetNumberOfInteractionLengthLeft()
81 { 81 {
82 theNumberOfInteractionLengthLeft = -1.*G4Lo 82 theNumberOfInteractionLengthLeft = -1.*G4Log( G4UniformRand() );
83 theInitialNumberOfInteractionLength = theNum 83 theInitialNumberOfInteractionLength = theNumberOfInteractionLengthLeft;
84 } 84 }
85 85
86 // ------------------------------------------- 86 // --------------------------------------------------------------------
87 void G4VProcess::StartTracking(G4Track*) 87 void G4VProcess::StartTracking(G4Track*)
88 { 88 {
89 currentInteractionLength = -1.0; 89 currentInteractionLength = -1.0;
90 theNumberOfInteractionLengthLeft = -1.0; 90 theNumberOfInteractionLengthLeft = -1.0;
91 theInitialNumberOfInteractionLength = -1.0; 91 theInitialNumberOfInteractionLength = -1.0;
92 #ifdef G4VERBOSE 92 #ifdef G4VERBOSE
93 if (verboseLevel>2) 93 if (verboseLevel>2)
94 { 94 {
95 G4cout << "G4VProcess::StartTracking() - [ 95 G4cout << "G4VProcess::StartTracking() - [" << theProcessName << "]"
96 << G4endl; 96 << G4endl;
97 } 97 }
98 #endif 98 #endif
99 } 99 }
100 100
101 // ------------------------------------------- 101 // --------------------------------------------------------------------
102 void G4VProcess::EndTracking() 102 void G4VProcess::EndTracking()
103 { 103 {
104 #ifdef G4VERBOSE 104 #ifdef G4VERBOSE
105 if (verboseLevel>2) 105 if (verboseLevel>2)
106 { 106 {
107 G4cout << "G4VProcess::EndTracking() - [" 107 G4cout << "G4VProcess::EndTracking() - [" << theProcessName << "]"
108 << G4endl; 108 << G4endl;
109 } 109 }
110 #endif 110 #endif
111 theNumberOfInteractionLengthLeft = -1.0; 111 theNumberOfInteractionLengthLeft = -1.0;
112 currentInteractionLength = -1.0; 112 currentInteractionLength = -1.0;
113 theInitialNumberOfInteractionLength=-1.0; 113 theInitialNumberOfInteractionLength=-1.0;
114 } 114 }
115 115
116 // ------------------------------------------- 116 // --------------------------------------------------------------------
117 namespace 117 namespace
118 { 118 {
119 static const G4String typeNotDefined = "NotD 119 static const G4String typeNotDefined = "NotDefined";
120 static const G4String typeTransportation = " 120 static const G4String typeTransportation = "Transportation";
121 static const G4String typeElectromagnetic = 121 static const G4String typeElectromagnetic = "Electromagnetic";
122 static const G4String typeOptical = "Optical 122 static const G4String typeOptical = "Optical";
123 static const G4String typeHadronic = "Hadron 123 static const G4String typeHadronic = "Hadronic";
124 static const G4String typePhotolepton_hadron 124 static const G4String typePhotolepton_hadron = "Photolepton_hadron";
125 static const G4String typeDecay = "Decay"; 125 static const G4String typeDecay = "Decay";
126 static const G4String typeGeneral = "General 126 static const G4String typeGeneral = "General";
127 static const G4String typeParameterisation = 127 static const G4String typeParameterisation = "Parameterisation";
128 static const G4String typeUserDefined = "Use 128 static const G4String typeUserDefined = "UserDefined";
129 static const G4String typePhonon = "Phonon"; 129 static const G4String typePhonon = "Phonon";
130 static const G4String noType = "------"; 130 static const G4String noType = "------";
131 } 131 }
132 132
133 // ------------------------------------------- 133 // --------------------------------------------------------------------
134 const G4String& G4VProcess::GetProcessTypeName 134 const G4String& G4VProcess::GetProcessTypeName(G4ProcessType aType )
135 { 135 {
136 switch (aType) 136 switch (aType)
137 { 137 {
138 case fNotDefined: return typeNotDe 138 case fNotDefined: return typeNotDefined; break;
139 case fTransportation: return typeTrans 139 case fTransportation: return typeTransportation; break;
140 case fElectromagnetic: return typeElect 140 case fElectromagnetic: return typeElectromagnetic; break;
141 case fOptical: return typeOptic 141 case fOptical: return typeOptical; break;
142 case fHadronic: return typeHadro 142 case fHadronic: return typeHadronic; break;
143 case fPhotolepton_hadron: return typePhoto 143 case fPhotolepton_hadron: return typePhotolepton_hadron; break;
144 case fDecay: return typeDecay 144 case fDecay: return typeDecay; break;
145 case fGeneral: return typeGener 145 case fGeneral: return typeGeneral; break;
146 case fParameterisation: return typeParam 146 case fParameterisation: return typeParameterisation; break;
147 case fUserDefined: return typeUserD 147 case fUserDefined: return typeUserDefined; break;
148 case fPhonon: return typePhono 148 case fPhonon: return typePhonon; break;
149 default: ; 149 default: ;
150 } 150 }
151 return noType; 151 return noType;
152 } 152 }
153 153
154 // ------------------------------------------- 154 // --------------------------------------------------------------------
155 const G4VProcess* G4VProcess::GetCreatorProces 155 const G4VProcess* G4VProcess::GetCreatorProcess() const
156 { 156 {
157 return this; 157 return this;
158 } 158 }
159 159
160 // ------------------------------------------- 160 // --------------------------------------------------------------------
161 G4bool G4VProcess::operator==(const G4VProcess 161 G4bool G4VProcess::operator==(const G4VProcess& right) const
162 { 162 {
163 return (this == &right); 163 return (this == &right);
164 } 164 }
165 165
166 // ------------------------------------------- 166 // --------------------------------------------------------------------
167 G4bool G4VProcess::operator!=(const G4VProcess 167 G4bool G4VProcess::operator!=(const G4VProcess& right) const
168 { 168 {
169 return (this != &right); 169 return (this != &right);
170 } 170 }
171 171
172 // ------------------------------------------- 172 // --------------------------------------------------------------------
173 void G4VProcess::DumpInfo() const 173 void G4VProcess::DumpInfo() const
174 { 174 {
175 G4cout << "Process Name " << theProcessName 175 G4cout << "Process Name " << theProcessName ;
176 G4cout << " : Type[" << GetProcessTypeName(t 176 G4cout << " : Type[" << GetProcessTypeName(theProcessType) << "]";
177 G4cout << " : SubType[" << theProcessSubType 177 G4cout << " : SubType[" << theProcessSubType << "]"<< G4endl;
178 } 178 }
179 179
180 // ------------------------------------------- 180 // --------------------------------------------------------------------
181 void G4VProcess::ProcessDescription(std::ostre 181 void G4VProcess::ProcessDescription(std::ostream& outFile) const
182 { 182 {
183 outFile << "This process has not yet been de 183 outFile << "This process has not yet been described\n";
184 } 184 }
185 185
186 // ------------------------------------------- 186 // --------------------------------------------------------------------
187 const G4String& G4VProcess:: 187 const G4String& G4VProcess::
188 GetPhysicsTableFileName( const G4ParticleDefin 188 GetPhysicsTableFileName( const G4ParticleDefinition* particle,
189 const G4String& direc 189 const G4String& directory,
190 const G4String& table 190 const G4String& tableName,
191 G4bool ascii ) 191 G4bool ascii )
192 { 192 {
193 G4String thePhysicsTableFileExt; 193 G4String thePhysicsTableFileExt;
194 if (ascii) thePhysicsTableFileExt = ".asc"; 194 if (ascii) thePhysicsTableFileExt = ".asc";
195 else thePhysicsTableFileExt = ".dat"; 195 else thePhysicsTableFileExt = ".dat";
196 196
197 thePhysicsTableFileName = directory + "/"; 197 thePhysicsTableFileName = directory + "/";
198 thePhysicsTableFileName += tableName + "." + 198 thePhysicsTableFileName += tableName + "." + theProcessName + ".";
199 thePhysicsTableFileName += particle->GetPart 199 thePhysicsTableFileName += particle->GetParticleName()
200 + thePhysicsTableFi 200 + thePhysicsTableFileExt;
201 201
202 return thePhysicsTableFileName; 202 return thePhysicsTableFileName;
203 } 203 }
204 204
205 // ------------------------------------------- 205 // --------------------------------------------------------------------
206 void G4VProcess::BuildWorkerPhysicsTable(const 206 void G4VProcess::BuildWorkerPhysicsTable(const G4ParticleDefinition& part)
207 { 207 {
208 BuildPhysicsTable(part); 208 BuildPhysicsTable(part);
209 } 209 }
210 210
211 // ------------------------------------------- 211 // --------------------------------------------------------------------
212 void G4VProcess::PrepareWorkerPhysicsTable(con 212 void G4VProcess::PrepareWorkerPhysicsTable(const G4ParticleDefinition& part)
213 { 213 {
214 PreparePhysicsTable(part); 214 PreparePhysicsTable(part);
215 } 215 }
216 216
217 // ------------------------------------------- 217 // --------------------------------------------------------------------
218 void G4VProcess::SetMasterProcess(G4VProcess* 218 void G4VProcess::SetMasterProcess(G4VProcess* masterP)
219 { 219 {
220 masterProcessShadow = masterP; 220 masterProcessShadow = masterP;
221 } 221 }
222 222