OscCalc Class Reference

#include <OscCalc.h>

List of all members.

Public Member Functions

 OscCalc ()
void GetOscParam (double *par)
double GetOscParam (OscPar::OscPar_t pos)
void SetOscParam (double *par, bool force=false)
void SetOscParam (OscPar::OscPar_t pos, double val, bool force=false)
double Oscillate (int nuFlavor, int nonOscNuFlavor, double Energy)
double Oscillate (int nuFlavor, int nonOscNuFlavor, double Energy, double *par)
double MuToElec (double x)
double MuToTau (double x)
double MuToMu (double x)
double ElecToElec (double x)
double ElecToMu (double x)
double ElecToTau (double x)
double TauToElec (double x)
double TauToTau (double x)
double TauToMu (double x)
double OscillateNSI (int nuFlavor, int nonOscNuFlavor, double E)
double OscillateLSND (int nuFlavor, int nonOscNuFlavor, double E)

Private Member Functions

void UpdateNSI ()
void UpdateLSND ()

Private Attributes

OscProb::PMNS_NSI myPMNS_NSI
OscProb::PMNS_Sterile myPMNS_LSND
bool fMixDirty
bool fDmSqrDirty
bool fNSIDirty
bool fLSNDDirty
double fOscPar [OscPar::kNumParameters]
double fSinTh [3]
double fCosTh [3]
double fSin2Th [3]
double fCos2Th [3]
double fElecDensity
double fV
double fSinDCP
double fCosDCP


Detailed Description

Definition at line 71 of file OscCalc.h.


Constructor & Destructor Documentation

OscCalc::OscCalc (  ) 

Definition at line 14 of file OscCalc.cxx.

References OscPar::kNumParameters, and SetOscParam().

00014                 :myPMNS_LSND(4)
00015 {
00016   double par[OscPar::kNumParameters] = {0}; 
00017   SetOscParam(par, true);
00018 }


Member Function Documentation

double OscCalc::ElecToElec ( double  x  ) 

Definition at line 579 of file OscCalc.cxx.

References MuELoss::e, fCos2Th, fOscPar, fSin2Th, fSinDCP, fSinTh, fV, OscPar::invKmToeV, OscPar::kDelta, OscPar::kDeltaM12, OscPar::kDeltaM23, OscPar::kL, OscPar::kNuAntiNu, OscPar::kTh12, and OscPar::kTh13.

Referenced by Oscillate(), Extrapolate2D::OscillatePrediction_NoSep(), Extrapolate2D::OscillatePrediction_SepNuNuBar(), and Extrapolate2D::SetNominalOscProb().

00580 {
00581   double E = x; //energy
00582                                                                                                                        
00583   //Building the standard terms
00584   double L = fOscPar[OscPar::kL];  //baseline
00585   double dmsq_23 = fOscPar[OscPar::kDeltaM23];
00586   double dmsq_12 = fOscPar[OscPar::kDeltaM12];
00587   double dmsq_13 = dmsq_23+dmsq_12; //eV^{2}
00588                                                                                                                        
00589   double sinsq_2th12 = fSin2Th[OscPar::kTh12]*fSin2Th[OscPar::kTh12];
00590   double sinsq_2th13 = fSin2Th[OscPar::kTh13]*fSin2Th[OscPar::kTh13];
00591                                                                                                                        
00592   double sin_th12 = fSinTh[OscPar::kTh12];
00593  
00594 //  double cos_2th23 = fCos2Th[OscPar::kTh23];
00595   double cos_2th13 = fCos2Th[OscPar::kTh13];
00596   double cos_2th12 = fCos2Th[OscPar::kTh12];
00597                                                                                                                        
00598   double d_cp = fOscPar[OscPar::kDelta];
00599   double sin_dcp = fSinDCP;
00600                                                                                                                        
00601   //Building the more complicated terms
00602   double Delta = dmsq_13*L/(4*E*1e9*OscPar::invKmToeV);
00603   double A = 2*fV*E*1e9/(dmsq_13);
00604   double alpha = dmsq_12/dmsq_13;
00605                                                                                                                        
00606   // A and d_cp both change sign for antineutrinos
00607   double plusminus = int(fOscPar[OscPar::kNuAntiNu]);
00608   A *= plusminus;
00609   d_cp *= plusminus;
00610   sin_dcp *= plusminus;
00611                                                                                                                        
00612   //Now calculate the resonance terms for alpha expansion (C13) and s13 expansion (C12)
00613   double C13 = TMath::Sqrt(sinsq_2th13+(A-cos_2th13)*(A-cos_2th13));
00614                                                                                                                        
00615   double C12 = 1;  //really C12 -> infinity when alpha = 0 but not an option really
00616   if(fabs(alpha) > 1e-10){  //want to be careful here
00617     double temp = cos_2th12 - A/alpha;
00618     C12 = TMath::Sqrt(sinsq_2th12+(temp*temp));
00619   }
00620                                                                                                                        
00621   //More complicated sin and cosine terms
00622   double cosC13Delta = cos(C13*Delta);
00623   double sinC13Delta = sin(C13*Delta);
00624                                                                                                                        
00625   double cosaC12Delta = 0;
00626   double sinaC12Delta = 0;
00627                                                                                                                        
00628   if(fabs(alpha) > 1e-10){
00629     cosaC12Delta = cos(alpha*C12*Delta);
00630     sinaC12Delta = sin(alpha*C12*Delta);
00631   } // otherwise not relevant
00632                                                                                                                        
00633   //First we calculate the terms for the alpha expansion (good to all orders in th13)
00634   // this is the equivalent of Eq 45 & 46 corrected for Mu to E instead of E to Mu
00635                                                                                                                        
00636   // Leading order term
00637   double p1 = 1 - sinsq_2th13*sinC13Delta*sinC13Delta/(C13*C13);
00638                                                                                                                        
00639   // terms that appear at order alpha
00640   double p2Inner = Delta*cosC13Delta*(1-A*cos_2th13)/C13 -
00641                       A*sinC13Delta*(cos_2th13-A)/(C13*C13);
00642                                                                                                                        
00643   double p2 = +2*sin_th12*sin_th12*sinsq_2th13*sinC13Delta/(C13*C13)*p2Inner*alpha;
00644   //  p1 + p2 is the complete contribution for this expansion
00645                                                                                                                        
00646   // Now for the expansion in orders of sin(th13) (good to all order alpha)
00647   //  this is the equivalent of Eq 63 and 64
00648                                                                                                                        
00649   // leading order term
00650   double pa1 = 1.0, pa2 = 0.0;
00651                                                                                                                        
00652   if(fabs(alpha) > 1e-10){
00653     // leading order term
00654     pa1 = 1.0 - sinsq_2th12*sinaC12Delta*sinaC12Delta/(C12*C12);
00655   }
00656   //pa1 is the complete contribution from this expansion, there is no order s13^1 term
00657                                                                                                                        
00658   // In order to combine the information correctly we need to add the two
00659   //  expansions and subtract off the terms that are in both (alpha^1, s13^1)
00660   //  these may be taken from the expansion to second order in both parameters
00661   //  Equation 30
00662                                                                                                                        
00663   double repeated = 1;
00664                                                                                                                        
00665   //  Calculate the total probability
00666   double totalP = p1+p2 + (pa1+pa2) - repeated;
00667                                                                                                                        
00668   return totalP;
00669 }

