| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
24 // *******************************************
25 //
26 // INCL++ intra-nuclear cascade model
27 // Alain Boudard, CEA-Saclay, France
28 // Joseph Cugnon, University of Liege, Belgium
29 // Jean-Christophe David, CEA-Saclay, France
30 // Pekka Kaitaniemi, CEA-Saclay, France, and H
31 // Sylvie Leray, CEA-Saclay, France
32 // Davide Mancusi, CEA-Saclay, France
33 //
34 #define INCLXX_IN_GEANT4_MODE 1
35
36 #include "globals.hh"
37
38 #include "G4INCLNNToNSKpiChannel.hh"
39 #include "G4INCLKinematicsUtils.hh"
40 #include "G4INCLBinaryCollisionAvatar.hh"
41 #include "G4INCLRandom.hh"
42 #include "G4INCLGlobals.hh"
43 #include "G4INCLLogger.hh"
44 #include <algorithm>
45 #include "G4INCLPhaseSpaceGenerator.hh"
46
47 namespace G4INCL {
48
49 const G4double NNToNSKpiChannel::angularSlop
50
51 NNToNSKpiChannel::NNToNSKpiChannel(Particle
52 : particle1(p1), particle2(p2)
53 {}
54
55 NNToNSKpiChannel::~NNToNSKpiChannel(){}
56
57 void NNToNSKpiChannel::fillFinalState(FinalS
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::to
77
78 const G4int iso = ParticleTable::getIsospi
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->getP
242 const ThreeVector &rcol2 = particle2->getP
243 const ThreeVector zero;
244 Particle *pion = new Particle(PionType,zer
245 Particle *kaon = new Particle(KaonType,zer
246 list.push_back(kaon);
247 list.push_back(pion);
248
249 if(Random::shoot()<0.5) PhaseSpaceGenerato
250 else PhaseSpaceGenerator::generateBiased(s
251
252 INCL_DEBUG("NNToNSKpi " << (kaon->getMomen
253
254 fs->addModifiedParticle(particle1);
255 fs->addModifiedParticle(particle2);
256 fs->addCreatedParticle(kaon);
257 fs->addCreatedParticle(pion);
258
259 }
260 }
261