This class extends MCMC and allow specialised for Oscillation parameters analysis which require specialised hardcoding. More...

#include <Fitters/OscProcessor.h>

Inheritance diagram for OscProcessor:

[legend]

Collaboration diagram for OscProcessor:

[legend]

Public Member Functions
	OscProcessor (const std::string &InputFile)
	Constructs an OscProcessor object with the specified input file and options.

virtual	~OscProcessor ()
	Destroys the OscProcessor object.

void	PerformJarlskogAnalysis ()
	Perform Several Jarlskog Plotting.

Public Member Functions inherited from MCMCProcessor
	MCMCProcessor (const std::string &InputFile)
	Constructs an MCMCProcessor object with the specified input file and options.

virtual	~MCMCProcessor ()
	Destroys the MCMCProcessor object.

void	Initialise ()
	Scan chain, what parameters we have and load information from covariance matrices.

void	MakePostfit ()
	Make 1D projection for each parameter and prepare structure.

void	MakeCovariance ()
	Calculate covariance by making 2D projection of each combination of parameters.

void	CacheSteps ()
	KS:By caching each step we use multithreading.

void	MakeCovariance_MP (const bool Mute=false)
	Calculate covariance by making 2D projection of each combination of parameters using multithreading.

void	MakeSubOptimality (const int NIntervals=10)
	Make and Draw SubOptimality [24].

void	ResetHistograms ()
	Reset 2D posteriors, in case we would like to calculate in again with different BurnInCut.

void	DrawPostfit ()
	Draw the post-fit comparisons.

void	MakeViolin ()
	Make and Draw Violin.

void	MakeCredibleIntervals (const std::vector< double > &CredibleIntervals={0.99, 0.90, 0.68 }, const std::vector< Color_t > &CredibleIntervalsColours={kCyan+4, kCyan-2, kCyan-10}, const bool CredibleInSigmas=false)
	Make and Draw Credible intervals.

void	DrawCovariance ()
	Draw the post-fit covariances.

void	MakeCredibleRegions (const std::vector< double > &CredibleRegions={0.99, 0.90, 0.68}, const std::vector< Style_t > &CredibleRegionStyle={kDashed, kSolid, kDotted}, const std::vector< Color_t > &CredibleRegionColor={kGreen-3, kGreen-10, kGreen}, const bool CredibleInSigmas=false, const bool Draw2DPosterior=true, const bool DrawBestFit=true)
	Make and Draw Credible Regions.

void	MakeTrianglePlot (const std::vector< std::string > &ParNames, const std::vector< double > &CredibleIntervals={0.99, 0.90, 0.68 }, const std::vector< Color_t > &CredibleIntervalsColours={kCyan+4, kCyan-2, kCyan-10}, const std::vector< double > &CredibleRegions={0.99, 0.90, 0.68}, const std::vector< Style_t > &CredibleRegionStyle={kDashed, kSolid, kDotted}, const std::vector< Color_t > &CredibleRegionColor={kGreen-3, kGreen-10, kGreen}, const bool CredibleInSigmas=false)
	Make fancy triangle plot for selected parameters.

void	CheckCredibleIntervalsOrder (const std::vector< double > &CredibleIntervals, const std::vector< Color_t > &CredibleIntervalsColours)
	Checks the order and size consistency of the `CredibleIntervals` and `CredibleIntervalsColours` vectors.

void	CheckCredibleRegionsOrder (const std::vector< double > &CredibleRegions, const std::vector< Style_t > &CredibleRegionStyle, const std::vector< Color_t > &CredibleRegionColor)
	Checks the order and size consistency of the `CredibleRegions`, `CredibleRegionStyle`, and `CredibleRegionColor` vectors.

void	GetPolarPlot (const std::vector< std::string > &ParNames)
	Make funny polar plot.

void	GetBayesFactor (const std::vector< std::string > &ParName, const std::vector< std::vector< double > > &Model1Bounds, const std::vector< std::vector< double > > &Model2Bounds, const std::vector< std::vector< std::string > > &ModelNames)
	Calculate Bayes factor for vector of params, and model boundaries.

void	GetSavageDickey (const std::vector< std::string > &ParName, const std::vector< double > &EvaluationPoint, const std::vector< std::vector< double > > &Bounds)
	Calculate Bayes factor for point like hypothesis using SavageDickey.

void	ReweightPrior (const std::vector< std::string > &Names, const std::vector< double > &NewCentral, const std::vector< double > &NewError)
	Reweight Prior by giving new central value and new error.

void	ParameterEvolution (const std::vector< std::string > &Names, const std::vector< int > &NIntervals)
	Make .gif of parameter evolution.

void	ThinMCMC (const int ThinningCut)
	Thin MCMC Chain, to save space and maintain low autocorrelations.

void	DiagMCMC ()
	KS: Perform MCMC diagnostic including Autocorrelation, Trace etc.

int	GetNParams ()
	Get total number of used parameters.

int	GetNXSec ()

int	GetNND ()

int	GetNFD ()

int	GetGroup (const std::string &name) const
	Number of params from a given group, for example flux.

TH1D *	GetHpost (const int i)
	Get 1D posterior for a given parameter.

TH2D *	GetHpost2D (const int i, const int j)
	Get 2D posterior for a given parameter combination.

TH2D *	GetViolin ()
	Get Violin plot for all parameters with posterior values.

TH2D *	GetViolinPrior ()
	Get Violin plot for all parameters with prior values.

std::vector< std::string >	GetXSecCov () const

std::string	GetNDCov () const

std::string	GetFDCov () const

void	GetPostfit (TVectorD &Central, TVectorD &Errors, TVectorD &Central_Gauss, TVectorD &Errors_Gauss, TVectorD *&Peaks)
	Get the post-fit results (arithmetic and Gaussian)

void	GetCovariance (TMatrixDSym &Cov, TMatrixDSym &Corr)
	Get the post-fit covariances and correlations.

void	GetPostfit_Ind (TVectorD &Central, TVectorD &Errors, TVectorD *&Peaks, ParameterEnum kParam)
	Or the individual post-fits.

const std::vector< TString > &	GetBranchNames () const
	Get the vector of branch names from root file.

void	GetNthParameter (const int param, double &Prior, double &PriorError, TString &Title) const
	Get properties of parameter by passing it number.

int	GetParamIndexFromName (const std::string &Name)
	Get parameter number based on name.

Long64_t	GetnEntries ()
	Get Number of entries that Chain has, for merged chains will not be the same Nsteps.

Long64_t	GetnSteps ()
	Get Number of Steps that Chain has, for merged chains will not be the same nEntries.

void	SetStepCut (const std::string &Cuts)
	Set the step cutting by string.

void	SetStepCut (const int Cuts)
	Set the step cutting by int.

void	SetPlotRelativeToPrior (const bool PlotOrNot)
	You can set relative to prior or relative to generated. It is advised to use relate to prior.

void	SetPrintToPDF (const bool PlotOrNot)

void	SetPlotErrorForFlatPrior (const bool PlotOrNot)
	Set whether you want to plot error for parameters which have flat prior.

void	SetPlotBinValue (const bool PlotOrNot)

void	SetFancyNames (const bool PlotOrNot)

void	SetSmoothing (const bool PlotOrNot)
	Set whether want to use smoothing for histograms using ROOT algorithm.

void	SetPost2DPlotThreshold (const double Threshold)
	Code will only plot 2D posteriors if Correlation are larger than defined threshold.

