| 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 // G4WrapperProcess class implementation <<
27 // 26 //
28 // Author: H.Kurahige, 18 December 1996 << 27 //
29 // ------------------------------------------- << 28 //
>> 29 // ------------------------------------------------------------
>> 30 // GEANT 4 class implementation file
>> 31 //
>> 32 // ------------------------------------------------------------
>> 33 // New Physics scheme 18 Dec. 1996 H.Kurahige
>> 34 // ------------------------------------------------------------
30 35
31 #include "G4WrapperProcess.hh" 36 #include "G4WrapperProcess.hh"
32 37
33 // ------------------------------------------- <<
34 G4WrapperProcess::G4WrapperProcess(const G4Str 38 G4WrapperProcess::G4WrapperProcess(const G4String& aName,
35 G4Pro << 39 G4ProcessType aType)
36 : G4VProcess(aName, aType) << 40 : G4VProcess(aName,aType),
>> 41 pRegProcess(nullptr)
37 { 42 {
38 } 43 }
39 44
40 // ------------------------------------------- <<
41 G4WrapperProcess::G4WrapperProcess(const G4Wra 45 G4WrapperProcess::G4WrapperProcess(const G4WrapperProcess& right)
42 : G4VProcess(*((G4VProcess*)(&right))), pReg 46 : G4VProcess(*((G4VProcess*)(&right))), pRegProcess(right.pRegProcess)
43 { 47 {
44 } 48 }
45 49
46 // ------------------------------------------- <<
47 G4WrapperProcess::~G4WrapperProcess() 50 G4WrapperProcess::~G4WrapperProcess()
48 { 51 {
>> 52 if (pRegProcess!=nullptr) delete pRegProcess;
49 } 53 }
50 54
51 // ------------------------------------------- <<
52 void G4WrapperProcess::ResetNumberOfInteractio 55 void G4WrapperProcess::ResetNumberOfInteractionLengthLeft()
53 { 56 {
54 pRegProcess->ResetNumberOfInteractionLengthL 57 pRegProcess->ResetNumberOfInteractionLengthLeft();
55 } 58 }
56 59
57 // ------------------------------------------- <<
58 G4double G4WrapperProcess:: 60 G4double G4WrapperProcess::
59 AlongStepGetPhysicalInteractionLength( const G 61 AlongStepGetPhysicalInteractionLength( const G4Track& track,
60 G 62 G4double previousStepSize,
61 G 63 G4double currentMinimumStep,
62 G 64 G4double& proposedSafety,
63 G << 65 G4GPILSelection* selection )
64 { 66 {
65 return pRegProcess-> 67 return pRegProcess->
66 AlongStepGetPhysicalInteractionLength 68 AlongStepGetPhysicalInteractionLength( track,
67 69 previousStepSize,
68 70 currentMinimumStep,
69 71 proposedSafety,
70 << 72 selection );
71 } 73 }
72 74
73 // ------------------------------------------- <<
74 G4double G4WrapperProcess:: 75 G4double G4WrapperProcess::
75 AtRestGetPhysicalInteractionLength( const G4Tr 76 AtRestGetPhysicalInteractionLength( const G4Track& track,
76 G4Fo 77 G4ForceCondition* condition )
77 { 78 {
78 return pRegProcess->AtRestGetPhysicalInterac 79 return pRegProcess->AtRestGetPhysicalInteractionLength( track, condition );
79 } 80 }
80 81
81 // ------------------------------------------- <<
82 G4double G4WrapperProcess:: 82 G4double G4WrapperProcess::
83 PostStepGetPhysicalInteractionLength( const G4 83 PostStepGetPhysicalInteractionLength( const G4Track& track,
84 G4 84 G4double previousStepSize,
85 G4 85 G4ForceCondition* condition )
86 { 86 {
87 return pRegProcess->PostStepGetPhysicalInter << 87 return pRegProcess->PostStepGetPhysicalInteractionLength( track,
88 << 88 previousStepSize,
89 << 89 condition );
90 } 90 }
91 91
92 // ------------------------------------------- <<
93 void G4WrapperProcess::SetProcessManager(const 92 void G4WrapperProcess::SetProcessManager(const G4ProcessManager* procMan)
94 { 93 {
95 pRegProcess->SetProcessManager(procMan); << 94 pRegProcess->SetProcessManager(procMan);
96 } 95 }
97 96
98 const G4ProcessManager* G4WrapperProcess::GetP 97 const G4ProcessManager* G4WrapperProcess::GetProcessManager()
99 { 98 {
100 return pRegProcess->GetProcessManager(); << 99 return pRegProcess->GetProcessManager();
101 } 100 }
102 101
103 // ------------------------------------------- <<
104 G4VParticleChange* G4WrapperProcess::PostStepD 102 G4VParticleChange* G4WrapperProcess::PostStepDoIt( const G4Track& track,
105 103 const G4Step& stepData )
106 { 104 {
107 return pRegProcess->PostStepDoIt( track, ste << 105 return pRegProcess->PostStepDoIt( track, stepData );
108 } 106 }
109 107
110 // ------------------------------------------- <<
111 G4VParticleChange* G4WrapperProcess::AlongStep 108 G4VParticleChange* G4WrapperProcess::AlongStepDoIt( const G4Track& track,
112 109 const G4Step& stepData )
113 { 110 {
114 return pRegProcess->AlongStepDoIt( track, st << 111 return pRegProcess->AlongStepDoIt( track, stepData );
115 } 112 }
116 113
117 // ------------------------------------------- <<
118 G4VParticleChange* G4WrapperProcess::AtRestDoI 114 G4VParticleChange* G4WrapperProcess::AtRestDoIt( const G4Track& track,
119 115 const G4Step& stepData )
120 { 116 {
121 return pRegProcess->AtRestDoIt( track, stepD << 117 return pRegProcess->AtRestDoIt( track, stepData );
122 } 118 }
123 119
124 // ------------------------------------------- <<
125 G4bool G4WrapperProcess::IsApplicable(const G4 120 G4bool G4WrapperProcess::IsApplicable(const G4ParticleDefinition& particle)
126 { 121 {
127 return pRegProcess->IsApplicable(particle); << 122 return pRegProcess->IsApplicable(particle);
128 } 123 }
129 124
130 // ------------------------------------------- <<
131 void G4WrapperProcess::BuildPhysicsTable(const 125 void G4WrapperProcess::BuildPhysicsTable(const G4ParticleDefinition& particle)
132 { 126 {
133 return pRegProcess->BuildPhysicsTable(partic << 127 return pRegProcess->BuildPhysicsTable(particle);
134 } 128 }
135 129
136 // ------------------------------------------- <<
137 void G4WrapperProcess::PreparePhysicsTable(con 130 void G4WrapperProcess::PreparePhysicsTable(const G4ParticleDefinition& particle)
138 { 131 {
139 return pRegProcess->PreparePhysicsTable(part << 132 return pRegProcess->PreparePhysicsTable(particle);
140 } 133 }
141 134
142 // ------------------------------------------- <<
143 G4bool G4WrapperProcess:: 135 G4bool G4WrapperProcess::
144 StorePhysicsTable(const G4ParticleDefinition* 136 StorePhysicsTable(const G4ParticleDefinition* particle,
145 const G4String& directory, 137 const G4String& directory,
146 G4bool ascii) << 138 G4bool ascii)
147 { 139 {
148 return pRegProcess->StorePhysicsTable(partic << 140 return pRegProcess->StorePhysicsTable(particle, directory, ascii);
149 } 141 }
150 142
151 // ------------------------------------------- <<
152 G4bool G4WrapperProcess:: 143 G4bool G4WrapperProcess::
153 RetrievePhysicsTable( const G4ParticleDefiniti 144 RetrievePhysicsTable( const G4ParticleDefinition* particle,
154 const G4String& director 145 const G4String& directory,
155 G4bool ascii) << 146 G4bool ascii)
156 { 147 {
157 return pRegProcess->RetrievePhysicsTable(par << 148 return pRegProcess->RetrievePhysicsTable(particle, directory, ascii);
158 } 149 }
159 150
160 // ------------------------------------------- <<
161 void G4WrapperProcess::StartTracking(G4Track* 151 void G4WrapperProcess::StartTracking(G4Track* track)
162 { 152 {
163 pRegProcess->StartTracking(track); 153 pRegProcess->StartTracking(track);
164 } 154 }
165 155
166 // ------------------------------------------- <<
167 void G4WrapperProcess::EndTracking() 156 void G4WrapperProcess::EndTracking()
168 { 157 {
169 pRegProcess->EndTracking(); 158 pRegProcess->EndTracking();
170 } 159 }
171 160
172 // ------------------------------------------- << 161 void G4WrapperProcess::RegisterProcess(G4VProcess* process)
173 void G4WrapperProcess::RegisterProcess(G4VProc <<
174 { 162 {
175 pRegProcess = process; << 163 pRegProcess=process;
176 theProcessName += process->GetProcessName(); 164 theProcessName += process->GetProcessName();
177 theProcessType = process->GetProcessType(); 165 theProcessType = process->GetProcessType();
178 } 166 }
179 167
180 // ------------------------------------------- <<
181 const G4VProcess* G4WrapperProcess::GetRegiste 168 const G4VProcess* G4WrapperProcess::GetRegisteredProcess() const
182 { 169 {
183 return pRegProcess; 170 return pRegProcess;
184 } 171 }
185 172
186 // ------------------------------------------- << 173 void G4WrapperProcess::SetMasterProcess(G4VProcess* masterP) {
187 void G4WrapperProcess::SetMasterProcess(G4VPro <<
188 { <<
189 G4WrapperProcess* master = static_cast<G4Wra 174 G4WrapperProcess* master = static_cast<G4WrapperProcess*>(masterP);
190 // Cannot use getter because it returns "con << 175 //Cannot use getter because it returns "const" and we do not want
191 // to cast away constness explicitly (even i << 176 //to cast away constness explicitly (even if this is the same)
192 pRegProcess->SetMasterProcess(master->pRegPr 177 pRegProcess->SetMasterProcess(master->pRegProcess);
193 } 178 }
194 179