OscProb: OscProb::PMNS_LIV Class Reference

References OscProb::PMNS_Maltoni::fdcosT, OscProb::PMNS_Maltoni::fdensityMatrix, OscProb::PMNS_Maltoni::fdInvE, OscProb::PMNS_Maltoni::fevolutionMatrixS, OscProb::PMNS_Maltoni::flambdaCosT, OscProb::PMNS_Maltoni::flambdaInvE, OscProb::PMNS_Maltoni::fVcosT, OscProb::PMNS_Maltoni::fVInvE, OscProb::PMNS_Maltoni::HadamardProduct(), OscProb::PMNS_Base::kGeV2eV, and OscProb::PMNS_Maltoni::RotateDensityM().

Referenced by OscProb::PMNS_Base::AddPath(), OscProb::PMNS_Base::SetAtt(), OscProb::PMNS_Base::SetPath(), and SetTestPath().

◆ AlgorithmDensityMatrix()

double PMNS_Maltoni::AlgorithmDensityMatrix	(	int	flvi,
		int	flvf
	)

protectedvirtualinherited

Algorithm for the transformations on the density matrix

Parameters

flvi	- The neutrino starting flavour.
flvf	- The neutrino final flavour.

Returns: Average neutrino oscillation probability

Definition at line 1099 of file PMNS_Maltoni.cxx.

{
  fdensityMatrix[flvi][flvi] = 1;
 
  RotateDensityM(true, fVcosT);
  HadamardProduct(flambdaCosT, fdcosT);
  RotateDensityM(false, fVcosT);
 
  RotateDensityM(true, fVInvE);
  HadamardProduct(flambdaInvE, fdInvE / kGeV2eV);
  RotateDensityM(false, fVInvE);
 
  RotateDensityM(false, fevolutionMatrixS);
 
  return real(fdensityMatrix[flvf][flvf]);
}

Referenced by OscProb::PMNS_Maltoni::AvgAlgo().

◆ AvgAlgo() [1/2]

double PMNS_Maltoni::AvgAlgo	(	int	flvi,
		int	flvf,
		double	InvE,
		double	dInvE,
		double	cosT,
		double	dcosT
	)

protectedvirtualinherited

Algorithm for the compute of the average probability over a bin of 1oE and cosT

Algorithm for computing the average probability over a bin of 1oE and cosT

Parameters

flvi	- The neutrino starting flavour.
flvf	- The neutrino final flavour.
InvE	- The neutrino 1/E value in the bin center in GeV-1
dInvE	- The 1/E bin width in GeV-1
cosT	- The cosine of the neutrino angle
dcosT	- The cosT bin width

Returns: Average neutrino oscillation probability

Definition at line 1065 of file PMNS_Maltoni.cxx.

{
  fPrem.FillPath(cosT);
  SetPath(fPrem.GetNuPath());
 
  // reset K et S et Ve et lambdaE
  InitializeTaylorsVectors();
 
  SetEnergy(1 / InvE);
  SetCosT(cosT);
  SetwidthBin(dInvE, dcosT);
 
  fminRsq = pow(fDetRadius * sqrt(1 - cosT * cosT), 2);
 
  // Propagate -> get S and K matrix (on the whole path)
  PropagateTaylor();
 
  // DiagolK -> get VE and lambdaE
  SolveK(fKInvE, flambdaInvE, fVInvE);
  SolveK(fKcosT, flambdaCosT, fVcosT);
 
  return AlgorithmDensityMatrix(flvi, flvf);
}

◆ AvgAlgo() [2/2]

double PMNS_Maltoni::AvgAlgo	(	int	flvi,
		int	flvf,
		double	LoE,
		double	dLoE,
		double	L
	)

protectedvirtualinherited

Algorithm for the compute of the average probability over a bin of LoE

Parameters

flvi	- The neutrino starting flavour.
flvf	- The neutrino final flavour.
LoE	- The neutrino L/E value in the bin center in km/GeV
dLoE	- The L/E bin width in km/GeV
L	- The length of the path in km

Returns: Average neutrino oscillation probability

Definition at line 594 of file PMNS_Maltoni.cxx.

{
  // Set width bin as 1/E
  double d1oE = dLoE / L;
 
  // reset K et S et Ve et lambdaE
  InitializeTaylorsVectors();
 
  SetEnergy(L / LoE);
  SetwidthBin(d1oE, 0);
 
  // Propagate -> get S and K matrix (on the whole path)
  PropagateTaylor();
 
  // DiagolK -> get VE and lambdaE
  SolveK(fKInvE, flambdaInvE, fVInvE);
 
  // return fct avr proba
  return AvgFormula(flvi, flvf, d1oE / kGeV2eV, flambdaInvE, fVInvE);
}

References OscProb::PMNS_Maltoni::AvgFormula(), OscProb::PMNS_Maltoni::fKInvE, OscProb::PMNS_Maltoni::flambdaInvE, OscProb::PMNS_Maltoni::fVInvE, OscProb::PMNS_Maltoni::InitializeTaylorsVectors(), OscProb::PMNS_Base::kGeV2eV, OscProb::PMNS_Maltoni::PropagateTaylor(), OscProb::PMNS_Base::SetEnergy(), OscProb::PMNS_Maltoni::SetwidthBin(), and OscProb::PMNS_Maltoni::SolveK().

Referenced by OscProb::PMNS_Maltoni::AvgProbLoE(), OscProb::PMNS_Maltoni::AvgProbMatrixLoE(), and OscProb::PMNS_Maltoni::AvgProbVectorLoE().

◆ AvgAlgoCosT()

double PMNS_Maltoni::AvgAlgoCosT	(	int	flvi,
		int	flvf,
		double	E,
		double	cosT,
		double	dcosT
	)

protectedvirtualinherited

Algorithm for the compute of the average probability over a bin of cosT

Parameters

flvi	- The neutrino starting flavour.
flvf	- The neutrino final flavour.
E	- The neutrino energy in GeV
cosT	- The cosine of the neutrino angle
dcosT	- The cosT bin width

Returns: Average neutrino oscillation probability

Definition at line 913 of file PMNS_Maltoni.cxx.

{
  // reset K et S et Ve et lambdaE
  InitializeTaylorsVectors();
 
  SetEnergy(E);
  SetCosT(cosT);
  SetwidthBin(0, dcosT);
 
  fPrem.FillPath(cosT);
  SetPath(fPrem.GetNuPath());
 
  fminRsq = pow(fDetRadius * sqrt(1 - cosT * cosT), 2);
 
  // Propagate -> get S and K matrix (on the whole path)
  PropagateTaylor();
 
  // DiagolK -> get VE and lambdaE
  SolveK(fKcosT, flambdaCosT, fVcosT);
  // Compute average
  return AvgFormula(flvi, flvf, fdcosT, flambdaCosT, fVcosT);
}

◆ AvgFormula()

double PMNS_Maltoni::AvgFormula	(	int	flvi,
		int	flvf,
		double	dbin,
		vectorD	lambda,
		matrixC	V
	)

protectedvirtualinherited

Formula for the average probability of flvi going to flvf over a bin of width dbin using the Maltoni method.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

flvi	- The neutrino starting flavour.
flvf	- The neutrino final flavour.
dbin	- The width of the bin
lambda	- The eigenvalues of K
V	- The eigenvectors of K

Returns: Average neutrino oscillation probability

Definition at line 450 of file PMNS_Maltoni.cxx.

{
  vectorC SV = vectorC(fNumNus, 0);
 
  for (int i = 0; i < fNumNus; i++) {
    for (int k = 0; k < fNumNus; k++) {
      SV[i] += fevolutionMatrixS[flvf][k] * V[k][i];
    }
  }
 
  complexD buffer[fNumNus];
 
  for (int n = 0; n < fNumNus; n++) { buffer[n] = SV[n] * conj(V[flvi][n]); }
 
  complexD sinc[fNumNus][fNumNus];
  for (int j = 0; j < fNumNus; j++) {
    sinc[j][j] = 1;
    for (int i = 0; i < j; i++) {
      double arg = (lambda[i] - lambda[j]) * dbin / 2;
      sinc[i][j] = sin(arg) / arg;
      sinc[j][i] = sinc[i][j];
    }
  }
 
  complexD P = 0;
 
  for (int j = 0; j < fNumNus; j++) {
    for (int i = 0; i < fNumNus; i++) {
      P += buffer[i] * conj(buffer[j]) * sinc[j][i];
    }
  }
 
  return real(P);
}

References OscProb::PMNS_Maltoni::fevolutionMatrixS, OscProb::PMNS_Base::fNumNus, and OscProb::PMNS_Base::P().

Referenced by OscProb::PMNS_Maltoni::AvgAlgo(), OscProb::PMNS_Maltoni::AvgAlgoCosT(), OscProb::PMNS_Maltoni::AvgProb(), OscProb::PMNS_Maltoni::AvgProbMatrixLoE(), and OscProb::PMNS_Maltoni::AvgProbVectorLoE().

◆ AvgFormulaExtrapolation()

double PMNS_Maltoni::AvgFormulaExtrapolation	(	int	flvi,
		int	flvf,
		double	dE,
		vectorD	lambda,
		matrixC	V
	)

protectedvirtualinherited

Fomula for the propability for flvi going to flvf for an energy E+dE using the Maltoni method from a reference energy E.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

flvi	- The neutrino starting flavour.
flvf	- The neutrino final flavour.
dE	- The energy variation in GeV
lambda	- The eigenvalues of K
V	- The eigenvectors of K

Returns: Neutrino oscillation probability

Definition at line 1289 of file PMNS_Maltoni.cxx.

{
  vectorC SV = vectorC(fNumNus, 0);
 
  for (int i = 0; i < fNumNus; i++) {
    for (int k = 0; k < fNumNus; k++) {
      SV[i] += fevolutionMatrixS[flvf][k] * V[k][i];
    }
  }
 
  complexD buffer[fNumNus];
  for (int n = 0; n < fNumNus; n++) { buffer[n] = SV[n] * conj(V[flvi][n]); }
 
  complexD expo[fNumNus][fNumNus];
 
  for (int j = 0; j < fNumNus; j++) {
    for (int i = 0; i < fNumNus; i++) {
      double arg = (lambda[j] - lambda[i]) * dE;
      expo[j][i] = exp(complexD(0.0, arg));
    }
  }
 
  complexD P = 0;
 
  for (int j = 0; j < fNumNus; j++) {
    for (int i = 0; i < fNumNus; i++) {
      P += buffer[i] * conj(buffer[j]) * expo[j][i];
    }
  }
 
  return real(P);
}

References OscProb::PMNS_Maltoni::fevolutionMatrixS, OscProb::PMNS_Base::fNumNus, and OscProb::PMNS_Base::P().

Referenced by OscProb::PMNS_Maltoni::ExtrapolationProb(), OscProb::PMNS_Maltoni::ExtrapolationProbCosT(), and OscProb::PMNS_Maltoni::ExtrapolationProbLoE().

◆ AvgProb() [1/5]

double PMNS_Maltoni::AvgProb	(	int	flvi,
		int	flvf,
		double	E,
		double	cosT,
		double	dcosT
	)

virtualinherited

Compute the average probability over a bin of cosTheta with a Taylor expansion

Compute the average probability of flvi going to flvf over a bin of angle cost with width dcosT using the Maltoni method.

IMPORTANT: The PremModel object used must be set by this class using the function SetPremModel.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

flvi	- The neutrino starting flavour.
flvf	- The neutrino final flavour.
E	- The neutrino energy in GeV
cosT	- The cosine of the neutrino angle
dcosT	- The cosT bin width

Returns: Average neutrino oscillation probability

Definition at line 876 of file PMNS_Maltoni.cxx.

{
  // reset K et S et Ve et lambdaE
  InitializeTaylorsVectors();
 
  SetEnergy(E);
  SetCosT(cosT);
  SetwidthBin(0, dcosT);
 
  fPrem.FillPath(cosT);
  SetPath(fPrem.GetNuPath());
 
  fminRsq = pow(fDetRadius * sqrt(1 - cosT * cosT), 2);
 
  // Propagate -> get S and K matrix (on the whole path)
  PropagateTaylor();
 
  // DiagolK -> get VE and lambdaE
  SolveK(fKcosT, flambdaCosT, fVcosT);
 
  // Compute average
  return AvgFormula(flvi, flvf, fdcosT, flambdaCosT, fVcosT);
}

◆ AvgProb() [2/5]

double PMNS_Maltoni::AvgProb	(	int	flvi,
		int	flvf,
		double	E,
		double	dE
	)

virtualinherited

Compute the average probability over a bin of energy with a Taylor expansion

Compute the average probability of flvi going to flvf over a bin of energy E with width dE using the Maltoni method.

This gets transformed into L/E, since the oscillation terms have arguments linear in 1/E and not E.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

flvi	- The neutrino starting flavour.
flvf	- The neutrino final flavour.
E	- The neutrino energy in GeV
dE	- The energy bin width in GeV

Returns: Average neutrino oscillation probability

Reimplemented from OscProb::PMNS_Base.

Definition at line 507 of file PMNS_Maltoni.cxx.

{
  if (fIsOscProbAvg == true) return PMNS_Base::AvgProb(flvi, flvf, E, dE);
 
  // Do nothing if energy not positive
  if (E <= 0) return 0;
 
  if (fNuPaths.empty()) return 0;
 
  // Don't average zero width
  if (dE <= 0) return Prob(flvi, flvf, E);
 
  vectorD LoEbin = ConvertEtoLoE(E, dE);
 
  // Compute average in LoE
  return AvgProbLoE(flvi, flvf, LoEbin[0], LoEbin[1]);
}

References OscProb::PMNS_Base::AvgProb(), OscProb::PMNS_Maltoni::AvgProbLoE(), OscProb::PMNS_Base::ConvertEtoLoE(), OscProb::PMNS_Maltoni::fIsOscProbAvg, OscProb::PMNS_Base::fNuPaths, and OscProb::PMNS_Base::Prob().

Referenced by OscProb::PMNS_Maltoni::AvgProb(), and OscProb::PMNS_Maltoni::AvgProbLoE().

◆ AvgProb() [3/5]

double PMNS_Maltoni::AvgProb	(	int	flvi,
		int	flvf,
		double	E,
		double	dE,
		double	cosT,
		double	dcosT
	)

virtualinherited

Compute the average probabilit over a bin of cosTheta and energy with a Taylor expansion

Compute the average probability of flvi going to flvf over a bin of energy E and angle cosT with width dE and dcosT using the Maltoni method.

IMPORTANT: The PremModel object used must be set by this class using the function SetPremModel.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

flvi	- The neutrino starting flavour.
flvf	- The neutrino final flavour.
E	- The neutrino energy in GeV
dE	- The energy bin width in GeV
cosT	- The cosine of the neutrino angle
dcosT	- The cosT bin width

Returns: Average neutrino oscillation probability

Definition at line 961 of file PMNS_Maltoni.cxx.

{
  if (E <= 0) return 0;
  if (cosT > 0) return 0;
 
  if (fNuPaths.empty()) return 0;
  // Don't average zero width
  if (dE <= 0 && dcosT == 0) return Prob(flvi, flvf, E);
  if (dE <= 0) return AvgProb(flvi, flvf, E, cosT, dcosT);
  if (dcosT == 0) return AvgProb(flvi, flvf, E, dE);
 
  vectorD Ebin = ConvertEtoLoE(E, dE);
 
  // Compute average in LoE
  return AvgProbLoE(flvi, flvf, Ebin[0], Ebin[1], cosT, dcosT);
}

References OscProb::PMNS_Maltoni::AvgProb(), OscProb::PMNS_Maltoni::AvgProbLoE(), OscProb::PMNS_Base::ConvertEtoLoE(), OscProb::PMNS_Base::fNuPaths, and OscProb::PMNS_Base::Prob().

◆ AvgProb() [4/5]

double PMNS_Base::AvgProb	(	int	flvi,
		int	flvf,
		double	E,
		double	dE = `0`
	)

virtualinherited

Compute the average probability of flvi going to flvf over a bin of energy E with width dE.

This gets transformed into L/E, since the oscillation terms have arguments linear in L/E and not E.

This function works best for single paths. In multiple paths the accuracy may be somewhat worse. If needed, average over smaller energy ranges.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

flvi	- The neutrino starting flavour.
flvf	- The neutrino final flavour.
E	- The neutrino energy in the bin center in GeV
dE	- The energy bin width in GeV

Returns: Average neutrino oscillation probability

Reimplemented from OscProb::PMNS_Base.

Definition at line 98 of file PMNS_Base.cxx.

{
  ResetToFlavour(flvi);
 
  return AvgProb(fNuState, flvf, E, dE);
}

◆ AvgProb() [5/5]

double PMNS_Base::AvgProb	(	vectorC	nu_in,
		int	flvf,
		double	E,
		double	dE = `0`
	)

virtualinherited

Compute the average probability of nu_in going to flvf over a bin of energy E with width dE.

This gets transformed into L/E, since the oscillation terms have arguments linear in L/E and not E.

This function works best for single paths. In multiple paths the accuracy may be somewhat worse. If needed, average over smaller energy ranges.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

nu_in	- The neutrino initial state in flavour.
flvf	- The neutrino final flavour.
E	- The neutrino energy in the bin center in GeV
dE	- The energy bin width in GeV

Returns: Average neutrino oscillation probability

Reimplemented from OscProb::PMNS_Base.

Definition at line 88 of file PMNS_Base.cxx.

{
  // Do nothing if energy is not positive
  if (E <= 0) return 0;
 
  if (fNuPaths.empty()) return 0;
 
  // Don't average zero width
  if (dE <= 0) return Prob(nu_in, flvf, E);
 
  vectorD LoEbin = ConvertEtoLoE(E, dE);
 
  // Compute average in LoE
  return AvgProbLoE(nu_in, flvf, LoEbin[0], LoEbin[1]);
}

◆ AvgProbLoE() [1/4]

double PMNS_Maltoni::AvgProbLoE	(	int	flvi,
		int	flvf,
		double	LoE,
		double	dLoE
	)

virtualinherited

Compute the average probability over a bin of LoE with a Taylor expansion

Compute the average probability of flvi going to flvf over a bin of energy L/E with width dLoE using the Maltoni method.

The probabilities are weighted by (L/E)^-2 so that event density is flat in energy. This avoids giving too much weight to low energies. Better approximations would be achieved if we used an interpolated event density.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

flvi	- The neutrino starting flavour.
flvf	- The neutrino final flavour.
LoE	- The neutrino L/E value in the bin center in km/GeV
dLoE	- The L/E bin width in km/GeV

Returns: Average neutrino oscillation probability

Reimplemented from OscProb::PMNS_Base.

Definition at line 548 of file PMNS_Maltoni.cxx.