void	SetUseFFTAutoCorrelation (const bool useFFT)
	Toggle using the FFT-based autocorrelation calculator.

void	SetExcludedTypes (std::vector< std::string > Name)
	Setter related what parameters we want to exclude from analysis, for example if cross-section parameters look like xsec_, then passing "xsec_" will.

void	SetExcludedNames (std::vector< std::string > Name)

void	SetnBatches (const int Batches)
	Set value of Nbatches used for batched mean, this need to be done earlier as batches are made when reading tree.

void	SetnLags (const int nLags)

void	SetOutputSuffix (const std::string Suffix)
	Sett output suffix, this way jobs using the same file will have different names.

void	SetPosterior1DCut (const std::string Cut)
	Allow to set addtional cuts based on ROOT TBrowser cut, for to only affect one mass ordering.

Protected Member Functions
void	LoadAdditionalInfo () override
	Read the Osc cov file and get the input central values and errors Here we allow Jarlskog Shenanigans.

void	MakeJarlskogPlot (const std::unique_ptr< TH1D > &jarl, const std::unique_ptr< TH1D > &jarl_flatsindcp, const std::unique_ptr< TH1D > &jarl_NH, const std::unique_ptr< TH1D > &jarl_NH_flatsindcp, const std::unique_ptr< TH1D > &jarl_IH, const std::unique_ptr< TH1D > &jarl_IH_flatsindcp)
	Perform Jarlskog Plotting.

double	CalcJarlskog (const double s2th13, const double s2th23, const double s2th12, const double dcp) const
	Calculate Jarlskog Invariant using oscillation parameters.

double	SamplePriorForParam (const int paramIndex, const std::unique_ptr< TRandom3 > &randGen, const std::vector< double > &FlatBounds) const
	Draw Prior value.

Protected Member Functions inherited from MCMCProcessor
std::unique_ptr< TH1D >	MakePrefit ()
	Prepare prefit histogram for parameter overlay plot.

void	MakeOutputFile ()
	prepare output root file and canvas to which we will save EVERYTHING

void	DrawCorrelations1D ()
	Draw 1D correlations which might be more helpful than looking at huge 2D Corr matrix.

void	ReadInputCov ()
	CW: Read the input Covariance matrix entries. Get stuff like parameter input errors, names, and so on.

void	ReadInputCovLegacy ()

void	FindInputFiles ()
	Read the output MCMC file and find what inputs were used.

void	FindInputFilesLegacy ()

void	ReadModelFile ()
	Read the xsec file and get the input central values and errors.

virtual void	LoadAdditionalInfo ()
	allow loading additional info for example used for oscillation parameters

void	ReadNDFile ()
	Read the ND cov file and get the input central values and errors.

void	ReadFDFile ()
	Read the FD cov file and get the input central values and errors.

void	PrintInfo () const
	Print info like how many params have been loaded etc.

void	ScanInput ()
	Scan Input etc.

void	ScanParameterOrder ()
	Scan order of params from a different groups.

void	SetupOutput ()
	Prepare all objects used for output.

void	PrepareDiagMCMC ()
	CW: Prepare branches etc. for DiagMCMC.

void	ParamTraces ()
	CW: Draw trace plots of the parameters i.e. parameter vs step.

void	AutoCorrelation ()
	KS: Calculate autocorrelations supports both OpenMP and CUDA :)

void	AutoCorrelation_FFT ()
	MJR: Autocorrelation function using FFT algorithm for extra speed.

void	CalculateESS (const int nLags, const std::vector< std::vector< double > > &LagL)
	KS: calc Effective Sample Size.

void	BatchedAnalysis ()
	Get the batched means variance estimation and variable indicating if number of batches is sensible [4] [25].

void	BatchedMeans ()
	CW: Batched means, literally read from an array and chuck into TH1D.

void	GewekeDiagnostic ()
	Geweke Diagnostic based on the methods described by Fang (2014) and Karlsbakk (2011). [8] [18].

void	AcceptanceProbabilities ()
	Acceptance Probability.

void	PowerSpectrumAnalysis ()
	RC: Perform spectral analysis of MCMC [7].

std::vector< double >	GetMargins (const std::unique_ptr< TCanvas > &Canv) const
	Get TCanvas margins, to be able to reset them if particular function need different margins.

void	SetMargins (std::unique_ptr< TCanvas > &Canv, const std::vector< double > &margins)
	Set TCanvas margins to specified values.

void	SetTLineStyle (TLine *Line, const Color_t Colour, const Width_t Width, const ELineStyle Style) const
	Configures a TLine object with the specified style parameters.

void	SetLegendStyle (TLegend *Legend, const double size) const
	Configures the style of a TLegend object.

Protected Attributes
bool	PlotJarlskog
	Will plot Jarlskog Invariant using information in the chain.

bool	OscEnabled
	Will plot Jarlskog Invariant using information in the chain.

std::string	Sin2Theta13Name
	Name of the parameter representing \(\sin^2\theta_{13}\).

std::string	Sin2Theta12Name
	Name of the parameter representing \(\sin^2\theta_{12}\).

std::string	Sin2Theta23Name
	Name of the parameter representing \(\sin^2\theta_{23}\).

std::string	DeltaCPName
	Name of the parameter representing \(\delta_{\mathrm{CP}}\) (the CP-violating phase).

std::string	DeltaM2_23Name
	Name of the parameter representing \(\Delta m^2_{32}\) (mass-squared difference).

int	Sin2Theta13Index
	Index of \(\sin^2\theta_{13}\) in the parameter list.

int	Sin2Theta12Index
	Index of \(\sin^2\theta_{12}\) in the parameter list.

int	Sin2Theta23Index
	Index of \(\sin^2\theta_{23}\) in the parameter list.

int	DeltaCPIndex
	Index of \(\delta_{\mathrm{CP}}\) in the parameter list.

int	DeltaM2_23Index
	Index of \(\Delta m^2_{32}\) in the parameter list.

Protected Attributes inherited from MCMCProcessor
std::string	MCMCFile
	Name of MCMC file.

std::string	OutputSuffix
	Output file suffix useful when running over same file with different settings.

std::vector< std::vector< std::string > >	CovPos
	Covariance matrix name position.

std::vector< YAML::Node >	CovConfig
	Covariance matrix config.

TChain *	Chain
	Main chain storing all steps etc.

std::string	StepCut
	BurnIn Cuts.

std::string	Posterior1DCut
	Cut used when making 1D Posterior distribution.

int	UpperCut
	KS: Used only for SubOptimality.

int	BurnInCut
	Value of burn in cut.

int	nBranches
	Number of branches in a TTree.

int	nEntries
	KS: For merged chains number of entries will be different from nSteps.

int	nSteps
	KS: For merged chains number of entries will be different from nSteps.

int	nSamples
	Number of sample PDF objects.

int	nSysts
	Number of covariance objects.

int	nDraw
	Number of all parameters used in the analysis.

std::vector< TString >	BranchNames

std::vector< std::string >	ExcludedTypes

std::vector< std::string >	ExcludedNames

std::vector< bool >	IamVaried
	Is the ith parameter varied.

std::vector< std::vector< TString > >	ParamNames
	Name of parameters which we are going to analyse.

std::vector< std::vector< double > >	ParamCentral
	Parameters central values which we are going to analyse.

std::vector< std::vector< double > >	ParamNom

std::vector< std::vector< double > >	ParamErrors
	Uncertainty on a single parameter.

