Geant4 10.7.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Member Functions | List of all members
G4INCL::NNToNSKpiChannel Class Reference

#include <G4INCLNNToNSKpiChannel.hh>

+ Inheritance diagram for G4INCL::NNToNSKpiChannel:

Public Member Functions

 NNToNSKpiChannel (Particle *, Particle *)
 
virtual ~NNToNSKpiChannel ()
 
void fillFinalState (FinalState *fs)
 
- Public Member Functions inherited from G4INCL::IChannel
 IChannel ()
 
virtual ~IChannel ()
 
FinalState * getFinalState ()
 
virtual void fillFinalState (FinalState *fs)=0
 

Detailed Description

Definition at line 47 of file G4INCLNNToNSKpiChannel.hh.

Constructor & Destructor Documentation

◆ NNToNSKpiChannel()

G4INCL::NNToNSKpiChannel::NNToNSKpiChannel ( Particle *  p1,
Particle *  p2 
)

Definition at line 51 of file G4INCLNNToNSKpiChannel.cc.

52 : particle1(p1), particle2(p2)
53 {}

◆ ~NNToNSKpiChannel()

G4INCL::NNToNSKpiChannel::~NNToNSKpiChannel ( )
virtual

Definition at line 55 of file G4INCLNNToNSKpiChannel.cc.

55{}

Member Function Documentation

◆ fillFinalState()

void G4INCL::NNToNSKpiChannel::fillFinalState ( FinalState *  fs)
virtual

Implements G4INCL::IChannel.

Definition at line 57 of file G4INCLNNToNSKpiChannel.cc.

