Belle II Software development
Public Member Functions | Private Attributes | List of all members
AntiBaryonPhysics Class Reference

Anti-baryon hadronic physics constructor for Belle II physics list. More...

#include <AntiBaryonPhysics.h>

Inheritance diagram for AntiBaryonPhysics:

Public Member Functions

virtual void ConstructParticle () override
 Build processes, models, cross sections used in physics list.
 
virtual void ConstructProcess () override
 Build all particle types used in physics list (empty in this class)
 

Private Attributes

G4TheoFSGenerator * m_ftfp
 Final state generator for QCD string models.
 
G4FTFModel * m_stringModel
 Fritiof string model.
 
G4ExcitedStringDecay * m_stringDecay
 Model to decay strings into hadrons.
 
G4LundStringFragmentation * m_fragModel
 Lund string fragmentation model.
 
G4GeneratorPrecompoundInterface * m_preCompoundModel
 Precompound model to deexcite post-collision nucleus.
 
G4ComponentAntiNuclNuclearXS * m_theAntiNucleonXS
 Cross section set for anti-nucleon nucleus inelastic collisions.
 

Detailed Description

Anti-baryon hadronic physics constructor for Belle II physics list.

Definition at line 32 of file AntiBaryonPhysics.h.

Constructor & Destructor Documentation

◆ AntiBaryonPhysics()

AntiBaryonPhysics ( )

Definition at line 36 of file AntiBaryonPhysics.cc.

37 : m_ftfp(nullptr), m_stringModel(nullptr), m_stringDecay(nullptr),
38 m_fragModel(nullptr), m_preCompoundModel(nullptr),
39 m_theAntiNucleonXS(nullptr)
40{}
Belle2::Simulation::AntiBaryonPhysics::m_preCompoundModel
G4GeneratorPrecompoundInterface * m_preCompoundModel
Precompound model to deexcite post-collision nucleus.
Definition: AntiBaryonPhysics.h:57
Belle2::Simulation::AntiBaryonPhysics::m_ftfp
G4TheoFSGenerator * m_ftfp
Final state generator for QCD string models.
Definition: AntiBaryonPhysics.h:45
Belle2::Simulation::AntiBaryonPhysics::m_stringModel
G4FTFModel * m_stringModel
Fritiof string model.
Definition: AntiBaryonPhysics.h:48
Belle2::Simulation::AntiBaryonPhysics::m_stringDecay
G4ExcitedStringDecay * m_stringDecay
Model to decay strings into hadrons.
Definition: AntiBaryonPhysics.h:51
Belle2::Simulation::AntiBaryonPhysics::m_theAntiNucleonXS
G4ComponentAntiNuclNuclearXS * m_theAntiNucleonXS
Cross section set for anti-nucleon nucleus inelastic collisions.
Definition: AntiBaryonPhysics.h:60
Belle2::Simulation::AntiBaryonPhysics::m_fragModel
G4LundStringFragmentation * m_fragModel
Lund string fragmentation model.
Definition: AntiBaryonPhysics.h:54

◆ ~AntiBaryonPhysics()

~AntiBaryonPhysics ( )

Definition at line 43 of file AntiBaryonPhysics.cc.

44{
45 delete m_stringDecay;
46 delete m_stringModel;
47 delete m_fragModel;
48 delete m_preCompoundModel;
49
50 delete m_theAntiNucleonXS;
51}

Member Function Documentation

◆ ConstructParticle()

void ConstructParticle ( )
overridevirtual

Build processes, models, cross sections used in physics list.

Definition at line 54 of file AntiBaryonPhysics.cc.

55{}

◆ ConstructProcess()

void ConstructProcess ( )
overridevirtual

Build all particle types used in physics list (empty in this class)

Definition at line 58 of file AntiBaryonPhysics.cc.

