Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Member Functions | Static Public Member Functions | Protected Member Functions | List of all members
G4QEnvironment Class Reference

#include <G4QEnvironment.hh>

Public Member Functions

 G4QEnvironment (const G4QNucleus &theEnv)
 
 G4QEnvironment (const G4QHadronVector &projHadrons, const G4int targPDG)
 
 G4QEnvironment (const G4QEnvironment &right)
 
 G4QEnvironment (G4QEnvironment *right)
 
 ~G4QEnvironment ()
 
const G4QEnvironment & operator= (const G4QEnvironment &right)
 
G4bool operator== (const G4QEnvironment &right) const
 
G4bool operator!= (const G4QEnvironment &right) const
 
G4QNucleus GetEnvironment () const
 
G4QuasmonVector * GetQuasmons ()
 
G4QHadronVector * GetQHadrons ()
 
G4QHadronVector * GetProjectiles ()
 
void AddQuasmon (G4Quasmon *Q)
 
G4QHadronVector * Fragment ()
 
void DecayBaryon (G4QHadron *dB, G4QHadronVector *HV)
 
void DecayMeson (G4QHadron *dB, G4QHadronVector *HV)
 
void DecayAntistrange (G4QHadron *aS, G4QHadronVector *HV)
 
void CheckMassShell (G4QHadronVector *HV)
 

Static Public Member Functions

static void SetParameters (G4double solAn=0.4, G4bool efFlag=false, G4double piThresh=141.4, G4double mpisq=20000., G4double dinum=1880.)
 
static void OpenElectromagneticDecays ()
 
static void CloseElectromagneticDecays ()
 

Protected Member Functions

void CleanUpQHadrons ()
 
void FillQHadrons (G4QHadronVector *input)
 

Detailed Description

Definition at line 50 of file G4QEnvironment.hh.

Constructor & Destructor Documentation

◆ G4QEnvironment() [1/4]

G4QEnvironment::G4QEnvironment ( const G4QNucleus &  theEnv)

Definition at line 69 of file G4QEnvironment.cc.

70 : theEnvironment(theEnv)
71{
72 theQFScat = G4QFreeScattering::GetPointer();
73 G4int envPDG = theEnv.GetPDG();
74 G4QPDGCode envQPDG(envPDG);
75 G4int envA = envQPDG.GetBaryNum();
76 G4double envM = envQPDG.GetMass();
77 theWorld = 0;
78 nBarClust = 0;
79 f2all = 0;
80 totCharge = envQPDG.GetCharge();
81 totBaryoN = envA;
82 tot4Mom = G4LorentzVector(0.,0.,0.,envM);
83 theTargetPDG = 0;
84#ifdef debug
85 G4cout << "G4QEnviron::Const: t4M=" << tot4Mom << ",tC=" << totCharge
86 << ",tB=" << totBaryoN << G4endl;
87#endif
88}
G4LorentzVector
CLHEP::HepLorentzVector G4LorentzVector
Definition: G4LorentzVector.hh:35
G4double
double G4double
Definition: G4Types.hh:64
G4int
int G4int
Definition: G4Types.hh:66
G4endl
#define G4endl
Definition: G4ios.hh:52
G4cout
G4DLLIMPORT std::ostream G4cout
G4QFreeScattering::GetPointer
static G4QFreeScattering * GetPointer()
Definition: G4QFreeScattering.cc:64
G4QNucleus::GetPDG
G4int GetPDG() const
Definition: G4QNucleus.hh:69

◆ G4QEnvironment() [2/4]

G4QEnvironment::G4QEnvironment ( const G4QHadronVector &  projHadrons,
const G4int  targPDG 
)

Definition at line 91 of file G4QEnvironment.cc.