double OscCalc::ElecToMu ( double  x  ) 

Definition at line 561 of file OscCalc.cxx.

References fOscPar, fSinDCP, OscPar::kDelta, and MuToElec().

Referenced by ElecToTau(), Oscillate(), Extrapolate2D::OscillatePrediction_NoSep(), Extrapolate2D::OscillatePrediction_SepNuNuBar(), and Extrapolate2D::SetNominalOscProb().

00562 {
00563   // Flip delta to reverse direction
00564   double oldSinDelta = fSinDCP;
00565   double oldDelta =  fOscPar[OscPar::kDelta];
00566 
00567   fOscPar[OscPar::kDelta] = -oldDelta;
00568   fSinDCP = -oldSinDelta;
00569                                                                                                                        
00570   double prob = OscCalc::MuToElec(x);
00571                                                                                                                        
00572   //restore the world
00573   fOscPar[OscPar::kDelta] = oldDelta;
00574   fSinDCP = oldSinDelta;
00575  
00576   return prob;   
00577 }

double OscCalc::ElecToTau ( double  x  ) 

Definition at line 534 of file OscCalc.cxx.

References ElecToMu(), fCosTh, fSin2Th, fSinTh, and OscPar::kTh23.

Referenced by Oscillate(), Extrapolate2D::OscillatePrediction_NoSep(), Extrapolate2D::OscillatePrediction_SepNuNuBar(), Extrapolate2D::SetNominalOscProb(), and TauToElec().

00535 {
00536 //  EtoTau is the same as E->Mu wich sinsq_th23 <-> cossq_th23, sin(2th23) <->-sin(2th23)
00537   double origCos = fCosTh[OscPar::kTh23];
00538   double origSin = fSinTh[OscPar::kTh23];
00539   double orig2Sin = fSin2Th[OscPar::kTh23];
00540 
00541   fCosTh[OscPar::kTh23] = origSin;
00542   fSinTh[OscPar::kTh23] = origCos;
00543   fSin2Th[OscPar::kTh23] = -orig2Sin;
00544 
00545   double prob = OscCalc::ElecToMu(x);
00546 
00547   //restore the world
00548   fCosTh[OscPar::kTh23] = origCos;
00549   fSinTh[OscPar::kTh23] = origSin;
00550   fSin2Th[OscPar::kTh23] = orig2Sin;
00551 
00552   return prob;
00553 
00554 /*  This is an option as well but I think results in more cycles
00555   double p1 = 1. - OscCalc::ElecToMu(x) - OscCalc::ElecToElec(x);
00556   if(p1 < 0){ cout<<"Damnation! "<<x[0]<<" "<<p1<<endl; p1 = 0;}
00557   return p1;
00558 */ 
00559 }

double OscCalc::GetOscParam ( OscPar::OscPar_t  pos  ) 

Definition at line 201 of file OscCalc.cxx.

References fOscPar, and OscPar::kNumParameters.

00202 {
00203    if(pos >=0 && pos < OscPar::kNumParameters)
00204      return fOscPar[pos];
00205    else 
00206      return -9999;
00207 }

void OscCalc::GetOscParam ( double *  par  ) 

Definition at line 194 of file OscCalc.cxx.

References fOscPar, and OscPar::kNumParameters.

Referenced by NueStandard::GetOscParam(), NueSystematic::GetOscParams(), Extrapolate2D::GetPrediction(), Extrapolate2D::InvertMassHierarchy(), Extrapolate2D_Simple::OscillatePrediction(), Extrapolate2D::OscillatePrediction(), and Extrapolate2D::ReadExtrap().

00195 {
00196    for(int i = 0; i < int(OscPar::kNumParameters); i++){
00197      par[i] = fOscPar[i];
00198    }
00199 }

double OscCalc::MuToElec ( double  x  ) 

Definition at line 210 of file OscCalc.cxx.

References MuELoss::e, fCos2Th, fCosDCP, fCosTh, fOscPar, fSin2Th, fSinDCP, fSinTh, fV, OscPar::invKmToeV, OscPar::kDelta, OscPar::kDeltaM12, OscPar::kDeltaM23, OscPar::kL, OscPar::kNuAntiNu, OscPar::kTh12, OscPar::kTh13, and OscPar::kTh23.

Referenced by ElecToMu(), MuToMu(), Oscillate(), Extrapolate2D_Simple::OscillatePrediction_NoSep(), Extrapolate2D::OscillatePrediction_NoSep(), Extrapolate2D_Simple::OscillatePrediction_SepNuNuBar(), Extrapolate2D::OscillatePrediction_SepNuNuBar(), and Extrapolate2D::SetNominalOscProb().

