Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/hadronic/models/inclxx/incl_physics/src/G4INCLNDeltaToDeltaSKChannel.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /processes/hadronic/models/inclxx/incl_physics/src/G4INCLNDeltaToDeltaSKChannel.cc (Version 11.3.0) and /processes/hadronic/models/inclxx/incl_physics/src/G4INCLNDeltaToDeltaSKChannel.cc (Version 11.0.p4)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 // INCL++ intra-nuclear cascade model              26 // INCL++ intra-nuclear cascade model
 27 // Alain Boudard, CEA-Saclay, France               27 // Alain Boudard, CEA-Saclay, France
 28 // Joseph Cugnon, University of Liege, Belgium     28 // Joseph Cugnon, University of Liege, Belgium
 29 // Jean-Christophe David, CEA-Saclay, France       29 // Jean-Christophe David, CEA-Saclay, France
 30 // Pekka Kaitaniemi, CEA-Saclay, France, and H     30 // Pekka Kaitaniemi, CEA-Saclay, France, and Helsinki Institute of Physics, Finland
 31 // Sylvie Leray, CEA-Saclay, France                31 // Sylvie Leray, CEA-Saclay, France
 32 // Davide Mancusi, CEA-Saclay, France              32 // Davide Mancusi, CEA-Saclay, France
 33 //                                                 33 //
 34 #define INCLXX_IN_GEANT4_MODE 1                    34 #define INCLXX_IN_GEANT4_MODE 1
 35                                                    35 
 36 #include "globals.hh"                              36 #include "globals.hh"
 37                                                    37 
 38 #include "G4INCLNDeltaToDeltaSKChannel.hh"         38 #include "G4INCLNDeltaToDeltaSKChannel.hh"
 39 #include "G4INCLKinematicsUtils.hh"                39 #include "G4INCLKinematicsUtils.hh"
 40 #include "G4INCLBinaryCollisionAvatar.hh"          40 #include "G4INCLBinaryCollisionAvatar.hh"
 41 #include "G4INCLRandom.hh"                         41 #include "G4INCLRandom.hh"
 42 #include "G4INCLGlobals.hh"                        42 #include "G4INCLGlobals.hh"
 43 #include "G4INCLLogger.hh"                         43 #include "G4INCLLogger.hh"
 44 #include <algorithm>                               44 #include <algorithm>
 45 #include "G4INCLPhaseSpaceGenerator.hh"            45 #include "G4INCLPhaseSpaceGenerator.hh"
 46                                                    46 
 47 namespace G4INCL {                                 47 namespace G4INCL {
 48                                                    48   
 49   const G4double NDeltaToDeltaSKChannel::angul     49   const G4double NDeltaToDeltaSKChannel::angularSlope = 2.;
 50                                                    50   
 51   NDeltaToDeltaSKChannel::NDeltaToDeltaSKChann     51   NDeltaToDeltaSKChannel::NDeltaToDeltaSKChannel(Particle *p1, Particle *p2)
 52     : particle1(p1), particle2(p2)                 52     : particle1(p1), particle2(p2)
 53     {}                                             53     {}
 54                                                    54   
 55   NDeltaToDeltaSKChannel::~NDeltaToDeltaSKChan     55   NDeltaToDeltaSKChannel::~NDeltaToDeltaSKChannel(){}
 56                                                    56   
 57   G4double NDeltaToDeltaSKChannel::sampleDelta     57   G4double NDeltaToDeltaSKChannel::sampleDeltaMass(G4double ecm) {
 58     const G4double maxDeltaMass = ecm - Partic     58     const G4double maxDeltaMass = ecm - ParticleTable::effectiveSigmaMass - ParticleTable::effectiveKaonMass - 1.0;
 59     const G4double maxDeltaMassRndm = std::ata     59     const G4double maxDeltaMassRndm = std::atan((maxDeltaMass-ParticleTable::effectiveDeltaMass)*2./ParticleTable::effectiveDeltaWidth); // atan((mass-1232)*2/130)
 60     const G4double deltaMassRndmRange = maxDel     60     const G4double deltaMassRndmRange = maxDeltaMassRndm - ParticleTable::minDeltaMassRndm; // atan
 61 // assert(deltaMassRndmRange>0.);                  61 // assert(deltaMassRndmRange>0.);
 62                                                    62 
 63     G4double y=ecm*ecm;                            63     G4double y=ecm*ecm;
 64     G4double q2=(y-1.157776E6)*(y-6.4E5)/y/4.0     64     G4double q2=(y-1.157776E6)*(y-6.4E5)/y/4.0; // 1.157776E6 = 1076^2 = (mNucleon + mPion)^2, 6.4E5 = 800^2 = (mNucleon - mPion)^2  // (prc56(1997)2431) (eq 3.7)^2
 65     G4double q3=std::pow(std::sqrt(q2), 3.);       65     G4double q3=std::pow(std::sqrt(q2), 3.);
 66     const G4double f3max=q3/(q3+5.832E6); // 5     66     const G4double f3max=q3/(q3+5.832E6); // 5.832E6 = 180^3 = cut_parameter^3 // (prc56(1997)2431) (cf eq 3.6)
 67     G4double x;                                    67     G4double x;
 68                                                    68 
 69     G4int nTries = 0;                              69     G4int nTries = 0;
 70     G4bool success = false;                        70     G4bool success = false;
 71     while(!success) { /* Loop checking, 10.07.     71     while(!success) { /* Loop checking, 10.07.2015, D.Mancusi */
 72       if(++nTries >= 100000) {                     72       if(++nTries >= 100000) {
 73         INCL_WARN("NDeltaToDeltaSKChannel::sam     73         INCL_WARN("NDeltaToDeltaSKChannel::sampleDeltaMass loop was stopped because maximum number of tries was reached. Minimum delta mass "
 74               << ParticleTable::minDeltaMass <     74               << ParticleTable::minDeltaMass << " MeV with CM energy " << ecm << " MeV may be unphysical." << '\n');
 75         return ParticleTable::minDeltaMass;        75         return ParticleTable::minDeltaMass;
 76       }                                            76       }
 77                                                    77       
 78       G4double rndm = ParticleTable::minDeltaM     78       G4double rndm = ParticleTable::minDeltaMassRndm + Random::shoot() * deltaMassRndmRange; // atan in order to avec a distribution in 1/(1+x^2)
 79       y = std::tan(rndm); // (mass-1232)*2/130     79       y = std::tan(rndm); // (mass-1232)*2/130
 80       x = ParticleTable::effectiveDeltaMass +      80       x = ParticleTable::effectiveDeltaMass + 0.5*ParticleTable::effectiveDeltaWidth*y; // probability to have the mass M = 1/(1+(M-1232)^2)/Pi cut with min and max mass
 81 // assert(x>=ParticleTable::minDeltaMass && ec     81 // assert(x>=ParticleTable::minDeltaMass && ecm >= x + ParticleTable::effectiveSigmaMass + ParticleTable::effectiveKaonMass + 1.0);
 82                                                    82       
 83       // generation of the delta mass with the     83       // generation of the delta mass with the penetration factor
 84       // (see prc56(1997)2431)                     84       // (see prc56(1997)2431)
 85       y=x*x;                                       85       y=x*x;
 86       q2=(y-1.157776E6)*(y-6.4E5)/y/4.0; // 1.     86       q2=(y-1.157776E6)*(y-6.4E5)/y/4.0; // 1.157776E6 = 1076^2 = (mNucleon + mPion)^2, 6.4E5 = 800^2 = (mNucleon - mPion)^2  // (prc56(1997)2431) (eq 3.7)^2
 87       q3=std::pow(std::sqrt(q2), 3.);              87       q3=std::pow(std::sqrt(q2), 3.);
 88       const G4double f3=q3/(q3+5.832E6); // 5.     88       const G4double f3=q3/(q3+5.832E6); // 5.832E6 = 180^3 = cut_parameter^3 // (prc56(1997)2431) (eq 3.6)
 89       rndm = Random::shoot();                      89       rndm = Random::shoot();
 90       if (rndm*f3max < f3) success = true; //      90       if (rndm*f3max < f3) success = true; // promoting high masses
 91     }                                              91     }
 92     return x;                                      92     return x;
 93   }                                                93   }
 94                                                    94   
 95   void NDeltaToDeltaSKChannel::fillFinalState(     95   void NDeltaToDeltaSKChannel::fillFinalState(FinalState *fs) {
 96         //                                         96         //
 97         // D++ p -> S+ K+ D+  (2)                  97         // D++ p -> S+ K+ D+  (2)
 98         // D++ p -> S0 K+ D++ (1)                  98         // D++ p -> S0 K+ D++ (1)
 99         // D++ p -> S+ K0 D++ (6)                  99         // D++ p -> S+ K0 D++ (6)
100         //                                        100         //
101         // D++ n -> S+ K+ D0  (2)                 101         // D++ n -> S+ K+ D0  (2)
102         // D++ n -> S0 K+ D+  (4)                 102         // D++ n -> S0 K+ D+  (4)
103         // D++ n -> S- K+ D++ (6)                 103         // D++ n -> S- K+ D++ (6)
104         // D++ n -> S+ K0 D+  (2)                 104         // D++ n -> S+ K0 D+  (2)
105         // D++ n -> S0 K0 D++ (1)                 105         // D++ n -> S0 K0 D++ (1)
106         //                                        106         //
107         // D+  p -> S+ K+ D0  (2)                 107         // D+  p -> S+ K+ D0  (2)
108         // D+  p -> S0 K+ D+  (1)                 108         // D+  p -> S0 K+ D+  (1)
109         // D+  p -> S- K+ D++ (2)                 109         // D+  p -> S- K+ D++ (2)
110         // D+  p -> S+ K0 D+  (2)                 110         // D+  p -> S+ K0 D+  (2)
111         // D+  p -> S0 K0 D++ (4)                 111         // D+  p -> S0 K0 D++ (4)
112         //                                        112         //
113         // D+  n -> S+ K+ D-  (2)                 113         // D+  n -> S+ K+ D-  (2)
114         // D+  n -> S0 K+ D0  (4)                 114         // D+  n -> S0 K+ D0  (4)
115         // D+  n -> S- K+ D+  (2)                 115         // D+  n -> S- K+ D+  (2)
116         // D+  n -> S+ K0 D0  (2)                 116         // D+  n -> S+ K0 D0  (2)
117         // D+  n -> S0 K0 D+  (1)                 117         // D+  n -> S0 K0 D+  (1)
118         // D+  n -> S- K0 D++ (2)                 118         // D+  n -> S- K0 D++ (2)
119                                                   119         
120                                                   120         
121         Particle *delta;                          121         Particle *delta;
122                                                   122         
123         if (particle1->isResonance()) {           123         if (particle1->isResonance()) {
124             delta = particle1;                    124             delta = particle1;
125         }                                         125         }
126         else {                                    126         else {
127             delta = particle2;                    127             delta = particle2;
128         }                                         128         }
129                                                   129     
130     const G4double sqrtS = KinematicsUtils::to    130     const G4double sqrtS = KinematicsUtils::totalEnergyInCM(particle1, particle2);
131                                                   131     
132     const G4int iso = ParticleTable::getIsospi    132     const G4int iso = ParticleTable::getIsospin(particle1->getType()) + ParticleTable::getIsospin(particle2->getType());
133     const G4int iso_d = ParticleTable::getIsos    133     const G4int iso_d = ParticleTable::getIsospin(delta->getType());
134                                                   134     
135     ParticleType KaonType;                        135     ParticleType KaonType;
136     ParticleType DeltaType;                       136     ParticleType DeltaType;
137     ParticleType SigmaType;                       137     ParticleType SigmaType;
138                                                   138     
139     const G4double rdm = Random::shoot();         139     const G4double rdm = Random::shoot();
140                                                   140     
141     if(std::abs(iso) == 4){// D++ p               141     if(std::abs(iso) == 4){// D++ p
142       if(rdm*9 < 2){                              142       if(rdm*9 < 2){
143         KaonType = ParticleTable::getKaonType(    143         KaonType = ParticleTable::getKaonType(iso/4);
144         DeltaType = ParticleTable::getDeltaTyp    144         DeltaType = ParticleTable::getDeltaType(iso/4);
145         SigmaType = ParticleTable::getSigmaTyp    145         SigmaType = ParticleTable::getSigmaType(iso/2);
146       }                                           146       }
147       else if(rdm*9 < 3){                         147       else if(rdm*9 < 3){
148         KaonType = ParticleTable::getKaonType(    148         KaonType = ParticleTable::getKaonType(iso/4);
149         DeltaType = ParticleTable::getDeltaTyp    149         DeltaType = ParticleTable::getDeltaType(3*iso/4);
150         SigmaType = SigmaZero;                    150         SigmaType = SigmaZero;
151       }                                           151       }
152       else{                                       152       else{
153         KaonType = ParticleTable::getKaonType(    153         KaonType = ParticleTable::getKaonType(-iso/4);
154         DeltaType = ParticleTable::getDeltaTyp    154         DeltaType = ParticleTable::getDeltaType(3*iso/4);
155         SigmaType = ParticleTable::getSigmaTyp    155         SigmaType = ParticleTable::getSigmaType(iso/2);
156       }                                           156       }
157     }                                             157     }
158     else if(iso == 0){// D+  n                    158     else if(iso == 0){// D+  n
159       if(rdm*13 < 2){                             159       if(rdm*13 < 2){
160         KaonType = ParticleTable::getKaonType(    160         KaonType = ParticleTable::getKaonType(iso_d);
161         DeltaType = ParticleTable::getDeltaTyp    161         DeltaType = ParticleTable::getDeltaType(-3*iso_d);
162         SigmaType = ParticleTable::getSigmaTyp    162         SigmaType = ParticleTable::getSigmaType(2*iso_d);
163       }                                           163       }
164       else if(rdm*13 < 6){                        164       else if(rdm*13 < 6){
165         KaonType = ParticleTable::getKaonType(    165         KaonType = ParticleTable::getKaonType(iso_d);
166         DeltaType = ParticleTable::getDeltaTyp    166         DeltaType = ParticleTable::getDeltaType(-iso_d);
167         SigmaType = SigmaZero;                    167         SigmaType = SigmaZero;
168       }                                           168       }
169       else if(rdm*13 < 8){                        169       else if(rdm*13 < 8){
170         KaonType = ParticleTable::getKaonType(    170         KaonType = ParticleTable::getKaonType(iso_d);
171         DeltaType = ParticleTable::getDeltaTyp    171         DeltaType = ParticleTable::getDeltaType(iso_d);
172         SigmaType = ParticleTable::getSigmaTyp    172         SigmaType = ParticleTable::getSigmaType(-2*iso_d);
173       }                                           173       }
174       else if(rdm*13 < 10){                       174       else if(rdm*13 < 10){
175         KaonType = ParticleTable::getKaonType(    175         KaonType = ParticleTable::getKaonType(-iso_d);
176         DeltaType = ParticleTable::getDeltaTyp    176         DeltaType = ParticleTable::getDeltaType(-iso_d);
177         SigmaType = ParticleTable::getSigmaTyp    177         SigmaType = ParticleTable::getSigmaType(2*iso_d);
178       }                                           178       }
179       else if(rdm*13 < 11){                       179       else if(rdm*13 < 11){
180         KaonType = ParticleTable::getKaonType(    180         KaonType = ParticleTable::getKaonType(-iso_d);
181         DeltaType = ParticleTable::getDeltaTyp    181         DeltaType = ParticleTable::getDeltaType(iso_d);
182         SigmaType = SigmaZero;                    182         SigmaType = SigmaZero;
183       }                                           183       }
184       else{                                       184       else{
185         KaonType = ParticleTable::getKaonType(    185         KaonType = ParticleTable::getKaonType(-iso_d);
186         DeltaType = ParticleTable::getDeltaTyp    186         DeltaType = ParticleTable::getDeltaType(3*iso_d);
187         SigmaType = ParticleTable::getSigmaTyp    187         SigmaType = ParticleTable::getSigmaType(-2*iso_d);
188       }                                           188       }
189     }                                             189     }
190     else if(ParticleTable::getIsospin(particle    190     else if(ParticleTable::getIsospin(particle1->getType()) == ParticleTable::getIsospin(particle2->getType())){// D+  p
191       if(rdm*11 < 2){                             191       if(rdm*11 < 2){
192         KaonType = ParticleTable::getKaonType(    192         KaonType = ParticleTable::getKaonType(iso/2);
193         DeltaType = ParticleTable::getDeltaTyp    193         DeltaType = ParticleTable::getDeltaType(-iso/2);
194         SigmaType = ParticleTable::getSigmaTyp    194         SigmaType = ParticleTable::getSigmaType(iso);
195       }                                           195       }
196       else if(rdm*11 < 3){                        196       else if(rdm*11 < 3){
197         KaonType = ParticleTable::getKaonType(    197         KaonType = ParticleTable::getKaonType(iso/2);
198         DeltaType = ParticleTable::getDeltaTyp    198         DeltaType = ParticleTable::getDeltaType(iso/2);
199         SigmaType = SigmaZero;                    199         SigmaType = SigmaZero;
200       }                                           200       }
201       else if(rdm*11 < 5){                        201       else if(rdm*11 < 5){
202         KaonType = ParticleTable::getKaonType(    202         KaonType = ParticleTable::getKaonType(iso/2);
203         DeltaType = ParticleTable::getDeltaTyp    203         DeltaType = ParticleTable::getDeltaType(3*iso/2);
204         SigmaType = ParticleTable::getSigmaTyp    204         SigmaType = ParticleTable::getSigmaType(-iso);
205       }                                           205       }
206       else if(rdm*11 < 7){                        206       else if(rdm*11 < 7){
207         KaonType = ParticleTable::getKaonType(    207         KaonType = ParticleTable::getKaonType(-iso/2);
208         DeltaType = ParticleTable::getDeltaTyp    208         DeltaType = ParticleTable::getDeltaType(iso/2);
209         SigmaType = ParticleTable::getSigmaTyp    209         SigmaType = ParticleTable::getSigmaType(iso);
210       }                                           210       }
211       else{                                       211       else{
212         KaonType = ParticleTable::getKaonType(    212         KaonType = ParticleTable::getKaonType(-iso/2);
213         DeltaType = ParticleTable::getDeltaTyp    213         DeltaType = ParticleTable::getDeltaType(3*iso/2);
214         SigmaType = SigmaZero;                    214         SigmaType = SigmaZero;
215       }                                           215       }
216     }                                             216     }
217     else{// D++ n                                 217     else{// D++ n 
218       if(rdm*15 < 2){                             218       if(rdm*15 < 2){
219         KaonType = ParticleTable::getKaonType(    219         KaonType = ParticleTable::getKaonType(iso/2);
220         DeltaType = ParticleTable::getDeltaTyp    220         DeltaType = ParticleTable::getDeltaType(-iso/2);
221         SigmaType = ParticleTable::getSigmaTyp    221         SigmaType = ParticleTable::getSigmaType(iso);
222       }                                           222       }
223       else if(rdm*15 < 6){                        223       else if(rdm*15 < 6){
224         KaonType = ParticleTable::getKaonType(    224         KaonType = ParticleTable::getKaonType(iso/2);
225         DeltaType = ParticleTable::getDeltaTyp    225         DeltaType = ParticleTable::getDeltaType(iso/2);
226         SigmaType = SigmaZero;                    226         SigmaType = SigmaZero;
227       }                                           227       }
228       else if(rdm*15 < 12){                       228       else if(rdm*15 < 12){
229         KaonType = ParticleTable::getKaonType(    229         KaonType = ParticleTable::getKaonType(iso/2);
230         DeltaType = ParticleTable::getDeltaTyp    230         DeltaType = ParticleTable::getDeltaType(3*iso/2);
231         SigmaType = ParticleTable::getSigmaTyp    231         SigmaType = ParticleTable::getSigmaType(-iso);
232       }                                           232       }
233       else if(rdm*15 < 14){                       233       else if(rdm*15 < 14){
234         KaonType = ParticleTable::getKaonType(    234         KaonType = ParticleTable::getKaonType(-iso/2);
235         DeltaType = ParticleTable::getDeltaTyp    235         DeltaType = ParticleTable::getDeltaType(iso/2);
236         SigmaType = ParticleTable::getSigmaTyp    236         SigmaType = ParticleTable::getSigmaType(iso);
237       }                                           237       }
238       else{                                       238       else{
239         KaonType = ParticleTable::getKaonType(    239         KaonType = ParticleTable::getKaonType(-iso/2);
240         DeltaType = ParticleTable::getDeltaTyp    240         DeltaType = ParticleTable::getDeltaType(3*iso/2);
241         SigmaType = SigmaZero;                    241         SigmaType = SigmaZero;
242       }                                           242       }
243     }                                             243     }
244                                                   244     
245                                                   245         
246     particle1->setType(DeltaType);                246     particle1->setType(DeltaType);
247     particle1->setMass(sampleDeltaMass(sqrtS))    247     particle1->setMass(sampleDeltaMass(sqrtS));
248     particle2->setType(SigmaType);                248     particle2->setType(SigmaType);
249                                                   249     
250     ParticleList list;                            250     ParticleList list;
251     list.push_back(particle1);                    251     list.push_back(particle1);
252     list.push_back(particle2);                    252     list.push_back(particle2);
253     const ThreeVector &rcol = particle2->getPo    253     const ThreeVector &rcol = particle2->getPosition();
254     const ThreeVector zero;                       254     const ThreeVector zero;
255     Particle *kaon = new Particle(KaonType,zer    255     Particle *kaon = new Particle(KaonType,zero,rcol);
256     list.push_back(kaon);                         256     list.push_back(kaon);
257                                                   257     
258     if(Random::shoot()<0.5) PhaseSpaceGenerato    258     if(Random::shoot()<0.5) PhaseSpaceGenerator::generateBiased(sqrtS, list, 0, angularSlope);
259     else PhaseSpaceGenerator::generateBiased(s    259     else PhaseSpaceGenerator::generateBiased(sqrtS, list, 1, angularSlope);
260                                                   260     
261     fs->addModifiedParticle(particle1);           261     fs->addModifiedParticle(particle1);
262     fs->addModifiedParticle(particle2);           262     fs->addModifiedParticle(particle2);
263     fs->addCreatedParticle(kaon);                 263     fs->addCreatedParticle(kaon);
264                                                   264     
265   }                                               265   }
266 }                                                 266 }
267                                                   267