59{
60 G4ProcessManager* procMan = 0;
61
62 // One elastic model for all anti-hyperon and anti-neutron energies
63 G4HadronElastic* elModel = new G4HadronElastic();
64
65 // Elastic models for anti-(p, d, t, He3, alpha)
66 G4HadronElastic* loelModel = new G4HadronElastic();
67 loelModel->SetMaxEnergy(100.1 * MeV);
68
69 G4AntiNuclElastic* anucEl = new G4AntiNuclElastic();
70 anucEl->SetMinEnergy(100.0 * MeV);
71
72 // Use FTFP for all energies ==>> eventually replace this with new class FTFPInterface
73 m_ftfp = new G4TheoFSGenerator("FTFP");
74 m_stringModel = new G4FTFModel;
75 m_stringDecay =
76 new G4ExcitedStringDecay(m_fragModel = new G4LundStringFragmentation);
77 m_stringModel->SetFragmentationModel(m_stringDecay);
78 m_preCompoundModel = new G4GeneratorPrecompoundInterface();
79
80 m_ftfp->SetHighEnergyGenerator(m_stringModel);
81 m_ftfp->SetTransport(m_preCompoundModel);
82 m_ftfp->SetMinEnergy(0.0);
83 m_ftfp->SetMaxEnergy(100 * TeV);
84
85 // Elastic data set
86 G4CrossSectionElastic* anucElxs =
87 new G4CrossSectionElastic(anucEl->GetComponentCrossSection());
88
89 // Inelastic cross section sets
90 m_theAntiNucleonXS = new G4ComponentAntiNuclNuclearXS;
91 G4VCrossSectionDataSet* antiNucleonData =
92 new G4CrossSectionInelastic(m_theAntiNucleonXS);
93
94 G4ChipsAntiBaryonElasticXS* hchipsElastic = new G4ChipsAntiBaryonElasticXS;
95 G4ChipsAntiBaryonInelasticXS* hchipsInelastic = new G4ChipsAntiBaryonInelasticXS;
96
98 // Anti-proton //
100
101 procMan = G4AntiProton::AntiProton()->GetProcessManager();
102
103 // elastic
104 G4HadronElasticProcess* apProcEl = new G4HadronElasticProcess;
105 apProcEl->RegisterMe(loelModel);
106 apProcEl->RegisterMe(anucEl);
107 apProcEl->AddDataSet(anucElxs);
108 procMan->AddDiscreteProcess(apProcEl);
109
110 // inelastic
111 G4HadronInelasticProcess* apProcInel = new G4HadronInelasticProcess("anti_protonInelastic", G4AntiProton::Definition());
112 apProcInel->RegisterMe(m_ftfp);
113 apProcInel->AddDataSet(antiNucleonData);
114 procMan->AddDiscreteProcess(apProcInel);
115
116 // stopping
117 G4HadronicAbsorptionFritiof* apAbsorb = new G4HadronicAbsorptionFritiof();
118 procMan->AddRestProcess(apAbsorb);
119
121 // Anti-neutron //
123
124 procMan = G4AntiNeutron::AntiNeutron()->GetProcessManager();
125
126 // elastic
127 G4HadronElasticProcess* anProcEl = new G4HadronElasticProcess;
128 anProcEl->RegisterMe(elModel);
129 anProcEl->AddDataSet(hchipsElastic);
130 procMan->AddDiscreteProcess(anProcEl);
131
132 // inelastic
133 G4HadronInelasticProcess* anProcInel = new G4HadronInelasticProcess("anti_neutronInelastic", G4AntiNeutron::Definition());
134 anProcInel->RegisterMe(m_ftfp);
135 anProcInel->AddDataSet(antiNucleonData);
136 procMan->AddDiscreteProcess(anProcInel);
137
139 // Anti-deuteron //
141
142 procMan = G4AntiDeuteron::AntiDeuteron()->GetProcessManager();
143
144 // elastic
145 G4HadronElasticProcess* adProcEl = new G4HadronElasticProcess;
146 adProcEl->RegisterMe(loelModel);
147 adProcEl->RegisterMe(anucEl);
148 adProcEl->AddDataSet(anucElxs);
149 procMan->AddDiscreteProcess(adProcEl);
150
151 // inelastic
152 G4HadronInelasticProcess* adProcInel = new G4HadronInelasticProcess("anti_deuteronInelastic", G4AntiDeuteron::Definition());
153 adProcInel->RegisterMe(m_ftfp);
154 adProcInel->AddDataSet(antiNucleonData);
155 procMan->AddDiscreteProcess(adProcInel);
156
157 // stopping
158 G4HadronicAbsorptionFritiof* adAbsorb = new G4HadronicAbsorptionFritiof();
159 procMan->AddRestProcess(adAbsorb);
160
162 // Anti-triton //
164
165 procMan = G4AntiTriton::AntiTriton()->GetProcessManager();
166
167 // elastic
168 G4HadronElasticProcess* atProcEl = new G4HadronElasticProcess;
169 atProcEl->RegisterMe(loelModel);
170 atProcEl->RegisterMe(anucEl);
171 atProcEl->AddDataSet(anucElxs);
172 procMan->AddDiscreteProcess(atProcEl);
173
174 // inelastic
175 G4HadronInelasticProcess* atProcInel = new G4HadronInelasticProcess("anti_tritonInelastic", G4AntiTriton::Definition());
176 atProcInel->RegisterMe(m_ftfp);
177 atProcInel->AddDataSet(antiNucleonData);
178 procMan->AddDiscreteProcess(atProcInel);
179
180 // stopping
181 G4HadronicAbsorptionFritiof* atAbsorb = new G4HadronicAbsorptionFritiof();
182 procMan->AddRestProcess(atAbsorb);
183
185 // Anti-He3 //
187
188 procMan = G4AntiHe3::AntiHe3()->GetProcessManager();
189
190 // elastic
191 G4HadronElasticProcess* ahe3ProcEl = new G4HadronElasticProcess;
192 ahe3ProcEl->RegisterMe(loelModel);
193 ahe3ProcEl->RegisterMe(anucEl);
194 ahe3ProcEl->AddDataSet(anucElxs);
195 procMan->AddDiscreteProcess(ahe3ProcEl);
196
197 // inelastic
198 G4HadronInelasticProcess* ahe3ProcInel = new G4HadronInelasticProcess("anti_He3Inelastic", G4AntiHe3::Definition());
199 ahe3ProcInel->RegisterMe(m_ftfp);
200 ahe3ProcInel->AddDataSet(antiNucleonData);
201 procMan->AddDiscreteProcess(ahe3ProcInel);
202
203 // stopping
204 G4HadronicAbsorptionFritiof* ahe3Absorb = new G4HadronicAbsorptionFritiof();
205 procMan->AddRestProcess(ahe3Absorb);
206
208 // Anti-alpha //
210
211 procMan = G4AntiAlpha::AntiAlpha()->GetProcessManager();
212
213 // elastic
214 G4HadronElasticProcess* aaProcEl = new G4HadronElasticProcess;
215 aaProcEl->RegisterMe(loelModel);
216 aaProcEl->RegisterMe(anucEl);
217 aaProcEl->AddDataSet(anucElxs);
218 procMan->AddDiscreteProcess(aaProcEl);
219
220 // inelastic
221 G4HadronInelasticProcess* aaProcInel = new G4HadronInelasticProcess("anti_alpha_Inelastic", G4AntiAlpha::Definition());
222 aaProcInel->RegisterMe(m_ftfp);
223 aaProcInel->AddDataSet(antiNucleonData);
224 procMan->AddDiscreteProcess(aaProcInel);
225
226 // stopping
227 G4HadronicAbsorptionFritiof* aaAbsorb = new G4HadronicAbsorptionFritiof();
228 procMan->AddRestProcess(aaAbsorb);
229
231 // Anti-lambda //
233
234 procMan = G4AntiLambda::AntiLambda()->GetProcessManager();
235
236 // elastic
237 G4HadronElasticProcess* alamProcEl = new G4HadronElasticProcess;
238 alamProcEl->RegisterMe(elModel);
239 alamProcEl->AddDataSet(hchipsElastic);
240 procMan->AddDiscreteProcess(alamProcEl);
241
242 // inelastic
243 G4HadronInelasticProcess* alamProcInel = new G4HadronInelasticProcess("anti-lambdaInelastic", G4AntiLambda::Definition());
244 alamProcInel->RegisterMe(m_ftfp);
245 alamProcInel->AddDataSet(hchipsInelastic);
246 procMan->AddDiscreteProcess(alamProcInel);
247
249 // Anti-sigma+ //
251
252 procMan = G4AntiSigmaPlus::AntiSigmaPlus()->GetProcessManager();
253
254 // elastic
255 G4HadronElasticProcess* aspProcEl = new G4HadronElasticProcess;
256 aspProcEl->RegisterMe(elModel);
257 aspProcEl->AddDataSet(hchipsElastic);
258 procMan->AddDiscreteProcess(aspProcEl);
259
260 // inelastic
261 G4HadronInelasticProcess* aspProcInel = new G4HadronInelasticProcess("anti_sigma+Inelastic", G4AntiSigmaPlus::Definition());
262 aspProcInel->RegisterMe(m_ftfp);
263 aspProcInel->AddDataSet(hchipsInelastic);
264 procMan->AddDiscreteProcess(aspProcInel);
265
266 // stopping
267 G4HadronicAbsorptionFritiof* aspAbsorb = new G4HadronicAbsorptionFritiof();
268 procMan->AddRestProcess(aspAbsorb);
269
271 // Anti-sigma- //
273
274 procMan = G4AntiSigmaMinus::AntiSigmaMinus()->GetProcessManager();
275
276 // elastic
277 G4HadronElasticProcess* asmProcEl = new G4HadronElasticProcess;
278 asmProcEl->RegisterMe(elModel);
279 asmProcEl->AddDataSet(hchipsElastic);
280 procMan->AddDiscreteProcess(asmProcEl);
281
282 // inelastic
283 G4HadronInelasticProcess* asmProcInel = new G4HadronInelasticProcess("anti_sigma-Inelastic", G4AntiSigmaMinus::Definition());
284 asmProcInel->RegisterMe(m_ftfp);
285 asmProcInel->AddDataSet(hchipsInelastic);
286 procMan->AddDiscreteProcess(asmProcInel);
287
289 // Anti-xi0 //
291
292 procMan = G4AntiXiZero::AntiXiZero()->GetProcessManager();
293
294 // elastic
295 G4HadronElasticProcess* axzProcEl = new G4HadronElasticProcess;
296 axzProcEl->RegisterMe(elModel);
297 axzProcEl->AddDataSet(hchipsElastic);
298 procMan->AddDiscreteProcess(axzProcEl);
299
300 // inelastic
301 G4HadronInelasticProcess* axzProcInel = new G4HadronInelasticProcess("anti_xi0Inelastic", G4AntiXiZero::Definition());
302 axzProcInel->RegisterMe(m_ftfp);
303 axzProcInel->AddDataSet(hchipsInelastic);
304 procMan->AddDiscreteProcess(axzProcInel);
305
307 // Anti-xi- //
309
310 procMan = G4AntiXiMinus::AntiXiMinus()->GetProcessManager();
311
312 // elastic
313 G4HadronElasticProcess* axmProcEl = new G4HadronElasticProcess;
314 axmProcEl->RegisterMe(elModel);
315 axmProcEl->AddDataSet(hchipsElastic);
316 procMan->AddDiscreteProcess(axmProcEl);
317
318 // inelastic
319 G4HadronInelasticProcess* axmProcInel = new G4HadronInelasticProcess("anti_xi-Inelastic", G4AntiXiMinus::Definition());
320 axmProcInel->RegisterMe(m_ftfp);
321 axmProcInel->AddDataSet(hchipsInelastic);
322 procMan->AddDiscreteProcess(axmProcInel);
323
325 // Anti-omega- //
327
328 procMan = G4AntiOmegaMinus::AntiOmegaMinus()->GetProcessManager();
329
330 // elastic
331 G4HadronElasticProcess* aomProcEl = new G4HadronElasticProcess;
332 aomProcEl->RegisterMe(elModel);
333 aomProcEl->AddDataSet(hchipsElastic);
334 procMan->AddDiscreteProcess(aomProcEl);
335
336 // inelastic
337 G4HadronInelasticProcess* aomProcInel = new G4HadronInelasticProcess("anti_omega-Inelastic", G4AntiOmegaMinus::Definition());
338 aomProcInel->RegisterMe(m_ftfp);
339 aomProcInel->AddDataSet(hchipsInelastic);
340 procMan->AddDiscreteProcess(aomProcInel);
341
342}

Member Data Documentation

◆ m_fragModel

G4LundStringFragmentation* m_fragModel
private

Lund string fragmentation model.

Definition at line 54 of file AntiBaryonPhysics.h.

◆ m_ftfp

G4TheoFSGenerator* m_ftfp
private

Final state generator for QCD string models.

Definition at line 45 of file AntiBaryonPhysics.h.

◆ m_preCompoundModel

G4GeneratorPrecompoundInterface* m_preCompoundModel
private

Precompound model to deexcite post-collision nucleus.

Definition at line 57 of file AntiBaryonPhysics.h.

◆ m_stringDecay

G4ExcitedStringDecay* m_stringDecay
private

Model to decay strings into hadrons.

Definition at line 51 of file AntiBaryonPhysics.h.

◆ m_stringModel

G4FTFModel* m_stringModel
private

Fritiof string model.

Definition at line 48 of file AntiBaryonPhysics.h.

◆ m_theAntiNucleonXS

G4ComponentAntiNuclNuclearXS* m_theAntiNucleonXS
private

Cross section set for anti-nucleon nucleus inelastic collisions.

Definition at line 60 of file AntiBaryonPhysics.h.

The documentation for this class was generated from the following files: