pyMaCh3.cpp File Reference

#include <pybind11/pybind11.h>
#include <pybind11/stl.h>

Include dependency graph for pyMaCh3.cpp:

Go to the source code of this file.

Functions
void	initPlotting (py::module &)
void	initFitters (py::module &)
void	initSamples (py::module &)
void	initManager (py::module &)
void	initParameters (py::module &)
void	initSplines (py::module &)
	PYBIND11_MODULE (_pyMaCh3, m)

Detailed Description

Author

Ewan Miller

Definition in file pyMaCh3.cpp.

Function Documentation

initFitters()

void initFitters

(

py::module &

m

)

Definition at line 47 of file fitters.cpp.

                              {
    auto m_fitters = m.def_submodule("fitters");
    m_fitters.doc() =
        "This is a Python binding of MaCh3s C++ fitters library.";
    
    
    py::class_<FitterBase, PyFitterBase /* <--- trampoline*/>(m_fitters, "FitterBase")
        .def(py::init<Manager* const>())
        
        .def(
            "run", 
            &FitterBase::RunMCMC,
            "The implementation of the fitter, you should override this with your own desired fitting algorithm"
        )
 
        .def(
            "get_name", 
            &FitterBase::GetName, 
            " The name of the algorithm, you should override this with something like:: \n"
            "\n"
            "    return 'mySuperCoolAlgoName' \n"
        )
 
        .def(
            "run_LLH_scan",
            &FitterBase::RunLLHScan,
            "Perform a 1D likelihood scan"
        )
 
        .def(
            "get_step_scale_from_LLH_scan",
            &FitterBase::GetStepScaleBasedOnLLHScan,
            "LLH scan is good first estimate of step scale, this will get the rough estimates for the step scales based on running an LLH scan"
        )
 
        .def(
            "run_2d_LLH_scan",
            &FitterBase::Run2DLLHScan,
            " Perform a 2D likelihood scan. \n"
            " :param warning: This operation may take a significant amount of time, especially for complex models."
        )
 
        .def(
            "run_sigma_var",
            &FitterBase::RunSigmaVar,
            " Perform a 2D and 1D sigma var for all samples. \n"
            " :param warning: Code uses TH2Poly"
        )
 
        .def(
            "drag_race",
            &FitterBase::DragRace,
            " Calculates the required time for each sample or covariance object in a drag race simulation. Inspired by Dan's feature \n"
            " :param NLaps: number of laps, every part of Fitter will be tested with given number of laps and you will get total and average time",
            py::arg("NLaps") = 100
        )
 
        // stuff for registering other objects with the fitter
        
        .def(
            "add_sample_handler",
            &FitterBase::AddSampleHandler,
            " This function adds a sample handler object to the analysis framework. The sample handler object will be utilized in fitting procedures or likelihood scans. \n"
            " :param sample: A sample handler object derived from SampleHandlerBase. ",
            py::arg("sample")
        )
        
        .def(
            "add_syst_object",
            &FitterBase::AddSystObj,
            " This function adds a Covariance object to the analysis framework. The Covariance object will be utilized in fitting procedures or likelihood scans. \n"
            " :param cov: A Covariance object derived from ParameterHandlerBase. ",
            py::arg("cov")
        )
 
    ; // End of FitterBase class binding
 
    py::class_<MR2T2, FitterBase>(m_fitters, "mcmc")
        .def(py::init<Manager *const>())
 
        .def(
            "set_chain_length",
            &MR2T2::setChainLength,
            "Set how long chain should be.",
            py::arg("length")); // end of MCMC class binding
 
    py::class_<DelayedMR2T2, FitterBase>(m_fitters, "DelayedMCMC")
        .def(py::init<Manager *const>())
 
        .def(
            "set_chain_length",
            &MR2T2::setChainLength,
            "Set how long chain should be.",
            py::arg("length")); // end of MCMC class binding
 
    py::class_<LikelihoodFit, PyLikelihoodFit /* <--- trampoline*/, FitterBase>(m_fitters, "LikelihoodFit")
        .def(py::init<Manager* const>())
        
        .def(
            "caluclate_chi2",
            [](LikelihoodFit &self, const std::vector<double> &parameterVals)
            {
                return self.CalcChi2(parameterVals.data());
            },
            "Get the Chi2 calculation over all included samples and syst objects for the specified parameter_values \n\
            :param parameter_valuse: The location to evaluate the chi2 at.",
            py::arg("parameter_values")
        )
 
        .def(
            "get_n_params",
            &LikelihoodFit::GetNPars,
            "Get The total number of parameters across all known covariance objects associated with this LikelihoodFit object."
        )
    ; // end of LikelihoodFit class binding
 
    py::class_<MinuitFit, LikelihoodFit>(m_fitters, "MinuitFit")
        .def(py::init<Manager* const>())
        
    ; // end of MinuitFit class binding
 
    py::class_<PSO, LikelihoodFit>(m_fitters, "PSO")
        .def(py::init<Manager* const>())
 
        .def(
            "init",
            &PSO::init,
            "Initialise the fitter"
        )
 
    ; // end of PSO class binding
}

initManager()

void initManager

(

py::module &

m

)

Definition at line 11 of file manager.cpp.

                              {
    auto m_manager = m.def_submodule("manager");
    m_manager.doc() = 
        "This is a Python binding of MaCh3s C++ based manager library.";
 
    // Bind some of the cpp-yaml library 
    // shamelessly stolen from stackoverflow: https://stackoverflow.com/questions/62347521/using-pybind11-to-wrap-yaml-cpp-iterator
    py::enum_<YAML::NodeType::value>(m_manager, "NodeType")
        .value("Undefined", YAML::NodeType::Undefined)
        .value("Null", YAML::NodeType::Null)
        .value("Scalar", YAML::NodeType::Scalar)
        .value("Sequence", YAML::NodeType::Sequence)
        .value("Map", YAML::NodeType::Map);
 
    py::class_<YAML::Node>(m_manager, "YamlNode")
        .def(py::init<const std::string &>())
 
        .def("data",
            [](const YAML::Node node){
                if ( node.Type() != YAML::NodeType::Scalar )
                {
                    throw MaCh3Exception(__FILE__, __LINE__, "Attempting to access the data of non-scalar yaml node. This is undefined.");
                }
                return node.Scalar();
            }, 
            "Access the data stored in the node. This is only valid if the node is a 'scalar' type, i.e. it is a leaf of the yaml tree structure.")
 
        .def("__getitem__",
            [](const YAML::Node node, const std::string& key){
              return node[key];
            })
 
        .def("__getitem__",
            [](const YAML::Node node, const int& key){
              if ( node.Type() != YAML::NodeType::Sequence)
              {
                throw MaCh3Exception(__FILE__, __LINE__, "Trying to access a non sequence yaml node with integer index");
              }
              return node[key];
            })
 
        .def("__iter__",
            [](const YAML::Node &node) {
              return py::make_iterator(node.begin(), node.end());},
             py::keep_alive<0, 1>())
 
        .def("__str__",
             [](const YAML::Node& node) {
               YAML::Emitter out;
               out << node;
               return std::string(out.c_str());
             })
 
        .def("type", &YAML::Node::Type)
        
        .def("__len__", &YAML::Node::size)
        ;
 
    py::class_<YAML::detail::iterator_value, YAML::Node>(m_manager, "_YamlDetailIteratorValue")
        .def(py::init<>())
        .def("first", [](YAML::detail::iterator_value& val) { return val.first;})
        .def("second", [](YAML::detail::iterator_value& val) { return val.second;})
        ;
 
    m.def("load_file", &YAML::LoadFile, "");
 
    py::class_<Manager>(m_manager, "Manager")
        .def(
            py::init<std::string const &>(),
            "create a Manager object with a specified *config_file*",
            py::arg("config_file")
        )
        
        .def(
            "print", 
            &Manager::Print,
            "Print currently used config."
        )
        
        .def(
            "raw", 
            &Manager::raw,
            "Get the raw yaml config."
        )
 
        .def(
            "get_test_stat",
            &Manager::GetMCStatLLH,
            "Get the test statistic that was specified in the config file."
        )
    ;
}

initParameters()

void initParameters

(

py::module &

m

)

Definition at line 38 of file parameters.cpp.

                                 {
    auto m_parameters = m.def_submodule("parameters");
    m_parameters.doc() =
        "This is a Python binding of MaCh3s C++ parameters library.";
 
    
    // Bind the systematic type enum that lets us set different types of systematics
    py::enum_<SystType>(m_parameters, "SystematicType")
            .value("Normalisation", SystType::kNorm)
            .value("Spline", SystType::kSpline)
            .value("Functional", SystType::kFunc)
            .value("N_Systematic_Types", SystType::kSystTypes);
 
        
    py::class_<ParameterHandlerBase, PyParameterHandlerBase /* <--- trampoline*/>(m_parameters, "ParameterHandlerBase")
        .def(
            py::init<const std::vector<std::string>&, const char *, double, int, int>(),
            "Construct a parameters object from a set of yaml files that define the systematic parameters \n\
            :param yaml_files: The name of the yaml file to initialise from. \n\
            :param name: the name of this ParameterHandler object. \n\
            :param threshold: threshold PCA threshold from 0 to 1. Default is -1 and means no PCA. \n\
            :param first_PCA_par: FirstPCAdpar First PCA parameter that will be decomposed. \n\
            :param last_PCA_par: LastPCAdpar First PCA parameter that will be decomposed.",
            py::arg("yaml_files"),
            py::arg("name"),
            py::arg("threshold") = -1.0,
            py::arg("firs_PCA_par") = -999,
            py::arg("last_PCA_par") = -999
        )
        
        .def(
            "calculate_likelihood", 
            &ParameterHandlerBase::CalcLikelihood,
            "Calculate penalty term based on inverted covariance matrix."
        )
 
        .def(
            "get_internal_par_name",
            [](ParameterHandlerBase &self, int index)
            {
                // do this to disambiguate between the std::string and const char* version of this fn
                std::string ret;
                ret = self.GetParName(index);
                return ret;
            },
            "Get the internally used name of this parameter. \n\
            :param index: The global index of the parameter",
            py::arg("index")
        )
        
        .def(
            "get_fancy_par_name",
            [](ParameterHandlerBase &self, int index)
            {
                // do this to disambiguate between the std::string and const char* version of this fn
                std::string ret;
                ret = self.GetParFancyName(index);
                return ret;
            },
            "Get the name of this parameter. \n\
            :param index: The global index of the parameter",
            py::arg("index")
        )
 
        .def(
            "get_n_pars",
            &ParameterHandlerBase::GetNParameters,
            "Get the number of parameters that this ParameterHandler object knows about."
        )
        
        .def(
            "propose_step",
            &ParameterHandlerBase::ProposeStep,
            "Propose a step based on the covariances. Also feel free to overwrite if you want something more funky."
        )
 
        .def(
            "get_proposal_array",
            [](ParameterHandlerBase &self)
            {
                return py::memoryview::from_buffer<double>(
                    self.GetParPropVec().data(), // the data pointer
                    {self.GetNParameters()}, // shape
                    {sizeof(double)} // shape
                ); 
            },
            "Bind a python array to the parameter proposal values for this ParameterHandler object. \n\
            This allows you to set e.g. a numpy array to 'track' the parameter proposal values. You could either use this to directly set the proposals, or to just read the values proposed by e.g. throw_par_prop() \n\
            :warning: This should be set *AFTER* all of the parameters have been read in from the config file as it resizes the array to fit the number of parameters. \n\
            :param array: This is the array that will be set. Size and contents don't matter as it will be changed to fit the parameters. "
        )
 
 
    ; // End of ParameterHandlerBase binding
 
    
    py::class_<ParameterHandlerGeneric, ParameterHandlerBase /* <--- trampoline*/>(m_parameters, "ParameterHandlerGeneric")
        .def(
            py::init<const std::vector<std::string>&, const char *, double, int, int>(),
            "Construct a systematic ParameterHandler object from a set of yaml files that define the systematic parameters \n\
            :param yaml_files: The name of the yaml file to initialise from. \n\
            :param name: the name of this ParameterHandler object. \n\
            :param threshold: threshold PCA threshold from 0 to 1. Default is -1 and means no PCA. \n\
            :param first_PCA_par: FirstPCAdpar First PCA parameter that will be decomposed. \n\
            :param last_PCA_par: LastPCAdpar First PCA parameter that will be decomposed.",
            py::arg("yaml_files"),
            py::arg("name") = "xsec_cov",
            py::arg("threshold") = -1.0,
            py::arg("firs_PCA_par") = -999,
            py::arg("last_PCA_par") = -999
        )
        
        .def(
            "get_par_type",
            &ParameterHandlerGeneric::GetParamType,
            "Get what type of systematic this parameters is (see :py:class:`pyMaCh3.m_parameters.SystematicType` for possible types). \n\
            :param index: The global index of the parameter",
            py::arg("index")
        )
        
        .def(
            "get_par_spline_type",
            &ParameterHandlerGeneric::GetParSplineInterpolation,
            "Get what type of spline this parameter is set to use (assuming that it is a spline type parameter). \n\
            :param index: The index of the spline parameter",
            py::arg("index")
        )
        
        .def(
            "get_par_spline_name",
            &ParameterHandlerGeneric::GetParSplineName,
            "Get the name of the spline associated with a spline parameter. This is generally what it is called in input spline files and can in principle be different to the parameters name. \n\
            :param index: The index of the spline parameter",
            py::arg("index")
        )
 
    ; // End of ParameterHandlerGeneric binding
}