{
  if (fIsOscProbAvg == true)
    return PMNS_Base::AvgProbLoE(flvi, flvf, LoE, dLoE);
 
  if (LoE <= 0) return 0;
 
  if (fNuPaths.empty()) return 0;
 
  // Don't average zero width
  if (dLoE <= 0) return Prob(flvi, flvf, fPath.length / LoE);
 
  // Get sample points for this bin
  vectorD samples = GetSamplePointsAvgClass(LoE, dLoE);
 
  double avgprob = 0;
  double L       = fPath.length;
  double sumw    = 0;
 
  // Loop over all sample points
  for (int j = 1; j < int(samples.size()); j++) {
    // Set (L/E)^-2 weights
    double w = 1. / pow(samples[j], 2);
 
    avgprob += w * AvgAlgo(flvi, flvf, samples[j], samples[0], L);
 
    // Increment sum of weights
    sumw += w;
  }
 
  // Return weighted average of probabilities
  return avgprob / sumw;
}

References OscProb::PMNS_Maltoni::AvgAlgo(), OscProb::PMNS_Base::AvgProbLoE(), OscProb::PMNS_Maltoni::fIsOscProbAvg, OscProb::PMNS_Base::fNuPaths, OscProb::PMNS_Base::fPath, OscProb::PMNS_Maltoni::GetSamplePointsAvgClass(), OscProb::NuPath::length, and OscProb::PMNS_Base::Prob().

Referenced by OscProb::PMNS_Maltoni::AvgProb(), and OscProb::PMNS_Maltoni::AvgProbLoE().

◆ AvgProbLoE() [2/4]

double PMNS_Maltoni::AvgProbLoE	(	int	flvi,
		int	flvf,
		double	LoE,
		double	dLoE,
		double	cosT,
		double	dcosT
	)

virtualinherited

Compute the average probability over a bin of cosTheta and LoE with a Taylor expansion

Compute the average probability of flvi going to flvf over a bin of energy L/E and cosT with width dLoE and dcosT using the Maltoni method.

The probabilities are weighted by (L/E)^-2 so that event density is flat in energy. This avoids giving too much weight to low energies. Better approximations would be achieved if we used an interpolated event density.

IMPORTANT: The PremModel object used must be set by this class using the function SetPremModel.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

flvi	- The neutrino starting flavour.
flvf	- The neutrino final flavour.
LoE	- The neutrino L/E value in the bin center in km/GeV
dLoE	- The L/E bin width in km/GeV
cosT	- The cosine of the neutrino angle
dcosT	- The cosT bin width

Returns: Average neutrino oscillation probability

chg ici

Definition at line 1008 of file PMNS_Maltoni.cxx.

{
  if (LoE <= 0) return 0;
  if (cosT > 0) return 0;
 
  // if (fNuPaths.empty()) return 0;
 
  // Don't average zero width
  if (dLoE <= 0 && dcosT == 0) return Prob(flvi, flvf, fPath.length / LoE);
  if (dLoE <= 0)
    return AvgProb(flvi, flvf, fPath.length / LoE, cosT, dcosT); 
  if (dcosT == 0) return AvgProbLoE(flvi, flvf, LoE, dLoE);
 
  // Make sample with 1oE and not LoE
  matrixC samples = GetSamplePointsAvgClass(LoE / fPath.length,
                                            dLoE / fPath.length, cosT, dcosT);
 
  int rows = samples.size();
  int cols = samples[0].size();
 
  double avgprob = 0;
  double sumw    = 0;
 
  // Loop over all sample points
  for (int k = 1; k < int(rows); k++) {
    for (int l = 1; l < int(cols); l++) {
      // Set (L/E)^-2 weights
      double w = 1. / pow(real(samples[k][l]), 2);
 
      avgprob +=
          w * AvgAlgo(flvi, flvf, real(samples[k][l]), real(samples[0][0]),
                      imag(samples[k][l]), imag(samples[0][0]));
 
      // Increment sum of weights
      sumw += w;
    }
  }
 
  // Return average of probabilities
  return avgprob / ((sumw));
}

References OscProb::PMNS_Maltoni::AvgAlgo(), OscProb::PMNS_Maltoni::AvgProb(), OscProb::PMNS_Maltoni::AvgProbLoE(), OscProb::PMNS_Base::fPath, OscProb::PMNS_Maltoni::GetSamplePointsAvgClass(), OscProb::NuPath::length, and OscProb::PMNS_Base::Prob().

◆ AvgProbLoE() [3/4]

double PMNS_Base::AvgProbLoE	(	int	flvi,
		int	flvf,
		double	LoE,
		double	dLoE = `0`
	)

virtualinherited

Compute the average probability of flvi going to flvf over a bin of L/E with width dLoE.

The probabilities are weighted by (L/E)^-2 so that event density is flat in energy. This avoids giving too much weight to low energies. Better approximations would be achieved if we used an interpolated event density.

This function works best for single paths. In multiple paths the accuracy may be somewhat worse. If needed, average over smaller L/E ranges.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

flvi	- The neutrino starting flavour.
flvf	- The neutrino final flavour.
LoE	- The neutrino L/E value in the bin center in km/GeV
dLoE	- The L/E bin width in km/GeV

Returns: Average neutrino oscillation probability

Reimplemented from OscProb::PMNS_Base.

Definition at line 102 of file PMNS_Base.cxx.

{
  ResetToFlavour(flvi);
 
  return AvgProbLoE(fNuState, flvf, LoE, dLoE);
}

◆ AvgProbLoE() [4/4]

double PMNS_Base::AvgProbLoE	(	vectorC	nu_in,
		int	flvf,
		double	LoE,
		double	dLoE = `0`
	)

virtualinherited

Compute the average probability of nu_in going to flvf over a bin of L/E with width dLoE.

The probabilities are weighted by (L/E)^-2 so that event density is flat in energy. This avoids giving too much weight to low energies. Better approximations would be achieved if we used an interpolated event density.

This function works best for single paths. In multiple paths the accuracy may be somewhat worse. If needed, average over smaller L/E ranges.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

nu_in	- The neutrino intial state in flavour basis.
flvf	- The neutrino final flavour.
LoE	- The neutrino L/E value in the bin center in km/GeV
dLoE	- The L/E bin width in km/GeV

Returns: Average neutrino oscillation probability

Reimplemented from OscProb::PMNS_Base.

Definition at line 92 of file PMNS_Base.cxx.

{
  // Do nothing if L/E is not positive
  if (LoE <= 0) return 0;
 
  if (fNuPaths.empty()) return 0;
 
  // Make sure fPath is set
  // Use average if multiple paths
  SetCurPath(AvgPath(fNuPaths));
 
  // Set the energy at bin center
  SetEnergy(fPath.length / LoE);
 
  // Don't average zero width
  if (dLoE <= 0) return Prob(nu_in, flvf);
 
  // Get sample points for this bin
  vectorD samples = GetSamplePoints(LoE, dLoE);
 
  // Variables to fill sample
  // probabilities and weights
  double sumw   = 0;
  double prob   = 0;
  double length = fPath.length;
 
  // Loop over all sample points
  for (int j = 0; j < int(samples.size()); j++) {
    // Set (L/E)^-2 weights
    double w = 1. / pow(samples[j], 2);
 
    // Add weighted probability
    prob += w * Prob(nu_in, flvf, length / samples[j]);
 
    // Increment sum of weights
    sumw += w;
  }
 
  // Return weighted average of probabilities
  return prob / sumw;
}

◆ AvgProbMatrix()

matrixD PMNS_Maltoni::AvgProbMatrix	(	int	nflvi,
		int	nflvf,
		double	E,
		double	dE
	)

virtualinherited

Compute the average probability matrix over a bin of energy using a Taylor expansion

Compute the average probability matrix for nflvi and nflvf over a bin of energy E with width dE using the Maltoni method.

Parameters

nflvi	- The number of initial flavours in the matrix.
nflvf	- The number of final flavours in the matrix.
E	- The neutrino energy in the bin center in GeV
dE	- The energy bin width in GeV

Returns: Average neutrino oscillation probabilities

Reimplemented from OscProb::PMNS_Base.

Definition at line 767 of file PMNS_Maltoni.cxx.

{
  if (fIsOscProbAvg == true)
    return PMNS_Base::AvgProbMatrix(nflvi, nflvf, E, dE);
 
  matrixD probs(nflvi, vectorD(nflvf, 0));
 
  // Do nothing if energy is not positive
  if (E <= 0) return probs;
 
  if (fNuPaths.empty()) return probs;
 
  // Don't average zero width
  if (dE <= 0) return ProbMatrix(nflvi, nflvf, E);
 
  vectorD LoEbin = ConvertEtoLoE(E, dE);
 
  // Compute average in LoE
  return AvgProbMatrixLoE(nflvi, nflvf, LoEbin[0], LoEbin[1]);
}

References OscProb::PMNS_Base::AvgProbMatrix(), OscProb::PMNS_Maltoni::AvgProbMatrixLoE(), OscProb::PMNS_Base::ConvertEtoLoE(), OscProb::PMNS_Maltoni::fIsOscProbAvg, OscProb::PMNS_Base::fNuPaths, and OscProb::PMNS_Base::ProbMatrix().

◆ AvgProbMatrixLoE()

matrixD PMNS_Maltoni::AvgProbMatrixLoE	(	int	nflvi,
		int	nflvf,
		double	LoE,
		double	dLoE
	)

virtualinherited

Compute the average probability matrix over a bin of L/E using a Taylor expansion

Compute the average probability matrix for nflvi and nflvf over a bin of L/E with width dLoE using the Maltoni method.

Parameters

nflvi	- The number of initial flavours in the matrix.
nflvf	- The number of final flavours in the matrix.
LoE	- The neutrino L/E value in the bin center in km/GeV
dLoE	- The L/E bin width in km/GeV

Returns: Average neutrino oscillation probabilities

Reimplemented from OscProb::PMNS_Base.

Definition at line 800 of file PMNS_Maltoni.cxx.

{
  if (fIsOscProbAvg == true)
    return PMNS_Base::AvgProbMatrixLoE(nflvi, nflvf, LoE, dLoE);
 
  matrixD probs(nflvi, vectorD(nflvf, 0));
 
  if (LoE <= 0) return probs;
 
  if (fNuPaths.empty()) return probs;
 
  double L = fPath.length;
 
  // Don't average zero width
  if (dLoE <= 0) return ProbMatrix(nflvi, nflvf, L / LoE);
 
  // Get sample points for this bin
  vectorD samples = GetSamplePointsAvgClass(LoE, dLoE);
 
  double sumw = 0;
 
  // Loop over all sample points
  for (int j = 1; j < int(samples.size()); j++) {
    // Set (L/E)^-2 weights
    double w = 1. / pow(samples[j], 2);
 
    for (int flvi = 0; flvi < nflvi; flvi++) {
      for (int flvf = 0; flvf < nflvf; flvf++) {
        // if (!TryCacheK())
        if (flvi == 0 && flvf == 0)
          probs[flvi][flvf] +=
              w * AvgAlgo(flvi, flvf, samples[j], samples[0], L);
        else
          probs[flvi][flvf] +=
              w * AvgFormula(flvi, flvf, fdInvE / kGeV2eV, flambdaInvE, fVInvE);
      }
    }
 
    // Increment sum of weights
    sumw += w;
  }
 
  for (int flvi = 0; flvi < nflvi; flvi++) {
    for (int flvf = 0; flvf < nflvf; flvf++) {
      // Divide by total sampling weight
      probs[flvi][flvf] /= sumw;
    }
  }
 
  // Return weighted average of probabilities
  return probs;
}

References OscProb::PMNS_Maltoni::AvgAlgo(), OscProb::PMNS_Maltoni::AvgFormula(), OscProb::PMNS_Base::AvgProbMatrixLoE(), OscProb::PMNS_Maltoni::fdInvE, OscProb::PMNS_Maltoni::fIsOscProbAvg, OscProb::PMNS_Maltoni::flambdaInvE, OscProb::PMNS_Base::fNuPaths, OscProb::PMNS_Base::fPath, OscProb::PMNS_Maltoni::fVInvE, OscProb::PMNS_Maltoni::GetSamplePointsAvgClass(), OscProb::PMNS_Base::kGeV2eV, OscProb::NuPath::length, and OscProb::PMNS_Base::ProbMatrix().

Referenced by OscProb::PMNS_Maltoni::AvgProbMatrix().

◆ AvgProbVector() [1/2]

vectorD PMNS_Maltoni::AvgProbVector	(	int	flvi,
		double	E,
		double	dE
	)

virtualinherited

Compute the average probability vector over a bin of energy using a Taylor expansion

Compute the average probability of flvi going to any flavour over a bin of energy E with width dE using the Maltoni method.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

flvi	- The neutrino starting flavour.
E	- The neutrino energy in GeV
dE	- The energy bin width in GeV

Returns: Average probability for all outgoing flavours

Reimplemented from OscProb::PMNS_Base.

Definition at line 671 of file PMNS_Maltoni.cxx.

{
  if (fIsOscProbAvg == true) return PMNS_Base::AvgProbVector(flvi, E, dE);
 
  vectorD probs(fNumNus, 0);
 
  // Do nothing if energy is not positive
  if (E <= 0) return probs;
 
  if (fNuPaths.empty()) return probs;
 
  // Don't average zero width
  if (dE <= 0) return ProbVector(flvi, E);
 
  vectorD LoEbin = ConvertEtoLoE(E, dE);
 
  // Compute average in LoE
  return AvgProbVectorLoE(flvi, LoEbin[0], LoEbin[1]);
}

References OscProb::PMNS_Base::AvgProbVector(), OscProb::PMNS_Maltoni::AvgProbVectorLoE(), OscProb::PMNS_Base::ConvertEtoLoE(), OscProb::PMNS_Maltoni::fIsOscProbAvg, OscProb::PMNS_Base::fNumNus, OscProb::PMNS_Base::fNuPaths, and OscProb::PMNS_Base::ProbVector().

◆ AvgProbVector() [2/2]

vectorD PMNS_Base::AvgProbVector	(	vectorC	nu_in,
		double	E,
		double	dE = `0`
	)

virtualinherited

Compute the average probability vector over a bin of energy

Compute the average probability of nu_in going to all flavours over a bin of energy E with width dE.

This gets transformed into L/E, since the oscillation terms have arguments linear in L/E and not E.

This function works best for single paths. In multiple paths the accuracy may be somewhat worse. If needed, average over smaller energy ranges.

Parameters

nu_in	- The neutrino initial state in flavour.
E	- The neutrino energy in the bin center in GeV
dE	- The energy bin width in GeV

Returns: Average neutrino oscillation probabilities

Definition at line 1753 of file PMNS_Base.cxx.

{
  vectorD probs(fNumNus, 0);
 
  // Do nothing if energy is not positive
  if (E <= 0) return probs;
 
  if (fNuPaths.empty()) return probs;
 
  // Don't average zero width
  if (dE <= 0) return ProbVector(nu_in, E);
 
  vectorD LoEbin = ConvertEtoLoE(E, dE);
 
  // Compute average in LoE
  return AvgProbVectorLoE(nu_in, LoEbin[0], LoEbin[1]);
}

References OscProb::PMNS_Base::AvgProbVectorLoE(), OscProb::PMNS_Base::ConvertEtoLoE(), OscProb::PMNS_Base::fNumNus, OscProb::PMNS_Base::fNuPaths, and OscProb::PMNS_Base::ProbVector().

Referenced by OscProb::PMNS_Maltoni::AvgProbVector(), and OscProb::PMNS_Base::AvgProbVector().

◆ AvgProbVectorLoE() [1/2]

vectorD PMNS_Maltoni::AvgProbVectorLoE	(	int	flvi,
		double	LoE,
		double	dLoE
	)

virtualinherited

Compute the average probability vector over a bin of L/E using a Taylor expansion

Compute the average probability of flvi going to any flavour over a bin of L/E with width dLoE using the Maltoni method.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

flvi	- The neutrino starting flavour.
LoE	- The neutrino L/E value in the bin center in km/GeV
dLoE	- The L/E bin width in km/GeV

Returns: Average probability for all outgoing flavours

Reimplemented from OscProb::PMNS_Base.

Definition at line 708 of file PMNS_Maltoni.cxx.

{
  if (fIsOscProbAvg == true)
    return PMNS_Base::AvgProbVectorLoE(flvi, LoE, dLoE);
 
  vectorD probs(fNumNus, 0);
 
  if (LoE <= 0) return probs;
 
  if (fNuPaths.empty()) return probs;
 
  double L = fPath.length;
 
  // Don't average zero width
  if (dLoE <= 0) return ProbVector(flvi, L / LoE);
 
  // Get sample points for this bin
  vectorD samples = GetSamplePointsAvgClass(LoE, dLoE);
 
  double sumw = 0;
 
  // Loop over all sample points
  for (int j = 1; j < int(samples.size()); j++) {
    // Set (L/E)^-2 weights
    double w = 1. / pow(samples[j], 2);
 
    for (int flvf = 0; flvf < fNumNus; flvf++) {
      if (flvf == 0)
        probs[flvf] += w * AvgAlgo(flvi, flvf, samples[j], samples[0], L);
      else
        probs[flvf] +=
            w * AvgFormula(flvi, flvf, fdInvE / kGeV2eV, flambdaInvE, fVInvE);
    }
 
    // Increment sum of weights
    sumw += w;
  }
 
  for (int flvf = 0; flvf < fNumNus; flvf++) {
    // Divide by total sampling weight
    probs[flvf] /= sumw;
  }
 
  // Return weighted average of probabilities
  return probs;
}

References OscProb::PMNS_Maltoni::AvgAlgo(), OscProb::PMNS_Maltoni::AvgFormula(), OscProb::PMNS_Base::AvgProbVectorLoE(), OscProb::PMNS_Maltoni::fdInvE, OscProb::PMNS_Maltoni::fIsOscProbAvg, OscProb::PMNS_Maltoni::flambdaInvE, OscProb::PMNS_Base::fNumNus, OscProb::PMNS_Base::fNuPaths, OscProb::PMNS_Base::fPath, OscProb::PMNS_Maltoni::fVInvE, OscProb::PMNS_Maltoni::GetSamplePointsAvgClass(), OscProb::PMNS_Base::kGeV2eV, OscProb::NuPath::length, and OscProb::PMNS_Base::ProbVector().

Referenced by OscProb::PMNS_Maltoni::AvgProbVector().

◆ AvgProbVectorLoE() [2/2]

vectorD PMNS_Base::AvgProbVectorLoE	(	vectorC	nu_in,
		double	LoE,
		double	dLoE = `0`
	)

virtualinherited

Compute the average probability of nu_in going to all flavours over a bin of L/E with width dLoE.