00211 {
00212   double E = x; //energy
00213 
00214   //Building the standard terms
00215   double L = fOscPar[OscPar::kL];  //baseline
00216   double dmsq_23 = fOscPar[OscPar::kDeltaM23];
00217   double dmsq_12 = fOscPar[OscPar::kDeltaM12];
00218   double dmsq_13 = dmsq_23+dmsq_12; //eV^{2}
00219 
00220   double sinsq_2th12 = fSin2Th[OscPar::kTh12]*fSin2Th[OscPar::kTh12];
00221   double sinsq_2th13 = fSin2Th[OscPar::kTh13]*fSin2Th[OscPar::kTh13];
00222                                                                                 
00223   double cos_th23 = fCosTh[OscPar::kTh23];
00224   double cos_th12 = fCosTh[OscPar::kTh12];
00225   double sin_th13 = fSinTh[OscPar::kTh13];
00226   double cos_th13 = fCosTh[OscPar::kTh13];  
00227                                                                               
00228   double sin_2th23 = fSin2Th[OscPar::kTh23];
00229   double sin_2th12 = fSin2Th[OscPar::kTh12];
00230   double cos_2th13 = fCos2Th[OscPar::kTh13];
00231   double cos_2th12 = fCos2Th[OscPar::kTh12];
00232 
00233   double sinsq_th23 = fSinTh[OscPar::kTh23]*fSinTh[OscPar::kTh23];
00234   double sinsq_th12 = fSinTh[OscPar::kTh12]*fSinTh[OscPar::kTh12];
00235 
00236   double d_cp = fOscPar[OscPar::kDelta];
00237   double cos_dcp = fCosDCP;
00238   double sin_dcp = fSinDCP;
00239 
00240   //Building the more complicated terms
00241   double Delta = dmsq_13*L/(4*E*1e9*OscPar::invKmToeV);
00242   double A = 2*fV*E*1e9/(dmsq_13);
00243   double alpha = dmsq_12/dmsq_13;
00244 
00245   // A and d_cp both change sign for antineutrinos
00246   double plusminus = int(fOscPar[OscPar::kNuAntiNu]);
00247   A *= plusminus;
00248   d_cp *= plusminus;
00249   sin_dcp *= plusminus;
00250 
00251   //Now calculate the resonance terms for alpha expansion (C13) and s13 expansion (C12)
00252 
00253   double C13 = TMath::Sqrt(sinsq_2th13+(A-cos_2th13)*(A-cos_2th13));
00254 
00255   double C12 = 1;  //really C12 -> infinity when alpha = 0 but not an option really
00256   if(fabs(alpha) > 1e-10){  //want to be careful here
00257     double temp = cos_2th12 - A/alpha;
00258     C12 = TMath::Sqrt(sinsq_2th12+(temp*temp));
00259   }
00260 
00261   //More complicated sin and cosine terms
00262   double cosC13Delta = cos(C13*Delta);
00263   double sinC13Delta = sin(C13*Delta);
00264   double sin1pADelta = sin((A+1)*Delta);
00265   double cos1pADelta = cos((A+1)*Delta);
00266   double sinADelta = sin(A*Delta);
00267   double sinAm1Delta = sin((A-1)*Delta);
00268   double cosdpDelta = cos(d_cp+Delta);
00269   double sinApam2Delta = sin((A+alpha-2)*Delta);
00270   double cosApam2Delta = cos((A+alpha-2)*Delta);
00271 
00272   double cosaC12Delta = 0;
00273   double sinaC12Delta = 0; 
00274   
00275   if(fabs(alpha) > 1e-10){
00276     cosaC12Delta = cos(alpha*C12*Delta);
00277     sinaC12Delta = sin(alpha*C12*Delta);
00278   } // otherwise not relevant
00279 
00280   //First we calculate the terms for the alpha expansion (good to all orders in th13)
00281   // this is the equivalent of Eq 47 & 48 corrected for Mu to E instead of E to Mu
00282 
00283   // Leading order term 
00284   double p1 = sinsq_th23*sinsq_2th13*sinC13Delta*sinC13Delta/(C13*C13);
00285 
00286   // terms that appear at order alpha
00287   //first work out the vacuum case since we get 0/0 otherwise.......
00288   double p2Inner = Delta*cosC13Delta;
00289 
00290   if(fabs(A) > 1e-9)
00291     p2Inner = Delta*cosC13Delta*(1-A*cos_2th13)/C13 -
00292                       A*sinC13Delta*(cos_2th13-A)/(C13*C13);
00293 
00294   double p2 = -2*sinsq_th12*sinsq_th23*sinsq_2th13*sinC13Delta/(C13*C13)*p2Inner*alpha;
00295 
00296 
00297   //again working out vacuum first.....
00298   double p3Inner = Delta* cos_th13* cos_th13*(-2*sin_dcp*sinC13Delta*sinC13Delta+2*cos_dcp*sinC13Delta*cosC13Delta);
00299 
00300   if(fabs(A) > 1e-9)
00301     p3Inner = (sinC13Delta/(A*C13*C13))*(- sin_dcp*(cosC13Delta - cos1pADelta)*C13
00302                          + cos_dcp*(C13*sin1pADelta - (1-A*cos_2th13)*sinC13Delta));
00303 
00304   double p3 = sin_2th12*sin_2th23*sin_th13*p3Inner*alpha;
00305 
00306   //  p1 + p2 + p3 is the complete contribution for this expansion
00307   
00308   // Now for the expansion in orders of sin(th13) (good to all order alpha) 
00309   //  this is the equivalent of Eq 65 and 66
00310 
00311   // leading order term
00312   double pa1 = 0.0, pa2 = 0.0;
00313 
00314   // no problems here when A -> 0
00315   if(fabs(alpha) > 1e-10){
00316     // leading order term
00317     pa1 = cos_th23*cos_th23*sinsq_2th12*sinaC12Delta*sinaC12Delta/(C12*C12);
00318 
00319     // and now to calculate the first order in s13 term
00320     double t1 = (cos_2th12 - A/alpha)/C12 
00321                   - alpha*A*C12*sinsq_2th12/(2*(1-alpha)*C12*C12);
00322     double t2 = -cos_dcp*(sinApam2Delta-sinaC12Delta*t1);
00323   
00324     double t3 = -(cosaC12Delta-cosApam2Delta)*sin_dcp;
00325  
00326     double denom = (1-A-alpha+A*alpha*cos_th12*cos_th12)*C12;
00327     double t4 = sin_2th12*sin_2th23*(1-alpha)*sinaC12Delta/denom;
00328 
00329     pa2 = t4*(t3+t2)*sin_th13;
00330   }
00331   //pa1+pa2 is the complete contribution from this expansion
00332 
00333   // In order to combine the information correctly we need to add the two
00334   //  expansions and subtract off the terms that are in both (alpha^1, s13^1) 
00335   //  these may be taken from the expansion to second order in both parameters
00336   //  Equation 31 
00337 
00338   double t1 = Delta*sinC13Delta*cosdpDelta;
00339   if(fabs(A) > 1e-9) t1 = sinADelta*cosdpDelta*sinAm1Delta/(A*(A-1));
00340 
00341   double repeated = 2*alpha*sin_2th12*sin_2th23*sin_th13*t1;
00342 
00343   //  Calculate the total probability
00344   double totalP = p1+p2+p3 + (pa1+pa2) - repeated;
00345 
00346   return totalP;
00347 }

double OscCalc::MuToMu ( double  x  ) 

Definition at line 527 of file OscCalc.cxx.

References MuELoss::e, MuToElec(), and MuToTau().

Referenced by Oscillate(), Extrapolate2D::OscillatePrediction_NoSep(), Extrapolate2D::OscillatePrediction_SepNuNuBar(), Extrapolate2D::SetNominalOscProb(), and TauToTau().

00528 {
00529   double p1 = 1. - OscCalc::MuToTau(x) - OscCalc::MuToElec(x);
00530   if(p1 < 1e-4){ cout<<"P(mu->mu) less than zero Damnation! "<<x<<" "<<p1<<endl; p1 = 0;}
00531   return p1;
00532 }

double OscCalc::MuToTau ( double  x  ) 

Definition at line 349 of file OscCalc.cxx.

References MuELoss::e, fCos2Th, fCosDCP, fCosTh, fOscPar, fSin2Th, fSinDCP, fSinTh, fV, OscPar::invKmToeV, OscPar::kDelta, OscPar::kDeltaM12, OscPar::kDeltaM23, OscPar::kL, OscPar::kNuAntiNu, OscPar::kTh12, OscPar::kTh13, and OscPar::kTh23.