std::vector< std::vector< bool > >	ParamFlat
	Whether Param has flat prior or not.

std::vector< int >	nParam
	Number of parameters per type.

std::vector< ParameterEnum >	ParamType
	Make an enum for which class this parameter belongs to so we don't have to keep string comparing.

std::vector< int >	ParamTypeStartPos

std::vector< std::string >	ParameterGroup

std::vector< TString >	SampleName_v
	Vector of each systematic.

std::vector< TString >	SystName_v
	Vector of each sample PDF object.

std::string	OutputName
	Name of output files.

TString	CanvasName
	Name of canvas which help to save to the sample pdf.

bool	PlotFlatPrior
	Whether we plot flat prior or not, we usually provide error even for flat prior params.

bool	plotRelativeToPrior
	Whether we plot relative to prior or nominal, in most cases is prior.

bool	MadePostfit
	Sanity check if Postfit is already done to not make several times.

bool	printToPDF
	Will plot all plot to PDF not only to root file.

bool	FancyPlotNames
	Whether we want fancy plot names or not.

bool	plotBinValue
	If true it will print value on each bin of covariance matrix.

bool	ApplySmoothing
	Apply smoothing for 2D histos using root algorithm.

double	Post2DPlotThreshold
	KS: Set Threshold when to plot 2D posterior as by default we get a LOT of plots.

bool	useFFTAutoCorrelation
	MJR: Use FFT-based autocorrelation algorithm (save time & resources)?

std::vector< int >	NDSamplesBins

std::vector< std::string >	NDSamplesNames

std::unique_ptr< TF1 >	Gauss
	Gaussian fitter.

TFile *	OutputFile
	The output file.

std::unique_ptr< TCanvas >	Posterior
	Fancy canvas used for our beautiful plots.

TVectorD *	Central_Value
	Vector with central value for each parameter.

TVectorD *	Means
	Vector with mean values using Arithmetic Mean.

TVectorD *	Errors
	Vector with errors values using RMS.

TVectorD *	Means_Gauss
	Vector with mean values using Gaussian fit.

TVectorD *	Errors_Gauss
	Vector with error values using Gaussian fit.

TVectorD *	Means_HPD
	Vector with mean values using Highest Posterior Density.

TVectorD *	Errors_HPD
	Vector with error values using Highest Posterior Density.

TVectorD *	Errors_HPD_Positive
	Vector with positive error (right hand side) values using Highest Posterior Density.

TVectorD *	Errors_HPD_Negative
	Vector with negative error (left hand side) values using Highest Posterior Density.

TMatrixDSym *	Covariance
	Posterior Covariance Matrix.

TMatrixDSym *	Correlation
	Posterior Correlation Matrix.

std::vector< TH1D * >	hpost
	Holds 1D Posterior Distributions.

std::vector< std::vector< TH2D * > >	hpost2D
	Holds 2D Posterior Distributions.

std::unique_ptr< TH2D >	hviolin
	Holds violin plot for all dials.

std::unique_ptr< TH2D >	hviolin_prior
	Holds prior violin plot for all dials,.

double **	ParStep
	Array holding values for all parameters.

int *	StepNumber
	Step number for step, important if chains were merged.

int	nBins
	Number of bins.

double	DrawRange
	Drawrange for SetMaximum.

bool	CacheMCMC
	MCMC Chain has been cached.

bool	doDiagMCMC
	Doing MCMC Diagnostic.

int	nBatches
	Number of batches for Batched Mean.

int	AutoCorrLag
	LagL used in AutoCorrelation.

double *	ParamSums
	Total parameter sum for each param.

double **	BatchedAverages
	Values of batched average for every param and batch.

double **	SampleValues
	Holds the sample values.

double **	SystValues
	Holds the systs values.

double *	AccProbValues
	Holds all accProb.

double *	AccProbBatchedAverages
	Holds all accProb in batches.

Detailed Description

This class extends MCMC and allow specialised for Oscillation parameters analysis which require specialised hardcoding.

Author: Clarence Wret; Kamil Skwarczynski

Definition at line 10 of file OscProcessor.h.

Constructor & Destructor Documentation

◆ OscProcessor()

_MaCh3_Safe_Include_Start_ _MaCh3_Safe_Include_End_ OscProcessor::OscProcessor ( const std::string & InputFile )

Constructs an OscProcessor object with the specified input file and options.

Parameters

InputFile The path to the input file containing MCMC data.

Todo:: Here where we should add all unitarity triangles, fancy Jarlskog studies and other hacky things that only make sense for oscitations

Definition at line 11 of file OscProcessor.cpp.

                                                     : MCMCProcessor(InputFile) {
// ****************************
  //KS: WARNING this only work when you project from Chain, will nor work when you try SetBranchAddress etc. Turn it on only if you know how to use it
  PlotJarlskog = false;
 
  Sin2Theta13Index = M3::_BAD_INT_;
  Sin2Theta12Index = M3::_BAD_INT_;
  Sin2Theta23Index = M3::_BAD_INT_;
  DeltaCPIndex = M3::_BAD_INT_;
  DeltaM2_23Index = M3::_BAD_INT_;
}

◆ ~OscProcessor()

OscProcessor::~OscProcessor ( )

virtual

Destroys the OscProcessor object.

Definition at line 26 of file OscProcessor.cpp.

                            {
// ****************************
 
}

Member Function Documentation

◆ CalcJarlskog()

double OscProcessor::CalcJarlskog	(	const double	s2th13,
		const double	s2th23,
		const double	s2th12,
		const double	dcp
	)		const

protected

Calculate Jarlskog Invariant using oscillation parameters.

Parameters

s2th13	Value of \( \sin^2\theta_{13} \)
s2th23	Value of \( \sin^2\theta_{23} \)
s2th12	Value of \( \sin^2\theta_{12} \)
dcp	CP-violating phase \( \delta_{\text{CP}} \) (in radians)

Returns: The value of the Jarlskog invariant \( J_{\text{CP}} \) [16]

Definition at line 97 of file OscProcessor.cpp.

                                                                                                                       {
// ***************
  const double s13  = std::sqrt(s2th13);
  const double s23  = std::sqrt(s2th23);
  const double s12  = std::sqrt(s2th12);
  const double sdcp = std::sin(dcp);
  const double c13  = std::sqrt(1.-s2th13);
  const double c12  = std::sqrt(1.-s2th12);
  const double c23  = std::sqrt(1.-s2th23);
 
  const double j = s13*c13*c13*s12*c12*s23*c23*sdcp;
 
  return j;
}

◆ LoadAdditionalInfo()

void OscProcessor::LoadAdditionalInfo ( )

overrideprotectedvirtual

Read the Osc cov file and get the input central values and errors Here we allow Jarlskog Shenanigans.

Todo:: remove this hardcoding (e.g., use a map or enum-to-name function)

Todo:: we should actually calculate central value and prior error but leave it for now...

Reimplemented from MCMCProcessor.