The probabilities are weighted by (L/E)^-2 so that event density is flat in energy. This avoids giving too much weight to low energies. Better approximations would be achieved if we used an interpolated event density.

This function works best for single paths. In multiple paths the accuracy may be somewhat worse. If needed, average over smaller L/E ranges.

Parameters

nu_in	- The neutrino intial state in flavour basis.
LoE	- The neutrino L/E value in the bin center in km/GeV
dLoE	- The L/E bin width in km/GeV

Returns: Average neutrino oscillation probabilities

Definition at line 1791 of file PMNS_Base.cxx.

{
  vectorD probs(fNumNus, 0);
 
  // Do nothing if L/E is not positive
  if (LoE <= 0) return probs;
 
  if (fNuPaths.empty()) return probs;
 
  // Make sure fPath is set
  // Use average if multiple paths
  SetCurPath(AvgPath(fNuPaths));
 
  // Set the energy at bin center
  SetEnergy(fPath.length / LoE);
 
  // Don't average zero width
  if (dLoE <= 0) return ProbVector(nu_in);
 
  // Get sample points for this bin
  vectorD samples = GetSamplePoints(LoE, dLoE);
 
  // Variables to fill sample
  // probabilities and weights
  double sumw   = 0;
  double length = fPath.length;
 
  // Loop over all sample points
  for (int j = 0; j < int(samples.size()); j++) {
    // Set (L/E)^-2 weights
    double w = 1. / pow(samples[j], 2);
 
    vectorD sample_probs = ProbVector(nu_in, length / samples[j]);
 
    for (int i = 0; i < fNumNus; i++) {
      // Add weighted probability
      probs[i] += w * sample_probs[i];
    }
    // Increment sum of weights
    sumw += w;
  }
 
  for (int i = 0; i < fNumNus; i++) {
    // Divide by total sampling weight
    probs[i] /= sumw;
  }
 
  // Return weighted average of probabilities
  return probs;
}

References OscProb::AvgPath(), OscProb::PMNS_Base::fNumNus, OscProb::PMNS_Base::fNuPaths, OscProb::PMNS_Base::fPath, OscProb::PMNS_Base::GetSamplePoints(), OscProb::NuPath::length, OscProb::PMNS_Base::ProbVector(), OscProb::PMNS_Base::SetCurPath(), and OscProb::PMNS_Base::SetEnergy().

Referenced by OscProb::PMNS_Base::AvgProbVector(), OscProb::PMNS_Maltoni::AvgProbVectorLoE(), and OscProb::PMNS_Base::AvgProbVectorLoE().

◆ BuildHms()

void PMNS_Base::BuildHms ( )

protectedvirtualinherited

Build Hms = H*2E, where H is the Hamiltonian in vacuum on flavour basis and E is the neutrino energy in eV. Hms is effectively the matrix of masses squared.

This is a hermitian matrix, so only the upper triangular part needs to be filled

The construction of the Hamiltonian avoids computing terms that are simply zero. This has a big impact in the computation time.

Reimplemented in OscProb::PMNS_Decay, OscProb::PMNS_OQS, and OscProb::PMNS_SNSI.

Definition at line 955 of file PMNS_Base.cxx.

{
  // Check if anything changed
  if (fBuiltHms) return;
 
  // Tag to recompute eigensystem
  fGotES = false;
 
  for (int j = 0; j < fNumNus; j++) {
    // Set mass splitting
    fHms[j][j] = fDm[j];
    // Reset off-diagonal elements
    for (int i = 0; i < j; i++) { fHms[i][j] = 0; }
    // Rotate j neutrinos
    for (int i = 0; i < j; i++) { RotateH(i, j, fHms); }
  }
 
  ClearCache();
 
  // Tag as built
  fBuiltHms = true;
}

References OscProb::PMNS_Base::ClearCache(), OscProb::PMNS_Base::fBuiltHms, OscProb::PMNS_Base::fDm, OscProb::PMNS_Base::fGotES, OscProb::PMNS_Base::fHms, OscProb::PMNS_Base::fNumNus, and OscProb::PMNS_Base::RotateH().

Referenced by OscProb::PMNS_OQS::BuildHms(), OscProb::PMNS_Sterile::SolveHam(), and OscProb::PMNS_Fast::SolveHamMatter().

◆ BuildKcosT()

void PMNS_Maltoni::BuildKcosT ( )

protectedvirtualinherited

Build K matrix for the zenith angle in flavor basis.

Definition at line 111 of file PMNS_Maltoni.cxx.

{
  UpdateHam();
 
  double dL = LnDerivative() * kKm2eV;
 
  for (int j = 0; j < fNumNus; j++) {
    for (int i = 0; i <= j; i++) {
      fKflavor[i][j] = dL * fHam(i, j);
 
      if (i != j) { fKflavor[j][i] = conj(fKflavor[i][j]); }
    }
  }
}

References OscProb::PMNS_Maltoni::fHam, OscProb::PMNS_Maltoni::fKflavor, OscProb::PMNS_Base::fNumNus, OscProb::PMNS_Base::kKm2eV, OscProb::PMNS_Maltoni::LnDerivative(), and OscProb::PMNS_Maltoni::UpdateHam().

Referenced by OscProb::PMNS_Maltoni::PropagatePathTaylor().

◆ BuildKE()

void PMNS_Maltoni::BuildKE ( double L )

protectedvirtualinherited

Build K matrix for the inverse of energy in mass basis.

The variable for which a Taylor expansion is done here is not directly the energy but the inverse of it. This change of variable allow to express the hamiltonien as linear with respect to this new variable.

Parameters

L	- The length of the layer in km

Definition at line 136 of file PMNS_Maltoni.cxx.

{
  double lenghtEV = L * kKm2eV;     // L in eV-1
  double bufK     = lenghtEV * 0.5; // L/2 in eV-1
 
  complexD buffer[fNumNus];
 
  for (int i = 0; i < fNumNus; i++) {
    complexD Hms_kl;
 
    for (int l = 0; l < fNumNus; l++) {
      buffer[l] = 0;
 
      for (int k = 0; k < fNumNus; k++) {
        if (k <= l)
          Hms_kl = fHms[k][l];
        else
          Hms_kl = conj(fHms[l][k]);
 
        if (fIsNuBar && k != l) Hms_kl = conj(Hms_kl);
 
        buffer[l] += conj(fEvec[k][i]) * Hms_kl;
      }
    }
 
    for (int j = 0; j <= i; j++) {
      fKmass[i][j] = 0;
 
      for (int l = 0; l < fNumNus; l++) {
        fKmass[i][j] += buffer[l] * fEvec[l][j];
      }
 
      complexD C;
 
      if (i == j) { C = complexD(1, 0); }
      else {
        double arg = (fEval[i] - fEval[j]) * lenghtEV;
 
        C = (complexD(cos(arg), sin(arg)) - complexD(1, 0.0)) /
            complexD(0.0, arg);
      }
 
      fKmass[i][j] *= bufK * C;
 
      if (i != j) fKmass[j][i] = conj(fKmass[i][j]);
    }
  }
}

References OscProb::PMNS_Base::fEval, OscProb::PMNS_Base::fEvec, OscProb::PMNS_Base::fHms, OscProb::PMNS_Base::fIsNuBar, OscProb::PMNS_Maltoni::fKmass, OscProb::PMNS_Base::fNumNus, and OscProb::PMNS_Base::kKm2eV.

Referenced by OscProb::PMNS_Maltoni::PropagatePathTaylor().

◆ ClearCache()

void PMNS_Base::ClearCache ( )

virtualinherited

Clear the cache

Definition at line 111 of file PMNS_Base.cxx.

{
  fMixCache.clear();
 
  // Set some better hash table parameters
  fMixCache.max_load_factor(0.25);
  fMixCache.reserve(512);
}

References OscProb::PMNS_Base::fMixCache.

Referenced by OscProb::PMNS_Base::BuildHms(), OscProb::PMNS_Base::PMNS_Base(), OscProb::PMNS_NUNM::SetAlpha(), SetaT(), OscProb::PMNS_NSI::SetCoupByIndex(), SetcT(), OscProb::PMNS_NSI::SetEps(), and OscProb::PMNS_NUNM::SetFracVnc().

◆ ClearPath()

void PMNS_Base::ClearPath ( )

virtualinherited

Clear the path vector.

Definition at line 287 of file PMNS_Base.cxx.

287{ fNuPaths.clear(); }

References OscProb::PMNS_Maltoni::AvgFormulaExtrapolation(), OscProb::PMNS_Maltoni::fdInvE, OscProb::PMNS_Maltoni::fKInvE, OscProb::PMNS_Maltoni::flambdaInvE, OscProb::PMNS_Maltoni::fVInvE, OscProb::PMNS_Maltoni::InitializeTaylorsVectors(), OscProb::PMNS_Base::kGeV2eV, OscProb::PMNS_Maltoni::PropagateTaylor(), OscProb::PMNS_Base::SetEnergy(), OscProb::PMNS_Maltoni::SetwidthBin(), and OscProb::PMNS_Maltoni::SolveK().

Referenced by OscProb::PMNS_Base::SetAtt(), and OscProb::PMNS_Base::SetPath().

◆ ConvertEtoLoE()

vectorD PMNS_Base::ConvertEtoLoE	(	double	E,
		double	dE
	)

protectedvirtualinherited

Convert a bin of energy into a bin of L/E

Parameters

E	- energy bin center in GeV
dE	- energy bin width in GeV

Returns: The L/E bin center and width in km/GeV

Definition at line 1516 of file PMNS_Base.cxx.

{
  // Make sure fPath is set
  // Use average if multiple paths
  SetCurPath(AvgPath(fNuPaths));
 
  // Define L/E variables
  vectorD LoEbin(2);
 
  // Set a minimum energy
  double minE = 0.1 * E;
 
  // Transform range to L/E
  // Full range if low edge > minE
  if (E - dE / 2 > minE) {
    LoEbin[0] =
        0.5 * (fPath.length / (E - dE / 2) + fPath.length / (E + dE / 2));
    LoEbin[1] = fPath.length / (E - dE / 2) - fPath.length / (E + dE / 2);
  }
  // Else start at minE
  else {
    LoEbin[0] = 0.5 * (fPath.length / minE + fPath.length / (E + dE / 2));
    LoEbin[1] = fPath.length / minE - fPath.length / (E + dE / 2);
  }
 
  return LoEbin;
}

References OscProb::AvgPath(), OscProb::PMNS_Base::fNuPaths, OscProb::PMNS_Base::fPath, OscProb::NuPath::length, and OscProb::PMNS_Base::SetCurPath().

Referenced by OscProb::PMNS_Maltoni::AvgProb(), OscProb::PMNS_Base::AvgProb(), OscProb::PMNS_Maltoni::AvgProbMatrix(), OscProb::PMNS_Base::AvgProbMatrix(), OscProb::PMNS_Maltoni::AvgProbVector(), and OscProb::PMNS_Base::AvgProbVector().

◆ ExtrapolationProb()

double PMNS_Maltoni::ExtrapolationProb	(	int	flvi,
		int	flvf,
		double	E,
		double	dE
	)

virtualinherited

Compute the propability for flvi going to flvf for an energy E+dE using the Maltoni method from a reference energy E.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

flvi	- The neutrino starting flavour.
flvf	- The neutrino final flavour.
E	- The reference energy in GeV
dE	- The energy variation in GeV

Returns: Neutrino oscillation probability

Definition at line 1341 of file PMNS_Maltoni.cxx.

{
  // reset K et S et Ve et lambdaE
  InitializeTaylorsVectors();
 
  SetEnergy(E);
  SetwidthBin(1 / (E + dE) - 1 / E, 0);
 
  // Propagate -> get S and K matrix (on the whole path)
  PropagateTaylor();
 
  // DiagolK -> get VE and lambdaE
  SolveK(fKInvE, flambdaInvE, fVInvE);
 
  return AvgFormulaExtrapolation(flvi, flvf, fdInvE / kGeV2eV, flambdaInvE,
                                 fVInvE);
}

◆ ExtrapolationProbCosT()

double PMNS_Maltoni::ExtrapolationProbCosT	(	int	flvi,
		int	flvf,
		double	cosT,
		double	dcosT
	)

virtualinherited

Compute the propability for flvi going to flvf for an angle cosT+dcosT using the Maltoni method from a reference angle cosT.

IMPORTANT: The PremModel object used must be set by this class using the function SetPremModel.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

flvi	- The neutrino starting flavour.
flvf	- The neutrino final flavour.
cosT	- The reference angle
dcosT	- The angle variation

Returns: Neutrino oscillation probability

Definition at line 1420 of file PMNS_Maltoni.cxx.

{
  fPrem.FillPath(cosT);
  SetPath(fPrem.GetNuPath());
 
  // reset K et S et Ve et lambdaE
  InitializeTaylorsVectors();
 
  // SetEnergy(E);
  SetCosT(cosT);
  SetwidthBin(0, dcosT);
 
  fminRsq = pow(fDetRadius * sqrt(1 - cosT * cosT), 2);
 
  // Propagate -> get S and K matrix (on the whole path)
  PropagateTaylor();
 
  // DiagolK -> get VE and lambdaE
  SolveK(fKcosT, flambdaCosT, fVcosT);
 
  return AvgFormulaExtrapolation(flvi, flvf, fdcosT, flambdaCosT, fVcosT);
}

◆ ExtrapolationProbLoE()

double PMNS_Maltoni::ExtrapolationProbLoE	(	int	flvi,
		int	flvf,
		double	LoE,
		double	dLoE
	)

virtualinherited

Compute the propability for flvi going to flvf for an energy LoE+dLoE using the Maltoni method from a reference value LoE.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

flvi	- The neutrino starting flavour.
flvf	- The neutrino final flavour.
LoE	- The reference energy in GeV
dLoE	- The energy variation in GeV

Returns: Neutrino oscillation probability

Definition at line 1377 of file PMNS_Maltoni.cxx.

{
  // reset K et S et Ve et lambdaE
  InitializeTaylorsVectors();
 
  SetCurPath(AvgPath(fNuPaths));
  double L = fPath.length;
 
  SetEnergy(L / LoE);
  SetwidthBin(dLoE / L, 0);
 
  // Propagate -> get S and K matrix (on the whole path)
  PropagateTaylor();
 
  // DiagolK -> get VE and lambdaE
  SolveK(fKInvE, flambdaInvE, fVInvE);
 
  return AvgFormulaExtrapolation(flvi, flvf, dLoE * kGeV2eV / L, flambdaInvE,
                                 fVInvE);
}

◆ FillCache()

virtual void OscProb::PMNS_LIV::FillCache ( )

inlineprotectedvirtual

Reimplemented from OscProb::PMNS_Base.

Definition at line 60 of file PMNS_LIV.h.

◆ GetAngle()

double PMNS_Base::GetAngle	(	int	i,
		int	j
	)

virtualinherited

Get the mixing angle theta_ij in radians.

Requires that i<j. Will notify you if input is wrong. If i>j, will assume reverse order and swap i and j.

Parameters

i,j	- the indices of theta_ij

Definition at line 570 of file PMNS_Base.cxx.

{
  if (i > j) {
    cerr << "WARNING: First argument should be smaller than second argument"
         << endl
         << "         Setting reverse order (Theta" << j << i << "). " << endl;
    int temp = i;
    i        = j;
    j        = temp;
  }
  if (i < 1 || i > fNumNus - 1 || j < 2 || j > fNumNus) {
    cerr << "ERROR: Theta" << i << j << " not valid for " << fNumNus
         << " neutrinos. Returning zero." << endl;
    return 0;
  }
 
  return fTheta[i - 1][j - 1];
}

References OscProb::PMNS_Base::fNumNus, and OscProb::PMNS_Base::fTheta.

◆ GetaT()

complexD PMNS_LIV::GetaT	(	int	flvi,
		int	flvj,
		int	dim = `3`
	)

virtual

Get any given LIV parameter of a chosen dimension. The flavour convention is: e -> 0 mu -> 1 tau -> 2

Get any given aT parameter of a chosen dimension.

Flavours are:

0 = nue, 1 = numu, 2 = nutau

Requires that flvi < flvj. Will notify you if input is wrong. If flvi > flvj, will assume reverse order and swap flvi and flvj.

Parameters

flvi	- The first flavour index
flvj	- The second flavour index
dim	- Dimension of the coefficient: can be 3,5,7.

Returns: - The aT parameter value

Definition at line 173 of file PMNS_LIV.cxx.

{
  if (flvi > flvj) {
    cerr << "WARNING: First argument should be smaller or equal to second "
            "argument"
         << endl
         << "Setting reverse order (aT_" << flvj << flvi << "). " << endl;
    int temp = flvi;
    flvi     = flvj;
    flvj     = temp;
  }
  if (flvi < 0 || flvi > 2 || flvj < flvi || flvj > 2) {
    cerr << "WARNING: aT_" << flvi << flvj << " not valid for " << fNumNus
         << " neutrinos. Returning 0." << endl;
    return zero;
  }
  if (dim != 3 && dim != 5 && dim != 7) {
    cerr << "WARNING: Invalid aT coefficient dimension dim=" << dim
         << " not in  [3,5,7].\n";
    return zero;
  }
 
  int pos = (dim - 3) / 2;
 
  return faT[flvi][flvj][pos];
}

References faT, OscProb::PMNS_Base::fNumNus, and OscProb::PMNS_Base::zero.

◆ GetcT()

complex< double > PMNS_LIV::GetcT	(	int	flvi,
		int	flvj,
		int	dim = `4`
	)

virtual

Get any given cT parameter of a chosen dimension.

Flavours are:

0 = nue, 1 = numu, 2 = nutau

Requires that flvi < flvj. Will notify you if input is wrong. If flvi > flvj, will assume reverse order and swap flvi and flvj.

Parameters

flvi	- The first flavour index
flvj	- The second flavour index
dim	- Dimension of the coefficient: can be 4,6,8.

Returns: - The cT parameter value

Definition at line 216 of file PMNS_LIV.cxx.

{
  if (flvi > flvj) {
    cerr << "WARNING: First argument should be smaller or equal to second "
            "argument"
         << endl
         << "Setting reverse order (cT_" << flvj << flvi << "). " << endl;
    int temp = flvi;
    flvi     = flvj;
    flvj     = temp;
  }
  if (flvi < 0 || flvi > 2 || flvj < flvi || flvj > 2) {
    cerr << "WARNING: cT_" << flvi << flvj << " not valid for " << fNumNus
         << " neutrinos. Returning 0." << endl;
    return zero;
  }
  if (dim != 4 && dim != 6 && dim != 8) {
    cerr << "WARNING: Invalid cT coefficient dimension dim=" << dim
         << " not in  [4,6,8].\n";
    return zero;
  }
 
  int pos = dim / 2 - 2;
 
  return fcT[flvi][flvj][pos];
}

