Calibratable.h

Go to the documentation of this file.

#ifndef CALIBRATABLE_H_
#define CALIBRATABLE_H_

//#include <boost/shared_ptr.hpp>

#include <vector>
#include <iostream>

#include "DataFormats/ParticleFlowReco/interface/CalibrationResultWrapper.h"
#include "DataFormats/ParticleFlowReco/interface/CalibrationProvenance.h"
#include "DataFormats/Math/interface/LorentzVector.h"
#include "DataFormats/ParticleFlowReco/interface/CaloWindow.h"
#include "DataFormats/ParticleFlowReco/interface/CaloEllipse.h"

namespace pftools {

class CalibratableElement {
public:
    CalibratableElement() {
        reset();
    }

    CalibratableElement(double energy, double eta, double phi, int layer,
            double extent = 0.0, double time = 0.0) :
        energy_(energy), eta_(eta), phi_(phi), time_(time), layer_(layer), extent_(extent) {
    }

    double energy_, eta_, phi_, time_;
    int layer_;

    //RMS of deltaR of hits in the cluster to its centre
    double extent_;

    void reset() {
        energy_ = 0.0;
        eta_ = 0.0;
        phi_ = 0.0;
        layer_ = 0;
        extent_ = 0.0;
        time_ = 0.0;
    }
    bool operator<(const CalibratableElement& em) const {
        if (em.energy_ < energy_)
            return true;
        return false;
    }


};

class CandidateWrapper {
public:
    CandidateWrapper() {
        reset();
    }

    CandidateWrapper(double energy, double eta, double phi, double energyEcal,
            double energyHcal, int type) :
        energy_(energy), eta_(eta), phi_(phi), energyEcal_(energyEcal),
                energyHcal_(energyHcal), type_(type) {
        calowindow_ecal_.reset();
        calowindow_hcal_.reset();
        caloellipse_ecal_.reset();
        caloellipse_hcal_.reset();

    }

    double energy_, eta_, phi_, energyEcal_, energyHcal_;
    int cluster_numEcal_, cluster_numHcal_;
    int type_;

    CaloWindow calowindow_ecal_;
    CaloWindow calowindow_hcal_;

    CaloEllipse caloellipse_ecal_;
    CaloEllipse caloellipse_hcal_;

    void reset() {
        energy_ = 0;
        eta_ = 0;
        phi_ = 0;
        energyEcal_ = 0;
        energyHcal_ = 0;
        cluster_numEcal_ = 0;
        cluster_numHcal_ = 0;
        type_ = -1;
        calowindow_ecal_.reset();
        calowindow_hcal_.reset();
        caloellipse_ecal_.reset();
        caloellipse_hcal_.reset();
    }

    void recompute() {
        caloellipse_ecal_.makeCaches();
        caloellipse_hcal_.makeCaches();
    }
};
class Calibratable {
public:

    Calibratable() {
        reset();
    }

    virtual ~Calibratable() {
    }

    virtual void reset();

    //truth first
    double sim_energyEvent_, sim_eta_, sim_phi_;
    double sim_energyEcal_, sim_energyHcal_;
    double sim_etaEcal_, sim_etaHcal_, sim_phiEcal_, sim_phiHcal_;
    int sim_numEvent_;
    //set to true if this event is not real data
    bool sim_isMC_;
    //test beam specific
    bool tb_isTB_;
    //where was the TB table?
    double tb_eta_, tb_phi_;
    //TB run number and PDG particle type
    int tb_run_, tb_pdg_;
    //Veto counter values
    double tb_tof_, tb_ck3_, tb_ck2_;
    //Erm, bit complicated this one...
    char tb_vetosPassed_;

    //DYNAMIC: Computed from tb_ecal_ and tb_hcal_
    double tb_energyEvent_, tb_energyEcal_, tb_energyHcal_;
    std::vector<CalibratableElement> tb_ecal_, tb_hcal_;
    int tb_numEcal_, tb_numHcal_; //DYNAMIC

    CalibratableElement tb_meanEcal_, tb_meanHcal_; //DYNAMIC

    //leading track
    double recotrk_numHits_, recotrk_quality_, recotrk_charge_;
    double recotrk_etaEcal_, recotrk_phiEcal_;
    //delta phi between sim particle and leading track
    double recotrk_deltaRWithSim_;
    math::XYZTLorentzVector recotrk_momentum_;

    //CaloWindow class (new for 3_1_X)
    CaloWindow calowindow_ecal_;
    CaloWindow calowindow_hcal_;

    //pf clusters
    //DYNAMIC: Computed from cluster_ecal_ and cluster_hcal_
    double cluster_energyEvent_, cluster_energyEcal_, cluster_energyHcal_; //DYNAMIC
    std::vector<CalibratableElement> cluster_ecal_, cluster_hcal_;
    int cluster_numEcal_, cluster_numHcal_; //DYNAMIC
    CalibratableElement cluster_meanEcal_, cluster_meanHcal_; //DYNAMIC

    //pf rechits
    //DYNAMIC: Computed from rechits_ecal_ and rechits_hcal_
    double rechits_energyEvent_, rechits_energyEcal_, rechits_energyHcal_;
    std::vector<CalibratableElement> rechits_ecal_, rechits_hcal_;
    int rechits_numEcal_, rechits_numHcal_; //DYNAMIC
    CalibratableElement rechits_meanEcal_, rechits_meanHcal_; //DYNAMIC

    //pf candidates
    std::vector<CandidateWrapper> cands_;
    CandidateWrapper cands_mean_; //DYNAMIC
    int cands_num_; //DYNAMIC

    //DYNAMIC: Computed from cands_
    double cand_energyEvent_, cand_energyEcal_, cand_energyHcal_, cand_eta_,
            cand_phi_;
    double cand_energyNeutralEM_, cand_energyNeutralHad_; //DYNAMIC
    int cand_type_; //DYNAMIC

    std::vector<CalibrationResultWrapper> calibrations_;

    //Recomputes cluster and rechit averages using the vectors of DepositDiets
    //Users should call this before filling the tree.
    virtual void recompute();

    virtual CalibratableElement computeMean(const std::vector<
            CalibratableElement>& diets);

    virtual CandidateWrapper computeMean(
            const std::vector<CandidateWrapper>& wrappers);

    virtual void fillCaloWindow(const std::vector<CalibratableElement>& source,
            CaloWindow& destination) const;

};

//typedef boost::shared_ptr<Calibratable> CalibratablePtr;

std::ostream& operator<<(std::ostream& s, const Calibratable& calib_);
std::ostream& operator<<(std::ostream& s, const CalibratableElement& ce_);

}
#endif /*CALIBRATABLE_H_*/