SwimdEdxTable Class Reference

#include <SwimdEdxTable.h>

List of all members.

Public Member Functions

virtual ~SwimdEdxTable ()
void FilldEdxTable (SwimGeo::SwimMaterial_t material)

Static Public Member Functions

static double GetdEdx (const SwimParticle &particle, SwimGeo::SwimMaterial_t material)

Private Member Functions

 SwimdEdxTable ()

Static Private Member Functions

static double CaldEdx (double p, SwimGeo::SwimMaterial_t material, double *dEdxTable)


Detailed Description

Definition at line 16 of file SwimdEdxTable.h.


Constructor & Destructor Documentation

virtual SwimdEdxTable::~SwimdEdxTable (  )  [inline, virtual]

Definition at line 19 of file SwimdEdxTable.h.

00019 { }

SwimdEdxTable::SwimdEdxTable (  )  [inline, private]

Definition at line 26 of file SwimdEdxTable.h.

00026 { }


Member Function Documentation

double SwimdEdxTable::CaldEdx ( double  p,
SwimGeo::SwimMaterial_t  material,
double *  dEdxTable 
) [static, private]

Definition at line 331 of file SwimdEdxTable.cxx.

References Munits::cm, Munits::cm2, Munits::g, SwimGeo::GetSwimMaterialDensity(), Munits::GeV, SwimGeo::kIron, SwimGeo::kScint, and Munits::m.

Referenced by GetdEdx().

00332 {
00333   int    i; // array index
00334   double p0,p1;
00335   double slope;
00336   double eLoss;
00337   double dEdxTableUnit = Munits::GeV/(Munits::g)*Munits::cm2;
00338   double density = SwimGeo::GetSwimMaterialDensity(material);
00339 
00340   // momentum (in GeV) are evenly distributed in log10
00341   // log10(p1) - log10(p0) = 0.0472440944881889757
00342   i = int((log10(p)+2.0)/0.0472440944881889757);
00343   if (i>=127)
00344     i = 126;
00345   p0 = pow(10, (-2.0 + 0.0472440944881889757*i));
00346   p1 = pow(10, (-2.0 + 0.0472440944881889757*(i+1)));
00347   slope = (dEdxTable[i+1]-dEdxTable[i])*dEdxTableUnit/
00348           ((p1-p0)*Munits::GeV);
00349 
00350   // eLoss unit: GeV/m
00351   eLoss = (density*(slope*(p-p0*Munits::GeV)
00352                    + dEdxTable[i]*dEdxTableUnit))*Munits::cm/Munits::m;
00353 
00354   if(material == SwimGeo::kIron){
00355     if(p>0) eLoss *= (1.005 + 0.005*log10(p));
00356     if(fabs(p)<0.1*Munits::GeV) eLoss *= 0.995;
00357   }
00358     
00359     if(material == SwimGeo::kScint){
00360       if(p>0) eLoss *= (1.0158 + 0.00511*log10(p));
00361     }
00362 
00363   
00364   return eLoss;
00365 }

void SwimdEdxTable::FilldEdxTable ( SwimGeo::SwimMaterial_t  material  ) 

Definition at line 372 of file SwimdEdxTable.cxx.

References MuELoss::a, SwimGeo::kIron, SwimGeo::kScint, Munits::m, and Mphysical::pi.

