OpProbability Class Reference

#include <OpProbability.h>

List of all members.

Public Member Functions

 OpProbability ()
 OpProbability (Double_t theta12, Double_t theta13, Double_t theta23, Double_t delta_m12_Sq, Double_t delta_m23_Sq, Double_t cpPhase, Double_t energy, Double_t length, Double_t matterParameter, Double_t m1)
 ~OpProbability ()
void PrintInput ()
void PrintResults ()
Double_t GetProbability ()

Private Member Functions

void Calculate_Trig_Variables ()
void Calculate_Mass_Matrix ()
void Calculate_Mass_In_Matter_Matrix ()
void Calculate_U_Matrix ()
void Calculate_U_e ()
void Calculate_U_mu ()
void Calculate_U_tau ()
void Calculate_H_Matrix ()
void Calculate_MX_Variables ()
void Calculate_fAlpha ()
void Calculate_fBeta ()
void Calculate_fGamma ()
void Calculate_MX ()
void Calculate_X_Matrix ()

Private Attributes

Double_t fTheta12
Double_t fTheta13
Double_t fTheta23
Double_t fDelta_m12_Sq
Double_t fDelta_m13_Sq
Double_t fDelta_m23_Sq
Double_t fCPPhase
Double_t fEnergy
Double_t fLength
Double_t fMatterParameter
Double_t fm1Sq
Double_t fm2Sq
Double_t fm3Sq
Double_t fS12
Double_t fS13
Double_t fS23
Double_t fC12
Double_t fC13
Double_t fC23
Double_t fAlpha
Double_t fBeta
Double_t fGamma
Double_t fM1Sq
Double_t fM2Sq
Double_t fM3Sq
OpMatrixfMassMatrix
OpMatrixfUMatrix
OpMatrixfHMatrix
OpMatrixfMassInMatterMatrix
OpMatrixfXMatrix
OpMatrixfUnitaryMatrix

Detailed Description

Definition at line 9 of file OpProbability.h.


Constructor & Destructor Documentation

OpProbability::OpProbability (  ) 

Definition at line 10 of file OpProbability.cxx.

00011 {
00012 
00013 }

OpProbability::OpProbability ( Double_t  theta12,
Double_t  theta13,
Double_t  theta23,
Double_t  delta_m12_Sq,
Double_t  delta_m23_Sq,
Double_t  cpPhase,
Double_t  energy,
Double_t  length,
Double_t  matterParameter,
Double_t  m1 
)

Definition at line 26 of file OpProbability.cxx.

References Calculate_H_Matrix(), Calculate_Mass_In_Matter_Matrix(), Calculate_Mass_Matrix(), Calculate_MX(), Calculate_MX_Variables(), Calculate_Trig_Variables(), Calculate_U_Matrix(), Calculate_X_Matrix(), fCPPhase, fDelta_m12_Sq, fDelta_m13_Sq, fDelta_m23_Sq, fEnergy, fHMatrix, fLength, fm1Sq, fm2Sq, fm3Sq, fMassInMatterMatrix, fMassMatrix, fMatterParameter, fTheta12, fTheta13, fTheta23, fUMatrix, fUnitaryMatrix, and fXMatrix.

00032 {
00033 
00034 //    cout << "OpProbability constructor" << endl;
00035 
00036   fMassMatrix = new OpMatrix(3, 3);
00037   fUMatrix = new OpMatrix(3, 3);
00038   fHMatrix = new OpMatrix(3, 3);
00039   fMassInMatterMatrix = new OpMatrix(3, 3);
00040   fXMatrix = new OpMatrix(3, 3);
00041   fUnitaryMatrix = new OpMatrix(3, 3);
00042   for(Int_t i = 1; i <= 3; i++) {
00043     (*fUnitaryMatrix)(i, i) = OpComplex(1, 0);
00044   }
00045 
00046 //    cout << "OpProbability constructor: allocated matrices" << endl;
00047 
00048   fTheta12 = theta12;
00049   fTheta13 = theta13;
00050   fTheta23 = theta23;
00051   fDelta_m12_Sq = delta_m12_Sq;
00052   fDelta_m23_Sq = delta_m23_Sq;
00053   fDelta_m13_Sq = fDelta_m12_Sq + fDelta_m23_Sq;
00054 
00055   fCPPhase = cpPhase;
00056   fEnergy = energy;
00057   fLength = length;
00058   fMatterParameter = matterParameter;
00059 
00060   fm1Sq = m1;
00061   fm2Sq = (-1 * fDelta_m12_Sq) + fm1Sq;
00062   fm3Sq = (-1 * fDelta_m13_Sq) + fm1Sq;
00063 
00064   //cout << "Calculating trig variables..." << endl;
00065 
00066   Calculate_Trig_Variables();
00067 
00068   //cout << "Calculating mass matrix..." << endl;
00069   Calculate_Mass_Matrix();
00070 
00071   //cout << "Calculating U matrix..." << endl;
00072   Calculate_U_Matrix();
00073 
00074   //cout << "Calculating H matrix..." << endl;
00075   Calculate_H_Matrix();
00076 
00077   //cout << "Calculating MX variables..." << endl;
00078   Calculate_MX_Variables();
00079 
00080   //cout << "Calculating MX..." << endl;
00081   Calculate_MX();
00082 
00083   //cout << "Calculating mass in matter matrix..." << endl;
00084   Calculate_Mass_In_Matter_Matrix();
00085 
00086   //cout << "Calculating X matrix..." << endl;
00087   Calculate_X_Matrix();
00088 
00089 //    PrintInput();
00090 //    PrintResults();
00091 }

OpProbability::~OpProbability (  ) 

Definition at line 15 of file OpProbability.cxx.

References fHMatrix, fMassInMatterMatrix, fMassMatrix, fUMatrix, fUnitaryMatrix, and fXMatrix.

00016 {
00017   if(fMassMatrix != 0) delete fMassMatrix;
00018   if(fUMatrix != 0) delete fUMatrix;
00019   if(fHMatrix != 0) delete fHMatrix;
00020   if(fMassInMatterMatrix != 0) delete fMassInMatterMatrix;
00021   if(fXMatrix != 0) delete fXMatrix;
00022   if(fUnitaryMatrix != 0) delete fUnitaryMatrix;
00023 }


Member Function Documentation

void OpProbability::Calculate_fAlpha (  )  [private]

Definition at line 205 of file OpProbability.cxx.

References fAlpha, fDelta_m12_Sq, fDelta_m13_Sq, fEnergy, and fMatterParameter.

Referenced by Calculate_MX_Variables().

00206 {
00207   fAlpha = fDelta_m12_Sq + fDelta_m13_Sq + 2*fEnergy*fMatterParameter;
00208 
00209 //    cout << " fAlpha:" << "\t" << fAlpha << endl;
00210 }

void OpProbability::Calculate_fBeta (  )  [private]

Definition at line 213 of file OpProbability.cxx.

References fBeta, fDelta_m12_Sq, fDelta_m13_Sq, fEnergy, fMatterParameter, and fUMatrix.

Referenced by Calculate_MX_Variables().

00214 {
00215   Double_t left, right;
00216   
00217   right = 2 * fEnergy * fMatterParameter 
00218     * (fDelta_m12_Sq * (1 - TMath::Power((*fUMatrix)(1,2).GetModulus(), 2.))
00219       + fDelta_m13_Sq * (1 - TMath::Power((*fUMatrix)(1,3).GetModulus(), 2.)));
00220 
00221 //    right = (fEnergy / (2. * 1.27)) * fMatterParameter 
00222 //      * (fDelta_m12_Sq * (1 - TMath::Power((*fUMatrix)(1,2).GetModulus(), 2.))
00223 //        + fDelta_m13_Sq * (1 - TMath::Power((*fUMatrix)(1,3).GetModulus(), 2.)));
00224 
00225   left = fDelta_m12_Sq * fDelta_m13_Sq;
00226 
00227   fBeta = left + right;
00228 
00229 //    cout << " fBeta:" << "\t" << fBeta << endl;
00230 }

void OpProbability::Calculate_fGamma (  )  [private]

Definition at line 232 of file OpProbability.cxx.

References fDelta_m12_Sq, fDelta_m13_Sq, fEnergy, fGamma, fMatterParameter, and fUMatrix.

Referenced by Calculate_MX_Variables().

00233 {
00234 
00235   fGamma = 2 * fEnergy * fMatterParameter * fDelta_m12_Sq * fDelta_m13_Sq 
00236     * TMath::Power((*fUMatrix)(1,1).GetModulus(), 2.);
00237 
00238 //      fGamma = (fEnergy / (2. * 1.27)) * fMatterParameter * fDelta_m12_Sq 
00239 //        * fDelta_m13_Sq 
00240 //        * TMath::Power((*fUMatrix)(1,1).GetModulus(), 2.);
00241 //    cout << " fGamma:" << "\t" << fGamma << endl;
00242 }

void OpProbability::Calculate_H_Matrix (  )  [private]

Definition at line 170 of file OpProbability.cxx.

References fEnergy, fMassMatrix, fMatterParameter, fUMatrix, OpMatrix::GetTransposeConjugate(), and OpComplex::SetReal().

Referenced by OpProbability().

00171 {
00172   OpComplex coefficient;
00173   coefficient.SetReal(1. / (2. * fEnergy)); 
00174 
00175   OpComplex matterParameter;
00176   matterParameter.SetReal(fMatterParameter);
00177 
00178   OpMatrix *UMatrixDagger = fUMatrix->GetTransposeConjugate();
00179 
00180   for(Int_t j = 1; j <= 3; j++) {
00181     
00182     for(Int_t k = 1; k <= 3; k++) {
00183 
00184       (*fHMatrix)(k, j) = coefficient * (*fMassMatrix)(j, k) 
00185         - matterParameter * (*fUMatrix)(1, j) 
00186         * (*UMatrixDagger)(k, 1);
00187     }
00188   }
00189 
00190   delete UMatrixDagger;
00191 
00192 //    cout << "Leaving Calculate_H_Matrix()..." << endl;
00193 }

void OpProbability::Calculate_Mass_In_Matter_Matrix (  )  [private]

Definition at line 293 of file OpProbability.cxx.

References fM1Sq, fM2Sq, and fM3Sq.

Referenced by OpProbability().

00294 {
00295 
00296 //    cout << "Calculate_Mass_In_Matter_Matrix()" << "\n"
00297 //         << "\t fM1Sq: " << fM1Sq
00298 //         << "\t fM2Sq: " << fM2Sq
00299 //         << "\t fM3Sq: " << fM3Sq << endl;
00300 
00301   (*fMassInMatterMatrix)(1, 1).SetReal(fM1Sq);
00302   (*fMassInMatterMatrix)(2, 2).SetReal(fM2Sq);
00303   (*fMassInMatterMatrix)(3, 3).SetReal(fM3Sq);
00304 }

void OpProbability::Calculate_Mass_Matrix (  )  [private]

Definition at line 93 of file OpProbability.cxx.

References fm1Sq, fm2Sq, and fm3Sq.

Referenced by OpProbability().

00094 {
00095   (*fMassMatrix)(1, 1).SetReal(fm1Sq);
00096   (*fMassMatrix)(2, 2).SetReal(fm2Sq);
00097   (*fMassMatrix)(3, 3).SetReal(fm3Sq);
00098 }

void OpProbability::Calculate_MX (  )  [private]

Definition at line 244 of file OpProbability.cxx.

References Error, fAlpha, fBeta, fGamma, fm1Sq, fM1Sq, fM2Sq, and fM3Sq.

Referenced by OpProbability().

