| Geant4 Cross Reference |
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 // G4WrapperProcess class implementation
27 //
28 // Author: H.Kurahige, 18 December 1996
29 // --------------------------------------------------------------------
30
31 #include "G4WrapperProcess.hh"
32
33 // --------------------------------------------------------------------
34 G4WrapperProcess::G4WrapperProcess(const G4String& aName,
35 G4ProcessType aType)
36 : G4VProcess(aName, aType)
37 {
38 }
39
40 // --------------------------------------------------------------------
41 G4WrapperProcess::G4WrapperProcess(const G4WrapperProcess& right)
42 : G4VProcess(*((G4VProcess*)(&right))), pRegProcess(right.pRegProcess)
43 {
44 }
45
46 // --------------------------------------------------------------------
47 G4WrapperProcess::~G4WrapperProcess()
48 {
49 }
50
51 // --------------------------------------------------------------------
52 void G4WrapperProcess::ResetNumberOfInteractionLengthLeft()
53 {
54 pRegProcess->ResetNumberOfInteractionLengthLeft();
55 }
56
57 // --------------------------------------------------------------------
58 G4double G4WrapperProcess::
59 AlongStepGetPhysicalInteractionLength( const G4Track& track,
60 G4double previousStepSize,
61 G4double currentMinimumStep,
62 G4double& proposedSafety,
63 G4GPILSelection* selection )
64 {
65 return pRegProcess->
66 AlongStepGetPhysicalInteractionLength( track,
67 previousStepSize,
68 currentMinimumStep,
69 proposedSafety,
70 selection );
71 }
72
73 // --------------------------------------------------------------------
74 G4double G4WrapperProcess::
75 AtRestGetPhysicalInteractionLength( const G4Track& track,
76 G4ForceCondition* condition )
77 {
78 return pRegProcess->AtRestGetPhysicalInteractionLength( track, condition );
79 }
80
81 // --------------------------------------------------------------------
82 G4double G4WrapperProcess::
83 PostStepGetPhysicalInteractionLength( const G4Track& track,
84 G4double previousStepSize,
85 G4ForceCondition* condition )
86 {
87 return pRegProcess->PostStepGetPhysicalInteractionLength( track,
88 previousStepSize,
89 condition );
90 }
91
92 // --------------------------------------------------------------------
93 void G4WrapperProcess::SetProcessManager(const G4ProcessManager* procMan)
94 {
95 pRegProcess->SetProcessManager(procMan);
96 }
97
98 const G4ProcessManager* G4WrapperProcess::GetProcessManager()
99 {
100 return pRegProcess->GetProcessManager();
101 }
102
103 // --------------------------------------------------------------------
104 G4VParticleChange* G4WrapperProcess::PostStepDoIt( const G4Track& track,
105 const G4Step& stepData )
106 {
107 return pRegProcess->PostStepDoIt( track, stepData );
108 }
109
110 // --------------------------------------------------------------------
111 G4VParticleChange* G4WrapperProcess::AlongStepDoIt( const G4Track& track,
112 const G4Step& stepData )
113 {
114 return pRegProcess->AlongStepDoIt( track, stepData );
115 }
116
117 // --------------------------------------------------------------------
118 G4VParticleChange* G4WrapperProcess::AtRestDoIt( const G4Track& track,
119 const G4Step& stepData )
120 {
121 return pRegProcess->AtRestDoIt( track, stepData );
122 }
123
124 // --------------------------------------------------------------------
125 G4bool G4WrapperProcess::IsApplicable(const G4ParticleDefinition& particle)
126 {
127 return pRegProcess->IsApplicable(particle);
128 }
129
130 // --------------------------------------------------------------------
131 void G4WrapperProcess::BuildPhysicsTable(const G4ParticleDefinition& particle)
132 {
133 return pRegProcess->BuildPhysicsTable(particle);
134 }
135
136 // --------------------------------------------------------------------
137 void G4WrapperProcess::PreparePhysicsTable(const G4ParticleDefinition& particle)
138 {
139 return pRegProcess->PreparePhysicsTable(particle);
140 }
141
142 // --------------------------------------------------------------------
143 G4bool G4WrapperProcess::
144 StorePhysicsTable(const G4ParticleDefinition* particle,
145 const G4String& directory,
146 G4bool ascii)
147 {
148 return pRegProcess->StorePhysicsTable(particle, directory, ascii);
149 }
150
151 // --------------------------------------------------------------------
152 G4bool G4WrapperProcess::
153 RetrievePhysicsTable( const G4ParticleDefinition* particle,
154 const G4String& directory,
155 G4bool ascii)
156 {
157 return pRegProcess->RetrievePhysicsTable(particle, directory, ascii);
158 }
159
160 // --------------------------------------------------------------------
161 void G4WrapperProcess::StartTracking(G4Track* track)
162 {
163 pRegProcess->StartTracking(track);
164 }
165
166 // --------------------------------------------------------------------
167 void G4WrapperProcess::EndTracking()
168 {
169 pRegProcess->EndTracking();
170 }
171
172 // --------------------------------------------------------------------
173 void G4WrapperProcess::RegisterProcess(G4VProcess* process)
174 {
175 pRegProcess = process;
176 theProcessName += process->GetProcessName();
177 theProcessType = process->GetProcessType();
178 }
179
180 // --------------------------------------------------------------------
181 const G4VProcess* G4WrapperProcess::GetRegisteredProcess() const
182 {
183 return pRegProcess;
184 }
185
186 // --------------------------------------------------------------------
187 void G4WrapperProcess::SetMasterProcess(G4VProcess* masterP)
188 {
189 G4WrapperProcess* master = static_cast<G4WrapperProcess*>(masterP);
190 // Cannot use getter because it returns "const" and we do not want
191 // to cast away constness explicitly (even if this is the same)
192 pRegProcess->SetMasterProcess(master->pRegProcess);
193 }
194