Definition at line 33 of file OscProcessor.cpp.

                                      {
// ***************
  // KS: Check if OscParams were enabled, in future we will also get
  for(size_t i = 0; i < ParameterGroup.size(); i++) {
    if(ParameterGroup[i] == "Osc"){
      OscEnabled = true;
      break;
    }
  }
 
  if(OscEnabled)
  {
    for (int i = 0; i < nDraw; ++i)
    {
      //Those keep which parameter type we run currently and relative number
      const int ParamEnum = ParamType[i];
      const int ParamNo = i - ParamTypeStartPos[ParameterEnum(ParamEnum)];
      const std::string CurrentName = ParamNames[ParamEnum][ParamNo].Data();
 
      if (CurrentName == "sin2th_13") {
        Sin2Theta13Index = i;
        Sin2Theta13Name  = CurrentName;
      } else if (CurrentName == "sin2th_12") {
        Sin2Theta12Index = i;
        Sin2Theta12Name  = CurrentName;
      } else if (CurrentName == "sin2th_23") {
        Sin2Theta23Index = i;
        Sin2Theta23Name  = CurrentName;
      } else if (CurrentName == "delta_cp") {
        DeltaCPIndex     = i;
        DeltaCPName      = CurrentName;
      } else if (CurrentName == "delm2_23") {
        DeltaM2_23Index  = i;
        DeltaM2_23Name   = CurrentName;
      }
    }
  } else{
    MACH3LOG_WARN("Didn't find oscillation parameters");
  }
 
  if(PlotJarlskog && OscEnabled)
  {
    Chain->SetAlias("J_cp", "TMath::Sqrt(sin2th_13)*TMath::Sqrt(1.-sin2th_13)*TMath::Sqrt(1.-sin2th_13)*TMath::Sqrt(sin2th_12)*TMath::Sqrt(1.-sin2th_12)*TMath::Sqrt(sin2th_23)*TMath::Sqrt(1.-sin2th_23)*TMath::Sin(delta_cp)");
    BranchNames.push_back("J_cp");
    ParamType.push_back(kXSecPar);
    nParam[kXSecPar]++;
    nDraw++;
 
    ParamNom[kXSecPar].push_back( 0. );
    ParamCentral[kXSecPar].push_back( 0. );
    ParamErrors[kXSecPar].push_back( 1. );
    // Push back the name
    ParamNames[kXSecPar].push_back("J_cp");
    ParamFlat[kXSecPar].push_back( false );
  } else if(PlotJarlskog && !OscEnabled) {
    MACH3LOG_ERROR("Trying to enable Jarlskog without oscillations");
    throw MaCh3Exception(__FILE__,__LINE__);
  }
}

◆ MakeJarlskogPlot()

void OscProcessor::MakeJarlskogPlot	(	const std::unique_ptr< TH1D > &	jarl,
		const std::unique_ptr< TH1D > &	jarl_flatsindcp,
		const std::unique_ptr< TH1D > &	jarl_NH,
		const std::unique_ptr< TH1D > &	jarl_NH_flatsindcp,
		const std::unique_ptr< TH1D > &	jarl_IH,
		const std::unique_ptr< TH1D > &	jarl_IH_flatsindcp
	)

protected

Perform Jarlskog Plotting.

Author: Kevin Wood

Note: based on drawJarl_dcpPriorComparison.C