00245 {
00246   Double_t coefficient;
00247 
00248   coefficient = -(2./3.)*TMath::Sqrt((fAlpha*fAlpha) - 3. * fBeta);
00249 
00250   Double_t arcCosArgument;
00251   Double_t numerator, denominator;
00252 
00253   numerator = (2. * (fAlpha * fAlpha * fAlpha)) - (9. * fAlpha * fBeta) 
00254     + (27. * fGamma);
00255   denominator = 2. * TMath::Power((fAlpha * fAlpha) - (3. * fBeta), (3. / 2.));
00256 
00257   if(denominator == 0) {
00258     if(numerator == 0) {
00259       arcCosArgument = 0;
00260     }
00261     else {
00262       Error("OpProbability::Calculate_MX()", "Trying to divide by zero");
00263       arcCosArgument = 0;
00264     }
00265   }
00266   else {
00267     arcCosArgument = numerator / denominator;
00268   }
00269 
00270   if(TMath::Abs(arcCosArgument) > 1.) {
00271     Error("OpProbability::Calculate_MX()", 
00272           "ACos() argument = %.20e.  Numerator = %.20e.  Denominator = %.20e",
00273           arcCosArgument, numerator, denominator);
00274     arcCosArgument = 1.;
00275   }
00276 
00277   Double_t arcCosValue = TMath::ACos(arcCosArgument);
00278 
00279   fM3Sq = coefficient * TMath::Cos((1./3.) * (arcCosValue - (2*TMath::Pi())))
00280     + fm1Sq - (fAlpha / 3.);
00281 
00282   fM1Sq = coefficient * TMath::Cos((1./3.) * (arcCosValue + (2*TMath::Pi())))
00283     + fm1Sq - (fAlpha / 3.);
00284 
00285   fM2Sq = coefficient * TMath::Cos((1./3.) * (arcCosValue))
00286     + fm1Sq - (fAlpha / 3.);
00287 
00288 //    cout << "fM1Sq: " << fM1Sq << endl;
00289 //    cout << "fM2Sq: " << fM2Sq << endl;
00290 //    cout << "fM3Sq: " << fM3Sq << endl;
00291 }

void OpProbability::Calculate_MX_Variables (  )  [private]

Definition at line 195 of file OpProbability.cxx.

References Calculate_fAlpha(), Calculate_fBeta(), and Calculate_fGamma().

Referenced by OpProbability().

00196 {
00197 //    cout << "Calculating MX variables..." << endl;
00198 
00199   Calculate_fAlpha();
00200   Calculate_fBeta();
00201   Calculate_fGamma();
00202 
00203 }

void OpProbability::Calculate_Trig_Variables (  )  [private]

Definition at line 100 of file OpProbability.cxx.

References fC12, fC13, fC23, fS12, fS13, fS23, fTheta12, fTheta13, and fTheta23.

Referenced by OpProbability().

00101 {
00102 //    cout << "Calculating trig variables..." << endl;
00103 
00104   fS12 = TMath::Sin(fTheta12);
00105   fS13 = TMath::Sin(fTheta13);
00106   fS23 = TMath::Sin(fTheta23);
00107 
00108   fC12 = TMath::Cos(fTheta12);
00109   fC13 = TMath::Cos(fTheta13);
00110   fC23 = TMath::Cos(fTheta23);
00111 }

void OpProbability::Calculate_U_e (  )  [private]

Definition at line 120 of file OpProbability.cxx.

References fC12, fC13, fCPPhase, fS12, fS13, OpComplex::SetArgument(), OpComplex::SetModulus(), and OpComplex::SetReal().

Referenced by Calculate_U_Matrix().

00121 {
00122   OpComplex e1, e2, e3;
00123 
00124   e1.SetReal(fC12 * fC13);
00125 
00126   e2.SetReal(fS12 * fC13);
00127 
00128   e3.SetModulus(fS13);
00129   e3.SetArgument(-fCPPhase);
00130 
00131   (*fUMatrix)(1, 1) = e1;
00132   (*fUMatrix)(1, 2) = e2;
00133   (*fUMatrix)(1, 3) = e3;
00134 }

void OpProbability::Calculate_U_Matrix (  )  [private]

Definition at line 113 of file OpProbability.cxx.

References Calculate_U_e(), Calculate_U_mu(), and Calculate_U_tau().

Referenced by OpProbability().

00114 {
00115   Calculate_U_e();
00116   Calculate_U_mu();
00117   Calculate_U_tau();
00118 }

void OpProbability::Calculate_U_mu (  )  [private]

Definition at line 136 of file OpProbability.cxx.

References fC12, fC13, fC23, fCPPhase, fS12, fS13, fS23, and OpComplex::SetReal().

Referenced by Calculate_U_Matrix().

00137 {
00138   OpComplex mu1, mu2, mu3;
00139   
00140   mu1.SetReal(-fC23 * fS12);
00141   mu1 = mu1 - OpComplex(fC12 * fS23 * fS13, fCPPhase);
00142 
00143   mu2.SetReal(fC12 * fC23);
00144   mu2 = mu2 - OpComplex(fS12 * fS23 * fS13, fCPPhase);
00145 
00146   mu3.SetReal(fC13 * fS23);
00147 
00148   (*fUMatrix)(2, 1) = mu1;
00149   (*fUMatrix)(2, 2) = mu2;
00150   (*fUMatrix)(2, 3) = mu3;
00151 }

void OpProbability::Calculate_U_tau (  )  [private]

Definition at line 153 of file OpProbability.cxx.

References fC12, fC13, fC23, fCPPhase, fS12, fS13, fS23, and OpComplex::SetReal().

Referenced by Calculate_U_Matrix().

00154 {
00155   OpComplex tau1, tau2, tau3;
00156   
00157   tau1.SetReal(fS12 * fS23);
00158   tau1 = tau1 - OpComplex(fC12 * fC23 * fS13, fCPPhase);
00159 
00160   tau2.SetReal(-fC12 * fS23);
00161   tau2 = tau2 - OpComplex(fC23 * fS12 * fS13, fCPPhase);
00162 
00163   tau3.SetReal(fC13 * fC23);
00164 
00165   (*fUMatrix)(3, 1) = tau1;
00166   (*fUMatrix)(3, 2) = tau2;
00167   (*fUMatrix)(3, 3) = tau3;
00168 }

void OpProbability::Calculate_X_Matrix (  )  [private]

Definition at line 308 of file OpProbability.cxx.

References fEnergy, fHMatrix, fLength, fMassInMatterMatrix, fUnitaryMatrix, OpComplex::SetArgument(), OpComplex::SetModulus(), OpComplex::SetReal(), and OpMatrix::Zero().

Referenced by OpProbability().