93 : theEnvironment(90000000) // User is responsible for projHadrons(Vector)
94{
95 //static const G4double mNeut= G4QPDGCode(2112).GetMass();
96 //static const G4QContent neutQC(2,1,0,0,0,0);
97 static const G4QPDGCode pimQPDG(-211);
98 theQFScat = G4QFreeScattering::GetPointer();
99 theWorld = G4QCHIPSWorld::Get(); // Get a pointer to the CHIPS World
100 nBarClust = 0;
101 totCharge = 0;
102 totBaryoN = 0;
103 f2all = 0;
104 G4bool fake=false; // At present only fake pi-
105 theTargetPDG=targPDG; // Remenber it for error message
106 G4int nHadrons=projHadrons.size(); // A#of hadrons in the input Vector
107
108#ifdef debug
109 G4cout<<"--->>G4QE::Const: Called targPDG="<<targPDG<<", nInpHadr="<<nHadrons<<G4endl;
110#endif
111 if(nHadrons<1 || targPDG==90000000) // No projectile Hadrons or no target Nucleus
112 {
113 G4cout << "---Warning---G4QEnv::Const:a#ofINPHadr=" << nHadrons
114 << ",tPDG=" << targPDG << G4endl;
115 //throw G4QException("***G4QEnvironment: There is no one projectile or vacuum target");
116 if(nHadrons) // The projectiles are copied to the output
117 {
118 for (G4int ih=0; ih<nHadrons; ih++)
119 {
120 G4QHadron* curQH = new G4QHadron(projHadrons[ih]);
121#ifdef debug
122 G4cout << "*G4QE::Const:iH#" << ih << "," << curQH->GetQC()
123 << curQH->Get4Momentum() << G4endl;
124#endif
125
126 if (curQH->GetPDGCode() == 10) {
127 // Chipolino is found in the input -> Decay
128
129 G4QContent chQC=curQH->GetQC();
130 // Quark content of the Hadron-Chipolino
131 G4QChipolino QCh(chQC);
132 // Define a Chipolino instance for the Hadron
133
134 G4LorentzVector ch4M=curQH->Get4Momentum(); // 4Mom of the Hadron-Chipolino
135 G4QPDGCode h1QPDG=QCh.GetQPDG1(); // QPDG of the first hadron
136 G4double h1M =h1QPDG.GetMass();// Mass of the first hadron
137 G4QPDGCode h2QPDG=QCh.GetQPDG2(); // QPDG of the second hadron
138 G4double h2M =h2QPDG.GetMass();// Mass of the second hadron
139 G4double chM2 =ch4M.m2(); // Squared Mass of the Chipolino
140 if( sqr(h1M+h2M) < chM2 ) // Decay is possible
141 {
142 G4LorentzVector h14M(0.,0.,0.,h1M);
143 G4LorentzVector h24M(0.,0.,0.,h2M);
144 if(!G4QHadron(ch4M).DecayIn2(h14M,h24M))
145 {
146 G4ExceptionDescription ed;
147 ed << "QChip DecIn2 error: CM=" << std::sqrt(chM2) << " -> h1="
148 << h1QPDG << "(" << h1M << ") + h2=" << h1QPDG << "(" << h2M
149 << ") = " << h1M+h2M << " **Failed**" << G4endl;
150 G4Exception("G4QEnvironment::G4QEnvironment()", "HAD_CHPS_0000",
151 FatalException, ed);
152 }
153 delete curQH; // Kill the primary Chipolino
154 G4QHadron* h1H = new G4QHadron(h1QPDG.GetPDGCode(),h14M);
155 theQHadrons.push_back(h1H); // (delete equivalent)
156 curQH = new G4QHadron(h1H); // ... just to remember independently
157 theProjectiles.push_back(curQH); // Remember it for the error message
158
159#ifdef debug
160 G4cout<<"G4QE::Constr: QChipolino -> H1="<<h1QPDG<<h14M<<G4endl;
161#endif
162 curQH = new G4QHadron(h2QPDG.GetPDGCode(),h24M);
163 theQHadrons.push_back(curQH); // (delete equivalent)
164#ifdef debug
165 G4cout<<"G4QE::Constr: QChipolino -> H2="<<h2QPDG<<h24M<<G4endl;
166#endif
167 }
168 else
169 {
170 G4ExceptionDescription ed;
171 ed << "LowMassChipolino in Input: " << ih << "," << curQH->GetQC()
172 << curQH->Get4Momentum() << ", chipoM=" << std::sqrt(chM2) << " < m1="
173 << h1M << "(" << h1QPDG << ") + m2=" << h2M << "(" << h2QPDG << ") = "
174 << h1M+h2M << G4endl;
175 G4Exception("G4QEnvironment::G4QEnvironment()", "HAD_CHPS_0001",
176 FatalException, ed);
177 }
178 }
179 theQHadrons.push_back(curQH); // (delete equivalent)
180 curQH = new G4QHadron(curQH); // ... just to remember independently
181 theProjectiles.push_back(curQH); // Remenber it for the error message
182 }
183 }
184 else if(targPDG!=90000000) // No projHadrons,fill targetNucleus to output
185 {
186 G4QHadron* curQH = new G4QHadron(targPDG);
187#ifdef debug
188 G4cout<<"**G4QE::Const:No iHad,eH="<<curQH->GetQC()<<curQH->Get4Momentum()<<G4endl;
189#endif
190 theQHadrons.push_back(curQH); // (delete equivalent)
191 }
192 if (nHadrons<0) G4cout<<"***Warning****G4QE::Const:NH="<<nHadrons<<" < 0 !"<<G4endl;
193 return;
194 }
195 G4QPDGCode targQPDG(targPDG);
196#ifdef debug
197 G4cout<<"G4QE::C:targQPDG="<<targQPDG<<G4endl;
198#endif
199 G4int targA=targQPDG.GetBaryNum();
200 G4double targM=targQPDG.GetMass();
201 totCharge=targQPDG.GetCharge();
202 totBaryoN=targA;
203 tot4Mom=G4LorentzVector(0.,0.,0.,targM);
204 // === Print out of the input information at Creation time & tot 4-mom Calculation ===
205#ifdef debug
206 G4cout<<"G4QE::C:PDG="<<targPDG<<",C="<<totCharge<<",M="<<targM<<",n="<<nHadrons<<G4endl;
207#endif
208 for(G4int ipr=0; ipr<nHadrons; ipr++)// LOOP is used for the tot4Mom calc. & for printing
209 {
210 G4QHadron* prHadr = projHadrons[ipr];
211 G4QHadron* curQH = new G4QHadron(prHadr);// Remenber it for _
212 theProjectiles.push_back(curQH); // the error message
213 G4LorentzVector h4Mom = prHadr->Get4Momentum();
214 tot4Mom += h4Mom;
215 totCharge += prHadr->GetCharge();
216 totBaryoN += prHadr->GetBaryonNumber();
217#ifdef debug
218 G4int hPDG = prHadr->GetPDGCode();
219 G4int hNFrag= prHadr->GetNFragments();
220 G4QContent hQC = prHadr->GetQC();
221 G4cout<<"G4QE::C:#"<<ipr<<",PDG="<<hPDG<<hQC<<",4M="<<h4Mom<<",hNFr="<<hNFrag<<G4endl;
222#endif
223 }
224#ifdef debug
225 G4cout<<"G4QEnv::Const:tC="<<totCharge<<",tB="<<totBaryoN<<",tot4M="<<tot4Mom<<G4endl;
226#endif
227#ifdef debug
228 G4cout<<"G4QEnv::Const: --> tC="<<totCharge<<",tB="<<totBaryoN<<G4endl;
229#endif
230 G4int nP=theWorld->GetQPEntries(); // A#of init'ed particles in CHIPS World
231 //G4int nCl=nP-90; // A#of init'ed clusters in CHIPS World
232 G4int nCl=nP-53; // @@ A#ofClusters in CHIPSWorld (53=nQHM in G4QPDGCode.hh)
233#ifdef debug
234 G4cout<<"G4QEnv:Const:Before NCI:n="<<nP<<",F="<<projHadrons[0]->GetNFragments()<<",tC="
235 <<totCharge<<",tB="<<totBaryoN<<", nCl="<<nCl<<G4endl;
236#endif
237 InitClustersVector(nCl,targA); // Init Clusters as Particles (to interact)
238#ifdef debug
239 G4cout<<"G4QEnv::Const:NucClust,n="<<nCl<<",F="<<projHadrons[0]->GetNFragments()<<",tC="
240 <<totCharge<<",tB="<<totBaryoN<<G4endl;
241#endif
242 if(targPDG>80000000) // ==> Nuclear target (including NUCPDG)
243 {
244 theEnvironment.InitByPDG(targPDG); // Create nuclear environment
245#ifdef debug
246 G4cout<<"G4QEnv::Const:nH="<<nHadrons<<",PDG="<<projHadrons[0]->GetPDGCode()<<",tC="
247 <<totCharge<<",tB="<<totBaryoN<<G4endl;
248#endif
249 if(nHadrons==1)
250 {
251 G4QHadron* opHad=projHadrons[0];
252 G4int opPDG=opHad->GetPDGCode();
253#ifdef debug
254 G4cout<<"G4QEnviron::Constructor: *** Only one input hadron*** PDG="<<opPDG<<G4endl;
255#endif
256 if(opPDG==22) // *** Check photon's NuclearSplitThreshold
257 {
258 G4double exMass=tot4Mom.m();
259#ifdef debug
260 G4cout<<"G4QEnvironment::Const: exM="<<exMass-targM<<" > mPi0 ?"<<G4endl;
261#endif
262 if(exMass<targM+135.977) // Nucleus is below the pion production threshold
263 {
264 G4QNucleus exEnviron(tot4Mom,targPDG);
265 // @@ One can put here the pbpt= (M.K.) @@ What about d,t,alpha splitting?
266 if(targM>999.&&!exEnviron.SplitBaryon())//Nucleus is below SplitFragmentThreshold
267 {
268#ifdef debug
269 G4cout<<"G4QEnv::Const:Photon's added to Output, Env="<<theEnvironment<<G4endl;
270#endif
271 G4QHadron* photon = new G4QHadron(opHad); // Fill projPhoton to Output
272#ifdef debug
273 G4cout<<"**G4QE::Const:Phot="<<photon->GetQC()<<photon->Get4Momentum()<<G4endl;
274#endif
275 theQHadrons.push_back(photon); // (delete equivalent)
276 return;
277 }
278 else if(targM<=999.) // Target is a nucleon
279 {
280 G4LorentzVector prot4m(0.,0.,0.,targM); // Prototype of secondary proton 4mom
281 G4LorentzVector gam4m(0.,0.,0.,0.); // Prototype for secondary gamma 4mom
282 if(!G4QHadron(tot4Mom).DecayIn2(prot4m,gam4m))
283 {
284#ifdef debug
285 G4cout<<"*War*G4QEnv::Const:(P)Photon->Output, Env="<<theEnvironment<<G4endl;
286#endif
287 G4QHadron* photon = new G4QHadron(opHad); // Fill projPhoton to Output
288#ifdef debug
289 G4cout<<"**G4QE::Const:Ph="<<photon->GetQC()<<photon->Get4Momentum()<<G4endl;
290#endif
291 theQHadrons.push_back(photon); // (delete equivalent)
292 return;
293 }
294 G4QHadron* proton = new G4QHadron(targPDG,prot4m); // Fill tgProton to Output
295 theQHadrons.push_back(proton); // (delete equivalent)
296 G4QHadron* photon = new G4QHadron(22,gam4m); // Fill prPhoton to Output
297 theQHadrons.push_back(photon); // (delete equivalent)
298 theEnvironment.InitByPDG(90000000); // Create nuclear environment
299#ifdef debug
300 G4cout<<"G4QEnv::Const:Fill gamma and N from gam+N"<<targPDG<<prot4m<<G4endl;
301#endif
302 return;
303 }
304 }
305 }
306 else if(opPDG==13 || opPDG==15)
307 {
308 G4int nuPDG=14;
309 if(opPDG==15) nuPDG=16;
310 G4LorentzVector mu4m=opHad->Get4Momentum();
311 //G4double qpen=-180.*log(G4UniformRand()); // Energy of target-quark-parton(T=180)
312 G4double qpen=465.*sqrt(sqrt(G4UniformRand())); // UniformDistr for 3-q nucleon
313 G4double qpct=2*G4UniformRand()-1.; // Cos(thet) of target-quark-parton
314 G4double qpst=sqrt(1.-qpct*qpct); // Sin(theta) of target-quark-parton
315 G4double qppt=qpen*qpst; // PT of target-quark-parton
316 G4double qphi=twopi*G4UniformRand(); // Phi of target-quark-parton
317 G4LorentzVector qi4m(qppt*sin(qphi),qppt*cos(qphi),qpen*qpct,qpen); // quark-parton
318 G4LorentzVector qt4m=mu4m+qi4m; // Total 4mom (iniQP+lepton)
319 G4LorentzVector nu4m(0.,0.,0.,0.); // Prototype of secondary neutrino 4mom
320 G4LorentzVector qf4m(0.,0.,0.,0.); // Prototype for secondary quark-parton
321 G4QContent targQC=targQPDG.GetQuarkContent(); // QC of the target nucleus (local!)
322 targQC+=G4QContent(1,0,0,0,1,0); // Make iso-shift with fake pi- is added
323 G4LorentzVector fn4m=G4LorentzVector(0.,0.,0.,0.); // Prototype of the residual 4M
324 G4QNucleus fnN(targQC,fn4m); // Define the final state nucleus
325 G4double fnm=fnN.GetMZNS(); // GS Mass of the final state nucleus
326 //G4QContent resiQC=targQC-neutQC; // QC of resid nucleus (-neutron)
327 //G4QNucleus rsN(resiQC,fn4m); // Define the final state nucleus
328 //G4double rsm=rsN.GetMZNS()+mNeut; // GS Mass of residual nucleus w/o neutron
329 G4double tm=0.; // Prototype of RealMass of the final nucleus
330 G4LorentzVector tg4m=G4LorentzVector(0.,0.,0.,targM); // 4mom of all target nucleus
331 G4LorentzVector fd4m=tg4m-qi4m; // 4mom of the residual coloured nuclear sys.
332#ifdef debug
333 //G4cout<<"-->>G4QEnv::Const:rM="<<rsm<<",fM="<<fnm<<",tM="<<targM<<G4endl;
334 G4cout<<"G4QEnvironment::Const:mu4M="<<mu4m<<",t4M="<<qt4m<<",tgQP="<<qi4m<<G4endl;
335#endif
336 while (tm<=fnm)
337 {
338 if(!G4QHadron(qt4m).DecayIn2(nu4m,qf4m))
339 {
340 G4cout<<"***G4QE::Constr:Muon error (1) 4M="<<mu4m<<". Fill as it is."<<G4endl;
341 G4QHadron* lepton = new G4QHadron(opHad); // Fill projMuon to Output
342 theQHadrons.push_back(lepton); // (delete equivalent)
343 return;
344 }
345#ifdef mudebug
346 G4cout<<"G4QEnv::Const:i="<<qi4m<<",t="<<qt4m<<"->n="<<nu4m<<"+q="<<qf4m<<G4endl;
347#endif
348 fn4m=fd4m+qf4m;
349 tm=fn4m.m(); // Real mass of the final nucleus
350#ifdef mudebug
351 G4cout<<"--G4QEnv::Const:M="<<tm<<",GSM=="<<fnm<<G4endl;
352#endif
353 }
354 fnN.Set4Momentum(fn4m);
355 // (mu,q->nu,q) reaction succeded and Neutrino can be pushed to Output
356 G4QHadron* neutrino = 0; // NeutrinoPrototype to be filled to Output
357#ifdef mudebug
358 G4cout<<"G4QEnv::Const:fM="<<tm<<fn4m<<",GSM="<<fnm<<G4endl;
359#endif
360 if(tm<fnm) // Final Nucleus is below the GS threshold
361 {
362 qf4m=G4LorentzVector(0.,0.,0.,fnm); // Final nucleus 4M for the final decay
363 qt4m=tg4m+mu4m;
364 if(!G4QHadron(qt4m).DecayIn2(nu4m,qf4m)) // Decay in Nucleus+nu_mu
365 {
366 G4cout<<"***G4QE::Constr:Muon error (2) 4M="<<mu4m<<". Fill as it is."<<G4endl;
367 G4QHadron* muon = new G4QHadron(opHad); // Fill projMuon to Output
368 theQHadrons.push_back(muon); // (delete equivalent)
369 return;
370 }
371 G4QHadron* fnuc = new G4QHadron(targQC,qf4m); // Fill Final Nucleus to Output
372 //theQHadrons.push_back(fnuc); // (delete equivalent)
373 EvaporateResidual(fnuc); // Try to evaporate residual (del. equiv.)
374 neutrino = new G4QHadron(nuPDG,nu4m);// Fill Neutrino to Output
375 theEnvironment.InitByPDG(90000000); // Create nuclear environment
376#ifdef debug
377 G4cout<<"G4QEnv::Const:Fill neutrino (1) "<<nuPDG<<nu4m<<G4endl;
378#endif
379 theQHadrons.push_back(neutrino); // (delete equivalent)
380 return;
381 }
382 neutrino = new G4QHadron(nuPDG,nu4m); // Fill Neutrino to Output
383#ifdef debug
384 G4cout<<"G4QEnv::Const:Fill neutrino (2) "<<nuPDG<<nu4m<<G4endl;
385#endif
386 theQHadrons.push_back(neutrino); // (delete equivalent)
387 if(tm<fnm+135.98) // FinalNucleus is below thePionThreshold(HE)
388 {
389 if(!fnN.SplitBaryon()) // Final Nucleus is below the splittingFragmentThreshold
390 {
391#ifdef mudebug
392 G4cout<<"G4QEnv::Const: impossible to split nucleon after mu->nu"<<G4endl;
393#endif
394 G4LorentzVector ga4m(0.,0.,0.,0.);
395 qf4m=G4LorentzVector(0.,0.,0.,fnm);// Final nucleus 4M for the final decay
396 if(!G4QHadron(fn4m).DecayIn2(ga4m,qf4m)) // Decay in Nucleus+photon
397 {
398 G4cout<<"***G4QE::Constr:LepCapError(3),M="<<fn4m.m()<<"<"<<fnm<<G4endl;
399 G4QHadron* resid = new G4QHadron(targQC,qt4m); // Fill ResidNucleus to Output
400 theQHadrons.push_back(resid); // (delete equivalent)
401 theEnvironment.InitByPDG(90000000);// Create nuclear environment
402 return;
403 }
404 G4QHadron* photon = new G4QHadron(22,ga4m); // Fill projPhoton to Output
405#ifdef debug
406 G4cout<<"G4QEnv::Const:Fill photon "<<ga4m<<G4endl;
407#endif
408 theQHadrons.push_back(photon); // (delete equivalent)
409 G4QHadron* fnuc = new G4QHadron(targQC,qf4m); // Fill Final Nucleus to Output
410#ifdef debug
411 G4cout<<"G4QEnv::Const:Fill target "<<targQC<<qf4m<<" in any form"<<G4endl;
412#endif
413 EvaporateResidual(fnuc); // Try to evaporate residual (del. equiv.)
414 theEnvironment.InitByPDG(90000000);// Create nuclear environment
415 return;
416 }
417 }
418 // At this poin it is possible to convert mu- to pi-
419 fn4m=qf4m-qi4m;
420 opHad->SetQPDG(pimQPDG); //Convert (mu-)u->d to (virt pi-)u->d capture
421 fake=false; // normal pi- for q-muon scattering
422 //fake=true; // fake pi- for q-muon scattering *****
423 //if(G4UniformRand()>.5) fake=false; // normal pi- for q-muon scattering *****
424 opHad->Set4Momentum(fn4m);
425 }
426 }
427 for(G4int ih=0; ih<nHadrons; ih++) // ==> The main LOOP over projQHadrons
428 {
429 G4QHadron* curHadr=projHadrons[ih]; // Pointer to current projectile Hadron
430 G4int hNFrag = curHadr->GetNFragments();// #0 means intermediate (skip)
431 G4LorentzVector ch4M=curHadr->Get4Momentum(); // 4-momenyum of the current projectile
432#ifdef debug
433 G4cout<<"G4QE:C:"<<ih<<",F="<<hNFrag<<",0="<<projHadrons[0]->GetNFragments()<<G4endl;
434#endif
435 if(!hNFrag&&ch4M.e()>0.) // => "Final hadron" case
436 {
437 G4int envPDG=theEnvironment.GetPDG();
438 if(envPDG==90000000||(theEnvironment.Get4Momentum().m2())<1.) // ==>"Vacuum"
439 {
440 G4int hPDG = curHadr->GetPDGCode();// A PDG Code of the projQHadron
441 //if(!hPDG||hPDG==10) // Check for the validity of the QHadron (@@ 10 OK?)
442 if(!hPDG) // Check for the validity of the QHadron
443 {
444 //G4cerr<<"--Warning--G4QEnvironment::Constructor: wrong PDG("<<ih<<")="<<hPDG
445 // <<", HQC="<<curHadr->GetQC()<<", HM="<<curHadr->GetMass()<<G4endl;
446 //throw G4QException("***G4QEnvironment::Constructor: theInputHadron is Chip");
447 }
448 else
449 {
450 G4int hQ = curHadr->GetQCode(); // One more check for valid of the QHadron
451 if(hQ<0)
452 {
453 //G4cerr<<"--Warning--G4QEnv::Constructor:Q<0, PDG=("<<ih<<")"<<hPDG<<G4endl;
454 //throw G4QException("***G4QEnvironment::Constructor:theInputHadron is bad");
455 }
456 else
457 {
458 G4QHadron* newHadr = new G4QHadron(curHadr);
459#ifdef debug
460 G4cout<<"*G4QE::Const:H="<<newHadr->GetQC()<<newHadr->Get4Momentum()<<G4endl;
461#endif
462 theQHadrons.push_back(newHadr); // Fill existing hadron (delete equivalent)
463#ifdef debug
464 G4cout<<"G4QEnviron::Constructor: Fill h="<<hPDG<<ch4M<<G4endl;
465 for(unsigned ipo=0; ipo<theQHadrons.size(); ipo++) // LOOP just for printing
466 {
467 G4int hPDG = theQHadrons[ipo]->GetPDGCode();
468 G4LorentzVector h4Mom = theQHadrons[ipo]->Get4Momentum();
469 G4int hNFrag= theQHadrons[ipo]->GetNFragments();
470 G4QContent hQC = theQHadrons[ipo]->GetQC();
471 G4cout<<"h#"<<ipo<<": "<<hPDG<<hQC<<",4M="<<h4Mom<<",nFr="<<hNFrag<<G4endl;
472 }
473#endif
474 } // End of Q-Code check
475 } // End of proper PDG for i-th Hadron
476 }
477 else // Nuclear Environment still exists
478 {
479 G4QContent hQC = curHadr->GetQC();
480#ifdef debug
481 G4cout<<"G4QE::Const:CreateQuasm, 4M="<<ch4M<<",QC="<<hQC<<",E="<<envPDG<<",tC="
482 <<totCharge<<",tB="<<totBaryoN<<G4endl;
483#endif
484 CreateQuasmon(hQC, ch4M, fake);
485 } // End of Existing Nuclear Environment case
486 } // End of final hadron case
487 } // End of the LOOP over input hadrons
488 } // End of nuclear target case (including neutron=90000001 & proton=90001000)
489 else // => "Unique hadron" case
490 {
491 // the nuclEnviron is already init'ed as vacuum + get the first hadron for interaction
492 G4QHadron* curHadr=projHadrons[0]; // Pointer to the firstProjecHadron (checked)
493 G4int hPDG = curHadr->GetPDGCode(); // A PDG Code of the projQHadron
494 if(!hPDG||hPDG==10) // Check for the validity of the QHadron
495 {
496 G4cout<<"---Warning---G4QEnvironment::Constructor:Vacuum,1st Hadron wrong PDG="<<hPDG
497 <<", HQC="<<curHadr->GetQC()<<", HM="<<curHadr->GetMass()<<G4endl;
498 //throw G4QException("***G4QEnvironment::Constructor: Fiest input Hadron is wrong");
499 }
500 else
501 {
502 G4int hQ = curHadr->GetQCode(); // One more check for valid of the QHadron
503 if(hQ<0)
504 {
505 G4cout<<"---Warning---G4QEnviron::Constructor:Vacuum,Q<0, 1st HPDG="<<hPDG<<G4endl;
506 //throw G4QException("***G4QEnvironment::Constructor:theFirstInputHadron's wrong");
507 }
508 else // Now we can get 4Mom & QC of incedent particle
509 {
510 G4LorentzVector h4Mom = curHadr->Get4Momentum();
511 G4QContent hQC = curHadr->GetQC();
512 if(!targPDG||targPDG==10) G4cout<<"G4QEnv::CreateQ; (1) PDG="<<targPDG<<G4endl;
513 G4QPDGCode tQPDG(targPDG);
514 G4int tQ = tQPDG.GetQCode();
515 if(tQ<0||targPDG==10)
516 {
517 G4cout<<"---Warning---G4QEnv::Constructor:TrgQC<0, Chipo?,PDG="<<targPDG<<G4endl;
518 //throw G4QException("***G4QEnvironment::Constructor: Target is wrong");
519 }
520 else // Now we can create a unique Quasmon
521 {
522 h4Mom+=G4LorentzVector(0.,0.,0.,tQPDG.GetMass()); //Projectile + TargetHadron
523 hQC+=tQPDG.GetQuarkContent();
524#ifdef debug
525 G4cout<<"G4QEnv::Const:VacHadrTarg="<<h4Mom<<hQC<<",E="<<theEnvironment<<G4endl;
526#endif
527 G4Quasmon* curQuasmon = new G4Quasmon(hQC, h4Mom);
528 theQuasmons.push_back(curQuasmon); // Insert Quasmon or hadron/gamma (del. eq.)
529 }
530 } // End of Q-Code check
531 } // End of proper PDG for i-th Hadron
532 if(nHadrons>1) for(G4int ih=0; ih<nHadrons; ih++) // fill other Hadrons to Output
533 {
534 G4QHadron* newHadr = new G4QHadron(curHadr);
535#ifdef debug
536 G4cout<<"*G4QE::Const:#"<<ih<<","<<curHadr->GetQC()<<curHadr->Get4Momentum()<<G4endl;
537#endif
538 theQHadrons.push_back(newHadr); // Fill existing hadron (delete equivalent)
539 }
540 } // End of Unique Hadron target treatment
541#ifdef chdebug
542 G4int finCharge=theEnvironment.GetCharge();
543 G4int finBaryoN=theEnvironment.GetA();
544 G4int nHad=theQHadrons.size();
545 if(nHad) for(G4int ih=0; ih<nHad; ih++)
546 {
547 finCharge+=theQHadrons[ih]->GetCharge();
548 finBaryoN+=theQHadrons[ih]->GetBaryonNumber();
549 }
550 G4int nQuas=theQuasmons.size();
551 if(nQuas) for(G4int iq=0; iq<nQuas; iq++)
552 {
553 finCharge+=theQuasmons[iq]->GetCharge();
554 finBaryoN+=theQuasmons[iq]->GetBaryonNumber();
555 }
556 if(finCharge!=totCharge || finBaryoN!=totBaryoN)
557 {
558 G4cout<<"*::*G4QEnv::C:(0) tC="<<totCharge<<",C="<<finCharge<<",tB="<<totBaryoN
559 <<",B="<<finBaryoN<<",E="<<theEnvironment<<G4endl;
560 if(nHad) for(G4int h=0; h<nHad; h++)
561 {
562 G4QHadron* cH = theQHadrons[h];
563 G4cout<<"*:*G4QE::C:h#"<<h<<",QC="<<cH->GetQC()<<",PDG="<<cH->GetPDGCode()<<G4endl;
564 }
565 if(nQuas) for(G4int q=0; q<nQuas; q++)
566 {
567 G4Quasmon* cQ = theQuasmons[q];
568 G4cout<<"::G4QE::C:q#"<<q<<",C="<<cQ->GetCharge()<<",QuarkCon="<<cQ->GetQC()<<G4endl;
569 }
570 }
571#endif
572} // End of the G4QEnvironment constructor
photon
@ photon
Definition: G4DataQuestionaire.hh:35
FatalException
@ FatalException
Definition: G4ExceptionSeverity.hh:60
G4bool
bool G4bool
Definition: G4Types.hh:67
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:53
G4QCHIPSWorld::Get
static G4QCHIPSWorld * Get()
Definition: G4QCHIPSWorld.cc:79
G4QCHIPSWorld::GetQPEntries
G4int GetQPEntries() const
Definition: G4QCHIPSWorld.hh:104
G4QHadron::Get4Momentum
G4LorentzVector Get4Momentum() const
Definition: G4QHadron.hh:79
G4QHadron::GetMass
G4double GetMass() const
Definition: G4QHadron.hh:176
G4QHadron::GetBaryonNumber
G4int GetBaryonNumber() const
Definition: G4QHadron.hh:181
G4QHadron::GetCharge
G4int GetCharge() const
Definition: G4QHadron.hh:179
G4QHadron::GetPDGCode
G4int GetPDGCode() const
Definition: G4QHadron.hh:170
G4QHadron::GetQCode
G4int GetQCode() const
Definition: G4QHadron.hh:171
G4QHadron::SetQPDG
void SetQPDG(const G4QPDGCode &QPDG)
Definition: G4QHadron.cc:275
G4QHadron::GetNFragments
G4int GetNFragments() const
Definition: G4QHadron.hh:174
G4QHadron::GetQC
G4QContent GetQC() const
Definition: G4QHadron.hh:173
G4QHadron::Set4Momentum
void Set4Momentum(const G4LorentzVector &aMom)
Definition: G4QHadron.hh:187
G4QNucleus::InitByPDG
void InitByPDG(G4int newPDG)
Definition: G4QNucleus.cc:371
G4QNucleus::GetA
G4int GetA() const
Definition: G4QNucleus.hh:73
G4QPDGCode::GetPDGCode
G4int GetPDGCode() const
Definition: G4QPDGCode.hh:326
G4QPDGCode::GetMass
G4double GetMass()
Definition: G4QPDGCode.cc:693
G4Quasmon::GetQC
G4QContent GetQC() const
Definition: G4Quasmon.hh:162
G4Quasmon::GetCharge
G4int GetCharge() const
Definition: G4Quasmon.hh:163
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
G4ExceptionDescription
std::ostringstream G4ExceptionDescription
Definition: globals.hh:76
sqr
T sqr(const T &x)
Definition: templates.hh:145