Definition at line 345 of file OscProcessor.cpp.

                                                                                   {
// ***************
  MACH3LOG_INFO("Starting {}", __func__);
  int originalErrorLevel = gErrorIgnoreLevel;
  gErrorIgnoreLevel = kFatal;
 
  // 1-->NH, 0-->both, -1-->IH
  for(int hierarchy = -1; hierarchy <= 1; hierarchy++)
  {
    std::unique_ptr<TH1D> j_hist;
    std::unique_ptr<TH1D> j_hist_sdcp;
    if(hierarchy == 1) {
      j_hist = M3::Clone(jarl_NH.get(), "");
      j_hist_sdcp = M3::Clone(jarl_NH_flatsindcp.get(), "");
      j_hist->SetTitle(";J_{CP} #equiv s_{13}c^{2}_{13}s_{12}c_{12}s_{23}c_{23}sin#delta_{CP};Posterior probability");
    } else if(hierarchy == 0) {
      j_hist = M3::Clone(jarl.get(), "");
      j_hist_sdcp = M3::Clone(jarl_flatsindcp.get(), "");
      j_hist->SetTitle(";J_{CP} #equiv s_{13}c^{2}_{13}s_{12}c_{12}s_{23}c_{23}sin#delta_{CP};Posterior probability");
    } else if(hierarchy == -1) {
      j_hist = M3::Clone(jarl_IH.get(), "");
      j_hist_sdcp = M3::Clone(jarl_IH_flatsindcp.get(), "");
      j_hist->SetTitle(";J_{CP} #equiv s_{13}c^{2}_{13}s_{12}c_{12}s_{23}c_{23}sin#delta_{CP};Posterior probability");
    } else {
      MACH3LOG_ERROR("Invalid hierarchy option. 1 for NH, 0 for both, -1 for IH");
      throw MaCh3Exception(__FILE__ , __LINE__ );
    }
 
    j_hist->Rebin(7);
    j_hist_sdcp->Rebin(7);
 
    j_hist->SetLineColor(kAzure-2);
    j_hist_sdcp->SetLineColor(kOrange+1);
    j_hist->SetLineWidth(2);
    j_hist_sdcp->SetLineWidth(2);
 
    auto StyleAxis = [](TH1* h) {
      auto xAxis = h->GetXaxis();
      auto yAxis = h->GetYaxis();
 
      xAxis->SetLabelSize(0.04);
      xAxis->SetLabelFont(132);
      xAxis->SetTitleSize(0.04);
      xAxis->SetTitleOffset(0.80);
      xAxis->SetTitleFont(132);
      xAxis->SetNdivisions(505);
      xAxis->SetTickSize(0.04);
 
      yAxis->SetLabelSize(0.04);
      yAxis->SetLabelFont(132);
      yAxis->SetTitleSize(0.04);
      yAxis->SetTitleOffset(1.2);
      yAxis->SetTitleFont(132);
      yAxis->SetNdivisions(505);
      yAxis->SetTickSize(0.04);
    };
 
    StyleAxis(j_hist.get());
 
    j_hist->GetXaxis()->SetRangeUser(-0.04,0.04);
    j_hist->Scale(1./j_hist->Integral());
    j_hist_sdcp->Scale(1./j_hist_sdcp->Integral());
 
    std::unique_ptr<TH1D> j_hist_copy = M3::Clone(j_hist.get(), "j_hist_copy");
    std::unique_ptr<TH1D> j_hist_1sig = M3::Clone(j_hist.get(), "j_hist_1sig");
    std::unique_ptr<TH1D> j_hist_2sig = M3::Clone(j_hist.get(), "j_hist_2sig");
    std::unique_ptr<TH1D> j_hist_3sig = M3::Clone(j_hist.get(), "j_hist_3sig");
 
    //upper and lower edges
    double j_bf = j_hist_copy->GetXaxis()->GetBinCenter(j_hist_copy->GetMaximumBin());
    double j_1sig_low = 9999999.;
    double j_1sig_up  = -9999999.;
    double j_2sig_low = 9999999.;;
    double j_2sig_up  = -9999999.;
    double j_3sig_low = 9999999.;;
    double j_3sig_up  = -9999999.;
 
 
    std::unique_ptr<TH1D> j_hist_sdcp_copy = M3::Clone(j_hist_sdcp.get(), "j_hist_sdcp_copy");
    std::unique_ptr<TH1D> j_hist_sdcp_1sig = M3::Clone(j_hist_sdcp.get(), "j_hist_sdcp_1sig");
    std::unique_ptr<TH1D> j_hist_sdcp_2sig = M3::Clone(j_hist_sdcp.get(), "j_hist_sdcp_2sig");
    std::unique_ptr<TH1D> j_hist_sdcp_3sig = M3::Clone(j_hist_sdcp.get(), "j_hist_sdcp_3sig");
 
    //upper and lower edges
    double j_sdcp_1sig_low = 9999999.;
    double j_sdcp_1sig_up  = -9999999.;
    double j_sdcp_2sig_low = 9999999.;;
    double j_sdcp_2sig_up  = -9999999.;
    double j_sdcp_3sig_low = 9999999.;;
    double j_sdcp_3sig_up  = -9999999.;
 
    double contlevel1 = 0.68;
    double contlevel2 = 0.90;
    double contlevel4 = 0.99;
    double contlevel5 = 0.9973;
    double integral, tsum = 0.;
 
    integral = j_hist_copy->Integral();
 
    while((tsum/integral)<contlevel5) {
      double tmax = j_hist_copy->GetMaximum();
      int bin = j_hist_copy->GetMaximumBin();
      double xval = j_hist_copy->GetXaxis()->GetBinCenter(bin);
      double xwidth = j_hist_copy->GetXaxis()->GetBinWidth(bin);
      if((tsum/integral)<contlevel1) {
        j_hist_copy->SetBinContent(bin,-1.0);
        j_hist_1sig->SetBinContent(bin,0.);
        j_hist_2sig->SetBinContent(bin,0.);
        j_hist_3sig->SetBinContent(bin,0.);
        if(xval<j_1sig_low && xval<j_bf) j_1sig_low = xval - xwidth/2.;
        if(xval>j_1sig_up && xval>j_bf) j_1sig_up = xval + xwidth/2.;
      }
      if((tsum/integral)<contlevel2  && (tsum / integral > contlevel1) ) {
        j_hist_copy->SetBinContent(bin,-5.0);
        j_hist_2sig->SetBinContent(bin,0.);
        j_hist_3sig->SetBinContent(bin,0.);
        if(xval<j_2sig_low && xval<j_bf) j_2sig_low = xval - xwidth/2.;
        if(xval>j_2sig_up && xval>j_bf) j_2sig_up = xval + xwidth/2.;
      }
      if((tsum/integral)<contlevel4  && (tsum / integral > contlevel1) ) {
        j_hist_copy->SetBinContent(bin,-9.0);
        j_hist_3sig->SetBinContent(bin,0.);
        if(xval < j_3sig_low && xval <j_bf) j_3sig_low = xval - xwidth/2.;
        if(xval > j_3sig_up && xval > j_bf) j_3sig_up = xval + xwidth/2.;
      }
      tsum+=tmax;
    }
 
    integral = j_hist_sdcp_copy->Integral();
    tsum = 0.;
 
    while((tsum/integral)<contlevel5) {
      double tmax = j_hist_sdcp_copy->GetMaximum();
      int bin = j_hist_sdcp_copy->GetMaximumBin();
      double xval = j_hist_sdcp_copy->GetXaxis()->GetBinCenter(bin);
      double xwidth = j_hist_sdcp_copy->GetXaxis()->GetBinWidth(bin);
      if((tsum/integral)<contlevel1) {
        j_hist_sdcp_copy->SetBinContent(bin,-1.0);
        j_hist_sdcp_1sig->SetBinContent(bin,0.);
        j_hist_sdcp_2sig->SetBinContent(bin,0.);
        j_hist_sdcp_3sig->SetBinContent(bin,0.);
        if(xval<j_sdcp_1sig_low && xval<j_bf) j_sdcp_1sig_low = xval - xwidth/2.;
        if(xval>j_sdcp_1sig_up && xval>j_bf) j_sdcp_1sig_up = xval + xwidth/2.;
      }
      if((tsum/integral)<contlevel2  && (tsum / integral > contlevel1) ) {
        j_hist_sdcp_copy->SetBinContent(bin,-5.0);
        j_hist_sdcp_2sig->SetBinContent(bin,0.);
        j_hist_sdcp_3sig->SetBinContent(bin,0.);
        if(xval<j_sdcp_2sig_low && xval<j_bf) j_sdcp_2sig_low = xval - xwidth/2.;
        if(xval>j_sdcp_2sig_up && xval>j_bf) j_sdcp_2sig_up = xval + xwidth/2.;
      }
      if((tsum/integral)<contlevel4  && (tsum / integral > contlevel1) ) {
        j_hist_sdcp_copy->SetBinContent(bin,-9.0);
        j_hist_sdcp_3sig->SetBinContent(bin,0.);
        if(xval<j_sdcp_3sig_low && xval<j_bf) j_sdcp_3sig_low = xval - xwidth/2.;
        if(xval>j_sdcp_3sig_up && xval>j_bf) j_sdcp_3sig_up = xval + xwidth/2.;
      }
      tsum+=tmax;
    }
 
    j_hist_1sig->SetLineStyle(9);
    j_hist_sdcp_1sig->SetLineStyle(9);
    j_hist_2sig->SetLineStyle(7);
    j_hist_sdcp_2sig->SetLineStyle(7);
    j_hist_3sig->SetLineStyle(2);
    j_hist_sdcp_3sig->SetLineStyle(2);
 
    auto ldash = std::make_unique<TH1D>("ldash", "solid",  10, -0.04, 0.04);
    auto sdash = std::make_unique<TH1D>("sdash", "dashed", 10, -0.04, 0.04);
    auto fdash = std::make_unique<TH1D>("fdash", "fdashed",10, -0.04, 0.04);
    ldash->SetLineColor(kBlack);
    sdash->SetLineColor(kBlack);
    fdash->SetLineColor(kBlack);
    ldash->SetLineWidth(2);
    sdash->SetLineWidth(2);
    fdash->SetLineWidth(2);
    ldash->SetLineStyle(9);
    sdash->SetLineStyle(7);
    fdash->SetLineStyle(2);
 
    double vertUp = 0.5 * j_hist->GetMaximum();
    auto jline_1sig_low = std::make_unique<TLine>(j_1sig_low, 0., j_1sig_low, vertUp);
    auto jline_2sig_low = std::make_unique<TLine>(j_2sig_low, 0., j_2sig_low, vertUp);
    auto jline_3sig_low = std::make_unique<TLine>(j_3sig_low, 0., j_3sig_low, vertUp);
 
    auto jline_1sig_up = std::make_unique<TLine>(j_1sig_up, 0., j_1sig_up,vertUp);
    auto jline_2sig_up = std::make_unique<TLine>(j_2sig_up, 0., j_2sig_up,vertUp);
    auto jline_3sig_up = std::make_unique<TLine>(j_3sig_up, 0., j_3sig_up,vertUp);
 
    auto jline_sdcp_1sig_low = std::make_unique<TLine>(j_sdcp_1sig_low, 0., j_sdcp_1sig_low, vertUp);
    auto jline_sdcp_2sig_low = std::make_unique<TLine>(j_sdcp_2sig_low, 0., j_sdcp_2sig_low, vertUp);
    auto jline_sdcp_3sig_low = std::make_unique<TLine>(j_sdcp_3sig_low, 0., j_sdcp_3sig_low, vertUp);
 
    auto jline_sdcp_1sig_up = std::make_unique<TLine>(j_sdcp_1sig_up, 0., j_sdcp_1sig_up, vertUp);
    auto jline_sdcp_2sig_up = std::make_unique<TLine>(j_sdcp_2sig_up, 0., j_sdcp_2sig_up, vertUp);
    auto jline_sdcp_3sig_up = std::make_unique<TLine>(j_sdcp_3sig_up, 0., j_sdcp_3sig_up, vertUp);
 
    double arrowLength = 0.003;
    double arrowHeight = vertUp;
 
    auto MakeArrow = [&](double x, Color_t color, Width_t width) -> std::unique_ptr<TArrow> {
      auto arrow = std::make_unique<TArrow>(x, arrowHeight, x - arrowLength, arrowHeight, 0.02, ">");
      arrow->SetLineColor(color);
      arrow->SetLineWidth(width);
      return arrow;
    };
 
    auto j_arrow_1sig_up = MakeArrow(j_1sig_up, j_hist_1sig->GetLineColor(), j_hist_1sig->GetLineWidth());
    auto j_arrow_2sig_up = MakeArrow(j_2sig_up, j_hist_2sig->GetLineColor(), j_hist_2sig->GetLineWidth());
    auto j_arrow_3sig_up = MakeArrow(j_3sig_up, j_hist_3sig->GetLineColor(), j_hist_3sig->GetLineWidth());
 
    auto j_sdcp_arrow_1sig_up = MakeArrow(j_sdcp_1sig_up, j_hist_sdcp_1sig->GetLineColor(), j_hist_sdcp_1sig->GetLineWidth());
    auto j_sdcp_arrow_2sig_up = MakeArrow(j_sdcp_2sig_up, j_hist_sdcp_2sig->GetLineColor(), j_hist_sdcp_2sig->GetLineWidth());
    auto j_sdcp_arrow_3sig_up = MakeArrow(j_sdcp_3sig_up, j_hist_sdcp_3sig->GetLineColor(), j_hist_sdcp_3sig->GetLineWidth());
 
    MACH3LOG_DEBUG("j_1sig_low = {}, j_2sig_low = {}, j_3sig_low = {}", j_1sig_low, j_2sig_low, j_3sig_low);
    MACH3LOG_DEBUG("j_1sig_up = {}, j_2sig_up = {}, j_3sig_up = {}", j_1sig_up, j_2sig_up, j_3sig_up);
 
    auto CopyLineStyle = [](const TH1D* src, TLine* dst) {
      dst->SetLineColor(src->GetLineColor());
      dst->SetLineStyle(src->GetLineStyle());
      dst->SetLineWidth(src->GetLineWidth());
    };
 
    CopyLineStyle(j_hist_1sig.get(), jline_1sig_low.get());
    CopyLineStyle(j_hist_1sig.get(), jline_1sig_up.get());
    CopyLineStyle(j_hist_2sig.get(), jline_2sig_low.get());
    CopyLineStyle(j_hist_2sig.get(), jline_2sig_up.get());
    CopyLineStyle(j_hist_3sig.get(), jline_3sig_low.get());
    CopyLineStyle(j_hist_3sig.get(), jline_3sig_up.get());
 
    CopyLineStyle(j_hist_sdcp_1sig.get(), jline_sdcp_1sig_low.get());
    CopyLineStyle(j_hist_sdcp_1sig.get(), jline_sdcp_1sig_up.get());
    CopyLineStyle(j_hist_sdcp_2sig.get(), jline_sdcp_2sig_low.get());
    CopyLineStyle(j_hist_sdcp_2sig.get(), jline_sdcp_2sig_up.get());
    CopyLineStyle(j_hist_sdcp_3sig.get(), jline_sdcp_3sig_low.get());
    CopyLineStyle(j_hist_sdcp_3sig.get(), jline_sdcp_3sig_up.get());
 
    auto leg = std::make_unique<TLegend>(0.45, 0.60, 0.75, 0.90);
    leg->SetTextSize(0.05);
    leg->SetFillStyle(0);
    leg->SetNColumns(1);
    leg->SetTextFont(132);
    leg->SetBorderSize(0);
 
    leg->AddEntry(j_hist.get(), "Prior flat in #delta_{CP}", "l");
    leg->AddEntry(j_hist_sdcp.get(), "Prior flat in sin#delta_{CP}", "l");
    leg->AddEntry(ldash.get(), "68% CI", "l");
    leg->AddEntry(sdash.get(), "90% CI", "l");
    leg->AddEntry(fdash.get(), "99% CI", "l");
 
    j_hist->GetYaxis()->SetRangeUser(0., j_hist->GetMaximum()*1.15);
    j_hist->Draw("h");
    j_hist_sdcp->Draw("same h");
 
    jline_sdcp_1sig_up->Draw("same");
    jline_sdcp_2sig_up->Draw("same");
    jline_sdcp_3sig_up->Draw("same");
    jline_1sig_up->Draw("same");
    jline_2sig_up->Draw("same");
    jline_3sig_up->Draw("same");
 
    j_arrow_1sig_up->Draw();
    j_arrow_2sig_up->Draw();
    j_arrow_3sig_up->Draw();
    j_sdcp_arrow_1sig_up->Draw();
    j_sdcp_arrow_2sig_up->Draw();
    j_sdcp_arrow_3sig_up->Draw();
    leg->Draw("same");
 
    auto ttext = std::make_unique<TText>();
    ttext->SetNDC(); // Use normalized device coordinates
    ttext->SetTextSize(0.03); // Adjust size as needed
    ttext->SetTextAlign(13); // Align left-top
 
    if (hierarchy == 1) ttext->DrawText(0.15, 0.85, "Normal Ordering");
    else if (hierarchy == 0) ttext->DrawText(0.15, 0.85, "Both Orderings");
    else if (hierarchy == -1) ttext->DrawText(0.15, 0.85, "Inverted Ordering");
 
    gPad->RedrawAxis();
    Posterior->Update();
    gPad->Update();
 
    Posterior->Print(CanvasName);
 
    if(hierarchy == 1)  Posterior->Write("jarl1D_NH_comp");
    else if(hierarchy == 0)  Posterior->Write("jarl1D_both_comp");
    else if(hierarchy == -1)  Posterior->Write("jarl1D_IH_comp");
  }
 
  gErrorIgnoreLevel = originalErrorLevel;
}

