OscProb: OscProb::PMNS_Maltoni Class Reference

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
	)

protectedvirtual

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]);
}

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

Referenced by AvgAlgo().

◆ AvgAlgo() [1/2]

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

protectedvirtual

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);
}

References AlgorithmDensityMatrix(), fDetRadius, OscProb::PremModel::FillPath(), fKcosT, fKInvE, flambdaCosT, flambdaInvE, fminRsq, fPrem, fVcosT, fVInvE, OscProb::EarthModelBase::GetNuPath(), InitializeTaylorsVectors(), PropagateTaylor(), SetCosT(), OscProb::PMNS_Base::SetEnergy(), OscProb::PMNS_Base::SetPath(), SetwidthBin(), and SolveK().

◆ AvgAlgo() [2/2]

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

protectedvirtual

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 AvgFormula(), fKInvE, flambdaInvE, fVInvE, InitializeTaylorsVectors(), OscProb::PMNS_Base::kGeV2eV, PropagateTaylor(), OscProb::PMNS_Base::SetEnergy(), SetwidthBin(), and SolveK().

Referenced by AvgProbLoE(), AvgProbMatrixLoE(), and AvgProbVectorLoE().

◆ AvgAlgoCosT()

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

protectedvirtual

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);
}

References AvgFormula(), fdcosT, fDetRadius, OscProb::PremModel::FillPath(), fKcosT, flambdaCosT, fminRsq, fPrem, fVcosT, OscProb::EarthModelBase::GetNuPath(), InitializeTaylorsVectors(), PropagateTaylor(), SetCosT(), OscProb::PMNS_Base::SetEnergy(), OscProb::PMNS_Base::SetPath(), SetwidthBin(), and SolveK().

◆ AvgFormula()

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

protectedvirtual

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 fevolutionMatrixS, OscProb::PMNS_Base::fNumNus, and OscProb::PMNS_Base::P().

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

◆ AvgFormulaExtrapolation()

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

protectedvirtual

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 fevolutionMatrixS, OscProb::PMNS_Base::fNumNus, and OscProb::PMNS_Base::P().

Referenced by ExtrapolationProb(), ExtrapolationProbCosT(), and ExtrapolationProbLoE().

◆ AvgProb() [1/5]

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

virtual

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);
}

References AvgFormula(), fdcosT, fDetRadius, OscProb::PremModel::FillPath(), fKcosT, flambdaCosT, fminRsq, fPrem, fVcosT, OscProb::EarthModelBase::GetNuPath(), InitializeTaylorsVectors(), PropagateTaylor(), SetCosT(), OscProb::PMNS_Base::SetEnergy(), OscProb::PMNS_Base::SetPath(), SetwidthBin(), and SolveK().

◆ AvgProb() [2/5]

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

virtual

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(), AvgProbLoE(), OscProb::PMNS_Base::ConvertEtoLoE(), fIsOscProbAvg, OscProb::PMNS_Base::fNuPaths, and OscProb::PMNS_Base::Prob().

Referenced by AvgProb(), and AvgProbLoE().

◆ AvgProb() [3/5]

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

virtual

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 AvgProb(), 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`
	)

virtual

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`
	)

virtual

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
	)

virtual

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 AvgAlgo(), OscProb::PMNS_Base::AvgProbLoE(), fIsOscProbAvg, OscProb::PMNS_Base::fNuPaths, OscProb::PMNS_Base::fPath, GetSamplePointsAvgClass(), OscProb::NuPath::length, and OscProb::PMNS_Base::Prob().

Referenced by AvgProb(), and AvgProbLoE().

◆ AvgProbLoE() [2/4]

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

virtual

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 AvgAlgo(), AvgProb(), AvgProbLoE(), OscProb::PMNS_Base::fPath, 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`
	)

virtual

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`
	)

virtual

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
	)

virtual

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(), AvgProbMatrixLoE(), OscProb::PMNS_Base::ConvertEtoLoE(), fIsOscProbAvg, OscProb::PMNS_Base::fNuPaths, and OscProb::PMNS_Base::ProbMatrix().

◆ AvgProbMatrixLoE()

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

virtual

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 AvgAlgo(), AvgFormula(), OscProb::PMNS_Base::AvgProbMatrixLoE(), fdInvE, fIsOscProbAvg, flambdaInvE, OscProb::PMNS_Base::fNuPaths, OscProb::PMNS_Base::fPath, fVInvE, GetSamplePointsAvgClass(), OscProb::PMNS_Base::kGeV2eV, OscProb::NuPath::length, and OscProb::PMNS_Base::ProbMatrix().

Referenced by AvgProbMatrix().