initPlotting()

void initPlotting

(

py::module &

m

)

Definition at line 15 of file plotting.cpp.

                               {
    auto m_plotting = m.def_submodule("plotting");
    m_plotting.doc() = "This is a Python binding of MaCh3s C++ based plotting library.";
 
    py::class_<MaCh3Plotting::PlottingManager>(m_plotting, "PlottingManager")
        .def(
            py::init<const std::string &>(),
            "construct a PlottingManager using the specified config file",
            py::arg("config_file_name")
        ) 
        
        .def(
            py::init(),
            "default constructor, will initialise the PlottingManager with the default plotting config"
        ) 
        
        .def(
            "initialise", 
            &MaCh3Plotting::PlottingManager::initialise, 
            "initalise this PlottingManager"
        )
        
        .def(
            "usage", 
            &MaCh3Plotting::PlottingManager::usage, 
            "Print a usage message for the current executable"
        )
        
        .def(
            "parse_inputs", 
            &MaCh3Plotting::PlottingManager::parseInputsVec, 
            "Parse command line variables",
            py::arg("arguments")
        )
        
        .def(
            "set_exec", 
            &MaCh3Plotting::PlottingManager::setExec, 
            "Set the name of the current executable, which will be used when getting executable specific options from the plotting config file",
            py::arg("exec_name")
        )
        
        .def(
            "get_file_name", 
            &MaCh3Plotting::PlottingManager::getFileName, 
            "Get the path to a particular file",
            py::arg("input_file_id")
        )
        
        .def(
            "get_file_label", 
            &MaCh3Plotting::PlottingManager::getFileLabel, 
            "Get the specified label of a particular input file",
            py::arg("input_file_id")
        )
        
        .def(
            "get_draw_options", 
            &MaCh3Plotting::PlottingManager::getDrawOptions, 
            "Get any additional root drawing options specified by the user"
        )
        
        .def(
            "get_output_name", 
            py::overload_cast<const std::string &>(&MaCh3Plotting::PlottingManager::getOutputName), 
            "Get the output name specified by the user, can specify an additional *suffix* to append to the file name but before the file extension",
            py::arg("suffix") = ""
        )
        
        .def(
            "get_file_names", 
            &MaCh3Plotting::PlottingManager::getFileNames, 
            "Get the list of all file names"
        )
        
        .def(
            "get_file_labels", 
            &MaCh3Plotting::PlottingManager::getFileLabels, 
            "Get the list of all file labels"
        )
        
        .def(
            "get_n_files", 
            &MaCh3Plotting::PlottingManager::getNFiles, 
            "Get the number of specified files"
        )
        
        .def(
            "get_split_by_sample", 
            &MaCh3Plotting::PlottingManager::getSplitBySample, 
            "Get whether or not the user has set the 'split by sample' (-s) option"
        )
        
        .def(
            "get_plot_ratios", 
            &MaCh3Plotting::PlottingManager::getPlotRatios, 
            "Get whether or not the user specified the 'plot ratios' (-r) option"
        )
        
        .def(
            "get_draw_grid", 
            &MaCh3Plotting::PlottingManager::getDrawGrid, 
            "Get wheter or not the user has specified the 'draw grid' (-g) option"
        )
        
        .def(
            "style", 
            &MaCh3Plotting::PlottingManager::style, py::return_value_policy::reference, 
            "Get the StyleManager associated with this PlottingManager"
        )
        
        .def(
            "input", 
            &MaCh3Plotting::PlottingManager::input, py::return_value_policy::reference, 
            "Get the InputManager associated with this PlottingManager"
        )
 
        // EM: I can't figure out how to add the getOption methods as theres not really a way to deduce the return type from yaml so leaving them out for now :/
        //     I think one solution would be to extend the PlottingManager class inside of python (add a pyPlottingManager (or something like that) that derives 
        //     from this one and add the functions to that) and then fold that python code into the module somehow. But that is currently beyond my pybinding abilities
        ;
 
    py::class_<MaCh3Plotting::InputManager>(m_plotting, "InputManager")
        .def(
            "print", 
            &MaCh3Plotting::InputManager::print, 
            "Print a summary of everything this manager knows"
            )
        
        .def(
            "get_llh_scan", 
            &MaCh3Plotting::InputManager::getLLHScan, 
            "Get the LLH scan for a particular parameter from a particular file",
            py::arg("input_file_id"), 
            py::arg("param_name"), 
            py::arg("LLH_type") = "total"
            )
        
        .def(
            "get_llh_scan_by_sample", 
            &MaCh3Plotting::InputManager::getSampleSpecificLLHScan, 
            "Get the LLH scan for a particular parameter from a particular file for a particular sample",
            py::arg("input_file_id"), 
            py::arg("param"), 
            py::arg("sample")
            )
        
        .def(
            "get_enabled_llh", 
            &MaCh3Plotting::InputManager::getEnabledLLH, 
            "Get whether a particular file has LLH scans for a particular parameter", 
            py::arg("input_file_id"), 
            py::arg("param"),
            py::arg("LLH_type") = "total"
            )
        
        .def(
            "get_enabled_llh_by_sample", 
            &MaCh3Plotting::InputManager::getEnabledLLHBySample, 
            "Get whether a particular file has LLH scans for a particular parameter for a particular sample",
            py::arg("input_file_id"), 
            py::arg("param"), 
            py::arg("sample")
            )
        
        .def(
            "get_post_fit_error", 
            &MaCh3Plotting::InputManager::getPostFitError, 
            "Get the post fit error for a parameter from a particular file",
            py::arg("input_file_id"), 
            py::arg("param"),
            py::arg("error_type") = ""
            )
        
        .def(
            "get_post_fit_value", 
            &MaCh3Plotting::InputManager::getPostFitValue, 
            "Get the post fit value for a parameter from a particular file",
            py::arg("input_file_id"), 
            py::arg("param"),
            py::arg("error_type") = ""
            )
        
        .def(
            "get_known_parameters", 
            &MaCh3Plotting::InputManager::getKnownParameters, 
            "Get all the parameters that this manager knows about. Useful for iterating over"
            )
        
        .def(
            "get_known_samples", 
            &MaCh3Plotting::InputManager::getKnownSamples, 
            "Get all the samples that this manager knows about. Useful for iterating over"
            )
        
        .def(
            "get_tagged_parameters", 
            &MaCh3Plotting::InputManager::getTaggedParameters, 
            "Get all the parameters whose tags match some specified list",
            py::arg("tags"),
            py::arg("check_type") = "all"
            )
        
        .def(
            "get_tagged_samples", 
            &MaCh3Plotting::InputManager::getTaggedSamples, 
            "Get all the samples whose tags match some specified list",
            py::arg("tags"),
            py::arg("check_type") = "all"
            )
        
        .def(
            "get_n_input_files", 
            &MaCh3Plotting::InputManager::getNInputFiles, 
            "Get the number of input files registered with this manager"
            )
        
        .def(
            "get_known_llh_parameters", 
            &MaCh3Plotting::InputManager::getKnownLLHParameters, 
            "Get all the parameters that a file has LLH scans for",
            py::arg("file_id")
            )
        
        .def(
            "get_known_llh_samples", 
            &MaCh3Plotting::InputManager::getKnownLLHSamples, 
            "Get all the samples that a file has individual LLH scans for",
            py::arg("file_id")
            )
        
        .def(
            "get_known_post_fit_parameters", 
            &MaCh3Plotting::InputManager::getKnownPostFitParameters, 
            "Get all the parameters that a file has post fit values and errors for",
            py::arg("file_id")
            )
        
        .def(
            "get_known_MCMC_parameters", 
            &MaCh3Plotting::InputManager::getKnownMCMCParameters, 
            "Get all the parameters that a file has MCMC chain entries for",
            py::arg("file_id")
            )
        
        .def(
            "get_known_1d_posterior_parameters", 
            &MaCh3Plotting::InputManager::getKnown1dPosteriorParameters, 
            "Get all the parameters that a file has processed 1d posteriors for",
            py::arg("file_id")
            )
        
        .def(
            "get_MCMC_entry", 
            &MaCh3Plotting::InputManager::getMCMCentry, 
            "Load up a particular step in the MCMC chain for a particular input file",
            py::arg("file_id"),
            py::arg("step")
            )
        
        .def(
            "get_MCMC_value", 
            &MaCh3Plotting::InputManager::getMCMCvalue, 
            "Get the value of a particular parameter for the current entry (set by set_MCMC_entry) in the chain for a particular file",
            py::arg("file_id"),
            py::arg("param")
            )
        
        .def(
            "get_n_MCMC_entries", 
            &MaCh3Plotting::InputManager::getnMCMCentries, 
            "Get the number of entries in the MCMC chain in a particular file"
            )
        
        .def(
            "get_1d_posterior",
            &MaCh3Plotting::InputManager::get1dPosterior,
            "Get the 1d posterior for a particular parameter from a particular file",
            py::arg("file_id"),
            py::arg("param")
            )
        ;
 
    py::class_<MaCh3Plotting::StyleManager>(m_plotting, "StyleManager")
        .def(
            "prettify_parameter_name", 
            &MaCh3Plotting::StyleManager::prettifyParamName, 
            "Convert internally used parameter name to a nice pretty name that can be used in plots",
            py::arg("param")
        )
        
        .def(
            "prettify_sample_name", 
            &MaCh3Plotting::StyleManager::prettifyParamName, 
            "Convert internally used sample name to a nice pretty name that can be used in plots",
            py::arg("sample")
        )
        ;
}