◆ PerformJarlskogAnalysis()

void OscProcessor::PerformJarlskogAnalysis ( )

Perform Several Jarlskog Plotting.

Author: Kevin Wood

Note: based on makeJarlskog.C

Todo:: KS: We need to fix this hardcoding here. As right we do not have a way for storing reweight info in a chain...

Definition at line 136 of file OscProcessor.cpp.

                                           {
// ***************
  if(!OscEnabled ||
    Sin2Theta13Index == M3::_BAD_INT_ ||
    Sin2Theta12Index == M3::_BAD_INT_ ||
    Sin2Theta23Index == M3::_BAD_INT_ ||
    DeltaCPIndex == M3::_BAD_INT_||
    DeltaM2_23Index == M3::_BAD_INT_)
  {
    MACH3LOG_WARN("Will not {}, as oscillation parameters are missing", __func__);
    return;
  }
  MACH3LOG_INFO("Starting {}", __func__);
 
  TDirectory *JarlskogDir = OutputFile->mkdir("Jarlskog");
  JarlskogDir->cd();
 
  bool DoReweight = false;
 
  double s2th13, s2th23, s2th12, dcp, dm2 = M3::_BAD_DOUBLE_;
  double weight = 1.;
  int step = M3::_BAD_INT_;
  Chain->SetBranchStatus("*", false);
 
  Chain->SetBranchStatus(Sin2Theta13Name.c_str(), true);
  Chain->SetBranchAddress(Sin2Theta13Name.c_str(), &s2th13);
 
  Chain->SetBranchStatus(Sin2Theta23Name.c_str(), true);
  Chain->SetBranchAddress(Sin2Theta23Name.c_str(), &s2th23);
 
  Chain->SetBranchStatus(Sin2Theta12Name.c_str(), true);
  Chain->SetBranchAddress(Sin2Theta12Name.c_str(), &s2th12);
 
  Chain->SetBranchStatus(DeltaCPName.c_str(), true);
  Chain->SetBranchAddress(DeltaCPName.c_str(), &dcp);
 
  Chain->SetBranchStatus(DeltaM2_23Name.c_str(), true);
  Chain->SetBranchAddress(DeltaM2_23Name.c_str(), &dm2);
 
  Chain->SetBranchStatus("step", true);
  Chain->SetBranchAddress("step", &step);
 
  if (Chain->GetBranch("Weight")) {
    MACH3LOG_CRITICAL("Found Weight in chain, using terrible hardcoding for RC prior...");
    Chain->SetBranchStatus("Weight", true);
    Chain->SetBranchAddress("Weight", &weight);
    DoReweight = true;
  } else {
    MACH3LOG_WARN("Not applying reweighting weight");
    weight = 1.0;
  }
  // Original histograms
  auto jarl = std::make_unique<TH1D>("jarl", "jarl", 1000, -0.05, 0.05);
  jarl->SetDirectory(nullptr);
  auto jarl_th23 = std::make_unique<TH2D>("jarl_th23", "jarl_th23", 500, -0.05, 0.05, 500, 0.3, 0.7);
  jarl_th23->SetDirectory(nullptr);
  auto jarl_dcp = std::make_unique<TH2D>("jarl_dcp", "jarl_dcp", 500, -0.05, 0.05, 500, -1. * TMath::Pi(), TMath::Pi());
  jarl_dcp->SetDirectory(nullptr);
 
  jarl->SetTitle("Jarlskog Invariant;J #equiv s_{13}c_{13}^{2}s_{12}c_{12}s_{23}c_{23}sin#delta;Posterior probability");
  jarl_th23->SetTitle("Jarlskog Invariant;J #equiv s_{13}c_{13}^{2}s_{12}c_{12}s_{23}c_{23}sin#delta;Posterior probability");
 
  // Clones
  auto jarl_IH  = M3::Clone(jarl.get(), "jarl_IH");
  auto jarl_NH  = M3::Clone(jarl.get(), "jarl_NH");
 
  auto jarl_th23_IH  = M3::Clone(jarl_th23.get(), "jarl_th23_IH");
  auto jarl_th23_NH  = M3::Clone(jarl_th23.get(), "jarl_th23_NH");
 
  auto jarl_dcp_IH  = M3::Clone(jarl_dcp.get(), "jarl_dcp_IH");
  auto jarl_dcp_NH  = M3::Clone(jarl_dcp.get(), "jarl_dcp_NH");
 
  auto jarl_flatsindcp          = M3::Clone(jarl.get(), "jarl_flatsindcp");
  auto jarl_IH_flatsindcp       = M3::Clone(jarl.get(), "jarl_IH_flatsindcp");
  auto jarl_NH_flatsindcp       = M3::Clone(jarl.get(), "jarl_NH_flatsindcp");
 
  auto jarl_th23_flatsindcp     = M3::Clone(jarl_th23.get(), "jarl_th23_flatsindcp");
  auto jarl_th23_IH_flatsindcp  = M3::Clone(jarl_th23.get(), "jarl_th23_IH_flatsindcp");
  auto jarl_th23_NH_flatsindcp  = M3::Clone(jarl_th23.get(), "jarl_th23_NH_flatsindcp");
 
  auto jarl_prior               = M3::Clone(jarl.get(), "jarl_prior");
 
  std::unique_ptr<TH1D> jarl_wRC_prior, jarl_wRC_prior_flatsindcp, jarl_wRC_prior_t2kth23;
  // Only use this if chain has reweigh weight [mostly coming from Reactor Constrains]
  if(DoReweight){
    jarl_wRC_prior            = M3::Clone(jarl.get(), "jarl_wRC_prior");
    jarl_wRC_prior_flatsindcp = M3::Clone(jarl.get(), "jarl_wRC_prior_flatsindcp");
    jarl_wRC_prior_t2kth23    = M3::Clone(jarl.get(), "jarl_wRC_prior_flatsindcp");
  }
 
  // to apply a prior that is flat in sin(dcp) intead of dcp
  auto prior3 = std::make_unique<TF1>("prior3", "TMath::Abs(TMath::Cos(x))");
 
  // T2K prior is flat (and uncorrelated) in dcp, sin^2(th13), sin^2(th23)
  auto randGen = std::make_unique<TRandom3>(0);
  const Long64_t countwidth = nEntries/5;
 
  for(int i = 0; i < nEntries; ++i) {
    if (i % countwidth == 0) {
      MaCh3Utils::PrintProgressBar(i, nEntries);
      MaCh3Utils::EstimateDataTransferRate(Chain, i);
    } else {
      Chain->GetEntry(i);
    }
 
    if(step < BurnInCut) continue; // burn-in cut
 
    const double j = CalcJarlskog(s2th13, s2th23, s2th12, dcp);
    const double prior_weight = prior3->Eval(dcp);
 
    jarl->Fill(j, weight);
    jarl_th23->Fill(j, s2th23,weight);
    jarl_dcp->Fill(j, dcp,weight);
 
    jarl_flatsindcp->Fill(j, prior_weight*weight);
    jarl_th23_flatsindcp->Fill(j, s2th23,prior_weight*weight);
 
    const double prior_s2th13 = SamplePriorForParam(Sin2Theta13Index, randGen, {0.,1.});
    const double prior_s2th23 = SamplePriorForParam(Sin2Theta23Index, randGen, {0.,1.});
    const double prior_s2th12 = SamplePriorForParam(Sin2Theta12Index, randGen, {0.,1.});
    const double prior_dcp = SamplePriorForParam(DeltaCPIndex, randGen, {-1.*TMath::Pi(),TMath::Pi()});
    // KS: This is hardcoded but we always assume flat in delta CP so probably fine
    const double prior_sindcp = randGen->Uniform(-1.,1.);
 
    const double prior_s13 = std::sqrt(prior_s2th13);
 
    const double prior_s23  = std::sqrt(prior_s2th23);
    const double prior_s12  = std::sqrt(prior_s2th12);
    const double prior_sdcp = std::sin(prior_dcp);
    const double prior_c13  = std::sqrt(1.-prior_s2th13);
    const double prior_c12  = std::sqrt(1.-prior_s2th12);
    const double prior_c23  = std::sqrt(1.-prior_s2th23);
    const double prior_j    = prior_s13*prior_c13*prior_c13*prior_s12*prior_c12*prior_s23*prior_c23*prior_sdcp;
 
    jarl_prior->Fill(prior_j);
 
    if(DoReweight){
      const double prior_wRC_s2th13 = randGen->Gaus(0.0220,0.0007);
      const double prior_wRC_s13 = std::sqrt(prior_wRC_s2th13);
      const double prior_wRC_c13 = std::sqrt(1.-prior_wRC_s2th13);
      const double prior_wRC_j = prior_wRC_s13*prior_wRC_c13*prior_wRC_c13*prior_s12*prior_c12*prior_s23*prior_c23*prior_sdcp;
      const double prior_wRC_flatsindcp_j = prior_wRC_s13*prior_wRC_c13*prior_wRC_c13*prior_s12*prior_c12*prior_s23*prior_c23*prior_sindcp;
 
      const double s23 = std::sqrt(s2th23);
      const double c23 = std::sqrt(1.-s2th23);
 
      jarl_wRC_prior->Fill(prior_wRC_j);
      jarl_wRC_prior_flatsindcp->Fill(prior_wRC_flatsindcp_j);
      jarl_wRC_prior_t2kth23->Fill(prior_wRC_s13*prior_wRC_c13*prior_wRC_c13*prior_s12*prior_c12*s23*c23*prior_sdcp);
    }
 
 
    if(dm2 > 0.) {
      jarl_NH->Fill(j,weight);
      jarl_th23_NH->Fill(j,s2th23,weight);
      jarl_dcp_NH->Fill(j,dcp,weight);
      jarl_NH_flatsindcp->Fill(j,prior_weight*weight);
      jarl_th23_NH_flatsindcp->Fill(j,s2th23,prior_weight*weight);
    }
    else if(dm2 < 0.) {
      jarl_IH->Fill(j,weight);
      jarl_th23_IH->Fill(j,s2th23,weight);
      jarl_dcp_IH->Fill(j,dcp,weight);
      jarl_IH_flatsindcp->Fill(j, prior_weight*weight);
      jarl_th23_IH_flatsindcp->Fill(j, s2th23, prior_weight*weight);
    }
  }
 
  jarl->Write("jarlskog_both");
  jarl_NH->Write("jarlskog_NH");
  jarl_IH->Write("jarlskog_IH");
  jarl_th23->Write("jarlskog_th23_both");
  jarl_th23_NH->Write("jarlskog_th23_NH");
  jarl_th23_IH->Write("jarlskog_th23_IH");
 
  jarl_dcp->Write("jarlskog_dcp_both");
  jarl_dcp_NH->Write("jarlskog_dcp_NH");
  jarl_dcp_IH->Write("jarlskog_dcp_IH");
 
 
  jarl_flatsindcp->Write("jarlskog_both_flatsindcp");
  jarl_NH_flatsindcp->Write("jarlskog_NH_flatsindcp");
  jarl_IH_flatsindcp->Write("jarlskog_IH_flatsindcp");
  jarl_th23_flatsindcp->Write("jarlskog_th23_both_flatsindcp");
  jarl_th23_NH_flatsindcp->Write("jarlskog_th23_NH_flatsindcp");
  jarl_th23_IH_flatsindcp->Write("jarlskog_th23_IH_flatsindcp");
 
  jarl_prior->Write("jarl_prior");
 
  if(DoReweight) {
    jarl_wRC_prior->Write("jarl_wRC_prior");
    jarl_wRC_prior_flatsindcp->Write("jarl_wRC_prior_flatsindcp");
    jarl_wRC_prior_t2kth23->Write("jarl_wRC_prior_t2kth23");
  }
 
  MakeJarlskogPlot(jarl, jarl_flatsindcp,
                   jarl_NH, jarl_NH_flatsindcp,
                   jarl_IH, jarl_IH_flatsindcp);
 
  JarlskogDir->Close();
  delete JarlskogDir;
 
  Chain->SetBranchStatus("*", true);
  OutputFile->cd();
}