◆ AvgProbVector() [1/2]

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

virtual

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(), AvgProbVectorLoE(), OscProb::PMNS_Base::ConvertEtoLoE(), 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 AvgProbVector(), and OscProb::PMNS_Base::AvgProbVector().

◆ AvgProbVectorLoE() [1/2]

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

virtual

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 AvgAlgo(), AvgFormula(), OscProb::PMNS_Base::AvgProbVectorLoE(), fdInvE, fIsOscProbAvg, flambdaInvE, OscProb::PMNS_Base::fNumNus, OscProb::PMNS_Base::fNuPaths, OscProb::PMNS_Base::fPath, fVInvE, GetSamplePointsAvgClass(), OscProb::PMNS_Base::kGeV2eV, OscProb::NuPath::length, and OscProb::PMNS_Base::ProbVector().

Referenced by 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(), 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 ( )

protectedvirtual

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 fHam, fKflavor, OscProb::PMNS_Base::fNumNus, OscProb::PMNS_Base::kKm2eV, LnDerivative(), and UpdateHam().

Referenced by PropagatePathTaylor().

◆ BuildKE()

void PMNS_Maltoni::BuildKE ( double L )

protectedvirtual

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, fKmass, OscProb::PMNS_Base::fNumNus, and OscProb::PMNS_Base::kKm2eV.

Referenced by 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(), OscProb::PMNS_LIV::SetaT(), OscProb::PMNS_NSI::SetCoupByIndex(), OscProb::PMNS_LIV::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(); }

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 AvgProb(), OscProb::PMNS_Base::AvgProb(), AvgProbMatrix(), OscProb::PMNS_Base::AvgProbMatrix(), AvgProbVector(), and OscProb::PMNS_Base::AvgProbVector().

◆ ExtrapolationProb()

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

virtual

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);
}

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

◆ ExtrapolationProbCosT()

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

virtual

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);
}

References AvgFormulaExtrapolation(), fdcosT, fDetRadius, OscProb::PremModel::FillPath(), fKcosT, flambdaCosT, fminRsq, fPrem, fVcosT, OscProb::EarthModelBase::GetNuPath(), InitializeTaylorsVectors(), PropagateTaylor(), SetCosT(), OscProb::PMNS_Base::SetPath(), SetwidthBin(), and SolveK().

◆ ExtrapolationProbLoE()

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

virtual

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);
}

References AvgFormulaExtrapolation(), OscProb::AvgPath(), fKInvE, flambdaInvE, OscProb::PMNS_Base::fNuPaths, OscProb::PMNS_Base::fPath, fVInvE, InitializeTaylorsVectors(), OscProb::PMNS_Base::kGeV2eV, OscProb::NuPath::length, PropagateTaylor(), OscProb::PMNS_Base::SetCurPath(), OscProb::PMNS_Base::SetEnergy(), SetwidthBin(), and SolveK().

◆ FillCache()

void PMNS_Base::FillCache ( )

protectedvirtualinherited

If using caching, save the eigensystem in memory

Reimplemented in OscProb::PMNS_LIV, and OscProb::PMNS_SNSI.

Definition at line 157 of file PMNS_Base.cxx.

{
  if (fUseCache) {
    if (fMixCache.size() > fMaxCache) { fMixCache.erase(fMixCache.begin()); }
    fProbe.SetVars(fEnergy, fPath, fIsNuBar);
    for (int i = 0; i < fNumNus; i++) {
      fProbe.fEval[i] = fEval[i];
      for (int j = 0; j < fNumNus; j++) { fProbe.fEvec[i][j] = fEvec[i][j]; }
    }
    fMixCache.insert(fProbe);
  }
}

References OscProb::PMNS_Base::fEnergy, OscProb::EigenPoint::fEval, OscProb::PMNS_Base::fEval, OscProb::EigenPoint::fEvec, OscProb::PMNS_Base::fEvec, OscProb::PMNS_Base::fIsNuBar, OscProb::PMNS_Base::fMaxCache, OscProb::PMNS_Base::fMixCache, OscProb::PMNS_Base::fNumNus, OscProb::PMNS_Base::fPath, OscProb::PMNS_Base::fProbe, OscProb::PMNS_Base::fUseCache, and OscProb::EigenPoint::SetVars().

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

◆ 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.

◆ 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
	)

protectedvirtual

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
	)

protectedvirtual

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
	)

protectedvirtual

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 AvgProbLoE(), AvgProbMatrixLoE(), and 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
	)

protectedvirtual

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 fdensityMatrix, and OscProb::PMNS_Base::fNumNus.

Referenced by AlgorithmDensityMatrix().

◆ InitializeTaylorsVectors()