Referenced by MuToMu(), Oscillate(), Extrapolate2D::OscillatePrediction_NoSep(), Extrapolate2D::OscillatePrediction_SepNuNuBar(), Extrapolate2D::SetNominalOscProb(), and TauToMu().

00350 {
00351   double E = x; //energy
00352 
00353   double L = fOscPar[OscPar::kL];  //baseline
00354   double dmsq_23 = fOscPar[OscPar::kDeltaM23];
00355   double dmsq_12 = fOscPar[OscPar::kDeltaM12];
00356   double dmsq_13 = dmsq_23+dmsq_12; //eV^{2}
00357 
00358   double sinsq_2th12 = fSin2Th[OscPar::kTh12]*fSin2Th[OscPar::kTh12];
00359   double sinsq_2th13 = fSin2Th[OscPar::kTh13]*fSin2Th[OscPar::kTh13];
00360   double sinsq_2th23 = fSin2Th[OscPar::kTh23]*fSin2Th[OscPar::kTh23];
00361                                                                                 
00362   double cos_th13 = fCosTh[OscPar::kTh13];
00363   double cos_th12 = fCosTh[OscPar::kTh12];
00364   double sin_th12 = fSinTh[OscPar::kTh12];
00365   double sin_th13 = fSinTh[OscPar::kTh13];
00366                                                                                 
00367   double sin_2th23 = fSin2Th[OscPar::kTh23];
00368 //  double sin_2th13 = fSin2Th[OscPar::kTh13];
00369   double sin_2th12 = fSin2Th[OscPar::kTh12];
00370                                                                                 
00371   double cos_2th23 = fCos2Th[OscPar::kTh23];
00372   double cos_2th13 = fCos2Th[OscPar::kTh13];
00373   double cos_2th12 = fCos2Th[OscPar::kTh12];
00374 
00375   double d_cp = fOscPar[OscPar::kDelta];
00376   double cos_dcp = fCosDCP;
00377   double sin_dcp = fSinDCP;
00378 
00379   //Building the more complicated terms                                                                              
00380   double Delta = dmsq_13*L/(4*E*1e9*OscPar::invKmToeV);
00381   double A = 2*fV*E*1e9/(dmsq_13);
00382   double alpha = dmsq_12/dmsq_13;
00383   
00384   // A and d_cp both change sign for antineutrinos
00385   double plusminus = int(fOscPar[OscPar::kNuAntiNu]);
00386   A *= plusminus;
00387   d_cp *= plusminus;
00388   sin_dcp *= plusminus;
00389 
00390   //Now calculate the resonance terms for alpha expansion (C13) and s13 expansion (C12)
00391                                                                                                                        
00392   double C13 = TMath::Sqrt(sinsq_2th13+(A-cos_2th13)*(A-cos_2th13));
00393                                                                                                                        
00394   double C12 = 1;  //really C12 -> infinity when alpha = 0 but not an option really
00395   if(fabs(alpha) > 1e-10){  //want to be careful here
00396     double temp = cos_2th12 - A/alpha;
00397     C12 = TMath::Sqrt(sinsq_2th12+(temp*temp));
00398   }
00399                                                                                                                        
00400   //More complicated sin and cosine terms
00401   double cosC13Delta = cos(C13*Delta);
00402   double sinC13Delta = sin(C13*Delta);
00403   double sin1pADelta = sin((A+1)*Delta);
00404   double cos1pADelta = cos((A+1)*Delta);
00405   double sinADelta = sin((A)*Delta);
00406 
00407   double sin1pAmCDelta = sin(0.5*(A+1-C13)*Delta);
00408   double sin1pApCDelta = sin(0.5*(A+1+C13)*Delta);
00409 
00410   double cosaC12Delta = 0;
00411   double sinaC12Delta = 0;
00412                                                                                                                        
00413   if(fabs(alpha) > 1e-10){
00414     cosaC12Delta = cos(alpha*C12*Delta);
00415     sinaC12Delta = sin(alpha*C12*Delta);
00416   } // otherwise not relevant
00417 
00418   double sinApam2Delta = sin((A+alpha-2)*Delta);
00419   double cosApam2Delta = cos((A+alpha-2)*Delta);
00420   double sinAm1Delta = sin((A-1)*Delta);
00421   double cosAm1Delta = cos((A-1)*Delta);
00422   double sinDelta = sin(Delta);
00423   double sin2Delta = sin(2*Delta);
00424 
00425   double cosaC12pApam2Delta = 0;                                                                                                                       
00426   if(fabs(alpha) > 1e-10){
00427     cosaC12pApam2Delta = cos((alpha*C12+A+alpha-2)*Delta);
00428   }
00429 
00430   //First we calculate the terms for the alpha expansion (good to all orders in th13)
00431   // this is the equivalent of Eq 49 & 50 corrected for Mu to E instead of E to Mu
00432 
00433   // Leading order term
00434   double pmt_0 = 0.5*sinsq_2th23;
00435   pmt_0 *= (1 - (cos_2th13-A)/C13)*sin1pAmCDelta*sin1pAmCDelta 
00436              +  (1 + (cos_2th13-A)/C13)*sin1pApCDelta*sin1pApCDelta
00437              - 0.5*sinsq_2th13*sinC13Delta*sinC13Delta/(C13*C13);
00438 
00439   // terms that appear at order alpha
00440   double t0, t1, t2, t3;
00441   t0 = (cos_th12*cos_th12-sin_th12*sin_th12*sin_th13*sin_th13
00442           *(1+2*sin_th13*sin_th13*A+A*A)/(C13*C13))*cosC13Delta*sin1pADelta*2;
00443   t1 = 2*(cos_th12*cos_th12*cos_th13*cos_th13-cos_th12*cos_th12*sin_th13*sin_th13
00444          +sin_th12*sin_th12*sin_th13*sin_th13
00445          +(sin_th12*sin_th12*sin_th13*sin_th13-cos_th12*cos_th12)*A);
00446   t1 *= sinC13Delta*cos1pADelta/C13;
00447 
00448   t2 =  sin_th12*sin_th12*sinsq_2th13*sinC13Delta/(C13*C13*C13);
00449   t2 *= A/Delta*sin1pADelta+A/Delta*(cos_2th13-A)/C13*sinC13Delta
00450           - (1-A*cos_2th13)*cosC13Delta;
00451 
00452   double pmt_1 = -0.5*sinsq_2th23*Delta*(t0+t1+t2);   
00453 
00454   t0 = t1 = t2 = t3 = 0.0;
00455 
00456   t0 = cosC13Delta-cos1pADelta;
00457   t1 = 2*cos_th13*cos_th13*sin(d_cp)*sinC13Delta/C13*t0;
00458   t2 = -cos_2th23*cos_dcp*(1+A)*t0*t0;
00459 
00460   t3  = cos_2th23*cos_dcp*(sin1pADelta+(cos_2th13-A)/C13*sinC13Delta);
00461   t3 *= (1+2*sin_th13*sin_th13*A + A*A)*sinC13Delta/C13 - (1+A)*sin1pADelta;
00462 
00463 //  cout<<t1<<"  "<<t2<<"  "<<t3<<endl;
00464 
00465   if(fabs(A) > 1e-9) 
00466     pmt_1 = pmt_1 + (t1+t2+t3)*sin_th13*sin_2th12*sin_2th23/(2*A*cos_th13*cos_th13);
00467   else
00468     pmt_1 = pmt_1 + sin_th13*sin_2th12*sin_2th23*cos_th13*cos_th13*Delta*(2*sin_dcp*sinC13Delta*sinC13Delta+cos_dcp*cos_2th23*2*sinC13Delta*cosC13Delta);
00469 
00470   pmt_1 *= alpha;
00471 
00472   //  pmt_0 + pmt_1 is the complete contribution for this expansion
00473                                                                                                                        
00474   // Now for the expansion in orders of sin(th13) (good to all order alpha)
00475   //  this is the equivalent of Eq 67 and 68
00476                                                                                                                        
00477   // leading order term
00478   double pmt_a0 =  0.5*sinsq_2th23;
00479 
00480   pmt_a0 *= 1 - 0.5*sinsq_2th12*sinaC12Delta*sinaC12Delta/(C12*C12)
00481               - cosaC12pApam2Delta
00482               - (1 - (cos_2th12 - A/alpha)/C12)*sinaC12Delta*sinApam2Delta;
00483             
00484   double denom = (1-A-alpha+A*alpha*cos_th12*cos_th12)*C12;
00485 
00486   t0 = (cosaC12Delta-cosApam2Delta)*(cosaC12Delta-cosApam2Delta);
00487            
00488   t1 = (cos_2th12 - A/alpha)/C12*sinaC12Delta+sinApam2Delta;
00489             
00490   t2 = ((cos_2th12 - A/alpha)/C12+2*(1-alpha)/(alpha*A*C12))*sinaC12Delta
00491              + sinApam2Delta;
00492 
00493   t3 = (alpha*A*C12)/2.0*cos_2th23*cos_dcp*(t0 + t1*t2);
00494   
00495   t3 += sin_dcp*(1-alpha)*(cosaC12Delta-cosApam2Delta)*sinaC12Delta;
00496 
00497   double pmt_a1 = sin_th13*sin_2th12*sin_2th23/denom*t3;
00498 
00499   // pmt_a1+pmt_a2 is the complete contribution from this expansion
00500                                                                                                                        
00501   // In order to combine the information correctly we need to add the two
00502   //  expansions and subtract off the terms that are in both (alpha^1, s13^1)
00503   //  and lower order terms
00504   //  these may be taken from the expansion to second order in both parameters
00505   //  Equation 34
00506 
00507 
00508   // Now for the term of order alpha * s13 or lower order!
00509   t0 = t1 = t2 = t3 = 0.0;
00510 
00511   t1 = +sin_dcp*sinDelta*sinADelta*sinAm1Delta/(A*(A-1));
00512   t2 = -1/(A-1)*cos_dcp*sinDelta*(A*sinDelta-sinADelta*cosAm1Delta/A)*cos_2th23;
00513   t0 =  2*alpha*sin_2th12*sin_2th23*sin_th13*(t1+t2);
00514 
00515   t1 = sinsq_2th23*sinDelta*sinDelta 
00516        - alpha*sinsq_2th23*cos_th12*cos_th12*Delta*sin2Delta;
00517 
00518   double repeated = t0+t1;
00519 
00520   //  Calculate the total probability
00521   double totalP = pmt_0 + pmt_1 + pmt_a0 + pmt_a1 - repeated;
00522 
00523   return totalP;
00524 }

