BMPTCalc Class Reference

#include <BMPTCalc.h>

List of all members.

Public Member Functions

 BMPTCalc ()
 BMPTCalc (BMPTConfig *)
 ~BMPTCalc ()
double XSec (BMPTEvent *, BMPTConfig *config=0)
double Reweight (BMPTEvent *, BMPTConfig *, BMPTConfig *config=0)

Protected Member Functions

double YLD (BMPTEvent *, BMPTConfig *config=0)
double FZ (BMPTEvent *, BMPTConfig *config=0)
double AH (BMPTEvent *, BMPTConfig *config=0)
double ZPRIME (BMPTEvent *)

Protected Attributes

BMPTConfig fConfig

Detailed Description

Definition at line 7 of file BMPTCalc.h.


Constructor & Destructor Documentation

BMPTCalc::BMPTCalc (  ) 

Definition at line 9 of file BMPTCalc.cxx.

00010 {
00011 }

BMPTCalc::BMPTCalc ( BMPTConfig config  ) 

Definition at line 14 of file BMPTCalc.cxx.

References fConfig.

00015 {
00016   fConfig = *config;
00017 }

BMPTCalc::~BMPTCalc (  ) 

Definition at line 20 of file BMPTCalc.cxx.

00021 {
00022 
00023 }


Member Function Documentation

double BMPTCalc::AH ( BMPTEvent ev,
BMPTConfig config = 0 
) [protected]

Definition at line 78 of file BMPTCalc.cxx.

References fConfig, BMPTConfig::GetBEAM_P(), BMPTEvent::Mass(), BMPTEvent::Momentum(), and BMPTEvent::pid.

Referenced by FZ().

00079 {
00080   
00081   //Factor to account for tertiary production See Eqn. 17 and Table 3
00082   BMPTConfig *conf = &fConfig;
00083   if(config!=0) conf = config;
00084 
00085   double x_lab = sqrt(ev->Momentum()*ev->Momentum() + 
00086                       ev->Mass()*ev->Mass())/conf->GetBEAM_P();
00087 
00088   //Pions:
00089   if(ev->pid==8 || ev->pid==9) {
00090     double ATertiaryH = 0.80;
00091     double BTertiaryH = 7.30;
00092     return ATertiaryH * TMath::Power(1.0 - x_lab,BTertiaryH);
00093   }
00094   
00095   //Kaons:
00096   if(ev->pid==10 || ev->pid==11 || 
00097      ev->pid==12 || ev->pid==16){
00098     double ATertiaryH = 1.56;
00099     double BTertiaryH = 10.1;
00100     return ATertiaryH * TMath::Power(1.0 - x_lab,BTertiaryH);
00101   }
00102 
00103   return 1.0;
00104 
00105 }

double BMPTCalc::FZ ( BMPTEvent ev,
BMPTConfig config = 0 
) [protected]

Definition at line 63 of file BMPTCalc.cxx.

References AH(), fConfig, BMPTConfig::GetLAMBDA_P(), BMPTConfig::GetLAMBDA_S(), BMPTEvent::z, and ZPRIME().

Referenced by YLD().

00064 {
00065 
00066   BMPTConfig *conf = &fConfig;
00067   if(config!=0) conf = config;
00068 
00069   double fz = 
00070     ( TMath::Exp(-ev->z/conf->GetLAMBDA_P())/conf->GetLAMBDA_P() ) *
00071     ( ( 1.0 + this->AH(ev,config)*(ev->z/conf->GetLAMBDA_P())) ) *
00072     ( TMath::Exp( -this->ZPRIME(ev)/conf->GetLAMBDA_S() ) );
00073   return fz;
00074   
00075 }

double BMPTCalc::Reweight ( BMPTEvent ev,
BMPTConfig rwtConfig,
BMPTConfig config = 0 
)

Definition at line 220 of file BMPTCalc.cxx.

References XSec().

Referenced by BMPTWeightCalculator::GetWeight().

00222 {  
00223   if(!rwtConfig) return 1;
00224   if(!ev)        return 1;
00225 
00226   double x0 = XSec(ev,config);
00227   double x1 = XSec(ev,rwtConfig);
00228 
00229   if(x0!=0) return x1/x0;
00230   return 1;
00231 }

double BMPTCalc::XSec ( BMPTEvent ev,
BMPTConfig config = 0 
)

Definition at line 139 of file BMPTCalc.cxx.

