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

OscWeight Class Reference

#include <OscWeight.h>

List of all members.

Public Member Functions

 OscWeight ()
void SetOscParam (double *par, bool force=false)
void SetOscParam (OscPar::OscPar_t pos, double val)
void GetOscParam (double *par)
double Oscillate (int nuFlavor, int nonOscNuFlavor, float Energy, float L, float dm2, float theta23, float UE32)
double Oscillate (int nuFlavor, int nonOscNuFlavor, double Energy)
double OscillateMatter (int nuFlavor, int nonOscNuFlavor, double Energy, double *par)
double OscillateMatter (int nuFlavor, int nonOscNuFlavor, double Energy)
double ElecAppear (double *x)
double MuToTau (double *x)
double MuSurvive (double *x)

Private Attributes

double fOscPar [10]
double fSinTh [3]
double fCosTh [3]
double fSin2Th [3]
double fElecDensity
double fA
double fSinAL

Constructor & Destructor Documentation

OscWeight::OscWeight (   ) 
 

Definition at line 18 of file OscWeight.cxx.

References fOscPar, and SetOscParam().

00019 {
00020   for(int i = 0; i < 9; i++) fOscPar[i] = 0;  
00021   double par[9] = {0};
00022   SetOscParam(par, true);
00023 }

Member Function Documentation

double OscWeight::ElecAppear (  double *  x  ) 
 

Definition at line 195 of file OscWeight.cxx.

References fA, fCosTh, fOscPar, fSin2Th, and fSinTh.

Referenced by MuSurvive(), and OscillateMatter().

00196 {
00197 
00198   //x[0] = E
00199 
00200   double E = x[0]; //energy
00201   double L = fOscPar[OscPar::kL];  //baseline
00202   double plusminus = int(fOscPar[OscPar::kNuAntiNu]);
00203 
00204   double sinsq_2th12 = fSin2Th[OscPar::kTh12]*fSin2Th[OscPar::kTh12];
00205   double sinsq_2th13 = fSin2Th[OscPar::kTh13]*fSin2Th[OscPar::kTh13];                   
00206 
00207   double cos_th23 = fCosTh[OscPar::kTh23];
00208   double sin_th23 = fSinTh[OscPar::kTh23];
00209   double cos_th13 = fCosTh[OscPar::kTh13];
00210 
00211   double sin_2th23 = fSin2Th[OscPar::kTh23];
00212   double sin_2th13 = fSin2Th[OscPar::kTh13];
00213   double sin_2th12 = fSin2Th[OscPar::kTh12];
00214 
00215   double d_cp = fOscPar[OscPar::kDelta];
00216 
00217   double dmsq_23 = fOscPar[OscPar::kDeltaM23];
00218   double dmsq_12 = fOscPar[OscPar::kDeltaM12];
00219   double dmsq_13 = dmsq_23+dmsq_12; //eV^{2}
00220 
00221   //double Delta23 = dmsq_23/(2.*E*1e9); //eV
00222   double Delta12 = dmsq_12/(2.*E*1e9);
00223   double Delta13 = dmsq_13/(2.*E*1e9);
00224 
00225   double B = TMath::Abs(fA - plusminus*Delta13); //eV
00226   double J = cos_th13*sin_2th12*sin_2th13*sin_2th23;
00227 
00228   double sin_BL = sin(B*L/(OscPar::invKmToeV*2.));
00229   double sin_AL = fSinAL;
00230 
00231 
00232   double p1 = sin_th23*sin_th23*sinsq_2th13*(Delta13/B * Delta13/B)
00233     *sin_BL*sin_BL;
00234 
00235   double p2 = 0;
00236   double p3 = 0;
00237   if(fA !=0){
00238     p2 = cos_th23*cos_th23*sinsq_2th12*(Delta12/fA * Delta12/fA)
00239       *sin_AL*sin_AL;
00240 
00241     p3 = J*Delta12*Delta13*sin_AL*sin_BL
00242       *cos(plusminus*d_cp + Delta13*L/(OscPar::invKmToeV*2.))/(fA*B);
00243   }
00244 
00245   //std::cout<<dmsq_13<<"  "<<dmsq_12<<"  "<<dmsq_23<<"  "<<Delta13<<"  "
00246     //       <<fA<<"  "<<B<<std::endl;
00247 
00248 
00249   if(p1+p2+p3>1) return 1;
00250   return p1+p2+p3;
00251 }