double OscCalc::Oscillate ( int  nuFlavor,
int  nonOscNuFlavor,
double  Energy,
double *  par 
)

Definition at line 20 of file OscCalc.cxx.

References Oscillate(), and SetOscParam().

00021 {
00022   SetOscParam(par);
00023   return Oscillate(nuFlavor, nonOscNuFlavor, Energy); 
00024 }

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

Definition at line 27 of file OscCalc.cxx.

References ElecToElec(), ElecToMu(), ElecToTau(), Msg::kInfo, OscPar::kNuAntiNu, MSG, MuToElec(), MuToMu(), MuToTau(), SetOscParam(), TauToElec(), TauToMu(), and TauToTau().

Referenced by NueSystematic::DoOscCalc(), ANtpTruthInfoBeamAna::GetOscProb(), NueStandard::GetOscWeight(), Oscillate(), NueSensitivity::OscillateMatter(), NueFCSensitivity::OscillateMatter(), Extrapolate2D::OscillatePrediction_NoSep(), Extrapolate2D::OscillatePrediction_SepNuNuBar(), Extrapolate2D::SetNominalOscProb(), NuOscProbCalc::ThreeFlavourNuMuToNuElectron(), NuOscProbCalc::ThreeFlavourNuMuToNuMu(), NuOscProbCalc::ThreeFlavourNuMuToNuTau(), and NC::OscProb::ThreeFlavor::TransitionProbability().

00028 {
00029 
00030 
00031   double x = Energy;
00032 
00033   if(nonOscNuFlavor > 0) SetOscParam(OscPar::kNuAntiNu, 1);
00034   else SetOscParam(OscPar::kNuAntiNu, -1);
00035 
00036   double prob = 0.0;
00037   if(abs(nonOscNuFlavor)==14) {
00038     if(abs(nuFlavor)==12)      prob = OscCalc::MuToElec(x);
00039     else if(abs(nuFlavor)==14) prob = OscCalc::MuToMu(x);
00040     else if(abs(nuFlavor)==16) prob = OscCalc::MuToTau(x);
00041   }
00042   if(abs(nonOscNuFlavor)==12) {
00043     if(abs(nuFlavor)==14) prob = OscCalc::ElecToMu(x);
00044     else if(abs(nuFlavor)==12) prob = OscCalc::ElecToElec(x);
00045     else if(abs(nuFlavor)==16) prob = OscCalc::ElecToTau(x);
00046   }
00047   if(abs(nonOscNuFlavor)==16) {
00048     if(abs(nuFlavor)==14) prob = OscCalc::TauToMu(x);
00049     else if(abs(nuFlavor)==12) prob = OscCalc::TauToElec(x);
00050     else if(abs(nuFlavor)==16) prob = OscCalc::TauToTau(x);
00051   } 
00052 
00053   if(prob < -1e-4 && Energy > 0.05){  //I'm sorry but the oscillations are just noisy at low E 
00054       MSG("OscCalc",Msg::kInfo)<<"P(<"<<nonOscNuFlavor<<"->"<<nuFlavor
00055                                <<") less than zero at E = "<<x<<" prob = "<<prob<<endl;
00056       prob = 0;
00057   } 
00058 
00059   return prob;
00060 }

double OscCalc::OscillateLSND ( int  nuFlavor,
int  nonOscNuFlavor,
double  E 
)

Definition at line 761 of file OscCalc.cxx.

References fOscPar, OscPar::kDensity, OscPar::kL, OscPar::kNuAntiNu, myPMNS_LSND, OscProb::PMNS_Sterile::P(), OscProb::PMNS_Sterile::PropMatter(), OscProb::PMNS_Sterile::ResetToFlavour(), UpdateLSND(), and OscPar::z_a.

Referenced by NueStandard::GetLSNDOscWeight(), Extrapolate2D::OscillatePrediction_NoSep(), Extrapolate2D::OscillatePrediction_SepNuNuBar(), and Extrapolate2D::SetNominalOscProb().

00762 {     
00763   UpdateLSND();
00764 
00765   int NuAntiNu = int(fOscPar[OscPar::kNuAntiNu]);
00766   double L = fOscPar[OscPar::kL];  //baseline
00767   
00768   // electron density in mol/cm^3
00769   double Ne = fOscPar[OscPar::kDensity]*OscPar::z_a;
00770 
00771   // Flavors
00772   int flvi = (abs(nonOscNuFlavor)-12)/2;           // Initial flavour: {0,1,2} for {e,mu,tau}
00773   int flvf = (abs(NuFlavor)-12)/2;                 // Final flavour: {0,1,2} for {e,mu,tau} 
00774 
00775   if(NuFlavor * NuAntiNu < 0){
00776     cout << "Warning: NuFlavor is " << (NuFlavor > 0 ? "positive" : "negative") 
00777          << ", but NuAntiNu is " << (NuAntiNu > 0 ? "positive" : "negative") << endl;
00778     cout << "Setting NuAntiNu = " << - NuAntiNu << " to agree with sign of NuFlavor..." << endl;
00779     NuAntiNu *= -1;
00780   }//Induce Flavor state if NuAntiNu is not set correctly
00781 
00782   // Reset the state to flvi
00783   myPMNS_LSND.ResetToFlavour(flvi);
00784 
00785   // Propagate through matter
00786   myPMNS_LSND.PropMatter(L, E, Ne, NuAntiNu);
00787 
00788   // Get the probability of flvf
00789   return myPMNS_LSND.P(flvf);
00790   
00791 
00792 }

double OscCalc::OscillateNSI ( int  nuFlavor,
int  nonOscNuFlavor,
double  E 
)

Definition at line 728 of file OscCalc.cxx.

References fOscPar, OscPar::kDensity, OscPar::kL, OscPar::kNuAntiNu, myPMNS_NSI, OscProb::PMNS_Fast::P(), OscProb::PMNS_Fast::PropMatter(), OscProb::PMNS_Fast::ResetToFlavour(), UpdateNSI(), and OscPar::z_a.

Referenced by NueStandard::GetNSIOscWeight(), NueStandard::GetOscWeight(), Extrapolate2D::OscillatePrediction_NoSep(), Extrapolate2D::OscillatePrediction_SepNuNuBar(), and Extrapolate2D::SetNominalOscProb().

00729 {     
00730   UpdateNSI();
00731 
00732   int NuAntiNu = int(fOscPar[OscPar::kNuAntiNu]);
00733   double L = fOscPar[OscPar::kL];  //baseline
00734   
00735   // electron density in mol/cm^3
00736   double Ne = fOscPar[OscPar::kDensity]*OscPar::z_a;
00737 
00738   // Flavors
00739   int flvi = (abs(nonOscNuFlavor)-12)/2;           // Initial flavour: {0,1,2} for {e,mu,tau}
00740   int flvf = (abs(NuFlavor)-12)/2;                 // Final flavour: {0,1,2} for {e,mu,tau} 
00741 
00742   if(NuFlavor * NuAntiNu < 0){
00743     cout << "Warning: NuFlavor is " << (NuFlavor > 0 ? "positive" : "negative") 
00744          << ", but NuAntiNu is " << (NuAntiNu > 0 ? "positive" : "negative") << endl;
00745     cout << "Setting NuAntiNu = " << - NuAntiNu << " to agree with sign of NuFlavor..." << endl;
00746     NuAntiNu *= -1;
00747   }//Induce Flavor state if NuAntiNu is not set correctly
00748 
00749   // Reset the state to flvi
00750   myPMNS_NSI.ResetToFlavour(flvi);
00751 
00752   // Propagate through matter
00753   myPMNS_NSI.PropMatter(L, E, Ne, NuAntiNu);
00754 
00755   // Get the probability of flvf
00756   return myPMNS_NSI.P(flvf);
00757   
00758 
00759 }

void OscCalc::SetOscParam ( OscPar::OscPar_t  pos,
double  val,
bool  force = false 
)

Definition at line 62 of file OscCalc.cxx.

References OscPar::A_av, MuELoss::e, fCos2Th, fCosDCP, fCosTh, fDmSqrDirty, fElecDensity, fLSNDDirty, fMixDirty, fNSIDirty, fOscPar, fSin2Th, fSinDCP, fSinTh, fV, OscPar::Gf, OscPar::invCmToeV, OscPar::invCmToGeV, OscPar::kDelta, OscPar::kDelta24, OscPar::kDelta_mutau, OscPar::kDeltaM12, OscPar::kDeltaM23, OscPar::kDensity, OscPar::kEps_ee, OscPar::kTh14, OscPar::root2, and OscPar::z_a.

00063 {
00064   if(fabs(fOscPar[pos] - val) > 1e-9 || force){
00065     fOscPar[pos] = val;
00066     if(pos < 3){
00067        fSinTh[pos] = sin(val);
00068        fCosTh[pos] = cos(val);
00069        fSin2Th[pos] = sin(2*val);
00070        fCos2Th[pos] = cos(2*val);
00071        fMixDirty = true;
00072     }
00073     if(pos == OscPar::kDensity){
00074       double ne = OscPar::z_a*OscPar::A_av*val; //electron density #/cm^{3}
00075       fElecDensity = ne*OscPar::invCmToeV*OscPar::invCmToGeV*OscPar::invCmToGeV;
00076       //electron density with units Gev^{2} eV
00077       //Gev^{2} to cancel with GeV^{-2} in Gf
00078                                                                                 
00079        fV = OscPar::root2*OscPar::Gf*fElecDensity; //eV
00080     }
00081     if(pos == OscPar::kDelta){
00082        fCosDCP = cos(val); 
00083        fSinDCP = sin(val);
00084        fMixDirty = true;
00085     }
00086     if(pos == OscPar::kDeltaM23 || pos == OscPar::kDeltaM12){
00087        fDmSqrDirty = true;
00088     }
00089     if(pos >= OscPar::kEps_ee && pos <= OscPar::kDelta_mutau){
00090        fNSIDirty = true;
00091     }
00092     if(pos >= OscPar::kTh14 && pos <= OscPar::kDelta24){
00093        fLSNDDirty = true;
00094     }
00095   }
00096 }

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

