| 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 /*
27 * =============================================================================
28 *
29 * Filename: CexmcChargeExchangeReconstructor.hh
30 *
31 * Description: charge exchange reconstructor
32 *
33 * Version: 1.0
34 * Created: 02.12.2009 15:07:16
35 * Revision: none
36 * Compiler: gcc
37 *
38 * Author: Alexey Radkov (),
39 * Company: PNPI
40 *
41 * =============================================================================
42 */
43
44 #ifndef CEXMC_CHARGE_EXCHANGE_RECONSTRUCTOR_HH
45 #define CEXMC_CHARGE_EXCHANGE_RECONSTRUCTOR_HH
46
47 #include "CexmcReconstructor.hh"
48 #include "CexmcProductionModelData.hh"
49 #include "CexmcCommon.hh"
50
51 class CexmcChargeExchangeReconstructorMessenger;
52 struct CexmcEnergyDepositStore;
53 class CexmcProductionModel;
54 class CexmcParticleGun;
55
56
57 class CexmcChargeExchangeReconstructor : public CexmcReconstructor
58 {
59 public:
60 CexmcChargeExchangeReconstructor(
61 const CexmcProductionModel * productionModel );
62
63 ~CexmcChargeExchangeReconstructor();
64
65 public:
66 void Reconstruct( const CexmcEnergyDepositStore * edStore );
67
68 public:
69 G4double GetOutputParticleMass( void ) const;
70
71 G4double GetNucleusOutputParticleMass( void ) const;
72
73 const CexmcProductionModelData & GetProductionModelData( void ) const;
74
75 void UseTableMass( G4bool on );
76
77 void UseMassCut( G4bool on );
78
79 void SetMassCutOPCenter( G4double value );
80
81 void SetMassCutNOPCenter( G4double value );
82
83 void SetMassCutOPWidth( G4double value );
84
85 void SetMassCutNOPWidth( G4double value );
86
87 void SetMassCutEllipseAngle( G4double value );
88
89 void UseAbsorbedEnergyCut( G4bool on );
90
91 void SetAbsorbedEnergyCutCLCenter( G4double value );
92
93 void SetAbsorbedEnergyCutCRCenter( G4double value );
94
95 void SetAbsorbedEnergyCutCLWidth( G4double value );
96
97 void SetAbsorbedEnergyCutCRWidth( G4double value );
98
99 void SetAbsorbedEnergyCutEllipseAngle( G4double value );
100
101 void SetExpectedMomentumAmp( G4double );
102
103 void SetExpectedMomentumAmpDiff( G4double );
104
105 void SetEDCollectionAlgorithm( CexmcEDCollectionAlgoritm value );
106
107 void SetupBeamParticle( void );
108
109 G4bool IsTableMassUsed( void ) const;
110
111 G4bool IsMassCutUsed( void ) const;
112
113 G4double GetMassCutOPCenter( void ) const;
114
115 G4double GetMassCutNOPCenter( void ) const;
116
117 G4double GetMassCutOPWidth( void ) const;
118
119 G4double GetMassCutNOPWidth( void ) const;
120
121 G4double GetMassCutEllipseAngle( void ) const;
122
123 G4bool HasMassCutTriggered( void ) const;
124
125 G4bool IsAbsorbedEnergyCutUsed( void ) const;
126
127 G4double GetAbsorbedEnergyCutCLCenter( void ) const;
128
129 G4double GetAbsorbedEnergyCutCRCenter( void ) const;
130
131 G4double GetAbsorbedEnergyCutCLWidth( void ) const;
132
133 G4double GetAbsorbedEnergyCutCRWidth( void ) const;
134
135 G4double GetAbsorbedEnergyCutEllipseAngle( void ) const;
136
137 G4double GetExpectedMomentumAmp( void ) const;
138
139 CexmcEDCollectionAlgoritm GetEDCollectionAlgorithm( void ) const;
140
141 G4bool HasAbsorbedEnergyCutTriggered( void ) const;
142
143 G4bool HasFullTrigger( void ) const;
144
145 private:
146 G4double outputParticleMass;
147
148 G4double nucleusOutputParticleMass;
149
150 private:
151 CexmcProductionModelData productionModelData;
152
153 private:
154 G4bool useTableMass;
155
156 G4bool useMassCut;
157
158 G4double massCutOPCenter;
159
160 G4double massCutNOPCenter;
161
162 G4double massCutOPWidth;
163
164 G4double massCutNOPWidth;
165
166 G4double massCutEllipseAngle;
167
168 G4bool useAbsorbedEnergyCut;
169
170 G4double absorbedEnergyCutCLCenter;
171
172 G4double absorbedEnergyCutCRCenter;
173
174 G4double absorbedEnergyCutCLWidth;
175
176 G4double absorbedEnergyCutCRWidth;
177
178 G4double absorbedEnergyCutEllipseAngle;
179
180 G4double expectedMomentumAmp;
181
182 CexmcEDCollectionAlgoritm edCollectionAlgorithm;
183
184 private:
185 G4bool hasMassCutTriggered;
186
187 G4bool hasAbsorbedEnergyCutTriggered;
188
189 private:
190 G4bool beamParticleIsInitialized;
191
192 CexmcParticleGun * particleGun;
193
194 CexmcChargeExchangeReconstructorMessenger * messenger;
195 };
196
197
198 inline G4double CexmcChargeExchangeReconstructor::GetOutputParticleMass(
199 void ) const
200 {
201 return outputParticleMass;
202 }
203
204
205 inline G4double CexmcChargeExchangeReconstructor::GetNucleusOutputParticleMass(
206 void ) const
207 {
208 return nucleusOutputParticleMass;
209 }
210
211
212 inline const CexmcProductionModelData &
213 CexmcChargeExchangeReconstructor::GetProductionModelData( void ) const
214 {
215 return productionModelData;
216 }
217
218
219 inline void CexmcChargeExchangeReconstructor::UseTableMass( G4bool on )
220 {
221 useTableMass = on;
222 }
223
224
225 inline void CexmcChargeExchangeReconstructor::UseMassCut( G4bool on )
226 {
227 useMassCut = on;
228 }
229
230
231 inline void CexmcChargeExchangeReconstructor::SetMassCutOPCenter(
232 G4double value )
233 {
234 massCutOPCenter = value;
235 }
236
237
238 inline void CexmcChargeExchangeReconstructor::SetMassCutNOPCenter(
239 G4double value )
240 {
241 massCutNOPCenter = value;
242 }
243
244
245 inline void CexmcChargeExchangeReconstructor::SetMassCutOPWidth(
246 G4double value )
247 {
248 massCutOPWidth = value;
249 }
250
251
252 inline void CexmcChargeExchangeReconstructor::SetMassCutNOPWidth(
253 G4double value )
254 {
255 massCutNOPWidth = value;
256 }
257
258
259 inline void CexmcChargeExchangeReconstructor::SetMassCutEllipseAngle(
260 G4double value )
261 {
262 massCutEllipseAngle = value;
263 }
264
265
266 inline void CexmcChargeExchangeReconstructor::UseAbsorbedEnergyCut(
267 G4bool on )
268 {
269 useAbsorbedEnergyCut = on;
270 }
271
272
273 inline void CexmcChargeExchangeReconstructor::SetAbsorbedEnergyCutCLCenter(
274 G4double value )
275 {
276 absorbedEnergyCutCLCenter = value;
277 }
278
279
280 inline void CexmcChargeExchangeReconstructor::SetAbsorbedEnergyCutCRCenter(
281 G4double value )
282 {
283 absorbedEnergyCutCRCenter = value;
284 }
285
286
287 inline void CexmcChargeExchangeReconstructor::SetAbsorbedEnergyCutCLWidth(
288 G4double value )
289 {
290 absorbedEnergyCutCLWidth = value;
291 }
292
293
294 inline void CexmcChargeExchangeReconstructor::SetAbsorbedEnergyCutCRWidth(
295 G4double value )
296 {
297 absorbedEnergyCutCRWidth = value;
298 }
299
300
301 inline void CexmcChargeExchangeReconstructor::SetAbsorbedEnergyCutEllipseAngle(
302 G4double value )
303 {
304 absorbedEnergyCutEllipseAngle = value;
305 }
306
307
308 inline void CexmcChargeExchangeReconstructor::SetExpectedMomentumAmp(
309 G4double value )
310 {
311 expectedMomentumAmp = value;
312 }
313
314
315 inline void CexmcChargeExchangeReconstructor::SetEDCollectionAlgorithm(
316 CexmcEDCollectionAlgoritm value )
317 {
318 edCollectionAlgorithm = value;
319 }
320
321
322 inline G4bool CexmcChargeExchangeReconstructor::IsTableMassUsed( void ) const
323 {
324 return useTableMass;
325 }
326
327
328 inline G4bool CexmcChargeExchangeReconstructor::IsMassCutUsed( void ) const
329 {
330 return useMassCut;
331 }
332
333
334 inline G4double CexmcChargeExchangeReconstructor::GetMassCutOPCenter( void )
335 const
336 {
337 return massCutOPCenter;
338 }
339
340
341 inline G4double CexmcChargeExchangeReconstructor::GetMassCutNOPCenter( void )
342 const
343 {
344 return massCutNOPCenter;
345 }
346
347
348 inline G4double CexmcChargeExchangeReconstructor::GetMassCutOPWidth( void )
349 const
350 {
351 return massCutOPWidth;
352 }
353
354
355 inline G4double CexmcChargeExchangeReconstructor::GetMassCutNOPWidth( void )
356 const
357 {
358 return massCutNOPWidth;
359 }
360
361
362 inline G4double CexmcChargeExchangeReconstructor::GetMassCutEllipseAngle(
363 void ) const
364 {
365 return massCutEllipseAngle;
366 }
367
368
369 inline G4bool CexmcChargeExchangeReconstructor::HasMassCutTriggered( void )
370 const
371 {
372 return hasMassCutTriggered;
373 }
374
375
376 inline G4bool CexmcChargeExchangeReconstructor::IsAbsorbedEnergyCutUsed( void )
377 const
378 {
379 return useAbsorbedEnergyCut;
380 }
381
382
383 inline G4double CexmcChargeExchangeReconstructor::GetAbsorbedEnergyCutCLCenter(
384 void ) const
385 {
386 return absorbedEnergyCutCLCenter;
387 }
388
389
390 inline G4double CexmcChargeExchangeReconstructor::GetAbsorbedEnergyCutCRCenter(
391 void ) const
392 {
393 return absorbedEnergyCutCRCenter;
394 }
395
396
397 inline G4double CexmcChargeExchangeReconstructor::GetAbsorbedEnergyCutCLWidth(
398 void ) const
399 {
400 return absorbedEnergyCutCLWidth;
401 }
402
403
404 inline G4double CexmcChargeExchangeReconstructor::GetAbsorbedEnergyCutCRWidth(
405 void ) const
406 {
407 return absorbedEnergyCutCRWidth;
408 }
409
410
411 inline G4double CexmcChargeExchangeReconstructor::
412 GetAbsorbedEnergyCutEllipseAngle( void ) const
413 {
414 return absorbedEnergyCutEllipseAngle;
415 }
416
417
418 inline G4double CexmcChargeExchangeReconstructor::GetExpectedMomentumAmp(
419 void ) const
420 {
421 return expectedMomentumAmp;
422 }
423
424
425 inline CexmcEDCollectionAlgoritm CexmcChargeExchangeReconstructor::
426 GetEDCollectionAlgorithm( void ) const
427 {
428 return edCollectionAlgorithm;
429 }
430
431
432 inline G4bool CexmcChargeExchangeReconstructor::HasAbsorbedEnergyCutTriggered(
433 void ) const
434 {
435 return hasAbsorbedEnergyCutTriggered;
436 }
437
438
439 #endif
440
441