initSamples()

void initSamples

(

py::module &

m

)

Definition at line 392 of file samples.cpp.

                              {
    auto m_samples = m.def_submodule("samples");
    m_samples.doc() =
        "This is a Python binding of MaCh3s C++ based samples library.";
 
    // Bind the systematic type enum that lets us set different types of systematics
    py::enum_<TestStatistic>(m_samples, "TestStatistic")
        .value("Poisson", TestStatistic::kPoisson)
        .value("Barlow_Beeston", TestStatistic::kBarlowBeeston)
        .value("Ice_Cube", TestStatistic::kIceCube)
        .value("Pearson", TestStatistic::kPearson)
        .value("Dembinski_Abdelmottele", TestStatistic::kDembinskiAbdelmotteleb)
        .value("N_Test_Statistics", TestStatistic::kNTestStatistics);
 
    py::class_<SampleHandlerBase, PySampleHandlerBase /* <--- trampoline*/>(m_samples, "SampleHandlerBase")
        .def(py::init())
        
        .def(
            "reweight", 
            &SampleHandlerBase::Reweight,
            "reweight the MC events in this sample. You will need to override this."
        )
        
        .def(
            "get_likelihood", 
            &SampleHandlerBase::GetLikelihood,
            "Get the sample likelihood at the current point in your model space. You will need to override this."
        )
        
        .def(
            "set_test_stat",
            &SampleHandlerBase::SetTestStatistic,
            "Set the test statistic that should be used when calculating likelihoods. \n\
            :param test_stat: The new test statistic to use",
            py::arg("test_stat")
        )
 
        .def(
            "get_bin_LLH",
            py::overload_cast<double, double, double>(&SampleHandlerBase::GetTestStatLLH, py::const_),
            "Get the LLH for a bin by comparing the data and MC. The result depends on having previously set the test statistic using :py:meth:`pyMaCh3.samples.SampleHandlerBase.set_test_stat` \n\
            :param data: The data content of the bin. \n\
            :param mc: The mc content of the bin \n\
            :param w2: The Sum(w_{i}^2) (sum of weights squared) in the bin, which is sigma^2_{MC stats}",
            py::arg("data"), 
            py::arg("mc"), 
            py::arg("w2")
        )
    ; // End of SampleHandlerBase binding
 
    py::class_<SampleHandlerFD, PySampleHandlerFD /* <--- trampoline*/, SampleHandlerBase>(m_samples, "SampleHandlerFD")
        .def(
            py::init<std::string, ParameterHandlerGeneric*>(),
            "This should never be called directly as SampleHandlerFD is an abstract base class. \n\
            However when creating a derived class, in the __init__() method, you should call the parent constructor i.e. this one by doing:: \n\
            \n\
            \tsuper(<your derived SampleHandler class>, self).__init__(*args) \n\
            \n ",
            py::arg("mc_version"),
            py::arg("xsec_cov")
        )
    ;
 
    /* Not sure if this will be needed in future versions of MaCh3 so leaving commented for now
    py::class_<fdmc_base>(m_samples, "MCstruct")
        .def(py::init())
        
        // Because a lot of the variables in fdmc_base use c style arrays,
        // we need to provide some setter functions to be able to set them using more
        // "pythony" objects, e.g. lists and numpy arrays
        .def(
            "set_event_variable_values", 
            [](fdmc_base &self, int dim, py::array_t<double, py::array::c_style> &array)
            {
                py::buffer_info bufInfo = array.request();
 
                if ( dim > 2 )
                    throw MaCh3Exception(__FILE__, __LINE__, "Currently only dimensions of 1 or 2 are supported sorry :(");
 
                if ( bufInfo.ndim != 1 )
                    throw MaCh3Exception(__FILE__, __LINE__, "Number of dimensions in parameter array must be one if setting only one of the event variable arrays!");
                
                if( dim ==1 )
                    self.x_var = array.data();
                    
                else if ( dim == 2)
                    self.y_var = array.data();
            }
        )
    ;
    */
}