◆ SamplePriorForParam()

double OscProcessor::SamplePriorForParam	(	const int	paramIndex,
		const std::unique_ptr< TRandom3 > &	randGen,
		const std::vector< double > &	FlatBounds
	)		const

protected

Draw Prior value.

Definition at line 113 of file OscProcessor.cpp.

                                                                                                                                                {
// ***************
  TString Title = "";
  double Prior = 1.0, PriorError = 1.0;
  bool FlatPrior = false;
 
  // Get info for this parameter
  GetNthParameter(paramIndex, Prior, PriorError, Title);
 
  ParameterEnum ParType = ParamType[paramIndex];
  int ParamTemp = paramIndex - ParamTypeStartPos[ParType];
  FlatPrior = ParamFlat[ParType][ParamTemp];
 
  if (FlatPrior) {
    return randGen->Uniform(FlatBounds[0], FlatBounds[1]);
  } else {
    // Gaussian prior centered at Prior with width PriorError
    return randGen->Gaus(Prior, PriorError);
  }
}

Member Data Documentation

◆ DeltaCPIndex

int OscProcessor::DeltaCPIndex

protected

Index of \(\delta_{\mathrm{CP}}\) in the parameter list.

Definition at line 75 of file OscProcessor.h.

◆ DeltaCPName

