OscProb: OscProb::PMNS_Avg Class Reference

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

◆ AlgorithmDensityMatrix()

double PMNS_Avg::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 847 of file PMNS_Avg.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_Avg::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

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 813 of file PMNS_Avg.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_Avg::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 580 of file PMNS_Avg.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().

◆ AvgAlgoCosT()

double PMNS_Avg::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 658 of file PMNS_Avg.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);
 
  // return fct avr proba
  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().

Referenced by AvgProb().

◆ AvgFormula()

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

protectedvirtual

Formula for the average probability over a bin of width dbin

Formula for the average probability of flvi going to flvf over a bin of width dbin with a Taylor expansion.

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 442 of file PMNS_Avg.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[3];
 
  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(), and AvgAlgoCosT().

◆ AvgFormulaExtrapolation()

double PMNS_Avg::AvgFormulaExtrapolation	(	int	flvi,
		int	flvf,
		double	dbin,
		vectorD	lambda,
		matrixC	V
	)

protectedvirtual

Fomula for the propability for flvi going to flvf for an energy E+dE using a first order Taylor expansion 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 1068 of file PMNS_Avg.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[3];
 
  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]) * dbin;
      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/4]

double PMNS_Avg::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 with a Taylor expansion.

IMPORTANT: The PremModel object used must be copied 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 623 of file PMNS_Avg.cxx.

{
  if (cosT > 0) return 0;
 
  // if (fNuPaths.empty()) return 0; //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
 
  // Don't average zero width
  if (dcosT == 0) return Prob(flvi, flvf, E);
 
  vectorD samples = GetSamplePoints(E, cosT, dcosT);
 
  double avgprob = 0;
 
  // Loop over all sample points
  for (int j = 1; j < int(samples.size()); j++) {
    avgprob += AvgAlgoCosT(flvi, flvf, E, samples[j], samples[0]);
  }
 
  // Return average of probabilities
  return avgprob / (samples.size() - 1);
}

References AvgAlgoCosT(), GetSamplePoints(), and OscProb::PMNS_Base::Prob().

◆ AvgProb() [2/4]

double PMNS_Avg::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 with a Taylor expansion.

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 501 of file PMNS_Avg.cxx.

{
  if (E <= 0) return 0;
 
  if (fNuPaths.empty()) return 0;
 
  // Don't average zero width
  if (dE <= 0) return Prob(flvi, flvf, E);
 
  vectorD Ebin = ConvertEtoLoE(E, dE);
 
  // return fct avr proba
  return AvgProbLoE(flvi, flvf, Ebin[0], Ebin[1]);
}

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

Referenced by AvgProb(), and AvgProbLoE().

◆ AvgProb() [3/4]

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

virtual

Compute the average probability 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 with a Taylor expansion.

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

IMPORTANT: The function SetPremLayers must be used in the macro file to make this function work. The argument for SetPremLayers must be premModel.GetPremLayers().

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 711 of file PMNS_Avg.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);
 
  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/4]

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

virtualinherited

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

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

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

Flavours are:

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

Parameters

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

Returns: Average neutrino oscillation probability

Definition at line 1568 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]);
}

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

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

◆ AvgProbLoE() [1/3]

double PMNS_Avg::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 with a Taylor expansion.

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 539 of file PMNS_Avg.cxx.

{
  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 = GetSamplePoints(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++) {
    double w = 1. / pow(samples[j], 2);
 
    avgprob += w * AvgAlgo(flvi, flvf, samples[j], samples[0], L);
 
    sumw += w;
  }
 
  // Return average of probabilities
  return avgprob / sumw;
}

References AvgAlgo(), OscProb::PMNS_Base::fNuPaths, OscProb::PMNS_Base::fPath, GetSamplePoints(), OscProb::NuPath::length, and OscProb::PMNS_Base::Prob().

Referenced by AvgProb(), and AvgProbLoE().

◆ AvgProbLoE() [2/3]

double PMNS_Avg::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 with a Taylor expansion.

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 copied 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 758 of file PMNS_Avg.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 =
      GetSamplePoints(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++) {
      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]));
 
      sumw += w;
    }
  }
 
  // Return average of probabilities
  return avgprob / ((sumw));
}

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

◆ AvgProbLoE() [3/3]

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

virtualinherited

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

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

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

Flavours are:

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

Parameters

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

Returns: Average neutrino oscillation probability

