Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

NueConvention Namespace Reference


Functions

Int_t DetermineClassType (Int_t inu, Int_t inunoosc, Int_t iaction)
int IsInsideNearFiducial_Nue_Extended (float x, float y, float z)
int IsInsideFarFiducial_Nue_Extended (float x, float y, float z)
int IsInsideNearFiducial_Nue_Standard (float x, float y, float z, bool isMC)
int IsInsideFarFiducial_Nue_Standard (float x, float y, float z, bool isMC)
int IsInsideNearFiducial_MRE_Standard (float x, float y, float z, bool isMC)
Int_t InPartialRegion (UShort_t plane, UShort_t strip)
float Oscillate (NtpMCTruth *mcth, float L, float dm2, float theta23, float UE32)
float Oscillate (ANtpTruthInfoBeam *ib, float L, float dm2, float theta23, float UE32)
float Oscillate (int nuFlavor, int nonOscNuFlavor, float Energy, float L, float dm2, float theta23, float U)
float Oscillate (ANtpTruthInfoBeamNue *ib)
float OscillateMatter (int nuFlavor, int nonOscNuFlavor, float Energy, float L, float dm2, float theta23, float UE32, float delta=0, int hierarchy=1)
float OscillateMatter (NtpMCTruth *mcth, float L, float dm2, float theta23, float UE32, float delta=0, int hierarchy=1)
float OscillateMatter (ANtpTruthInfoBeam *ib, float L, float dm2, float theta23, float UE32, float delta=0, int hierarchy=1)
float OscillateMatter (int nuFlavor, int nonOscNuFlavor, float Energy, double *par)
double ElecAppear (double *, double *)
double MuToTau (double *, double *)
double MuSurvive (double *, double *)
void NueEnergyCorrection (NueRecord *nr)
float NueEnergyCorrection (float mue, int release, int detector)

Variables

const Int_t NC = 0
const Int_t numu = 1
const Int_t nue = 2
const Int_t nutau = 3
const Int_t bnue = 4

Function Documentation

Int_t NueConvention::DetermineClassType (  Int_t  inu,
Int_t  inunoosc,
Int_t  iaction
) 
 

Definition at line 29 of file NueConvention.cxx.

Referenced by ANtpTruthInfoBeamAna::GetNueClass(), NueAnalysisCuts::IsBackground(), and NueAnalysisCuts::IsSignal().

00030 {
00031      int cType=ANtpDefVal::kInt;
00032 
00033      if(iaction ==0){ cType= ClassType::NC; // NC class
00034       }
00035      else if(iaction >=1){
00036        if(inu ==14 || inu==-14){ 
00037           cType=ClassType::numu;  // CC numu class
00038        }
00039        else
00040        if(inu==12 || inu==-12){
00041          if(inunoosc==14 || inunoosc==-14){
00042             cType=ClassType::nue; // CC osc nue class
00043          }
00044          else if(inunoosc==12 || inunoosc==-12){
00045             cType=ClassType::bnue; // CC beam nue class
00046          }
00047        }
00048        else if(inu==16 || inu==-16){
00049           cType= ClassType::nutau;  // CC nutau class
00050        }
00051     }
00052 
00053     return cType;
00054 }

double NueConvention::ElecAppear (  double *  ,
double * 
) 
 

Definition at line 4 of file OscProb.cxx.

Referenced by MuSurvive(), and OscillateMatter().

00005 {
00006 
00007   //x[0] = E
00008   //Params:
00009   //par[0] = L  
00010   //par[1] = th23
00011   //par[2] = th12
00012   //par[3] = th13
00013   //par[4] = dm23^2
00014   //par[5] = dm12^2
00015   //par[6] = density
00016   //par[7] = d_cp
00017   //par[8] = +/-;
00018 
00019   double E = x[0]; //energy
00020   double L = par[0]; //baseline
00021   double plusminus = int(par[8]);
00022 
00023   //standard rock:
00024   double density = par[6]; //g/cm^{3}
00025   double z_a = 0.5; //average Z/A
00026 
00027   double A_av = 6.02214199e23; //avogadro's number
00028   double invCmToeV = 1.97e-5; //convert 1/cm to eV
00029   double invCmToGeV = 1.97e-14; //convert 1/cm to GeV
00030   double invKmToeV = 1.97e-10; //convert 1/km to eV
00031 
00032   double Gf = 1.166391e-5; //fermi constant (GeV^{-2})
00033   double ne = z_a*A_av*density; //electron density #/cm^{3}
00034   double ne_natunits = ne*invCmToeV*invCmToGeV*invCmToGeV;
00035   //electron density with units Gev^{2} eV
00036   //Gev^{2} to cancel with GeV^{-2} in Gf
00037 
00038   double th23 = par[1];
00039   double th12 = par[2];
00040   double th13 = par[3];
00041 
00042   double sinsq_2th23 = TMath::Power(TMath::Sin(2.*th23),2);
00043   double sinsq_2th12 = TMath::Power(TMath::Sin(2.*th12),2);
00044   double sinsq_2th13 = TMath::Power(TMath::Sin(2.*th13),2);
00045   
00046   double cos_th23 = TMath::Cos(th23);
00047   double sin_th23 = TMath::Sin(th23);
00048   double cos_th13 = TMath::Cos(th13);
00049   
00050   double d_cp = par[7];
00051   
00052   double dmsq_23 = par[4];
00053   double dmsq_12 = par[5];
00054   double dmsq_13 = dmsq_23+dmsq_12; //eV^{2}
00055 
00056   //double Delta23 = dmsq_23/(2.*E*1e9); //eV
00057   double Delta12 = dmsq_12/(2.*E*1e9);
00058   double Delta13 = dmsq_13/(2.*E*1e9);
00059   
00060   double A = sqrt(2.)*Gf*ne_natunits; //eV
00061   double B = TMath::Abs(A - plusminus*Delta13); //eV
00062   double J = cos_th13*sqrt(sinsq_2th12)*sqrt(sinsq_2th13)*sqrt(sinsq_2th23);
00063 
00064   double p1 = sin_th23*sin_th23*sinsq_2th13*TMath::Power(Delta13/B,2)
00065     *TMath::Power(TMath::Sin(B*L/(invKmToeV*2.)),2);
00066   
00067   double p2 = 0;
00068   double p3 = 0;
00069   if(density!=0){
00070     p2 = cos_th23*cos_th23*sinsq_2th12*TMath::Power(Delta12/A,2)
00071       *TMath::Power(TMath::Sin(A*L/(invKmToeV*2.)),2);
00072     
00073     p3 = J*Delta12*Delta13*TMath::Sin(A*L/(invKmToeV*2.))
00074       *TMath::Sin(B*L/(invKmToeV*2.))
00075       *TMath::Cos(plusminus*d_cp + Delta13*L/(invKmToeV*2.))/(A*B);
00076   }
00077 
00078   if(p1+p2+p3>1) return 1;
00079   return p1+p2+p3;
00080 
00081 }

Int_t NueConvention::InPartialRegion (  UShort_t  plane,
UShort_t  strip
) 
 

Definition at line 380 of file NueConvention.cxx.

Referenced by ANtpTrackInfoAna::DetermineSigInOut(), and ANtpEventInfoAna::FillStripVariables().

00380                                                                   {
00381   // figure out if this (plane,strip) corresponds to something in
00382   // the partially instrumented region
00383   //
00384   // this region is defined as:
00385   // v planes: (strip<=4 || strip>=67)
00386   // partial u: (strip==0 || strip=63)
00387   // full u: (strip<=26 || strip>=88)
00388   //
00389   // if so, return 1
00390   // if not, return -1
00391   // if error, return 0
00392 
00393 
00394   // make a lookup ptype to hold the type of each plane
00395   // 1 = v partial   2 = u partial
00396   // 3 = v full   4 = u full
00397   // 0 = uninstrumented
00398   static bool first=true;
00399   static UShort_t ptype[282];
00400   if(first){
00401     ptype[0]=0;
00402     for(int i=1; i<=281; i++){
00403       if(i%2==0) ptype[i]=1; // a v plane
00404       else ptype[i]=2; // a u plane
00405       if((i-1)%5 == 0) ptype[i]+=2; // fully instrumented
00406       else if(i>120) ptype[i]=0; // not instrumented
00407     }
00408     first=false;
00409   }
00410   if(plane>281){
00411     //    std::cerr<<"InPartialRegion passed plane = "<<plane<<std::endl;
00412     return 0;
00413   }
00414   UShort_t pt = ptype[plane];
00415 
00416   Int_t result;
00417   switch(pt){
00418   case 1:
00419   case 3:
00420     if(strip<=4 || strip>=67) result=1;
00421     else result = -1;
00422     break;
00423   case 2:
00424     if(strip==0 || strip == 63) result=1;
00425     else result = -1;
00426     break;
00427   case 4:
00428     if(strip<=26 || strip>=88) result=1;
00429     else result = -1;
00430     break;
00431   case 0:
00432   default:
00433     result=0;
00434     break;
00435   }
00436   return result;
00437 
00438 }

int NueConvention::IsInsideFarFiducial_Nue_Extended (  float  x,
float  y,
float  z
) 
 

Definition at line 251 of file NueConvention.cxx.

Referenced by AnalysisInfoAna::IsFidAll(), NueAnalysisCuts::IsInsideFarFiducial(), and NueDisplayModule::PassCuts().

00252 {
00253   Float_t SuperModule1Beg =  0.35;
00254   Float_t SuperModule2Beg = 16.20;
00255   Float_t SuperModule1End = 14.57;
00256   Float_t SuperModule2End = 29.62;
00257 
00258   Float_t radialInner = 0.40;
00259   Float_t radialOuter = 3.87;
00260   Bool_t zContained = false;
00261   Bool_t xyContained = false;
00262   Float_t r = TMath::Sqrt(x*x + y*y);
00263 
00264   if( (z >= SuperModule1Beg && z <=SuperModule1End) ||
00265       (z >= SuperModule2Beg && z <=SuperModule2End) )
00266      zContained = true;
00267 
00268   if( r >= radialInner && r <= radialOuter)
00269      xyContained = true;
00270 
00271   Int_t retVal = 0;
00272   if(zContained && xyContained) retVal = 1;
00273   if(!zContained) retVal = -1;
00274   if(!xyContained) retVal -= 2;
00275 
00276   return retVal;  //  1 contained, -1 out of bounds z
00277                   //  -2 oob xy, -3 oob both
00278 }

int NueConvention::IsInsideFarFiducial_Nue_Standard (  float  x,
float  y,
float  z,
bool  isMC
) 
 

Definition at line 308 of file NueConvention.cxx.

Referenced by AnalysisInfoAna::Analyze(), and NueStandard::IsInFid().

00308                                                                                        {
00309 
00310   Float_t SuperModule1Beg =  0.49080;   // These are data values
00311   Float_t SuperModule2Beg = 16.27110;
00312   Float_t SuperModule1End = 14.29300;
00313   Float_t SuperModule2End = 27.98270;
00314 
00315   if(isMC){
00316     SuperModule1Beg =  0.47692;   // These are mc values
00317     SuperModule2Beg = 16.26470;
00318     SuperModule1End = 14.27860;
00319     SuperModule2End = 27.97240;
00320   }
00321                                                                               
00322   Float_t radialInner = 0.50;
00323   Float_t radialOuter = TMath::Sqrt(14.0);
00324   Bool_t zContained = false;
00325   Bool_t xyContained = false;
00326 
00327   Float_t r = TMath::Sqrt(x*x + y*y);
00328                                                                                 
00329   if( (z >= SuperModule1Beg && z <=SuperModule1End) ||
00330       (z >= SuperModule2Beg && z <=SuperModule2End) )
00331      zContained = true;
00332                                                                                 
00333   if( r >= radialInner && r <= radialOuter)
00334      xyContained = true;
00335                                                                                 
00336   Int_t retVal = 0;
00337   if(zContained && xyContained) retVal = 1;
00338   if(!zContained) retVal = -1;
00339   if(!xyContained) retVal -= 2;
00340                                                                                 
00341   return retVal;  //  1 contained, -1 out of bounds z
00342                   //  -2 oob xy, -3 oob both
00343 }

int NueConvention::IsInsideNearFiducial_MRE_Standard (  float  x,
float  y,
float  z,
bool  isMC
) 
 

Definition at line 345 of file NueConvention.cxx.

Referenced by NueStandard::PassesMRCCFiducial().

00347 {
00348   Float_t SuperModule1Beg = 0.5;  //Data and MC values 
00349                                   //  (according to DataUtil/infid.h on 10/02/07
00350   Float_t SuperModule1End = 5.5;
00351                                                                                 
00352   Float_t radialInner = 0;
00353   Float_t radialOuter = 1.2;
00354   Float_t xCenter = 1.4885;
00355   Float_t yCenter = 0.1397;
00356                                                                                 
00357   Bool_t zContained = false;
00358   Bool_t xyContained = false;
00359                                                                                 
00360   Float_t r = TMath::Sqrt((x-xCenter)*(x-xCenter) + (y-yCenter)*(y-yCenter));
00361                                                                                 
00362   if( z >= SuperModule1Beg && z <=SuperModule1End)
00363      zContained = true;
00364   if( r >= radialInner && r <= radialOuter)
00365      xyContained = true;
00366                                                                                 
00367                                                                                 
00368   Int_t retVal = 0;
00369   if(zContained && xyContained) retVal = 1;
00370   if(!zContained) retVal = -1;
00371   if(!xyContained) retVal -= 2;
00372                                                                                 
00373   return retVal;
00374 }

int NueConvention::IsInsideNearFiducial_Nue_Extended (  float  x,
float  y,
float  z
) 
 

Definition at line 226 of file NueConvention.cxx.

Referenced by AnalysisInfoAna::IsFidAll(), NueAnalysisCuts::IsInsideNearFiducial(), and NueDisplayModule::PassCuts().

00227 {
00228   Float_t SuperModule1Beg = 0.50;
00229   Float_t SuperModule1End = 6.50;
00230 
00231   Float_t radialInner = 0;
00232   Float_t radialOuter = 1;
00233   Float_t xCenter = 1.4885;
00234   Float_t yCenter = 0.1397;
00235   Bool_t zContained = false;
00236   Bool_t xyContained = false;
00237   Float_t r = TMath::Sqrt((x-xCenter)*(x-xCenter) + (y-yCenter)*(y-yCenter));
00238   if( z >= SuperModule1Beg && z <=SuperModule1End)
00239      zContained = true;
00240   if( r >= radialInner && r <= radialOuter)
00241      xyContained = true;
00242 
00243   Int_t retVal = 0;
00244   if(zContained && xyContained) retVal = 1;
00245   if(!zContained) retVal = -1;
00246   if(!xyContained) retVal -= 2;
00247   return retVal;
00248 }

int NueConvention::IsInsideNearFiducial_Nue_Standard (  float  x,
float  y,
float  z,
bool  isMC
) 
 

Definition at line 280 of file NueConvention.cxx.

Referenced by AnalysisInfoAna::Analyze(), and NueStandard::IsInFid().

00281 {
00282   Float_t SuperModule1Beg = 1.01080;  //Data and MC values (according to DataUtil/infid.h on 10/02/07
00283   Float_t SuperModule1End = 4.99059;
00284 
00285   Float_t radialInner = 0;
00286   Float_t radialOuter = 0.8;
00287   Float_t xCenter = 1.4885;
00288   Float_t yCenter = 0.1397;
00289 
00290   Bool_t zContained = false;
00291   Bool_t xyContained = false;
00292 
00293   Float_t r = TMath::Sqrt((x-xCenter)*(x-xCenter) + (y-yCenter)*(y-yCenter));
00294 
00295   if( z >= SuperModule1Beg && z <=SuperModule1End)
00296      zContained = true;
00297   if( r >= radialInner && r <= radialOuter)
00298      xyContained = true;
00299                                                                                                                                      
00300   Int_t retVal = 0;
00301   if(zContained && xyContained) retVal = 1;
00302   if(!zContained) retVal = -1;
00303   if(!xyContained) retVal -= 2;
00304 
00305   return retVal;
00306 }

double NueConvention::MuSurvive (  double *  ,
double * 
) 
 

Definition at line 131 of file OscProb.cxx.

References ElecAppear(), and MuToTau().

Referenced by OscillateMatter().

00132 {
00133   return 1. - NueConvention::MuToTau(x,par) - NueConvention::ElecAppear(x,par);
00134 }

double NueConvention::MuToTau (  double *  ,
double * 
) 
 

Definition at line 87 of file OscProb.cxx.

Referenced by MuSurvive(), and OscillateMatter().

00088 {
00089 
00090   //x[0] = E
00091   //Params:
00092   //par[0] = L
00093   //par[1] = th23
00094   //par[2] = th12
00095   //par[3] = th13
00096   //par[4] = dm23^2
00097   //par[5] = dm12^2
00098   //par[6] = density
00099   //par[7] = d_cp
00100   //par[8] = +/-;
00101 
00102   double E = x[0]; //energy
00103   double L = par[0]; //baseline
00104 
00105   double invKmToeV = 1.97e-10; //convert 1/km to eV
00106 
00107   //electron density with units Gev^{2} eV
00108   //Gev^{2} to cancel with GeV^{-2} in Gf
00109 
00110   double th23 = par[1];
00111   double th13 = par[3];
00112 
00113   double sinsq_2th23 = TMath::Power(TMath::Sin(2.*th23),2);
00114   double cos_th13 = TMath::Cos(th13);
00115   double dmsq_23 = par[4];
00116 
00117   double Delta23 = dmsq_23/(2.*E*1e9); //eV
00118 
00119   
00120 //  std::cout<<sinsq_2th23<<"   "<<TMath::Power(cos_th13,4)
00121 //      <<" "<<TMath::Sin(Delta23*L/(invKmToeV*2.))<<std::endl; 
00122  
00123   double p1 = sinsq_2th23*TMath::Power(cos_th13,4)
00124     *TMath::Power(TMath::Sin(Delta23*L/(invKmToeV*2.)),2);  //numu->nutau
00125 
00126   return p1;
00127 
00128 }

float NueConvention::NueEnergyCorrection (  float  mue,
int  release,
int  detector
) 
 

Definition at line 469 of file NueConvention.cxx.

References ReleaseType::GetRecoSubVersion(), ReleaseType::IsCarrot(), ReleaseType::IsCedar(), ReleaseType::IsDaikon(), and ReleaseType::IsData().

00470 {
00471         if(ReleaseType::IsCedar(type)&&ReleaseType::IsCarrot(type))//cedar carrot only
00472         {
00473                 float offset =   -1.52;
00474                 float slope  =   25.06;
00475                 return (meu-offset)/slope;
00476         }
00477         else if(ReleaseType::IsCedar(type)&&(ReleaseType::IsDaikon(type)||ReleaseType::IsData(type))&&(ReleaseType::GetRecoSubVersion(type)==0 || ReleaseType::GetRecoSubVersion(type)==1 ) ) //cedar daikon or data
00478         {
00479                 float offset =   -1.515;
00480                 float slope  =   24.86;
00481                 return (meu-offset)/slope;
00482         }
00483         else if(ReleaseType::IsCedar(type)&&(ReleaseType::IsDaikon(type)||ReleaseType::IsData(type))&&(ReleaseType::GetRecoSubVersion(type)==2 || ReleaseType::GetRecoSubVersion(type)==3)) //cedar_phy or cedar_phy_bhcurv, daikon or data
00484         {
00485                 if(detector==2) //far
00486                 {
00487                         float offset =   -1.466;
00488                         float slope  =   24.38;
00489                         return (meu-offset)/slope;
00490                 }
00491                 else if(detector==1) //near
00492                 {
00493                         float offset =   -3.133;
00494                         float slope  =   25.65;
00495                         return (meu-offset)/slope;
00496                 }       
00497         }
00498 
00499         //msg asked for ecal change but can't determine which to use
00500 
00501         throw -1;
00502         return -1;
00503 }

void NueConvention::NueEnergyCorrection (  NueRecord *  nr  ) 
 

Definition at line 446 of file NueConvention.cxx.

References VldContext::GetDetector(), RecRecordImp< T >::GetHeader(), NueHeader::GetRelease(), RecHeader::GetVldContext(), MSG, ANtpTrackInfoNue::phMeu, ANtpShowerInfoNue::phMeu, ANtpEventInfoNue::phMeu, ANtpTrackInfoNue::phNueGeV, ANtpShowerInfoNue::phNueGeV, ANtpEventInfoNue::phNueGeV, NueRecord::srevent, NueRecord::srshower, and NueRecord::srtrack.

Referenced by MiniMaker::EvaluateCuts(), NueExtrapolationJB::LoadFiles(), and NueModule::PassesBlindingCuts().

00447 {
00448 //scale all GeV values using MEU variables and constants contained in this method
00449 
00450 int release = nr->GetHeader().GetRelease();
00451 int detector = nr->GetHeader().GetVldContext().GetDetector();
00452 
00453 try
00454 {
00455 if(nr->srevent.phMeu>-9999)nr->srevent.phNueGeV=NueConvention::NueEnergyCorrection(nr->srevent.phMeu,release,detector);
00456 if(nr->srshower.phMeu>-9999)nr->srshower.phNueGeV=NueConvention::NueEnergyCorrection(nr->srshower.phMeu,release,detector);
00457 if(nr->srtrack.phMeu>-9999)nr->srtrack.phNueGeV=NueConvention::NueEnergyCorrection(nr->srtrack.phMeu,release,detector);
00458 
00459 }
00460 catch (int e)
00461 {
00462         MSG("NueConvention",Msg::kError)<<"NueEnergyCorrection - attempted to correct energy for unknown specification";
00463 }
00464 
00465 }

float NueConvention::Oscillate (  ANtpTruthInfoBeamNue *  ib  ) 
 

Definition at line 76 of file NueConvention.cxx.

References ANtpTruthInfoBeamNue::Baseline, ANtpTruthInfoBeamNue::DeltamSquared23, ANtpTruthInfoBeam::nonOscNuFlavor, ANtpTruthInfo::nuEnergy, ANtpTruthInfo::nuFlavor, Oscillate(), ANtpTruthInfoBeamNue::Theta23, and ANtpTruthInfoBeamNue::Ue3Squared.

00077 {
00078    return NueConvention::Oscillate(ib->nuFlavor, ib->nonOscNuFlavor,ib->nuEnergy,                                  ib->Baseline, ib->DeltamSquared23,
00079                                   ib->Theta23, ib->Ue3Squared);
00080 }

float NueConvention::Oscillate (  int  nuFlavor,
int  nonOscNuFlavor,
float  Energy,
float  L,
float  dm2,
float  theta23,
float  U
) 
 

Definition at line 102 of file NueConvention.cxx.

References abs(), and pow().

00104 {
00105    float oscterm = TMath::Sin(1.269*dm2*L/Energy);
00106 
00107 //   std::cout<<oscterm<<"  "<<pow(TMath::Sin(2*theta23),2)<<"  "
00108 //       <<pow((1-UE32),2)<<std::endl;
00109 
00110    float pmt=pow((1-UE32)*oscterm*TMath::Sin(2*theta23),2);
00111    float pme=pow(TMath::Sin(theta23),2)*4.*UE32*(1-UE32)*pow(oscterm,2);
00112    float pmm=1.-pmt-pme;
00113 
00114    float pet=4*(1-UE32)*UE32*pow(TMath::Cos(theta23)*oscterm,2);
00115    float pem=pow(TMath::Sin(theta23),2)*4.*UE32*(1-UE32)*pow(oscterm,2);
00116    float pee=1.-pet-pem;
00117 
00118 
00119    if(abs(nonOscNuFlavor)==14){
00120       if(abs(nuFlavor)==12){
00121          return pme;
00122       }
00123       else if(abs(nuFlavor)==14){
00124          return pmm;
00125       }
00126       else if(abs(nuFlavor)==16){
00127          return pmt;
00128       }
00129    }
00130    else if(abs(nonOscNuFlavor)==12){
00131       if(abs(nuFlavor)==12){
00132          return pee;
00133       }
00134       else if(abs(nuFlavor)==14){
00135          return pem;
00136       }
00137       else if(abs(nuFlavor)==16){
00138          return pet;
00139       }
00140    }
00141    else{
00142      std::cout<<"I don't know what to do with "<<nonOscNuFlavor
00143          <<" "<<nuFlavor<<" "<<pee<<std::endl;
00144    }
00145    return 0.;
00146 }

float NueConvention::Oscillate (  ANtpTruthInfoBeam *  ib,
float  L,
float  dm2,
float  theta23,
float  UE32
) 
 

Definition at line 69 of file NueConvention.cxx.

References ANtpTruthInfoBeam::nonOscNuFlavor, ANtpTruthInfo::nuEnergy, ANtpTruthInfo::nuFlavor, and Oscillate().

00071 {
00072   return NueConvention::Oscillate(ib->nuFlavor, ib->nonOscNuFlavor,ib->nuEnergy,
00073                                    L, dm2, theta23, UE32);
00074 }

float NueConvention::Oscillate (  NtpMCTruth *  mcth,
float  L,
float  dm2,
float  theta23,
float  UE32
) 
 

Definition at line 62 of file NueConvention.cxx.

References NtpMCTruth::inu, NtpMCTruth::inunoosc, and NtpMCTruth::p4neu.

Referenced by ANtpTruthInfoBeamAna::GetOscProb(), Oscillate(), TrimModule::Reco(), NueReweight::Reco(), MiniMaker::RunMiniMaker(), and Trimmer::RunTrimmer().

00064 {
00065     return NueConvention::Oscillate(mcth->inu, mcth->inunoosc, mcth->p4neu[3],
00066                                    L, dm2, theta23, UE32);
00067 }

float NueConvention::OscillateMatter (  int  nuFlavor,
int  nonOscNuFlavor,
float  Energy,
double *  par
) 
 

Definition at line 190 of file NueConvention.cxx.

References abs(), ElecAppear(), MuSurvive(), and MuToTau().

00192 {
00193                                                                                          
00194   Double_t x[1] = {};
00195   x[0] = Energy;
00196 
00197   Double_t L = par[0];
00198   Double_t th23 = par[1];     
00199   Double_t UE32 = TMath::Sin(par[3])*TMath::Sin(par[3]);
00200   Double_t ss2th13 = 4*UE32*(1-UE32);
00201   Double_t dm2 = par[4];
00202 
00203   float eToTau = ss2th13*TMath::Power(TMath::Cos(th23)
00204                      *TMath::Sin(1.27*dm2*L/x[0]),2);
00205                                                                                 
00206   if(abs(nonOscNuFlavor)==14) {
00207     if(abs(nuFlavor)==12) return NueConvention::ElecAppear(x,par);
00208     else if(abs(nuFlavor)==14) return NueConvention::MuSurvive(x,par);
00209     else if(abs(nuFlavor)==16) return NueConvention::MuToTau(x,par);
00210   }
00211   if(abs(nonOscNuFlavor)==12) {
00212     if(abs(nuFlavor)==12) return 1 - NueConvention::ElecAppear(x,par) - eToTau;
00213     else if(abs(nuFlavor)==14) return NueConvention::ElecAppear(x,par);
00214     else if(abs(nuFlavor)==16) return (eToTau);
00215   }
00216 
00217   return 0;
00218 }

float NueConvention::OscillateMatter (  ANtpTruthInfoBeam *  ib,
float  L,
float  dm2,
float  theta23,
float  UE32,
float  delta = 0,
int  hierarchy = 1
) 
 

Definition at line 92 of file NueConvention.cxx.

References ANtpTruthInfoBeam::nonOscNuFlavor, ANtpTruthInfo::nuEnergy, ANtpTruthInfo::nuFlavor, and OscillateMatter().

00095 {
00096   return NueConvention::OscillateMatter(ib->nuFlavor, ib->nonOscNuFlavor,
00097                                        ib->nuEnergy,
00098                                        L, dm2, theta23, UE32,
00099                                        delta,hierarchy);
00100 }

float NueConvention::OscillateMatter (  NtpMCTruth *  mcth,
float  L,
float  dm2,
float  theta23,
float  UE32,
float  delta = 0,
int  hierarchy = 1
) 
 

Definition at line 82 of file NueConvention.cxx.

References NtpMCTruth::inu, NtpMCTruth::inunoosc, OscillateMatter(), and NtpMCTruth::p4neu.

00085 {
00086   return NueConvention::OscillateMatter(mcth->inu, mcth->inunoosc,
00087                                        mcth->p4neu[3],
00088                                        L, dm2, theta23, UE32,
00089                                        delta,hierarchy);
00090 }

float NueConvention::OscillateMatter (  int  nuFlavor,
int  nonOscNuFlavor,
float  Energy,
float  L,
float  dm2,
float  theta23,
float  UE32,
float  delta = 0,
int  hierarchy = 1
) 
 

Definition at line 148 of file NueConvention.cxx.

References abs(), ElecAppear(), MuSurvive(), and MuToTau().

Referenced by NueSensitivity::OscillateMatter(), and OscillateMatter().

00152 {
00153 
00154   Double_t x[1] = {};
00155   x[0] = Energy;
00156   Double_t th12 = 0.554;              //sinsq2theta_12=0.8
00157   Double_t ss2th13 = 4*UE32*(1-UE32); //sinsq2theta_13
00158   Double_t dm2_12 = 8.2e-5; //best fit SNO
00159   Double_t dm2_23 = dm2;
00160 
00161   Double_t par[9] = {0};
00162   par[0] = L;
00163   par[1] = th23;
00164   par[2] = th12;
00165   par[3] = TMath::ASin(TMath::Sqrt(ss2th13))/2.;
00166   par[4] = hierarchy*dm2_23;
00167   par[5] = dm2_12;
00168   par[6] = 2.65; //standard rock density
00169   par[7] = delta;
00170   par[8] = 1;
00171   if(nonOscNuFlavor < 0) par[8] = -1;
00172 
00173   float eToTau = ss2th13*TMath::Power(TMath::Cos(th23)
00174                      *TMath::Sin(1.27*dm2*L/x[0]),2);
00175 
00176   if(abs(nonOscNuFlavor)==14) {
00177     if(abs(nuFlavor)==12) return NueConvention::ElecAppear(x,par);
00178     else if(abs(nuFlavor)==14) return NueConvention::MuSurvive(x,par);
00179     else if(abs(nuFlavor)==16) return NueConvention::MuToTau(x,par);
00180   }
00181   if(abs(nonOscNuFlavor)==12) {
00182     if(abs(nuFlavor)==12) return 1 - NueConvention::ElecAppear(x,par) - eToTau;
00183     else if(abs(nuFlavor)==14) return NueConvention::ElecAppear(x,par);
00184     else if(abs(nuFlavor)==16) return (eToTau);
00185   }
00186 
00187   return 0;
00188 }

Variable Documentation

const Int_t NueConvention::bnue = 4 [static]
 

Definition at line 34 of file NueConvention.h.

const Int_t NueConvention::NC = 0 [static]
 

Definition at line 30 of file NueConvention.h.

const Int_t NueConvention::nue = 2 [static]
 

Definition at line 32 of file NueConvention.h.

const Int_t NueConvention::numu = 1 [static]
 

Definition at line 31 of file NueConvention.h.

const Int_t NueConvention::nutau = 3 [static]
 

Definition at line 33 of file NueConvention.h.

Generated on Mon Jun 16 15:04:20 2008 for loon by  doxygen 1.3.9.1