References fcT, OscProb::PMNS_Base::fNumNus, and OscProb::PMNS_Base::zero.

◆ GetDelta()

double PMNS_Base::GetDelta	(	int	i,
		int	j
	)

virtualinherited

Get the CP phase delta_ij in radians.

Requires that i+1<j. Will notify you if input is wrong. If i>j, will assume reverse order and swap i and j.

Parameters

i,j	- the indices of delta_ij

Definition at line 638 of file PMNS_Base.cxx.

{
  if (i > j) {
    cerr << "WARNING: First argument should be smaller than second argument"
         << endl
         << "         Setting reverse order (Delta" << j << i << "). " << endl;
    int temp = i;
    i        = j;
    j        = temp;
  }
  if (i < 1 || i > fNumNus - 1 || j < 2 || j > fNumNus) {
    cerr << "ERROR: Delta" << i << j << " not valid for " << fNumNus
         << " neutrinos. Returning zero." << endl;
    return 0;
  }
  if (i + 1 == j) {
    cerr << "WARNING: Rotation " << i << j << " is real. Returning zero."
         << endl;
    return 0;
  }
 
  return fDelta[i - 1][j - 1];
}

References OscProb::PMNS_Base::fDelta, and OscProb::PMNS_Base::fNumNus.

◆ GetDm()

double PMNS_Base::GetDm ( int j )

virtualinherited

Get the mass-splitting dm_j1 = (m_j^2 - m_1^2) in eV^2

Requires that j>1. Will notify you if input is wrong.

Parameters

j	- the index of dm_j1

Definition at line 696 of file PMNS_Base.cxx.

{
  if (j < 2 || j > fNumNus) {
    cerr << "ERROR: Dm" << j << "1 not valid for " << fNumNus
         << " neutrinos. Returning zero." << endl;
    return 0;
  }
 
  return fDm[j - 1];
}

References OscProb::PMNS_Base::fDm, and OscProb::PMNS_Base::fNumNus.

◆ GetDmEff()

double PMNS_Base::GetDmEff ( int j )

virtualinherited

Get the effective mass-splitting dm_j1 in matter in eV^2

Requires that j>1. Will notify you if input is wrong.

Parameters

j	- the index of dm_j1

Definition at line 732 of file PMNS_Base.cxx.

{
  if (j < 2 || j > fNumNus) {
    cerr << "ERROR: Dm_" << j << "1 not valid for " << fNumNus
         << " neutrinos. Returning zero." << endl;
    return 0;
  }
 
  // Solve the Hamiltonian to update eigenvalues
  SolveHam();
 
  // Sort eigenvalues in same order as vacuum Dm^2
  vectorI dm_idx = GetSortedIndices(fDm);
  vectorD dm_idx_double(dm_idx.begin(), dm_idx.end());
  dm_idx         = GetSortedIndices(dm_idx_double);
  vectorI ev_idx = GetSortedIndices(fEval);
 
  // Return difference in eigenvalues * 2E
  return (fEval[ev_idx[dm_idx[j - 1]]] - fEval[ev_idx[dm_idx[0]]]) * 2 *
         fEnergy * kGeV2eV;
}

References OscProb::PMNS_Base::fDm, OscProb::PMNS_Base::fEnergy, OscProb::PMNS_Base::fEval, OscProb::PMNS_Base::fNumNus, OscProb::PMNS_Base::GetSortedIndices(), OscProb::PMNS_Base::kGeV2eV, and OscProb::PMNS_Base::SolveHam().

◆ GetEnergy()

double PMNS_Base::GetEnergy ( )

virtualinherited

Get the neutrino energy in GeV.

Definition at line 255 of file PMNS_Base.cxx.

255{ return fEnergy; }

References OscProb::PMNS_Base::fEnergy.

◆ GetIsNuBar()

bool PMNS_Base::GetIsNuBar ( )

virtualinherited

Get the anti-neutrino flag.

Definition at line 261 of file PMNS_Base.cxx.

261{ return fIsNuBar; }

References OscProb::PMNS_Base::fIsNuBar.

◆ GetMassEigenstate()

vectorC PMNS_Base::GetMassEigenstate ( int mi )

virtualinherited

Get the neutrino mass eigenstate in vacuum

States are:

  0 = m_1, 1 = m_2, 2 = m_3, etc.

Parameters

mi	- the mass eigenstate index

Returns: The mass eigenstate

Definition at line 795 of file PMNS_Base.cxx.

{
  vectorC oldState = fNuState;
 
  ResetToFlavour(mi);
 
  for (int j = 0; j < fNumNus; j++) {
    for (int i = 0; i < j; i++) { RotateState(i, j); }
  }
 
  vectorC newState = fNuState;
  fNuState         = oldState;
 
  return newState;
}

References OscProb::PMNS_Base::fNumNus, OscProb::PMNS_Base::fNuState, OscProb::PMNS_Base::ResetToFlavour(), and OscProb::PMNS_Base::RotateState().

◆ GetPath()

vector< NuPath > PMNS_Base::GetPath ( )

virtualinherited

Get the vector of neutrino paths.

Definition at line 300 of file PMNS_Base.cxx.

300{ return fNuPaths; }

◆ GetProbVector()

vectorD PMNS_Base::GetProbVector ( )

protectedvirtualinherited

Return vector of probabilities from final state

Get the vector of probabilities for current state

Returns: Neutrino oscillation probabilities

Definition at line 1233 of file PMNS_Base.cxx.

{
  vectorD probs(fNumNus);
 
  for (int i = 0; i < probs.size(); i++) { probs[i] = P(i); }
 
  return probs;
}

References OscProb::PMNS_Base::fNumNus, and OscProb::PMNS_Base::P().

Referenced by OscProb::PMNS_Base::ProbVector().

◆ GetSamplePoints()

vectorD PMNS_Base::GetSamplePoints	(	double	LoE,
		double	dLoE
	)

virtualinherited

Compute the sample points for a bin of L/E with width dLoE

This is used for averaging the probability over a bin of L/E. It should be a private function, but I'm keeping it public for now for debugging purposes. The number of sample points seems too high for most purposes. The number of subdivisions needs to be optimized.

Parameters

LoE	- The neutrino L/E value in the bin center in km/GeV
dLoE	- The L/E bin width in km/GeV

Definition at line 1985 of file PMNS_Base.cxx.

{
  // Solve Hamiltonian to get eigenvalues
  SolveHam();
 
  // Define conversion factor [km/GeV -> 1/(4 eV^2)]
  const double k1267 = kKm2eV / (4 * kGeV2eV);
 
  // Get list of all effective Dm^2
  vectorD effDm;
 
  for (int i = 0; i < fNumNus - 1; i++) {
    for (int j = i + 1; j < fNumNus; j++) {
      effDm.push_back(2 * kGeV2eV * fEnergy * fabs(fEval[j] - fEval[i]));
    }
  }
 
  int numDm = effDm.size();
 
  // Sort the effective Dm^2 list
  sort(effDm.begin(), effDm.end());
 
  // Set a number of sub-divisions to achieve "good" accuracy
  // This needs to be studied better
  int n_div = ceil(200 * pow(dLoE / LoE, 0.8) / sqrt(fAvgProbPrec / 1e-4));
  // int n_div = 1;
 
  // A vector to store sample points
  vectorD allSamples;
 
  // Loop over sub-divisions
  for (int k = 0; k < n_div; k++) {
    // Define sub-division center and width
    double bctr = LoE - dLoE / 2 + (k + 0.5) * dLoE / n_div;
    double bwdt = dLoE / n_div;
 
    // Make a vector of L/E sample values
    // Initialized in the sub-division center
    vectorD samples;
    samples.push_back(bctr);
 
    // Loop over all Dm^2 to average each frequency
    // This will recursively sample points in smaller
    // bins so that all relevant frequencies are used
    for (int i = 0; i < numDm; i++) {
      // Copy the list of sample L/E values
      vectorD prev = samples;
 
      // Redefine bin width to lie within full sub-division
      double Width =
          2 * min(prev[0] - (bctr - bwdt / 2), (bctr + bwdt / 2) - prev[0]);
 
      // Compute oscillation argument sorted from lowest  to highest
      const double arg = k1267 * effDm[i] * Width;
 
      // Skip small oscillation values.
      // If it's the last one, lower the tolerance
      if (i < numDm - 1) {
        if (arg < 0.9) continue;
      }
      else {
        if (arg < 0.1) continue;
      }
 
      // Reset samples to redefine them
      samples.clear();
 
      // Loop over previous samples
      for (int j = 0; j < int(prev.size()); j++) {
        // Compute new sample points around old samples
        // This is based on a oscillatory quadrature rule
        double sample = (1 / sqrt(3)) * (Width / 2);
        if (arg != 0) sample = acos(sin(arg) / arg) / arg * (Width / 2);
 
        // Add samples above and below center
        samples.push_back(prev[j] - sample);
        samples.push_back(prev[j] + sample);
      }
 
    } // End of loop over Dm^2
 
    // Add sub-division samples to the end of allSamples vector
    allSamples.insert(allSamples.end(), samples.begin(), samples.end());
 
  } // End of loop over sub-divisions
 
  // Return all sample points
  return allSamples;
}

References OscProb::PMNS_Base::fAvgProbPrec, OscProb::PMNS_Base::fEnergy, OscProb::PMNS_Base::fEval, OscProb::PMNS_Base::fNumNus, OscProb::PMNS_Base::kGeV2eV, OscProb::PMNS_Base::kKm2eV, and OscProb::PMNS_Base::SolveHam().

Referenced by OscProb::PMNS_Base::AvgProbLoE(), OscProb::PMNS_Base::AvgProbMatrixLoE(), and OscProb::PMNS_Base::AvgProbVectorLoE().

◆ GetSamplePointsAvgClass() [1/3]

vectorD PMNS_Maltoni::GetSamplePointsAvgClass	(	double	E,
		double	cosT,
		double	dcosT
	)

protectedvirtualinherited

Compute the sample points for a bin of cosTheta with width dcosTheta

This is used to increase the precision of the average probability over a bin of cosT, calculated using the Maltoni method.

Parameters

E	- The neutrino Energy value GeV
cosT	- The neutrino cosT value in the bin center
dcosT	- The cosT bin width

Returns: Vector of sample cosT points

Definition at line 1243 of file PMNS_Maltoni.cxx.

{
  // Set a number of sub-divisions to achieve "good" accuracy
  // This needs to be studied better
  int n_div = ceil(35 * pow(E, -0.4) * pow(abs(dcosT / cosT), 0.8) /
                   sqrt(fAvgProbPrec / 1e-4));
 
  // A vector to store sample points
  vectorD Samples;
 
  // Define sub-division width
  Samples.push_back(dcosT / n_div);
 
  // Loop over sub-divisions
  for (int k = 0; k < n_div; k++) {
    // Define sub-division center
    double bctr = cosT - dcosT / 2 + (k + 0.5) * dcosT / n_div;
 
    Samples.push_back(bctr);
 
  } // End of loop over sub-divisions
 
  // Return sample points
  return Samples;
}

◆ GetSamplePointsAvgClass() [2/3]

matrixC PMNS_Maltoni::GetSamplePointsAvgClass	(	double	InvE,
		double	dInvE,
		double	cosT,
		double	dcosT
	)

protectedvirtualinherited

Compute the sample points for a bin of E and cosT with width dE and dcosT

Compute the sample points for a bin of 1oE and cosTheta with width d1oE and dcosTheta

This is used to increase the precision of the average probability over a bin of L/E and cosT, calculated using the Maltoni method.

Parameters

InvE	- The neutrino 1/E value in the bin center in GeV-1
dInvE	- The 1/E bin width in GeV-1
cosT	- The neutrino cosT value in the bin center
dcosT	- The cosT bin width

Returns: Matrix of sample InvE and cosT points

Definition at line 1131 of file PMNS_Maltoni.cxx.

{
  // Set a number of sub-divisions to achieve "good" accuracy
  // This needs to be studied better
  int n_divCosT = ceil(380 * pow(InvE, 0.5) * pow(abs(dcosT / cosT), 0.8) /
                       sqrt(fAvgProbPrec / 1e-4));
  int n_divE    = ceil(260 * pow(dInvE / InvE, 0.8) * pow(InvE, 0.6) /
                       sqrt(fAvgProbPrec / 1e-4));
 
  // A matrix to store sample points
  matrixC Samples = matrixC(n_divE + 1, vectorC(n_divCosT + 1, 0));
 
  // Define sub-division width
  Samples[0][0] = complexD(dInvE / n_divE, dcosT / n_divCosT);
 
  // Loop over sub-divisions
  for (int k = 0; k < n_divE; k++) {
    // Define sub-division center for energy
    double bctr_InvE = InvE - dInvE / 2 + (k + 0.5) * dInvE / n_divE;
 
    for (int l = 0; l < n_divCosT; l++) {
      // Define sub-division center for angle
      double bctr_CosT = cosT - dcosT / 2 + (l + 0.5) * dcosT / n_divCosT;
 
      Samples[k + 1][l + 1] = complexD(bctr_InvE, bctr_CosT);
    }
 
  } // End of loop over sub-divisions
 
  // Return sample points
  return Samples;
}

◆ GetSamplePointsAvgClass() [3/3]

vectorD PMNS_Maltoni::GetSamplePointsAvgClass	(	double	LoE,
		double	dLoE
	)

protectedvirtualinherited

Compute the sample points for a bin of L/E with width dLoE.

This is used to increase the precision of the average probability over a bin of L/E, calculated using the Maltoni method.

Parameters

LoE	- The neutrino L/E value in the bin center in km/GeV
dLoE	- The L/E bin width in km/GeV

Returns: Vector of sample L/E points

Definition at line 628 of file PMNS_Maltoni.cxx.

{
  // Set a number of sub-divisions to achieve "good" accuracy
  // This needs to be studied better
  int n_div = ceil(3 * pow(dLoE / LoE, 0.8) * pow(LoE, 0.3) /
                   sqrt(fAvgProbPrec / 1e-4));
 
  // A vector to store sample points
  vectorD Samples;
 
  // Define sub-division width
  Samples.push_back(dLoE / n_div);
 
  // Loop over sub-divisions
  for (int k = 0; k < n_div; k++) {
    // Define sub-division center
    double bctr = LoE - dLoE / 2 + (k + 0.5) * dLoE / n_div;
 
    Samples.push_back(bctr);
 
  } // End of loop over sub-divisions
 
  // Return sample points
  return Samples;
}

Referenced by OscProb::PMNS_Base::AvgProb(), OscProb::PMNS_Base::AvgProbLoE(), OscProb::PMNS_Base::AvgProbVector(), OscProb::PMNS_Base::AvgProbVectorLoE(), OscProb::PMNS_Base::GetMassEigenstate(), OscProb::PMNS_Base::PMNS_Base(), OscProb::PMNS_Base::Prob(), OscProb::PMNS_Base::ProbMatrix(), OscProb::PMNS_NUNM::ProbMatrix(), OscProb::PMNS_Base::ProbVector(), and OscProb::PMNS_DensityMatrix::ResetToFlavour().

Referenced by OscProb::PMNS_Maltoni::AvgProbLoE(), OscProb::PMNS_Maltoni::AvgProbMatrixLoE(), and OscProb::PMNS_Maltoni::AvgProbVectorLoE().

◆ GetSortedIndices()

vectorI PMNS_Base::GetSortedIndices ( const vectorD x )

protectedvirtualinherited

Get the indices of the sorted x vector

Parameters

x	- input vector

Returns: The vector of sorted indices

Definition at line 715 of file PMNS_Base.cxx.

{
  vectorI idx(x.size(), 0);
  for (int i = 0; i < x.size(); i++) idx[i] = i;
  sort(idx.begin(), idx.end(), IdxCompare(x));
 
  return idx;
}

Referenced by OscProb::PMNS_Base::GetDmEff().

◆ HadamardProduct()

void PMNS_Maltoni::HadamardProduct	(	vectorD	lambda,
		double	dbin
	)

protectedvirtualinherited

Apply an Hadamard Product to the density matrix

Parameters

lambda	- Eigenvalues of the K matrix
dbin	- Width of the bin

Definition at line 1209 of file PMNS_Maltoni.cxx.

{
  matrixC sinc = matrixC(fNumNus, vectorC(fNumNus, 0));
  for (int j = 0; j < fNumNus; j++) {
    for (int i = 0; i < j; i++) {
      double arg = (lambda[i] - lambda[j]) * dbin;
      sinc[i][j] = sin(arg) / arg;
 
      sinc[j][i] = sinc[i][j];
    }
  }
 
  for (int i = 0; i < fNumNus; i++) { sinc[i][i] = 1; }
 
  for (int j = 0; j < fNumNus; j++) {
    for (int i = 0; i < fNumNus; i++) {
      fdensityMatrix[i][j] = fdensityMatrix[i][j] * sinc[i][j];
    }
  }
}

References OscProb::PMNS_Maltoni::fdensityMatrix, and OscProb::PMNS_Base::fNumNus.

Referenced by OscProb::PMNS_Maltoni::AlgorithmDensityMatrix().

◆ InitializeTaylorsVectors()

void PMNS_Maltoni::InitializeTaylorsVectors ( )

protectedvirtualinherited

Set vector sizes and initialize elements to zero. Initialize diagonal elements of S to one

Definition at line 37 of file PMNS_Maltoni.cxx.

{
  fdensityMatrix = matrixC(fNumNus, vectorC(fNumNus, 0));
 
  flambdaInvE = vectorD(fNumNus, 0);
  fVInvE      = matrixC(fNumNus, vectorC(fNumNus, 0));
  fKInvE      = Eigen::MatrixXcd::Zero(fNumNus, fNumNus);
 
  flambdaCosT = vectorD(fNumNus, 0);
  fVcosT      = matrixC(fNumNus, vectorC(fNumNus, 0));
  fKcosT      = Eigen::MatrixXcd::Zero(fNumNus, fNumNus);
 
  fevolutionMatrixS = matrixC(fNumNus, vectorC(fNumNus, 0));
 
  fSflavor = matrixC(fNumNus, vectorC(fNumNus, 0));
  fKmass   = matrixC(fNumNus, vectorC(fNumNus, 0));
  fKflavor = matrixC(fNumNus, vectorC(fNumNus, 0));
 
  for (int i = 0; i < fNumNus; i++) { fevolutionMatrixS[i][i] = 1; }
 
  fLayer = fPrem.GetPremLayers().size() - 1;
 
  fdl = -1;
 
  fDetRadius = fPrem.GetDetRadius();
}