◆ G4QEnvironment() [3/4]

G4QEnvironment::G4QEnvironment ( const G4QEnvironment &  right)

Definition at line 575 of file G4QEnvironment.cc.

576{
577 // theQHadrons (Vector)
578 theQFScat = G4QFreeScattering::GetPointer();
579 G4int nQH = right.theQHadrons.size();
580 if(nQH) for(G4int ih=0; ih<nQH; ih++)
581 {
582 G4QHadron* curQH = new G4QHadron(right.theQHadrons[ih]);
583#ifdef debug
584 G4cout<<"G4QE::CopyByVal:cH#"<<ih<<","<<curQH->GetQC()<<curQH->Get4Momentum()<<G4endl;
585#endif
586 theQHadrons.push_back(curQH); // (delete equivalent)
587 }
588 // theProjectiles (Vector)
589 G4int nP = right.theProjectiles.size();
590 if(nP) for(G4int ip=0; ip<nP; ip++)
591 {
592 G4QHadron* curP = new G4QHadron(right.theProjectiles[ip]);
593 theProjectiles.push_back(curP); // (delete equivalent)
594 }
595 theTargetPDG = right.theTargetPDG;
596 theWorld = right.theWorld;
597 nBarClust = right.nBarClust;
598 f2all = right.f2all;
599 tot4Mom = right.tot4Mom;
600 totCharge = right.totCharge;
601 totBaryoN = right.totBaryoN;
602
603 // theQuasmons (Vector)
604 G4int nQ = right.theQuasmons.size();
605 if(nQ) for(G4int iq=0; iq<nQ; iq++)
606 {
607 G4Quasmon* curQ = new G4Quasmon(right.theQuasmons[iq]);
608 theQuasmons.push_back(curQ); // (delete equivalent)
609 }
610
611 // theQCandidates (Vector)
612 G4int nQC = right.theQCandidates.size();
613 if(nQC) for(G4int ic=0; ic<nQC; ic++)
614 {
615 G4QCandidate* curQC = new G4QCandidate(right.theQCandidates[ic]);
616 theQCandidates.push_back(curQC); // (delete equivalent)
617 }
618
619 theEnvironment = right.theEnvironment;
620}

◆ G4QEnvironment() [4/4]

G4QEnvironment::G4QEnvironment ( G4QEnvironment *  right)

Definition at line 622 of file G4QEnvironment.cc.

623{
624 // theQHadrons (Vector)
625 theQFScat = G4QFreeScattering::GetPointer();
626 G4int nQH = right->theQHadrons.size();
627 if(nQH) for(G4int ih=0; ih<nQH; ih++)
628 {
629 G4QHadron* curQH = new G4QHadron(right->theQHadrons[ih]);
630#ifdef debug
631 G4cout<<"G4QE::CopyByPtr:cH#"<<ih<<","<<curQH->GetQC()<<curQH->Get4Momentum()<<G4endl;
632#endif
633 theQHadrons.push_back(curQH); // (delete equivalent)
634 }
635
636 // theProjectiles (Vector)
637 G4int nP = right->theProjectiles.size();
638 if(nP) for(G4int ip=0; ip<nP; ip++)
639 {
640 G4QHadron* curP = new G4QHadron(right->theProjectiles[ip]);
641 theProjectiles.push_back(curP); // (delete equivalent)
642 }
643 theTargetPDG = right->theTargetPDG;
644 theWorld = right->theWorld;
645 nBarClust = right->nBarClust;
646 f2all = right->f2all;
647 tot4Mom = right->tot4Mom;
648 totCharge = right->totCharge;
649 totBaryoN = right->totBaryoN;
650
651 // theQuasmons (Vector)
652 G4int nQ = right->theQuasmons.size();
653 if(nQ) for(G4int iq=0; iq<nQ; iq++)
654 {
655 G4Quasmon* curQ = new G4Quasmon(right->theQuasmons[iq]);
656 theQuasmons.push_back(curQ); // (delete equivalent)
657 }
658
659 // theQCandidates (Vector)
660 G4int nQC = right->theQCandidates.size();
661 if(nQC) for(G4int ic=0; ic<nQC; ic++)
662 {
663 G4QCandidate* curQC = new G4QCandidate(right->theQCandidates[ic]);
664 theQCandidates.push_back(curQC); // (delete equivalent)
665 }
666
667 theEnvironment = right->theEnvironment;
668}

◆ ~G4QEnvironment()

G4QEnvironment::~G4QEnvironment ( )

Definition at line 670 of file G4QEnvironment.cc.

671{
672#ifdef debug
673 G4cout<<"~G4QEnvironment: before theQCandidates nC="<<theQCandidates.size()<<G4endl;
674#endif
675 for_each(theQCandidates.begin(), theQCandidates.end(), DeleteQCandidate());
676#ifdef debug
677 G4cout<<"~G4QEnvironment: before theQuasmons nQ="<<theQuasmons.size()<<G4endl;
678#endif
679 for_each(theQuasmons.begin(), theQuasmons.end(), DeleteQuasmon());
680#ifdef debug
681 G4cout<<"~G4QEnvironment: before theQHadrons nH="<<theQHadrons.size()<<G4endl;
682#endif
683 for_each(theQHadrons.begin(), theQHadrons.end(), DeleteQHadron());
684#ifdef debug
685 G4cout<<"~G4QEnvironment: before theProjectiles nP="<<theProjectiles.size()<<G4endl;
686#endif
687 for_each(theProjectiles.begin(), theProjectiles.end(), DeleteQHadron());
688#ifdef debug
689 G4cout<<"~G4QEnvironment: === DONE ==="<<G4endl;
690#endif
691}

Member Function Documentation

◆ AddQuasmon()

void G4QEnvironment::AddQuasmon ( G4Quasmon *  Q)

Definition at line 10522 of file G4QEnvironment.cc.

10523{
10524 theQuasmons.push_back(Q);
10525 totCharge+=Q->GetCharge();
10526 totBaryoN+=Q->GetBaryonNumber();
10527 tot4Mom +=Q->Get4Momentum();
10528#ifdef debug
10529 G4cout<<"G4QEnv::AddQuasmon:t4M="<<tot4Mom<<",tC="<<totCharge<<",tB="<<totBaryoN<<G4endl;
10530#endif
10531}
G4Quasmon::Get4Momentum
G4LorentzVector Get4Momentum() const
Definition: G4Quasmon.hh:161
G4Quasmon::GetBaryonNumber
G4int GetBaryonNumber() const
Definition: G4Quasmon.hh:164

Referenced by G4QFragmentation::Fragment(), G4QIonIonCollision::Fragment(), and G4QDiffractionRatio::TargFragment().

◆ CheckMassShell()

void G4QEnvironment::CheckMassShell ( G4QHadronVector *  HV)

Definition at line 10534 of file G4QEnvironment.cc.

10535{
10536 static const G4double eps=.003;
10537 G4int nHadrons = HV->size();
10538 if(nHadrons)
10539 {
10540 for(G4int ih=0; ih<nHadrons; ++ih) // LOOP over output QHadrons
10541 {
10542 G4QHadron* inH = (*HV)[ih]; // Pointer to the i-th QHadron
10543 G4int hNF = inH->GetNFragments(); // A#of secondary fragments
10544 if(!hNF) // Fill only final hadrons
10545 {
10546 G4LorentzVector q4M = inH->Get4Momentum(); // Get 4-momentum of the Hadron
10547 G4double qM2 = q4M.m2(); // Squared Mass of the Hadron
10548 G4double qGM = inH->GetQPDG().GetMass(); // Get Ground State Mass
10549 G4double qGM2= qGM*qGM; // Squared Ground State Mass
10550#ifdef debug
10551 G4cout << "G4QEnv::ChkMassShell:#" << ih <<", hPDG="<< inH->GetPDGCode() <<", dM2="
10552 << qM2 - qGM*qGM << G4endl;
10553#endif
10554 if( fabs(qM2 - qGM*qGM) > eps) // Correct the mass shell
10555 {
10556 G4double mins= 10000000000.; // Minimum excitation found
10557 G4int nj = -1; // Minimum j-index
10558 for(G4int jh=0; jh<nHadrons; ++jh) // LOOP over output QHadrons
10559 {
10560 if(jh != ih)
10561 {
10562 G4QHadron* jnH = (*HV)[jh]; // Pointer to the j-th QHadron
10563 hNF = inH->GetNFragments(); // A#of secondary fragments
10564 if(!hNF) // Fill only final hadrons
10565 {
10566 G4LorentzVector j4M = jnH->Get4Momentum(); // Get 4-mom of the Hadron
10567 G4double jGM = jnH->GetQPDG().GetMass(); // Get Ground State Mass
10568 G4double jGM2= jGM*jGM; // Doubled GS Mass
10569 G4LorentzVector s4M = j4M+q4M; // Compound 4-mom
10570 G4double jqM = qGM * jGM; // Worling var.
10571 G4double s2M = s4M.m2()-qGM2-jGM2-jqM-jqM;// Closeness parameter
10572 if(s2M > eps && s2M < mins)
10573 {
10574 mins = s2M;
10575 nj = jh;
10576 }
10577 }
10578 }
10579 } // End of the searching LOOP for the rest of hadrons
10580 //if(nj<0) G4cout<<"-W-G4QE::ChkMShell:NotCorr,M2="<<qM2<<",GSM2="<<qGM2<<G4endl;
10581 //else // It's possible to correct
10582 if(nj >= 0) // It's possible to correct
10583 {
10584 G4QHadron* jnH = (*HV)[nj]; // Pointer to j-th QHadron
10585 G4LorentzVector j4M = jnH->Get4Momentum(); // Get 4-mom of the Hadron
10586 G4double jGM = jnH->GetQPDG().GetMass(); // Get Ground State Mass
10587 G4LorentzVector c4M = q4M + j4M; // Get 4-mom of Compound
10588 G4LorentzVector i4Mom(0.,0.,0.,qGM);
10589 G4LorentzVector j4Mom(0.,0.,0.,jGM);
10590 /*
10591 // DHW 16 June 2011: variable set but not used. Comment out to fix compiler
10592 // warning.
10593 G4bool done = true;
10594 */
10595 if(!G4QHadron(c4M).DecayIn2(i4Mom, j4Mom))
10596 {
10597 G4cout<<"-Warning-G4QEnv::ChkMShell: tM="<< c4M.m() <<", iM="<< qGM <<", jM="
10598 << jGM <<", d="<< c4M.m()-qGM-jGM << G4endl;
10599 /*
10600 // DHW 16 June 2011: set but not used.
10601 done = false;
10602 */
10603 }
10604 else
10605 {
10606 inH->Set4Momentum(i4Mom);
10607 jnH->Set4Momentum(j4Mom);
10608 }
10609 }
10610 }
10611 }
10612 }
10613 }
10614}
G4QHadron::GetQPDG
G4QPDGCode GetQPDG() const
Definition: G4QHadron.hh:172

Referenced by Fragment().

◆ CleanUpQHadrons()

void G4QEnvironment::CleanUpQHadrons ( )
protected

Definition at line 8290 of file G4QEnvironment.cc.

8291{
8292 for_each(theQHadrons.begin(), theQHadrons.end(), DeleteQHadron());
8293 theQHadrons.clear();
8294} // End of CleanUpQHadrons

◆ CloseElectromagneticDecays()

void G4QEnvironment::CloseElectromagneticDecays ( )
static

Definition at line 705 of file G4QEnvironment.cc.

705{ElMaDecays=false;}

◆ DecayAntistrange()

void G4QEnvironment::DecayAntistrange ( G4QHadron *  aS,
G4QHadronVector *  HV 
)

Definition at line 9534 of file G4QEnvironment.cc.