00309 {
00310 //    cout << "Entering Calculate_X_Matrix()" << endl;
00311   OpComplex energyTerm;
00312   OpComplex expTerm;
00313 
00314   OpMatrix energyHMatrix(3, 3);
00315   OpMatrix massInMatterIdentityMatrix(3, 3);
00316 
00317   OpMatrix productMatrix(3, 3);
00318   OpMatrix productMatrixOne(3, 3);
00319   OpMatrix productMatrixOneNumerator(3, 3);
00320   OpComplex productMatrixOneDenominator;
00321   OpMatrix productMatrixTwoNumerator(3, 3);
00322   OpComplex productMatrixTwoDenominator;
00323   OpMatrix productMatrixTwo(3, 3);
00324   OpMatrix sumComponent(3, 3);
00325 
00326   energyTerm.SetReal(2. * fEnergy);
00327 //    energyTerm.SetReal(fEnergy / (2.*1.27));
00328 
00329 //    cout << "H Matrix: " << endl;
00330 //    fHMatrix->Print();
00331 
00332 //    cout << "Energy term: " << energyTerm.Re() << " i" << energyTerm.Im() 
00333 //         << endl;
00334 
00335   energyHMatrix = *fHMatrix;
00336 
00337 //    cout << "E * H Matrix after assignment but before multiplication: " << endl;
00338 
00339 //    energyHMatrix.Print();
00340 
00341   energyHMatrix *= energyTerm;
00342 
00343   
00344 //    cout << "E * H Matrix: " << endl;
00345 
00346 //    energyHMatrix.Print();
00347 
00348 //    cout << "Calculating sums and products" << endl;
00349 
00350   for(Int_t k = 1; k <= 3; k++) {
00351     Bool_t matrixOneNotFilled = kTRUE;
00352 
00353     productMatrixOneNumerator.Zero();
00354     productMatrix.Zero();
00355     productMatrixOne.Zero();
00356     productMatrixOneNumerator.Zero();
00357     productMatrixOneDenominator = OpComplex(0, 0);
00358     productMatrixTwoNumerator.Zero();
00359     productMatrixTwoDenominator = OpComplex(0, 0);
00360     productMatrixTwo.Zero();
00361     sumComponent.Zero();
00362 
00363     for(Int_t j = 1; j <= 3; j++) {
00364       if(j == k) {
00365         continue;
00366       }
00367       else{
00368         if(matrixOneNotFilled) {
00369 //        cout << "k = " << k << " j = " << j << endl;
00370 
00371 //        cout << "H * E matrix" << endl;
00372 //        ((*fHMatrix) * energyTerm).Print(); 
00373 //        cout << "Mj matrix" << endl;
00374 //        ((*fUnitaryMatrix)*(*fMassInMatterMatrix)(j, j)).Print();
00375 
00376 //        cout << "Calculating productMatrixOne" << endl;
00377 
00378           massInMatterIdentityMatrix = *fUnitaryMatrix;
00379           massInMatterIdentityMatrix *= (*fMassInMatterMatrix)(j, j);
00380 
00381           productMatrixOneNumerator += energyHMatrix;
00382 
00383 //        productMatrixOneNumerator.Print();
00384 
00385           productMatrixOneNumerator -= massInMatterIdentityMatrix;
00386 
00387 //        productMatrixOneNumerator.Print();
00388 
00389           productMatrixOneDenominator = ((*fMassInMatterMatrix)(k, k) 
00390                                - (*fMassInMatterMatrix)(j, j));
00391 
00392           productMatrixOne = productMatrixOneNumerator;
00393           productMatrixOne /= productMatrixOneDenominator;
00394 
00395 //        productMatrixOneNumerator =  ((*fHMatrix) * energyTerm 
00396 //                                      - (*fUnitaryMatrix)
00397 //                                      *(*fMassInMatterMatrix)(j, j));
00398 
00399 //        productMatrixOne = productMatrixOneNumerator 
00400 //          / productMatrixOneDenominator;
00401             
00402 //        (OpMatrix) productMatrixOne = (OpMatrix) ((*fHMatrix) * energyTerm 
00403 //                            - (*fUnitaryMatrix)*(*fMassInMatterMatrix)(j, j))
00404 //          / ((*fMassInMatterMatrix)(k, k) - (*fMassInMatterMatrix)(j, j));
00405 
00406 //        cout << "Product matrix one calculated" << endl;
00407 //        productMatrixOne.Print();
00408 
00409           matrixOneNotFilled = kFALSE;
00410         }
00411         else{
00412           massInMatterIdentityMatrix = *fUnitaryMatrix;
00413           massInMatterIdentityMatrix *= (*fMassInMatterMatrix)(j, j);
00414 
00415           productMatrixTwoNumerator += energyHMatrix;
00416           productMatrixTwoNumerator -= massInMatterIdentityMatrix;
00417 
00418           productMatrixTwoDenominator = ((*fMassInMatterMatrix)(k, k) 
00419                                - (*fMassInMatterMatrix)(j, j));
00420 
00421           productMatrixTwo = productMatrixTwoNumerator;
00422           productMatrixTwo /= productMatrixTwoDenominator;
00423 
00424 
00425 
00426 //        productMatrixTwo = ((*fHMatrix) * energyTerm 
00427 //                            - (*fUnitaryMatrix)*(*fMassInMatterMatrix)(j, j))
00428 //          / ((*fMassInMatterMatrix)(k, k) - (*fMassInMatterMatrix)(j, j));
00429 
00430 //        cout << "Product matrix two calculated" << endl;
00431 //        productMatrixTwo.Print();
00432         }
00433       }
00434     }
00435 
00436     productMatrix = productMatrixOne;
00437     productMatrix *= productMatrixTwo;
00438 
00439 //        cout << "Product matrix" << endl;
00440 //        productMatrix.Print();
00441 
00442     expTerm.SetModulus(1);
00443     expTerm.SetArgument(-(*fMassInMatterMatrix)(k, k).GetReal() * fLength
00444                         * (2. * 1.27) / (fEnergy));
00445 
00446 
00447 //        cout << "Exponential term: " << endl;
00448 //        cout << expTerm.Re() << " + i" << expTerm.Im() << endl;
00449 //        cout << "Argument: " << expTerm.GetArgument() << endl;
00450     
00451     sumComponent = productMatrix;
00452     sumComponent *= expTerm;
00453 
00454 //      cout << "Adding the following to X Matrix: " << endl;
00455 //      sumComponent.Print();
00456     (*fXMatrix) += sumComponent;
00457   }
00458 
00459 //    cout << "Final X Matrix: " << endl;
00460 //    fXMatrix->Print();
00461 
00462 //    cout << "Leaving Calculate_X_Matrix()" << endl;
00463 
00464 }

