| 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 26
27 // GEANT 4 class implementation file --- Copyr 27 // GEANT 4 class implementation file --- Copyright CERN 1995
28 28
29 // History: 29 // History:
30 // 29.02.04 V.Ivanchenko create 30 // 29.02.04 V.Ivanchenko create
31 // 28.07.05, P.Gumplinger add G4ProcessType to 31 // 28.07.05, P.Gumplinger add G4ProcessType to constructor
32 32
33 #include "G4VTransitionRadiation.hh" 33 #include "G4VTransitionRadiation.hh"
34 34
35 #include "G4EmProcessSubType.hh" 35 #include "G4EmProcessSubType.hh"
36 #include "G4LossTableManager.hh" 36 #include "G4LossTableManager.hh"
37 #include "G4Material.hh" 37 #include "G4Material.hh"
38 #include "G4ParticleDefinition.hh" 38 #include "G4ParticleDefinition.hh"
39 #include "G4Region.hh" 39 #include "G4Region.hh"
40 #include "G4TransportationManager.hh" 40 #include "G4TransportationManager.hh"
41 #include "G4VTRModel.hh" 41 #include "G4VTRModel.hh"
42 42
43 ////////////////////////////////////////////// 43 ///////////////////////////////////////////////////////////////////////
44 G4VTransitionRadiation::G4VTransitionRadiation 44 G4VTransitionRadiation::G4VTransitionRadiation(const G4String& processName,
45 45 G4ProcessType type)
46 : G4VDiscreteProcess(processName, type) 46 : G4VDiscreteProcess(processName, type)
47 , region(nullptr) 47 , region(nullptr)
48 , model(nullptr) 48 , model(nullptr)
49 , gammaMin(100.) 49 , gammaMin(100.)
50 , cosDThetaMax(std::cos(0.1)) 50 , cosDThetaMax(std::cos(0.1))
51 , nSteps(0) 51 , nSteps(0)
52 { 52 {
53 SetProcessSubType(fTransitionRadiation); 53 SetProcessSubType(fTransitionRadiation);
54 Clear(); 54 Clear();
55 theManager = G4LossTableManager::Instance(); 55 theManager = G4LossTableManager::Instance();
56 theManager->Register(this); 56 theManager->Register(this);
57 } 57 }
58 58
59 ////////////////////////////////////////////// 59 ///////////////////////////////////////////////////////////////////////
60 G4VTransitionRadiation::~G4VTransitionRadiatio 60 G4VTransitionRadiation::~G4VTransitionRadiation()
61 { 61 {
62 Clear(); 62 Clear();
63 theManager->DeRegister(this); 63 theManager->DeRegister(this);
64 } 64 }
65 65
66 void G4VTransitionRadiation::ProcessDescriptio 66 void G4VTransitionRadiation::ProcessDescription(std::ostream& out) const
67 { 67 {
68 out << "Generic process of transition radiat 68 out << "Generic process of transition radiation.\n";
69 69
70 if(model) 70 if(model)
71 model->PrintInfo(); 71 model->PrintInfo();
72 } 72 }
73 73
74 ////////////////////////////////////////////// 74 ///////////////////////////////////////////////////////////////////////
75 void G4VTransitionRadiation::Clear() 75 void G4VTransitionRadiation::Clear()
76 { 76 {
77 materials.clear(); 77 materials.clear();
78 steps.clear(); 78 steps.clear();
79 normals.clear(); 79 normals.clear();
80 nSteps = 0; 80 nSteps = 0;
81 } 81 }
82 82
83 ////////////////////////////////////////////// 83 ///////////////////////////////////////////////////////////////////////
84 G4VParticleChange* G4VTransitionRadiation::Pos 84 G4VParticleChange* G4VTransitionRadiation::PostStepDoIt(const G4Track& track,
85 85 const G4Step& step)
86 { 86 {
87 // Fill temporary vectors 87 // Fill temporary vectors
88 const G4Material* material = track.GetMateri 88 const G4Material* material = track.GetMaterial();
89 G4double length = step.GetStepLen 89 G4double length = step.GetStepLength();
90 G4ThreeVector direction = track.GetMoment 90 G4ThreeVector direction = track.GetMomentumDirection();
91 91
92 if(nSteps == 0) 92 if(nSteps == 0)
93 { 93 {
94 nSteps = 1; 94 nSteps = 1;
95 materials.push_back(material); 95 materials.push_back(material);
96 steps.push_back(length); 96 steps.push_back(length);
97 const G4StepPoint* point = step.GetPreStep 97 const G4StepPoint* point = step.GetPreStepPoint();
98 startingPosition = point->GetPosit 98 startingPosition = point->GetPosition();
99 startingDirection = point->GetMomen 99 startingDirection = point->GetMomentumDirection();
100 G4bool valid = true; 100 G4bool valid = true;
101 G4ThreeVector n = G4TransportationManager: 101 G4ThreeVector n = G4TransportationManager::GetTransportationManager()
102 ->GetNavigatorForTrack 102 ->GetNavigatorForTracking()
103 ->GetLocalExitNormal(& 103 ->GetLocalExitNormal(&valid);
104 if(valid) 104 if(valid)
105 normals.push_back(n); 105 normals.push_back(n);
106 else 106 else
107 normals.push_back(direction); 107 normals.push_back(direction);
108 } 108 }
109 else 109 else
110 { 110 {
111 if(material == materials[nSteps - 1]) 111 if(material == materials[nSteps - 1])
112 { 112 {
113 steps[nSteps - 1] += length; 113 steps[nSteps - 1] += length;
114 } 114 }
115 else 115 else
116 { 116 {
117 ++nSteps; 117 ++nSteps;
118 materials.push_back(material); 118 materials.push_back(material);
119 steps.push_back(length); 119 steps.push_back(length);
120 G4bool valid = true; 120 G4bool valid = true;
121 G4ThreeVector n = G4TransportationManage 121 G4ThreeVector n = G4TransportationManager::GetTransportationManager()
122 ->GetNavigatorForTra 122 ->GetNavigatorForTracking()
123 ->GetLocalExitNormal 123 ->GetLocalExitNormal(&valid);
124 if(valid) 124 if(valid)
125 normals.push_back(n); 125 normals.push_back(n);
126 else 126 else
127 normals.push_back(direction); 127 normals.push_back(direction);
128 } 128 }
129 } 129 }
130 130
131 // Check PostStepPoint condition 131 // Check PostStepPoint condition
132 if(track.GetTrackStatus() == fStopAndKill || 132 if(track.GetTrackStatus() == fStopAndKill ||
133 track.GetVolume()->GetLogicalVolume()->Ge 133 track.GetVolume()->GetLogicalVolume()->GetRegion() != region ||
134 startingDirection.x() * direction.x() + 134 startingDirection.x() * direction.x() +
135 startingDirection.y() * direction.y() 135 startingDirection.y() * direction.y() +
136 startingDirection.z() * direction.z() 136 startingDirection.z() * direction.z() <
137 cosDThetaMax) 137 cosDThetaMax)
138 { 138 {
139 if(model) 139 if(model)
140 { 140 {
141 model->GenerateSecondaries(*pParticleCha 141 model->GenerateSecondaries(*pParticleChange, materials, steps, normals,
142 startingPosit 142 startingPosition, track);
143 } 143 }
144 Clear(); 144 Clear();
145 } 145 }
146 146
147 return pParticleChange; 147 return pParticleChange;
148 } 148 }
149 149
150 ////////////////////////////////////////////// 150 ///////////////////////////////////////////////////////////////////////
151 G4bool G4VTransitionRadiation::IsApplicable( 151 G4bool G4VTransitionRadiation::IsApplicable(
152 const G4ParticleDefinition& aParticle) 152 const G4ParticleDefinition& aParticle)
153 { 153 {
154 return (aParticle.GetPDGCharge() != 0.0); 154 return (aParticle.GetPDGCharge() != 0.0);
155 } 155 }
156 156
157 ////////////////////////////////////////////// 157 ///////////////////////////////////////////////////////////////////////
158 void G4VTransitionRadiation::SetRegion(const G 158 void G4VTransitionRadiation::SetRegion(const G4Region* reg) { region = reg; }
159 159
160 ////////////////////////////////////////////// 160 ///////////////////////////////////////////////////////////////////////
161 void G4VTransitionRadiation::SetModel(G4VTRMod 161 void G4VTransitionRadiation::SetModel(G4VTRModel* mod) { model = mod; }
162 162
163 ////////////////////////////////////////////// 163 ///////////////////////////////////////////////////////////////////////
164 G4double G4VTransitionRadiation::GetMeanFreePa 164 G4double G4VTransitionRadiation::GetMeanFreePath(const G4Track& track, G4double,
165 165 G4ForceCondition* condition)
166 { 166 {
167 if(nSteps > 0) 167 if(nSteps > 0)
168 { 168 {
169 *condition = StronglyForced; 169 *condition = StronglyForced;
170 } 170 }
171 else 171 else
172 { 172 {
173 *condition = NotForced; 173 *condition = NotForced;
174 if(track.GetKineticEnergy() / track.GetDef 174 if(track.GetKineticEnergy() / track.GetDefinition()->GetPDGMass() + 1.0 >
175 gammaMin && 175 gammaMin &&
176 track.GetVolume()->GetLogicalVolume()-> 176 track.GetVolume()->GetLogicalVolume()->GetRegion() == region)
177 { 177 {
178 *condition = StronglyForced; 178 *condition = StronglyForced;
179 } 179 }
180 } 180 }
181 return DBL_MAX; // so TR doesn't limit mean 181 return DBL_MAX; // so TR doesn't limit mean free path
182 } 182 }
183 183