PMNS_Maltoni.h

Go to the documentation of this file.

 
 
#include "PMNS_Base.h"
#include <Eigen/Core>
 
#ifndef PMNS_BASEAVG_H
#define PMNS_BASEAVG_H
 
#include "PremModel.h"
 
namespace OscProb {
 
  class PMNS_Maltoni : public PMNS_Base {
    public:
      PMNS_Maltoni(int numNus); 
      virtual void SetPremModel(OscProb::PremModel& prem);
 
      using PMNS_Base::AvgProb;
      using PMNS_Base::AvgProbLoE;
 
      virtual double AvgProb(int flvi, int flvf, double E, double dE);
 
      virtual double AvgProb(int flvi, int flvf, double E, double cosT,
                             double dcosT);
 
      virtual double AvgProb(int flvi, int flvf, double E, double dE,
                             double cosT, double dcosT);
 
      virtual double AvgProbLoE(int flvi, int flvf, double LoE, double dLoE);
 
      virtual double AvgProbLoE(int flvi, int flvf, double LoE, double dLoE,
                                double cosT, double dcosT);
 
      virtual vectorD AvgProbVector(int flvi, double E, double dE);
 
      virtual vectorD AvgProbVectorLoE(int flvi, double LoE, double dLoE);
 
      virtual matrixD AvgProbMatrix(int nflvi, int nflvf, double E, double dE);
 
      virtual matrixD AvgProbMatrixLoE(int nflvi, int nflvf, double LoE,
                                       double dLoE);
 
      virtual double ExtrapolationProb(int flvi, int flvf, double E, double dE);
 
      virtual double ExtrapolationProbLoE(int flvi, int flvf, double LoE,
                                          double dLoE);
 
      virtual double ExtrapolationProbCosT(int flvi, int flvf, double cosT,
                                           double dcosT);
 
      virtual void SetIsOscProbAvg(bool isOscProbAvg);
 
    protected:
      virtual vectorD GetSamplePointsAvgClass(double LoE, double dLoE);
 
      virtual vectorD GetSamplePointsAvgClass(double E, double cosT,
                                              double dcosT);
 
      virtual matrixC GetSamplePointsAvgClass(double InvE, double dInvE,
                                              double cosT, double dcosT);
 
      virtual void UpdateHam() = 0; 
 
      virtual void InitializeTaylorsVectors();
 
      virtual void SetwidthBin(double dE, double dcosT);
 
      virtual void SetCosT(double cosT); 
 
      virtual void BuildKE(double L);
 
      virtual void BuildKcosT();
 
      virtual double LnDerivative();
 
      virtual void PropagatePathTaylor(NuPath p);
 
      virtual void PropagateTaylor();
 
      // Rotation from mass to flavor basis
      virtual void rotateS(); 
      virtual void rotateK(); 
 
      virtual void MultiplicationRuleS();
 
      virtual void MultiplicationRuleK(Eigen::MatrixXcd& K);
 
      void SolveK(Eigen::MatrixXcd& K, vectorD& lambda, matrixC& V);
 
      template <typename T>
      void TemplateSolver(Eigen::MatrixXcd& K, vectorD& lambda, matrixC& V);
 
      // Propagating
      virtual double AvgFormula(int flvi, int flvf, double dbin,
                                vectorD flambda, matrixC fV);
 
      virtual double AvgFormulaExtrapolation(int flvi, int flvf, double dE,
                                             vectorD flambda, matrixC fV);
 
      virtual double AvgAlgo(int flvi, int flvf, double LoE, double dLoE,
                             double L);
 
      virtual double AvgAlgo(int flvi, int flvf, double InvE, double dInvE,
                             double cosT, double dcosT);
 
      virtual double AvgAlgoCosT(int flvi, int flvf, double E, double cosT,
                                 double dcosT);
 
      virtual double AlgorithmDensityMatrix(int flvi, int flvf);
 
      virtual void RotateDensityM(bool to_basis, matrixC V);
 
      virtual void HadamardProduct(vectorD lambda, double dbin);
 
      double fcosT; 
 
      double fdInvE; 
      double fdcosT; 
 
      vectorD flambdaInvE; 
      vectorD flambdaCosT; 
      matrixC fVInvE;      
 
      Eigen::MatrixXcd fKInvE;
      Eigen::MatrixXcd fKcosT;
 
      matrixC fevolutionMatrixS;
      matrixC fVcosT;   
      matrixC fSflavor; 
      matrixC fKmass;   
      matrixC fKflavor; 
 
      matrixC fdensityMatrix; 
 
      // Variables for the compute of the derivation of one layer's length
      int    fLayer;     
      int    fdl;        
      double fDetRadius; 
      double fminRsq;    
 
      OscProb::PremModel fPrem;
 
      Eigen::MatrixXcd fHam; 
 
      bool fIsOscProbAvg; 
  };
 
} // namespace OscProb
 
#endif