References fConfig, BMPTConfig::GetA_BE(), BMPTConfig::GetA_TARGET(), BMPTConfig::GetALPHA(), BMPTConfig::GetBEAM_P(), BMPTConfig::GetBETA(), BMPTConfig::GetCPA(), BMPTConfig::GetCPB(), BMPTConfig::GetDELTA(), BMPTConfig::GetGAMMA(), BMPTConfig::GetR0(), BMPTConfig::GetR1(), BMPTConfig::GetSMA(), BMPTConfig::GetSMB(), BMPTEvent::pid, BMPTEvent::px, BMPTEvent::py, BMPTEvent::pz, and MuELoss::R.

Referenced by Reweight(), and YLD().

00140 {
00141   
00142   //Return a weight (E * d3sigma/dp3 ) for a particle produced in a
00143   //hadron-nucleus interaction according to the BMPT (hep-ph/0101163)
00144   //parameterization
00145   BMPTConfig *conf = &fConfig;
00146   if(config!=0) conf = config;
00147 
00148   double XF    = ev->pz/conf->GetBEAM_P();
00149   double XR    = XF;
00150   double PT    = sqrt(ev->px*ev->px + ev->py*ev->py);
00151 
00152   double CPA   = conf->GetCPA(ev->pid);
00153   double CPB   = conf->GetCPB(ev->pid);
00154   double SMA   = conf->GetSMA(ev->pid);
00155   double SMB   = conf->GetSMB(ev->pid);
00156   double ALPHA = conf->GetALPHA(ev->pid);
00157   double BETA  = conf->GetBETA(ev->pid);
00158   double GAMMA = conf->GetGAMMA(ev->pid);
00159   double DELTA = conf->GetDELTA(ev->pid);
00160   double R0    = conf->GetR0(ev->pid);
00161   double R1    = conf->GetR1(ev->pid);
00162 
00163   double A_PRIME = SMA/TMath::Power(XR,GAMMA);
00164   double B_PRIME = SMA*SMA/(2.0*TMath::Power(XR,DELTA));
00165 
00166   //Calculate the production cross-section for pi/K/p/pbar
00167   //Work in log's first to accomodate large dynamic range
00168   double ED3SDP3 = 0;
00169 
00170   if (ev->pid==8  || ev->pid==9  ||  // pi+ / pi-
00171       ev->pid==10 || ev->pid==11 ||  // K+/K-/K0S/K0L
00172       ev->pid==12 || ev->pid==16 ) {
00173     ED3SDP3 =
00174       (  TMath::Log(CPA) ) +
00175       (  ALPHA*TMath::Log(1.0 - XR) ) +
00176       (  TMath::Log(1.0 + CPB*XR) ) +
00177       ( -BETA*TMath::Log(XR) ) +
00178       (  TMath::Log( 1.0 + A_PRIME*PT + B_PRIME*PT*PT ) ) +
00179       ( -A_PRIME*PT );
00180   }
00181   else if (ev->pid==14) {      // proton
00182     ED3SDP3 =
00183       ( TMath::Log(CPA) ) +
00184       ( TMath::Log( 1.0 + CPB*XR) ) +
00185       ( SMB * PT * PT * TMath::Log(1.0 - XR) ) +
00186       ( TMath::Log( 1.0 + SMA*PT + (0.5*SMA*SMA)*PT*PT) ) +
00187       ( -SMA*PT );
00188   }
00189   else if (ev->pid==15) {       // anti-proton
00190     ED3SDP3 =
00191       ( TMath::Log(CPA) ) +
00192       ( ALPHA * TMath::Log(1.0 - XR ) ) +
00193       ( -BETA*TMath::Log(XR) ) +
00194       ( TMath::Log(1.0 + SMA*PT + (0.5*SMA*SMA)*PT*PT ) ) +
00195       ( -SMA*PT );
00196   }
00197 
00198   //Calculate the ratios of negatives to positives
00199   double R = 1.0;
00200   if(ev->pid==9) R = R0 * TMath::Power((1.0 + XR),R1);
00201   else if(ev->pid==10 || ev->pid==12 || 
00202           ev->pid==16) R = R0 * TMath::Power((1.0 - XR),R1);
00203     
00204   //Calculate production off of Be
00205   ED3SDP3 = TMath::Exp(ED3SDP3)/R;
00206   
00207   //K0's are a special case
00208   if(ev->pid==10 || ev->pid==16)
00209     ED3SDP3 = ED3SDP3 * ( 0.25*(R + 3.0) );
00210 
00211   //Scale to different target nuclei  
00212   ALPHA = (0.74-0.55*XF+0.26*XF*XF)*(0.98+0.21*PT*PT);
00213   ED3SDP3 = ED3SDP3*TMath::Power((conf->GetA_TARGET()/conf->GetA_BE()),ALPHA);
00214 
00215   return ED3SDP3;
00216 
00217 }