Double_t OpProbability::GetProbability (  ) 

Definition at line 466 of file OpProbability.cxx.

References fUMatrix, fXMatrix, OpComplex::GetModulus(), and OpMatrix::GetTransposeConjugate().

00467 {
00468   OpMatrix *UMatrixDagger = fUMatrix->GetTransposeConjugate();
00469 
00470   OpComplex amplitude;
00471 
00472   for(Int_t i = 1; i <= 3; i++) {
00473       for(Int_t j = 1; j <= 3; j++) {
00474         amplitude = amplitude + (*fUMatrix)(2,i) * (*fXMatrix)(i,j)  
00475           * (*UMatrixDagger)(j, 1);
00476       }
00477   }
00478 
00479   delete UMatrixDagger;
00480   return TMath::Power(amplitude.GetModulus(), 2.);
00481 }

void OpProbability::PrintInput (  ) 

Definition at line 499 of file OpProbability.cxx.

00500 {
00501 //    cout << "Intput..." << endl;
00502 //    cout << " Theta12:" << "\t" << fTheta12 << endl;
00503 //    cout << " Theta13:" << "\t" << fTheta13 << endl;
00504 //    cout << " Theta23:" << "\t" << fTheta23 << endl;
00505 //    cout << " DeltaM12Sq:" << "\t" << -1. * fDeltaM21Sq << endl;
00506 //    cout << " DeltaM23Sq:" << "\t" << fDeltaM23Sq << endl;
00507 //    cout << " DeltaM31Sq:" << "\t" << fDeltaM31Sq << endl;
00508 //    cout << " CP Phase:" << "\t" << fDelta << endl;
00509 //    cout << " Energy:" << "\t" << fEnergy << endl;
00510 //    cout << " Length:" << "\t" << fLength << endl;
00511 //    cout << " Time:" << "\t" << fTime << endl;
00512 //    cout << " Density:" << "\t" << fD << endl;
00513 //    cout << " m1:" << "\t" << fm1Sq << endl;
00514 //    cout << " m2:" << "\t" << fm2Sq << endl;
00515 //    cout << " m3:" << "\t" << fm3Sq << endl;
00516 }

void OpProbability::PrintResults (  ) 

Definition at line 484 of file OpProbability.cxx.

References fHMatrix, fMassInMatterMatrix, fMassMatrix, fUMatrix, fXMatrix, and OpMatrix::Print().

00485 {
00486   cout << "Mass matrix:" << endl;
00487   fMassMatrix->Print();
00488   cout << "U matrix:" << endl;
00489   fUMatrix->Print();
00490   cout << "H matrix:" << endl;
00491   fHMatrix->Print();
00492   cout << "Mass in matter matrix:" << endl;
00493   fMassInMatterMatrix->Print();
00494   cout << "X matrix:" << endl;
00495   fXMatrix->Print();
00496 }


Member Data Documentation

Double_t OpProbability::fAlpha [private]

Definition at line 37 of file OpProbability.h.

Referenced by Calculate_fAlpha(), and Calculate_MX().

Double_t OpProbability::fBeta [private]

Definition at line 38 of file OpProbability.h.

Referenced by Calculate_fBeta(), and Calculate_MX().

Double_t OpProbability::fC12 [private]
Double_t OpProbability::fC13 [private]
Double_t OpProbability::fC23 [private]