9535{
9536 static const G4QPDGCode kpQPDG(321); // QPDG for Antistrange positive kaon
9537 static const G4QPDGCode kzQPDG(311); // QPDG for Antistrange neutral anti-kaon
9538 static const G4double mK =G4QPDGCode(321).GetMass(); // Mass of antistrange positive Kaon
9539 static const G4double mK0=G4QPDGCode(311).GetMass(); // Mass of antistrange neutral aK0
9540 static const G4double eps=0.003;
9541 //static const G4QNucleus vacuum(90000000);
9542 G4int theLS= qH->GetStrangeness(); // Strangness of the Nucleus
9543 if(theLS>=0)
9544 {
9545 G4cerr<<"***G4QEnvironment::DecayAntistrange: S="<<theLS<<", but must be <0"<<G4endl;
9546 //#ifdef ppdebug
9547 // throw G4QException("G4QEnv::DecayAntistrange: Not Antistrange nucleus");
9548 G4Exception("G4QEnvironment::DecayAntistrange()", "HAD_CHPS_0000",
9549 FatalException, "Not Antistrange nucleus");
9550 //#endif
9551 //HV->push_back(qH); // Fill AsIs (delete equivalent)
9552 return;
9553 }
9554 //else if(theLS<-1)
9555 //{
9556 // G4cout<<"*Warning*G4QEnviron::DecayAntistrange: S="<<theLS<<",AsIs->Improve"<<G4endl;
9557 // HV->push_back(qH); // Fill AsIs (delete equivalent)
9558 // return;
9559 //}
9560 G4int astr=-theLS; // Number of K+ (or anti-K0)
9561 G4int theLB= qH->GetBaryonNumber(); // Baryon number of the Nucleus
9562 G4int theLC= qH->GetCharge(); // Chsrge of the Nucleus
9563 G4int qPDG = qH->GetPDGCode(); // PDG Code of the decaying Nucleus
9564 G4int K0PDG= qPDG+astr*999999; // Residual nonStrange nucleus for S*antiK0
9565 G4QPDGCode K0QPDG(K0PDG); // QPDG of the nuclear residual for S*antiK0
9566 G4double rK0M=K0QPDG.GetMass(); // Mass of the nuclear residual for S*antiK0
9567 G4int KpPDG= qPDG+astr*999000; // Residual nonStrange nucleus for S*K+
9568 G4QPDGCode KpQPDG(KpPDG); // QPDG of the nuclear residual for S*K+
9569 G4double rKpM=KpQPDG.GetMass(); // Mass of the nuclear residual for S*K+
9570 G4LorentzVector q4M = qH->Get4Momentum(); // Get 4-momentum of the Nucleus
9571 G4double qM = q4M.m(); // Mass of the Nucleus
9572#ifdef debug
9573 G4cout<<"G4QE::DecayAntistrang:S="<<theLS<<",C="<<theLC<<",B="<<theLB<<",M="<<qM<<G4endl;
9574#endif
9575 // Select a chanel of the decay: @@ The Kaon binding energy is not taken into account !!
9576 G4QPDGCode fQPDG = kzQPDG; // Prototype for Kaon (anti-K0)
9577 G4double fMass= mK0;
9578 G4QPDGCode sQPDG = K0QPDG; // Prototype for residual nucleus to Kaon
9579 G4double sMass= rK0M;
9580 if(astr*mK0+rK0M>qM) // Can not be K0
9581 {
9582 if(astr*mK+rKpM>qM) // Can not be K+ too
9583 {
9584#ifdef debug
9585 // @@ Survices, but...
9586 G4cout<<"*Warning*G4QEnvironment::DecayAntistrange: Too low mass, keep AsIs"<<G4endl;
9587#endif
9588 HV->push_back(qH); // Fill AsIs (delete equivalent)
9589 return;
9590 }
9591 else // Switch to K+
9592 {
9593 fQPDG = kpQPDG; // Positive Kaon
9594 fMass= mK;
9595 sQPDG = KpQPDG; // Residual nucleus to K+
9596 sMass= rKpM;
9597 }
9598 }
9599 else if(astr*mK+rKpM<qM && theLC>theLB-theLC) // Switch to K+ if Z>N
9600 {
9601 fQPDG = kpQPDG; // Positive Kaon
9602 fMass= mK;
9603 sQPDG = KpQPDG; // Residual nucleus to K+
9604 sMass= rKpM;
9605 }
9606 G4double afMass=fMass;
9607 if(astr>1) afMass*=astr;
9608 G4LorentzVector f4Mom(0.,0.,0.,afMass);
9609 G4LorentzVector s4Mom(0.,0.,0.,sMass);
9610 G4double sum=afMass+sMass;
9611 if(fabs(qM-sum)<eps)
9612 {
9613 f4Mom=q4M*(afMass/sum);
9614 s4Mom=q4M*(sMass/sum);
9615 }
9616 else if(qM<sum || !G4QHadron(q4M).DecayIn2(f4Mom, s4Mom))
9617 {
9618#ifdef debug
9619 G4cout<<"--Warning--G4QE::DecAntistrange: fPDG="<<fQPDG<<"(M="<<fMass<<")+sPDG="<<sQPDG
9620 <<"(M="<<sMass<<") > TotM="<<q4M.m()<<G4endl;
9621#endif
9622 // G4cerr<<"***G4QEnv::DecayAntistrange: M="<<qM<<", sum="<<sum<<G4endl;
9623 // throw G4QException("G4QEnv::DecayAntistrange: Nucleus DecayIn2 error");
9624 G4ExceptionDescription ed;
9625 ed << "Nucleus DecayIn2 error: DecayAntistrange: M=" << qM << ", sum="
9626 << sum << G4endl;
9627 G4Exception("G4QEnvironment::DecayAntistrange()", "HAD_CHPS_0001",
9628 FatalException, ed);
9629 }
9630#ifdef debug
9631 G4cout<<"G4QEnv::DecayAntistrange: *Done* f4M="<<f4Mom<<",fPDG="<<fQPDG<<", s4M="<<s4Mom
9632 <<",sPDG="<<sQPDG<<G4endl;
9633#endif
9634 delete qH;
9635 //
9636 if(astr>1) f4Mom/=astr;
9637 G4QHadron* H1 = new G4QHadron(fQPDG,f4Mom); // Create a Hadron for the 1-st kaon
9638 HV->push_back(H1); // Fill "H1" (delete equivalent)
9639 for(G4int ia=1; ia < astr; ++ia)
9640 {
9641 H1 = new G4QHadron(fQPDG,f4Mom); // Create a Hadron for other kaons
9642 HV->push_back(H1); // Fill "H1" (delete equivalent)
9643 }
9644 G4QHadron* H2 = new G4QHadron(sQPDG,s4Mom); // Create a Hadron for the Residual Nucleus
9645 HV->push_back(H2); // Fill "H2" (delete equivalent)
9646} // End of DecayAntistrange
G4cerr
G4DLLIMPORT std::ostream G4cerr
G4QHadron::DecayIn2
G4bool DecayIn2(G4LorentzVector &f4Mom, G4LorentzVector &s4Mom)
Definition: G4QHadron.cc:544

Referenced by G4QFragmentation::EvaporateResidual().

◆ DecayBaryon()

void G4QEnvironment::DecayBaryon ( G4QHadron *  dB,
G4QHadronVector *  HV 
)

Definition at line 8318 of file G4QEnvironment.cc.

