////////////////////////////////////////// //METUtility.h //Authors: Jet Goodson //First version: 5/5/2011 // //The METUtility is intended to provide the user at D3PD level //with the correct recipe and information for rebuilding MET to include //scaling and smearing, and for calculating the systematic //uncertainty on MET. // //While it's designed for D3PD/Ntuples, we hope to keep it usable by AOD users //////////////////////////////////////////// //Instructions: //Prior to root macro // .L METUtility.h+ // //////////////////////////////////////////// #ifndef _METUTILITY_ #define _METUTILITY_ #include "TNamed.h" #include "TVector3.h" #include "TLorentzVector.h" #include "TMath.h" #include #include #include #include using namespace std; struct MissingETTags {//copied from MissingETEvent/MissingETComposition -- changed tag to Tag to avoid potential conflicts enum Tags { UNKNOWN = 0x0000, DEFAULT = 0x0001, SPECTRO = 0x0002, TRACK = 0x0004, REFMUON = 0x0008, MUID = 0x0010, EFLOW_CLUSTER = 0x0020 //NEXT_COMES = 0x0040, //THEN = 0x0080, //AND_THEN = 0x0100, }; //isDEFAULT means use default pt and no other bits are set static bool isDEFAULT(unsigned short tag) { return tag == DEFAULT; } //usesDEFAULT means use default pt but other bits could also be set static bool usesDEFAULT(unsigned short tag) { return tag & DEFAULT; } static bool usesSPECTRO(unsigned short tag) { return tag & SPECTRO; } static bool usesTRACK(unsigned short tag) { return tag & TRACK; } static bool usesREFMUON(unsigned short tag) { return tag & REFMUON; } static bool usesMUID(unsigned short tag) { return tag & MUID; } static bool usesEFLOW_CLUSTER(unsigned short tag) { return tag & EFLOW_CLUSTER; } static void setUsesDEFAULT(unsigned short &tag) { tag = tag | DEFAULT;} static void setUsesSPECTRO(unsigned short &tag) { tag = tag | SPECTRO;} static void setUsesTRACK(unsigned short &tag) { tag = tag | TRACK;} static void setUsesREFMUON(unsigned short &tag) { tag = tag | REFMUON;} static void setUsesMUID(unsigned short &tag) { tag = tag | MUID;} static void setUsesEFLOW_CLUSTER(unsigned short &tag) { tag = tag | EFLOW_CLUSTER;} }; class METObject : public TNamed { public: METObject(){m_etx = 0.0; m_ety = 0.0; m_sumet = 0.0; m_et = -1.0; m_significance = 0; m_isValid = false;}//will return false until changed, preferably after etx/ety/sumet are set METObject(float etx, float ety, float sumet){m_significance = 0; m_sumet = sumet; m_etx = etx; m_ety = ety; m_et = -1.0; m_isValid = true;} ~METObject(){} float etx() {return m_etx;} float ety() {return m_ety;} float sumet() {return m_sumet;} float phi() {return atan2(m_ety, m_etx);} float et() {return ((m_et < 0) ? sqrt(m_etx*m_etx + m_ety*m_ety) : m_et);} float sig() {return et()/(.5*TMath::Sqrt(m_sumet));} float significance(){return m_significance;} //for the more complex MET significance bool isValid(){return m_isValid;} void setEtx(float _etx){m_etx = _etx;} void setEty(float _ety){m_ety = _ety;} void setSumet(float _sumet){m_sumet = _sumet;} void setEt(float _et){m_et = _et;} //don't do this unless you know what you're doing, it's mostly for systematic diffs. if you're doing actually MET let etx/ety compute et void setBase(float etx, float ety, float sumet){m_sumet = sumet; m_etx = etx; m_ety = ety;} void setSignificance(float sig){m_significance = sig;} void setIsValid(bool status){m_isValid = status;} private: float m_sumet; float m_etx; float m_ety; float m_et; //this is mostly for return systematic diffs, i.e., (up - down)/none float m_significance; bool m_isValid; friend class METUtility; }; /////////////////////////////////////////////////////////////////////////////////// class PhysicsObject : public TNamed { public: PhysicsObject(){m_relativeResolution = -1.0;} ~PhysicsObject(){} void setMomenergy(float pT, float eta, float phi, float E, string caseFlag="default");//{m_momenergy->SetPtEtaPhiE(pT, eta, phi, E);} void setWeights(float wex, float wey, float wet){m_weights.SetXYZ(wex, wey, wet);} void setStatusCode(unsigned int status){m_statusWord = status;} void setEnergyUncertainty(float energyUp, float energyDown, string caseFlag="default");//{m_relEnergyUncertainty.first = energyUp; m_relEnergyUncertainty.second = energyDown;} void setResolution(float res); void setResShift(float resUp, float resDown, string caseFlag="default"); // void setIsMuon(bool status){m_isMuon = status;} void setIndex(int index){m_index = index;} float E(string caseFlag="default"); float Et(string caseFlag="default"); float Pt(string caseFlag="default"); float Px(string caseFlag="default"); float Py(string caseFlag="default"); float phi(string caseFlag="default"); float eta(string caseFlag="default"); float wex(){return m_weights.x();} float wey(){return m_weights.y();} float wet(){return m_weights.z();} unsigned int statusWord(){return m_statusWord;} pair resShift(string caseFlag="default"); pair energyShift(string caseFlag="default"); float resolution(); unsigned int index(){return m_index;} private: TLorentzVector m_momenergy; TLorentzVector m_secondaryMomenergy; TVector3 m_weights; unsigned int m_statusWord; float m_relativeResolution; unsigned int m_index; //used for keeping track of uncertainties and weights for in vector > pair m_relEnergyUncertainty; pair m_relativeResolutionShift; //bool m_isMuon; //muons have different pts, combined, track, spectro //let's just ComboID in m_relativeResolutionShift pair m_relativeResolutionComboMS; pair m_relativeResolutionSpectro; friend class METUtility; }; class METUtility : public TNamed { public: METUtility(bool verbose = false); METUtility(bool doRefEle, bool doRefGamma, bool doRefTau, bool doRefJet, bool doSoftJets, bool doRefMuon, bool doMuonTotal, bool doCellOut, bool doCellOutEflow, bool isMuid, double softJetCut, bool verbose=false); ~METUtility(){} //objects to read things out METObject getMissingET(string term, string systematic="none"); METObject deltaMissingET(string term, string systematics = "All"); METObject absDeltaMissingET(string term, string systematics = "All"); METObject MissingETHelper(string term, string systematic="none"); //objects to set things up void setObjects(string type, vector *pT, vector *eta, vector *phi, vector *E, vector > *wet, vector > *wex, vector > *wey, vector > *statusWord); void setObjects(string type, vector *pT, vector *eta, vector *phi, vector *E, vector *wet, vector *wex, vector *wey, vector *statusWord); void setObjectsHelper(string type, vector pT, vector eta, vector phi, vector E, vector > wet, vector > wex, vector > wey, vector > statusWord); void setObjectsHelper(string type, vector pT, vector eta, vector phi, vector E,vector wet, vector wex, vector wey, vector statusWord); void setObjectEnergyUncertainties(string type, vector energyUp, vector energyDown); void setObjectEnergyUncertaintiesHelper(vector objects, vector energyUp, vector energyDown, string caseFlag="default"); void setObjectResolutionShift(string type, vector resUp, vector resDown); void setObjectResolutionShiftHelper(vector objects, vector resUp, vector resDown, string caseFlag="default"); void setObjectResolutions(string type, vector resolutions); void setObjectResolutionsHelper(vector objects, vector resolutions, string caseFlag="default"); void setObjectMomenta(string type, vector pT, vector eta, vector phi, vector E); void setObjectMomentaHelper(vector objects, vector pT, vector eta, vector phi, vector E, string caseFlag ="default"); void setMETTerm(string term, float _etx, float _ety, float _sumet); void setSoftJetCut(float cut){m_softJetCut = cut;} void setIsMuid(bool status){m_isMuid = status;} void setVerbosity(bool status){m_verbose = status;} void setCellFix(bool status){m_doCellFix = status;} void doSignificance(bool status){m_doSignificance = status;} void doForwardEtaCut(bool status){m_doForwardEtaCut = status;} void setPileUpUncertainty(double uncert){m_pileUpUncertainty = uncert;} void setClusterDefaults(bool energyStat, bool resStat=false){m_useStandardClusterRes = resStat; m_useStandardClusterEnergySigma = energyStat;} void defineMissingET(bool doRefEle, bool doRefGamma, bool doRefTau, bool doRefJet, bool doSoftJets, bool doRefMuon, bool doMuonTotal, bool doCellOut, bool doCellOutEflow); float METSignificance(string systematic); vector GetObjects(std::string objectName); METObject RefEle(string systematic); METObject RefGamma(string systematic); METObject RefTau(string systematic); METObject RefJet(string systematic); METObject RefMuon(string systematic); METObject MuonTotal(string systematic); METObject CellOut(string systematic); METObject CellOutEflow(string systematic); METObject SoftJets(string systematic); ///helper functions to deal with odd variables void setJetParameters(vector *pT, vector *eta, vector *phi, vector *E, vector > *wet, vector > *wex, vector > *wey, vector > *statusWord); void setElectronParameters(vector *pT, vector *eta, vector *phi, vector > *wet, vector > *wex, vector > *wey, vector > *statusWord); void setPhotonParameters(vector *pT, vector *eta, vector *phi, vector > *wet, vector > *wex, vector > *wey, vector > *statusWord); void setTauParameters(vector *pT, vector *eta, vector *phi, vector > *wet, vector > *wex, vector > *wey, vector > *statusWord); void setClusterParameters(vector *pT, vector *eta, vector *phi, vector *E, vector > *wet, vector > *wex, vector > *wey, vector > *statusWord); void setTrackParameters(vector *pT, vector *eta, vector *phi, vector *E, vector > *wet, vector > *wex, vector > *wey, vector > *statusWord); void setMuonParameters(vector *pT, vector *eta, vector *phi, vector > *wet, vector > *wex, vector > *wey, vector > *statusWord); void setExtraMuonParameters(vector *qOverPSpectro, vector *thetaSpectro, vector *phiSpectro, vector *charge); void setExtraMuonParameters(vector *mu_staco_ms_pt, vector *thetaSpectro, vector *phiSpectro); void setExtraJetParameters(vector *moment, vector *mass, vector *eta, vector *phi); void setJetParameters(vector *pT, vector *eta, vector *phi, vector *E, vector *wet, vector *wex, vector *wey, vector *statusWord); void setElectronParameters(vector *pT, vector *eta, vector *phi, vector *wet, vector *wex, vector *wey, vector *statusWord); void setPhotonParameters(vector *pT, vector *eta, vector *phi, vector *wet, vector *wex, vector *wey, vector *statusWord); void setTauParameters(vector *pT, vector *eta, vector *phi, vector *wet, vector *wex, vector *wey, vector *statusWord); void setClusterParameters(vector *pT, vector *eta, vector *phi, vector *E, vector *wet, vector *wex, vector *wey, vector *statusWord); void setTrackParameters(vector *pT, vector *eta, vector *phi, vector *E, vector *wet, vector *wex, vector *wey, vector *statusWord); void setMuonParameters(vector *pT, vector *eta, vector *phi, vector *wet, vector *wex, vector *wey, vector *statusWord); vector getPhysicsObject(std::string type="jets"); private: vector m_jets; vector m_electrons; vector m_muons; vector m_taus; vector m_clusters; vector m_tracks; vector m_photons; METObject m_cellOut; //these hold the original inputs, for instance cell out we don't want to feed a systematically altered term to the next systematic METObject m_cellOutEflow; METObject m_softJets; METObject m_refMuon; METObject m_refJet; METObject m_refEle; METObject m_refTau; METObject m_refGamma; METObject m_muonTotal; METObject m_scaled_cellOut; //these hold the current scaled MET term METObject m_scaled_cellOutEflow; METObject m_scaled_softJets; METObject m_scaled_refMuon; METObject m_scaled_refJet; METObject m_scaled_refEle; METObject m_scaled_refTau; METObject m_scaled_refGamma; METObject m_scaled_muonTotal; METObject m_refFinal; //control variables //check whether momenta are set bool m_jetsMomentaSet; bool m_photonsMomentaSet; bool m_electronsMomentaSet; bool m_muonsMomentaSet; bool m_tausMomentaSet; bool m_clustersMomentaSet; bool m_trackMomentaSet; //check whether uncertainties are set bool m_jetsUncertaintiesSet; bool m_photonsUncertaintiesSet; bool m_electronsUncertaintiesSet; bool m_muonsUncertaintiesSet; bool m_muonsTrackUncertaintiesSet; bool m_muonsSpectroUncertaintiesSet; bool m_tausUncertaintiesSet; bool m_clustersUncertaintiesSet; bool m_trackUncertaintiesSet; bool m_muonsComboIDUncertaintiesSet; bool m_muonsComboMSUncertaintiesSet; //check whether resShifts are set bool m_jetsResShiftsSet; bool m_photonsResShiftsSet; bool m_electronsResShiftsSet; bool m_muonsResShiftsSet; bool m_muonsTrackResShiftsSet; bool m_muonsSpectroResShiftsSet; bool m_muonsComboIDResShiftsSet; bool m_muonsComboMSResShiftsSet; bool m_tausResShiftsSet; bool m_clustersResShiftsSet; bool m_tracksResShiftsSet; //check whether resolutions are set bool m_jetsResolutionsSet; bool m_photonsResolutionsSet; bool m_electronsResolutionsSet; bool m_muonsResolutionsSet; bool m_muonsTrackResolutionsSet; bool m_muonsSpectroResolutionsSet; bool m_muonsComboIDResolutionsSet; bool m_muonsComboMSResolutionsSet; bool m_tausResolutionsSet; bool m_clustersResolutionsSet; bool m_tracksResolutionsSet; //which terms to do bool m_doRefEle; bool m_doRefGamma; bool m_doRefTau; bool m_doRefJet; bool m_doRefMuon; bool m_doMuonTotal; bool m_doSoftJets; bool m_doCellOut; bool m_doCellOutEflow; double m_pileUpUncertainty; bool m_doForwardEtaCut; bool m_doCellFix; bool m_doCellFixOverride;//this is the manual shutoff, if true cellfix is allowed, if false, cellfix is not allowed at all this way we can ovreride it for release 17 even if a new tag of this tool isn't immediatly available float m_softJetCut; //the cut used to put jets in RefJet or SoftJets bool m_isMuid; //are muons muid bool m_useStandardClusterRes; //switches to do the default cluster resolution and energy bool m_useStandardClusterEnergySigma; bool m_doSignificance; bool m_verbose; };//end of METUtilityclass #endif // _METUTILITY_