initSplines()

void initSplines

(

py::module &

m

)

Definition at line 72 of file splines.cpp.

                              {
    auto m_splines = m.def_submodule("splines");
    m_splines.doc() = 
        "This is a Python binding of MaCh3s C++ based spline library.";
 
    // Bind the interpolation type enum that lets us set different interpolation types for our splines
    py::enum_<SplineInterpolation>(m_splines, "InterpolationType")
            .value("Linear", SplineInterpolation::kLinear, "Linear interpolation between the knots")
            .value("Linear_Func", SplineInterpolation::kLinearFunc, "Same as 'Linear'")
            .value("Cubic_TSpline3", SplineInterpolation::kTSpline3, "Use same coefficients as `ROOT's TSpline3 <https://root.cern.ch/doc/master/classTSpline3.html>`_ implementation")
            .value("Cubic_Monotonic", SplineInterpolation::kMonotonic, "Coefficients are calculated such that the segments between knots are forced to be monotonic. The implementation we use is based on `this method <https://www.jstor.org/stable/2156610>`_ by Fritsch and Carlson.")
            .value("Cubic_Akima", SplineInterpolation::kAkima, "The second derivative is not required to be continuous at the knots. This means that these splines are useful if the second derivative is rapidly varying. The implementation we used is based on `this paper <http://www.leg.ufpr.br/lib/exe/fetch.php/wiki:internas:biblioteca:akima.pdf>`_ by Akima.")
            .value("N_Interpolation_Types", SplineInterpolation::kSplineInterpolations, "This is only to be used when iterating and is not a valid interpolation type.");
 
    
    py::class_<SplineBase, PySplineBase /* <--- trampoline*/>(m_splines, "SplineBase");
 
    py::class_<TResponseFunction_red>(m_splines, "_ResponseFunctionBase")
        .doc() = "Base class of the response function, this binding only exists for consistency with the inheritance structure of the c++ code. Just pretend it doesn't exist and don't worry about it...";
 
    // Bind the TSpline3_red class. Decided to go with a clearer name of ResponseFunction for the python binding
    // and make the interface a bit more python-y. Additionally remove passing root stuff so we don't need to deal 
    // with root python binding and can just pass it native python objects.
    py::class_<TSpline3_red, TResponseFunction_red, std::unique_ptr<TSpline3_red, py::nodelete>>(m_splines, "ResponseFunction")
        .def(
            // define a more python friendly constructor that massages the inputs and passes them
            // through to the c++ constructor
            py::init
            (
                // Just take in some vectors, then build a TSpline3 and pass this to the constructor
                [](std::vector<double> &xVals, std::vector<double> &yVals, SplineInterpolation interpType)
                {
                    if ( xVals.size() != yVals.size() )
                    {
                        throw MaCh3Exception(__FILE__, __LINE__, "Different number of x values and y values!");
                    }
 
                    int length = int(xVals.size());
 
                    if (length == 1)
                    {
                        M3::float_t xKnot = M3::float_t(xVals[0]);
                        M3::float_t yKnot = M3::float_t(yVals[0]);
 
                        std::vector<M3::float_t *> pars;
                        pars.resize(3);
                        pars[0] = new M3::float_t(0.0);
                        pars[1] = new M3::float_t(0.0);
                        pars[2] = new M3::float_t(0.0);
                        delete pars[0];
                        delete pars[1];
                        delete pars[2];
 
                        return new TSpline3_red(&xKnot, &yKnot, 1, pars.data());
                    }
 
                    TSpline3 *splineTmp = new TSpline3( "spline_tmp", xVals.data(), yVals.data(), length );
                    return new TSpline3_red(splineTmp, interpType);
                }
            )
        )
 
        .def(
            "find_segment", 
            &TSpline3_red::FindX, 
            "Find the segment that a particular *value* lies in. \n"
            ":param value: The value to test",
            py::arg("value")
        )
 
        .def(
            "evaluate",
            &TSpline3_red::Eval,
            "Evaluate the response function at a particular *value*. \n"
            ":param value: The value to evaluate at.",
            py::arg("value")
        )
    ; // End of binding for ResponseFunction
 
    py::class_<SMonolith, SplineBase>(m_splines, "EventSplineMonolith")
        .def(
            py::init(
                [](std::vector<std::vector<TResponseFunction_red*>> &responseFns, const bool saveFlatTree)
                {
                    std::vector<RespFuncType> respFnTypes;
                    for(uint i = 0; i < responseFns[0].size(); i++)
                    {
                        // ** WARNING **
                        // Right now I'm only pushing back TSpline3_reds as that's all that's supported right now
                        // In the future there might be more
                        // I think what would be best to do would be to store the interpolation type somehow in the ResponseFunction objects
                        // then just read them here and pass through to the constructor
                        respFnTypes.push_back(RespFuncType::kTSpline3_red);
                    }
                    return new SMonolith(responseFns, respFnTypes, saveFlatTree);
                }
            ),
            "Create an EventSplineMonolith \n"
            ":param master_splines: These are the 'knot' values to make splines from. This should be an P x E 2D list where P is the number of parameters and E is the number of events. \n"
            ":param save_flat_tree: Whether we want to save monolith into speedy flat tree",
            py::arg("master_splines"),
            py::arg("save_flat_tree") = false
        )
 
        .def(
            py::init<std::string>(),
            "Constructor where you pass path to preprocessed root FileName which is generated by creating an EventSplineMonolith with the `save_flat_tree` flag set to True. \n"
            ":param file_name: The name of the file to read from.",
            py::arg("file_name")
        )
 
        .def(
            "evaluate",
            &SMonolith::Evaluate,
            "Evaluate the splines at their current values."
        )
 
        .def(
            "sync_mem_transfer",
            &SMonolith::SynchroniseMemTransfer,
            "This is important when running on GPU. After calculations are done on GPU we copy memory to CPU. This operation is asynchronous meaning while memory is being copied some operations are being carried. Memory must be copied before actual reweight. This function make sure all has been copied."
        )
 
        .def(
            "get_event_weight",
            &SMonolith::retPointer,
            py::return_value_policy::reference,
            "Get the weight of a particular event. \n"
            ":param event: The index of the event whose weight you would like.",
            py::arg("event")
        )
 
        .def(
            "set_param_value_array",
            // Wrap up the setSplinePointers method so that we can take in a numpy array and get 
            // pointers to it's sweet sweet data and use those pointers in the splineMonolith 
            [](SMonolith &self, py::array_t<double, py::array::c_style> &array)
            {
                py::buffer_info bufInfo = array.request();
 
                if ( bufInfo.ndim != 1)
                {
                    throw MaCh3Exception(__FILE__, __LINE__, "Number of dimensions in parameter array must be one!");
                }
 
                if ( bufInfo.shape[0] != self.GetNParams() )
                {
                    throw MaCh3Exception(__FILE__, __LINE__, "Number of entries in parameter array must equal the number of parameters!");
                }
 
                std::vector<const double *> paramVec;
                paramVec.resize(self.GetNParams());
 
                for( int idx = 0; idx < self.GetNParams(); idx++ )
                {
                    // booooo pointer arithmetic
                    paramVec[idx] = array.data() + idx;
                } 
 
                self.setSplinePointers(paramVec);
            },
            "Set the array that the monolith should use to read parameter values from. \n"
            "Usage of this might vary a bit from what you're used to in python. \n"
            "Rather than just setting the values here, what you're really doing is setting pointers in the underlying c++ code. \n"
            "What that means is that you pass an array to this function like:: \n"
            "\n event_spline_monolith_instance.set_param_value_array(array) \n\n"
            "Then when you set values in that array as normal, they will also be updated inside of the event_spline_monolith_instance.",
            py::arg("array")
 
        )
 
        .doc() = "This 'monolith' deals with event by event weighting using splines."
 
    ; // End of binding for EventSplineMonolith
}

PYBIND11_MODULE()

PYBIND11_MODULE	(	_pyMaCh3	,
		m
	)

Definition at line 16 of file pyMaCh3.cpp.

                               {
    initPlotting(m);
    initFitters(m);
    initSamples(m);
    initManager(m);
    initParameters(m);
    initSplines(m);
}