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