void PMNS_Maltoni::InitializeTaylorsVectors ( )

protectedvirtual

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();
}

References fdensityMatrix, fDetRadius, fdl, fevolutionMatrixS, fKcosT, fKflavor, fKInvE, fKmass, flambdaCosT, flambdaInvE, fLayer, OscProb::PMNS_Base::fNumNus, fPrem, fSflavor, fVcosT, fVInvE, OscProb::PremModel::GetDetRadius(), and OscProb::PremModel::GetPremLayers().

Referenced by AvgAlgo(), AvgAlgoCosT(), AvgProb(), ExtrapolationProb(), ExtrapolationProbCosT(), ExtrapolationProbLoE(), and 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 ( )

protectedvirtual

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 fcosT, fDetRadius, fdl, fLayer, fminRsq, fPrem, and OscProb::PremModel::GetPremLayers().

Referenced by BuildKcosT().

◆ MultiplicationRuleK()

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

protectedvirtual

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 fevolutionMatrixS, fKflavor, and OscProb::PMNS_Base::fNumNus.

Referenced by PropagatePathTaylor().

◆ MultiplicationRuleS()

void PMNS_Maltoni::MultiplicationRuleS ( )

protectedvirtual

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 fevolutionMatrixS, OscProb::PMNS_Base::fNumNus, and fSflavor.

Referenced by 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 AvgFormula(), 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 AvgProb(), OscProb::PMNS_Base::AvgProb(), 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 AvgProbMatrix(), OscProb::PMNS_Base::AvgProbMatrix(), 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 AvgProbVector(), OscProb::PMNS_Base::AvgProbVector(), 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 )

protectedvirtual

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();
}

References BuildKcosT(), BuildKE(), fdcosT, fdInvE, OscProb::PMNS_Base::fEval, fKcosT, fKInvE, OscProb::PMNS_Base::fNumNus, OscProb::PMNS_Base::fPhases, OscProb::PMNS_Base::kKm2eV, OscProb::NuPath::length, MultiplicationRuleK(), MultiplicationRuleS(), rotateK(), rotateS(), OscProb::PMNS_Base::SetCurPath(), and OscProb::PMNS_Base::SolveHam().

Referenced by PropagateTaylor().

◆ PropagateTaylor()

void PMNS_Maltoni::PropagateTaylor ( )

protectedvirtual

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 PropagatePathTaylor().

Referenced by AvgAlgo(), AvgAlgoCosT(), AvgProb(), ExtrapolationProb(), ExtrapolationProbCosT(), and 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
	)

protectedvirtual

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 fdensityMatrix, and OscProb::PMNS_Base::fNumNus.

Referenced by 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 ( )

protectedvirtual

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, fKflavor, fKmass, and OscProb::PMNS_Base::fNumNus.

Referenced by PropagatePathTaylor().

◆ rotateS()

void PMNS_Maltoni::rotateS ( )

protectedvirtual

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 fSflavor.

Referenced by 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().

◆ 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;
}

OscProb::PMNS_Base::SetAtt

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

◆ SetCosT()

void PMNS_Maltoni::SetCosT ( double cosT )

protectedvirtual

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 fcosT.

Referenced by AvgAlgo(), AvgAlgoCosT(), AvgProb(), and ExtrapolationProbCosT().

◆ 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.

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

◆ 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().

◆ 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); }

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); }

◆ 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.

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

◆ 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()

void PMNS_Maltoni::SetIsOscProbAvg ( bool isOscProbAvg )

virtual

Set method used for averaging.

Parameters

isOscProbAvg - OscProb (true) or Maltoni (false)

Reimplemented in OscProb::PMNS_DensityMatrix, OscProb::PMNS_LIV, OscProb::PMNS_NUNM, and OscProb::PMNS_SNSI.

Definition at line 70 of file PMNS_Maltoni.cxx.

{
  fIsOscProbAvg = isOscProbAvg;
}

References fIsOscProbAvg.

Referenced by PMNS_Maltoni().

◆ 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); }

◆ 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; }

References OscProb::PMNS_Base::fMaxCache.

◆ 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 AvgAlgo(), AvgAlgoCosT(), AvgProb(), 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; }

◆ SetPremModel()

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

virtual

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 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(), OscProb::PMNS_LIV::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; }

References OscProb::PMNS_Base::fUseCache.

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

◆ SetwidthBin()

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

protectedvirtual

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 fdcosT, and fdInvE.

Referenced by AvgAlgo(), AvgAlgoCosT(), AvgProb(), ExtrapolationProb(), ExtrapolationProbCosT(), ExtrapolationProbLoE(), and 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); }