void OscWeight::GetOscParam (  double *  par  ) 
 

Definition at line 10 of file OscWeight.cxx.

References fOscPar.

00011 {
00012    for(int i = 0; i < int(OscPar::kUnknown); i++){
00013      par[i] = fOscPar[i];
00014    }
00015 }

double OscWeight::MuSurvive (  double *  x  ) 
 

Definition at line 279 of file OscWeight.cxx.

References ElecAppear(), and MuToTau().

Referenced by OscillateMatter().

00280 {
00281   double p1 = 1. - OscWeight::MuToTau(x) - OscWeight::ElecAppear(x);
00282   if(p1 < 0) p1 = 0;
00283   return p1;
00284 }

double OscWeight::MuToTau (  double *  x  ) 
 

Definition at line 253 of file OscWeight.cxx.

References fCosTh, fOscPar, and fSin2Th.

Referenced by MuSurvive(), and OscillateMatter().

00254 {
00255 
00256   //x[0] = E
00257 
00258   double E = x[0]; //energy
00259   double L = fOscPar[OscPar::kL];  //baseline
00260 
00261   double sinsq_2th23 = fSin2Th[OscPar::kTh23]*fSin2Th[OscPar::kTh23];
00262 
00263   double cos_th13 = fCosTh[OscPar::kTh13];
00264 
00265   double dmsq_23 = fOscPar[OscPar::kDeltaM23];
00266 
00267   double Delta23 = dmsq_23/(2.*E*1e9); //eV
00268   double sin_delta = sin(Delta23*L/(OscPar::invKmToeV*2.));  
00269  
00270   double p1 = sinsq_2th23*cos_th13*cos_th13*cos_th13*cos_th13
00271     *sin_delta*sin_delta;  //numu->nutau
00272 
00273 
00274   return p1;
00275 
00276 }

double OscWeight::Oscillate (  int  nuFlavor,
int  nonOscNuFlavor,
double  Energy
) 
 

Definition at line 25 of file OscWeight.cxx.

References abs(), fCosTh, fOscPar, fSin2Th, and fSinTh.

00026 {
00027    double L = fOscPar[OscPar::kL];
00028    double dm2 = fOscPar[OscPar::kDeltaM23];
00029 //   double theta23 = fOscPar[OscPar::kTh23];
00030                                                                                          
00031    double oscterm = TMath::Sin(1.269*dm2*L/Energy);
00032    oscterm = oscterm*oscterm;
00033                                                                                          
00034    double sin2th23 = fSin2Th[OscPar::kTh23];
00035    double sinsq2th23 = sin2th23*sin2th23;
00036    double sinth23 = fSinTh[OscPar::kTh23];
00037    double costh23 = fCosTh[OscPar::kTh23];
00038    double UE32 = fSinTh[OscPar::kTh13]*fSinTh[OscPar::kTh13];
00039                                                                                          
00040    double pmt=(1-UE32)*(1-UE32)*sinsq2th23*oscterm;
00041    double pme=sinth23*sinth23*4.*UE32*(1-UE32)*oscterm;
00042    double pmm=1.-pmt-pme;
00043                                                                                          
00044    double pet=4*(1-UE32)*UE32*oscterm*costh23*costh23;
00045    double pem=sinth23*sinth23*4.*UE32*(1-UE32)*oscterm;
00046    double pee=1.-pet-pem;
00047                                                                                          
00048                                                                                          
00049    if(abs(nonOscNuFlavor)==14){
00050       if(abs(nuFlavor)==12)       { return pme; }
00051       else if(abs(nuFlavor)==14)  { return pmm; }
00052       else if(abs(nuFlavor)==16)  { return pmt; }
00053    }
00054    else if(abs(nonOscNuFlavor)==12){
00055       if(abs(nuFlavor)==12)       { return pee; }
00056       else if(abs(nuFlavor)==14)  { return pem; }
00057       else if(abs(nuFlavor)==16)  { return pet; }
00058    }
00059    else{
00060      std::cout<<"I don't know what to do with "<<nonOscNuFlavor
00061          <<" "<<nuFlavor<<" "<<pee<<std::endl;
00062    }
00063    return 0.;
00064 }

double OscWeight::Oscillate (  int  nuFlavor,
int  nonOscNuFlavor,
float  Energy,
float  L,
float  dm2,
float  theta23,
float  UE32
) 
 

Definition at line 66 of file OscWeight.cxx.

References abs(), fCosTh, fOscPar, fSin2Th, fSinTh, and SetOscParam().

00068 {
00069    double par[9] = {0};
00070    for(int i = 0; i < 9; i++) {par[i] = fOscPar[i];}
00071    par[OscPar::kL] = L;
00072    par[OscPar::kDeltaM23] = dm2;
00073    par[OscPar::kTh23] = theta23;
00074 
00075    SetOscParam(par);
00076 
00077    double oscterm = TMath::Sin(1.269*dm2*L/Energy);
00078    oscterm = oscterm*oscterm;
00079 
00080    double sin2th23 = fSin2Th[OscPar::kTh23];
00081    double sinsq2th23 = sin2th23*sin2th23;
00082    double sinth23 = fSinTh[OscPar::kTh23];
00083    double costh23 = fCosTh[OscPar::kTh23];
00084 
00085    double pmt=(1-UE32)*(1-UE32)*sinsq2th23*oscterm;
00086    double pme=sinth23*sinth23*4.*UE32*(1-UE32)*oscterm;
00087    double pmm=1.-pmt-pme;
00088 
00089    double pet=4*(1-UE32)*UE32*oscterm*costh23*costh23;
00090    double pem=sinth23*sinth23*4.*UE32*(1-UE32)*oscterm;
00091    double pee=1.-pet-pem;
00092 
00093 
00094    if(abs(nonOscNuFlavor)==14){
00095       if(abs(nuFlavor)==12)       { return pme; }
00096       else if(abs(nuFlavor)==14)  { return pmm; }
00097       else if(abs(nuFlavor)==16)  { return pmt; }
00098    }
00099    else if(abs(nonOscNuFlavor)==12){
00100       if(abs(nuFlavor)==12)       { return pee; }
00101       else if(abs(nuFlavor)==14)  { return pem; }
00102       else if(abs(nuFlavor)==16)  { return pet; }
00103    }
00104    else{
00105      std::cout<<"I don't know what to do with "<<nonOscNuFlavor
00106          <<" "<<nuFlavor<<" "<<pee<<std::endl;
00107    }
00108    return 0.;
00109 }

double OscWeight::OscillateMatter (  int  nuFlavor,
int  nonOscNuFlavor,
double  Energy
) 
 

Definition at line 121 of file OscWeight.cxx.

References abs(), ElecAppear(), fCosTh, fOscPar, fSin2Th, MuSurvive(), and MuToTau().

00123 {
00124   double x[1] = {};
00125   x[0] = Energy;
00126 
00127   double L = fOscPar[OscPar::kL];
00128   double cos_th23 = fCosTh[OscPar::kTh23];
00129   double sinsq_2th13 = fSin2Th[OscPar::kTh13]*fSin2Th[OscPar::kTh13];
00130   double dm2 = fOscPar[OscPar::kDeltaM23];
00131 
00132   if(abs(nonOscNuFlavor)==14) {
00133     if(abs(nuFlavor)==12)      return OscWeight::ElecAppear(x);
00134     else if(abs(nuFlavor)==14) return OscWeight::MuSurvive(x);
00135     else if(abs(nuFlavor)==16) return OscWeight::MuToTau(x);
00136   }
00137   if(abs(nonOscNuFlavor)==12) {
00138     if(abs(nuFlavor)==14) return OscWeight::ElecAppear(x);
00139 
00140     double sin_dm = sin(1.27*dm2*L/x[0]);
00141     double eToTau = sinsq_2th13*cos_th23*cos_th23*sin_dm*sin_dm;
00142 
00143     if(abs(nuFlavor)==12) return 1 - OscWeight::ElecAppear(x) - eToTau;
00144     else if(abs(nuFlavor)==16) return (eToTau);
00145   }
00146 
00147   return 0;
00148 }

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

Definition at line 113 of file OscWeight.cxx.

References SetOscParam().