Definition at line 98 of file OscCalc.cxx.

References OscPar::kNumParameters.

Referenced by NueSystematic::DoOscCalc(), ANtpTruthInfoBeamAna::GetOscProb(), Extrapolate2D::InitializeOscCalc(), Extrapolate2D::InvertMassHierarchy(), OscCalc(), Oscillate(), NueSensitivity::OscillateMatter(), NueFCSensitivity::OscillateMatter(), Extrapolate2D_Simple::OscillatePrediction_NoSep(), Extrapolate2D::OscillatePrediction_NoSep(), Extrapolate2D_Simple::OscillatePrediction_SepNuNuBar(), Extrapolate2D::OscillatePrediction_SepNuNuBar(), Extrapolate2D::ReadExtrap(), Extrapolate2D_Simple::ReadFNFile(), Extrapolate2D::ReadFNFile(), Extrapolate2D_Simple::ReadFNFileNo3D(), NueSensitivity::RunStandardApproach(), NueFCSensitivity::RunStandardApproach(), NueStandard::SetDefaultOscParam(), Extrapolate2D::SetDelta_etau(), Extrapolate2D::SetDeltaCP(), Extrapolate2D::SetDm41(), Extrapolate2D::SetEps_etau(), Extrapolate2D::SetNominalOscProb(), NueStandard::SetOscNoMatter(), Extrapolate2D::SetOscPar(), NueStandard::SetOscParam(), NueSensitivity::SetOscParamBase(), NueFCSensitivity::SetOscParamBase(), NNTrain::SetOscParamBase(), NueSystematic::SetOscParams(), Extrapolate2D::SetSinSq2Th13(), Extrapolate2D::SetSinSq2Th14(), Extrapolate2D::SetSinSqTh24(), NuOscProbCalc::ThreeFlavourNuMuToNuElectron(), NuOscProbCalc::ThreeFlavourNuMuToNuMu(), NuOscProbCalc::ThreeFlavourNuMuToNuTau(), and NC::OscProb::ThreeFlavor::TransitionProbability().

00099 {
00100    for(int i = 0; i < int(OscPar::kNumParameters); i++){
00101      SetOscParam(OscPar::OscPar_t(i), par[i], force);
00102    }
00103 }

double OscCalc::TauToElec ( double  x  ) 

Definition at line 710 of file OscCalc.cxx.

References ElecToTau(), fOscPar, fSinDCP, and OscPar::kDelta.

Referenced by Oscillate().

00711 {
00712   // Flip delta to reverse direction
00713   double oldSinDelta = fSinDCP;
00714   double oldDelta =  fOscPar[OscPar::kDelta];
00715    
00716   fOscPar[OscPar::kDelta] = -oldDelta;
00717   fSinDCP = -oldSinDelta; 
00718                                
00719   double prob = OscCalc::ElecToTau(x);
00720                                  
00721   //restore the world 
00722   fOscPar[OscPar::kDelta] = oldDelta;
00723   fSinDCP = oldSinDelta; 
00724    
00725   return prob; 
00726 }  

double OscCalc::TauToMu ( double  x  ) 

Definition at line 692 of file OscCalc.cxx.

References fOscPar, fSinDCP, OscPar::kDelta, and MuToTau().

Referenced by Oscillate().

00693 {
00694   // Flip delta to reverse direction
00695   double oldSinDelta = fSinDCP;
00696   double oldDelta =  fOscPar[OscPar::kDelta];
00697   
00698   fOscPar[OscPar::kDelta] = -oldDelta;
00699   fSinDCP = -oldSinDelta;
00700                               
00701   double prob = OscCalc::MuToTau(x);
00702                                                                                       
00703   //restore the world
00704   fOscPar[OscPar::kDelta] = oldDelta;
00705   fSinDCP = oldSinDelta;
00706   
00707   return prob;
00708 } 

double OscCalc::TauToTau ( double  x  ) 

Definition at line 671 of file OscCalc.cxx.

References fCosTh, fSin2Th, fSinTh, OscPar::kTh23, and MuToMu().

Referenced by Oscillate().

00672 {
00673 //  TautoTau is the same as Mu->Mu wich sinsq_th23 <-> cossq_th23, sin(2th23) <->-sin(2th23)
00674   double origCos = fCosTh[OscPar::kTh23];
00675   double origSin = fSinTh[OscPar::kTh23];
00676   double orig2Sin = fSin2Th[OscPar::kTh23];
00677 
00678   fCosTh[OscPar::kTh23] = origSin;
00679   fSinTh[OscPar::kTh23] = origCos;
00680   fSin2Th[OscPar::kTh23] = -orig2Sin;
00681 
00682   double prob = OscCalc::MuToMu(x);
00683   
00684   //restore the world
00685   fCosTh[OscPar::kTh23] = origCos;
00686   fSinTh[OscPar::kTh23] = origSin;
00687   fSin2Th[OscPar::kTh23] = orig2Sin;
00688   
00689   return prob;
00690 } 

void OscCalc::UpdateLSND (  )  [private]

Definition at line 143 of file OscCalc.cxx.

References fDmSqrDirty, fLSNDDirty, fMixDirty, fOscPar, OscPar::kDelta, OscPar::kDelta14, OscPar::kDelta24, OscPar::kDeltaM12, OscPar::kDeltaM23, OscPar::kDm41, OscPar::kTh12, OscPar::kTh13, OscPar::kTh14, OscPar::kTh23, OscPar::kTh24, OscPar::kTh34, myPMNS_LSND, OscProb::PMNS_Sterile::SetAngle(), OscProb::PMNS_Sterile::SetDelta(), and OscProb::PMNS_Sterile::SetDm().

Referenced by OscillateLSND().

00143                         {   
00144 
00145    // Set the mass splittings
00146    if(fDmSqrDirty){
00147       double dmsq_32 = fOscPar[OscPar::kDeltaM23];
00148       double dmsq_21 = fOscPar[OscPar::kDeltaM12];
00149        
00150       double dmsq_31 = dmsq_32 + dmsq_21;      
00151 
00152       myPMNS_LSND.SetDm(2,dmsq_21);
00153       myPMNS_LSND.SetDm(3,dmsq_31);
00154 
00155    }
00156    
00157    // Set the mixings
00158    if(fMixDirty){
00159       double theta12 = fOscPar[OscPar::kTh12];
00160       double theta13 = fOscPar[OscPar::kTh13];
00161       double theta23 = fOscPar[OscPar::kTh23];
00162 
00163       double Delta_cp = fOscPar[OscPar::kDelta];
00164    
00165       myPMNS_LSND.SetAngle(1,2,theta12);
00166       myPMNS_LSND.SetAngle(1,3,theta13);
00167       myPMNS_LSND.SetAngle(2,3,theta23);
00168 
00169       myPMNS_LSND.SetDelta(1,3,Delta_cp);
00170 
00171    }
00172    
00173    // Set the LSND-style parameters
00174    if(fLSNDDirty){
00175       double theta14 = fOscPar[OscPar::kTh14];
00176       double theta24 = fOscPar[OscPar::kTh24];
00177       double theta34 = fOscPar[OscPar::kTh34]; 
00178       double dmsq_41 = fOscPar[OscPar::kDm41];
00179       double delta14 = fOscPar[OscPar::kDelta14];
00180       double delta24 = fOscPar[OscPar::kDelta24];
00181  
00182       myPMNS_LSND.SetAngle(1,4,theta14);
00183       myPMNS_LSND.SetAngle(2,4,theta24);
00184       myPMNS_LSND.SetAngle(3,4,theta34);
00185 
00186       myPMNS_LSND.SetDm(4,dmsq_41);
00187 
00188       myPMNS_LSND.SetDelta(1,4,delta14);
00189       myPMNS_LSND.SetDelta(2,4,delta24);
00190    }
00191 }

