Geant4  10.02.p01
G4hhElastic.cc
Go to the documentation of this file.
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 // $Id: G4hhElastic.cc,v 1.5 2010-11-09 09:04:29 grichine Exp $
27 // GEANT4 tag $Name: not supported by cvs2svn $
28 //
29 //
30 // Physics model class G4hhElastic
31 //
32 //
33 // G4 Model: qQ hadron hadron elastic scattering with 4-momentum balance
34 //
35 // 02.05.2014 V. Grichine 1-st version
36 //
37 
38 #include "G4hhElastic.hh"
39 #include "G4ParticleTable.hh"
40 #include "G4ParticleDefinition.hh"
41 #include "G4IonTable.hh"
42 #include "G4NucleiProperties.hh"
43 
44 #include "Randomize.hh"
45 #include "G4Integrator.hh"
46 #include "globals.hh"
47 #include "G4PhysicalConstants.hh"
48 #include "G4SystemOfUnits.hh"
49 
50 #include "G4Proton.hh"
51 #include "G4Neutron.hh"
52 #include "G4PionPlus.hh"
53 #include "G4PionMinus.hh"
54 
55 #include "G4Element.hh"
56 #include "G4ElementTable.hh"
57 #include "G4PhysicsTable.hh"
58 #include "G4PhysicsLogVector.hh"
59 #include "G4PhysicsFreeVector.hh"
60 
61 #include "G4HadronNucleonXsc.hh"
62 
63 #include "G4Pow.hh"
64 
65 using namespace std;
66 
67 
69 //
70 // Tracking constructor. Target is proton
71 
72 
74  : G4HadronElastic("HadrHadrElastic")
75 {
76  SetMinEnergy( 1.*GeV );
77  SetMaxEnergy( 10000.*TeV );
78  verboseLevel = 0;
79  lowEnergyRecoilLimit = 100.*keV;
80  lowEnergyLimitQ = 0.0*GeV;
81  lowEnergyLimitHE = 0.0*GeV;
82  lowestEnergyLimit= 0.0*keV;
83  plabLowLimit = 20.0*MeV;
84 
86  fInTkin=0;
91 
93  fProjectile = 0;
95 
96  fEnergyBin = 200;
97  fBinT = 514; // 514; // 500; // 200;
98 
100 
101  fTableT = 0;
102  fOldTkin = 0.;
103  SetParameters();
104 
105  Initialise();
106 }
107 
108 
110 //
111 // test constructor
112 
113 
115  : G4HadronElastic("HadrHadrElastic")
116 {
117  SetMinEnergy( 1.*GeV );
118  SetMaxEnergy( 10000.*TeV );
119  verboseLevel = 0;
120  lowEnergyRecoilLimit = 100.*keV;
121  lowEnergyLimitQ = 0.0*GeV;
122  lowEnergyLimitHE = 0.0*GeV;
123  lowestEnergyLimit = 0.0*keV;
124  plabLowLimit = 20.0*MeV;
125 
127  fInTkin=0;
132 
133  fTarget = target;
134  fProjectile = projectile;
140 
141  fEnergyBin = 200;
142  fBinT = 514; // 200;
143 
145  fTableT = 0;
146  fOldTkin = 0.;
147 
148 
149  SetParameters();
150  SetParametersCMS( plab);
151 }
152 
153 
155 //
156 // constructor used for low mass diffraction
157 
158 
160  : G4HadronElastic("HadrHadrElastic")
161 {
162  SetMinEnergy( 1.*GeV );
163  SetMaxEnergy( 10000.*TeV );
164  verboseLevel = 0;
165  lowEnergyRecoilLimit = 100.*keV;
166  lowEnergyLimitQ = 0.0*GeV;
167  lowEnergyLimitHE = 0.0*GeV;
168  lowestEnergyLimit= 0.0*keV;
169  plabLowLimit = 20.0*MeV;
170 
172  fInTkin=0;
173 
174  fTarget = target; // later vmg
175  fProjectile = projectile;
180 
181  fTarget = G4Proton::Proton(); // later vmg
182  fProjectile = 0;
188 
189  fEnergyBin = 200;
190  fBinT = 514; // 514; // 500; // 200;
191 
193 
194  fTableT = 0;
195  fOldTkin = 0.;
196 
197  SetParameters();
198 }
199 
200 
201 
203 //
204 // Destructor
205 
207 {
208  if ( fEnergyVector ) {
209  delete fEnergyVector;
210  fEnergyVector = 0;
211  }
212 
213  for ( std::vector<G4PhysicsTable*>::iterator it = fBankT.begin();
214  it != fBankT.end(); ++it ) {
215  if ( (*it) ) (*it)->clearAndDestroy();
216  delete *it;
217  *it = 0;
218  }
219  fTableT = 0;
220  if(fHadrNuclXsc) delete fHadrNuclXsc;
221 }
222 
225 
226 
228 //
229 // Initialisation for given particle on the proton target
230 
232 {
233  // pp,pn
234 
237  fBankT.push_back(fTableT); // 0
238 
239  // pi+-p
240 
243  fBankT.push_back(fTableT); // 1
244  //K+-p
247  fBankT.push_back(fTableT); // 2
248 
249 }
250 
252 //
253 // Build for given particle and proton table of momentum transfers.
254 
255 void G4hhElastic::BuildTableT( G4ParticleDefinition* target, G4ParticleDefinition* projectile) // , G4double plab)
256 {
257  G4int iTkin, jTransfer;
258  G4double plab, Tkin, tMax;
259  G4double t1, t2, dt, delta = 0., sum = 0.;
260 
261  fTarget = target;
262  fProjectile = projectile;
267 
269  // G4HadronNucleonXsc* hnXsc = new G4HadronNucleonXsc();
271 
272  for( iTkin = 0; iTkin < fEnergyBin; iTkin++)
273  {
274  Tkin = fEnergyVector->GetLowEdgeEnergy(iTkin);
275  plab = std::sqrt( Tkin*( Tkin + 2*fMassProj ) );
276  // G4DynamicParticle* theDynamicParticle = new G4DynamicParticle(projectile,
277  // G4ParticleMomentum(0.,0.,1.),
278  // Tkin);
279  // fSigmaTot = fHadrNuclXsc->GetHadronNucleonXscNS( theDynamicParticle, target );
280 
281  SetParametersCMS( plab );
282 
283  tMax = 4.*fPcms*fPcms;
284  if( tMax > 15.*GeV*GeV ) tMax = 15.*GeV*GeV; // Check vs. energy ???
285 
287  sum = 0.;
288  dt = tMax/fBinT;
289 
290  // for(j = 1; j < fBinT; j++)
291 
292  for( jTransfer = fBinT-1; jTransfer >= 1; jTransfer--)
293  {
294  t1 = dt*(jTransfer-1);
295  t2 = t1 + dt;
296 
297  if( fMassProj > 900.*MeV ) // pp, pn
298  {
299  delta = integral.Legendre10(this, &G4hhElastic::GetdsdtF123, t1, t2);
300  // delta = integral.Legendre96(this, &G4hhElastic::GetdsdtF123, t1, t2);
301  }
302  else // pi+-p, K+-p
303  {
304  delta = integral.Legendre10(this, &G4hhElastic::GetdsdtF123qQgG, t1, t2);
305  // delta = integral.Legendre96(this, &G4hhElastic::GetdsdtF123qQgG, t1, t2);
306  }
307  sum += delta;
308  vectorT->PutValue( jTransfer-1, t1, sum ); // t2
309  }
310  // vectorT->PutValue( fBinT-1, dt*(fBinT-1), 0. ); // t2
311  fTableT->insertAt( iTkin, vectorT );
312  // delete theDynamicParticle;
313  }
314  // delete hnXsc;
315 
316  return;
317 }
318 
320 //
321 // Return inv momentum transfer -t > 0 from initialisation table
322 
324  G4int, G4int )
325 {
326  G4int iTkin, iTransfer;
327  G4double t, t2, position, m1 = aParticle->GetPDGMass();
328  G4double Tkin = std::sqrt(m1*m1+p*p) - m1;
329 
330  if( aParticle == G4Proton::Proton() || aParticle == G4Neutron::Neutron() )
331  {
332  fTableT = fBankT[0];
333  }
334  if( aParticle == G4PionPlus::PionPlus() || aParticle == G4PionMinus::PionMinus() )
335  {
336  fTableT = fBankT[1];
337  }
338  if( aParticle == G4KaonPlus::KaonPlus() || aParticle == G4KaonMinus::KaonMinus() )
339  {
340  fTableT = fBankT[2];
341  }
342 
343  G4double delta = std::abs(Tkin - fOldTkin)/(Tkin + fOldTkin);
344  G4double deltaMax = 1.e-2;
345 
346  if ( delta < deltaMax ) iTkin = fInTkin;
347  else
348  {
349  for( iTkin = 0; iTkin < fEnergyBin; iTkin++)
350  {
351  if( Tkin < fEnergyVector->GetLowEdgeEnergy(iTkin) ) break;
352  }
353  }
354  if ( iTkin >= fEnergyBin ) iTkin = fEnergyBin-1; // Tkin is more then theMaxEnergy
355  if ( iTkin < 0 ) iTkin = 0; // against negative index, Tkin < theMinEnergy
356 
357  fOldTkin = Tkin;
358  fInTkin = iTkin;
359 
360  if (iTkin == fEnergyBin -1 || iTkin == 0 ) // the table edges
361  {
362  position = (*(*fTableT)(iTkin))(0)*G4UniformRand();
363 
364  // G4cout<<"position = "<<position<<G4endl;
365 
366  for(iTransfer = 0; iTransfer < fBinT-1; iTransfer++)
367  {
368  if( position >= (*(*fTableT)(iTkin))(iTransfer) ) break;
369  }
370  if (iTransfer >= fBinT-1) iTransfer = fBinT-2;
371 
372  // G4cout<<"iTransfer = "<<iTransfer<<G4endl;
373 
374  t = GetTransfer(iTkin, iTransfer, position);
375 
376  // G4cout<<"t = "<<t<<G4endl;
377  }
378  else // Tkin inside between energy table edges
379  {
380  // position = (*(*fTableT)(iTkin))(fBinT-2)*G4UniformRand();
381  position = (*(*fTableT)(iTkin))(0)*G4UniformRand();
382 
383  // G4cout<<"position = "<<position<<G4endl;
384 
385  for(iTransfer = 0; iTransfer < fBinT-1; iTransfer++)
386  {
387  // if( position < (*(*fTableT)(iTkin))(iTransfer) ) break;
388  if( position >= (*(*fTableT)(iTkin))(iTransfer) ) break;
389  }
390  if (iTransfer >= fBinT-1) iTransfer = fBinT-2;
391 
392  // G4cout<<"iTransfer = "<<iTransfer<<G4endl;
393 
394  t2 = GetTransfer(iTkin, iTransfer, position);
395  return t2;
396  /*
397  G4double t1, E1, E2, W, W1, W2;
398  // G4cout<<"t2 = "<<t2<<G4endl;
399 
400  E2 = fEnergyVector->GetLowEdgeEnergy(iTkin);
401 
402  // G4cout<<"E2 = "<<E2<<G4endl;
403 
404  iTkin--;
405 
406  // position = (*(*fTableT)(iTkin))(fBinT-2)*G4UniformRand();
407 
408  // G4cout<<"position = "<<position<<G4endl;
409 
410  for(iTransfer = 0; iTransfer < fBinT-1; iTransfer++)
411  {
412  // if( position < (*(*fTableT)(iTkin))(iTransfer) ) break;
413  if( position >= (*(*fTableT)(iTkin))(iTransfer) ) break;
414  }
415  if (iTransfer >= fBinT-1) iTransfer = fBinT-2;
416 
417  t1 = GetTransfer(iTkin, iTransfer, position);
418 
419  // G4cout<<"t1 = "<<t1<<G4endl;
420 
421  E1 = fEnergyVector->GetLowEdgeEnergy(iTkin);
422 
423  // G4cout<<"E1 = "<<E1<<G4endl;
424 
425  W = 1.0/(E2 - E1);
426  W1 = (E2 - Tkin)*W;
427  W2 = (Tkin - E1)*W;
428 
429  t = W1*t1 + W2*t2;
430  */
431  }
432  return t;
433 }
434 
435 
437 //
438 // Return inv momentum transfer -t > 0 from initialisation table
439 
441 {
442  G4int iTkin, iTransfer;
443  G4double t, position, m1 = aParticle->GetPDGMass();
444  G4double Tkin = std::sqrt(m1*m1+p*p) - m1;
445 
446  if( aParticle == G4Proton::Proton() || aParticle == G4Neutron::Neutron() )
447  {
448  fTableT = fBankT[0];
449  }
450  if( aParticle == G4PionPlus::PionPlus() || aParticle == G4PionMinus::PionMinus() )
451  {
452  fTableT = fBankT[1];
453  }
454  if( aParticle == G4KaonPlus::KaonPlus() || aParticle == G4KaonMinus::KaonMinus() )
455  {
456  fTableT = fBankT[2];
457  }
458  G4double delta = std::abs(Tkin - fOldTkin)/(Tkin + fOldTkin);
459  G4double deltaMax = 1.e-2;
460 
461  if ( delta < deltaMax ) iTkin = fInTkin;
462  else
463  {
464  for( iTkin = 0; iTkin < fEnergyBin; iTkin++ )
465  {
466  if( Tkin < fEnergyVector->GetLowEdgeEnergy(iTkin) ) break;
467  }
468  }
469  if ( iTkin >= fEnergyBin ) iTkin = fEnergyBin-1; // Tkin is more then theMaxEnergy
470  if ( iTkin < 0 ) iTkin = 0; // against negative index, Tkin < theMinEnergy
471 
472  fOldTkin = Tkin;
473  fInTkin = iTkin;
474 
475  if (iTkin == fEnergyBin -1 || iTkin == 0 ) // the table edges
476  {
477  position = (*(*fTableT)(iTkin))(0)*G4UniformRand();
478 
479  for(iTransfer = 0; iTransfer < fBinT-1; iTransfer++)
480  {
481  if( position >= (*(*fTableT)(iTkin))(iTransfer) ) break;
482  }
483  if (iTransfer >= fBinT-1) iTransfer = fBinT-2;
484 
485  t = GetTransfer(iTkin, iTransfer, position);
486 
487 
488  }
489  else // Tkin inside between energy table edges
490  {
491  G4double rand = G4UniformRand();
492  position = (*(*fTableT)(iTkin))(0)*rand;
493 
494  //
495  // (*fTableT)(iTkin)->GetLowEdgeEnergy(fBinT-2);
496  G4int sTransfer = 0, fTransfer = fBinT - 2, dTransfer = fTransfer - sTransfer;
497  G4double y2;
498 
499  for( iTransfer = 0; iTransfer < fBinT - 1; iTransfer++ )
500  {
501  // dTransfer %= 2;
502  dTransfer /= 2;
503  // dTransfer *= 0.5;
504  y2 = (*(*fTableT)(iTkin))( sTransfer + dTransfer );
505 
506  if( y2 > position ) sTransfer += dTransfer;
507 
508  // if( dTransfer <= 1 ) break;
509  if( dTransfer < 1 ) break;
510  }
511  t = (*fTableT)(iTkin)->GetLowEdgeEnergy(sTransfer); // +(-0.5+rand)*(*fTableT)(iTkin)->GetLowEdgeEnergy(3);
512  }
513  return t;
514 }
515 
516 
518 //
519 // Build for given particle and proton table of momentum transfers.
520 
522 {
523  G4int jTransfer;
524  G4double tMax; // , sQq, sQG;
525  G4double t1, t2, dt, delta = 0., sum = 0. ; // , threshold;
526 
527  fTarget = target;
528  fProjectile = projectile;
533  fSpp = fMassProj*fMassProj + fMassTarg*fMassTarg + 2.*fMassTarg*std::sqrt(plab*plab + fMassProj*fMassProj);
534  fPcms = std::sqrt( (fSpp - fMassSum2)*(fSpp - fMassDif2)/4./fSpp);
535 
536  G4cout<<"fMassTarg = "<<fMassTarg<<" MeV; fMassProj = "<<fMassProj<<" MeV"<<G4endl;
537  tMax = 4.*fPcms*fPcms;
538  if( tMax > 15.*GeV*GeV ) tMax = 15.*GeV*GeV; // Check vs. energy ???
539 
540 
542  fTableT = new G4PhysicsTable(1);
544 
545  sum = 0.;
546  dt = tMax/G4double(fBinT);
547  G4cout<<"s = "<<std::sqrt(fSpp)/GeV<<" GeV; fPcms = "<<fPcms/GeV
548  <<" GeV; qMax = "<<tMax/GeV/GeV<<" GeV2; dt = "<<dt/GeV/GeV<<" GeV2"<<G4endl;
549 
550  // G4cout<<"fRA = "<<fRA*GeV<<"; fRB = "<<fRB*GeV<<G4endl;
551 
552  // for(jTransfer = 1; jTransfer < fBinT; jTransfer++)
553  for( jTransfer = fBinT-1; jTransfer >= 1; jTransfer-- )
554  {
555  t1 = dt*(jTransfer-1);
556  t2 = t1 + dt;
557 
558  if( fMassProj > 900.*MeV ) // pp, pn
559  {
560  delta = integral.Legendre10(this, &G4hhElastic::GetdsdtF123, t1, t2);
561  // threshold = integral.Legendre96(this, &G4hhElastic::GetdsdtF123, t1, tMax);
562  }
563  else // pi+-p, K+-p
564  {
565  delta = integral.Legendre10(this, &G4hhElastic::GetdsdtF123qQgG, t1, t2);
566  // threshold = integral.Legendre96(this, &G4hhElastic::GetdsdtF123qQgG, t1, tMax);
567  // delta = integral.Legendre96(this, &G4hhElastic::GetdsdtF123, t1, t2);
568  }
569  sum += delta;
570  // G4cout<<delta<<"\t"<<sum<<"\t"<<threshold<<G4endl;
571 
572  // sQq = GetdsdtF123(q1);
573  // sQG = GetdsdtF123qQgG(q1);
574  // G4cout<<q1/GeV<<"\t"<<sQG*GeV*GeV/millibarn<<"\t"<<sQq*GeV*GeV/millibarn<<G4endl;
575  // G4cout<<"sum = "<<sum<<", ";
576 
577  vectorT->PutValue( jTransfer-1, t1, sum ); // t2
578  }
579  // vectorT->PutValue( fBinT-1, dt*(fBinT-1), 0. ); // t2
580  fTableT->insertAt( 0, vectorT );
581  fBankT.push_back( fTableT ); // 0
582 
583  // for(jTransfer = 0; jTransfer < fBinT-1; jTransfer++)
584  // G4cout<<(*(*fTableT)(0))(jTransfer)/sum<<"\t\t"<<G4Pow::GetInstance()->powN(2.,-jTransfer)<<G4endl;
585 
586  return;
587 }
588 
589 
591 //
592 // Return inv momentum transfer -t > 0 from initialisation table
593 
594 G4double G4hhElastic::SampleTest(G4double tMin ) // const G4ParticleDefinition* aParticle, )
595 {
596  G4int iTkin, iTransfer, iTmin;
597  G4double t, position;
598  // G4double qMin = std::sqrt(tMin);
599 
600  fTableT = fBankT[0];
601  iTkin = 0;
602 
603  for(iTransfer = 0; iTransfer < fBinT-1; iTransfer++)
604  {
605  // if( qMin <= (*fTableT)(iTkin)->GetLowEdgeEnergy(iTransfer) ) break;
606  if( tMin <= (*fTableT)(iTkin)->GetLowEdgeEnergy(iTransfer) ) break;
607  }
608  iTmin = iTransfer-1;
609  if(iTmin < 0 ) iTmin = 0;
610 
611  position = (*(*fTableT)(iTkin))(iTmin)*G4UniformRand();
612 
613  for( iTmin = 0; iTransfer < fBinT-1; iTransfer++)
614  {
615  if( position > (*(*fTableT)(iTkin))(iTransfer) ) break;
616  }
617  if (iTransfer >= fBinT-1) iTransfer = fBinT-2;
618 
619  t = GetTransfer(iTkin, iTransfer, position);
620 
621  return t;
622 }
623 
624 
626 //
627 // Check with PAI sampling
628 
629 G4double
631 {
632  G4double x1, x2, y1, y2, randTransfer, delta, mean, epsilon = 1.e-6;
633 
634  if( iTransfer == 0 )
635  {
636  randTransfer = (*fTableT)(iTkin)->GetLowEdgeEnergy(iTransfer);
637  // iTransfer++;
638  }
639  else
640  {
641  if ( iTransfer >= G4int((*fTableT)(iTkin)->GetVectorLength()) )
642  {
643  iTransfer = (*fTableT)(iTkin)->GetVectorLength() - 1;
644  }
645  y1 = (*(*fTableT)(iTkin))(iTransfer-1);
646  y2 = (*(*fTableT)(iTkin))(iTransfer);
647 
648  x1 = (*fTableT)(iTkin)->GetLowEdgeEnergy(iTransfer-1);
649  x2 = (*fTableT)(iTkin)->GetLowEdgeEnergy(iTransfer);
650 
651  delta = y2 - y1;
652  mean = y2 + y1;
653 
654  if ( x1 == x2 ) randTransfer = x2;
655  else
656  {
657  // if ( y1 == y2 )
658  if ( delta < epsilon*mean )
659  randTransfer = x1 + ( x2 - x1 )*G4UniformRand();
660  else randTransfer = x1 + ( position - y1 )*( x2 - x1 )/delta; // ( y2 - y1 );
661  }
662  }
663  return randTransfer;
664 }
665 
667 {
668  // sqrt(fSpp) in GeV, fRA in 1/GeV, fRB in 1/GeV, fBq, fBQ, fImCof
669 
670  { 2.76754, 4.8, 4.8, 0.05, 0.742441, 10.5 }, // pp 3GeV/c
671  { 3.07744, 5.4, 5.4, 0.02, 0.83818, 6.5 }, // pp 4GeV/c
672  { 3.36305, 5.2, 5.2, 0.02, 0.838893, 7.5 }, // np 5GeV/c
673  { 4.32941, 6, 6, 0.03, 0.769389, 7.5 }, // np 9 GeV/c
674  { 4.62126, 6, 6, 0.03, 0.770111, 6.5 }, // pp 10.4 GeV/c
675 
676  { 5.47416, 4.5, 4.5, 0.03, 0.813185, 7.5 }, // np 15 GeV/c
677  { 6.15088, 6.5, 6.5, 0.02, 0.799539, 6.5 }, // pp 19.2 GeV/c
678  { 6.77474, 5.2, 5.2, 0.03, 0.784901, 7.5 }, // np 23.5 GeV/c
679  { 9.77775, 7, 7, 0.03, 0.742531, 6.5 }, // pp 50 GeV/c
680  // {9.77775, 7, 7, 0.011, 0.84419, 4.5 }, // pp 50 GeV/c
681  { 10.4728, 5.2, 5.2, 0.03, 0.780439, 7.5 }, // np 57.5 GeV/c
682 
683  { 13.7631, 7, 7, 0.008, 0.8664, 5.0 }, // pp 100 GeV/c
684  { 19.4184, 6.8, 6.8, 0.009, 0.861337, 2.5 }, // pp 200 GeV/c
685  { 23.5, 6.8, 6.8, 0.007, 0.878112, 1.5 }, // pp 23.5 GeV
686  // {24.1362, 6.4, 6.4, 0.09, 0.576215, 7.5 }, // np 309.5 GeV/c
687  { 24.1362, 7.2, 7.2, 0.008, 0.864745, 5.5 },
688  { 52.8, 6.8, 6.8, 0.008, 0.871929, 1.5 }, // pp 58.2 GeV
689 
690  { 546, 7.4, 7.4, 0.013, 0.845877, 5.5 }, // pb-p 546 GeV
691  { 1960, 7.8, 7.8, 0.022, 0.809062, 7.5 }, // pb-p 1960 GeV
692  { 7000, 8, 8, 0.024, 0.820441, 5.5 } // pp TOTEM
693 
694 };
695 
697 
699 {
700  // sqrt(fSpp) in GeV, fRA in 1/GeV, fRB in 1/GeV, fBq, fBQ, fImCof
701 
702  { 2.5627, 3.8, 3.3, 0.22, 0.222, 1.5 }, // pipp 3.017 GeV/c
703  { 2.93928, 4.3, 3.8, 0.2, 0.250601, 1.3 }, // pipp 4.122 GeV/c
704  { 3.22326, 4.8, 4.3, 0.13, 0.32751, 2.5 }, // pipp 5.055 GeV/c
705  { 7.80704, 5.5, 5, 0.13, 0.340631, 2.5 }, // pipp 32 GeV/c
706  { 9.7328, 5, 4.5, 0.05, 0.416319, 5.5 }, // pipp 50 GeV/c
707 
708  { 13.7315, 5.3, 4.8, 0.05, 0.418426, 5.5 }, // pipp 100 GeV/c
709  { 16.6359, 6.3, 5.8, 0.05, 0.423817, 5.5 }, // pipp 147 GeV/c
710  { 19.3961, 5, 4.5, 0.05, 0.413477, 3.5 } // pimp 200 GeV/c
711 
712 };
713 
714 //
715 //
G4double Legendre10(T &typeT, F f, G4double a, G4double b)
void SetParameters()
Definition: G4hhElastic.hh:273
void SetParametersCMS(G4double plab)
Definition: G4hhElastic.hh:318
static const double MeV
Definition: G4SIunits.hh:211
G4ParticleDefinition * thePionMinus
Definition: G4hhElastic.hh:101
virtual ~G4hhElastic()
Definition: G4hhElastic.cc:206
void PutValue(size_t binNumber, G4double binValue, G4double dataValue)
G4PhysicsLogVector * fEnergyVector
Definition: G4hhElastic.hh:113
G4double fOldTkin
Definition: G4hhElastic.hh:246
static const G4double theNuclNuclData[18][6]
Definition: G4hhElastic.hh:247
G4double lowEnergyLimitQ
Definition: G4hhElastic.hh:106
G4double lowEnergyRecoilLimit
Definition: G4hhElastic.hh:104
G4double fMassProj
Definition: G4hhElastic.hh:126
G4double GetLowEdgeEnergy(size_t binNumber) const
G4double fSpp
Definition: G4hhElastic.hh:159
int G4int
Definition: G4Types.hh:78
G4double lowestEnergyLimit
Definition: G4hhElastic.hh:107
G4ParticleDefinition * theProton
Definition: G4hhElastic.hh:98
static G4KaonMinus * KaonMinus()
Definition: G4KaonMinus.cc:113
void BuildTableT(G4ParticleDefinition *target, G4ParticleDefinition *projectile)
Definition: G4hhElastic.cc:255
std::vector< G4PhysicsTable * > fBankT
Definition: G4hhElastic.hh:115
void SetMinEnergy(G4double anEnergy)
void BuildTableTest(G4ParticleDefinition *target, G4ParticleDefinition *projectile, G4double plab)
Definition: G4hhElastic.cc:521
#define position
Definition: xmlparse.cc:622
#define G4UniformRand()
Definition: Randomize.hh:97
G4GLOB_DLL std::ostream G4cout
G4double GetTransfer(G4int iMomentum, G4int iTransfer, G4double position)
Definition: G4hhElastic.cc:630
G4double lowEnergyLimitHE
Definition: G4hhElastic.hh:105
G4double fOptRatio
Definition: G4hhElastic.hh:158
G4double fPcms
Definition: G4hhElastic.hh:160
G4HadronNucleonXsc * fHadrNuclXsc
Definition: G4hhElastic.hh:249
static G4Proton * Proton()
Definition: G4Proton.cc:93
static G4PionPlus * PionPlus()
Definition: G4PionPlus.cc:98
G4double GetdsdtF123qQgG(G4double q)
Definition: G4hhElastic.hh:748
static const double GeV
Definition: G4SIunits.hh:214
G4int fEnergyBin
Definition: G4hhElastic.hh:110
G4double GetdsdtF123(G4double q)
G4ParticleDefinition * fProjectile
Definition: G4hhElastic.hh:97
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104
G4double fMassSum2
Definition: G4hhElastic.hh:127
G4double SampleInvariantT(const G4ParticleDefinition *p, G4double plab, G4int, G4int)
Definition: G4hhElastic.cc:323
G4PhysicsTable * fTableT
Definition: G4hhElastic.hh:114
G4double GetPDGMass() const
G4double fSigmaTot
Definition: G4hhElastic.hh:154
G4double SampleBisectionalT(const G4ParticleDefinition *p, G4double plab)
Definition: G4hhElastic.cc:440
static G4PionMinus * PionMinus()
Definition: G4PionMinus.cc:98
G4double fMassDif2
Definition: G4hhElastic.hh:128
void insertAt(size_t, G4PhysicsVector *)
void SetMaxEnergy(const G4double anEnergy)
G4double fMassTarg
Definition: G4hhElastic.hh:125
#define G4endl
Definition: G4ios.hh:61
G4ParticleDefinition * thePionPlus
Definition: G4hhElastic.hh:100
static const double TeV
Definition: G4SIunits.hh:215
static const G4double thePiKaNuclData[8][6]
Definition: G4hhElastic.hh:248
static const double keV
Definition: G4SIunits.hh:213
void Initialise()
Definition: G4hhElastic.cc:231
double G4double
Definition: G4Types.hh:76
static G4KaonPlus * KaonPlus()
Definition: G4KaonPlus.cc:113
G4ParticleDefinition * fTarget
Definition: G4hhElastic.hh:96
G4ParticleDefinition * theNeutron
Definition: G4hhElastic.hh:99
G4double plabLowLimit
Definition: G4hhElastic.hh:108
double epsilon(double density, double temperature)
G4double SampleTest(G4double tMin)
Definition: G4hhElastic.cc:594
G4double fRhoReIm
Definition: G4hhElastic.hh:150