00115 {
00116   SetOscParam(par);
00117   return OscillateMatter(nuFlavor, nonOscNuFlavor, Energy); 
00118 }

void OscWeight::SetOscParam (  OscPar::OscPar_t  pos,
double  val
) 
 

Definition at line 150 of file OscWeight.cxx.

References fA, fCosTh, fElecDensity, fOscPar, fSin2Th, fSinAL, and fSinTh.

00151 {
00152   //cout<<"setting  "<<pos<<"  "<<val<<endl;
00153   if(fabs(fOscPar[pos] - val) > 1e-9){
00154     fOscPar[pos] = val;
00155     if(pos < 3){
00156        fSinTh[pos] = sin(val);
00157        fCosTh[pos] = cos(val);
00158        fSin2Th[pos] = sin(2*val);
00159     }
00160     if(pos == OscPar::kDensity){
00161       double ne = OscPar::z_a*OscPar::A_av*val; //electron density #/cm^{3}
00162       fElecDensity = ne*OscPar::invCmToeV*OscPar::invCmToGeV*OscPar::invCmToGeV;
00163       //electron density with units Gev^{2} eV
00164       //Gev^{2} to cancel with GeV^{-2} in Gf
00165                                                                                 
00166        fA = OscPar::root2*OscPar::Gf*fElecDensity; //eV
00167        fSinAL = sin(fA*fOscPar[OscPar::kL]/(OscPar::invKmToeV*2.));
00168     }
00169   }
00170 }

void OscWeight::SetOscParam (  double *  par,
bool  force = false
) 
 

Definition at line 172 of file OscWeight.cxx.

References fA, fCosTh, fElecDensity, fOscPar, fSin2Th, fSinAL, and fSinTh.

Referenced by Oscillate(), OscillateMatter(), and OscWeight().

00173 {
00174    for(int i = 0; i < int(OscPar::kUnknown); i++){
00175      if(fOscPar[i] != par[i] || force){
00176         fOscPar[i] = par[i];
00177         if(i < 3){
00178             fSinTh[i] = sin(par[i]);
00179             fCosTh[i] = cos(par[i]);
00180             fSin2Th[i] = sin(2*par[i]);
00181         }
00182         if(i == OscPar::kDensity){
00183           double ne = OscPar::z_a*OscPar::A_av*par[i]; //electron density #/cm^{3}
00184           fElecDensity = ne*OscPar::invCmToeV*OscPar::invCmToGeV*OscPar::invCmToGeV;
00185           //electron density with units Gev^{2} eV
00186           //Gev^{2} to cancel with GeV^{-2} in Gf
00187           
00188           fA = OscPar::root2*OscPar::Gf*fElecDensity; //eV
00189           fSinAL = sin(fA*par[OscPar::kL]/(OscPar::invKmToeV*2.));
00190         }
00191      }
00192    }
00193 }

Member Data Documentation

double OscWeight::fA [private]
 

Definition at line 65 of file OscWeight.h.

Referenced by ElecAppear(), and SetOscParam().

double OscWeight::fCosTh[3] [private]
 

Definition at line 62 of file OscWeight.h.

Referenced by ElecAppear(), MuToTau(), Oscillate(), OscillateMatter(), and SetOscParam().

double OscWeight::fElecDensity [private]
 

Definition at line 64 of file OscWeight.h.

Referenced by SetOscParam().

double OscWeight::fOscPar[10] [private]
 

Definition at line 59 of file OscWeight.h.

Referenced by ElecAppear(), GetOscParam(), MuToTau(), Oscillate(), OscillateMatter(), OscWeight(), and SetOscParam().

double OscWeight::fSin2Th[3] [private]
 

Definition at line 63 of file OscWeight.h.

Referenced by ElecAppear(), MuToTau(), Oscillate(), OscillateMatter(), and SetOscParam().

double OscWeight::fSinAL [private]
 

Definition at line 66 of file OscWeight.h.

Referenced by SetOscParam().

double OscWeight::fSinTh[3] [private]
 

Definition at line 61 of file OscWeight.h.

Referenced by ElecAppear(), Oscillate(), and SetOscParam().

The documentation for this class was generated from the following files:
Generated on Mon Feb 15 11:09:59 2010 for loon by  doxygen 1.3.9.1