double BMPTCalc::YLD ( BMPTEvent ev,
BMPTConfig config = 0 
) [protected]

Definition at line 26 of file BMPTCalc.cxx.

References fConfig, FZ(), BMPTConfig::GetA_TARGET(), BMPTConfig::GetLAMBDA_P(), BMPTConfig::GetTARGET_RHO(), BMPTEvent::Mass(), BMPTEvent::px, BMPTEvent::py, BMPTEvent::pz, and XSec().

00027 {
00028 
00029   //Return yield of secondaries (tertiaries, etc.) produced as a
00030   //function of the secondary's energy, transverse momentum, and
00031   //distance along target. (Eqn. 12)
00032   //    E         Secondary energy (GeV)
00033   //    PID       Particle type (GEANT3 convention)
00034   //    PX        Secondary X momentum (GeV/c)
00035   //    PY        Secondary Y momentum (GeV/c)
00036   //    PZ        Secondary Z momentum (GeV/c)
00037   //    Z         Distance along target (cm)
00038 
00039   BMPTConfig *conf = &fConfig;
00040   if(config!=0) conf = config;
00041 
00042   double px = ev->px;
00043   double py = ev->py;
00044   double pz = ev->pz;
00045 
00046   double AvNo = 6.02e23;  //Avogadro's number
00047   double M = ev->Mass();
00048   double P = pz*sqrt((px/pz)*(px/pz) + (py/pz)*(py/pz) + 1.0);
00049   double E = P*sqrt((M/P)*(M/P) + 1.0);
00050 
00051   //Work in log's to extend dynamic range
00052   double DYDZ =
00053     TMath::Log(AvNo) + TMath::Log(conf->GetTARGET_RHO()) + 
00054     TMath::Log(conf->GetLAMBDA_P()) + 3.0*TMath::Log(P) + 
00055     TMath::Log(this->XSec(ev,config)) + 
00056     TMath::Log(this->FZ(ev,config)) - 
00057     TMath::Log(100.0) - TMath::Log(conf->GetA_TARGET()) - TMath::Log(E);
00058   return TMath::Exp(DYDZ);
00059 
00060 }

double BMPTCalc::ZPRIME ( BMPTEvent ev  )  [protected]

Definition at line 108 of file BMPTCalc.cxx.

References MuELoss::a, BMPTEvent::px, BMPTEvent::py, BMPTEvent::pz, BMPTEvent::x, BMPTEvent::y, and BMPTEvent::z.

Referenced by FZ().

00109 {
00110   //assume (0,0,-0.296) is front, centre of target
00111   double z0 = -0.296; //LE beam
00112   double tZ = 0.9;  //length of target (m)
00113   double tX = 6.4e-3;  //width of target (m)
00114   double tY = 20.0e-3; //height of target (m)
00115   double x1 = ev->x/100.;  //x,y,z are in cm
00116   double y1 = ev->y/100.;
00117   double z1 = ev->z/100.;
00118   double x2 = x1;
00119   double y2 = y1;
00120   double z2 = z1;
00121   double dxdz = ev->px/ev->pz;
00122   double dydz = ev->py/ev->pz;
00123   double a1 = (tX/2. - x1)/dxdz;
00124   double a2 = (-tX/2. - x1)/dxdz;
00125   double a = a1; if(a2>a1) a = a2; 
00126   double b1 = (tY/2. - y1)/dydz;
00127   double b2 = (-tY/2. - y1)/dydz;
00128   double b = b1; if(b2>b1) b = b2;
00129   double c = tZ - z0 - z1;
00130   if(c<a&&c<b) z2 += c;
00131   else if(a<c&&a<b) z2 += a;
00132   else if(b<a&&b<c) z2 += b;
00133   x2 += dxdz*(z2-z1);
00134   y2 += dydz*(z2-z1);
00135   return sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1) + (z2-z1)*(z2-z1));
00136 }


Member Data Documentation

Definition at line 12 of file BMPTCalc.h.

Referenced by AH(), BMPTCalc(), FZ(), XSec(), and YLD().


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

Generated on 2 Nov 2017 for loon by  doxygen 1.6.1