Belle II Software  release-05-01-25
AntiBaryonPhysics.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(c) 2018 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributor: Dennis Wright (SLAC) *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 #include <simulation/physicslist/AntiBaryonPhysics.h>
12 
13 #include "G4ProcessManager.hh"
14 #include "G4AntiProtonInelasticProcess.hh"
15 #include "G4AntiNeutronInelasticProcess.hh"
16 #include "G4AntiLambdaInelasticProcess.hh"
17 #include "G4AntiSigmaPlusInelasticProcess.hh"
18 #include "G4AntiSigmaMinusInelasticProcess.hh"
19 #include "G4AntiXiZeroInelasticProcess.hh"
20 #include "G4AntiXiMinusInelasticProcess.hh"
21 #include "G4AntiOmegaMinusInelasticProcess.hh"
22 
23 #include "G4AntiDeuteronInelasticProcess.hh"
24 #include "G4AntiTritonInelasticProcess.hh"
25 #include "G4AntiHe3InelasticProcess.hh"
26 #include "G4AntiAlphaInelasticProcess.hh"
27 #include "G4HadronElasticProcess.hh"
28 
29 #include "G4TheoFSGenerator.hh"
30 #include "G4FTFModel.hh"
31 #include "G4ExcitedStringDecay.hh"
32 #include "G4LundStringFragmentation.hh"
33 #include "G4GeneratorPrecompoundInterface.hh"
34 #include "G4HadronElastic.hh"
35 #include "G4AntiNuclElastic.hh"
36 #include "G4HadronicAbsorptionFritiof.hh"
37 
38 #include "G4ChipsAntiBaryonElasticXS.hh"
39 #include "G4ChipsAntiBaryonInelasticXS.hh"
40 #include "G4ComponentAntiNuclNuclearXS.hh"
41 #include "G4CrossSectionInelastic.hh"
42 #include "G4CrossSectionElastic.hh"
43 
44 #include "G4SystemOfUnits.hh"
45 
46 using namespace Belle2;
47 using namespace Simulation;
48 
49 
50 AntiBaryonPhysics::AntiBaryonPhysics()
51  : m_ftfp(nullptr), m_stringModel(nullptr), m_stringDecay(nullptr),
52  m_fragModel(nullptr), m_preCompoundModel(nullptr),
53  m_theAntiNucleonXS(nullptr)
54 {}
55 
56 
57 AntiBaryonPhysics::~AntiBaryonPhysics()
58 {
59  delete m_stringDecay;
60  delete m_stringModel;
61  delete m_fragModel;
62  delete m_preCompoundModel;
63 
64  delete m_theAntiNucleonXS;
65 }
66 
67 
69 {}
70 
71 
73 {
74  G4ProcessManager* procMan = 0;
75 
76  // One elastic model for all anti-hyperon and anti-neutron energies
77  G4HadronElastic* elModel = new G4HadronElastic();
78 
79  // Elastic models for anti-(p, d, t, He3, alpha)
80  G4HadronElastic* loelModel = new G4HadronElastic();
81  loelModel->SetMaxEnergy(100.1 * MeV);
82 
83  G4AntiNuclElastic* anucEl = new G4AntiNuclElastic();
84  anucEl->SetMinEnergy(100.0 * MeV);
85 
86  // Use FTFP for all energies ==>> eventually replace this with new class FTFPInterface
87  m_ftfp = new G4TheoFSGenerator("FTFP");
88  m_stringModel = new G4FTFModel;
90  new G4ExcitedStringDecay(m_fragModel = new G4LundStringFragmentation);
91  m_stringModel->SetFragmentationModel(m_stringDecay);
92  m_preCompoundModel = new G4GeneratorPrecompoundInterface();
93 
94  m_ftfp->SetHighEnergyGenerator(m_stringModel);
95  m_ftfp->SetTransport(m_preCompoundModel);
96  m_ftfp->SetMinEnergy(0.0);
97  m_ftfp->SetMaxEnergy(100 * TeV);
98 
99  // Elastic data set
100  G4CrossSectionElastic* anucElxs =
101  new G4CrossSectionElastic(anucEl->GetComponentCrossSection());
102 
103  // Inelastic cross section sets
104  m_theAntiNucleonXS = new G4ComponentAntiNuclNuclearXS;
105  G4VCrossSectionDataSet* antiNucleonData =
106  new G4CrossSectionInelastic(m_theAntiNucleonXS);
107 
108  G4ChipsAntiBaryonElasticXS* hchipsElastic = new G4ChipsAntiBaryonElasticXS;
109  G4ChipsAntiBaryonInelasticXS* hchipsInelastic = new G4ChipsAntiBaryonInelasticXS;
110 
112  // Anti-proton //
114 
115  procMan = G4AntiProton::AntiProton()->GetProcessManager();
116 
117  // elastic
118  G4HadronElasticProcess* apProcEl = new G4HadronElasticProcess;
119  apProcEl->RegisterMe(loelModel);
120  apProcEl->RegisterMe(anucEl);
121  apProcEl->AddDataSet(anucElxs);
122  procMan->AddDiscreteProcess(apProcEl);
123 
124  // inelastic
125  G4AntiProtonInelasticProcess* apProcInel = new G4AntiProtonInelasticProcess;
126  apProcInel->RegisterMe(m_ftfp);
127  apProcInel->AddDataSet(antiNucleonData);
128  procMan->AddDiscreteProcess(apProcInel);
129 
130  // stopping
131  G4HadronicAbsorptionFritiof* apAbsorb = new G4HadronicAbsorptionFritiof();
132  procMan->AddRestProcess(apAbsorb);
133 
135  // Anti-neutron //
137 
138  procMan = G4AntiNeutron::AntiNeutron()->GetProcessManager();
139 
140  // elastic
141  G4HadronElasticProcess* anProcEl = new G4HadronElasticProcess;
142  anProcEl->RegisterMe(elModel);
143  anProcEl->AddDataSet(hchipsElastic);
144  procMan->AddDiscreteProcess(anProcEl);
145 
146  // inelastic
147  G4AntiNeutronInelasticProcess* anProcInel = new G4AntiNeutronInelasticProcess;
148  anProcInel->RegisterMe(m_ftfp);
149  anProcInel->AddDataSet(antiNucleonData);
150  procMan->AddDiscreteProcess(anProcInel);
151 
153  // Anti-deuteron //
155 
156  procMan = G4AntiDeuteron::AntiDeuteron()->GetProcessManager();
157 
158  // elastic
159  G4HadronElasticProcess* adProcEl = new G4HadronElasticProcess;
160  adProcEl->RegisterMe(loelModel);
161  adProcEl->RegisterMe(anucEl);
162  adProcEl->AddDataSet(anucElxs);
163  procMan->AddDiscreteProcess(adProcEl);
164 
165  // inelastic
166  G4AntiDeuteronInelasticProcess* adProcInel = new G4AntiDeuteronInelasticProcess;
167  adProcInel->RegisterMe(m_ftfp);
168  adProcInel->AddDataSet(antiNucleonData);
169  procMan->AddDiscreteProcess(adProcInel);
170 
171  // stopping
172  G4HadronicAbsorptionFritiof* adAbsorb = new G4HadronicAbsorptionFritiof();
173  procMan->AddRestProcess(adAbsorb);
174 
176  // Anti-triton //
178 
179  procMan = G4AntiTriton::AntiTriton()->GetProcessManager();
180 
181  // elastic
182  G4HadronElasticProcess* atProcEl = new G4HadronElasticProcess;
183  atProcEl->RegisterMe(loelModel);
184  atProcEl->RegisterMe(anucEl);
185  atProcEl->AddDataSet(anucElxs);
186  procMan->AddDiscreteProcess(atProcEl);
187 
188  // inelastic
189  G4AntiTritonInelasticProcess* atProcInel = new G4AntiTritonInelasticProcess;
190  atProcInel->RegisterMe(m_ftfp);
191  atProcInel->AddDataSet(antiNucleonData);
192  procMan->AddDiscreteProcess(atProcInel);
193 
194  // stopping
195  G4HadronicAbsorptionFritiof* atAbsorb = new G4HadronicAbsorptionFritiof();
196  procMan->AddRestProcess(atAbsorb);
197 
199  // Anti-He3 //
201 
202  procMan = G4AntiHe3::AntiHe3()->GetProcessManager();
203 
204  // elastic
205  G4HadronElasticProcess* ahe3ProcEl = new G4HadronElasticProcess;
206  ahe3ProcEl->RegisterMe(loelModel);
207  ahe3ProcEl->RegisterMe(anucEl);
208  ahe3ProcEl->AddDataSet(anucElxs);
209  procMan->AddDiscreteProcess(ahe3ProcEl);
210 
211  // inelastic
212  G4AntiHe3InelasticProcess* ahe3ProcInel = new G4AntiHe3InelasticProcess;
213  ahe3ProcInel->RegisterMe(m_ftfp);
214  ahe3ProcInel->AddDataSet(antiNucleonData);
215  procMan->AddDiscreteProcess(ahe3ProcInel);
216 
217  // stopping
218  G4HadronicAbsorptionFritiof* ahe3Absorb = new G4HadronicAbsorptionFritiof();
219  procMan->AddRestProcess(ahe3Absorb);
220 
222  // Anti-alpha //
224 
225  procMan = G4AntiAlpha::AntiAlpha()->GetProcessManager();
226 
227  // elastic
228  G4HadronElasticProcess* aaProcEl = new G4HadronElasticProcess;
229  aaProcEl->RegisterMe(loelModel);
230  aaProcEl->RegisterMe(anucEl);
231  aaProcEl->AddDataSet(anucElxs);
232  procMan->AddDiscreteProcess(aaProcEl);
233 
234  // inelastic
235  G4AntiAlphaInelasticProcess* aaProcInel = new G4AntiAlphaInelasticProcess;
236  aaProcInel->RegisterMe(m_ftfp);
237  aaProcInel->AddDataSet(antiNucleonData);
238  procMan->AddDiscreteProcess(aaProcInel);
239 
240  // stopping
241  G4HadronicAbsorptionFritiof* aaAbsorb = new G4HadronicAbsorptionFritiof();
242  procMan->AddRestProcess(aaAbsorb);
243 
245  // Anti-lambda //
247 
248  procMan = G4AntiLambda::AntiLambda()->GetProcessManager();
249 
250  // elastic
251  G4HadronElasticProcess* alamProcEl = new G4HadronElasticProcess;
252  alamProcEl->RegisterMe(elModel);
253  alamProcEl->AddDataSet(hchipsElastic);
254  procMan->AddDiscreteProcess(alamProcEl);
255 
256  // inelastic
257  G4AntiLambdaInelasticProcess* alamProcInel = new G4AntiLambdaInelasticProcess;
258  alamProcInel->RegisterMe(m_ftfp);
259  alamProcInel->AddDataSet(hchipsInelastic);
260  procMan->AddDiscreteProcess(alamProcInel);
261 
263  // Anti-sigma+ //
265 
266  procMan = G4AntiSigmaPlus::AntiSigmaPlus()->GetProcessManager();
267 
268  // elastic
269  G4HadronElasticProcess* aspProcEl = new G4HadronElasticProcess;
270  aspProcEl->RegisterMe(elModel);
271  aspProcEl->AddDataSet(hchipsElastic);
272  procMan->AddDiscreteProcess(aspProcEl);
273 
274  // inelastic
275  G4AntiSigmaPlusInelasticProcess* aspProcInel = new G4AntiSigmaPlusInelasticProcess;
276  aspProcInel->RegisterMe(m_ftfp);
277  aspProcInel->AddDataSet(hchipsInelastic);
278  procMan->AddDiscreteProcess(aspProcInel);
279 
280  // stopping
281  G4HadronicAbsorptionFritiof* aspAbsorb = new G4HadronicAbsorptionFritiof();
282  procMan->AddRestProcess(aspAbsorb);
283 
285  // Anti-sigma- //
287 
288  procMan = G4AntiSigmaMinus::AntiSigmaMinus()->GetProcessManager();
289 
290  // elastic
291  G4HadronElasticProcess* asmProcEl = new G4HadronElasticProcess;
292  asmProcEl->RegisterMe(elModel);
293  asmProcEl->AddDataSet(hchipsElastic);
294  procMan->AddDiscreteProcess(asmProcEl);
295 
296  // inelastic
297  G4AntiSigmaMinusInelasticProcess* asmProcInel = new G4AntiSigmaMinusInelasticProcess;
298  asmProcInel->RegisterMe(m_ftfp);
299  asmProcInel->AddDataSet(hchipsInelastic);
300  procMan->AddDiscreteProcess(asmProcInel);
301 
303  // Anti-xi0 //
305 
306  procMan = G4AntiXiZero::AntiXiZero()->GetProcessManager();
307 
308  // elastic
309  G4HadronElasticProcess* axzProcEl = new G4HadronElasticProcess;
310  axzProcEl->RegisterMe(elModel);
311  axzProcEl->AddDataSet(hchipsElastic);
312  procMan->AddDiscreteProcess(axzProcEl);
313 
314  // inelastic
315  G4AntiXiZeroInelasticProcess* axzProcInel = new G4AntiXiZeroInelasticProcess;
316  axzProcInel->RegisterMe(m_ftfp);
317  axzProcInel->AddDataSet(hchipsInelastic);
318  procMan->AddDiscreteProcess(axzProcInel);
319 
321  // Anti-xi- //
323 
324  procMan = G4AntiXiMinus::AntiXiMinus()->GetProcessManager();
325 
326  // elastic
327  G4HadronElasticProcess* axmProcEl = new G4HadronElasticProcess;
328  axmProcEl->RegisterMe(elModel);
329  axmProcEl->AddDataSet(hchipsElastic);
330  procMan->AddDiscreteProcess(axmProcEl);
331 
332  // inelastic
333  G4AntiXiMinusInelasticProcess* axmProcInel = new G4AntiXiMinusInelasticProcess;
334  axmProcInel->RegisterMe(m_ftfp);
335  axmProcInel->AddDataSet(hchipsInelastic);
336  procMan->AddDiscreteProcess(axmProcInel);
337 
339  // Anti-omega- //
341 
342  procMan = G4AntiOmegaMinus::AntiOmegaMinus()->GetProcessManager();
343 
344  // elastic
345  G4HadronElasticProcess* aomProcEl = new G4HadronElasticProcess;
346  aomProcEl->RegisterMe(elModel);
347  aomProcEl->AddDataSet(hchipsElastic);
348  procMan->AddDiscreteProcess(aomProcEl);
349 
350  // inelastic
351  G4AntiOmegaMinusInelasticProcess* aomProcInel = new G4AntiOmegaMinusInelasticProcess;
352  aomProcInel->RegisterMe(m_ftfp);
353  aomProcInel->AddDataSet(hchipsInelastic);
354  procMan->AddDiscreteProcess(aomProcInel);
355 
356 }
357 
Belle2::Simulation::AntiBaryonPhysics::m_theAntiNucleonXS
G4ComponentAntiNuclNuclearXS * m_theAntiNucleonXS
Cross section set for anti-nucleon nucleus inelastic collisions.
Definition: AntiBaryonPhysics.h:62
Belle2::Simulation::AntiBaryonPhysics::m_preCompoundModel
G4GeneratorPrecompoundInterface * m_preCompoundModel
Precompound model to deexcite post-collision nucleus.
Definition: AntiBaryonPhysics.h:59
Belle2::Simulation::AntiBaryonPhysics::m_ftfp
G4TheoFSGenerator * m_ftfp
Final state generator for QCD string models.
Definition: AntiBaryonPhysics.h:47
Belle2::Simulation::AntiBaryonPhysics::ConstructProcess
virtual void ConstructProcess() override
Build all particle types used in physics list (empty in this class)
Definition: AntiBaryonPhysics.cc:72
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::Simulation::AntiBaryonPhysics::m_stringDecay
G4ExcitedStringDecay * m_stringDecay
Model to decay strings into hadrons.
Definition: AntiBaryonPhysics.h:53
Belle2::Simulation::AntiBaryonPhysics::m_stringModel
G4FTFModel * m_stringModel
Fritiof string model.
Definition: AntiBaryonPhysics.h:50
Belle2::Simulation::AntiBaryonPhysics::ConstructParticle
virtual void ConstructParticle() override
Build processes, models, cross sections used in physics list.
Definition: AntiBaryonPhysics.cc:68
Belle2::Simulation::AntiBaryonPhysics::m_fragModel
G4LundStringFragmentation * m_fragModel
Lund string fragmentation model.
Definition: AntiBaryonPhysics.h:56