Referenced by OscProb::PMNS_Maltoni::AvgAlgo(), OscProb::PMNS_Maltoni::AvgAlgoCosT(), OscProb::PMNS_Maltoni::AvgProb(), OscProb::PMNS_Maltoni::ExtrapolationProb(), OscProb::PMNS_Maltoni::ExtrapolationProbCosT(), OscProb::PMNS_Maltoni::ExtrapolationProbLoE(), and OscProb::PMNS_Maltoni::PMNS_Maltoni().

◆ InitializeVectors()

void PMNS_Base::InitializeVectors ( )

protectedvirtualinherited

Initialize all member vectors with zeros

Set vector sizes and initialize elements to zero.

Definition at line 79 of file PMNS_Base.cxx.

{
  fDm    = vectorD(fNumNus, 0);
  fTheta = matrixD(fNumNus, vectorD(fNumNus, 0));
  fDelta = matrixD(fNumNus, vectorD(fNumNus, 0));
 
  fNuState = vectorC(fNumNus, zero);
  fHms     = matrixC(fNumNus, vectorC(fNumNus, zero));
 
  fPhases = vectorC(fNumNus, zero);
  fBuffer = vectorC(fNumNus, zero);
 
  fEval = vectorD(fNumNus, 0);
  fEvec = matrixC(fNumNus, vectorC(fNumNus, zero));
}

Referenced by OscProb::PMNS_Base::PMNS_Base().

◆ LnDerivative()

double PMNS_Maltoni::LnDerivative ( )

protectedvirtualinherited

Compute the derivative of one layer's length depending on the angle

Definition at line 189 of file PMNS_Maltoni.cxx.

{
  double dL = 0;
 
  double L1 = pow(fPrem.GetPremLayers()[fLayer].radius, 2) - fminRsq;
 
  double L2 = -fminRsq;
  if (fLayer > 0) L2 += pow(fPrem.GetPremLayers()[fLayer - 1].radius, 2);
 
  bool ismin = (L2 <= 0 && fcosT < 0);
 
  if (ismin)
    dL = 2 * pow(fDetRadius, 2) * fcosT * pow(L1, -0.5);
  else
    dL = pow(fDetRadius, 2) * fcosT * (pow(L1, -0.5) - pow(L2, -0.5));
 
  if (ismin) fdl = 1;
 
  fLayer += fdl;
 
  return dL;
}

References OscProb::PMNS_Maltoni::fcosT, OscProb::PMNS_Maltoni::fDetRadius, OscProb::PMNS_Maltoni::fdl, OscProb::PMNS_Maltoni::fLayer, OscProb::PMNS_Maltoni::fminRsq, OscProb::PMNS_Maltoni::fPrem, and OscProb::PremModel::GetPremLayers().

Referenced by OscProb::PMNS_Maltoni::BuildKcosT().

◆ MultiplicationRuleK()

void PMNS_Maltoni::MultiplicationRuleK ( Eigen::MatrixXcd & K )

protectedvirtualinherited

Product between two K matrices.

This is used to calculate the matrix K corresponding to the propagation between the beginning of the path and the end of the current layer.

The matrix fKflavor correspond to the propagation between the beginning and the end of the layer.

Parameters

K	- The current K matrix

Definition at line 305 of file PMNS_Maltoni.cxx.

{
  for (int i = 0; i < fNumNus; i++) {
    complexD buffer[fNumNus];
 
    for (int l = 0; l < fNumNus; l++) {
      for (int k = 0; k < fNumNus; k++) {
        buffer[l] += conj(fevolutionMatrixS[k][i]) * fKflavor[k][l];
      }
    }
 
    for (int j = 0; j <= i; j++) {
      for (int l = 0; l < fNumNus; l++) {
        K(i, j) += buffer[l] * fevolutionMatrixS[l][j];
      }
 
      if (i != j) { K(j, i) = conj(K(i, j)); }
    }
  }
}

References OscProb::PMNS_Maltoni::fevolutionMatrixS, OscProb::PMNS_Maltoni::fKflavor, and OscProb::PMNS_Base::fNumNus.

Referenced by OscProb::PMNS_Maltoni::PropagatePathTaylor().

◆ MultiplicationRuleS()

void PMNS_Maltoni::MultiplicationRuleS ( )

protectedvirtualinherited

Product between two S matrices.

This is used to calculate the matrix S corresponding to the propagation between the beginning of the path and the end of the current layer.

The matrix fevolutionMatrixS represent the propagation between the beginning of the path and the beginning of the current layer. This matrix is updated after every layer with this function. The matrix fSflavor represent the propagation between the beginning and the end of the layer.

Definition at line 276 of file PMNS_Maltoni.cxx.

{
  complexD save[fNumNus];
 
  for (int j = 0; j < fNumNus; j++) {
    for (int n = 0; n < fNumNus; n++) { save[n] = fevolutionMatrixS[n][j]; }
 
    for (int i = 0; i < fNumNus; i++) {
      fevolutionMatrixS[i][j] = 0;
 
      for (int k = 0; k < fNumNus; k++) {
        fevolutionMatrixS[i][j] += fSflavor[i][k] * save[k];
      }
    }
  }
}

References OscProb::PMNS_Maltoni::fevolutionMatrixS, OscProb::PMNS_Base::fNumNus, and OscProb::PMNS_Maltoni::fSflavor.

Referenced by OscProb::PMNS_Maltoni::PropagatePathTaylor().

◆ P()

double PMNS_Base::P ( int flv )

protectedvirtualinherited

Compute oscillation probability of flavour flv from current state

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

flv	- The neutrino final flavour.

Returns: Neutrino oscillation probability

Reimplemented in OscProb::PMNS_DensityMatrix.

Definition at line 1058 of file PMNS_Base.cxx.

{
  assert(flv >= 0 && flv < fNumNus);
  return norm(fNuState[flv]);
}

References OscProb::PMNS_Base::fNumNus, and OscProb::PMNS_Base::fNuState.

Referenced by OscProb::PMNS_Maltoni::AvgFormula(), OscProb::PMNS_Maltoni::AvgFormulaExtrapolation(), OscProb::PMNS_Base::GetProbVector(), and OscProb::PMNS_Base::Prob().

◆ Prob() [1/6]

double PMNS_Base::Prob	(	int	flvi,
		int	flvf
	)

virtualinherited

Compute the probability of flvi going to flvf.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

flvi	- The neutrino starting flavour.
flvf	- The neutrino final flavour.

Returns: Neutrino oscillation probability

Definition at line 1091 of file PMNS_Base.cxx.

{
  ResetToFlavour(flvi);
 
  Propagate();
 
  return P(flvf);
}

References OscProb::PMNS_Base::P(), OscProb::PMNS_Base::Propagate(), and OscProb::PMNS_Base::ResetToFlavour().

◆ Prob() [2/6]

double PMNS_Base::Prob	(	int	flvi,
		int	flvf,
		double	E
	)

virtualinherited

Compute the probability of flvi going to flvf for energy E

Compute the probability of flvi going to flvf for a given energy in GeV.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

flvi	- The neutrino starting flavour.
flvf	- The neutrino final flavour.
E	- The neutrino energy in GeV

Returns: Neutrino oscillation probability

Definition at line 1160 of file PMNS_Base.cxx.

{
  SetEnergy(E);
 
  return Prob(flvi, flvf);
}

References OscProb::PMNS_Base::Prob(), and OscProb::PMNS_Base::SetEnergy().

◆ Prob() [3/6]

double PMNS_Base::Prob	(	int	flvi,
		int	flvf,
		double	E,
		double	L
	)

virtualinherited

Compute the probability of flvi going to flvf for energy E and distance L

Compute the probability of flvi going to flvf for a given energy in GeV and distance in km in a single path.

If the path sequence is not a single path, a new single path will be created and the previous sequence will be lost.

Don't use this if you want to propagate over multiple path segments.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

flvi	- The neutrino starting flavour.
flvf	- The neutrino final flavour.
E	- The neutrino energy in GeV
L	- The neutrino path length in km

Returns: Neutrino oscillation probability

Definition at line 1219 of file PMNS_Base.cxx.

{
  SetEnergy(E);
  SetLength(L);
 
  return Prob(flvi, flvf);
}

References OscProb::PMNS_Base::Prob(), OscProb::PMNS_Base::SetEnergy(), and OscProb::PMNS_Base::SetLength().

◆ Prob() [4/6]

double PMNS_Base::Prob	(	vectorC	nu_in,
		int	flvf
	)

virtualinherited

Compute the probability of nu_in going to flvf.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

nu_in	- The neutrino initial state in flavour basis.
flvf	- The neutrino final flavour.

Returns: Neutrino oscillation probability

Definition at line 1114 of file PMNS_Base.cxx.

{
  SetPureState(nu_in);
 
  Propagate();
 
  return P(flvf);
}

References OscProb::PMNS_Base::P(), OscProb::PMNS_Base::Propagate(), and OscProb::PMNS_Base::SetPureState().

Referenced by OscProb::PMNS_Maltoni::AvgProb(), OscProb::PMNS_Base::AvgProb(), OscProb::PMNS_Maltoni::AvgProbLoE(), OscProb::PMNS_Base::AvgProbLoE(), and OscProb::PMNS_Base::Prob().

◆ Prob() [5/6]

double PMNS_Base::Prob	(	vectorC	nu_in,
		int	flvf,
		double	E
	)

virtualinherited

Compute the probability of nu_in going to flvf for energy E

Compute the probability of nu_in going to flvf for a given energy in GeV.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

nu_in	- The neutrino initial state in flavour basis.
flvf	- The neutrino final flavour.
E	- The neutrino energy in GeV

Returns: Neutrino oscillation probability

Definition at line 1138 of file PMNS_Base.cxx.

{
  SetEnergy(E);
 
  return Prob(nu_in, flvf);
}

References OscProb::PMNS_Base::Prob(), and OscProb::PMNS_Base::SetEnergy().

◆ Prob() [6/6]

double PMNS_Base::Prob	(	vectorC	nu_in,
		int	flvf,
		double	E,
		double	L
	)

virtualinherited

Compute the probability of nu_in going to flvf for energy E and distance L

Compute the probability of nu_in going to flvf for a given energy in GeV and distance in km in a single path.

If the path sequence is not a single path, a new single path will be created and the previous sequence will be lost.

Don't use this if you want to propagate over multiple path segments.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

nu_in	- The neutrino initial state in flavour basis.
flvf	- The neutrino final flavour.
E	- The neutrino energy in GeV
L	- The neutrino path length in km

Returns: Neutrino oscillation probability

Definition at line 1189 of file PMNS_Base.cxx.

{
  SetEnergy(E);
  SetLength(L);
 
  return Prob(nu_in, flvf);
}

References OscProb::PMNS_Base::Prob(), OscProb::PMNS_Base::SetEnergy(), and OscProb::PMNS_Base::SetLength().

◆ ProbMatrix() [1/3]

matrixD PMNS_Base::ProbMatrix	(	int	nflvi,
		int	nflvf
	)

virtualinherited

Compute the probability matrix for the first nflvi and nflvf states.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

nflvi	- The number of initial flavours in the matrix.
nflvf	- The number of final flavours in the matrix.

Returns: Neutrino oscillation probabilities

Reimplemented in OscProb::PMNS_DensityMatrix, OscProb::PMNS_DensityMatrix, OscProb::PMNS_NUNM, and OscProb::PMNS_OQS.

Definition at line 1387 of file PMNS_Base.cxx.

{
  assert(nflvi <= fNumNus && nflvi >= 0);
  assert(nflvf <= fNumNus && nflvf >= 0);
 
  // Output probabilities
  matrixD probs(nflvi, vectorD(nflvf));
 
  // List of states
  matrixC allstates(nflvi, vectorC(fNumNus));
 
  // Reset all initial states
  for (int i = 0; i < nflvi; i++) {
    ResetToFlavour(i);
    allstates[i] = fNuState;
  }
 
  // Propagate all states in parallel
  for (int i = 0; i < int(fNuPaths.size()); i++) {
    for (int flvi = 0; flvi < nflvi; flvi++) {
      fNuState = allstates[flvi];
      PropagatePath(fNuPaths[i]);
      allstates[flvi] = fNuState;
    }
  }
 
  // Get all probabilities
  for (int flvi = 0; flvi < nflvi; flvi++) {
    for (int flvj = 0; flvj < nflvf; flvj++) {
      probs[flvi][flvj] = norm(allstates[flvi][flvj]);
    }
  }
 
  return probs;
}

References OscProb::PMNS_Base::fNumNus, OscProb::PMNS_Base::fNuPaths, OscProb::PMNS_Base::fNuState, OscProb::PMNS_Base::PropagatePath(), and OscProb::PMNS_Base::ResetToFlavour().

Referenced by OscProb::PMNS_Maltoni::AvgProbMatrix(), OscProb::PMNS_Base::AvgProbMatrix(), OscProb::PMNS_Maltoni::AvgProbMatrixLoE(), OscProb::PMNS_Base::AvgProbMatrixLoE(), and OscProb::PMNS_Base::ProbMatrix().

◆ ProbMatrix() [2/3]

matrixD PMNS_Base::ProbMatrix	(	int	nflvi,
		int	nflvf,
		double	E
	)

virtualinherited

Compute the probability matrix for the first nflvi and nflvf states for a given energy in GeV.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

nflvi	- The number of initial flavours in the matrix.
nflvf	- The number of final flavours in the matrix.
E	- The neutrino energy in GeV

Returns: Neutrino oscillation probabilities

Reimplemented in OscProb::PMNS_DensityMatrix.

Definition at line 1439 of file PMNS_Base.cxx.

{
  SetEnergy(E);
 
  return ProbMatrix(nflvi, nflvf);
}

References OscProb::PMNS_Base::ProbMatrix(), and OscProb::PMNS_Base::SetEnergy().

◆ ProbMatrix() [3/3]

matrixD PMNS_Base::ProbMatrix	(	int	nflvi,
		int	nflvf,
		double	E,
		double	L
	)

virtualinherited

Compute the probability matrix for energy E and distance L

Compute the probability matrix for the first nflvi and nflvf states for a given energy in GeV and distance in km in a single path.

If the path sequence is not a single path, a new single path will be created and the previous sequence will be lost.

Don't use this if you want to propagate over multiple path segments.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

nflvi	- The number of initial flavours in the matrix.
nflvf	- The number of final flavours in the matrix.
E	- The neutrino energy in GeV
L	- The neutrino path length in km

Returns: Neutrino oscillation probabilities

Reimplemented in OscProb::PMNS_DensityMatrix.

Definition at line 1468 of file PMNS_Base.cxx.

{
  SetEnergy(E);
  SetLength(L);
 
  return ProbMatrix(nflvi, nflvf);
}

References OscProb::PMNS_Base::ProbMatrix(), OscProb::PMNS_Base::SetEnergy(), and OscProb::PMNS_Base::SetLength().

◆ ProbVector() [1/6]

vectorD PMNS_Base::ProbVector ( int flvi )

virtualinherited

Compute the probabilities of flvi going to all flavours

Compute the probability of flvi going to all flavours.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

flvi	- The neutrino starting flavour.

Returns: Neutrino oscillation probabilities

Definition at line 1272 of file PMNS_Base.cxx.

{
  ResetToFlavour(flvi);
 
  Propagate();
 
  return GetProbVector();
}

References OscProb::PMNS_Base::GetProbVector(), OscProb::PMNS_Base::Propagate(), and OscProb::PMNS_Base::ResetToFlavour().

◆ ProbVector() [2/6]

vectorD PMNS_Base::ProbVector	(	int	flvi,
		double	E
	)

virtualinherited

Compute the probabilities of flvi going to all flavours for energy E

Compute the probability of flvi going to all flavours for a given energy in GeV.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

flvi	- The neutrino starting flavour.
E	- The neutrino energy in GeV

Returns: Neutrino oscillation probability

Definition at line 1313 of file PMNS_Base.cxx.

{
  SetEnergy(E);
 
  return ProbVector(flvi);
}

References OscProb::PMNS_Base::ProbVector(), and OscProb::PMNS_Base::SetEnergy().

◆ ProbVector() [3/6]

vectorD PMNS_Base::ProbVector	(	int	flvi,
		double	E,
		double	L
	)

virtualinherited

Compute the probabilities of flvi going to all flavours for energy E and distance L

Compute the probability of flvi going to all flavours for a given energy in GeV and distance in km in a single path.

If the path sequence is not a single path, a new single path will be created and the previous sequence will be lost.

Don't use this if you want to propagate over multiple path segments.

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

flvi	- The neutrino starting flavour.
E	- The neutrino energy in GeV
L	- The neutrino path length in km

Returns: Neutrino oscillation probability

Definition at line 1365 of file PMNS_Base.cxx.

{
  SetEnergy(E);
  SetLength(L);
 
  return ProbVector(flvi);
}

References OscProb::PMNS_Base::ProbVector(), OscProb::PMNS_Base::SetEnergy(), and OscProb::PMNS_Base::SetLength().

◆ ProbVector() [4/6]

vectorD PMNS_Base::ProbVector ( vectorC nu_in )

virtualinherited

Compute the probabilities of nu_in going to all flavours

Compute the probability of nu_in going to all flavours.

Parameters

nu_in - The neutrino initial state in flavour basis.

Returns: Neutrino oscillation probabilities

Definition at line 1250 of file PMNS_Base.cxx.

{
  SetPureState(nu_in);
 
  Propagate();
 
  return GetProbVector();
}

References OscProb::PMNS_Base::GetProbVector(), OscProb::PMNS_Base::Propagate(), and OscProb::PMNS_Base::SetPureState().

Referenced by OscProb::PMNS_Maltoni::AvgProbVector(), OscProb::PMNS_Base::AvgProbVector(), OscProb::PMNS_Maltoni::AvgProbVectorLoE(), OscProb::PMNS_Base::AvgProbVectorLoE(), and OscProb::PMNS_Base::ProbVector().

◆ ProbVector() [5/6]

vectorD PMNS_Base::ProbVector	(	vectorC	nu_in,
		double	E
	)

virtualinherited

Compute the probabilities of nu_in going to all

Compute the probability of nu_in going to all flavours for a given energy in GeV.

Parameters

nu_in	- The neutrino initial state in flavour basis.
E	- The neutrino energy in GeV

Returns: Neutrino oscillation probabilities

Definition at line 1291 of file PMNS_Base.cxx.

{
  SetEnergy(E);
 
  return ProbVector(nu_in);
}

References OscProb::PMNS_Base::ProbVector(), and OscProb::PMNS_Base::SetEnergy().

◆ ProbVector() [6/6]

vectorD PMNS_Base::ProbVector	(	vectorC	nu_in,
		double	E,
		double	L
	)

virtualinherited

Compute the probabilities of nu_in going to all flavours for energy E and distance L

Compute the probability of nu_in going to all flavours for a given energy in GeV and distance in km in a single path.

If the path sequence is not a single path, a new single path will be created and the previous sequence will be lost.

Don't use this if you want to propagate over multiple path segments.

Parameters

nu_in	- The neutrino initial state in flavour basis.
E	- The neutrino energy in GeV
L	- The neutrino path length in km

Returns: Neutrino oscillation probabilities

Definition at line 1336 of file PMNS_Base.cxx.

{
  SetEnergy(E);
  SetLength(L);
 
  return ProbVector(nu_in);
}

References OscProb::PMNS_Base::ProbVector(), OscProb::PMNS_Base::SetEnergy(), and OscProb::PMNS_Base::SetLength().

◆ Propagate()

void PMNS_Base::Propagate ( )

protectedvirtualinherited

Propagate neutrino state through full path

Reimplemented in OscProb::PMNS_NUNM, and OscProb::PMNS_OQS.

Definition at line 1018 of file PMNS_Base.cxx.

{
  for (int i = 0; i < int(fNuPaths.size()); i++) { PropagatePath(fNuPaths[i]); }
}

References OscProb::PMNS_Base::fNuPaths, and OscProb::PMNS_Base::PropagatePath().

Referenced by OscProb::PMNS_Base::Prob(), OscProb::PMNS_Base::ProbVector(), OscProb::PMNS_NUNM::Propagate(), and OscProb::PMNS_OQS::Propagate().

◆ PropagatePath()

void PMNS_Base::PropagatePath ( NuPath p )

protectedvirtualinherited

Propagate the current neutrino state through a given path

Parameters

p	- A neutrino path segment

Reimplemented in OscProb::PMNS_Decay, OscProb::PMNS_Deco, OscProb::PMNS_Iter, OscProb::PMNS_NUNM, OscProb::PMNS_OQS, and OscProb::PMNS_DensityMatrix.

Definition at line 983 of file PMNS_Base.cxx.

{
  // Set the neutrino path
  SetCurPath(p);
 
  // Solve for eigensystem
  SolveHam();
 
  double LengthIneV = kKm2eV * p.length;
  for (int i = 0; i < fNumNus; i++) {
    double arg = fEval[i] * LengthIneV;
    fPhases[i] = complexD(cos(arg), -sin(arg));
  }
 
  for (int i = 0; i < fNumNus; i++) {
    fBuffer[i] = 0;
    for (int j = 0; j < fNumNus; j++) {
      fBuffer[i] += conj(fEvec[j][i]) * fNuState[j];
    }
    fBuffer[i] *= fPhases[i];
  }
 
  // Propagate neutrino state
  for (int i = 0; i < fNumNus; i++) {
    fNuState[i] = 0;
    for (int j = 0; j < fNumNus; j++) {
      fNuState[i] += fEvec[i][j] * fBuffer[j];
    }
  }
}

References OscProb::PMNS_Base::fBuffer, OscProb::PMNS_Base::fEval, OscProb::PMNS_Base::fEvec, OscProb::PMNS_Base::fNumNus, OscProb::PMNS_Base::fNuState, OscProb::PMNS_Base::fPhases, OscProb::PMNS_Base::kKm2eV, OscProb::NuPath::length, OscProb::PMNS_Base::SetCurPath(), and OscProb::PMNS_Base::SolveHam().

Referenced by OscProb::PMNS_Base::ProbMatrix(), OscProb::PMNS_Base::Propagate(), OscProb::PMNS_Iter::PropagatePath(), and OscProb::PMNS_NUNM::PropagatePath().

◆ PropagatePathTaylor()

void PMNS_Maltoni::PropagatePathTaylor ( NuPath p )

protectedvirtualinherited

Propagate the current neutrino state through a given path

Parameters

p	- A neutrino path segment

Definition at line 343 of file PMNS_Maltoni.cxx.

{
  // Set the neutrino path
  SetCurPath(p);
 
  // Solve for eigensystem
  SolveHam();
 
  // Get the evolution matrix in mass basis
  double LengthIneV = kKm2eV * p.length;
  for (int i = 0; i < fNumNus; i++) {
    double arg = fEval[i] * LengthIneV;
    fPhases[i] = complexD(cos(arg), -sin(arg));
  }
 
  // Rotate S in flavor basis
  rotateS();
 
  // if avg on E
  if (fdInvE != 0) {
    // Build KE in mass basis
    BuildKE(p.length);
 
    // Rotate KE in flavor basis
    rotateK();
 
    // Multiply this layer K's with the previous path K's
    MultiplicationRuleK(fKInvE);
  }
  // if avg on cosT
  if (fdcosT != 0) {
    // Build KcosT in mass basis
    BuildKcosT();
 
    // Multiply this layer K's with the previous path K's
    MultiplicationRuleK(fKcosT);
  }
 
  // Multiply this layer S's with the previous path S's
  MultiplicationRuleS();
}

Referenced by OscProb::PMNS_Maltoni::PropagateTaylor().

◆ PropagateTaylor()

void PMNS_Maltoni::PropagateTaylor ( )

protectedvirtualinherited

Propagate neutrino state through full path

Definition at line 330 of file PMNS_Maltoni.cxx.

{
  for (int i = 0; i < int(fNuPaths.size()); i++) {
    PropagatePathTaylor(fNuPaths[i]);
  }
}

References OscProb::PMNS_Base::fNuPaths, and OscProb::PMNS_Maltoni::PropagatePathTaylor().

Referenced by OscProb::PMNS_Maltoni::AvgAlgo(), OscProb::PMNS_Maltoni::AvgAlgoCosT(), OscProb::PMNS_Maltoni::AvgProb(), OscProb::PMNS_Maltoni::ExtrapolationProb(), OscProb::PMNS_Maltoni::ExtrapolationProbCosT(), and OscProb::PMNS_Maltoni::ExtrapolationProbLoE().

◆ ResetToFlavour()

void PMNS_Base::ResetToFlavour ( int flv )

protectedvirtualinherited

Reset the neutrino state back to a pure flavour where it starts

Flavours are:

  0 = nue, 1 = numu, 2 = nutau
  3 = sterile_1, 4 = sterile_2, etc.

Parameters

flv	- The neutrino starting flavour.

Reimplemented in OscProb::PMNS_DensityMatrix.

Definition at line 1034 of file PMNS_Base.cxx.

{
  assert(flv >= 0 && flv < fNumNus);
  for (int i = 0; i < fNumNus; ++i) {
    if (i == flv)
      fNuState[i] = one;
    else
      fNuState[i] = zero;
  }
}

References OscProb::PMNS_Base::fNumNus, OscProb::PMNS_Base::fNuState, OscProb::PMNS_Base::one, and OscProb::PMNS_Base::zero.

◆ RotateDensityM()

void PMNS_Maltoni::RotateDensityM	(	bool	to_basis,
		matrixC	V
	)

protectedvirtualinherited

Apply rotation to the density matrix from or to the basis where V is diagonal

Parameters

to_basis	- Rotation from (false) or to (true)
V	- The matrix used for the denisty matrix rotation.

Definition at line 1173 of file PMNS_Maltoni.cxx.

{
  matrixC Buffer = matrixC(fNumNus, vectorC(fNumNus, 0));
 
  for (int i = 0; i < fNumNus; i++) {
    for (int j = 0; j < fNumNus; j++) {
      for (int k = 0; k < fNumNus; k++) {
        if (to_basis)
          Buffer[i][j] += fdensityMatrix[i][k] * V[k][j];
        else
          Buffer[i][j] += fdensityMatrix[i][k] * conj(V[j][k]);
      }
    }
  }
 
  for (int i = 0; i < fNumNus; i++) {
    for (int j = i; j < fNumNus; j++) {
      fdensityMatrix[i][j] = 0;
      for (int k = 0; k < fNumNus; k++) {
        if (to_basis)
          fdensityMatrix[i][j] += conj(V[k][i]) * Buffer[k][j];
        else
          fdensityMatrix[i][j] += V[i][k] * Buffer[k][j];
      }
      if (j > i) fdensityMatrix[j][i] = conj(fdensityMatrix[i][j]);
    }
  }
}

References OscProb::PMNS_Maltoni::fdensityMatrix, and OscProb::PMNS_Base::fNumNus.

Referenced by OscProb::PMNS_Maltoni::AlgorithmDensityMatrix().

◆ RotateH()

void PMNS_Base::RotateH	(	int	i,
		int	j,
		matrixC &	Ham
	)

protectedvirtualinherited

Rotate the Hamiltonian by the angle theta_ij and phase delta_ij.

The rotations assume all off-diagonal elements with i > j are zero. This is correct if the order of rotations is chosen appropriately and it speeds up computation by skipping null terms

Parameters

i,j	- the indices of the rotation ij
Ham	- the Hamiltonian to be rotated

Definition at line 822 of file PMNS_Base.cxx.

{
  // Do nothing if angle is zero
  if (fTheta[i][j] == 0) return;
 
  double fSinBuffer = sin(fTheta[i][j]);
  double fCosBuffer = cos(fTheta[i][j]);
 
  double   fHmsBufferD;
  complexD fHmsBufferC;
 
  // With Delta
  if (i + 1 < j) {
    complexD fExpBuffer = complexD(cos(fDelta[i][j]), -sin(fDelta[i][j]));
 
    // General case
    if (i > 0) {
      // Top columns
      for (int k = 0; k < i; k++) {
        fHmsBufferC = Ham[k][i];
 
        Ham[k][i] *= fCosBuffer;
        Ham[k][i] += Ham[k][j] * fSinBuffer * conj(fExpBuffer);
 
        Ham[k][j] *= fCosBuffer;
        Ham[k][j] -= fHmsBufferC * fSinBuffer * fExpBuffer;
      }
 
      // Middle row and column
      for (int k = i + 1; k < j; k++) {
        fHmsBufferC = Ham[k][j];
 
        Ham[k][j] *= fCosBuffer;
        Ham[k][j] -= conj(Ham[i][k]) * fSinBuffer * fExpBuffer;
 
        Ham[i][k] *= fCosBuffer;
        Ham[i][k] += fSinBuffer * fExpBuffer * conj(fHmsBufferC);
      }
 
      // Nodes ij
      fHmsBufferC = Ham[i][i];
      fHmsBufferD = real(Ham[j][j]);
 
      Ham[i][i] *= fCosBuffer * fCosBuffer;
      Ham[i][i] +=
          2 * fSinBuffer * fCosBuffer * real(Ham[i][j] * conj(fExpBuffer));
      Ham[i][i] += fSinBuffer * Ham[j][j] * fSinBuffer;
 
      Ham[j][j] *= fCosBuffer * fCosBuffer;
      Ham[j][j] += fSinBuffer * fHmsBufferC * fSinBuffer;
      Ham[j][j] -=
          2 * fSinBuffer * fCosBuffer * real(Ham[i][j] * conj(fExpBuffer));
 
      Ham[i][j] -= 2 * fSinBuffer * real(Ham[i][j] * conj(fExpBuffer)) *
                   fSinBuffer * fExpBuffer;
      Ham[i][j] +=
          fSinBuffer * fCosBuffer * (fHmsBufferD - fHmsBufferC) * fExpBuffer;
    }
    // First rotation on j (No top columns)
    else {
      // Middle rows and columns
      for (int k = i + 1; k < j; k++) {
        Ham[k][j] = -conj(Ham[i][k]) * fSinBuffer * fExpBuffer;
 
        Ham[i][k] *= fCosBuffer;
      }
 
      // Nodes ij
      fHmsBufferD = real(Ham[i][i]);
 
      Ham[i][j] =
          fSinBuffer * fCosBuffer * (Ham[j][j] - fHmsBufferD) * fExpBuffer;
 
      Ham[i][i] *= fCosBuffer * fCosBuffer;
      Ham[i][i] += fSinBuffer * Ham[j][j] * fSinBuffer;
 
      Ham[j][j] *= fCosBuffer * fCosBuffer;
      Ham[j][j] += fSinBuffer * fHmsBufferD * fSinBuffer;
    }
  }
  // Without Delta (No middle rows or columns: j = i+1)
  else {
    // General case
    if (i > 0) {
      // Top columns
      for (int k = 0; k < i; k++) {
        fHmsBufferC = Ham[k][i];
 
        Ham[k][i] *= fCosBuffer;
        Ham[k][i] += Ham[k][j] * fSinBuffer;
 
        Ham[k][j] *= fCosBuffer;
        Ham[k][j] -= fHmsBufferC * fSinBuffer;
      }
 
      // Nodes ij
      fHmsBufferC = Ham[i][i];
      fHmsBufferD = real(Ham[j][j]);
 
      Ham[i][i] *= fCosBuffer * fCosBuffer;
      Ham[i][i] += 2 * fSinBuffer * fCosBuffer * real(Ham[i][j]);
      Ham[i][i] += fSinBuffer * Ham[j][j] * fSinBuffer;
 
      Ham[j][j] *= fCosBuffer * fCosBuffer;
      Ham[j][j] += fSinBuffer * fHmsBufferC * fSinBuffer;
      Ham[j][j] -= 2 * fSinBuffer * fCosBuffer * real(Ham[i][j]);
 
      Ham[i][j] -= 2 * fSinBuffer * real(Ham[i][j]) * fSinBuffer;
      Ham[i][j] += fSinBuffer * fCosBuffer * (fHmsBufferD - fHmsBufferC);
    }
    // First rotation (theta12)
    else {
      Ham[i][j] = fSinBuffer * fCosBuffer * Ham[j][j];
 
      Ham[i][i] = fSinBuffer * Ham[j][j] * fSinBuffer;
 
      Ham[j][j] *= fCosBuffer * fCosBuffer;
    }
  }
}

References OscProb::PMNS_Base::fDelta, and OscProb::PMNS_Base::fTheta.

Referenced by OscProb::PMNS_Base::BuildHms(), OscProb::PMNS_Decay::BuildHms(), and OscProb::PMNS_SNSI::BuildHms().

◆ rotateK()

void PMNS_Maltoni::rotateK ( )

protectedvirtualinherited

Rotate the K matrix from mass to flavor basis

Definition at line 238 of file PMNS_Maltoni.cxx.

{
  complexD buffer[fNumNus];
 
  for (int j = 0; j < fNumNus; j++) {
    for (int k = 0; k < fNumNus; k++) {
      buffer[k] = 0;
 
      for (int l = 0; l < fNumNus; l++) {
        buffer[k] += fKmass[k][l] * conj(fEvec[j][l]);
      }
    }
 
    for (int i = 0; i <= j; i++) {
      fKflavor[i][j] = 0;
 
      for (int k = 0; k < fNumNus; k++) {
        fKflavor[i][j] += fEvec[i][k] * buffer[k];
      }
 
      if (i != j) { fKflavor[j][i] = conj(fKflavor[i][j]); }
    }
  }
}

References OscProb::PMNS_Base::fEvec, OscProb::PMNS_Maltoni::fKflavor, OscProb::PMNS_Maltoni::fKmass, and OscProb::PMNS_Base::fNumNus.

Referenced by OscProb::PMNS_Maltoni::PropagatePathTaylor().

◆ rotateS()

void PMNS_Maltoni::rotateS ( )

protectedvirtualinherited

Rotate the S matrix for the current layer from mass to flavor basis

Definition at line 216 of file PMNS_Maltoni.cxx.

{
  complexD buffer[fNumNus];
 
  for (int j = 0; j < fNumNus; j++) {
    for (int k = 0; k < fNumNus; k++) {
      buffer[k] = fPhases[k] * conj(fEvec[j][k]);
    }
 
    for (int i = 0; i < fNumNus; i++) {
      fSflavor[i][j] = 0;
      for (int k = 0; k < fNumNus; k++) {
        fSflavor[i][j] += fEvec[i][k] * buffer[k];
      }
    }
  }
}

References OscProb::PMNS_Base::fEvec, OscProb::PMNS_Base::fNumNus, OscProb::PMNS_Base::fPhases, and OscProb::PMNS_Maltoni::fSflavor.

Referenced by OscProb::PMNS_Maltoni::PropagatePathTaylor().

◆ RotateState()

void PMNS_Base::RotateState	(	int	i,
		int	j
	)

protectedvirtualinherited

Rotate the neutrino state by the angle theta_ij and phase delta_ij.

Parameters

i,j	- the indices of the rotation ij

Definition at line 760 of file PMNS_Base.cxx.

{
  // Do nothing if angle is zero
  if (fTheta[i][j] == 0) return;
 
  double sij = sin(fTheta[i][j]);
  double cij = cos(fTheta[i][j]);
 
  complexD buffer;
 
  if (i + 1 == j || fDelta[i][j] == 0) {
    buffer      = cij * fNuState[i] + sij * fNuState[j];
    fNuState[j] = cij * fNuState[j] - sij * fNuState[i];
  }
  else {
    complexD eij = complexD(cos(fDelta[i][j]), -sin(fDelta[i][j]));
    buffer       = cij * fNuState[i] + sij * eij * fNuState[j];
    fNuState[j]  = cij * fNuState[j] - sij * conj(eij) * fNuState[i];
  }
 
  fNuState[i] = buffer;
}

References OscProb::PMNS_Base::fDelta, OscProb::PMNS_Base::fNuState, and OscProb::PMNS_Base::fTheta.

Referenced by OscProb::PMNS_Base::GetMassEigenstate().

◆ SetAngle()

void PMNS_Base::SetAngle	(	int	i,
		int	j,
		double	th
	)

virtualinherited

Set the mixing angle theta_ij in radians.

Requires that i<j. Will notify you if input is wrong. If i>j, will assume reverse order and swap i and j.

This will check if value is changing to keep track of whether the hamiltonian needs to be rebuilt.

Parameters

i,j	- the indices of theta_ij
th	- the value of theta_ij

Definition at line 539 of file PMNS_Base.cxx.

{
  if (i > j) {
    cerr << "WARNING: First argument should be smaller than second argument"
         << endl
         << "         Setting reverse order (Theta" << j << i << "). " << endl;
    int temp = i;
    i        = j;
    j        = temp;
  }
  if (i < 1 || i > fNumNus - 1 || j < 2 || j > fNumNus) {
    cerr << "ERROR: Theta" << i << j << " not valid for " << fNumNus
         << " neutrinos. Doing nothing." << endl;
    return;
  }
 
  // Check if value is actually changing
  fBuiltHms *= (fTheta[i - 1][j - 1] == th);
 
  fTheta[i - 1][j - 1] = th;
}

References OscProb::PMNS_Base::fBuiltHms, OscProb::PMNS_Base::fNumNus, and OscProb::PMNS_Base::fTheta.

Referenced by GetSterile(), OscProb::PMNS_Decay::SetMix(), OscProb::PMNS_Fast::SetMix(), SetNominalPars(), and OscProb::PMNS_Base::SetStdPars().

◆ SetaT() [1/2]

void PMNS_LIV::SetaT	(	int	flvi,
		int	flvj,
		double	val,
		double	phase
	)