00372                                                                 {
00373   double logpMin = log10(0.01);
00374   double logpMax = log10(10000.);
00375   double logpTable[128];
00376   for (int n=0; n<128; ++n)
00377     logpTable[n] = logpMin + (logpMax-logpMin)*n/127;
00378 
00379   // energyTable units: GeV
00380   double energyTable[45] =
00381   {1.0,   2.0,   4.0,   6.0,   8.0,
00382    10.0,  15.0,  20.0,  30.0,  40.0,
00383    50.0,  60.0,  70.0,  80.0,  90.0,
00384    100.,  120.,  140.,  160.,  180.,
00385    200.,  220.,  240.,  260.,  280.,
00386    300.,  350.,  400.,  450.,  500.,
00387    600.,  700.,  800.,  900.,  1000.,
00388    1500., 2000., 3000., 4000., 5000.,
00389    6000., 7000., 8000., 9000., 10000.};
00390 
00391   // eLossTable units: GeV*cm^2/g
00392   double eLossTableScint[45] =
00393   {0.002027, 0.002147, 0.002265, 0.002330, 0.002375,
00394    0.002409, 0.002470, 0.002514, 0.002581, 0.002633, 
00395    0.002677, 0.002718, 0.002756, 0.002792, 0.002826, 
00396    0.002860, 0.002925, 0.002987, 0.003049, 0.003109, 
00397    0.003169, 0.003228, 0.003287, 0.003345, 0.003403, 
00398    0.003461, 0.003605, 0.003749, 0.003892, 0.004035, 
00399    0.004320, 0.004606, 0.004891, 0.005178, 0.005464,
00400    0.006899, 0.008341, 0.01124,  0.01417,  0.01710,
00401    0.02005,  0.02300,  0.02597,  0.02893,  0.03191};
00402 
00403   double eLossTableFe[45] = 
00404   {0.001561, 0.001682, 0.001802, 0.001870, 0.001919,
00405    0.001958, 0.002032, 0.002091, 0.002189, 0.002275, 
00406    0.002357, 0.002436, 0.002513, 0.002590, 0.002666,
00407    0.002741, 0.002893, 0.003044, 0.003195, 0.003347, 
00408    0.003499, 0.003652, 0.003805, 0.003958, 0.004112, 
00409    0.004265, 0.004652, 0.005040, 0.005429, 0.005821,
00410    0.006607, 0.007395, 0.008189, 0.008985, 0.009782,
00411    0.01380,  0.01785,  0.02600,  0.03419,  0.04241,
00412    0.05065,  0.05892,  0.06719,  0.07548,  0.08377};
00413 
00414   double E;
00415   double p;
00416   double beta;
00417   double gamma;
00418   double X;
00419   double Em;
00420   double dEdx  = 0;
00421   double alpha = 1/137.036;
00422   double N     = 6.023e23;
00423   double me    = 0.510998902e-3;
00424   double mu    = 0.105658357;
00425   double lamda = 3.8616e-11;
00426   double pi    = 3.141592654;
00427   double delta  = 0.0;;
00428 
00429   double ZOverA = 0;
00430   double I      = 0;
00431   double C      = 0;
00432   double X0     = 0;
00433   double X1     = 0;
00434   double a      = 0;
00435   double m      = 0;
00436 
00437   if (material==SwimGeo::kScint) {
00438     // Scint information
00439     ZOverA = .5377;
00440     I      = 68.7e-9;
00441     C      = -3.300;
00442     X0     = .165;
00443     X1     = 2.503;
00444     a      = .165;
00445     m      = 3.222;
00446   }
00447   else if (material==SwimGeo::kIron) {
00448     // Fe information
00449     ZOverA = 26./55.847;
00450     I      = 286.0e-9;
00451     C      = -4.291;
00452     X0     = -.001;
00453     X1     = 3.153;
00454     a      = .147;
00455     m      = 2.963;
00456   }
00457 
00458   for (int i=0; i<128; ++i) {
00459     p = pow(10,logpTable[i]);
00460     E = TMath::Sqrt(p*p+mu*mu);
00461 
00462     if (p<1.0) {
00463       beta  = p/E;
00464       gamma = E/mu;
00465       X     = log10(beta*gamma);
00466       
00467       if (X>X0 && X<X1)
00468         delta = 4.6052*X+a*pow((X1-X),m)+C;
00469       else if (X>X1)
00470         delta = 4.6052*X+C;
00471 
00472       Em = 2*me*p*p/(me*me+mu*mu+2*me*E);
00473 
00474       dEdx = alpha*alpha*2*pi*N*lamda*lamda*ZOverA*me/(beta*beta)*
00475              (log(2*me*beta*beta*gamma*gamma*Em/(I*I))-2*beta*beta+Em*Em/(E*E)/4-delta);
00476     }
00477     else {
00478       int j;
00479       double slope;
00480 
00481       for (j=0; j<45; ++j)
00482         if (p<TMath::Sqrt(energyTable[j]*energyTable[j]-mu*mu))
00483           break;
00484       if (p>TMath::Sqrt(energyTable[44]*energyTable[44]-mu*mu))
00485         j = 44;
00486 
00487       double logp1 = log10(TMath::Sqrt(energyTable[j]*energyTable[j]-mu*mu));
00488       double logp2 = log10(TMath::Sqrt(energyTable[j-1]*energyTable[j-1]-mu*mu));
00489       if (material==SwimGeo::kScint) {
00490         slope = (log10(eLossTableScint[j])-log10(eLossTableScint[j-1]))/(logp1-logp2);
00491         dEdx = pow(10,(slope*(logpTable[i]-logp2)+log10(eLossTableScint[j-1])));
00492       }
00493       else if (material==SwimGeo::kIron) {
00494         slope = (log10(eLossTableFe[j])-log10(eLossTableFe[j-1]))/(logp1-logp2);
00495         dEdx = pow(10,(slope*(logpTable[i]-logp2)+log10(eLossTableFe[j-1])));
00496       }
00497     }
00498     cout << p << " " << dEdx << endl;
00499   }
00500 }