57 {
58
59 // pp (36) pn (36)
60 //
61 // pp -> p pi+ S- K+ (9)
62 // pp -> p pi+ S0 K0 (9)
63 // pp -> p pi0 S+ K0 (4)
64 // pp -> n pi+ S+ K0 (2)
65 // pp -> p pi0 S0 K+ (4)
66 // pp -> n pi+ S0 K+ (2)
67 // pp -> p pi- S+ K+ (2)
68 // pp -> n pi0 S+ K+ (4)
69
70 // pn -> p pi0 S- K+ (4)
71 // pn -> n pi+ S- K+ (2)
72 // pn -> p pi0 S0 K0 (2)
73 // pn -> n pi+ S0 K0 (1)
74 // pn -> p pi+ S- K0 (9)
75
76 const G4double sqrtS = KinematicsUtils::totalEnergyInCM(particle1, particle2);
77
78 const G4int iso = ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
79
80 ParticleType KaonType;
81 ParticleType PionType;
82
83 G4double rdm = Random::shoot();
84
85 if(iso == 2){
86 if(rdm * 36. < 9.){
87 KaonType = KPlus;
88 PionType = PiPlus;
89 particle2->setType(SigmaMinus);
90 }
91 else if(rdm * 36. < 18.){
92 KaonType = KZero;
93 PionType = PiPlus;
94 particle2->setType(SigmaZero);
95 }
96 else if(rdm * 36. < 22.){
97 KaonType = KZero;
98 PionType = PiZero;
99 particle2->setType(SigmaPlus);
100 }
101 else if(rdm * 36. < 24.){
102 KaonType = KZero;
103 PionType = PiPlus;
104 particle1->setType(Neutron);
105 particle2->setType(SigmaPlus);
106 }
107 else if(rdm * 36. < 28.){
108 KaonType = KPlus;
109 PionType = PiZero;
110 particle2->setType(SigmaZero);
111 }
112 else if(rdm * 36. < 30.){
113 KaonType = KPlus;
114 PionType = PiPlus;
115 particle1->setType(Neutron);
116 particle2->setType(SigmaZero);
117 }
118 else if(rdm * 36. < 32.){
119 KaonType = KPlus;
120 PionType = PiMinus;
121 particle2->setType(SigmaPlus);
122 }
123 else{
124 KaonType = KPlus;
125 PionType = PiZero;
126 particle1->setType(Neutron);
127 particle2->setType(SigmaPlus);
128 }
129
130 }
131 else if(iso == -2){
132 if(rdm * 36. < 9.){
133 KaonType = KZero;
134 PionType = PiMinus;
135 particle2->setType(SigmaPlus);
136 }
137 else if(rdm * 36. < 18.){
138 KaonType = KPlus;
139 PionType = PiMinus;
140 particle2->setType(SigmaZero);
141 }
142 else if(rdm * 36. < 22.){
143 KaonType = KPlus;
144 PionType = PiZero;
145 particle2->setType(SigmaMinus);
146 }
147 else if(rdm * 36. < 24.){
148 KaonType = KPlus;
149 PionType = PiMinus;
150 particle1->setType(Proton);
151 particle2->setType(SigmaMinus);
152 }
153 else if(rdm * 36. < 28.){
154 KaonType = KZero;
155 PionType = PiZero;
156 particle2->setType(SigmaZero);
157 }
158 else if(rdm * 36. < 30.){
159 KaonType = KZero;
160 PionType = PiMinus;
161 particle1->setType(Proton);
162 particle2->setType(SigmaZero);
163 }
164 else if(rdm * 36. < 32.){
165 KaonType = KZero;
166 PionType = PiPlus;
167 particle2->setType(SigmaMinus);
168 }
169 else{
170 KaonType = KZero;
171 PionType = PiZero;
172 particle1->setType(Proton);
173 particle2->setType(SigmaMinus);
174 }
175
176 }
177 else if(rdm*36. < 4.){
178 KaonType = KPlus;
179 PionType = PiZero;
180 particle1->setType(Proton);
181 particle2->setType(SigmaMinus);
182 }
183 else if(rdm*36. < 6.){
184 KaonType = KZero;
185 PionType = PiZero;
186 particle1->setType(Neutron);
187 particle2->setType(SigmaPlus);
188 }
189 else if(rdm*36. < 8.){
190 KaonType = KPlus;
191 PionType = PiPlus;
192 particle1->setType(Neutron);
193 particle2->setType(SigmaMinus);
194 }
195 else if(rdm*36. < 9.){
196 KaonType = KZero;
197 PionType = PiMinus;
198 particle1->setType(Proton);
199 particle2->setType(SigmaPlus);
200 }
201 else if(rdm*36. < 18.){
202 KaonType = KZero;
203 PionType = PiZero;
204 particle1->setType(Proton);
205 particle2->setType(SigmaZero);
206 }
207 else if(rdm*36. < 27.){
208 KaonType = KPlus;
209 PionType = PiZero;
210 particle1->setType(Neutron);
211 particle2->setType(SigmaZero);
212 }
213 else if(rdm*36. < 28.){
214 KaonType = KZero;
215 PionType = PiPlus;
216 particle1->setType(Neutron);
217 particle2->setType(SigmaZero);
218 }
219 else if(rdm*36. < 30.){
220 KaonType = KPlus;
221 PionType = PiMinus;
222 particle1->setType(Proton);
223 particle2->setType(SigmaZero);
224 }
225 else if(rdm*36. < 32.){
226 KaonType = KZero;
227 PionType = PiPlus;
228 particle1->setType(Proton);
229 particle2->setType(SigmaMinus);
230 }
231 else{
232 KaonType = KPlus;
233 PionType = PiMinus;
234 particle1->setType(Neutron);
235 particle2->setType(SigmaPlus);
236 }
237
238 ParticleList list;
239 list.push_back(particle1);
240 list.push_back(particle2);
241 const ThreeVector &rcol1 = particle1->getPosition();
242 const ThreeVector &rcol2 = particle2->getPosition();
243 const ThreeVector zero;
244 Particle *pion = new Particle(PionType,zero,rcol1);
245 Particle *kaon = new Particle(KaonType,zero,rcol2);
246 list.push_back(kaon);
247 list.push_back(pion);
248
249 if(Random::shoot()<0.5) PhaseSpaceGenerator::generateBiased(sqrtS, list, 0, angularSlope);
250 else PhaseSpaceGenerator::generateBiased(sqrtS, list, 1, angularSlope);
251
252 INCL_DEBUG("NNToNSKpi " << (kaon->getMomentum().theta()) * 180. / G4INCL::Math::pi << '\n');
253
254 fs->addModifiedParticle(particle1);
255 fs->addModifiedParticle(particle2);
256 fs->addCreatedParticle(kaon);
257 fs->addCreatedParticle(pion);
258
259 }
INCL_DEBUG
#define INCL_DEBUG(x)
Definition: G4INCLLogger.hh:240
G4double
double G4double
Definition: G4Types.hh:83
G4int
int G4int
Definition: G4Types.hh:85
G4INCL::Particle::getPosition
const G4INCL::ThreeVector & getPosition() const
Definition: G4INCLParticle.hh:816
G4INCL::Particle::getType
G4INCL::ParticleType getType() const
Definition: G4INCLParticle.hh:178
G4INCL::Particle::setType
void setType(ParticleType t)
Definition: G4INCLParticle.hh:187
G4INCL::KinematicsUtils::totalEnergyInCM
G4double totalEnergyInCM(Particle const *const p1, Particle const *const p2)
Definition: G4INCLKinematicsUtils.cc:94
G4INCL::Math::pi
const G4double pi
Definition: G4INCLGlobals.hh:68
G4INCL::ParticleTable::getIsospin
G4int getIsospin(const ParticleType t)
Get the isospin of a particle.
Definition: G4INCLParticleTable.cc:478
G4INCL::PhaseSpaceGenerator::generateBiased
void generateBiased(const G4double sqrtS, ParticleList &particles, const size_t index, const G4double slope)
Generate a biased event in the CM system.
Definition: G4INCLPhaseSpaceGenerator.cc:98
G4INCL::Random::shoot
G4double shoot()
Definition: G4INCLRandom.cc:93
G4InuclParticleNames::pion
G4bool pion(G4int ityp)
Definition: G4InuclParticleNames.hh:90
The documentation for this class was generated from the following files: