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 *)

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 27 of file NueConvention.cxx.

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

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

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 378 of file NueConvention.cxx.

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

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

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

Definition at line 249 of file NueConvention.cxx.

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

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

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

Definition at line 306 of file NueConvention.cxx.

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

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

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

Definition at line 343 of file NueConvention.cxx.

Referenced by NueStandard::PassesMREFiducial().

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

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

Definition at line 224 of file NueConvention.cxx.

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

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

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

Definition at line 278 of file NueConvention.cxx.

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

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

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::Oscillate (  ANtpTruthInfoBeamNue *  ib  ) 
 

Definition at line 74 of file NueConvention.cxx.

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

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

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

Definition at line 100 of file NueConvention.cxx.

References abs(), and pow().

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

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

Definition at line 67 of file NueConvention.cxx.

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

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

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

Definition at line 60 of file NueConvention.cxx.

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

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

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

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

Definition at line 188 of file NueConvention.cxx.

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

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

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

Definition at line 90 of file NueConvention.cxx.

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

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

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

Definition at line 80 of file NueConvention.cxx.

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

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

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 146 of file NueConvention.cxx.

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

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

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

Variable Documentation

const Int_t NueConvention::bnue = 4 [static]
 

Definition at line 32 of file NueConvention.h.

const Int_t NueConvention::NC = 0 [static]
 

Definition at line 28 of file NueConvention.h.

const Int_t NueConvention::nue = 2 [static]
 

Definition at line 30 of file NueConvention.h.

const Int_t NueConvention::numu = 1 [static]
 

Definition at line 29 of file NueConvention.h.

const Int_t NueConvention::nutau = 3 [static]
 

Definition at line 31 of file NueConvention.h.

Generated on Thu Nov 1 12:02:19 2007 for loon by  doxygen 1.3.9.1