std::string OscProcessor::DeltaCPName

protected

Name of the parameter representing \(\delta_{\mathrm{CP}}\) (the CP-violating phase).

Definition at line 64 of file OscProcessor.h.

◆ DeltaM2_23Index

int OscProcessor::DeltaM2_23Index

protected

Index of \(\Delta m^2_{32}\) in the parameter list.

Definition at line 77 of file OscProcessor.h.

◆ DeltaM2_23Name

std::string OscProcessor::DeltaM2_23Name

protected

Name of the parameter representing \(\Delta m^2_{32}\) (mass-squared difference).

Definition at line 66 of file OscProcessor.h.

◆ OscEnabled

bool OscProcessor::OscEnabled

protected

Will plot Jarlskog Invariant using information in the chain.

Definition at line 55 of file OscProcessor.h.

◆ PlotJarlskog

bool OscProcessor::PlotJarlskog

protected

Will plot Jarlskog Invariant using information in the chain.

Definition at line 52 of file OscProcessor.h.

◆ Sin2Theta12Index

int OscProcessor::Sin2Theta12Index

protected

Index of \(\sin^2\theta_{12}\) in the parameter list.

Definition at line 71 of file OscProcessor.h.

◆ Sin2Theta12Name

std::string OscProcessor::Sin2Theta12Name

protected

Name of the parameter representing \(\sin^2\theta_{12}\).

Definition at line 60 of file OscProcessor.h.

◆ Sin2Theta13Index

int OscProcessor::Sin2Theta13Index

protected

Index of \(\sin^2\theta_{13}\) in the parameter list.

Definition at line 69 of file OscProcessor.h.

◆ Sin2Theta13Name

std::string OscProcessor::Sin2Theta13Name

protected

Name of the parameter representing \(\sin^2\theta_{13}\).

Definition at line 58 of file OscProcessor.h.

◆ Sin2Theta23Index

int OscProcessor::Sin2Theta23Index

protected

Index of \(\sin^2\theta_{23}\) in the parameter list.

Definition at line 73 of file OscProcessor.h.

◆ Sin2Theta23Name

std::string OscProcessor::Sin2Theta23Name

protected

Name of the parameter representing \(\sin^2\theta_{23}\).

Definition at line 62 of file OscProcessor.h.

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

Fitters/OscProcessor.h
Fitters/OscProcessor.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ OscProcessor()

◆ ~OscProcessor()

Member Function Documentation

◆ CalcJarlskog()

◆ LoadAdditionalInfo()

◆ MakeJarlskogPlot()

◆ PerformJarlskogAnalysis()

◆ SamplePriorForParam()

Member Data Documentation

◆ DeltaCPIndex

◆ DeltaCPName

◆ DeltaM2_23Index

◆ DeltaM2_23Name

◆ OscEnabled

◆ PlotJarlskog

◆ Sin2Theta12Index

◆ Sin2Theta12Name

◆ Sin2Theta13Index

◆ Sin2Theta13Name

◆ Sin2Theta23Index

◆ Sin2Theta23Name