Observable.h

Go to the documentation of this file.

#pragma once
 
#include <iostream>
#include <list>
#include <memory>
#include <optional>
#include <utility>
 
#include <Eigen/Dense>
 
#include <TString.h>
#include <TTreeReader.h>
#include <TUnfoldBinning.h>
 
#include "Core/Unfolding/interface/DistVariation.h"
 
class TH1;
class TH2;
 
namespace DAS::Unfolding {
 
template<class T>
auto initOptionalBranch(TTreeReader& reader, const char *name)
{
     return reader.GetTree()->GetBranch(name) != nullptr
         ? std::make_optional<typename T::value_type>(reader, name)
         : std::nullopt;
}
 
struct Filler {
    virtual ~Filler () = default;
 
    virtual std::list<int> fillRec (DistVariation&);
 
    virtual void match ();
 
    virtual void fillMC (DistVariation&);
};
 
class Transformer {
 
protected:
 
    //static int offset; //!< number of bins before the present distribution in original binning
 
    static void AddAxis (TUnfoldBinning *, 
                         TUnfoldBinning *, 
                         int 
                         );
 
public:
 
    static Eigen::VectorXd y; 
 
    TUnfoldBinning * preBinning, 
                   * postBinning; 
 
    virtual ~Transformer () = default;
 
    virtual void Transform
        (const Eigen::VectorXd& 
        ) const;
 
    virtual void RemoveBadInputBins (TH1 *, 
                                     TH2 * 
                                    );
 
    Transformer (TUnfoldBinning *, 
                 bool = true 
                );
};
 
struct Observable {
 
    static bool isMC; 
    static double maxDR; 
 
    // The following objects may be used either directly in `getUnfHist` command
    TUnfoldBinning * recBinning, 
                   * genBinning; 
 
    virtual std::unique_ptr<Filler> getFiller (TTreeReader& reader) const;
 
    virtual std::unique_ptr<Transformer> getTransformer (TUnfoldBinning *) const;
 
    virtual void setLmatrix (const std::unique_ptr<TH1>&, 
                             std::unique_ptr<TH2>& 
                            );
 
    virtual ~Observable () = default;
protected:
 
    Observable (const char *, const char *);
};
 
std::vector<Observable *> GetObservables 
                    (boost::property_tree::ptree 
                     );
 
} // end of namespace DAS::Unfolding