#include <BMPTCalc.h>
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 |
|
|
Definition at line 9 of file BMPTCalc.cxx. 00010 {
00011 }
|
|
|
Definition at line 14 of file BMPTCalc.cxx. References fConfig. 00015 {
00016 fConfig = *config;
00017 }
|
|
|
Definition at line 20 of file BMPTCalc.cxx. 00021 {
00022
00023 }
|
|
||||||||||||
|
Definition at line 78 of file BMPTCalc.cxx. References 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 }
|
|
||||||||||||
|
Definition at line 63 of file BMPTCalc.cxx. References AH(), BMPTConfig::GetLAMBDA_P(), BMPTConfig::GetLAMBDA_S(), and BMPTEvent::z. 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 }
|
|
||||||||||||||||
|
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 }
|
|
||||||||||||
|
Definition at line 139 of file BMPTCalc.cxx. References 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, and BMPTEvent::pz. Referenced by Reweight(). 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 }
|
|
||||||||||||
|
Definition at line 26 of file BMPTCalc.cxx. References BMPTConfig::GetA_TARGET(), BMPTConfig::GetLAMBDA_P(), BMPTConfig::GetTARGET_RHO(), BMPTEvent::Mass(), BMPTEvent::px, BMPTEvent::py, and BMPTEvent::pz. 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 }
|
|
|
Definition at line 108 of file BMPTCalc.cxx. References BMPTEvent::px, BMPTEvent::py, BMPTEvent::pz, BMPTEvent::x, BMPTEvent::y, and BMPTEvent::z. 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 }
|
|
|
Definition at line 12 of file BMPTCalc.h. Referenced by BMPTCalc(). |
1.3.9.1