8319{
8320 static const G4QPDGCode gQPDG(22);
8321 static const G4QPDGCode pizQPDG(111);
8322 static const G4QPDGCode pipQPDG(211);
8323 static const G4QPDGCode pimQPDG(-211);
8324 static const G4QPDGCode kmQPDG(-321);
8325 static const G4QPDGCode kzQPDG(-311);
8326 static const G4QPDGCode nQPDG(2112);
8327 static const G4QPDGCode pQPDG(2212);
8328 static const G4QPDGCode lQPDG(3122);
8329 static const G4QPDGCode laQPDG(3122);
8330 static const G4QPDGCode smQPDG(3112);
8331 static const G4QPDGCode szQPDG(3212);
8332 static const G4QPDGCode spQPDG(3222);
8333 static const G4QPDGCode kszQPDG(3322);
8334 static const G4QPDGCode ksmQPDG(3312);
8335 static const G4double mPi = G4QPDGCode(211).GetMass();
8336 static const G4double mPi0 = G4QPDGCode(111).GetMass();
8337 static const G4double mK = G4QPDGCode(321).GetMass();
8338 static const G4double mK0 = G4QPDGCode(311).GetMass();
8339 static const G4double mNeut= G4QPDGCode(2112).GetMass();
8340 static const G4double mProt= G4QPDGCode(2212).GetMass();
8341 static const G4double mSigM= G4QPDGCode(3112).GetMass();
8342 static const G4double mLamb= G4QPDGCode(3122).GetMass();
8343 static const G4double mSigZ= G4QPDGCode(3212).GetMass();
8344 static const G4double mSigP= G4QPDGCode(3222).GetMass();
8345 //static const G4double mKsiM= G4QPDGCode(3312).GetMass();
8346 //static const G4double mKsi0= G4QPDGCode(3322).GetMass();
8347 //static const G4double mOmeg= G4QPDGCode(3334).GetMass();
8348 static const G4double mNPi0 = mPi0+ mNeut;
8349 static const G4double mNPi = mPi + mNeut;
8350 static const G4double mPPi0 = mPi0+ mProt;
8351 static const G4double mPPi = mPi + mProt;
8352 static const G4double mLPi0 = mPi0+ mLamb;
8353 static const G4double mLPi = mPi + mLamb;
8354 static const G4double mSpPi = mPi + mSigP;
8355 static const G4double mSmPi = mPi + mSigM;
8356 static const G4double mPK = mK + mProt;
8357 static const G4double mPKZ = mK0 + mProt;
8358 static const G4double mNKZ = mK0 + mNeut;
8359 static const G4double mSpPi0= mPi0+ mSigP;
8360 static const G4double mSzPi0= mPi0+ mSigZ;
8361 static const G4double mSzPi = mPi + mSigZ;
8362 static const G4double eps = 0.003;
8363 //static const G4QNucleus vacuum(90000000);
8364 G4int theLB= qH->GetBaryonNumber(); // Baryon number of the Baryon
8365 if(theLB!=1)
8366 {
8367 G4cerr<<"***G4QEnvironment::DecayBaryon: A!=1 -> fill as it is"<<G4endl;
8368#ifdef ppdebug
8369 // throw G4QException("G4QEnv::DecayBaryon: Unknown Baryon with A!=1");
8370 G4Exception("G4QEnvironment::DecayBaryon()", "HAD_CHPS_0000",
8371 FatalException, "Unknown Baryon with A!=1");
8372#endif
8373 HV->push_back(qH); // Fill AsIs (delete equivalent)
8374 return;
8375 }
8376 G4int theLC= qH->GetCharge(); // Chsrge of the Baryon
8377 G4int theLS= qH->GetStrangeness(); // Strangness of the Baryon
8378 //G4int qPDG = qH->GetPDGCode(); // PDG Code of the decaying baryon
8379 G4LorentzVector q4M = qH->Get4Momentum(); // Get 4-momentum of the Baryon
8380 G4double qM = q4M.m(); // Mass of the Baryon
8381#ifdef debug
8382 G4cout<<"G4QEnv::DecayBaryon: *Called* S="<<theLS<<",C="<<theLC<<",4M="<<q4M<<qM<<G4endl;
8383#endif
8384 // Select a chanel of the baryon decay
8385 G4QPDGCode fQPDG = pQPDG; // Prototype for Proton
8386 G4double fMass= mProt;
8387 G4QPDGCode sQPDG = pizQPDG; // Prototype for Pi0
8388 G4double sMass= mPi0;
8389 if(!theLS) // This is only for not strange baryons
8390 {
8391 if(!theLC) // Neutron like: n+gam, n+Pi0, p+Pi- are possible
8392 {
8393 if(qM<mNPi0) // Only n+gamma decay is possible
8394 {
8395 if(qM < mNeut+eps)
8396 {
8397#ifdef debug
8398 G4cout<<"G4QEnv::DecayBaryon: Fill Neutron AsIs"<<G4endl;
8399#endif
8400 qH->SetQPDG(nQPDG);
8401 HV->push_back(qH); // Fill AsIs (delete equivalent)
8402 if(qM+eps<mNeut) G4cout<<"-Warning-G4QEnv::DecayBaryon: N0 AsIs, M="<<qM<<G4endl;
8403 return;
8404 }
8405 fQPDG=nQPDG; // Baryon is neutron
8406 fMass=mNeut;
8407 sQPDG=gQPDG; // Meson is gamma
8408 sMass=0.;
8409#ifdef debug
8410 G4cout<<"-Warning-G4QEnv::DecayBaryon: Gamma+n, M="<<qM<<",d="<<qM-mNeut<<G4endl;
8411#endif
8412 }
8413 else if(qM>mPPi) // Both n+pi0 (p=2/3) & p+Pi- (p=1/3) are possible
8414 {
8415 if(G4UniformRand()>.333333333) // Clebsh value for the Isobar decay
8416 {
8417 fQPDG=nQPDG; // Baryon is neutron (meson is Pi0)
8418 fMass=mNeut;
8419 }
8420 else
8421 {
8422 sQPDG=pimQPDG; // Meson is Pi- (baryon is proton)
8423 sMass=mPi;
8424 }
8425 }
8426 else // Only n+Pi0 decay is possible
8427 {
8428 fQPDG=nQPDG; // Baryon is neutron
8429 fMass=mNeut;
8430 }
8431 }
8432 else if(theLC==1) // Proton like: p+gam, p+Pi0, n+Pi+ are possible
8433 {
8434 if(qM<mPPi0) // Only p+gamma decay is possible
8435 {
8436 if(qM < mProt+eps)
8437 {
8438#ifdef debug
8439 G4cout<<"G4QEnv::DecayBaryon: Fill Proton AsIs"<<G4endl;
8440#endif
8441 qH->SetQPDG(pQPDG);
8442 HV->push_back(qH); // Fill AsIs (delete equivalent)
8443#ifdef debug
8444 if(qM+eps<mProt)G4cout<<"-Warning-G4QEnv::DecayBaryon: Pr+ AsIs, M="<<qM<<G4endl;
8445#endif
8446 return;
8447 }
8448 sQPDG=gQPDG; // Meson is gamma (baryon is proton)
8449 sMass=0.;
8450 }
8451 else if(qM>mNPi) // Both p+pi0 (p=2/3) & n+Pi+ (p=1/3) are possible
8452 {
8453 if(G4UniformRand()<.333333333) // Clebsh value for the Isobar decay
8454 {
8455 fQPDG=nQPDG; // Baryon is neutron
8456 fMass=mNeut;
8457 sQPDG=pipQPDG; // Meson is Pi+
8458 sMass=mPi;
8459 }
8460 // p+Pi0 is a default case
8461 }
8462 // p+Pi0 is a default case
8463 }
8464 else if(theLC==2) // Delta++ like: only p+PiP is possible
8465 {
8466 if(qM>mPPi) // Only p+gamma decay is possible
8467 {
8468 sQPDG=pipQPDG; // Meson is Pi+ (baryon is proton)
8469 sMass=mPi;
8470 }
8471 else // @@ Can be aReason to search for anError in Fragmentation
8472 {
8473#ifdef debug
8474 G4cout<<"-Warning-G4QE::DecBary:*AsIs* DEL++ M="<<qM<<"<"<<mPPi<<G4endl;
8475#endif
8476 HV->push_back(qH); // Fill AsIs (delete equivalent)
8477 return;
8478 }
8479 }
8480 else if(theLC==-1) // Delta- like: only n+PiM is possible
8481 {
8482 if(qM+eps>mNPi) // Only p+gamma decay is possible
8483 {
8484 fQPDG=nQPDG; // Baryon is neutron
8485 fMass=mNeut;
8486 sQPDG=pimQPDG; // Meson is Pi-
8487 sMass=mPi;
8488 }
8489 else // @@ Can be aReason to search for anError in Fragmentation
8490 {
8491#ifdef debug
8492 G4cout<<"-Warning-G4QE::DecBary:*AsIs* DEL++ M="<<qM<<"<"<<mNPi<<G4endl;
8493#endif
8494 HV->push_back(qH); // Fill AsIs (delete equivalent)
8495 return;
8496 }
8497 }
8498 else
8499 {
8500#ifdef debug
8501 G4cout<<"-Warning-G4QE::DecBary:*AsIs* UnknBaryon (S=0) QC="<<qH->GetQC()<<G4endl;
8502#endif
8503 HV->push_back(qH); // Fill AsIs (delete equivalent)
8504 return;
8505 }
8506 }
8507 else if(theLS==1) // ==>->->-> S=1 <-<-<-<==
8508 {
8509 if(!theLC) // -->> Lambda/Sz: L+g,L+Pi0,Sz+Pi0,Sm+Pip,Sp+Pim,p+Km,n+Kz
8510 {
8511 if(qM<mLPi0) // Only Lambda+gamma decay is possible
8512 {
8513 if(qM < mLamb+eps)
8514 {
8515#ifdef debug
8516 G4cout<<"G4QEnv::DecayBaryon: Fill Lambda AsIs"<<G4endl;
8517#endif
8518 qH->SetQPDG(lQPDG);
8519 HV->push_back(qH); // Fill AsIs (delete equivalent)
8520 if(qM+eps<mLamb)G4cout<<"-Warning-G4QEnv::DecayBaryon: La0 AsIs, M="<<qM<<G4endl;
8521 return;
8522 }
8523 fQPDG=lQPDG; // Baryon is Lambda
8524 fMass=mLamb;
8525 sQPDG=gQPDG; // Meson is gamma
8526 sMass=0.;
8527 }
8528 else if(qM<mSzPi0) // Only Lambda+Pi0 is possible
8529 {
8530 fQPDG=lQPDG; // Baryon is Lambda
8531 fMass=mLamb;
8532 }
8533 else if(qM<mSpPi) // Both Lambda+Pi0 & Sigma0+Pi0 are possible
8534 {
8535 if(G4UniformRand()>.6) // @@ Relative probability (take into account Phase Space)
8536 {
8537 fQPDG=szQPDG; // Baryon is Sigma0
8538 fMass=mSigZ;
8539 }
8540 else
8541 {
8542 fQPDG=lQPDG; // Baryon is Lambda
8543 fMass=mLamb;
8544 }
8545 }
8546 else if(qM<mSmPi) // Lambda+Pi0, Sigma0+Pi0, & SigmaP+PiM are possible
8547 {
8548 G4double ra=G4UniformRand();
8549 if(ra<.4) // @@ Rel. probab. (take into account Phase Space)
8550 {
8551 fQPDG=lQPDG; // Baryon is Lambda
8552 fMass=mLamb;
8553 }
8554 else if(ra<.7) // @@ Rel. probab. (take into account Phase Space)
8555 {
8556 fQPDG=szQPDG; // Baryon is Sigma0
8557 fMass=mSigZ;
8558 }
8559 else
8560 {
8561 fQPDG=spQPDG; // Baryon is SigmaP
8562 fMass=mSigP;
8563 sQPDG=pimQPDG; // Meson is Pi-
8564 sMass=mPi;
8565 }
8566 }
8567 else if(qM<mPK) // Lambda+Pi0, Sig0+Pi0, SigP+PiM, SigM+PiP are possible
8568 {
8569 G4double ra=G4UniformRand();
8570 if(ra<.35) // @@ Rel. probab. (take into account Phase Space)
8571 {
8572 fQPDG=lQPDG; // Baryon is Lambda
8573 fMass=mLamb;
8574 }
8575 else if(ra<.6) // @@ Rel. probab. (take into account Phase Space)
8576 {
8577 fQPDG=szQPDG; // Baryon is Sigma0
8578 fMass=mSigZ;
8579 }
8580 else if(ra<.8) // @@ Rel. probab. (take into account Phase Space)
8581 {
8582 fQPDG=smQPDG; // Baryon is SigmaM
8583 fMass=mSigM;
8584 sQPDG=pipQPDG; // Meson is Pi+
8585 sMass=mPi;
8586 }
8587 else
8588 {
8589 fQPDG=spQPDG; // Baryon is SigmaP
8590 fMass=mSigP;
8591 sQPDG=pimQPDG; // Meson is Pi-
8592 sMass=mPi;
8593 }
8594 }
8595 else if(qM<mNKZ) // Lambda+Pi0, Sig0+Pi0, SigP+PiM, SigM+PiP are possible
8596 {
8597 G4double ra=G4UniformRand();
8598 if(ra<.3) // @@ Rel. probab. (take into account Phase Space)
8599 {
8600 fQPDG=lQPDG; // Baryon is Lambda
8601 fMass=mLamb;
8602 }
8603 else if(ra<.5) // @@ Rel. probab. (take into account Phase Space)
8604 {
8605 fQPDG=szQPDG; // Baryon is Sigma0
8606 fMass=mSigZ;
8607 }
8608 else if(ra<.7) // @@ Rel. probab. (take into account Phase Space)
8609 {
8610 fQPDG=smQPDG; // Baryon is SigmaM
8611 fMass=mSigM;
8612 sQPDG=pipQPDG; // Meson is Pi+
8613 sMass=mPi;
8614 }
8615 else if(ra<.9) // @@ Rel. probab. (take into account Phase Space)
8616 {
8617 fQPDG=spQPDG; // Baryon is SigmaP
8618 fMass=mSigP;
8619 sQPDG=pimQPDG; // Meson is Pi-
8620 sMass=mPi;
8621 }
8622 else
8623 {
8624 fQPDG=pQPDG; // Baryon is Proton
8625 fMass=mProt;
8626 sQPDG=kmQPDG; // Meson is K-
8627 sMass=mK;
8628 }
8629 }
8630 else // Only n+Pi0 decay is possible
8631 {
8632 G4double ra=G4UniformRand();
8633 if(ra<.3) // @@ Rel. probab. (take into account Phase Space)
8634 {
8635 fQPDG=lQPDG; // Baryon is Lambda
8636 fMass=mLamb;
8637 }
8638 else if(ra<.5) // @@ Rel. probab. (take into account Phase Space)
8639 {
8640 fQPDG=szQPDG; // Baryon is Sigma0
8641 fMass=mSigZ;
8642 }
8643 else if(ra<.65) // @@ Rel. probab. (take into account Phase Space)
8644 {
8645 fQPDG=smQPDG; // Baryon is SigmaM
8646 fMass=mSigM;
8647 sQPDG=pipQPDG; // Meson is Pi+
8648 sMass=mPi;
8649 }
8650 else if(ra<.8) // @@ Rel. probab. (take into account Phase Space)
8651 {
8652 fQPDG=spQPDG; // Baryon is SigmaP
8653 fMass=mSigP;
8654 sQPDG=pimQPDG; // Meson is Pi-
8655 sMass=mPi;
8656 }
8657 else if(ra<.9) // @@ Rel. probab. (take into account Phase Space)
8658 {
8659 fQPDG=pQPDG; // Baryon is Proton
8660 fMass=mProt;
8661 sQPDG=kmQPDG; // Meson is K-
8662 sMass=mK;
8663 }
8664 else
8665 {
8666 fQPDG=nQPDG; // Baryon is Neutron
8667 fMass=mNeut;
8668 sQPDG=kzQPDG; // Meson is K0
8669 sMass=mK0;
8670 }
8671 }
8672 }
8673 else if(theLC==1) // SigmaP: SigP+gam,SigP+Pi0,Sp+PiP,L+Pi0,p+K0 are possible
8674 {
8675 if(qM<mLPi) // Only SigmaPlus+gamma decay is possible
8676 {
8677 if(qM < mSigP+eps)
8678 {
8679#ifdef debug
8680 G4cout<<"G4QEnv::DecayBaryon: Fill SigmaPlus AsIs"<<G4endl;
8681#endif
8682 qH->SetQPDG(spQPDG);
8683 HV->push_back(qH); // Fill AsIs (delete equivalent)
8684 if(qM+eps<mSigP)G4cout<<"-Warning-G4QEnv::DecayBaryon: Si+ AsIs, M="<<qM<<G4endl;
8685 return;
8686 }
8687 fQPDG=spQPDG; // Baryon is SigmaP
8688 fMass=mSigP;
8689 sQPDG=gQPDG; // Meson is gamma
8690 sMass=0.;
8691 }
8692 else if(qM<mSpPi0) // Only Lambda+PiP is possible
8693 {
8694 fQPDG=lQPDG; // Baryon is Lambda
8695 fMass=mLamb;
8696 sQPDG=pipQPDG; // Meson is Pi+
8697 sMass=mPi;
8698 }
8699 else if(qM<mSzPi) // Both Lambda+PiP & Sigma0+Pi0 are possible
8700 {
8701 if(G4UniformRand()<.6) // @@ Relative probability (take into account Phase Space)
8702 {
8703 fQPDG=lQPDG; // Baryon is Lambda
8704 fMass=mLamb;
8705 sQPDG=pipQPDG; // Meson is Pi+
8706 sMass=mPi;
8707 }
8708 else
8709 {
8710 fQPDG=spQPDG; // Baryon is SigmaP
8711 fMass=mSigP;
8712 }
8713 }
8714 else if(qM<mPKZ) // Lambda+PiP, SigmaP+Pi0, & Sigma0+PiP are possible
8715 {
8716 G4double ra=G4UniformRand();
8717 if(ra<.4) // @@ Rel. probab. (take into account Phase Space)
8718 {
8719 fQPDG=lQPDG; // Baryon is Lambda
8720 fMass=mLamb;
8721 sQPDG=pipQPDG; // Meson is Pi+
8722 sMass=mPi;
8723 }
8724 else if(ra<.7) // @@ Rel. probab. (take into account Phase Space)
8725 {
8726 fQPDG=spQPDG; // Baryon is SigmaP
8727 fMass=mSigP;
8728 }
8729 else
8730 {
8731 fQPDG=szQPDG; // Baryon is SigmaZ
8732 fMass=mSigZ;
8733 sQPDG=pipQPDG; // Meson is Pi+
8734 sMass=mPi;
8735 }
8736 }
8737 else // Lambda+PiP, SigmaP+Pi0, Sigma0+PiP, p+K0 are possible
8738 {
8739 G4double ra=G4UniformRand();
8740 if(ra<.35) // @@ Rel. probab. (take into account Phase Space)
8741 {
8742 fQPDG=lQPDG; // Baryon is Lambda
8743 fMass=mLamb;
8744 sQPDG=pipQPDG; // Meson is Pi+
8745 sMass=mPi;
8746 }
8747 else if(ra<.6) // @@ Rel. probab. (take into account Phase Space)
8748 {
8749 fQPDG=spQPDG; // Baryon is SigmaP
8750 fMass=mSigP;
8751 }
8752 else if(ra<.8) // @@ Rel. probab. (take into account Phase Space)
8753 {
8754 fQPDG=szQPDG; // Baryon is SigmaZ
8755 fMass=mSigZ;
8756 sQPDG=pipQPDG; // Meson is Pi+
8757 sMass=mPi;
8758 }
8759 else
8760 {
8761 fQPDG=pQPDG; // Baryon is Proton
8762 fMass=mProt;
8763 sQPDG=kzQPDG; // Meson is K0
8764 sMass=mK0;
8765 }
8766 }
8767 }
8768 else if(theLC==-1) // SigmaM: SigM+gam,SigM+Pi0,S0+PiM,L+Pi-,n+KM are possible
8769 {
8770 if(qM<mLPi) // Only SigmaMinus + gamma decay is possible
8771 {
8772 if(qM < mSigM+eps)
8773 {
8774#ifdef debug
8775 G4cout<<"G4QEnv::DecayBaryon: Fill SigmaMinus AsIs"<<G4endl;
8776#endif
8777 qH->SetQPDG(smQPDG);
8778 HV->push_back(qH); // Fill AsIs (delete equivalent)
8779 if(qM+eps<mSigM)G4cout<<"-Warning-G4QEnv::DecayBaryon: Si- AsIs, M="<<qM<<G4endl;
8780 return;
8781 }
8782 fQPDG=smQPDG; // Baryon is SigmaP
8783 fMass=mSigM;
8784 sQPDG=gQPDG; // Meson is gamma
8785 sMass=0.;
8786 }
8787 else if(qM<mSzPi) // Only Lambda+PiM is possible
8788 {
8789 fQPDG=lQPDG; // Baryon is Lambda
8790 fMass=mLamb;
8791 sQPDG=pimQPDG; // Meson is Pi-
8792 sMass=mPi;
8793 }
8794 else if(qM<mSzPi) // Both Lambda+PiM & Sigma0+PiM are possible
8795 {
8796 if(G4UniformRand()<.6) // @@ Relative probability (take into account Phase Space)
8797 {
8798 fQPDG=lQPDG; // Baryon is Lambda
8799 fMass=mLamb;
8800 sQPDG=pimQPDG; // Meson is Pi-
8801 sMass=mPi;
8802 }
8803 else
8804 {
8805 fQPDG=szQPDG; // Baryon is Sigma0
8806 fMass=mSigZ;
8807 sQPDG=pimQPDG; // Meson is Pi-
8808 sMass=mPi;
8809 }
8810 }
8811 else if(qM<mPKZ) // Lambda+PiM, Sigma0+PiM, & SigmaM+Pi0 are possible
8812 {
8813 G4double ra=G4UniformRand();
8814 if(ra<.4) // @@ Rel. probab. (take into account Phase Space)
8815 {
8816 fQPDG=lQPDG; // Baryon is Lambda
8817 fMass=mLamb;
8818 sQPDG=pimQPDG; // Meson is Pi-
8819 sMass=mPi;
8820 }
8821 else if(ra<.7) // @@ Rel. probab. (take into account Phase Space)
8822 {
8823 fQPDG=szQPDG; // Baryon is Sigma0
8824 fMass=mSigZ;
8825 sQPDG=pimQPDG; // Meson is Pi-
8826 sMass=mPi;
8827 }
8828 else
8829 {
8830 fQPDG=smQPDG; // Baryon is SigmaM
8831 fMass=mSigM;
8832 }
8833 }
8834 else // Lambda+PiM, Sig0+PiM, SigM+Pi0, n+KM are possible
8835 {
8836 G4double ra=G4UniformRand();
8837 if(ra<.35) // @@ Rel. probab. (take into account Phase Space)
8838 {
8839 fQPDG=lQPDG; // Baryon is Lambda
8840 fMass=mLamb;
8841 sQPDG=pimQPDG; // Meson is Pi-
8842 sMass=mPi;
8843 }
8844 else if(ra<.6) // @@ Rel. probab. (take into account Phase Space)
8845 {
8846 fQPDG=szQPDG; // Baryon is Sigma0
8847 fMass=mSigZ;
8848 sQPDG=pimQPDG; // Meson is Pi-
8849 sMass=mPi;
8850 }
8851 else if(ra<.8) // @@ Rel. probab. (take into account Phase Space)
8852 {
8853 fQPDG=smQPDG; // Baryon is SigmaM
8854 fMass=mSigM;
8855 }
8856 else
8857 {
8858 fQPDG=nQPDG; // Baryon is Proton
8859 fMass=mNeut;
8860 sQPDG=kmQPDG; // Meson is K-
8861 sMass=mK;
8862 }
8863 }
8864 }
8865 else if(theLC==2 || theLC==-2) // SigmaPlus+PiPlus or SigmaMinus+PiMinus
8866 {
8867 if(theLC==2 && qM>=mSpPi) // SigmaPlus+PiPlus decay is possible
8868 {
8869 fQPDG=spQPDG; // Baryon is SigmaP
8870 fMass=mSigP;
8871 sQPDG=pipQPDG; // Pi+ Meson
8872 sMass=mPi;
8873 }
8874 if(theLC==-2 && qM>=mSmPi)// SigmaPlus+PiPlus decay is possible
8875 {
8876 fQPDG=smQPDG; // Baryon is SigmaP
8877 fMass=mSigM;
8878 sQPDG=pimQPDG; // Pi- Meson
8879 sMass=mPi;
8880 }
8881 else
8882 {
8883#ifdef debug
8884 G4cout<<"-Warning-G4QE::DecBary:*AsIs* Baryon(S=1,|C|=2),QC="<<qH->GetQC()<<G4endl;
8885#endif
8886 HV->push_back(qH); // Fill AsIs (delete equivalent)
8887 return;
8888 }
8889 }
8890 else
8891 {
8892 //KsiM: KsiM+Pi0=1456.29, Ksi0+Pi=1454.4, L+K=1609.36, Sig0+K=1686.32, SigM+K0=1695.1
8893 //KsiZ: Ksi0+Pi0=1449.81, KsiM+Pi=1460.9, L+K0=1613.3, Sig0+K0=1690.3, SigP+K=1683.05
8894 //Omeg: Omeg+Pi0=1807.43, Ksi0+K=1808.5, KsiM+K0=1818.96
8895 G4cout<<"-Warning-G4QE::DecBary:*AsIs* UnknownBaryon(S=1)QC="<<qH->GetQC()<<G4endl;
8896 HV->push_back(qH); // Fill AsIs (delete equivalent)
8897 return;
8898 }
8899 }
8900 else
8901 {
8902#ifdef debug
8903 G4cout<<"---Warning---G4QE::DecBary:*AsIso*UnknBaryon(AntiS),QC="<<qH->GetQC()<<G4endl;
8904#endif
8905 HV->push_back(qH); // Fill AsIs (delete equivalent)
8906 return;
8907 }
8908 G4LorentzVector f4Mom(0.,0.,0.,fMass);
8909 G4LorentzVector s4Mom(0.,0.,0.,sMass);
8910 G4double sum=fMass+sMass;
8911 if(fabs(qM-sum)<eps)
8912 {
8913 f4Mom=q4M*(fMass/sum);
8914 s4Mom=q4M*(sMass/sum);
8915 }
8916 else if(qM<sum || !G4QHadron(q4M).DecayIn2(f4Mom, s4Mom))
8917 {
8918#ifdef debug
8919 G4cout<<"---Warning---G4QE::DecBar:fPDG="<<fQPDG<<"(M="<<fMass<<")+sPDG="<<sQPDG<<"(M="
8920 <<sMass<<") > TotM="<<q4M.m()<<G4endl;
8921#endif
8922 if(!theEnvironment.GetA())
8923 {
8924 G4Quasmon* quasH = new G4Quasmon(qH->GetQC(),qH->Get4Momentum());
8925 if(!CheckGroundState(quasH,true)) HV->push_back(qH); // Cor or fill asItIs
8926 else delete qH;
8927 delete quasH;
8928 return;
8929 }
8930 else
8931 {
8932 delete qH;
8933 G4ExceptionDescription ed;
8934 ed << "Baryon DecayIn2 error: Can't Correct, *EmptyEnv*="
8935 << theEnvironment << G4endl;
8936 G4Exception("G4QEnvironment::DecayBaryon()", "HAD_CHPS_0001",
8937 FatalException, ed);
8938 }
8939 }
8940#ifdef debug
8941 G4cout<<"G4QEnv::DecayBaryon: *DONE* f4M="<<f4Mom<<",fPDG="<<fQPDG<<", s4M="<<s4Mom
8942 <<",sPDG="<<sQPDG<<G4endl;
8943#endif
8944 delete qH;
8945 //
8946 G4QHadron* H1 = new G4QHadron(fQPDG,f4Mom); // Create a Hadron for the 1-st baryon
8947 HV->push_back(H1); // Fill "H1" (delete equivalent)
8948 G4QHadron* H2 = new G4QHadron(sQPDG,s4Mom); // Create a Hadron for the 2-nd baryon
8949 HV->push_back(H2); // Fill "H2" (delete equivalent)
8950} // End of DecayBaryon