double SwimdEdxTable::GetdEdx ( const SwimParticle particle,
SwimGeo::SwimMaterial_t  material 
) [static]

Definition at line 19 of file SwimdEdxTable.cxx.

References CaldEdx(), SwimParticle::GetMomentumModulus(), Munits::GeV, SwimGeo::kAluminum, SwimGeo::kCarbon, SwimGeo::kCoil_far, SwimGeo::kCoil_near, SwimGeo::kCopper, SwimGeo::kHydrogen, SwimGeo::kIron, SwimGeo::kNitrogen, SwimGeo::kOxygen, SwimGeo::kScint, and SwimGeo::kWater.

Referenced by SwimdEdxAction::Perform().

00021 {
00022   double p = particle.GetMomentumModulus();
00023 
00024   if (material==SwimGeo::kScint) {
00025     static double dEdxTableScint[128] =
00026       {0.090744, 0.076389, 0.064217, 0.053925, 0.045244, 
00027        0.037938, 0.031804, 0.026664, 0.022364, 0.018775, 
00028        0.015784, 0.013296, 0.011229, 0.009517, 0.008099, 
00029        0.006929, 0.005964, 0.005171, 0.004521, 0.003989, 
00030        0.003555, 0.003204, 0.002919, 0.002691, 0.002510, 
00031        0.002366, 0.002248, 0.002156, 0.002086, 0.002032, 
00032        0.001994, 0.001966, 0.001949, 0.001939, 0.001935, 
00033        0.001937, 0.001942, 0.001951, 0.001962, 0.001975, 
00034        0.001990, 0.002006, 0.002023, 0.002040, 0.002058, 
00035        0.002077, 0.002096, 0.002115, 0.002134, 0.002153, 
00036        0.002171, 0.002189, 0.002207, 0.002226, 0.002245, 
00037        0.002264, 0.002281, 0.002298, 0.002316, 0.002333, 
00038        0.002350, 0.002367, 0.002384, 0.002401, 0.002417, 
00039        0.002433, 0.002450, 0.002466, 0.002483, 0.002499, 
00040        0.002516, 0.002534, 0.002552, 0.002570, 0.002589, 
00041        0.002608, 0.002628, 0.002649, 0.002671, 0.002694, 
00042        0.002719, 0.002746, 0.002774, 0.002804, 0.002837, 
00043        0.002873, 0.002912, 0.002954, 0.002999, 0.003050, 
00044        0.003105, 0.003167, 0.003234, 0.003309, 0.003392, 
00045        0.003484, 0.003586, 0.003700, 0.003826, 0.003966,
00046        0.004124, 0.004296, 0.004492, 0.004707, 0.004947, 
00047        0.005217, 0.005521, 0.005878, 0.006257, 0.006661, 
00048        0.007120, 0.007650, 0.008219, 0.008889, 0.009629, 
00049        0.010432, 0.011307, 0.012342, 0.013472, 0.014730, 
00050        0.016144, 0.017715, 0.019479, 0.021448, 0.023643, 
00051        0.026103, 0.028839, 0.031910};
00052 
00053     return(SwimdEdxTable::CaldEdx(p, material, dEdxTableScint));
00054   }
00055   else if (material==SwimGeo::kIron) {
00056     static double dEdxTableFe[128] =
00057       {0.055599, 0.047622, 0.040664, 0.034633, 0.029434, 
00058        0.024973, 0.021162, 0.017918, 0.015166, 0.012839, 
00059        0.010878, 0.009229, 0.007846, 0.006690, 0.005726, 
00060        0.004924, 0.004259, 0.003710, 0.003257, 0.002885, 
00061        0.002581, 0.002334, 0.002116, 0.001954, 0.001824, 
00062        0.001722, 0.001641, 0.001580, 0.001533, 0.001499, 
00063        0.001476, 0.001461, 0.001453, 0.001450, 0.001452, 
00064        0.001458, 0.001467, 0.001478, 0.001492, 0.001506, 
00065        0.001522, 0.001539, 0.001556, 0.001574, 0.001593, 
00066        0.001611, 0.001630, 0.001649, 0.001668, 0.001688, 
00067        0.001706, 0.001724, 0.001743, 0.001762, 0.001781, 
00068        0.001801, 0.001819, 0.001837, 0.001855, 0.001874, 
00069        0.001892, 0.001911, 0.001929, 0.001948, 0.001968, 
00070        0.001987, 0.002007, 0.002027, 0.002049, 0.002071, 
00071        0.002094, 0.002120, 0.002146, 0.002173, 0.002202, 
00072        0.002234, 0.002267, 0.002305, 0.002345, 0.002390, 
00073        0.002438, 0.002492, 0.002551, 0.002617, 0.002689, 
00074        0.002771, 0.002861, 0.002962, 0.003073, 0.003197, 
00075        0.003337, 0.003493, 0.003668, 0.003864, 0.004082, 
00076        0.004327, 0.004600, 0.004907, 0.005248, 0.005631, 
00077        0.006063, 0.006539, 0.007076, 0.007674, 0.008343, 
00078        0.009092, 0.009934, 0.010894, 0.011948, 0.013104, 
00079        0.014403, 0.015875, 0.017497, 0.019341, 0.021394, 
00080        0.023665, 0.026183, 0.029039, 0.032207, 0.035744, 
00081        0.039702, 0.044114, 0.049044, 0.054555, 0.060704, 
00082        0.067561, 0.075225, 0.083770};
00083 
00084     return(SwimdEdxTable::CaldEdx(p,material, dEdxTableFe));
00085   }
00086   else if( material==SwimGeo::kAluminum ) {
00087     static double dEdxTableAl[128] =
00088       {0.066606, 0.056594, 0.047979, 0.040601, 0.034306,
00089        0.028953, 0.024417, 0.020583, 0.017352, 0.014636,
00090        0.012358, 0.010452, 0.008861, 0.007535, 0.006434,
00091        0.005520, 0.004765, 0.004142, 0.003630, 0.003210,
00092        0.002867, 0.002589, 0.002364, 0.002183, 0.002039,
00093        0.001926, 0.001827, 0.001759, 0.001708, 0.001671,
00094        0.001645, 0.001628, 0.001618, 0.001615, 0.001616,
00095        0.001622, 0.001630, 0.001641, 0.001654, 0.001669,
00096        0.001685, 0.001702, 0.001719, 0.001736, 0.001754,
00097        0.001773, 0.001792, 0.001811, 0.001830, 0.001848,
00098        0.001866, 0.001884, 0.001902, 0.001920, 0.001938,
00099        0.001957, 0.001974, 0.001991, 0.002008, 0.002025,
00100        0.002042, 0.002058, 0.002075, 0.002092, 0.002108,
00101        0.002125, 0.002142, 0.002159, 0.002177, 0.002195,
00102        0.002214, 0.002233, 0.002253, 0.002273, 0.002294,
00103        0.002318, 0.002342, 0.002368, 0.002394, 0.002425,
00104        0.002458, 0.002494, 0.002533, 0.002575, 0.002621,
00105        0.002673, 0.002730, 0.002792, 0.002861, 0.002937,
00106        0.003023, 0.003117, 0.003224, 0.003341, 0.003472,
00107        0.003620, 0.003783, 0.003966, 0.004170, 0.004397,
00108        0.004653, 0.004934, 0.005254, 0.005608, 0.006003,
00109        0.006444, 0.006944, 0.007520, 0.008143, 0.008819,
00110        0.009582, 0.010453, 0.011404, 0.012501, 0.013719,
00111        0.015056, 0.016529, 0.018221, 0.020088, 0.022172,
00112        0.024514, 0.027120, 0.030033, 0.033292, 0.036926,
00113        0.040980, 0.045510, 0.050570};
00114     return(SwimdEdxTable::CaldEdx(p, material, dEdxTableAl));
00115   }
00116   else if( material==SwimGeo::kCopper ) {
00117     static double dEdxTableCu[128] =
00118       {0.052630, 0.045172, 0.038644, 0.032967, 0.028059,
00119        0.023838, 0.020225, 0.017143, 0.014525, 0.012307,
00120        0.010436, 0.008860, 0.007538, 0.006432, 0.005508,
00121        0.004739, 0.004102, 0.003574, 0.003139, 0.002782,
00122        0.002489, 0.002252, 0.002048, 0.001890, 0.001765,
00123        0.001665, 0.001588, 0.001528, 0.001483, 0.001450,
00124        0.001427, 0.001413, 0.001405, 0.001403, 0.001405,
00125        0.001411, 0.001420, 0.001431, 0.001444, 0.001459,
00126        0.001474, 0.001491, 0.001508, 0.001525, 0.001544,
00127        0.001562, 0.001581, 0.001600, 0.001619, 0.001639,
00128        0.001657, 0.001675, 0.001694, 0.001712, 0.001731,
00129        0.001751, 0.001769, 0.001787, 0.001806, 0.001825,
00130        0.001843, 0.001862, 0.001880, 0.001899, 0.001919,
00131        0.001940, 0.001960, 0.001981, 0.002003, 0.002026,
00132        0.002049, 0.002076, 0.002104, 0.002131, 0.002162,
00133        0.002196, 0.002231, 0.002271, 0.002313, 0.002361,
00134        0.002411, 0.002469, 0.002532, 0.002602, 0.002680,
00135        0.002767, 0.002863, 0.002971, 0.003090, 0.003223,
00136        0.003373, 0.003540, 0.003728, 0.003938, 0.004172,
00137        0.004436, 0.004728, 0.005058, 0.005426, 0.005837,
00138        0.006301, 0.006812, 0.007391, 0.008034, 0.008754,
00139        0.009558, 0.010463, 0.011493, 0.012626, 0.013870,
00140        0.015268, 0.016852, 0.018600, 0.020581, 0.022790,
00141        0.025235, 0.027946, 0.031017, 0.034426, 0.038230,
00142        0.042487, 0.047231, 0.052532, 0.058457, 0.065069,
00143        0.072449, 0.080686, 0.089870};
00144     
00145     return(SwimdEdxTable::CaldEdx(p, material, dEdxTableCu));
00146   }
00147   else if( material==SwimGeo::kHydrogen ) {
00148     static double dEdxTableH[128] =
00149       {0.206816, 0.172698, 0.144099, 0.120169, 0.100177,
00150        0.083501, 0.069612, 0.058058, 0.048461, 0.040500,
00151        0.033904, 0.028447, 0.023937, 0.020216, 0.017149,
00152        0.014627, 0.012555, 0.010857, 0.009468, 0.008335,
00153        0.007413, 0.006665, 0.006062, 0.005577, 0.005191,
00154        0.004885, 0.004645, 0.004461, 0.004321, 0.004218,
00155        0.004145, 0.004098, 0.004069, 0.004052, 0.004044,
00156        0.004045, 0.004051, 0.004063, 0.004079, 0.004098,
00157        0.004119, 0.004142, 0.004167, 0.004191, 0.004219,
00158        0.004247, 0.004275, 0.004303, 0.004332, 0.004361,
00159        0.004389, 0.004418, 0.004447, 0.004477, 0.004506,
00160        0.004536, 0.004564, 0.004593, 0.004622, 0.004651,
00161        0.004679, 0.004707, 0.004735, 0.004762, 0.004790,
00162        0.004817, 0.004844, 0.004872, 0.004898, 0.004925,
00163        0.004951, 0.004978, 0.005004, 0.005031, 0.005058,
00164        0.005085, 0.005112, 0.005140, 0.005169, 0.005198,
00165        0.005227, 0.005258, 0.005290, 0.005323, 0.005358,
00166        0.005394, 0.005433, 0.005473, 0.005516, 0.005563,
00167        0.005612, 0.005666, 0.005723, 0.005786, 0.005854,
00168        0.005929, 0.006011, 0.006100, 0.006198, 0.006306,
00169        0.006427, 0.006557, 0.006704, 0.006864, 0.007042,
00170        0.007239, 0.007464, 0.007732, 0.008010, 0.008297,
00171        0.008628, 0.009015, 0.009419, 0.009915, 0.010457,
00172        0.011029, 0.011639, 0.012392, 0.013194, 0.014091,
00173        0.015111, 0.016236, 0.017497, 0.018911, 0.020483,
00174        0.022237, 0.024215, 0.026420};
00175     
00176      return(SwimdEdxTable::CaldEdx(p, material, dEdxTableH));
00177   }
00178   else if( material==SwimGeo::kOxygen ) {
00179     static double dEdxTableO[128] =
00180       {0.078780, 0.066518, 0.056073, 0.047204, 0.039697,
00181        0.033358, 0.028020, 0.023534, 0.019773, 0.016626,
00182        0.013998, 0.011807, 0.009985, 0.008472, 0.007218,
00183        0.006181, 0.005326, 0.004621, 0.004043, 0.003571,
00184        0.003185, 0.002872, 0.002619, 0.002416, 0.002254,
00185        0.002126, 0.002027, 0.001951, 0.001894, 0.001853,
00186        0.001823, 0.001804, 0.001793, 0.001788, 0.001788,
00187        0.001793, 0.001801, 0.001812, 0.001824, 0.001839,
00188        0.001854, 0.001871, 0.001887, 0.001904, 0.001921,
00189        0.001939, 0.001957, 0.001976, 0.001994, 0.002012,
00190        0.002028, 0.002045, 0.002062, 0.002079, 0.002096,
00191        0.002113, 0.002129, 0.002144, 0.002160, 0.002176,
00192        0.002191, 0.002207, 0.002223, 0.002238, 0.002254,
00193        0.002269, 0.002285, 0.002300, 0.002317, 0.002333,
00194        0.002350, 0.002368, 0.002387, 0.002405, 0.002424,
00195        0.002445, 0.002466, 0.002489, 0.002513, 0.002539,
00196        0.002566, 0.002595, 0.002627, 0.002662, 0.002700,
00197        0.002742, 0.002787, 0.002838, 0.002892, 0.002952,
00198        0.003019, 0.003093, 0.003176, 0.003267, 0.003368,
00199        0.003482, 0.003607, 0.003748, 0.003903, 0.004077,
00200        0.004273, 0.004487, 0.004730, 0.004999, 0.005299,
00201        0.005634, 0.006013, 0.006454, 0.006927, 0.007436,
00202        0.008011, 0.008672, 0.009388, 0.010222, 0.011148,
00203        0.012157, 0.013263, 0.014547, 0.015956, 0.017531,
00204        0.019305, 0.021275, 0.023476, 0.025941, 0.028690,
00205        0.031757, 0.035186, 0.039030};
00206 
00207      return(SwimdEdxTable::CaldEdx(p, material, dEdxTableO));
00208   }
00209   else if( material==SwimGeo::kWater ) {
00210     static double dEdxTableH20[128]=
00211       {0.091993, 0.077501, 0.065198, 0.054784, 0.045992,
00212        0.038587, 0.032365, 0.027147, 0.022780, 0.019132,
00213        0.016090, 0.013558, 0.011455, 0.009711, 0.008267,
00214        0.007074, 0.006091, 0.005282, 0.004619, 0.004076,
00215        0.003634, 0.003275, 0.002985, 0.002752, 0.002567,
00216        0.002420, 0.002306, 0.002218, 0.002145, 0.002091,
00217        0.002051, 0.002023, 0.002005, 0.001995, 0.001991,
00218        0.001993, 0.001998, 0.002008, 0.002019, 0.002033,
00219        0.002049, 0.002065, 0.002083, 0.002101, 0.002120,
00220        0.002140, 0.002159, 0.002179, 0.002199, 0.002219,
00221        0.002238, 0.002257, 0.002276, 0.002295, 0.002315,
00222        0.002335, 0.002353, 0.002371, 0.002390, 0.002408,
00223        0.002426, 0.002444, 0.002462, 0.002479, 0.002497,
00224        0.002514, 0.002532, 0.002550, 0.002568, 0.002586,
00225        0.002604, 0.002624, 0.002643, 0.002662, 0.002683,
00226        0.002704, 0.002726, 0.002749, 0.002774, 0.002800,
00227        0.002827, 0.002857, 0.002889, 0.002924, 0.002961,
00228        0.003003, 0.003048, 0.003096, 0.003149, 0.003208,
00229        0.003273, 0.003344, 0.003424, 0.003513, 0.003610,
00230        0.003720, 0.003840, 0.003974, 0.004125, 0.004291,
00231        0.004478, 0.004682, 0.004915, 0.005171, 0.005457,
00232        0.005777, 0.006139, 0.006562, 0.007014, 0.007497,
00233        0.008045, 0.008675, 0.009356, 0.010152, 0.011034,
00234        0.011992, 0.013039, 0.014266, 0.015609, 0.017108,
00235        0.018796, 0.020670, 0.022770, 0.025117, 0.027732,
00236        0.027483, 0.003627, 0.037580};
00237 
00238     return(SwimdEdxTable::CaldEdx(p, material, dEdxTableH20));
00239   }
00240   else if( material==SwimGeo::kNitrogen ) {
00241     static double dEdxTableN[128] =
00242       {0.081280, 0.068531, 0.057696, 0.048513, 0.040753,
00243        0.034212, 0.028710, 0.024093, 0.020227, 0.016995,
00244        0.014299, 0.012053, 0.010187, 0.008639, 0.007356,
00245        0.006297, 0.005423, 0.004704, 0.004114, 0.003631,
00246        0.003238, 0.002919, 0.002661, 0.002454, 0.002289,
00247        0.002159, 0.002057, 0.001980, 0.001922, 0.001879,
00248        0.001850, 0.001830, 0.001818, 0.001813, 0.001813,
00249        0.001818, 0.001826, 0.001836, 0.001849, 0.001863,
00250        0.001879, 0.001895, 0.001912, 0.001929, 0.001946,
00251        0.001964, 0.001982, 0.002001, 0.002019, 0.002037,
00252        0.002053, 0.002070, 0.002087, 0.002104, 0.002121,
00253        0.002138, 0.002154, 0.002169, 0.002185, 0.002201,
00254        0.002216, 0.002231, 0.002246, 0.002261, 0.002277,
00255        0.002292, 0.002308, 0.002323, 0.002339, 0.002356,
00256        0.002372, 0.002390, 0.002407, 0.002425, 0.002444,
00257        0.002463, 0.002483, 0.002505, 0.002527, 0.002552,
00258        0.002578, 0.002606, 0.002636, 0.002668, 0.002703,
00259        0.002742, 0.002784, 0.002831, 0.002881, 0.002936,
00260        0.002998, 0.002099, 0.003141, 0.003225, 0.003317,
00261        0.003421, 0.003536, 0.003664, 0.003806, 0.003964,
00262        0.004143, 0.004338, 0.004559, 0.004803, 0.005076,
00263        0.005380, 0.005725, 0.006128, 0.006559, 0.007020,
00264        0.007543, 0.008145, 0.008794, 0.009554, 0.010397,
00265        0.011313, 0.012315, 0.013485, 0.014766, 0.016197,
00266        0.017807, 0.019597, 0.021601, 0.023841, 0.026339,
00267        0.029132, 0.032256, 0.035740};
00268 
00269     return(SwimdEdxTable::CaldEdx(p, material, dEdxTableN));
00270   }
00271   else if( material==SwimGeo::kCarbon ) {
00272     static double dEdxTableC[128] =
00273       {0.082111, 0.069200, 0.058234, 0.048947, 0.041103,
00274        0.034494, 0.028938, 0.024278, 0.020376, 0.017116,
00275        0.014398, 0.012134, 0.010253, 0.008693, 0.007402,
00276        0.006334, 0.005455, 0.004731, 0.004137, 0.003651,
00277        0.003256, 0.002934, 0.002429, 0.002244, 0.002096,
00278        0.001979, 0.001887, 0.001816, 0.001763, 0.001724,
00279        0.001697, 0.001679, 0.001670, 0.001666, 0.001668,
00280        0.001675, 0.001684, 0.001696, 0.001711, 0.001727,
00281        0.001744, 0.001763, 0.001782, 0.001842, 0.001860,
00282        0.001877, 0.001895, 0.001913, 0.001930, 0.001948,
00283        0.001965, 0.001982, 0.001999, 0.002017, 0.002034,
00284        0.002052, 0.002068, 0.002084, 0.002100, 0.002116,
00285        0.002132, 0.002148, 0.002164, 0.002179, 0.002195,
00286        0.002210, 0.002226, 0.002241, 0.002257, 0.002273,
00287        0.002289, 0.002306, 0.002323, 0.002340, 0.002358,
00288        0.002376, 0.002395, 0.002416, 0.002438, 0.002461,
00289        0.002485, 0.002511, 0.002539, 0.002569, 0.002601,
00290        0.002637, 0.002676, 0.002718, 0.002764, 0.002815,
00291        0.002871, 0.002933, 0.003001, 0.003078, 0.003162,
00292        0.003256, 0.003360, 0.003476, 0.003604, 0.003746,
00293        0.003907, 0.004083, 0.004283, 0.004503, 0.004748,
00294        0.005023, 0.005334, 0.005697, 0.006085, 0.006500,
00295        0.006969, 0.007511, 0.008095, 0.008779, 0.009536,
00296        0.010359, 0.011258, 0.012313, 0.013466, 0.009176,
00297        0.003280, 0.002969, 0.012916, 0.021635, 0.023886,
00298        0.026397, 0.029207, 0.032350};
00299 
00300     return(SwimdEdxTable::CaldEdx(p, material, dEdxTableC));
00301   }
00302   else if ( material==SwimGeo::kCoil_near) {
00303     // Fraction by weight 
00304     Float_t f_H20 = 0.085313;
00305     Float_t f_Al  = 0.914687;
00306   
00307     return
00308       f_Al*SwimdEdxTable::GetdEdx(particle,SwimGeo::kAluminum)+
00309       f_H20*SwimdEdxTable::GetdEdx(particle,SwimGeo::kWater);
00310   }
00311   else if ( material==SwimGeo::kCoil_far) {
00312     // materials in far detector coil foam from mix_farcoil.F
00313     Float_t f_H =  0.012814;                  
00314     Float_t f_C =  0.060215;
00315     Float_t f_N =  0.000197;
00316     Float_t f_O =  0.021346;
00317     Float_t f_Cu = 0.905425; 
00318     return 
00319       f_H*SwimdEdxTable::GetdEdx(particle,SwimGeo::kHydrogen)+
00320       f_C*SwimdEdxTable::GetdEdx(particle,SwimGeo::kCarbon) +
00321       f_N*SwimdEdxTable::GetdEdx(particle,SwimGeo::kNitrogen)+
00322       f_O*SwimdEdxTable::GetdEdx(particle,SwimGeo::kOxygen)  +
00323       f_Cu*SwimdEdxTable::GetdEdx(particle,SwimGeo::kCopper);
00324   }
00325   else
00326     return 0.0*Munits::GeV;
00327 }


The documentation for this class was generated from the following files:
Generated on Thu Apr 10 23:03:46 2014 for loon by  doxygen 1.4.7