[819] | 1 | // |
---|
| 2 | // ******************************************************************** |
---|
| 3 | // * License and Disclaimer * |
---|
| 4 | // * * |
---|
| 5 | // * The Geant4 software is copyright of the Copyright Holders of * |
---|
| 6 | // * the Geant4 Collaboration. It is provided under the terms and * |
---|
| 7 | // * conditions of the Geant4 Software License, included in the file * |
---|
| 8 | // * LICENSE and available at http://cern.ch/geant4/license . These * |
---|
| 9 | // * include a list of copyright holders. * |
---|
| 10 | // * * |
---|
| 11 | // * Neither the authors of this software system, nor their employing * |
---|
| 12 | // * institutes,nor the agencies providing financial support for this * |
---|
| 13 | // * work make any representation or warranty, express or implied, * |
---|
| 14 | // * regarding this software system or assume any liability for its * |
---|
| 15 | // * use. Please see the license in the file LICENSE and URL above * |
---|
| 16 | // * for the full disclaimer and the limitation of liability. * |
---|
| 17 | // * * |
---|
| 18 | // * This code implementation is the result of the scientific and * |
---|
| 19 | // * technical work of the GEANT4 collaboration. * |
---|
| 20 | // * By using, copying, modifying or distributing the software (or * |
---|
| 21 | // * any work based on the software) you agree to acknowledge its * |
---|
| 22 | // * use in resulting scientific publications, and indicate your * |
---|
| 23 | // * acceptance of all terms of the Geant4 Software license. * |
---|
| 24 | // ******************************************************************** |
---|
| 25 | // |
---|
| 26 | // |
---|
[1196] | 27 | // $Id: G4QChipolino.cc,v 1.36 2009/08/10 16:36:53 mkossov Exp $ |
---|
[1340] | 28 | // GEANT4 tag $Name: hadr-chips-V09-03-08 $ |
---|
[819] | 29 | // |
---|
| 30 | // ---------------- G4QChipolino ---------------- |
---|
| 31 | // by Mikhail Kossov, Sept 1999. |
---|
| 32 | // class for Quasmon initiated Chipolinos generated by CHIPS Model |
---|
[1055] | 33 | // -------------------------------------------------------------------- |
---|
| 34 | // Short description: In the CHIPS model not only hadrons are considered, |
---|
| 35 | // but the di-hadrons, which can not be convereged to the quark content |
---|
| 36 | // of only one hadron (e.g. pi+pi+, K+p, Delta++p etc). This kind of |
---|
| 37 | // hadronic states, which can be easily decayed in two hadrons, is called |
---|
| 38 | // Chipolino-particle in the model. |
---|
| 39 | // ---------------------------------------------------------------------- |
---|
[819] | 40 | |
---|
| 41 | //#define debug |
---|
| 42 | //#define pdebug |
---|
| 43 | |
---|
| 44 | #include "G4QChipolino.hh" |
---|
| 45 | #include <cstdlib> |
---|
| 46 | using namespace std; |
---|
| 47 | |
---|
| 48 | G4QChipolino::G4QChipolino(G4QContent& QCont) |
---|
| 49 | { |
---|
| 50 | // @@ Does not work as static const ?? |
---|
| 51 | G4QPDGCode Pi0(111); |
---|
| 52 | G4double mPi0 = Pi0.GetMass(); |
---|
| 53 | G4QContent Pi0QC = Pi0.GetQuarkContent(); |
---|
| 54 | G4int ban =QCont.GetBaryonNumber(); |
---|
| 55 | G4int tban=abs(3*ban); |
---|
| 56 | G4int tot=QCont.GetTot(); // Initial total number of quarks in QC |
---|
| 57 | G4int tod=tot%2; // tot is even - meson or dibaryon-nucleus |
---|
| 58 | if ( (!tod && (tot < 4 || (ban && tot < tban) ) ) || (tod && tot < tban+2) ) |
---|
| 59 | QCont.IncQAQ(1,0.); // Add quark-pair |
---|
| 60 | |
---|
[1055] | 61 | G4QContent rQC=QCont; // Copy for possible reduction ("annihilation" of q-aq pairs) |
---|
[819] | 62 | tot=rQC.GetTot(); // New total number of quarks in QC (temporary) |
---|
| 63 | if (tot%2)rQC.DecQAQ(-tban-2); // Reduce pairs, keep only 5 quarks (baryon case) |
---|
| 64 | else if(ban)rQC.DecQAQ(-tban); // Reduce pairs, keep only 6 quarks (dibaryon case) |
---|
| 65 | else rQC.DecQAQ(-4); // Reduce pairs, keep only 4 quarks (meson case) |
---|
| 66 | tot=rQC.GetTot(); // Final total number of quarks (updated) |
---|
| 67 | #ifdef debug |
---|
| 68 | cout<<"G4QChipolino is called with QC="<<QCont<<",rQC="<<rQC<<",tot="<<tot<<G4endl; |
---|
| 69 | #endif |
---|
| 70 | minM=1000000.; // Prototype of minimal mass (@@ just a big number) |
---|
| 71 | theQPDG1 = Pi0; |
---|
| 72 | theQPDG2 = Pi0; |
---|
| 73 | theQCont1 = Pi0QC; |
---|
| 74 | if (!tot) // Should not be here, just in case (strange input) |
---|
| 75 | { |
---|
| 76 | G4cerr<<"***G4QChipolino: shouldn't be here 1 QC="<<rQC<<G4endl; |
---|
| 77 | } |
---|
| 78 | else if (tot==2 || tot==3) // Should not be here (basic octet/singlet states) |
---|
| 79 | { |
---|
| 80 | G4cerr<<"***G4QChipolino: shouldn't be here 2 QC="<<rQC<<G4endl; |
---|
| 81 | theQCont1= rQC; |
---|
| 82 | theQPDG1.InitByQCont(rQC); |
---|
| 83 | theQCont = rQC+Pi0QC; |
---|
| 84 | } |
---|
| 85 | else if (tot==4) // Two possible combinations for the meson |
---|
| 86 | { |
---|
| 87 | G4QContent bQC=rQC.IndQ(); |
---|
| 88 | #ifdef debug |
---|
| 89 | G4cout<<"G4QChipolino: tot=4,rQC="<<rQC<<",bQC="<<bQC<<G4endl; |
---|
| 90 | #endif |
---|
| 91 | for(int j=0; j<2; j++) |
---|
| 92 | { |
---|
| 93 | G4QContent aQC=rQC.IndAQ(j); |
---|
| 94 | G4QContent cQC=bQC+aQC; |
---|
| 95 | G4QPDGCode cQPDG(cQC); |
---|
| 96 | G4double M1=cQPDG.GetMass(); |
---|
| 97 | if(cQPDG.GetPDGCode()==221) M1=mPi0; |
---|
| 98 | G4QContent oQC=rQC-cQC; |
---|
| 99 | #ifdef debug |
---|
[1055] | 100 | cout<<"G4QChipolino: aQC="<<aQC<<", cQC="<<cQC<<", oQC="<<oQC<<G4endl; |
---|
[819] | 101 | #endif |
---|
| 102 | G4QPDGCode oQPDG(oQC); |
---|
| 103 | G4double M2=oQPDG.GetMass(); |
---|
| 104 | if(oQPDG.GetPDGCode()==221) M2=mPi0; |
---|
| 105 | G4double m=M1+M2; |
---|
| 106 | #ifdef debug |
---|
[1055] | 107 | cout<<"G4QChipolino: c="<<cQPDG<<",cM="<<M1<<",o="<<oQPDG<<",oM="<<M2 |
---|
[819] | 108 | <<",cM+0M="<<m<<", curMinM="<<minM<<G4endl; |
---|
| 109 | #endif |
---|
| 110 | if(m<minM) |
---|
| 111 | { |
---|
| 112 | minM=m; |
---|
| 113 | theQPDG1 = cQPDG; |
---|
| 114 | theQCont1 = cQC; |
---|
| 115 | theQPDG2 = oQPDG; |
---|
| 116 | } |
---|
| 117 | } |
---|
| 118 | } |
---|
| 119 | else if (tot==5) // Four possible combinations for the baryon |
---|
| 120 | { |
---|
| 121 | G4int nQ=rQC.GetQ(); |
---|
| 122 | G4int nA=rQC.GetAQ(); |
---|
| 123 | G4bool fl=nA>nQ; // Flag of antibaryon case |
---|
| 124 | #ifdef pdebug |
---|
[1055] | 125 | cout<<"G4QChipolino: Baryon case nQ="<<nQ<<",nA="<<nA<<",QC="<<rQC |
---|
[819] | 126 | <<",fl="<<fl<<G4endl; |
---|
| 127 | #endif |
---|
| 128 | G4QContent bQC; |
---|
| 129 | if (fl) bQC=rQC.IndQ(); // Antibaryon case |
---|
| 130 | else bQC=rQC.IndAQ(); // Baryon case - QC of antiquark |
---|
| 131 | for (int i=0; i<4; i++) |
---|
| 132 | { |
---|
| 133 | G4QContent cQC; |
---|
| 134 | if (fl) cQC=bQC+rQC.IndAQ(i); |
---|
| 135 | else cQC=bQC+rQC.IndQ(i);// Make mesonout of anti-quark |
---|
| 136 | G4QPDGCode cQPDG(cQC); // Make QPDG particle |
---|
| 137 | G4double M1=cQPDG.GetMass(); // Get meson mass |
---|
| 138 | if(cQPDG.GetPDGCode()==221) M1=mPi0; // Make pi0 out of eta |
---|
| 139 | G4QContent oQC=rQC-cQC; // Make residual baryon |
---|
| 140 | G4QPDGCode oQPDG(oQC); // Make QPDG of residual baryon |
---|
| 141 | G4double M2=oQPDG.GetMass(); // Get baryon mass |
---|
| 142 | if(oQPDG.GetPDGCode()==221) M2=mPi0; // @@ Never !! |
---|
| 143 | G4double m=M1+M2; |
---|
| 144 | if(m<minM) |
---|
| 145 | { |
---|
| 146 | minM=m; |
---|
| 147 | theQPDG1 = cQPDG; |
---|
| 148 | theQCont1 = cQC; |
---|
| 149 | theQPDG2 = oQPDG; |
---|
| 150 | } |
---|
| 151 | } |
---|
| 152 | #ifdef pdebug |
---|
[1055] | 153 | cout<<"G4QChipolino: Baryon case minM="<<minM<<", M="<<theQCont1<<theQPDG1 |
---|
[819] | 154 | <<", B="<<theQPDG2<<G4endl; |
---|
| 155 | #endif |
---|
| 156 | } |
---|
| 157 | else if (tot==6) // Four possible combinations for the di-baryon |
---|
| 158 | { |
---|
| 159 | if(ban) |
---|
[1055] | 160 | { |
---|
[819] | 161 | G4int nQ=rQC.GetQ(); |
---|
| 162 | G4int nA=rQC.GetAQ(); |
---|
| 163 | G4bool fl=nA>nQ; // Flag of anti-dibaryon case |
---|
| 164 | #ifdef debug |
---|
[1055] | 165 | cout<<"G4QChipolino: Di-Bar. case nQ="<<nQ<<",nA="<<nA<<",QC="<<rQC<<",fl="<<fl<<G4endl; |
---|
[819] | 166 | #endif |
---|
| 167 | for (int i=0; i<4; i++) |
---|
| 168 | { |
---|
| 169 | G4QContent aQC; |
---|
| 170 | if (fl) aQC=rQC.IndAQ(i); |
---|
| 171 | else aQC=rQC.IndQ(i); |
---|
| 172 | for (int j=i+1; j<5; j++) |
---|
| 173 | { |
---|
| 174 | G4QContent bQC; |
---|
| 175 | if (fl) bQC=aQC+rQC.IndAQ(j); |
---|
| 176 | else bQC=aQC+rQC.IndQ(j); |
---|
| 177 | for (int k=j+1; k<6; k++) |
---|
| 178 | { |
---|
| 179 | G4QContent cQC; |
---|
| 180 | if (fl) cQC=bQC+rQC.IndAQ(k); |
---|
| 181 | else cQC=bQC+rQC.IndQ(k); |
---|
| 182 | G4QPDGCode cQPDG(cQC); |
---|
| 183 | G4double M1=cQPDG.GetMass(); |
---|
| 184 | if(cQPDG.GetPDGCode()==221) M1=mPi0; |
---|
| 185 | G4QContent oQC=rQC-cQC; |
---|
| 186 | G4QPDGCode oQPDG=(oQC); |
---|
| 187 | G4double M2=oQPDG.GetMass(); |
---|
| 188 | if(oQPDG.GetPDGCode()==221) M2=mPi0; |
---|
| 189 | G4double m=M1+M2; |
---|
| 190 | if(m<minM) |
---|
| 191 | { |
---|
| 192 | minM=m; |
---|
| 193 | theQPDG1 = cQPDG; |
---|
| 194 | theQCont1 = cQC; |
---|
| 195 | theQPDG2 = oQPDG; |
---|
| 196 | } |
---|
[1055] | 197 | } |
---|
| 198 | } |
---|
[819] | 199 | } |
---|
| 200 | } |
---|
| 201 | else // Baryon-AntiBaryon |
---|
[1055] | 202 | { |
---|
[819] | 203 | theQCont1 = rQC.IndQ(0)+rQC.IndQ(1)+rQC.IndQ(2); |
---|
| 204 | theQPDG1.InitByQCont(theQCont1); |
---|
| 205 | theQPDG2.InitByQCont(rQC.IndAQ(0)+rQC.IndAQ(1)+rQC.IndAQ(2)); |
---|
[1055] | 206 | } |
---|
[819] | 207 | } |
---|
| 208 | else if(((rQC.GetU() )>(rQC.GetS() -4) && (rQC.GetD() )>(rQC.GetS() -4)) || |
---|
| 209 | ((rQC.GetAU())>(rQC.GetAS()-4) && (rQC.GetAD())>(rQC.GetAS()-4)) ) |
---|
| 210 | { |
---|
| 211 | G4int kD=rQC.GetD(); |
---|
| 212 | G4int kU=rQC.GetU(); |
---|
| 213 | G4int kS=rQC.GetS(); |
---|
| 214 | G4int mD=rQC.GetAD(); |
---|
| 215 | G4int mU=rQC.GetAU(); |
---|
| 216 | G4int mS=rQC.GetAS(); |
---|
| 217 | G4int nQ=rQC.GetQ(); |
---|
| 218 | G4int nA=rQC.GetAQ(); |
---|
| 219 | G4bool fl=nA>nQ; // Flag of anti-fragment case |
---|
| 220 | #ifdef debug |
---|
[1055] | 221 | G4cout<<"G4QChipolino: NucFragment case nQ="<<nQ<<",nAQ="<<nA<<", QC="<<rQC<<",fl="<<fl |
---|
| 222 | <<G4endl; |
---|
[819] | 223 | #endif |
---|
[1196] | 224 | if( (fl && kS>1) || (!fl && mS>1)) |
---|
[819] | 225 | { |
---|
[1196] | 226 | #ifdef debug |
---|
[819] | 227 | G4cerr<<"***G4QChipolino: ***Overfowed by strange quarks*** rQC="<<rQC<<G4endl; |
---|
[1055] | 228 | //throw G4QException("G4QChipolino: NuclearFragment is overflowed by strangeQuarks"); |
---|
[1196] | 229 | #endif |
---|
[819] | 230 | } |
---|
| 231 | else if(fl) // ===> Anti-fragment |
---|
[1055] | 232 | { |
---|
[819] | 233 | //G4cerr<<"***G4QChipolino: ***Anti-nuclear fragments*** rQC="<<rQC<<G4endl; |
---|
[1055] | 234 | //throw G4QException("G4QChipolino: Antinuclear fragments are not yet supported"); |
---|
| 235 | if(!mS) // No strange quarks |
---|
| 236 | { |
---|
| 237 | G4int nI=mU-mD; // Isotopic shift |
---|
[819] | 238 | G4int nN=(mU+mD-nI*3)/6; |
---|
[1055] | 239 | if(!kS) // No kaons |
---|
| 240 | { |
---|
| 241 | if((nI>=0&&nN>=0)||(nI<0&&nN>=-nI)) // Delta isn't necessary |
---|
[819] | 242 | { |
---|
[1055] | 243 | if(nI>0) // Excess of antiprotons |
---|
[819] | 244 | { |
---|
[1055] | 245 | theQPDG1 = G4QPDGCode(-(90000000+1000*(nN+nI-1)+nN));// A Fragment-AProton |
---|
| 246 | theQPDG2 = G4QPDGCode(-2212); // An Anti-Proton |
---|
[819] | 247 | } |
---|
[1055] | 248 | else // Excess of a-neutrons |
---|
[819] | 249 | { |
---|
[1055] | 250 | theQPDG1 = G4QPDGCode(-(90000000+1000*(nN+nI)+nN-1));// A Fragment-ANeutron |
---|
| 251 | theQPDG2 = G4QPDGCode(-2112); // An Anti-Neutron |
---|
[819] | 252 | } |
---|
[1055] | 253 | } |
---|
| 254 | else if((nI>=0&&nN>-2)||(nI<0&&nN>-nI-2)) // Delta can be a part |
---|
| 255 | { |
---|
| 256 | if(nI>0) // Excess of au-quarks |
---|
[819] | 257 | { |
---|
[1055] | 258 | theQPDG1=G4QPDGCode(-(90000000+1000*(nN+nI-2)+nN+1));// A Fragment-AProton |
---|
| 259 | theQPDG2=G4QPDGCode(-2224); // An Anti-Delta++ |
---|
[819] | 260 | } |
---|
[1055] | 261 | else // Excess of ad-quarks |
---|
[819] | 262 | { |
---|
[1055] | 263 | theQPDG1=G4QPDGCode(-(90000000+1000*(nN+nI+1)+nN-2));// A Fragment-ANeutron |
---|
| 264 | theQPDG2=G4QPDGCode(-1114); // An Anti-Delta- |
---|
[819] | 265 | } |
---|
[1055] | 266 | } |
---|
[819] | 267 | else |
---|
[1055] | 268 | { |
---|
| 269 | G4cerr<<"***G4QChipolino:**A**IsotopicAsymmetry (without S),rQC="<<rQC<<G4endl; |
---|
| 270 | //throw G4QException("G4QChipolino: IsotopicAsymmety of AntiMultyBar Quasmon"); |
---|
| 271 | } |
---|
[819] | 272 | } |
---|
[1055] | 273 | else if(kS<2) // NucFrag+K is possible |
---|
| 274 | { |
---|
[819] | 275 | G4int nN =(mU+mD-4-nI*3)/6; |
---|
[1055] | 276 | if(nI>0) // Excess of au-quarks |
---|
[819] | 277 | { |
---|
| 278 | nN+=1; |
---|
[1055] | 279 | theQPDG1 = G4QPDGCode(-(90000000+1000*(nN+nI-1)+nN)); // An Anti-Fragment |
---|
| 280 | theQPDG2 = G4QPDGCode(-321); // A K- meson |
---|
| 281 | } |
---|
[819] | 282 | else |
---|
[1055] | 283 | { |
---|
| 284 | theQPDG1 = G4QPDGCode(-(90000000+1000*(nN+nI+1)+nN)); // An AntiFragment |
---|
| 285 | theQPDG2 = G4QPDGCode(-311); // An Anti-K0 meson |
---|
[819] | 286 | } |
---|
[1055] | 287 | } |
---|
[819] | 288 | else |
---|
[1055] | 289 | { |
---|
[819] | 290 | G4cerr<<"***G4QChipolino: ***Too many kaons are needed*** rQC="<<rQC<<G4endl; |
---|
[1055] | 291 | //throw G4QException("G4QChipolino: Too Many Kaons are needed for AntiNucFragm"); |
---|
| 292 | } |
---|
| 293 | } |
---|
[819] | 294 | else // Fragment with strangeness |
---|
[1055] | 295 | { |
---|
[819] | 296 | if(mS<=mU&&mS<=mD) // Fragment consisting of Neutrons, Protons & Lambrdas only |
---|
[1055] | 297 | { |
---|
| 298 | G4int nI=mU-mD; // Isotopic shift |
---|
[819] | 299 | G4int nN=(mU+mD-mS-mS-nI*3)/6; |
---|
[1055] | 300 | if((nI>=0&&nN>=0)||(nI<0&&nN>=-nI)) // Delta isn't necessary |
---|
[819] | 301 | { |
---|
[1055] | 302 | if(nI>0) // Excess of protons |
---|
[819] | 303 | { |
---|
[1055] | 304 | theQPDG1 = G4QPDGCode(-(90000000+1000*(kS*1000+nN+nI-1)+nN));// Fragm-AProton |
---|
| 305 | theQPDG2 = G4QPDGCode(-2212); // An Anti-Proton |
---|
[819] | 306 | } |
---|
[1055] | 307 | else // Excess of neutrons |
---|
[819] | 308 | { |
---|
[1055] | 309 | theQPDG1 = G4QPDGCode(-(90000000+1000*(kS*1000+nN+nI)+nN-1));//Fragm-ANeutron |
---|
| 310 | theQPDG2 = G4QPDGCode(-2112); // An Anti-Neutron |
---|
[819] | 311 | } |
---|
[1055] | 312 | } |
---|
| 313 | else if((nI>=0&&nN>-2)||(nI<0&&nN>-nI-2)) // Delta can be a part |
---|
| 314 | { |
---|
| 315 | if(nI>0) // Excess of au-quarks |
---|
[819] | 316 | { |
---|
[1055] | 317 | theQPDG1=G4QPDGCode(-(90000000+1000*(kS*1000+nN+nI-2)+nN+1));//Fragm-AProton |
---|
| 318 | theQPDG2=G4QPDGCode(-2224); // An Anti-Delta++ |
---|
[819] | 319 | } |
---|
[1055] | 320 | else // Excess of ad-quarks |
---|
[819] | 321 | { |
---|
[1055] | 322 | theQPDG1=G4QPDGCode(-(90000000+1000*(kS*1000+nN+nI+1)+nN-2));//Fragm-ANeutron |
---|
| 323 | theQPDG2=G4QPDGCode(-1114); // An Anti-Delta- |
---|
[819] | 324 | } |
---|
[1055] | 325 | } |
---|
[819] | 326 | else |
---|
[1055] | 327 | { |
---|
| 328 | G4cerr<<"***G4QChipolino:**A**IsotopicAssimetry (with S)*** rQC="<<rQC<<G4endl; |
---|
| 329 | //throw G4QException("G4QChipolino: Isotopics of Strange AntiMultyBarQuasmon"); |
---|
| 330 | } |
---|
| 331 | } |
---|
| 332 | else // Excess of s-quarks |
---|
| 333 | { |
---|
| 334 | G4int lam=mU; // A#of Anti-Lambdas |
---|
[819] | 335 | if (lam>mD) lam=mD; |
---|
[1055] | 336 | G4int lD=mD-lam; // Residual ad-quarks |
---|
| 337 | G4int lU=mU-lam; // Residual au-quarks |
---|
| 338 | G4int lS=mS-lam; // Residual as-quarks |
---|
[819] | 339 | if(lD+lU+lS!=3||lD<0||lU<0||lS<0) |
---|
[1055] | 340 | { |
---|
| 341 | G4cerr<<"***G4QChipolino:*AntiFragment* rQC="<<rQC<<",s="<<lS<<",u="<<lU<<",d" |
---|
| 342 | <<lD<<G4endl; |
---|
| 343 | //throw G4QException("G4QChipolino: Exotic superstrange AntiMultyBaryon"); |
---|
| 344 | } |
---|
| 345 | if ( !lD && lU==2) theQPDG2=G4QPDGCode(-3222); // Anti-Sigma+ |
---|
| 346 | else if( !lU && lD==2) theQPDG2=G4QPDGCode(-3112); // Anti-Sigma- |
---|
| 347 | else if( !lD && lU==1) theQPDG2=G4QPDGCode(-3322); // Anti-Ksi0 |
---|
| 348 | else if( !lU && lD==1) theQPDG2=G4QPDGCode(-3312); // Anti-Ksi- |
---|
| 349 | else theQPDG2=G4QPDGCode(-3334); // Anti-Omega- |
---|
| 350 | theQPDG1=G4QPDGCode(-(90+lam)*1000000); // Anti Strange Matter |
---|
| 351 | } |
---|
| 352 | theQCont1 = rQC-theQPDG2.GetQuarkContent(); // QCont of Fragment-H |
---|
| 353 | theQCont = rQC; // QCont of Chipolino |
---|
| 354 | } |
---|
| 355 | } |
---|
| 356 | else // ===> Nuclear Fragment |
---|
| 357 | { |
---|
| 358 | if(!kS) // No strange quarks |
---|
| 359 | { |
---|
| 360 | G4int nI=kU-kD; // Isotopic shift |
---|
[819] | 361 | G4int nN=(kU+kD-nI*3)/6; |
---|
[1055] | 362 | if(!mS) // No kaons |
---|
| 363 | { |
---|
| 364 | if((nI>=0&&nN>=0)||(nI<0&&nN>=-nI)) // Delta isn't necessary |
---|
[819] | 365 | { |
---|
[1055] | 366 | if(nI>0) // Excess of protons |
---|
[819] | 367 | { |
---|
[1055] | 368 | theQPDG1 = G4QPDGCode(90000000+1000*(nN+nI-1)+nN); // A Fragment-Proton |
---|
| 369 | theQPDG2 = G4QPDGCode(2212); // A Proton |
---|
[819] | 370 | } |
---|
[1055] | 371 | else // Excess of neutrons |
---|
[819] | 372 | { |
---|
[1055] | 373 | theQPDG1 = G4QPDGCode(90000000+1000*(nN+nI)+nN-1); // A Fragment-Neutron |
---|
| 374 | theQPDG2 = G4QPDGCode(2112); // A Neutron |
---|
[819] | 375 | } |
---|
[1055] | 376 | } |
---|
| 377 | else if((nI>=0&&nN>-2)||(nI<0&&nN>-nI-2)) // Delta can be a part |
---|
| 378 | { |
---|
| 379 | if(nI>0) // Excess of u-quarks |
---|
[819] | 380 | { |
---|
[1055] | 381 | theQPDG1=G4QPDGCode(90000000+1000*(nN+nI-2)+nN+1); // A Fragment-Proton |
---|
| 382 | theQPDG2=G4QPDGCode(2224); // A Delta++ |
---|
[819] | 383 | } |
---|
[1055] | 384 | else // Excess of d-quarks |
---|
[819] | 385 | { |
---|
[1055] | 386 | theQPDG1=G4QPDGCode(90000000+1000*(nN+nI+1)+nN-2); // A Fragment-Neutron |
---|
| 387 | theQPDG2=G4QPDGCode(1114); // A Delta- |
---|
[819] | 388 | } |
---|
[1055] | 389 | } |
---|
[819] | 390 | else |
---|
[1055] | 391 | { |
---|
| 392 | G4cerr<<"***G4QChipolino:***Isotopic assimetry (without S), rQC="<<rQC<<G4endl; |
---|
| 393 | //throw G4QException("G4QChipolino:ExoticIsotopicAssimety of MultyBarQuasmon"); |
---|
| 394 | } |
---|
[819] | 395 | } |
---|
[1055] | 396 | else if(mS<2) // NucFrag+K is possible |
---|
| 397 | { |
---|
[819] | 398 | G4int nN =(kU+kD-4-nI*3)/6; |
---|
[1055] | 399 | if(nI>0) // Excess of u-quarks |
---|
[819] | 400 | { |
---|
| 401 | nN+=1; |
---|
[1055] | 402 | theQPDG1 = G4QPDGCode(90000000+1000*(nN+nI-1)+nN); // A Fragment |
---|
| 403 | theQPDG2 = G4QPDGCode(321); // A K+ meson |
---|
| 404 | } |
---|
[819] | 405 | else |
---|
[1055] | 406 | { |
---|
| 407 | theQPDG1 = G4QPDGCode(90000000+1000*(nN+nI+1)+nN); // A Fragment |
---|
| 408 | theQPDG2 = G4QPDGCode(311); // A K0 meson |
---|
[819] | 409 | } |
---|
[1055] | 410 | } |
---|
[819] | 411 | else |
---|
[1055] | 412 | { |
---|
[819] | 413 | G4cerr<<"***G4QChipolino: ***Too many kaons are needed*** rQC="<<rQC<<G4endl; |
---|
[1055] | 414 | //throw G4QException("G4QChipolino: More than one Kaon is needed for NuclFragm"); |
---|
| 415 | } |
---|
| 416 | } |
---|
[819] | 417 | else // Fragment with strangeness |
---|
[1055] | 418 | { |
---|
[819] | 419 | if(kS<=kU&&kS<=kD) // Fragment consisting of Neutrons, Protons & Lambrdas only |
---|
[1055] | 420 | { |
---|
| 421 | G4int nI=kU-kD; // Isotopic shift |
---|
[819] | 422 | G4int nN=(kU+kD-kS-kS-nI*3)/6; |
---|
[1055] | 423 | if((nI>=0&&nN>=0)||(nI<0&&nN>=-nI)) // Delta isn't necessary |
---|
[819] | 424 | { |
---|
[1055] | 425 | if(nI>0) // Excess of protons |
---|
[819] | 426 | { |
---|
[1055] | 427 | theQPDG1 = G4QPDGCode(90000000+1000*(kS*1000+nN+nI-1)+nN);// Fragment-Proton |
---|
| 428 | theQPDG2 = G4QPDGCode(2212); // A Proton |
---|
[819] | 429 | } |
---|
[1055] | 430 | else // Excess of neutrons |
---|
[819] | 431 | { |
---|
[1055] | 432 | theQPDG1 = G4QPDGCode(90000000+1000*(kS*1000+nN+nI)+nN-1);// Fragment-Neutron |
---|
| 433 | theQPDG2 = G4QPDGCode(2112); // A Neutron |
---|
[819] | 434 | } |
---|
[1055] | 435 | } |
---|
| 436 | else if((nI>=0&&nN>-2)||(nI<0&&nN>-nI-2)) // Delta can be a part |
---|
| 437 | { |
---|
| 438 | if(nI>0) // Excess of u-quarks |
---|
[819] | 439 | { |
---|
[1055] | 440 | theQPDG1=G4QPDGCode(90000000+1000*(kS*1000+nN+nI-2)+nN+1);// Fragment-Proton |
---|
| 441 | theQPDG2=G4QPDGCode(2224); // A Delta++ |
---|
[819] | 442 | } |
---|
[1055] | 443 | else // Excess of d-quarks |
---|
[819] | 444 | { |
---|
[1055] | 445 | theQPDG1=G4QPDGCode(90000000+1000*(kS*1000+nN+nI+1)+nN-2);// Fragment-Neutron |
---|
| 446 | theQPDG2=G4QPDGCode(1114); // A Delta- |
---|
[819] | 447 | } |
---|
[1055] | 448 | } |
---|
[819] | 449 | else |
---|
[1055] | 450 | { |
---|
[819] | 451 | G4cerr<<"***G4QChipolino: ***Isotopic assimetry (with S)*** rQC="<<rQC<<G4endl; |
---|
[1055] | 452 | //throw G4QException("G4QChipolino:IsotopicAssimety of StrangeMultyBar Quasm"); |
---|
| 453 | } |
---|
| 454 | } |
---|
| 455 | else // Excess of s-quarks |
---|
| 456 | { |
---|
| 457 | G4int lam=kU; // A#of Lambda |
---|
[819] | 458 | if (lam>kD) lam=kD; |
---|
[1055] | 459 | G4int lD=kD-lam; // Residual d-quarks |
---|
| 460 | G4int lU=kU-lam; // Residual u-quarks |
---|
| 461 | G4int lS=kS-lam; // Residual s-quarks |
---|
[819] | 462 | if(lD+lU+lS!=3||lD<0||lU<0||lS<0) |
---|
[1055] | 463 | { |
---|
| 464 | G4cerr<<"***G4QChipolino:*Fragment*rQC="<<rQC<<",s="<<lS<<",u="<<lU<<",d" |
---|
| 465 | <<lD<<G4endl; |
---|
| 466 | //throw G4QException("G4QChipolino: Exotic superstrange Multy Baryon"); |
---|
| 467 | } |
---|
| 468 | if ( !lD && lU==2) theQPDG2=G4QPDGCode(3222); // Sigma+ |
---|
| 469 | else if( !lU && lD==2) theQPDG2=G4QPDGCode(3112); // Sigma- |
---|
| 470 | else if( !lD && lU==1) theQPDG2=G4QPDGCode(3322); // Ksi0 |
---|
| 471 | else if( !lU && lD==1) theQPDG2=G4QPDGCode(3312); // Ksi- |
---|
| 472 | else theQPDG2=G4QPDGCode(3334); // Omega- |
---|
| 473 | theQPDG1=G4QPDGCode((90+lam)*1000000); // Strange Matter |
---|
| 474 | } |
---|
| 475 | theQCont1 = rQC-theQPDG2.GetQuarkContent(); // QCont of Fragment-H |
---|
| 476 | theQCont = rQC; // QCont of Chipolino |
---|
| 477 | } |
---|
| 478 | } |
---|
[819] | 479 | } |
---|
| 480 | else |
---|
| 481 | { |
---|
| 482 | G4cerr<<"***G4QChipolino: ***Exotics*** rQC="<<rQC<<G4endl; |
---|
[1055] | 483 | //throw G4QException("G4QChipolino: can't be constructed for exotic baryon or meson"); |
---|
[819] | 484 | } |
---|
| 485 | } |
---|
| 486 | |
---|
| 487 | G4QChipolino::G4QChipolino(const G4QChipolino& right) |
---|
| 488 | { |
---|
| 489 | theQPDG1 = right.theQPDG1; |
---|
| 490 | theQPDG2 = right.theQPDG2; |
---|
| 491 | theQCont = right.theQCont; |
---|
| 492 | theQCont1 = right.theQCont1; |
---|
| 493 | minM = right.minM; |
---|
| 494 | } |
---|
| 495 | |
---|
| 496 | G4QChipolino::G4QChipolino(G4QChipolino* right) |
---|
| 497 | { |
---|
| 498 | theQPDG1 = right->theQPDG1; |
---|
| 499 | theQPDG2 = right->theQPDG2; |
---|
| 500 | theQCont = right->theQCont; |
---|
| 501 | theQCont1 = right->theQCont1; |
---|
| 502 | minM = right->minM; |
---|
| 503 | } |
---|
| 504 | |
---|
| 505 | const G4QChipolino& G4QChipolino::operator=(const G4QChipolino &right) |
---|
| 506 | { |
---|
| 507 | if(this != &right) // Beware of self assignment |
---|
| 508 | { |
---|
| 509 | theQPDG1 = right.theQPDG1; |
---|
| 510 | theQPDG2 = right.theQPDG2; |
---|
| 511 | theQCont = right.theQCont; |
---|
| 512 | theQCont1 = right.theQCont1; |
---|
| 513 | minM = right.minM; |
---|
| 514 | } |
---|
| 515 | return *this; |
---|
| 516 | } |
---|
| 517 | |
---|
| 518 | G4QChipolino::~G4QChipolino() {} |
---|
| 519 | |
---|
| 520 | // Standard output for G4QChipolino |
---|
| 521 | ostream& operator<<(ostream& lhs, G4QChipolino& rhs) |
---|
| 522 | {// =========================================== |
---|
| 523 | lhs<<"{1="<<rhs.GetQPDG1()<<",2="<<rhs.GetQPDG2()<< "}"; |
---|
| 524 | return lhs; |
---|
| 525 | } |
---|
| 526 | |
---|
| 527 | |
---|
| 528 | |
---|
| 529 | |
---|
| 530 | |
---|
| 531 | |
---|