void OscCalc::UpdateNSI (  )  [private]

Definition at line 105 of file OscCalc.cxx.

References fDmSqrDirty, fMixDirty, fNSIDirty, fOscPar, OscPar::kDelta, OscPar::kDelta_emu, OscPar::kDelta_etau, OscPar::kDelta_mutau, OscPar::kDeltaM12, OscPar::kDeltaM23, OscPar::kEps_ee, OscPar::kEps_emu, OscPar::kEps_etau, OscPar::kEps_mumu, OscPar::kEps_mutau, OscPar::kEps_tautau, OscPar::kTh12, OscPar::kTh13, OscPar::kTh23, myPMNS_NSI, OscProb::PMNS_Fast::SetDeltaMsqrs(), OscProb::PMNS_Fast::SetMix(), and OscProb::PMNS_NSI::SetNSI().

Referenced by OscillateNSI().

00105                        {   
00106 
00107    // Set the mass splittings
00108    if(fDmSqrDirty){
00109       double dmsq_32 = fOscPar[OscPar::kDeltaM23];
00110       double dmsq_21 = fOscPar[OscPar::kDeltaM12];
00111    
00112       myPMNS_NSI.SetDeltaMsqrs(dmsq_21, dmsq_32);
00113    }
00114    
00115    // Set the mixings
00116    if(fMixDirty){
00117       double theta12 = fOscPar[OscPar::kTh12];
00118       double theta13 = fOscPar[OscPar::kTh13];
00119       double theta23 = fOscPar[OscPar::kTh23];
00120    
00121       double Delta_cp = fOscPar[OscPar::kDelta];
00122    
00123       myPMNS_NSI.SetMix(theta12,theta23,theta13,Delta_cp);
00124    }
00125    
00126    // Set the NSI parameters
00127    if(fNSIDirty){
00128       double Eps_ee = fOscPar[OscPar::kEps_ee];
00129       double Eps_emu = fOscPar[OscPar::kEps_emu];
00130       double Eps_etau = fOscPar[OscPar::kEps_etau];
00131       double Eps_mumu = fOscPar[OscPar::kEps_mumu];
00132       double Eps_mutau = fOscPar[OscPar::kEps_mutau];
00133       double Eps_tautau = fOscPar[OscPar::kEps_tautau];
00134    
00135       double Delta_emu = fOscPar[OscPar::kDelta_emu];
00136       double Delta_etau = fOscPar[OscPar::kDelta_etau];
00137       double Delta_mutau = fOscPar[OscPar::kDelta_mutau];
00138    
00139       myPMNS_NSI.SetNSI(Eps_ee,Eps_emu,Eps_etau,Eps_mumu,Eps_mutau,Eps_tautau,Delta_emu,Delta_etau,Delta_mutau);   
00140    }
00141 }


Member Data Documentation

double OscCalc::fCos2Th[3] [private]

Definition at line 120 of file OscCalc.h.

Referenced by ElecToElec(), MuToElec(), MuToTau(), and SetOscParam().

double OscCalc::fCosDCP [private]

Definition at line 124 of file OscCalc.h.

Referenced by MuToElec(), MuToTau(), and SetOscParam().

double OscCalc::fCosTh[3] [private]

Definition at line 118 of file OscCalc.h.

Referenced by ElecToTau(), MuToElec(), MuToTau(), SetOscParam(), and TauToTau().

bool OscCalc::fDmSqrDirty [private]

Definition at line 111 of file OscCalc.h.

Referenced by SetOscParam(), UpdateLSND(), and UpdateNSI().

double OscCalc::fElecDensity [private]

Definition at line 121 of file OscCalc.h.

Referenced by SetOscParam().

bool OscCalc::fLSNDDirty [private]

Definition at line 113 of file OscCalc.h.

Referenced by SetOscParam(), and UpdateLSND().

bool OscCalc::fMixDirty [private]

Definition at line 110 of file OscCalc.h.

Referenced by SetOscParam(), UpdateLSND(), and UpdateNSI().

bool OscCalc::fNSIDirty [private]

Definition at line 112 of file OscCalc.h.

Referenced by SetOscParam(), and UpdateNSI().

double OscCalc::fOscPar[OscPar::kNumParameters] [private]

Definition at line 115 of file OscCalc.h.

Referenced by ElecToElec(), ElecToMu(), GetOscParam(), MuToElec(), MuToTau(), OscillateLSND(), OscillateNSI(), SetOscParam(), TauToElec(), TauToMu(), UpdateLSND(), and UpdateNSI().

double OscCalc::fSin2Th[3] [private]

Definition at line 119 of file OscCalc.h.

Referenced by ElecToElec(), ElecToTau(), MuToElec(), MuToTau(), SetOscParam(), and TauToTau().

double OscCalc::fSinDCP [private]

Definition at line 123 of file OscCalc.h.

Referenced by ElecToElec(), ElecToMu(), MuToElec(), MuToTau(), SetOscParam(), TauToElec(), and TauToMu().

double OscCalc::fSinTh[3] [private]

Definition at line 117 of file OscCalc.h.

Referenced by ElecToElec(), ElecToTau(), MuToElec(), MuToTau(), SetOscParam(), and TauToTau().

double OscCalc::fV [private]

Definition at line 122 of file OscCalc.h.

Referenced by ElecToElec(), MuToElec(), MuToTau(), and SetOscParam().

OscProb::PMNS_Sterile OscCalc::myPMNS_LSND [private]

Definition at line 109 of file OscCalc.h.

Referenced by OscillateLSND(), and UpdateLSND().

OscProb::PMNS_NSI OscCalc::myPMNS_NSI [private]

Definition at line 108 of file OscCalc.h.

Referenced by OscillateNSI(), and UpdateNSI().


The documentation for this class was generated from the following files:
Generated on Fri Oct 10 22:46:16 2014 for loon by  doxygen 1.4.7