Referenced by G4QFragmentation::EvaporateResidual().

◆ DecayMeson()

void G4QEnvironment::DecayMeson ( G4QHadron *  dB,
G4QHadronVector *  HV 
)

Definition at line 8953 of file G4QEnvironment.cc.

8954{
8955 static const G4QPDGCode gQPDG(22);
8956 static const G4QPDGCode pizQPDG(111);
8957 static const G4QPDGCode pipQPDG(211);
8958 static const G4QPDGCode pimQPDG(-211);
8959 static const G4QPDGCode kmQPDG(-321);
8960 static const G4QPDGCode kzQPDG(-311);
8961 static const G4QPDGCode kpQPDG(321);
8962 static const G4QPDGCode akzQPDG(311);
8963 static const G4double mPi = G4QPDGCode(211).GetMass();
8964 static const G4double mPi0 = G4QPDGCode(111).GetMass();
8965 static const G4double mK = G4QPDGCode(321).GetMass();
8966 static const G4double mK0 = G4QPDGCode(311).GetMass();
8967 static const G4double m2Pi0 = mPi0+ mPi0;
8968 static const G4double mPiPi0= mPi + mPi0;
8969 static const G4double mPiPi = mPi + mPi;
8970 static const G4double mKPi0 = mPi0+ mK;
8971 static const G4double mK0Pi0= mPi0+ mK0;
8972 static const G4double mKPi = mPi + mK;
8973 static const G4double mK0Pi = mPi + mK0;
8974 static const G4double mK0K = mK0 + mK;
8975 static const G4double mK0K0 = mK0 + mK0;
8976 static const G4double mKK = mK + mK;
8977 static const G4double eps = 0.003;
8978 //static const G4QNucleus vacuum(90000000);
8979 G4int theLB= qH->GetBaryonNumber(); // Baryon number of the Meson
8980 if(theLB)
8981 {
8982 G4cerr<<"*Warning*G4QEnvironment::DecayMeson:A="<<theLB<<" != 0 -> Fill asIs"<<G4endl;
8983#ifdef ppdebug
8984 // throw G4QException("G4QEnv::DecayMeson: Unknown Meson with A!=0");
8985 G4Exception("G4QEnvironment::DecayMeson()", "HAD_CHPS_0000",
8986 FatalException, "Unknown Meson with A!=0");
8987#endif
8988 HV->push_back(qH); // Fill AsIs (delete equivalent)
8989 return;
8990 }
8991 G4LorentzVector q4M = qH->Get4Momentum(); // Get 4-momentum of the Meson
8992 G4double qM = q4M.m(); // Excited Mass of the Meson
8993 G4int theLC= qH->GetCharge(); // Chsrge of the Meson
8994 G4int theLS= qH->GetStrangeness(); // Strangness of the Meson
8995 if(qM < eps)
8996 {
8997 HV->push_back(qH); // Fill AsIs (delete equivalent)
8998 if(theLC || theLS) G4cout<<"-Warning-G4QEnv::DecMes: S="<<theLS<<", C="<<theLC<<G4endl;
8999 return;
9000 }
9001#ifdef debug
9002 G4cout<<"G4QEnv::DecayMeson: *Called* S="<<theLS<<",C="<<theLC<<",4M="<<q4M<<qM<<G4endl;
9003#endif
9004 // Select a chanel of the Excited Meson decay
9005 G4QPDGCode fQPDG = pipQPDG; // Prototype for Meson1 = Pi+
9006 G4double fMass= mPi;
9007 G4QPDGCode sQPDG = pizQPDG; // Prototype for Meson2 = Pi0
9008 G4double sMass= mPi0;
9009 if(!theLS) // This is only for not strange Excited Mesons
9010 {
9011 if(!theLC) // Rho0 like
9012 {
9013 if(qM < m2Pi0) // Only Pi0+gamma decay is possible
9014 {
9015 if(qM < mPi0+eps)
9016 {
9017#ifdef debug
9018 G4cout<<"G4QEnv::DecayMeson: Fill Pi0 AsIs"<<G4endl;
9019#endif
9020 qH->SetQPDG(pizQPDG);
9021 HV->push_back(qH); // Fill AsIs (delete equivalent)
9022 if(qM+eps < mPi0)G4cout<<"-Warning-G4QEnv::DecayMeson: Pi0 AsIs, M="<<qM<<G4endl;
9023 return;
9024 }
9025 fQPDG=gQPDG; // Meson1 is gamma
9026 fMass=0.;
9027#ifdef debug
9028 G4cout<<"-Warning-G4QEnv::DecayMeson: Gamma+Pi0, M="<<qM<<",d="<<qM-mPi0<<G4endl;
9029#endif
9030 }
9031 else if(qM < mPiPi) // only Pi0+Pi0 is possible
9032 {
9033 fQPDG=pizQPDG; // Meson1 is Pi0
9034 fMass=mPi0;
9035 }
9036 else
9037 {
9038 if(G4UniformRand() < .333333333) // @@ can be smaller or dec \w qM !
9039 {
9040 fQPDG=pizQPDG; // Meson1 is Pi0
9041 fMass=mPi0;
9042 }
9043 else
9044 {
9045 sQPDG=pimQPDG; // Meson2 is Pi- (Pi+/Pi- decay)
9046 sMass=mPi;
9047 }
9048 }
9049 }
9050 else if(theLC==1) // Rho+ like decay
9051 {
9052 if(qM < mPiPi0) // Only gamma+Pi+ decay is possible
9053 {
9054 if(qM < mPi+eps)
9055 {
9056#ifdef debug
9057 G4cout<<"G4QEnv::DecayMeson: Fill Pi+ AsIs"<<G4endl;
9058#endif
9059 qH->SetQPDG(pipQPDG);
9060 HV->push_back(qH); // Fill AsIs (delete equivalent)
9061 if(qM+eps < mPi) G4cout<<"-Warning-G4QEnv::DecayMeson: Pi+ AsIs, M="<<qM<<G4endl;
9062 return;
9063 }
9064 sQPDG=gQPDG; // Meson is gamma (gamma + Pi+ decay)
9065 sMass=0.;
9066#ifdef debug
9067 G4cout<<"-Warning-G4QEnv::DecayMeson: Gamma+Pi+, M="<<qM<<",d="<<qM-mPi0<<G4endl;
9068#endif
9069 }
9070 //else // Pi0+Pi+ is a default case
9071 }
9072 else if(theLC==2) // Meson++ like: only PiP+PiP is possible
9073 {
9074 if(qM > mPiPi) // Only Pi+ + Pi+ decay is possible
9075 {
9076 sQPDG=pipQPDG; // Meson2 is Pi+
9077 sMass=mPi;
9078 }
9079 else // @@ Can be aReason to search for anError in Fragmentation
9080 {
9081#ifdef debug
9082 G4cout<<"-Warning-G4QE::DecayMeson:*AsIs* Meson++ M="<<qM<<",d="<<qM-mPiPi<<G4endl;
9083#endif
9084 HV->push_back(qH); // Fill AsIs (delete equivalent)
9085 return;
9086 }
9087 }
9088 else if(theLC==-1) // Rho- like decay
9089 {
9090 if(qM < mPiPi0) // Only gamma + Pi- decay is possible
9091 {
9092 if(qM < mPi+eps)
9093 {
9094#ifdef debug
9095 G4cout<<"G4QEnv::DecayMeson: Fill Pi- AsIs"<<G4endl;
9096#endif
9097 qH->SetQPDG(pimQPDG);
9098 HV->push_back(qH); // Fill AsIs (delete equivalent)
9099 if(qM+eps < mPi) G4cout<<"-Warning-G4QEnv::DecayMeson: Pi- AsIs, M="<<qM<<G4endl;
9100 return;
9101 }
9102 fQPDG=pimQPDG; // Meson1 is Pi-
9103 sQPDG=gQPDG; // Meson2 is gamma (gamma + Pi- decay)
9104 sMass=0.;
9105#ifdef debug
9106 G4cout<<"-Warning-G4QEnv::DecayMeson: Gamma+Pi-, M="<<qM<<",d="<<qM-mPi<<G4endl;
9107#endif
9108 }
9109 else fQPDG=pimQPDG; // Meson1 is Pi- instead of Pi+
9110 }
9111 else if(theLC==-2) // Meson-- like: only p+PiP is possible
9112 {
9113 if(qM > mPiPi) // Only Pi- + Pi- decay is possible
9114 {
9115 fQPDG=pimQPDG; // Meson1 is Pi-
9116 sQPDG=pimQPDG; // Meson2 is Pi-
9117 sMass=mPi;
9118 }
9119 else // @@ Can be aReason to search for anError in Fragmentation
9120 {
9121#ifdef debug
9122 G4cout<<"-Warning-G4QE::DecayMeson:*AsIs* Meson-- M="<<qM<<",d="<<qM-mPiPi<<G4endl;
9123#endif
9124 HV->push_back(qH); // Fill AsIs (delete equivalent)
9125 return;
9126 }
9127 }
9128 else // @@ Growing point: No solution for |C| > 2 so far
9129 {
9130#ifdef debug
9131 G4cout<<"-Warning-G4QE::DecayMeson:*AsIs* UnknMeson (S=0) QC="<<qH->GetQC()<<G4endl;
9132#endif
9133 HV->push_back(qH); // Fill AsIs (delete equivalent)
9134 return;
9135 }
9136 }
9137 else if( theLS == 1 ) // ==>->->-> Strange mesons (K-* like) S = 1 <-<-<-<==
9138 {
9139 if(!theLC) // -->> K0* like decay
9140 {
9141 if(qM < mKPi) // Only K0+gamma decay is possible KPi < K0Pi0
9142 {
9143 if(qM < mK0+eps) // Can not decay, hopefully it is close to K0
9144 {
9145#ifdef debug
9146 G4cout << "G4QEnv::DecayMeson: Fill K0 AsIs" << G4endl;
9147#endif
9148 qH->SetQPDG(kzQPDG);
9149 HV->push_back(qH); // Fill AsIs (delete equivalent)
9150 if(qM+eps < mK0) G4cout<<"-Warning-G4QEnv::DecayMeson: K0 AsIs, M="<<qM<<G4endl;
9151 return;
9152 }
9153 fQPDG=kzQPDG; // Meson is K0
9154 fMass=mK0;
9155 sQPDG=gQPDG; // Meson is gamma
9156 sMass=0.;
9157 }
9158 else if(qM < mK0Pi0) // Only K- + Pi+ is possible
9159 {
9160 sQPDG=kmQPDG; // Meson2 is K-
9161 sMass=mK;
9162 }
9163 else // Both K0 + Pi0 & K- + Pi+ are possible
9164 {
9165 if(G4UniformRand()>.5) // @@ Relative probability (take into account Phase Space)
9166 {
9167 sQPDG=kmQPDG; // Meson2 is K-
9168 sMass=mK;
9169 }
9170 else
9171 {
9172 fQPDG=kzQPDG; // Meson2 is K0
9173 fMass=mK0;
9174 }
9175 }
9176 }
9177 else if(theLC==-1) // -->> K-* like decay
9178 {
9179 if(qM < mKPi0) // Only K- + gamma decay is possible
9180 {
9181 if(qM < mK+eps) // Can not decay, hopefully it is close to K-
9182 {
9183#ifdef debug
9184 G4cout << "G4QEnv::DecayMeson: Fill K- AsIs" << G4endl;
9185#endif
9186 qH->SetQPDG(kmQPDG);
9187 HV->push_back(qH); // Fill AsIs (delete equivalent)
9188 if(qM+eps < mK) G4cout<<"-Warning-G4QEnv::DecayMeson: K- AsIs, M="<<qM<<G4endl;
9189 return;
9190 }
9191 fQPDG=kmQPDG; // Meson is K-
9192 fMass=mK;
9193 sQPDG=gQPDG; // Meson is gamma
9194 sMass=0.;
9195 }
9196 else if(qM < mKPi0) // Only K- + Pi0 is possible
9197 {
9198 fQPDG=kmQPDG; // Meson1 is K-
9199 fMass=mK;
9200 }
9201 else // Both K0 + Pi0 & K- + Pi+ are possible
9202 {
9203 if(G4UniformRand()>.5) // @@ Relative probability (take into account Phase Space)
9204 {
9205 fQPDG=kmQPDG; // Meson1 is K-
9206 fMass=mK;
9207 }
9208 else
9209 {
9210 fQPDG=pimQPDG; // Meson1 is Pi-
9211 sQPDG=kzQPDG; // Meson2 is K0
9212 sMass=mK0;
9213 }
9214 }
9215 }
9216 else if(theLC== 1) // -->> K0 + Pi+ decay only
9217 {
9218 if(qM+eps < mK0Pi) // Nothing can be done for this bad combination (Recover!)
9219 {
9220 G4cout<<"-Warniong-G4QEnv::DecayMeson: LowMassPositive Strange Meson AsIs"<<G4endl;
9221 HV->push_back(qH); // Fill AsIs (delete equivalent)
9222 return;
9223 }
9224 else // Only K- + Pi0 is possible
9225 {
9226 sQPDG=kzQPDG; // Meson2 is K0
9227 sMass=mK0;
9228 }
9229 }
9230 else if(theLC== -2) // -->> K- + Pi- decay only
9231 {
9232 if(qM+eps < mKPi) // Nothing can be done for this bad combination (Recover!)
9233 {
9234 G4cout<<"-Warniong-G4QEnv::DecayMeson: LowMassDNegativeStrange Meson AsIs"<<G4endl;
9235 HV->push_back(qH); // Fill AsIs (delete equivalent)
9236 return;
9237 }
9238 else // Only K- + Pi- is possible
9239 {
9240 fQPDG=pimQPDG; // Meson1 is Pi-
9241 sQPDG=kmQPDG; // Meson2 is K-
9242 sMass=mK;
9243 }
9244 }
9245 else
9246 {
9247 G4cout<<"-Warning-G4QE::DecMeson:*AsIs*UnknownMeson.(S=1), QC="<<qH->GetQC()<<G4endl;
9248 HV->push_back(qH); // Fill AsIs (delete equivalent)
9249 return;
9250 }
9251 }
9252 else if(theLS==2) // ==>->->-> Double srange Meson: S = 2 <-<-<-<==
9253 {
9254 if(theLC== 0) // -->> K0 + K0 decay only
9255 {
9256 if(qM+eps < mK0K0) // Nothing can be done for this bad combination (Recover!)
9257 {
9258 G4cout<<"-Warniong-G4QEnv::DecayMeson: LowMassNeutral DStrange Meson AsIs"<<G4endl;
9259 HV->push_back(qH); // Fill AsIs (delete equivalent)
9260 return;
9261 }
9262 else // Only K- + Pi0 is possible
9263 {
9264 fQPDG=kzQPDG; // Meson1 is K0
9265 fMass=mK0;
9266 sQPDG=kzQPDG; // Meson2 is K0
9267 sMass=mK0;
9268 }
9269 }
9270 else if(theLC== -1) // -->> K- + K0 decay only
9271 {
9272 if(qM+eps < mK0K) // Nothing can be done for this bad combination (Recover!)
9273 {
9274 G4cout<<"-Warniong-G4QEnv::DecayMeson: LowMassNegativeDStrange Meson AsIs"<<G4endl;
9275 HV->push_back(qH); // Fill AsIs (delete equivalent)
9276 return;
9277 }
9278 else // Only K- + Pi- is possible
9279 {
9280 fQPDG=kmQPDG; // Meson1 is K-
9281 fMass=mK;
9282 sQPDG=kzQPDG; // Meson2 is K0
9283 sMass=mK0;
9284 }
9285 }
9286 else if(theLC==-2) // -->> K- + K- decay only
9287 {
9288 if(qM+eps < mKK) // Nothing can be done for this bad combination (Recover!)
9289 {
9290 G4cout<<"-Warniong-G4QEnv::DecayMeson:LowMassDNegativeADStrangeMeson AsIs"<<G4endl;
9291 HV->push_back(qH); // Fill AsIs (delete equivalent)
9292 return;
9293 }
9294 else // Only K+ + K+ is possible
9295 {
9296 fQPDG=kmQPDG; // Meson1 is K-
9297 fMass=mK;
9298 sQPDG=kmQPDG; // Meson2 is K-
9299 sMass=mK;
9300 }
9301 }
9302 else
9303 {
9304 G4cout<<"-Warning-G4QE::DecMeson:*AsIs*UnknownMeson.(S=2), QC="<<qH->GetQC()<<G4endl;
9305 HV->push_back(qH); // Fill AsIs (delete equivalent)
9306 return;
9307 }
9308 }
9309 else if( theLS ==-1 ) // ==>->->-> AntiStrange mesons (K+* like) S =-1 <-<-<-<==
9310 {
9311 if(!theLC) // -->> aK0* like decay
9312 {
9313 if(qM < mKPi) // Only aK0+gamma decay is possible
9314 {
9315 if(qM < mK0+eps) // Can not decay, hopefully it is close to K0
9316 {
9317#ifdef debug
9318 G4cout << "G4QEnv::DecayMeson: Fill K0 AsIs" << G4endl;
9319#endif
9320 qH->SetQPDG(akzQPDG);
9321 HV->push_back(qH); // Fill AsIs (delete equivalent)
9322 if(qM+eps < mK0) G4cout<<"-Warning-G4QEnv::DecayMeson: aK0 AsIs, M="<<qM<<G4endl;
9323 return;
9324 }
9325 fQPDG=akzQPDG; // Meson is aK0
9326 fMass=mK0;
9327 sQPDG=gQPDG; // Meson is gamma
9328 sMass=0.;
9329 }
9330 else if(qM < mK0Pi0) // Only K+ + Pi- is possible
9331 {
9332 fQPDG=pimQPDG; // Meson1 is Pi-
9333 sQPDG=kpQPDG; // Meson2 is K+
9334 sMass=mK;
9335 }
9336 else // Both aK0 + Pi0 & K+ + Pi- are possible
9337 {
9338 if(G4UniformRand()>.5) // @@ Relative probability (take into account Phase Space)
9339 {
9340 fQPDG=pimQPDG; // Meson1 is Pi-
9341 sQPDG=kpQPDG; // Meson2 is K+
9342 sMass=mK;
9343 }
9344 else
9345 {
9346 fQPDG=akzQPDG; // Meson1 is aK0
9347 fMass=mK0;
9348 }
9349 }
9350 }
9351 else if(theLC == 1) // -->> aK+* like decay
9352 {
9353 if(qM < mKPi0) // Only aK+ + gamma decay is possible
9354 {
9355 if(qM < mK+eps) // Can not decay, hopefully it is close to K+
9356 {
9357#ifdef debug
9358 G4cout << "G4QEnv::DecayMeson: Fill K+ AsIs" << G4endl;
9359#endif
9360 HV->push_back(qH); // Fill AsIs (delete equivalent)
9361 if(qM+eps < mK) G4cout<<"-Warning-G4QEnv::DecayMeson: K+ AsIs, M="<<qM<<G4endl;
9362 return;
9363 }
9364 fQPDG=kpQPDG; // Meson is K+
9365 fMass=mK;
9366 sQPDG=gQPDG; // Meson is gamma
9367 sMass=0.;
9368 }
9369 else if(qM < mKPi0) // Only K+ + Pi0 is possible
9370 {
9371 fQPDG=kpQPDG; // Meson1 is K+
9372 fMass=mK;
9373 }
9374 else // Both K+ + Pi0 & aK0 + Pi+ are possible
9375 {
9376 if(G4UniformRand()>.5) // @@ Relative probability (take into account Phase Space)
9377 {
9378 fQPDG=kpQPDG; // Meson1 is K+
9379 fMass=mK;
9380 }
9381 else
9382 {
9383 sQPDG=akzQPDG; // Meson2 is aK0
9384 sMass=mK0;
9385 }
9386 }
9387 }
9388 else if(theLC==-1) // -->> aK0 + Pi- decay only
9389 {
9390 if(qM+eps < mK0Pi) // Nothing can be done for this bad combination (Recover!)
9391 {
9392 G4cout<<"-Warniong-G4QEnv::DecayMeson: LowMassNegativeAStrange Meson AsIs"<<G4endl;
9393 HV->push_back(qH); // Fill AsIs (delete equivalent)
9394 return;
9395 }
9396 else // Only aK0 + Pi- is possible
9397 {
9398 fQPDG=pimQPDG; // Meson1 is Pi-
9399 sQPDG=akzQPDG; // Meson2 is K0
9400 sMass=mK0;
9401 }
9402 }
9403 else if(theLC== 2) // -->> K+ + Pi+ decay only
9404 {
9405 if(qM+eps < mKPi) // Nothing can be done for this bad combination (Recover!)
9406 {
9407 G4cout<<"-Warniong-G4QEnv::DecayMeson: LowMassDPositiveStrange Meson AsIs"<<G4endl;
9408 HV->push_back(qH); // Fill AsIs (delete equivalent)
9409 return;
9410 }
9411 else // Only K- + Pi- is possible
9412 {
9413 sQPDG=kpQPDG; // Meson2 is K+
9414 sMass=mK;
9415 }
9416 }
9417 else
9418 {
9419 G4cout<<"-Warning-G4QE::DecMeson:*AsIs*UnknownMeson.(S=-1),QC="<<qH->GetQC()<<G4endl;
9420 HV->push_back(qH); // Fill AsIs (delete equivalent)
9421 return;
9422 }
9423 }
9424 else if(theLS==-2) // ==>->->-> Double srange Meson: S =-2 <-<-<-<==
9425 {
9426 if(theLC== 0) // -->> aK0 + aK0 decay only
9427 {
9428 if(qM+eps < mK0K0) // Nothing can be done for this bad combination (Recover!)
9429 {
9430 G4cout<<"-Warniong-G4QEnv::DecayMeson: LowMassNeutralADStrange Meson AsIs"<<G4endl;
9431 HV->push_back(qH); // Fill AsIs (delete equivalent)
9432 return;
9433 }
9434 else // Only K- + Pi0 is possible
9435 {
9436 fQPDG=akzQPDG; // Meson1 is aK0
9437 fMass=mK0;
9438 sQPDG=akzQPDG; // Meson2 is aK0
9439 sMass=mK0;
9440 }
9441 }
9442 else if(theLC== 1) // -->> K+ + K0 decay only
9443 {
9444 if(qM+eps < mK0K) // Nothing can be done for this bad combination (Recover!)
9445 {
9446 G4cout<<"-Warniong-G4QEnv::DecayMeson: LowMassPositiveADStrangeMeson AsIs"<<G4endl;
9447 HV->push_back(qH); // Fill AsIs (delete equivalent)
9448 return;
9449 }
9450 else // Only K+ + K0 is possible
9451 {
9452 fQPDG=kpQPDG; // Meson1 is K+
9453 fMass=mK;
9454 sQPDG=akzQPDG; // Meson2 is K0
9455 sMass=mK0;
9456 }
9457 }
9458 else if(theLC== 2) // -->> K+ + K+ decay only
9459 {
9460 if(qM+eps < mKK) // Nothing can be done for this bad combination (Recover!)
9461 {
9462 G4cout<<"-Warniong-G4QEnv::DecayMeson:LowMassDPositiveADStrangeMeson AsIs"<<G4endl;
9463 HV->push_back(qH); // Fill AsIs (delete equivalent)
9464 return;
9465 }
9466 else // Only K+ + K+ is possible
9467 {
9468 fQPDG=kpQPDG; // Meson1 is K+
9469 fMass=mK;
9470 sQPDG=kpQPDG; // Meson2 is K+
9471 sMass=mK;
9472 }
9473 }
9474 else
9475 {
9476 G4cout<<"-Warning-G4QE::DecMeson:*AsIs*UnknownMeson.(S=-2),QC="<<qH->GetQC()<<G4endl;
9477 HV->push_back(qH); // Fill AsIs (delete equivalent)
9478 return;
9479 }
9480 }
9481 else
9482 {
9483 //#ifdef debug
9484 G4cout<<"---Warning---G4QE::DecMeso: *Fill AsIso* UnknMeson, QC="<<qH->GetQC()<<G4endl;
9485 //#endif
9486 HV->push_back(qH); // Fill AsIs (delete equivalent)
9487 return;
9488 }
9489 G4LorentzVector f4Mom(0.,0.,0.,fMass);
9490 G4LorentzVector s4Mom(0.,0.,0.,sMass);
9491 G4double sum=fMass+sMass;
9492 if(fabs(qM-sum)<eps)
9493 {
9494 f4Mom=q4M*(fMass/sum);
9495 s4Mom=q4M*(sMass/sum);
9496 }
9497 else if(qM<sum || !G4QHadron(q4M).DecayIn2(f4Mom, s4Mom))
9498 {
9499#ifdef debug
9500 G4cout<<"---Warning---G4QE::DecMes:fPDG="<<fQPDG<<"(M="<<fMass<<")+sPDG="<<sQPDG<<"(M="
9501 <<sMass<<") > TotM="<<q4M.m()<<G4endl;
9502#endif
9503 if(!theEnvironment.GetA())
9504 {
9505 G4Quasmon* quasH = new G4Quasmon(qH->GetQC(),qH->Get4Momentum());
9506 if(!CheckGroundState(quasH,true)) HV->push_back(qH); // Cor or fill asItIs
9507 else delete qH;
9508 delete quasH;
9509 return;
9510 }
9511 else
9512 {
9513 delete qH;
9514 G4ExceptionDescription ed;
9515 ed << "Meson DecayIn2 error: Can't Correct, *EmptyEnv*="
9516 << theEnvironment << G4endl;
9517 G4Exception("G4QEnvironment::DecayMeson()", "HAD_CHPS_0001",
9518 FatalException, ed);
9519 }
9520 }
9521#ifdef debug
9522 G4cout<<"G4QEnv::DecayMeson: *DONE* f4M="<<f4Mom<<",fPDG="<<fQPDG<<", s4M="<<s4Mom
9523 <<",sPDG="<<sQPDG<<G4endl;
9524#endif
9525 delete qH;
9526 //
9527 G4QHadron* H1 = new G4QHadron(fQPDG,f4Mom); // Create a Hadron for the 1-st baryon
9528 HV->push_back(H1); // Fill "H1" (delete equivalent)
9529 G4QHadron* H2 = new G4QHadron(sQPDG,s4Mom); // Create a Hadron for the 2-nd baryon
9530 HV->push_back(H2); // Fill "H2" (delete equivalent)
9531} // End of DecayMeson