virtual

Set any given aT parameter with dimension 3.

This will check if value is changing to keep track of whether the eigensystem needs to be recomputed.

Flavours are:

0 = nue, 1 = numu, 2 = nutau

Requires that flvi < flvj. Will notify you if input is wrong. If flvi > flvj, will assume reverse order and swap flvi and flvj.

Parameters

flvi	- The first flavour index
flvj	- The second flavour index
val	- The absolute value of the parameter
phase	- The complex phase of the parameter in radians

Definition at line 388 of file PMNS_LIV.cxx.

{
  SetaT(flvi, flvj, 3, val, phase);
}

References SetaT().

◆ SetaT() [2/2]

void PMNS_LIV::SetaT	(	int	flvi,
		int	flvj,
		int	dim,
		double	val,
		double	phase
	)

virtual

Set any given LIV parameter of a chosen dimension. The flavour convention is: e -> 0 mu -> 1 tau -> 2

Set any given aT parameter of a chosen dimension.

Flavours are:

0 = nue, 1 = numu, 2 = nutau

Requires that flvi < flvj. Will notify you if input is wrong. If flvi > flvj, will assume reverse order and swap flvi and flvj.

Parameters

flvi	- First flavour index
flvj	- Second flavour index
dim	- Dimension of the coefficient: can be 3,5,7.
val	- Absolute value of the parameter
phase	- Complex phase of the parameter in radians

Definition at line 68 of file PMNS_LIV.cxx.

{
  if (flvi > flvj) {
    cerr << "WARNING: First argument should be smaller or equal to second "
            "argument"
         << endl
         << "Setting reverse order (aT_" << flvj << flvi << "). " << endl;
    int temp = flvi;
    flvi     = flvj;
    flvj     = temp;
  }
  if (flvi < 0 || flvi > 2 || flvj < flvi || flvj > 2) {
    cerr << "WARNING: aT_" << flvi << flvj << " not valid for " << fNumNus
         << " neutrinos. Doing nothing." << endl;
    return;
  }
  if (dim != 3 && dim != 5 && dim != 7) {
    cerr << "WARNING: Invalid aT coefficient dimension dim=" << dim
         << " not in  [3,5,7].\n";
    return;
  }
 
  int pos = (dim - 3) / 2;
 
  complexD h = val;
 
  if (flvi != flvj) h *= complexD(cos(phase), sin(phase));
 
  bool isSame = (faT[flvi][flvj][pos] == h);
 
  if (!isSame) ClearCache();
 
  fGotES *= isSame;
 
  faT[flvi][flvj][pos] = h;
}

References OscProb::PMNS_Base::ClearCache(), faT, OscProb::PMNS_Base::fGotES, and OscProb::PMNS_Base::fNumNus.

Referenced by GetLIV(), PMNS_LIV(), SetaT(), SetaT_ee(), SetaT_emu(), SetaT_etau(), SetaT_mumu(), SetaT_mutau(), SetaT_tautau(), and SetLIV().

◆ SetaT_ee()

void PMNS_LIV::SetaT_ee ( double a )

virtual

Set aT_ee parameter

Parameters

a	- The absolute value of the parameter

Definition at line 422 of file PMNS_LIV.cxx.

422{ SetaT(0, 0, a, 0); }

References SetaT().

◆ SetaT_emu()

void PMNS_LIV::SetaT_emu	(	double	a,
		double	phi
	)

virtual

Set aT_emu parameter

Parameters

a	- The absolute value of the parameter
phi	- The complex phase of the parameter in radians

Definition at line 447 of file PMNS_LIV.cxx.

447{ SetaT(0, 1, a, phi); }

References SetaT().

◆ SetaT_etau()

void PMNS_LIV::SetaT_etau	(	double	a,
		double	phi
	)

virtual

Set aT_etau parameter

Parameters

a	- The absolute value of the parameter
phi	- The complex phase of the parameter in radians

Definition at line 456 of file PMNS_LIV.cxx.

456{ SetaT(0, 2, a, phi); }

References SetaT().

◆ SetaT_mumu()

void PMNS_LIV::SetaT_mumu ( double a )

virtual

Set aT_mumu parameter

Parameters

a	- The absolute value of the parameter

Definition at line 430 of file PMNS_LIV.cxx.

430{ SetaT(1, 1, a, 0); }

References SetaT().

◆ SetaT_mutau()

void PMNS_LIV::SetaT_mutau	(	double	a,
		double	phi
	)

virtual

Set aT_mutau parameter

Parameters

a	- The absolute value of the parameter
phi	- The complex phase of the parameter in radians

Definition at line 465 of file PMNS_LIV.cxx.

465{ SetaT(1, 2, a, phi); }

References SetaT().

◆ SetaT_tautau()

void PMNS_LIV::SetaT_tautau ( double a )

virtual

Set aT_tautau parameter

Parameters

a	- The absolute value of the parameter

Definition at line 438 of file PMNS_LIV.cxx.

438{ SetaT(2, 2, a, 0); }

References SetaT().

◆ SetAtt() [1/2]

void PMNS_Base::SetAtt	(	double	att,
		int	idx
	)

protectedvirtualinherited

Set some single path attribute.

An auxiliary function to set individual attributes in a single path.

If the path sequence is not a single path, a new single path will be created and the previous sequence will be lost. Use with care.

Parameters

att	- The value of the attribute
idx	- The index of the attribute (0,1,2,3) = (L, Rho, Z/A, Layer)

Definition at line 364 of file PMNS_Base.cxx.

{
  if (fNuPaths.size() != 1) {
    cerr << "WARNING: Clearing path vector and starting new single path."
         << endl
         << "To avoid possible issues, use the SetPath function." << endl;
 
    SetStdPath();
  }
 
  switch (idx) {
    case 0: fNuPaths[0].length = att; break;
    case 1: fNuPaths[0].density = att; break;
    case 2: fNuPaths[0].zoa = att; break;
    case 3: fNuPaths[0].layer = att; break;
  }
}

References OscProb::PMNS_Base::fNuPaths, and OscProb::PMNS_Base::SetStdPath().

Referenced by OscProb::PMNS_Base::SetDensity(), OscProb::PMNS_Base::SetLayers(), OscProb::PMNS_Base::SetLength(), and OscProb::PMNS_Base::SetZoA().

◆ SetAtt() [2/2]

void PMNS_Base::SetAtt	(	vectorD	att,
		int	idx
	)

protectedvirtualinherited

Set all values of a path attribute.

An auxiliary function to set individual attributes in a path sequence.

If the path sequence is of a different size, a new path sequence will be created and the previous sequence will be lost. Use with care.

Parameters

att	- The values of the attribute
idx	- The index of the attribute (0,1,2,3) = (L, Rho, Z/A, Layer)

Definition at line 427 of file PMNS_Base.cxx.

{
  // Get the sizes of the attribute and
  // path sequence vectors
  int nA = att.size();
  int nP = fNuPaths.size();
 
  // If the vector sizes are equal, update this attribute
  if (nA == nP) {
    for (int i = 0; i < nP; i++) {
      switch (idx) {
        case 0: fNuPaths[i].length = att[i]; break;
        case 1: fNuPaths[i].density = att[i]; break;
        case 2: fNuPaths[i].zoa = att[i]; break;
        case 3: fNuPaths[i].layer = att[i]; break;
      }
    }
  }
  // If the vector sizes differ, create a new path sequence
  // and set value for this attribute. Other attributes will
  // be taken from default single path.
  else {
    cerr << "WARNING: New vector size. Starting new path vector." << endl
         << "To avoid possible issues, use the SetPath function." << endl;
 
    // Start a new standard path just
    // to set default values
    SetStdPath();
 
    // Create a path segment with default values
    NuPath p = fNuPaths[0];
 
    // Clear the path sequence
    ClearPath();
 
    // Set this particular attribute's value
    // and add the path segment to the sequence
    for (int i = 0; i < nA; i++) {
      switch (idx) {
        case 0: p.length = att[i]; break;
        case 1: p.density = att[i]; break;
        case 2: p.zoa = att[i]; break;
        case 3: p.layer = att[i]; break;
      }
 
      AddPath(p);
    }
  }
}

References OscProb::PMNS_Base::AddPath(), OscProb::PMNS_Base::ClearPath(), OscProb::NuPath::density, OscProb::PMNS_Base::fNuPaths, OscProb::NuPath::layer, OscProb::NuPath::length, OscProb::PMNS_Base::SetStdPath(), and OscProb::NuPath::zoa.

◆ SetAvgProbPrec()

void PMNS_Base::SetAvgProbPrec ( double prec )

virtualinherited

Set the precision for the AvgProb method

Parameters

prec	- AvgProb precision

Definition at line 1962 of file PMNS_Base.cxx.

{
  if (prec < 1e-8) {
    cerr << "WARNING: Cannot set AvgProb precision lower that 1e-8."
         << "Setting to 1e-8." << endl;
    prec = 1e-8;
  }
  fAvgProbPrec = prec;
}

Referenced by OscProb::PMNS_Base::AvgProbLoE(), OscProb::PMNS_Base::AvgProbMatrixLoE(), OscProb::PMNS_Base::AvgProbVectorLoE(), OscProb::PMNS_OQS::BuildHVMB(), OscProb::PMNS_Base::ConvertEtoLoE(), OscProb::PMNS_Maltoni::ExtrapolationProbLoE(), OscProb::PMNS_Base::PropagatePath(), OscProb::PMNS_Decay::PropagatePath(), OscProb::PMNS_Deco::PropagatePath(), and OscProb::PMNS_Maltoni::PropagatePathTaylor().

Referenced by OscProb::PMNS_Base::PMNS_Base(), and OscProb::PMNS_Maltoni::PMNS_Maltoni().

◆ SetCosT()

void PMNS_Maltoni::SetCosT ( double cosT )

protectedvirtualinherited

Set neutrino zenith angle.

Parameters

cosT	- The cosine of the zenith angle

Definition at line 92 of file PMNS_Maltoni.cxx.

92{ fcosT = cosT; }

References OscProb::PMNS_Maltoni::fcosT.

Referenced by OscProb::PMNS_Maltoni::AvgAlgo(), OscProb::PMNS_Maltoni::AvgAlgoCosT(), OscProb::PMNS_Maltoni::AvgProb(), and OscProb::PMNS_Maltoni::ExtrapolationProbCosT().

◆ SetcT() [1/2]

void PMNS_LIV::SetcT	(	int	flvi,
		int	flvj,
		double	val,
		double	phase
	)

virtual

Set any given cT parameter with dimension 4.

This will check if value is changing to keep track of whether the eigensystem needs to be recomputed.

Flavours are:

0 = nue, 1 = numu, 2 = nutau

Requires that flvi < flvj. Will notify you if input is wrong. If flvi > flvj, will assume reverse order and swap flvi and flvj.

Parameters

flvi	- The first flavour index
flvj	- The second flavour index
val	- The absolute value of the parameter
phase	- The complex phase of the parameter in radians

Definition at line 411 of file PMNS_LIV.cxx.

{
  SetcT(flvi, flvj, 4, val, phase);
}

References SetcT().

◆ SetcT() [2/2]

void PMNS_LIV::SetcT	(	int	flvi,
		int	flvj,
		int	dim,
		double	val,
		double	phase
	)

virtual

Set any given cT parameter of a chosen dimension.

Flavours are:

0 = nue, 1 = numu, 2 = nutau

Requires that flvi < flvj. Will notify you if input is wrong. If flvi > flvj, will assume reverse order and swap flvi and flvj.

Parameters

flvi	- First flavour index
flvj	- Second flavour index
dim	- Dimension of the coefficient: can be 4,6,8.
val	- Absolute value of the parameter
phase	- Complex phase of the parameter in radians

Definition at line 120 of file PMNS_LIV.cxx.

{
  if (flvi > flvj) {
    cerr << "WARNING: First argument should be smaller or equal to second "
            "argument"
         << endl
         << "Setting reverse order (cT_" << flvj << flvi << "). " << endl;
    int temp = flvi;
    flvi     = flvj;
    flvj     = temp;
  }
  if (flvi < 0 || flvi > 2 || flvj < flvi || flvj > 2) {
    cerr << "WARNING: cT_" << flvi << flvj << " not valid for " << fNumNus
         << " neutrinos. Doing nothing." << endl;
    return;
  }
  if (dim != 4 && dim != 6 && dim != 8) {
    cerr << "WARNING: Invalid cT coefficient dimension dim=" << dim
         << " not in  [4,6,8].\n";
    return;
  }
 
  int pos = dim / 2 - 2;
 
  complexD h = val;
 
  if (flvi != flvj) h *= complexD(cos(phase), sin(phase));
 
  bool isSame = (fcT[flvi][flvj][pos] == h);
 
  if (!isSame) ClearCache();
 
  fGotES *= isSame;
 
  fcT[flvi][flvj][pos] = h;
}

References OscProb::PMNS_Base::ClearCache(), fcT, OscProb::PMNS_Base::fGotES, and OscProb::PMNS_Base::fNumNus.

Referenced by GetLIV(), PMNS_LIV(), SetcT(), SetcT_ee(), SetcT_emu(), SetcT_etau(), SetcT_mumu(), SetcT_mutau(), SetcT_tautau(), and SetLIV().

◆ SetcT_ee()

void PMNS_LIV::SetcT_ee ( double a )

virtual

Set cT_ee parameter

Parameters

a	- The absolute value of the parameter

Definition at line 473 of file PMNS_LIV.cxx.

473{ SetcT(0, 0, a, 0); }

References SetcT().

◆ SetcT_emu()

void PMNS_LIV::SetcT_emu	(	double	a,
		double	phi
	)

virtual

Set cT_emu parameter

Parameters

a	- The absolute value of the parameter
phi	- The complex phase of the parameter in radians

Definition at line 498 of file PMNS_LIV.cxx.

498{ SetcT(0, 1, a, phi); }

References SetcT().

◆ SetcT_etau()

void PMNS_LIV::SetcT_etau	(	double	a,
		double	phi
	)

virtual

Set cT_etau parameter

Parameters

a	- The absolute value of the parameter
phi	- The complex phase of the parameter in radians

Definition at line 507 of file PMNS_LIV.cxx.

507{ SetcT(0, 2, a, phi); }

References SetcT().

◆ SetcT_mumu()

void PMNS_LIV::SetcT_mumu ( double a )

virtual

Set cT_mumu parameter

Parameters

a	- The absolute value of the parameter

Definition at line 481 of file PMNS_LIV.cxx.

481{ SetcT(1, 1, a, 0); }

References SetcT().

◆ SetcT_mutau()

void PMNS_LIV::SetcT_mutau	(	double	a,
		double	phi
	)

virtual

Set cT_mutau parameter

Parameters

a	- The absolute value of the parameter
phi	- The complex phase of the parameter in radians

Definition at line 516 of file PMNS_LIV.cxx.

516{ SetcT(1, 2, a, phi); }

References SetcT().

◆ SetcT_tautau()

void PMNS_LIV::SetcT_tautau ( double a )

virtual

Set cT_tautau parameter

Parameters

a	- The absolute value of the parameter

Definition at line 489 of file PMNS_LIV.cxx.

489{ SetcT(2, 2, a, 0); }

References SetcT().

◆ SetCurPath()

void PMNS_Base::SetCurPath ( NuPath p )

protectedvirtualinherited

Set the path currentlyin use by the class.

This will be used to know what path to propagate through next.

It will also check if values are changing to keep track of whether the eigensystem needs to be recomputed.

Parameters

p	- A neutrino path segment

Definition at line 274 of file PMNS_Base.cxx.

{
  // Check if relevant value are actually changing
  fGotES *= (fPath.density == p.density);
  fGotES *= (fPath.zoa == p.zoa);
 
  fPath = p;
}

References OscProb::NuPath::density, OscProb::PMNS_Base::fGotES, OscProb::PMNS_Base::fPath, and OscProb::NuPath::zoa.

◆ SetDelta()

void PMNS_Base::SetDelta	(	int	i,
		int	j,
		double	delta
	)

virtualinherited

Set the CP phase delta_ij in radians.

Requires that i+1<j. Will notify you if input is wrong. If i>j, will assume reverse order and swap i and j.

This will check if value is changing to keep track of whether the hamiltonian needs to be rebuilt.

Parameters

i,j	- the indices of delta_ij
delta	- the value of delta_ij

Definition at line 602 of file PMNS_Base.cxx.

{
  if (i > j) {
    cerr << "WARNING: First argument should be smaller than second argument"
         << endl
         << "         Setting reverse order (Delta" << j << i << "). " << endl;
    int temp = i;
    i        = j;
    j        = temp;
  }
  if (i < 1 || i > fNumNus - 1 || j < 2 || j > fNumNus) {
    cerr << "ERROR: Delta" << i << j << " not valid for " << fNumNus
         << " neutrinos. Doing nothing." << endl;
    return;
  }
  if (i + 1 == j) {
    cerr << "WARNING: Rotation " << i << j << " is real. Doing nothing."
         << endl;
    return;
  }
 
  // Check if value is actually changing
  fBuiltHms *= (fDelta[i - 1][j - 1] == delta);
 
  fDelta[i - 1][j - 1] = delta;
}

References OscProb::PMNS_Base::fBuiltHms, OscProb::PMNS_Base::fDelta, and OscProb::PMNS_Base::fNumNus.

Referenced by OscProb::PMNS_Decay::SetMix(), OscProb::PMNS_Fast::SetMix(), and SetNominalPars().

◆ SetDeltaMsqrs()

void PMNS_Fast::SetDeltaMsqrs	(	double	dm21,
		double	dm32
	)

virtualinherited

Set both mass-splittings at once.

These are Dm_21 and Dm_32 in eV^2.
The corresponding Dm_31 is set in the class attributes.

Parameters

dm21	- The solar mass-splitting Dm_21
dm32	- The atmospheric mass-splitting Dm_32

Definition at line 55 of file PMNS_Fast.cxx.

{
  SetDm(2, dm21);
  SetDm(3, dm32 + dm21);
}

References OscProb::PMNS_Base::SetDm().

◆ SetDensity() [1/2]

void PMNS_Base::SetDensity ( double rho )

virtualinherited

Set single path density.

If the path sequence is not a single path, a new single path will be created and the previous sequence will be lost. Use with care.

Parameters

rho	- The density of the path segment in g/cm^3

Definition at line 402 of file PMNS_Base.cxx.

402{ SetAtt(rho, 1); }

OscProb::PMNS_Base::SetAtt

virtual void SetAtt(double att, int idx)

Set one of the path attributes.

Definition: PMNS_Base.cxx:364

◆ SetDensity() [2/2]

void PMNS_Base::SetDensity ( vectorD rho )

virtualinherited

Set multiple path densities.

If the path sequence is of a different size, a new path sequence will be created and the previous sequence will be lost. Use with care.