Definition at line 1643 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;
}

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

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

◆ AvgProbMatrix()

matrixD PMNS_Base::AvgProbMatrix	(	int	nflvi,
		int	nflvf,
		double	E,
		double	dE = `0`
	)

virtualinherited

Compute the average probability matrix over a bin of energy

Compute the average probability matrix for nflvi and nflvf 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

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

Definition at line 1861 of file PMNS_Base.cxx.

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

◆ AvgProbMatrixLoE()

matrixD PMNS_Base::AvgProbMatrixLoE	(	int	nflvi,
		int	nflvf,
		double	LoE,
		double	dLoE = `0`
	)

virtualinherited

Compute the average probability matrix for nflvi and nflvf 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

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

Definition at line 1900 of file PMNS_Base.cxx.

{
  matrixD probs(nflvi, vectorD(nflvf, 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 ProbMatrix(nflvi, nflvf);
 
  // 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);
 
    matrixD sample_probs = ProbMatrix(nflvi, nflvf, length / samples[j]);
 
    for (int flvi = 0; flvi < nflvi; flvi++) {
      for (int flvf = 0; flvf < nflvf; flvf++) {
        // Add weighted probability
        probs[flvi][flvf] += w * sample_probs[flvi][flvf];
      }
    }
    // Increment sum of weights
    sumw += w;
  }
 
  for (int flvi = 0; flvi < nflvi; flvi++) {
    for (int flvf = 0; flvf < nflvf; flvf++) {
      // Divide by total sampling weight
      probs[flvi][flvf] /= sumw;
    }
  }
 
  // Return weighted average of probabilities
  return probs;
}

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

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

◆ AvgProbVector() [1/2]

vectorD PMNS_Base::AvgProbVector	(	int	flvi,
		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

flvi	- The neutrino starting 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 1729 of file PMNS_Base.cxx.

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

References OscProb::PMNS_Base::AvgProbVector(), OscProb::PMNS_Base::fNuState, and OscProb::PMNS_Base::ResetToFlavour().

◆ AvgProbVector() [2/2]

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

virtualinherited

Compute the average probability vector over a bin of energy

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

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

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

Parameters

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

Returns: Average neutrino oscillation probabilities

Definition at line 1753 of file PMNS_Base.cxx.

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

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

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

◆ AvgProbVectorLoE() [1/2]

vectorD PMNS_Base::AvgProbVectorLoE	(	int	flvi,
		double	LoE,
		double	dLoE = `0`
	)

virtualinherited

Compute the average probability of flvi 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

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 neutrino oscillation probabilities

Definition at line 1705 of file PMNS_Base.cxx.

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

References OscProb::PMNS_Base::AvgProbVectorLoE(), OscProb::PMNS_Base::fNuState, and OscProb::PMNS_Base::ResetToFlavour().

◆ 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(), 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_Avg::BuildKcosT ( double L )

protectedvirtual

Build K matrix for angle in flavor basis

The variable for which a Taylor expansion is done here is not directly the angle but the cosine of the angle

Parameters

L	- The length of the layer in km

Definition at line 180 of file PMNS_Avg.cxx.

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

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

Referenced by PropagatePathTaylor().

◆ BuildKE()

void PMNS_Avg::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 122 of file PMNS_Avg.cxx.

{
  double lenghtEV = L * kKm2eV;     // L in eV-1
  double bufK     = lenghtEV * 0.5; // L/2 in eV-1
 
  complexD buffer[3];
 
  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(), OscProb::PMNS_Base::AvgProbMatrix(), and OscProb::PMNS_Base::AvgProbVector().

◆ ExtrapolationProb()

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

virtual

Compute the probability of flvi going to flvf for an energy E+dE

Compute the propability for flvi going to flvf for an energy E+dE using a first order Taylor expansion 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 1121 of file PMNS_Avg.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_Avg::ExtrapolationProbCosT	(	int	flvi,
		int	flvf,
		double	cosT,
		double	dcosT
	)

virtual

Compute the probability of flvi going to flvf for an angle cosT+dcosT

Compute the propability for flvi going to flvf for an angle cosT+dcosT using a first order Taylor expansion from a reference angle cosT.

IMPORTANT: The PremModel object used must be copied 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 1200 of file PMNS_Avg.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_Avg::ExtrapolationProbLoE	(	int	flvi,
		int	flvf,
		double	LoE,
		double	dLoE
	)

virtual

Compute the probability of flvi going to flvf at LoE+dLoE

Compute the propability for flvi going to flvf for an energy LoE+dLoE using a first order Taylor expansion 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 1157 of file PMNS_Avg.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() [1/3]

vectorD PMNS_Avg::GetSamplePoints	(	double	E,
		double	cosT,
		double	dcosT
	)

protectedvirtual

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

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

This is used to increase the average probability over a bin of cosT, calculated with a Taylor expansion

Parameters

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

Definition at line 976 of file PMNS_Avg.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;
}

◆ GetSamplePoints() [2/3]

matrixC PMNS_Avg::GetSamplePoints	(	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 average probability over a bin of L/E and cosT, calculated with a Taylor expansion

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

Definition at line 1015 of file PMNS_Avg.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;
}

◆ GetSamplePoints() [3/3]

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

protectedvirtual

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

This is used to increase the average probability over a bin of L/E, calculated with a Taylor expansion

Parameters

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

Reimplemented from OscProb::PMNS_Base.

Definition at line 939 of file PMNS_Avg.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 AvgProb(), and AvgProbLoE().

◆ 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_Avg::HadamardProduct	(	vectorD	lambda,
		double	dbin
	)

protectedvirtual

Apply an Hadamard Product

Apply an Hadamard Product to the density matrix

Parameters

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

Definition at line 908 of file PMNS_Avg.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_Avg::InitializeTaylorsVectors ( )

protectedvirtual

Initialize all member vectors with zeros

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

Definition at line 48 of file PMNS_Avg.cxx.

{
  fdensityMatrix = matrixC(fNumNus, vectorC(fNumNus, 0));
 
  flambdaInvE = vectorD(fNumNus, 0);
  fVInvE      = matrixC(fNumNus, vectorC(fNumNus, 0));
 
  flambdaCosT = vectorD(fNumNus, 0);
  fVcosT      = matrixC(fNumNus, vectorC(fNumNus, 0));
 
  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;
 
    for (int j = 0; j < fNumNus; j++) {
      fKInvE[i][j] = 0;
      fKcosT[i][j] = 0;
    }
  }
 
  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(), ExtrapolationProb(), ExtrapolationProbCosT(), ExtrapolationProbLoE(), and PMNS_Avg().

◆ 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_Avg::LnDerivative ( )

protectedvirtual

Compute the derivation of one layer's length

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

Definition at line 199 of file PMNS_Avg.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_Avg::MultiplicationRuleK ( complexD K[3][3] )

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 K matrix corresponding to the propagation between the beginning of the path and the beginning of the current layer

Definition at line 316 of file PMNS_Avg.cxx.

{
  for (int i = 0; i < fNumNus; i++) {
    complexD buffer[3];
 
    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_Avg::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 285 of file PMNS_Avg.cxx.

{
  complexD save[3];
 
  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 OscProb::PMNS_Base::AvgProbMatrix(), OscProb::PMNS_Base::AvgProbMatrixLoE(), and OscProb::PMNS_Base::ProbMatrix().

◆ ProbMatrix() [2/3]

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

virtualinherited

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

Flavours are:

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

Parameters

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

Returns: Neutrino oscillation probabilities

Reimplemented in OscProb::PMNS_DensityMatrix.

Definition at line 1439 of file PMNS_Base.cxx.

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

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

◆ ProbMatrix() [3/3]

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

virtualinherited

Compute the probability matrix for energy E and distance L

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

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

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

Flavours are:

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

Parameters

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

Returns: Neutrino oscillation probabilities

Reimplemented in OscProb::PMNS_DensityMatrix.

Definition at line 1468 of file PMNS_Base.cxx.

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

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

◆ ProbVector() [1/6]

vectorD PMNS_Base::ProbVector ( int flvi )

virtualinherited

Compute the probabilities of flvi going to all flavours

Compute the probability of flvi going to all flavours.

Flavours are:

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

Parameters

flvi	- The neutrino starting flavour.

Returns: Neutrino oscillation probabilities

Definition at line 1272 of file PMNS_Base.cxx.

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

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

◆ ProbVector() [2/6]

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

virtualinherited

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

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

Flavours are:

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

Parameters

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

Returns: Neutrino oscillation probability

Definition at line 1313 of file PMNS_Base.cxx.

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

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

◆ ProbVector() [3/6]

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

virtualinherited

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

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

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

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

Flavours are:

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

Parameters

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

Returns: Neutrino oscillation probability

Definition at line 1365 of file PMNS_Base.cxx.

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

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

◆ ProbVector() [4/6]

vectorD PMNS_Base::ProbVector ( vectorC nu_in )

virtualinherited

Compute the probabilities of nu_in going to all flavours

Compute the probability of nu_in going to all flavours.

Parameters

nu_in - The neutrino initial state in flavour basis.

Returns: Neutrino oscillation probabilities

Definition at line 1250 of file PMNS_Base.cxx.

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

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

Referenced by OscProb::PMNS_Base::AvgProbVector(), 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_Avg::PropagatePathTaylor ( NuPath p )

protectedvirtual

Propagate the current neutrino state through a given path

Parameters

p	- A neutrino path segment

Definition at line 353 of file PMNS_Avg.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(p.length);
 
    // 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_Fast::SolveHam().

Referenced by PropagateTaylor().

◆ PropagateTaylor()

void PMNS_Avg::PropagateTaylor ( )

protectedvirtual

Propagate neutrino state through full path

Definition at line 341 of file PMNS_Avg.cxx.

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

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

Referenced by AvgAlgo(), AvgAlgoCosT(), 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_Avg::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 872 of file PMNS_Avg.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_Avg::rotateK ( )

protectedvirtual

Rotate the K matrix from mass to flavor basis

Definition at line 248 of file PMNS_Avg.cxx.

{
  complexD buffer[3];
 
  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_Avg::rotateS ( )

protectedvirtual

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

Definition at line 226 of file PMNS_Avg.cxx.

{
  complexD buffer[3];
 
  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 PMNS_Avg(), and OscProb::PMNS_Base::PMNS_Base().

◆ SetCosT()

void PMNS_Avg::SetCosT ( double cosT )

protectedvirtual

Set neutrino angle.

Parameters

cosT	- The cosine of the neutrino angle

Definition at line 97 of file PMNS_Avg.cxx.

97{ fcosT = cosT; }

References fcosT.

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

◆ SetDeltaMsqrs()

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

virtualinherited

Set both mass-splittings at once.

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

Parameters

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

Definition at line 55 of file PMNS_Fast.cxx.

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

References OscProb::PMNS_Base::SetDm().

◆ SetDensity() [1/2]

void PMNS_Base::SetDensity ( double rho )

virtualinherited

Set single path density.

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

Parameters

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

Definition at line 402 of file PMNS_Base.cxx.

402{ SetAtt(rho, 1); }

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

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

◆ SetMix()

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

virtualinherited

Set all mixing parameters at once.

Parameters

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

Definition at line 37 of file PMNS_Fast.cxx.

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

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

◆ SetPath() [1/3]

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

virtualinherited

Set a single path defining attributes directly.

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

Parameters

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

Definition at line 347 of file PMNS_Base.cxx.

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

References OscProb::PMNS_Base::SetPath().

◆ SetPath() [2/3]

void PMNS_Base::SetPath ( NuPath p )

virtualinherited

Set a single path.

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

Parameters

p	- A neutrino path segment

Definition at line 330 of file PMNS_Base.cxx.

{
  ClearPath();
  AddPath(p);
}

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

Referenced by AvgAlgo(), AvgAlgoCosT(), 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_Avg::SetPremModel ( OscProb::PremModel & prem )

virtual

Copy the earth model 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 89 of file PMNS_Avg.cxx.

89{ 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().

◆ SetVacuumEigensystem()

void PMNS_Fast::SetVacuumEigensystem ( )

protectedvirtualinherited

Set the eigensystem to the analytic solution in vacuum.

We know the vacuum eigensystem, so just write it explicitly

Definition at line 154 of file PMNS_Fast.cxx.

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

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

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

◆ SetwidthBin()

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

protectedvirtual

Set bin's widths for energy and angle

Set bin's widths.

Parameters

dE	- The width of the bin for energy in GeV
dcosT	- The width of the bin for angle

Definition at line 106 of file PMNS_Avg.cxx.

{
  fdInvE = dE;
  fdcosT = dcosT;
}

References fdcosT, and fdInvE.

Referenced by AvgAlgo(), AvgAlgoCosT(), ExtrapolationProb(), ExtrapolationProbCosT(), ExtrapolationProbLoE(), and PMNS_Avg().

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