Referenced by G4QFragmentation::EvaporateResidual().

◆ FillQHadrons()

void G4QEnvironment::FillQHadrons ( G4QHadronVector *  input)
protected

Definition at line 8297 of file G4QEnvironment.cc.

8298{
8299 G4int nH=input->size();
8300#ifdef debug
8301 G4cout<<"G4QEnvironment::FillQHadrons is called nH="<<nH<<G4endl;
8302#endif
8303 if(nH) for(G4int ih=0; ih<nH; ih++)
8304 {
8305#ifdef debug
8306 G4cout<<"G4QEnv::FillQHadrons:H#"<<ih<<",HQPDG="<<(*input)[ih]->GetQPDG()<<",HQC="
8307 <<(*input)[ih]->GetQC()<<",HM="<<(*input)[ih]->GetMass()<<G4endl;
8308#endif
8309 G4QHadron* curH = new G4QHadron((*input)[ih]);
8310 theQHadrons.push_back(curH); // (del. equiv.
8311 }
8312#ifdef debug
8313 G4cout<<"G4QEnvironment::FillQHadrons ===OUT=== Filled nQH="<<theQHadrons.size()<<G4endl;
8314#endif
8315} // End of FillQHadrons

◆ Fragment()

G4QHadronVector * G4QEnvironment::Fragment ( )

Definition at line 4512 of file G4QEnvironment.cc.