Parameters

rho	- The densities of the path segments in g/cm^3

Definition at line 497 of file PMNS_Base.cxx.

497{ SetAtt(rho, 1); }

Referenced by OscProb::PMNS_Maltoni::AvgAlgo(), OscProb::PMNS_Maltoni::AvgAlgoCosT(), OscProb::PMNS_Maltoni::AvgProb(), OscProb::PMNS_Base::AvgProbLoE(), OscProb::PMNS_Base::AvgProbMatrixLoE(), OscProb::PMNS_Base::AvgProbVectorLoE(), OscProb::PMNS_Maltoni::ExtrapolationProb(), OscProb::PMNS_Maltoni::ExtrapolationProbLoE(), OscProb::PMNS_Base::PMNS_Base(), OscProb::PMNS_Base::Prob(), OscProb::PMNS_Base::ProbMatrix(), and OscProb::PMNS_Base::ProbVector().

◆ SetDm()

void PMNS_Base::SetDm	(	int	j,
		double	dm
	)

virtualinherited

Set the mass-splitting dm_j1 = (m_j^2 - m_1^2) in eV^2

Requires that j>1. Will notify you if input is wrong.

This will check if value is changing to keep track of whether the hamiltonian needs to be rebuilt.

Parameters

j	- the index of dm_j1
dm	- the value of dm_j1

Definition at line 674 of file PMNS_Base.cxx.

{
  if (j < 2 || j > fNumNus) {
    cerr << "ERROR: Dm" << j << "1 not valid for " << fNumNus
         << " neutrinos. Doing nothing." << endl;
    return;
  }
 
  // Check if value is actually changing
  fBuiltHms *= (fDm[j - 1] == dm);
 
  fDm[j - 1] = dm;
}

References OscProb::PMNS_Base::fBuiltHms, OscProb::PMNS_Base::fDm, and OscProb::PMNS_Base::fNumNus.

Referenced by GetSterile(), OscProb::PMNS_Decay::SetDeltaMsqrs(), OscProb::PMNS_Fast::SetDeltaMsqrs(), SetNominalPars(), and OscProb::PMNS_Base::SetStdPars().

◆ SetEnergy()

void PMNS_Base::SetEnergy ( double E )

virtualinherited

Set neutrino energy in GeV.

This will check if value is changing to keep track of whether the eigensystem needs to be recomputed.

Parameters

E	- The neutrino energy in GeV

Definition at line 226 of file PMNS_Base.cxx.

{
  // Check if value is actually changing
  fGotES *= (fEnergy == E);
 
  fEnergy = E;
}

References OscProb::PMNS_Base::fEnergy, and OscProb::PMNS_Base::fGotES.

◆ SetIsNuBar()

void PMNS_Base::SetIsNuBar ( bool isNuBar )

virtualinherited

Set anti-neutrino flag.

This will check if value is changing to keep track of whether the eigensystem needs to be recomputed.

Parameters

isNuBar - Set to true for anti-neutrino and false for neutrino.

Reimplemented in OscProb::PMNS_Decay, OscProb::PMNS_Iter, and OscProb::PMNS_OQS.

Definition at line 243 of file PMNS_Base.cxx.

{
  // Check if value is actually changing
  fGotES *= (fIsNuBar == isNuBar);
 
  fIsNuBar = isNuBar;
}

References OscProb::PMNS_Base::fGotES, and OscProb::PMNS_Base::fIsNuBar.

Referenced by CheckProb(), OscProb::PMNS_Base::PMNS_Base(), SaveTestFile(), and OscProb::PMNS_OQS::SetIsNuBar().

◆ SetIsOscProbAvg()

virtual void OscProb::PMNS_LIV::SetIsOscProbAvg ( bool isOscProbAvg )

inlinevirtual

Reimplemented from OscProb::PMNS_Maltoni.

Definition at line 49 of file PMNS_LIV.h.

References OscProb::PMNS_Maltoni::fIsOscProbAvg.

Referenced by PMNS_LIV().

◆ SetLayers()

void PMNS_Base::SetLayers ( std::vector< int > lay )

virtualinherited

Set multiple path layer indices.

If the path sequence is of a different size, a new path sequence will be created and the previous sequence will be lost. Use with care.

Parameters

lay	- Indices to identify the layer types (e.g. earth inner core)

Definition at line 519 of file PMNS_Base.cxx.

{
  vectorD lay_double(lay.begin(), lay.end());
 
  SetAtt(lay_double, 3);
}

◆ SetLength() [1/2]

void PMNS_Base::SetLength ( double L )

virtualinherited

Set the length for a single path.

If the path sequence is not a single path, a new single path will be created and the previous sequence will be lost. Use with care.

Parameters

L	- The length of the path segment in km

Definition at line 391 of file PMNS_Base.cxx.

391{ SetAtt(L, 0); }

Referenced by OscProb::PMNS_Base::Prob(), OscProb::PMNS_Base::ProbMatrix(), and OscProb::PMNS_Base::ProbVector().

◆ SetLength() [2/2]

void PMNS_Base::SetLength ( vectorD L )

virtualinherited

Set multiple path lengths.

If the path sequence is of a different size, a new path sequence will be created and the previous sequence will be lost. Use with care.

Parameters

L	- The lengths of the path segments in km

Definition at line 486 of file PMNS_Base.cxx.

486{ SetAtt(L, 0); }

OscProb::PMNS_Base::fMaxCache

◆ SetLIV()

void PMNS_LIV::SetLIV	(	double	aT_ee,
		double	aT_mumu,
		double	aT_tautau,
		double	aT_emu,
		double	aT_etau,
		double	aT_mutau,
		double	cT_ee,
		double	cT_mumu,
		double	cT_tautau,
		double	cT_emu,
		double	cT_etau,
		double	cT_mutau,
		double	delta_aT_emu = `0`,
		double	delta_aT_etau = `0`,
		double	delta_aT_mutau = `0`,
		double	delta_cT_emu = `0`,
		double	delta_cT_etau = `0`,
		double	delta_cT_mutau = `0`
	)

Set all LIV parameters at once.

Parameters

aT_ee	- The absolute value of the parameter aT_ee
aT_mumu	- The absolute value of the parameter aT_mumu
aT_tautau	- The absolute value of the parameter aT_tautau
aT_emu	- The absolute value of the parameter aT_emu
aT_etau	- The absolute value of the parameter aT_etau
aT_mutau	- The absolute value of the parameter aT_mutau
delta_aT_emu	- The phase of the complex parameter aT_emu in radians
delta_aT_etau	- The phase of the complex parameter aT_etau in radians
delta_aT_mutau	- The phase of the complex parameter aT_mutau in radians
cT_ee	- The absolute value of the parameter cT_ee
cT_mumu	- The absolute value of the parameter cT_mumu
cT_tautau	- The absolute value of the parameter cT_tautau
cT_emu	- The absolute value of the parameter cT_emu
cT_etau	- The absolute value of the parameter cT_etau
cT_mutau	- The absolute value of the parameter cT_mutau
delta_cT_emu	- The phase of the complex parameter cT_emu in radians
delta_cT_etau	- The phase of the complex parameter cT_etau in radians
delta_cT_mutau	- The phase of the complex parameter cT_mutau in radians

Definition at line 345 of file PMNS_LIV.cxx.

{
  SetaT(0, 0, aT_ee, 0);
  SetaT(1, 1, aT_mumu, 0);
  SetaT(2, 2, aT_tautau, 0);
 
  SetaT(0, 1, aT_emu, delta_aT_emu);
  SetaT(0, 2, aT_etau, delta_aT_etau);
  SetaT(1, 2, aT_mutau, delta_aT_mutau);
 
  SetcT(0, 0, cT_ee, 0);
  SetcT(1, 1, cT_mumu, 0);
  SetcT(2, 2, cT_tautau, 0);
 
  SetcT(0, 1, cT_emu, delta_cT_emu);
  SetcT(0, 2, cT_etau, delta_cT_etau);
  SetcT(1, 2, cT_mutau, delta_cT_mutau);
}

References SetaT(), and SetcT().

◆ SetMaxCache()

void PMNS_Base::SetMaxCache ( int mc = 1e6 )

virtualinherited

Set maximum number of cached eigensystems. Finding eigensystems can become slow and take up memory. This protects the cache from becoming too large.

Parameters

mc	- Max cache size (default: 1e6)

Definition at line 128 of file PMNS_Base.cxx.

128{ fMaxCache = mc; }

int fMaxCache

Maximum cache size.

Definition: PMNS_Base.h:303

References OscProb::PMNS_Base::fMaxCache.

◆ SetMix()

void PMNS_Fast::SetMix	(	double	th12,
		double	th23,
		double	th13,
		double	deltacp
	)

virtualinherited

Set all mixing parameters at once.

Parameters

th12	- The value of the mixing angle theta_12
th23	- The value of the mixing angle theta_23
th13	- The value of the mixing angle theta_13
deltacp	- The value of the CP phase delta_13

Definition at line 37 of file PMNS_Fast.cxx.

{
  SetAngle(1, 2, th12);
  SetAngle(1, 3, th13);
  SetAngle(2, 3, th23);
  SetDelta(1, 3, deltacp);
}

References OscProb::PMNS_Base::SetAngle(), and OscProb::PMNS_Base::SetDelta().

◆ SetPath() [1/3]

void PMNS_Base::SetPath	(	double	length,
		double	density,
		double	zoa = `0.5`,
		int	layer = `0`
	)

virtualinherited

Set a single path defining attributes directly.

This destroys the current path sequence and creates a new first path.

Parameters

length	- The length of the path segment in km
density	- The density of the path segment in g/cm^3
zoa	- The effective Z/A of the path segment
layer	- An index to identify the layer type (e.g. earth inner core)

Definition at line 347 of file PMNS_Base.cxx.

{
  SetPath(NuPath(length, density, zoa, layer));
}

References OscProb::PMNS_Base::SetPath().

◆ SetPath() [2/3]

void PMNS_Base::SetPath ( NuPath p )

virtualinherited

Set a single path.

This destroys the current path sequence and creates a new first path.

Parameters

p	- A neutrino path segment

Definition at line 330 of file PMNS_Base.cxx.

{
  ClearPath();
  AddPath(p);
}

References OscProb::PMNS_Base::AddPath(), and OscProb::PMNS_Base::ClearPath().

Referenced by OscProb::PMNS_Maltoni::AvgAlgo(), OscProb::PMNS_Maltoni::AvgAlgoCosT(), OscProb::PMNS_Maltoni::AvgProb(), OscProb::PMNS_Maltoni::ExtrapolationProbCosT(), OscProb::PMNS_Base::SetPath(), OscProb::PMNS_Base::SetStdPath(), and SetTestPath().

◆ SetPath() [3/3]

void PMNS_Base::SetPath ( std::vector< NuPath > paths )

virtualinherited

Set vector of neutrino paths.

Parameters

paths - A sequence of neutrino paths

Definition at line 294 of file PMNS_Base.cxx.

294{ fNuPaths = paths; }

OscProb::PMNS_Base::fUseCache

◆ SetPremModel()

void PMNS_Maltoni::SetPremModel ( OscProb::PremModel & prem )

virtualinherited

Set the earth model to be used.

This is done to get access to the PremLayer list to be used in the LnDerivative() function.

Parameters

prem	- The earth model used

Definition at line 84 of file PMNS_Maltoni.cxx.

84{ fPrem = prem; }

References OscProb::PMNS_Maltoni::fPrem.

◆ SetPureState()

void PMNS_Base::SetPureState ( vectorC nu_in )

protectedvirtualinherited

Set the initial state from a pure state

Parameters

nu_in - The neutrino initial state in flavour basis.

Reimplemented in OscProb::PMNS_DensityMatrix.

Definition at line 1070 of file PMNS_Base.cxx.

{
  assert(nu_in.size() == fNumNus);
 
  fNuState = nu_in;
}

References OscProb::PMNS_Base::fNumNus, and OscProb::PMNS_Base::fNuState.

Referenced by OscProb::PMNS_Base::Prob(), and OscProb::PMNS_Base::ProbVector().

◆ SetStdPars()

void PMNS_Base::SetStdPars ( )

virtualinherited

Set standard oscillation parameters from PDG 2015.

For two neutrinos, Dm is set to the muon disappearance effective mass-splitting and mixing angle.

Definition at line 177 of file PMNS_Base.cxx.

{
  if (fNumNus > 2) {
    // PDG values for 3 neutrinos
    // Also applicable for 3+N neutrinos
    SetAngle(1, 2, asin(sqrt(0.304)));
    SetAngle(1, 3, asin(sqrt(0.0219)));
    SetAngle(2, 3, asin(sqrt(0.514)));
    SetDm(2, 7.53e-5);
    SetDm(3, 2.52e-3);
  }
  else if (fNumNus == 2) {
    // Effective muon disappearance values
    // for two-flavour approximation
    SetAngle(1, 2, 0.788);
    SetDm(2, 2.47e-3);
  }
}

References OscProb::PMNS_Base::fNumNus, OscProb::PMNS_Base::SetAngle(), and OscProb::PMNS_Base::SetDm().

Referenced by OscProb::PMNS_Base::PMNS_Base().

◆ SetStdPath()

void PMNS_Base::SetStdPath ( )

virtualinherited

Set standard single path.

Length is 1000 km, so ~2 GeV peak energy.

Density is approximate from CRUST2.0 (~2.8 g/cm^3). Z/A is set to a round 0.5.

Definition at line 205 of file PMNS_Base.cxx.

{
  NuPath p;
 
  p.length  = 1000; // 1000 km default
  p.density = 2.8;  // Crust density
  p.zoa     = 0.5;  // Crust Z/A
  p.layer   = 0;    // Single layer
 
  SetPath(p);
}

References OscProb::NuPath::density, OscProb::NuPath::layer, OscProb::NuPath::length, OscProb::PMNS_Base::SetPath(), and OscProb::NuPath::zoa.

Referenced by OscProb::PMNS_Base::PMNS_Base(), PMNS_LIV(), OscProb::PMNS_NSI::PMNS_NSI(), OscProb::PMNS_NUNM::PMNS_NUNM(), and OscProb::PMNS_Base::SetAtt().

◆ SetUseCache()

void PMNS_Base::SetUseCache ( bool u = true )

virtualinherited

Turn on/off caching of eigensystems. This can save a lot of CPU time by avoiding recomputing eigensystems if we've already seen them recently. Especially useful when running over multiple earth layers and even more if multiple baselines will be computed, e.g. for atmospheric neutrinos.

Parameters

u	- flag to set caching on (default: true)

Definition at line 105 of file PMNS_Base.cxx.

105{ fUseCache = u; }

bool fUseCache

Flag for whether to use caching.

Definition: PMNS_Base.h:301

References OscProb::PMNS_Base::fUseCache.

Referenced by OscProb::PMNS_Base::PMNS_Base().

◆ SetVacuumEigensystem()

void PMNS_Fast::SetVacuumEigensystem ( )

protectedvirtualinherited

Set the eigensystem to the analytic solution in vacuum.

We know the vacuum eigensystem, so just write it explicitly

Definition at line 154 of file PMNS_Fast.cxx.

{
  double   s12, s23, s13, c12, c23, c13;
  complexD idelta(0.0, fDelta[0][2]);
  if (fIsNuBar) idelta = conj(idelta);
 
  s12 = sin(fTheta[0][1]);
  s23 = sin(fTheta[1][2]);
  s13 = sin(fTheta[0][2]);
  c12 = cos(fTheta[0][1]);
  c23 = cos(fTheta[1][2]);
  c13 = cos(fTheta[0][2]);
 
  fEvec[0][0] = c12 * c13;
  fEvec[0][1] = s12 * c13;
  fEvec[0][2] = s13 * exp(-idelta);
 
  fEvec[1][0] = -s12 * c23 - c12 * s23 * s13 * exp(idelta);
  fEvec[1][1] = c12 * c23 - s12 * s23 * s13 * exp(idelta);
  fEvec[1][2] = s23 * c13;
 
  fEvec[2][0] = s12 * s23 - c12 * c23 * s13 * exp(idelta);
  fEvec[2][1] = -c12 * s23 - s12 * c23 * s13 * exp(idelta);
  fEvec[2][2] = c23 * c13;
 
  fEval[0] = 0;
  fEval[1] = fDm[1] / (2 * kGeV2eV * fEnergy);
  fEval[2] = fDm[2] / (2 * kGeV2eV * fEnergy);
}

References OscProb::PMNS_Base::fDelta, OscProb::PMNS_Base::fDm, OscProb::PMNS_Base::fEnergy, OscProb::PMNS_Base::fEval, OscProb::PMNS_Base::fEvec, OscProb::PMNS_Base::fIsNuBar, OscProb::PMNS_Base::fTheta, and OscProb::PMNS_Base::kGeV2eV.

Referenced by OscProb::PMNS_OQS::BuildHms(), OscProb::PMNS_Fast::SolveHam(), and OscProb::PMNS_Iter::SolveHam().

◆ SetwidthBin()

void PMNS_Maltoni::SetwidthBin	(	double	dE,
		double	dcosT
	)

protectedvirtualinherited

Set bin widths.

Parameters

dE	- The width of the energy bin in GeV
dcosT	- The width of the cos(theta_z) bin

Definition at line 101 of file PMNS_Maltoni.cxx.

{
  fdInvE = dE;
  fdcosT = dcosT;
}

References OscProb::PMNS_Maltoni::fdcosT, and OscProb::PMNS_Maltoni::fdInvE.

Referenced by OscProb::PMNS_Maltoni::AvgAlgo(), OscProb::PMNS_Maltoni::AvgAlgoCosT(), OscProb::PMNS_Maltoni::AvgProb(), OscProb::PMNS_Maltoni::ExtrapolationProb(), OscProb::PMNS_Maltoni::ExtrapolationProbCosT(), OscProb::PMNS_Maltoni::ExtrapolationProbLoE(), and OscProb::PMNS_Maltoni::PMNS_Maltoni().

◆ SetZoA() [1/2]

void PMNS_Base::SetZoA ( double zoa )

virtualinherited

Set single path Z/A.

If the path sequence is not a single path, a new single path will be created and the previous sequence will be lost. Use with care.

Parameters

zoa	- The effective Z/A of the path segment

Definition at line 413 of file PMNS_Base.cxx.

413{ SetAtt(zoa, 2); }

◆ SetZoA() [2/2]

void PMNS_Base::SetZoA ( vectorD zoa )

virtualinherited

Set multiple path Z/A values.

If the path sequence is of a different size, a new path sequence will be created and the previous sequence will be lost. Use with care.

Parameters

zoa	- The effective Z/A of the path segments

Definition at line 508 of file PMNS_Base.cxx.

508{ SetAtt(zoa, 2); }