Definition at line 35 of file OpProbability.h.

Referenced by Calculate_Trig_Variables(), Calculate_U_mu(), and Calculate_U_tau().

Double_t OpProbability::fCPPhase [private]

Definition at line 20 of file OpProbability.h.

Referenced by Calculate_U_e(), Calculate_U_mu(), Calculate_U_tau(), and OpProbability().

Double_t OpProbability::fDelta_m12_Sq [private]

Definition at line 17 of file OpProbability.h.

Referenced by Calculate_fAlpha(), Calculate_fBeta(), Calculate_fGamma(), and OpProbability().

Double_t OpProbability::fDelta_m13_Sq [private]

Definition at line 18 of file OpProbability.h.

Referenced by Calculate_fAlpha(), Calculate_fBeta(), Calculate_fGamma(), and OpProbability().

Double_t OpProbability::fDelta_m23_Sq [private]

Definition at line 19 of file OpProbability.h.

Referenced by OpProbability().

Double_t OpProbability::fEnergy [private]
Double_t OpProbability::fGamma [private]

Definition at line 39 of file OpProbability.h.

Referenced by Calculate_fGamma(), and Calculate_MX().

Definition at line 47 of file OpProbability.h.

Referenced by Calculate_X_Matrix(), OpProbability(), PrintResults(), and ~OpProbability().

Double_t OpProbability::fLength [private]

Definition at line 22 of file OpProbability.h.

Referenced by Calculate_X_Matrix(), and OpProbability().

Double_t OpProbability::fM1Sq [private]

Definition at line 41 of file OpProbability.h.

Referenced by Calculate_Mass_In_Matter_Matrix(), and Calculate_MX().

Double_t OpProbability::fm1Sq [private]

Definition at line 25 of file OpProbability.h.

Referenced by Calculate_Mass_Matrix(), Calculate_MX(), and OpProbability().

Double_t OpProbability::fM2Sq [private]

Definition at line 42 of file OpProbability.h.

Referenced by Calculate_Mass_In_Matter_Matrix(), and Calculate_MX().

Double_t OpProbability::fm2Sq [private]

Definition at line 26 of file OpProbability.h.

Referenced by Calculate_Mass_Matrix(), and OpProbability().

Double_t OpProbability::fM3Sq [private]

Definition at line 43 of file OpProbability.h.

Referenced by Calculate_Mass_In_Matter_Matrix(), and Calculate_MX().

Double_t OpProbability::fm3Sq [private]

Definition at line 27 of file OpProbability.h.

Referenced by Calculate_Mass_Matrix(), and OpProbability().

Definition at line 48 of file OpProbability.h.

Referenced by Calculate_X_Matrix(), OpProbability(), PrintResults(), and ~OpProbability().

Definition at line 45 of file OpProbability.h.

Referenced by Calculate_H_Matrix(), OpProbability(), PrintResults(), and ~OpProbability().

Double_t OpProbability::fMatterParameter [private]
Double_t OpProbability::fS12 [private]
Double_t OpProbability::fS13 [private]
Double_t OpProbability::fS23 [private]

Definition at line 31 of file OpProbability.h.

Referenced by Calculate_Trig_Variables(), Calculate_U_mu(), and Calculate_U_tau().

Double_t OpProbability::fTheta12 [private]

Definition at line 14 of file OpProbability.h.

Referenced by Calculate_Trig_Variables(), and OpProbability().

Double_t OpProbability::fTheta13 [private]

Definition at line 15 of file OpProbability.h.

Referenced by Calculate_Trig_Variables(), and OpProbability().

Double_t OpProbability::fTheta23 [private]

Definition at line 16 of file OpProbability.h.

Referenced by Calculate_Trig_Variables(), and OpProbability().

Definition at line 50 of file OpProbability.h.

Referenced by Calculate_X_Matrix(), OpProbability(), and ~OpProbability().

Definition at line 49 of file OpProbability.h.

Referenced by GetProbability(), OpProbability(), PrintResults(), and ~OpProbability().


The documentation for this class was generated from the following files:

Generated on 2 Nov 2017 for loon by  doxygen 1.6.1