4513{
4514#ifdef chdebug
4515 G4int fCharge=theEnvironment.GetCharge();
4516 G4int fBaryoN=theEnvironment.GetA();
4517 G4int nHad=theQHadrons.size();
4518 if(nHad) for(G4int ih=0; ih<nHad; ih++)
4519 {
4520 fCharge+=theQHadrons[ih]->GetCharge();
4521 fBaryoN+=theQHadrons[ih]->GetBaryonNumber();
4522 }
4523 G4int nQuas=theQuasmons.size();
4524 if(nQuas)for(G4int iqs=0; iqs<nQuas; iqs++)
4525 {
4526 fCharge+=theQuasmons[iqs]->GetCharge();
4527 fBaryoN+=theQuasmons[iqs]->GetBaryonNumber();
4528 }
4529 if(fCharge!=totCharge || fBaryoN!=totBaryoN)
4530 {
4531 G4cout<<"*::*G4QE::Frag:(4) tC="<<totCharge<<",C="<<fCharge<<",tB="<<totBaryoN
4532 <<",B="<<fBaryoN<<",E="<<theEnvironment<<G4endl;
4533 if(nHad) for(G4int h=0; h<nHad; h++)
4534 {
4535 G4QHadron* cH = theQHadrons[h];
4536 G4cout<<"*::*G4QE::HQ:h#"<<h<<",QC="<<cH->GetQC()<<",PDG="<<cH->GetPDGCode()<<G4endl;
4537 }
4538 if(nQuas) for(G4int q=0; q<nQuas; q++)
4539 {
4540 G4Quasmon* cQ = theQuasmons[q];
4541 G4cout<<"*::*G4QE::HQ:q#"<<q<<",C="<<cQ->GetCharge()<<",QCont="<<cQ->GetQC()<<G4endl;
4542 }
4543 }
4544#endif
4545 G4QHadronVector dummy; // Prototype of the output G4QHadronVector to avoid warnings
4546 G4QHadronVector* theFragments = &dummy; // Prototype of the output G4QHadronVector
4547 G4int ExCount =0; // Counter of the repetitions
4548 G4int MaxExCnt=1; // A#of of repetitions + 1 (1 for no repetitions)
4549 G4bool RepFlag=true; // To come inside the while
4550 // For the purpose of the recalculation the Quasmons, Hadrons, Environment must be stored
4551 G4QuasmonVector* reQuasmons = new G4QuasmonVector; // deleted after the "while LOOP"
4552 G4int nQ = theQuasmons.size();
4553 if(nQ)
4554 {
4555 for(G4int iq=0; iq<nQ; iq++)
4556 {
4557 G4Quasmon* curQ = new G4Quasmon(theQuasmons[iq]);
4558 reQuasmons->push_back(curQ); // deleted after the "while LOOP"
4559 }
4560 }
4561 G4QHadronVector* reQHadrons = new G4QHadronVector; // deleted after the "while LOOP"
4562 G4int nH = theQHadrons.size();
4563 if(nH)
4564 {
4565 for(G4int ih=0; ih<nH; ih++)
4566 {
4567 G4QHadron* curH = new G4QHadron(theQHadrons[ih]);
4568 reQHadrons->push_back(curH); // deleted after the "while LOOP"
4569 }
4570 }
4571 G4QNucleus reEnvironment=theEnvironment;
4572 G4LorentzVector rem4M=tot4Mom;
4573 while (RepFlag && ExCount<MaxExCnt)
4574 {
4575 try
4576 {
4577 RepFlag=false; // If OK - go out of the while
4578 theFragments = FSInteraction(); // InterClass creation. User must delet QHadrons.
4579 }
4580 catch (G4QException& error)
4581 {
4582 G4cout<<"***G4QEnvironment::Fragment: Exception is catched"<<G4endl;
4583 RepFlag=true; // For the Exception - repete
4584 ExCount++; // Increment the repetition counter
4585 G4cout<<"***G4QEnv::Fragment:Exception #"<<ExCount<<": "<<error.GetMessage()<<G4endl;
4586 G4LorentzVector dif=rem4M-theEnvironment.Get4Momentum(); // CHECK difference
4587 G4int nHp=theQHadrons.size();
4588 G4int nQp = theQuasmons.size();
4589 G4cout<<"***G4QEnvir::Fragment:nH="<<nHp<<",nQ="<<nQp<<",E="<<theEnvironment<<G4endl;
4590 for(G4int ph=0; ph<nHp; ph++)
4591 {
4592 G4QHadron* cH = theQHadrons[ph];
4593 dif-=cH->Get4Momentum();
4594 G4cout<<"***G4QEnvir::Fr:H"<<ph<<"="<<cH->Get4Momentum()<<cH->GetPDGCode()<<G4endl;
4595 }
4596 for(G4int pq=0; pq<nQp; pq++)
4597 {
4598 G4Quasmon* cQ = theQuasmons[pq];
4599 dif-=cQ->Get4Momentum();
4600 G4cout<<"***G4QEnvir::Fr:Quasm#"<<pq<<"="<<cQ->Get4Momentum()<<cQ->GetQC()<<G4endl;
4601 }
4602 // *** Cleaning Up of all old output instances for the recalculation purposes ***
4603 for_each(theFragments->begin(), theFragments->end(), DeleteQHadron()); // old Hadrons
4604 theFragments->clear();
4605 for_each(theQHadrons.begin(), theQHadrons.end(), DeleteQHadron()); //internal Hadrons
4606 theQHadrons.clear();
4607 for_each(theQuasmons.begin(), theQuasmons.end(), DeleteQuasmon()); // old Quasmons
4608 theQuasmons.clear();
4609 G4cout<<"***G4QEnv::Fragment: ----------- End of CleaningUp: 4Mdif="<<dif<<G4endl;
4610 // **************** Recover all conditions for the recalculation ********************
4611 theEnvironment=reEnvironment; // Recover the nuclear environment
4612 tot4Mom=rem4M; // Recover the total 4Momentum of the React
4613 G4cout<<"***G4QEnv::Fragment:*Recover*Env="<<theEnvironment<<",4M="<<tot4Mom<<G4endl;
4614 G4int mQ = reQuasmons->size(); // Recover the memorizedQuasmons with print
4615 for(G4int jq=0; jq<mQ; jq++)
4616 {
4617 //G4Quasmon* curQ = new G4Quasmon(reQuasmons->operator[](jq));
4618 G4Quasmon* curQ = new G4Quasmon((*reQuasmons)[jq]);
4619 G4cout<<"***G4QE::Fragm:Q("<<jq<<")="<<curQ->Get4Momentum()<<curQ->GetQC()<<G4endl;
4620 theQuasmons.push_back(curQ); // (delete equivalent)
4621 }
4622 G4int mH = reQHadrons->size(); // Recover the memorizedQHadrons with print
4623 for(G4int jh=0; jh<mH; jh++)
4624 {
4625 //G4QHadron* curH = new G4QHadron(reQHadrons->operator[](jh));
4626 G4QHadron* curH = new G4QHadron((*reQHadrons)[jh]);
4627 G4cout<<"***G4QE::Fragm:H("<<jh<<")="<<curH->Get4Momentum()<<curH->GetQC()<<G4endl;
4628 theQHadrons.push_back(curH); // (delete equivalent)
4629 }
4630 }
4631 }
4632 if(reQuasmons->size()) // If something is still in memory then clean it up
4633 {
4634 for_each(reQuasmons->begin(),reQuasmons->end(),DeleteQuasmon()); // CleanUp oldQuasmons
4635 reQuasmons->clear();
4636 }
4637 delete reQuasmons; // All temporary Quasmons memory is wiped out
4638 if(reQHadrons->size()) // If something is still in memory then clean it up
4639 {
4640 for_each(reQHadrons->begin(),reQHadrons->end(),DeleteQHadron()); //CleanUp old QHadrons
4641 reQHadrons->clear();
4642 }
4643 delete reQHadrons; // All temporary QHadrons memory is wiped out
4644 if(ExCount>=MaxExCnt)
4645 {
4646 G4int nProj=theProjectiles.size();
4647 G4cerr<<"*G4QEnv::Fragment:Exception.Target="<<theTargetPDG<<". #Proj="<<nProj<<G4endl;
4648 if(nProj) for(G4int ipr=0; ipr<nProj; ipr++)
4649 {
4650 G4QHadron* prH = theProjectiles[ipr];
4651 G4cerr<<"G4QE::F:#"<<ipr<<",PDG/4M="<<prH->GetPDGCode()<<prH->Get4Momentum()<<G4endl;
4652 }
4653 G4Exception("G4QEnvironment::Fragment()", "HAD_CHPS_0000",
4654 FatalException, "This reaction caused the CHIPSException");
4655 }
4656 // Put the postponed hadrons in the begining of theFragments and clean them up
4657 G4int tmpS=intQHadrons.size();
4658 if(tmpS)
4659 {
4660 //tmpS=theFragments->size();
4661 //intQHadrons.resize(tmpS+intQHadrons.size());
4662 //copy(theFragments->begin(), theFragments->end(), intQHadrons.end()-tmpS);
4663 //tmpS=intQHadrons.size();
4664 //theFragments->resize(tmpS); // Resize theFragments
4665 //copy(intQHadrons.begin(), intQHadrons.end(), theFragments->begin());
4666 // Can be like this, but by performance it is closer to FNAL (but better than it)
4667 //copy(theFragments->begin(), theFragments->end(), back_inserter(intQHadrons));
4668 //theFragments->resize(intQHadrons.size()); // Resize theFragments
4669 //copy(intQHadrons.begin(), intQHadrons.end(), theFragments->begin());
4670 // The following (istead of all above) has worse performance !
4671 theFragments->insert(theFragments->begin(), intQHadrons.begin(), intQHadrons.end() );
4672 intQHadrons.clear();
4673 }
4674 // No we need to check that all hadrons are on the mass shell
4675 CheckMassShell(theFragments); // @@ the same can be done in the end of G4QFragmentation
4676 return theFragments;
4677} // End of the Fragmentation member function
G4QHadronVector
std::vector< G4QHadron * > G4QHadronVector
Definition: G4QHadronVector.hh:56
G4QuasmonVector
std::vector< G4Quasmon * > G4QuasmonVector
Definition: G4QuasmonVector.hh:50
G4QEnvironment::CheckMassShell
void CheckMassShell(G4QHadronVector *HV)
Definition: G4QEnvironment.cc:10534
G4QException::GetMessage
const G4String & GetMessage()
Definition: G4QException.cc:42

Referenced by G4ChiralInvariantPhaseSpace::ApplyYourself(), G4QCaptureAtRest::AtRestDoIt(), G4QFragmentation::Fragment(), G4QIonIonCollision::Fragment(), G4QAtomicElectronScattering::PostStepDoIt(), G4QStringChipsParticleLevelInterface::Propagate(), G4StringChipsInterface::Propagate(), G4StringChipsParticleLevelInterface::Propagate(), and G4QDiffractionRatio::TargFragment().

◆ GetEnvironment()

G4QNucleus G4QEnvironment::GetEnvironment ( ) const
inline

Definition at line 136 of file G4QEnvironment.hh.

136{return theEnvironment;}

◆ GetProjectiles()

G4QHadronVector * G4QEnvironment::GetProjectiles ( )

◆ GetQHadrons()

G4QHadronVector * G4QEnvironment::GetQHadrons ( )

Definition at line 8267 of file G4QEnvironment.cc.

8268{
8269 G4int nH=theQHadrons.size();
8270#ifdef debug
8271 G4cout<<"G4QEnvironment::GetQHadrons is called nH="<<nH<<G4endl;
8272#endif
8273 G4QHadronVector* hadrons = new G4QHadronVector; // !! User is responsible to delet it
8274 if(nH) for(G4int ih=0; ih<nH; ih++)
8275 {
8276#ifdef debug
8277 G4cout<<"G4QEnv::GetQHadrons:H#"<<ih<<",HQPDG="<<theQHadrons[ih]->GetQPDG()<<",HQC="
8278 <<theQHadrons[ih]->GetQC()<<",HM="<<theQHadrons[ih]->GetMass()<<G4endl;
8279#endif
8280 G4QHadron* curH = new G4QHadron(theQHadrons[ih]);
8281 hadrons->push_back(curH); // (del. equiv. - user is responsibile)
8282 }
8283#ifdef debug
8284 G4cout<<"G4QEnvironment::GetQHadrons ===OUT=== Copied nQH="<<hadrons->size()<<G4endl;
8285#endif
8286 return hadrons;
8287} // End of GetQHadrons

◆ GetQuasmons()

G4QuasmonVector * G4QEnvironment::GetQuasmons ( )

Definition at line 8244 of file G4QEnvironment.cc.

8245{
8246 G4int nQ=theQuasmons.size();
8247#ifdef debug
8248 G4cout<<"G4QEnvironment::GetQuasmons is called nQ="<<nQ<<G4endl;
8249#endif
8250 G4QuasmonVector* quasmons = new G4QuasmonVector; // !! User is responsible to delet it
8251 if(nQ) for(G4int iq=0; iq<nQ; iq++)
8252 {
8253#ifdef debug
8254 G4cout<<"G4QEnv::GetQuasm:Q#"<<iq<<",QQPDG="<<theQuasmons[iq]->GetQPDG()<<",QQC="
8255 <<theQuasmons[iq]->GetQC()<<",M="<<theQuasmons[iq]->Get4Momentum().m()<<G4endl;
8256#endif
8257 G4Quasmon* curQ = new G4Quasmon(theQuasmons[iq]);
8258 quasmons->push_back(curQ); // (delete equivalent - user is responsible)
8259 }
8260#ifdef debug
8261 G4cout<<"G4QEnvironment::GetQuasmons ===OUT==="<<G4endl;
8262#endif
8263 return quasmons;
8264} // End of GetQuasmons

◆ OpenElectromagneticDecays()

void G4QEnvironment::OpenElectromagneticDecays ( )
static

Definition at line 702 of file G4QEnvironment.cc.

702{ElMaDecays=true;}

◆ operator!=()

G4bool G4QEnvironment::operator!= ( const G4QEnvironment &  right) const
inline

Definition at line 134 of file G4QEnvironment.hh.

135 {return this != &rhs;}

◆ operator=()

const G4QEnvironment & G4QEnvironment::operator= ( const G4QEnvironment &  right)

Definition at line 718 of file G4QEnvironment.cc.

719{
720 if(this != &right) // Beware of self assignment
721 {
722 // theQHadrons (Vector)
723 theQFScat = G4QFreeScattering::GetPointer();
724 G4int iQH = theQHadrons.size();
725 if(iQH) for(G4int ii=0; ii<iQH; ii++) delete theQHadrons[ii];
726 theQHadrons.clear();
727 G4int nQH = right.theQHadrons.size();
728 if(nQH) for(G4int ih=0; ih<nQH; ih++)
729 {
730 G4QHadron* curQH = new G4QHadron(right.theQHadrons[ih]);
731#ifdef debug
732 G4cout<<"G4QE::Operator=:c#"<<ih<<","<<curQH->GetQC()<<curQH->Get4Momentum()<<G4endl;
733#endif
734 theQHadrons.push_back(curQH); // (delete equivalent)
735 }
736
737 theWorld = right.theWorld;
738 nBarClust = right.nBarClust;
739 f2all = right.f2all;
740
741 // theQuasmons (Vector)
742 G4int iQ = theQuasmons.size();
743 if(iQ) for(G4int jq=0; jq<iQ; jq++) delete theQuasmons[jq];
744 theQuasmons.clear();
745 G4int nQ = right.theQuasmons.size();
746 if(nQ) for(G4int iq=0; iq<nQ; iq++)
747 {
748 G4Quasmon* curQ = new G4Quasmon(right.theQuasmons[iq]);
749 theQuasmons.push_back(curQ); // (delete equivalent)
750 }
751
752 // theQCandidates (Vector)
753 G4int iQC = theQCandidates.size();
754 if(iQC) for(G4int jc=0; jc<iQC; jc++) delete theQCandidates[jc];
755 theQCandidates.clear();
756 G4int nQC = right.theQCandidates.size();
757 if(nQC) for(G4int ic=0; ic<nQC; ic++)
758 {
759 G4QCandidate* curQC = new G4QCandidate(right.theQCandidates[ic]);
760 theQCandidates.push_back(curQC); // (delete equivalent)
761 }
762
763 theEnvironment = right.theEnvironment;
764 }
765 return *this;
766}

◆ operator==()

G4bool G4QEnvironment::operator== ( const G4QEnvironment &  right) const
inline

Definition at line 132 of file G4QEnvironment.hh.

133 {return this == &rhs;}

◆ SetParameters()

void G4QEnvironment::SetParameters ( G4double  solAn = 0.4,
G4bool  efFlag = false,
G4double  piThresh = 141.4,
G4double  mpisq = 20000.,
G4double  dinum = 1880. 
)
static

Definition at line 708 of file G4QEnvironment.cc.

710{
711 EnergyFlux=efFlag; // Flag for Energy Flux use instead of Multy Quasmon
712 SolidAngle=solAn; // Part of Solid Angle to capture secondaries (@@A-dep)
713 PiPrThresh=piThresh; // Pion Production Threshold for gammas
714 M2ShiftVir=mpisq; // Shift for M2=-Q2=m_pi^2 of the virtual gamma
715 DiNuclMass=dinum; // Double Nucleon Mass for virtual normalization
716}

Referenced by G4QAtomicElectronScattering::G4QAtomicElectronScattering(), G4QCaptureAtRest::G4QCaptureAtRest(), G4QInelastic::G4QInelastic(), G4QAtomicElectronScattering::SetParameters(), G4QCaptureAtRest::SetParameters(), and G4QInelastic::SetParameters().

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