//////////////////////////////////////////////////////////////////////////
// //
// TMBTree Met class //
// //
//////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <fstream>
#include <cmath>
#include "tmb_tree/TMBMet.hpp"
ClassImp(TMBMet)
//_____________________________________________________________________________
TMBMet::TMBMet():
_MET(0.), _MEx(0.), _MEy(0.), _ScalarET(0.), _MET_noeta(0.), _MEx_noeta(0.),
_MEy_noeta(0.), _ScalarET_noeta(0.), _MET_weta(0.), _MEx_weta(0.),
_MEy_weta(0.), _ScalarET_weta(0.), _nrings(0),
_RingEMx(NULL), _RingEMy(NULL), _RingHDx(NULL), _RingHDy(NULL) , _Zvertex(999.)
{};
TMBMet::TMBMet( const TMBMet & met ):TObject()
{
_MET = met._MET;
_MEx = met._MEx;
_MEy = met._MEy;
_ScalarET = met._ScalarET;
_MET_noeta = met._MET_noeta;
_MEx_noeta = met._MEx_noeta;
_MEy_noeta = met._MEy_noeta;
_ScalarET_noeta = met._ScalarET_noeta;
_MET_weta = met._MET_weta;
_MEx_weta = met._MEx_weta;
_MEy_weta = met._MEy_weta;
_ScalarET_weta = met._ScalarET_weta;
_Zvertex = met._Zvertex;
_nrings = met._nrings;
if ( _nrings > 0 )
{
if ( met._RingEMx )
{
_RingEMx = new Float_t[_nrings];
for ( Int_t i = 0; i < _nrings; ++i) _RingEMx[i] = met._RingEMx[i];
}
if ( met._RingEMy )
{
_RingEMy = new Float_t[_nrings];
for ( Int_t i = 0; i < _nrings; ++i) _RingEMy[i] = met._RingEMy[i];
}
if ( met._RingHDx )
{
_RingHDx = new Float_t[_nrings];
for ( Int_t i = 0; i < _nrings; ++i) _RingHDx[i] = met._RingHDx[i];
}
if ( met._RingHDy )
{
_RingHDy = new Float_t[_nrings];
for ( Int_t i = 0; i < _nrings; ++i) _RingHDy[i] = met._RingHDy[i];
}
}
//Set1
_visMuX = met._visMuX;
_visMuY = met._visMuY;
_visMuPt = met._visMuPt;
_SETT = met._SETT;
_METTx = met._METTx;
_METTy = met._METTy;
_METT = met._METT;
_SETTM = met._SETTM;
_METTMx = met._METTMx;
_METTMy = met._METTMy;
_METTM = met._METTM;
_SETTAS = met._SETTAS;
_VETTASx = met._VETTASx;
_VETTASy = met._VETTASy;
_VETTAS = met._VETTAS;
_SETTBS = met._SETTBS;
_VETTBSx = met._VETTBSx;
_VETTBSy = met._VETTBSy;
_VETTBS = met._VETTBS;
_SETTAN = met._SETTAN;
_VETTANx = met._VETTANx;
_VETTANy = met._VETTANy;
_VETTAN = met._VETTAN;
_SETTBN = met._SETTBN;
_VETTBNx = met._VETTBNx;
_VETTBNy = met._VETTBNy;
_VETTBN = met._VETTBN;
_SETC = met._SETC;
_METCx = met._METCx;
_METCy = met._METCy;
_METC = met._METC;
_SETCM = met._SETCM;
_METCMx = met._METCMx;
_METCMy = met._METCMy;
_METCM = met._METCM;
// Set2
_SETCAS = met._SETCAS;
_VETCASx = met._VETCASx;
_VETCASy = met._VETCASy;
_VETCAS = met._VETCAS;
_SETCBS = met._SETCBS;
_VETCBSx = met._VETCBSx;
_VETCBSy = met._VETCBSy;
_VETCBS = met._VETCBS;
_SETCAN = met._SETCAN;
_VETCANx = met._VETCANx;
_VETCANy = met._VETCANy;
_VETCAN = met._VETCAN;
_SETCBN = met._SETCBN;
_VETCBNx = met._VETCBNx;
_VETCBNy = met._VETCBNy;
_VETCBN = met._VETCBN;
_SETICD = met._SETICD;
_VETICDx = met._VETICDx;
_VETICDy = met._VETICDy;
_VETICD = met._VETICD;
_SETNADA = met._SETNADA;
_VETNADAx = met._VETNADAx;
_VETNADAy = met._VETNADAy;
_VETNADA = met._VETNADA;
_VETMUONx = met._VETMUONx;
_VETMUONy = met._VETMUONy;
_VETMUONz = met._VETMUONz;
_VETMUON = met._VETMUON;
_VETCx = met._VETCx;
_VETCy = met._VETCy;
_VETCMx = met._VETCMx;
_VETCMy = met._VETCMy;
_SETD = met._SETD;
_VETDx = met._VETDx;
_VETDy = met._VETDy;
_METD = met._METD;
//Set3
_SETDM = met._SETDM;
_VETDMx = met._VETDMx;
_VETDMy = met._VETDMy;
_METDM = met._METDM;
_SETEM = met._SETEM;
_VETEMx = met._VETEMx;
_VETEMy = met._VETEMy;
_METEM = met._METEM;
_SETMG = met._SETMG;
_VETMGx = met._VETMGx;
_VETMGy = met._VETMGy;
_METMG = met._METMG;
_SETFH = met._SETFH;
_VETFHx = met._VETFHx;
_VETFHy = met._VETFHy;
_METFH = met._METFH;
_SETCH = met._SETCH;
_VETCHx = met._VETCHx;
_VETCHy = met._VETCHy;
_METCH = met._METCH;
_EDge = met._EDge;
_SETED = met._SETED;
_VETEDx = met._VETEDx;
_VETEDy = met._VETEDy;
_METED = met._METED;
_SETNG = met._SETNG;
_VETNGx = met._VETNGx;
_VETNGy = met._VETNGy;
_METNG = met._METNG;
_SET42 = met._SET42;
_VET42x = met._VET42x;
_VET42y = met._VET42y;
_MET42 = met._MET42;
//Set4
_DMETACHx = met._DMETACHx;
_DMETACHy = met._DMETACHy;
_SETACH = met._SETACH;
_DMETBCHx = met._DMETBCHx;
_DMETBCHy = met._DMETBCHy;
_SETBCH = met._SETBCH;
_DMETAELx = met._DMETAELx;
_DMETAELy = met._DMETAELy;
_SETAEL = met._SETAEL;
_DMETBELx = met._DMETBELx;
_DMETBELy = met._DMETBELy;
_SETBEL = met._SETBEL;
_DMETAJESx = met._DMETAJESx;
_DMETAJESy = met._DMETAJESy;
_SETAJES = met._SETAJES;
_DMETBJESx = met._DMETBJESx;
_DMETBJESy = met._DMETBJESy;
_SETBJES = met._SETBJES;
_DMETAMUx = met._DMETAMUx;
_DMETAMUy = met._DMETAMUy;
_SETAMU = met._SETAMU;
_DMETBMUx = met._DMETBMUx;
_DMETBMUy = met._DMETBMUy;
_SETBMU = met._SETBMU;
_DMETAUEx = met._DMETAUEx;
_DMETAUEy = met._DMETAUEy;
_SETAUE = met._SETAUE;
_DMETBUEx = met._DMETBUEx;
_DMETBUEy = met._DMETBUEy;
_SETBUE = met._SETBUE;
_DMETABJx = met._DMETABJx;
_DMETABJy = met._DMETABJy;
_SETABJ = met._SETABJ;
_DMETBBJx = met._DMETBBJx;
_DMETBBJy = met._DMETBBJy;
_SETBBJ = met._SETBBJ;
}
TMBMet::TMBMet(Float_t MET, Float_t MEx, Float_t MEy, Float_t ScalarET,
Float_t MET_noeta, Float_t MEx_noeta, Float_t MEy_noeta, Float_t ScalarET_noeta,
Float_t MET_weta, Float_t MEx_weta, Float_t MEy_weta, Float_t ScalarET_weta,
Int_t nrings, const Float_t *RingEMx, const Float_t *RingEMy,
const Float_t *RingHDx, const Float_t *RingHDy, Float_t Zvertex)
{
Set(MET, MEx, MEy, ScalarET,
MET_noeta, MEx_noeta, MEy_noeta, ScalarET_noeta,
MET_weta, MEx_weta, MEy_weta, ScalarET_weta,
nrings, RingEMx, RingEMy,
RingHDx, RingHDy, Zvertex);
}
void TMBMet::Set(Float_t MET, Float_t MEx, Float_t MEy, Float_t ScalarET,
Float_t MET_noeta, Float_t MEx_noeta, Float_t MEy_noeta, Float_t ScalarET_noeta,
Float_t MET_weta, Float_t MEx_weta, Float_t MEy_weta, Float_t ScalarET_weta,
Int_t nrings, const Float_t *RingEMx, const Float_t *RingEMy,
const Float_t *RingHDx, const Float_t *RingHDy, Float_t Zvertex)
{
_MET = MET;
_MEx = MEx;
_MEy = MEy;
_ScalarET = ScalarET;
_MET_noeta = MET_noeta;
_MEx_noeta = MEx_noeta;
_MEy_noeta = MEy_noeta;
_ScalarET_noeta = ScalarET_noeta;
_MET_weta = MET_weta;
_MEx_weta = MEx_weta;
_MEy_weta = MEy_weta;
_ScalarET_weta = ScalarET_weta;
// cout << " In TMBMet::Set - variables set except rings " << endl;
_nrings = nrings;
// cout << " Number of rings in TMBMetSet: " << _nrings << endl;
//delete [] _RingEMx;
//delete [] _RingEMy;
//delete [] _RingHDx;
//delete [] _RingHDy;
if ( _RingEMx ) delete [] _RingEMx;
if ( _RingEMy ) delete [] _RingEMy;
if ( _RingHDx ) delete [] _RingHDx;
if ( _RingHDy ) delete [] _RingHDy;
if (RingEMx) _RingEMx = new Float_t[_nrings];
if (RingEMy) _RingEMy = new Float_t[_nrings];
if (RingHDx) _RingHDx = new Float_t[_nrings];
if (RingHDy) _RingHDy = new Float_t[_nrings];
for (Int_t i=0; i<nrings; i++)
{
if (RingEMx) _RingEMx[i] = RingEMx[i];
if (RingEMy) _RingEMy[i] = RingEMy[i];
if (RingHDx) _RingHDx[i] = RingHDx[i];
if (RingHDy) _RingHDy[i] = RingHDy[i];
}
_Zvertex = Zvertex;
// cout << "In TMBMet::Set - rings are set; _Zvertex: " << _Zvertex << endl;
}
void TMBMet::Set1(Float_t visMuX, Float_t visMuY, Float_t visMuPt,
Float_t SETT, Float_t METTx, Float_t METTy, Float_t METT,
Float_t SETTM, Float_t METTMx, Float_t METTMy, Float_t METTM,
Float_t SETTAS, Float_t VETTASx, Float_t VETTASy, Float_t VETTAS,
Float_t SETTBS, Float_t VETTBSx, Float_t VETTBSy, Float_t VETTBS,
Float_t SETTAN, Float_t VETTANx, Float_t VETTANy, Float_t VETTAN,
Float_t SETTBN, Float_t VETTBNx, Float_t VETTBNy, Float_t VETTBN,
Float_t SETC, Float_t METCx, Float_t METCy, Float_t METC,
Float_t SETCM, Float_t METCMx, Float_t METCMy, Float_t METCM)
{
_visMuX = visMuX;
_visMuY = visMuY;
_visMuPt = visMuPt;
_SETT = SETT;
_METTx = METTx;
_METTy = METTy;
_METT = METT;
_SETTM = SETTM;
_METTMx = METTMx;
_METTMy = METTMy;
_METTM = METTM;
_SETTAS = SETTAS;
_VETTASx = VETTASx;
_VETTASy = VETTASy;
_VETTAS = VETTAS;
_SETTBS = SETTBS;
_VETTBSx = VETTBSx;
_VETTBSy = VETTBSy;
_VETTBS = VETTBS;
_SETTAN = SETTAN;
_VETTANx = VETTANx;
_VETTANy = VETTANy;
_VETTAN = VETTAN;
_SETTBN = SETTBN;
_VETTBNx = VETTBNx;
_VETTBNy = VETTBNy;
_VETTBN = VETTBN;
_SETC = SETC;
_METCx = METCx;
_METCy = METCy;
_METC = METC;
_SETCM = SETCM;
_METCMx = METCMx;
_METCMy = METCMy;
_METCM = METCM;
}
void TMBMet::Set2(Float_t SETCAS, Float_t VETCASx, Float_t VETCASy, Float_t VETCAS,
Float_t SETCBS, Float_t VETCBSx, Float_t VETCBSy, Float_t VETCBS,
Float_t SETCAN, Float_t VETCANx, Float_t VETCANy, Float_t VETCAN,
Float_t SETCBN, Float_t VETCBNx, Float_t VETCBNy, Float_t VETCBN,
Float_t SETICD, Float_t VETICDx, Float_t VETICDy, Float_t VETICD,
Float_t SETNADA, Float_t VETNADAx, Float_t VETNADAy, Float_t VETNADA,
Float_t VETMUONx, Float_t VETMUONy, Float_t VETMUONz, Float_t VETMUON,
Float_t VETCx, Float_t VETCy, Float_t VETCMx,Float_t VETCMy,
Float_t SETD, Float_t VETDx, Float_t VETDy, Float_t METD)
{
_SETCAS = SETCAS;
_VETCASx = VETCASx;
_VETCASy = VETCASy;
_VETCAS = VETCAS;
_SETCBS = SETCBS;
_VETCBSx = VETCBSx;
_VETCBSy = VETCBSy;
_VETCBS = VETCBS;
_SETCAN = SETCAN;
_VETCANx = VETCANx;
_VETCANy = VETCANy;
_VETCAN = VETCAN;
_SETCBN = SETCBN;
_VETCBNx = VETCBNx;
_VETCBNy = VETCBNy;
_VETCBN = VETCBN;
_SETICD = SETICD;
_VETICDx = VETICDx;
_VETICDy = VETICDy;
_VETICD = VETICD;
_SETNADA = SETNADA;
_VETNADAx = VETNADAx;
_VETNADAy = VETNADAy;
_VETNADA = VETNADA;
_VETMUONx = VETMUONx;
_VETMUONy = VETMUONy;
_VETMUONz = VETMUONz;
_VETMUON = VETMUON;
_VETCx = VETCx;
_VETCy = VETCy;
_VETCMx = VETCMx;
_VETCMy = VETCMy;
_SETD = SETD;
_VETDx = VETDx;
_VETDy = VETDy;
_METD = METD;
}
void TMBMet::Set3( Float_t SETDM, Float_t VETDMx, Float_t VETDMy, Float_t METDM,
Float_t SETEM, Float_t VETEMx, Float_t VETEMy, Float_t METEM,
Float_t SETMG, Float_t VETMGx, Float_t VETMGy, Float_t METMG,
Float_t SETFH, Float_t VETFHx, Float_t VETFHy, Float_t METFH,
Float_t SETCH, Float_t VETCHx, Float_t VETCHy, Float_t METCH,
Float_t EDge, Float_t SETED, Float_t VETEDx, Float_t VETEDy, Float_t METED,
Float_t SETNG, Float_t VETNGx, Float_t VETNGy, Float_t METNG,
Float_t SET42, Float_t VET42x, Float_t VET42y, Float_t MET42,
Float_t METICD, Float_t METNADA, Float_t METMUON)
{
_SETDM = SETDM;
_VETDMx = VETDMx;
_VETDMy = VETDMy;
_METDM = METDM;
_SETEM = SETEM;
_VETEMx = VETEMx;
_VETEMy = VETEMy;
_METEM = METEM;
_SETMG = SETMG;
_VETMGx = VETMGx;
_VETMGy = VETMGy;
_METMG = METMG;
_SETFH = SETFH;
_VETFHx = VETFHx;
_VETFHy = VETFHy;
_METFH = METFH;
_SETCH = SETCH;
_VETCHx = VETCHx;
_VETCHy = VETCHy;
_METCH = METCH;
_EDge = EDge;
_SETED = SETED;
_VETEDx = VETEDx;
_VETEDy = VETEDy;
_METED = METED;
_SETNG = SETNG;
_VETNGx = VETNGx;
_VETNGy = VETNGy;
_METNG = METNG;
_SET42 = SET42;
_VET42x = VET42x;
_VET42y = VET42y;
_MET42 = MET42;
_METICD=METICD;
_METNADA=METNADA;
_METMUON=METMUON;
}
void TMBMet::Set4( Float_t DMETACHx, Float_t DMETACHy, Float_t SETACH,
Float_t DMETBCHx, Float_t DMETBCHy, Float_t SETBCH,
Float_t DMETAELx, Float_t DMETAELy, Float_t SETAEL,
Float_t DMETBELx, Float_t DMETBELy, Float_t SETBEL,
Float_t DMETAJESx, Float_t DMETAJESy, Float_t SETAJES,
Float_t DMETBJESx, Float_t DMETBJESy, Float_t SETBJES,
Float_t DMETAMUx, Float_t DMETAMUy, Float_t SETAMU,
Float_t DMETBMUx, Float_t DMETBMUy, Float_t SETBMU,
Float_t DMETAUEx, Float_t DMETAUEy, Float_t SETAUE,
Float_t DMETBUEx, Float_t DMETBUEy, Float_t SETBUE,
Float_t DMETABJx, Float_t DMETABJy, Float_t SETABJ,
Float_t DMETBBJx, Float_t DMETBBJy, Float_t SETBBJ){
_DMETACHx = DMETACHx;
_DMETACHy = DMETACHy;
_SETACH = SETACH;
_DMETBCHx = DMETBCHx;
_DMETBCHy = DMETBCHy;
_SETBCH = SETBCH;
_DMETAELx = DMETAELx;
_DMETAELy = DMETAELy;
_SETAEL = SETAEL;
_DMETBELx = DMETBELx;
_DMETBELy = DMETBELy;
_SETBEL = SETBEL;
_DMETAJESx = DMETAJESx;
_DMETAJESy = DMETAJESy;
_SETAJES = SETAJES;
_DMETBJESx = DMETBJESx;
_DMETBJESy = DMETBJESy;
_SETBJES = SETBJES;
_DMETAMUx = DMETAMUx;
_DMETAMUy = DMETAMUy;
_SETAMU = SETAMU;
_DMETBMUx = DMETBMUx;
_DMETBMUy = DMETBMUy;
_SETBMU = SETBMU;
_DMETAUEx = DMETAUEx;
_DMETAUEy = DMETAUEy;
_SETAUE = SETAUE;
_DMETBUEx = DMETBUEx;
_DMETBUEy = DMETBUEy;
_SETBUE = SETBUE;
_DMETABJx = DMETABJx;
_DMETABJy = DMETABJy;
_SETABJ = SETABJ;
_DMETBBJx = DMETBBJx;
_DMETBBJy = DMETBBJy;
_SETBBJ = SETBBJ;
}
TMBMet::~TMBMet()
{
// cout << "Entering TMBMet destructor " << endl;
if ( _RingEMx ) delete [] _RingEMx;
if ( _RingEMy ) delete [] _RingEMy;
if ( _RingHDx ) delete [] _RingHDx;
if ( _RingHDy ) delete [] _RingHDy;
// cout << "Leaving TMBMet destructor " << endl;
}
// return missing ET
// ...no ET or Eta limits
Float_t TMBMet::getMET() const
{
return _MET;
// return _METC;
}
// ...ET limit only
Float_t TMBMet::getMET_noeta() const
{
return _MET_noeta;
}
// ...ET and Eta limits
Float_t TMBMet::getMET_weta() const
{
return _MET_weta;
}
// return scalar ET
// ...no ET or Eta limit
Float_t TMBMet::getScalarET() const
{
// return _ScalarET;
return _SETC;
}
// ...ET limit only
Float_t TMBMet::getScalarET_noeta() const
{
return _ScalarET_noeta;
}
// ...ET and Eta limits
Float_t TMBMet::getScalarET_weta() const
{
return _ScalarET_weta;
}
// return missing ETx, ETy
// ...no ET or Eta limits
void TMBMet::getMExy(Float_t &MEx, Float_t &MEy) const
{
MEx = _MEx;
MEy = _MEy;
return;
}
// ...ET limit only
void TMBMet::getMExy_noeta(Float_t &MEx_noeta, Float_t &MEy_noeta) const
{
MEx_noeta = _MEx_noeta;
MEy_noeta = _MEy_noeta;
return;
}
// ...ET and Eta limits
void TMBMet::getMExy_weta(Float_t &MEx_weta, Float_t &MEy_weta) const
{
MEx_weta = _MEx_weta;
MEy_weta = _MEy_weta;
return;
}
// return Rings EMx, EMy, HDx, HDy
void TMBMet::getRings(const Float_t *&RingEMx, const Float_t *&RingEMy,
const Float_t *&RingHDx, const Float_t *&RingHDy) const
{
RingEMx = _RingEMx;
RingEMy = _RingEMy;
RingHDx = _RingHDx;
RingHDy = _RingHDy;
return;
}
Int_t TMBMet::numRings() const
{
return _nrings;
}
// return Z vertex
void TMBMet::getZvertex(Float_t &Zvertex) const
{
Zvertex = _Zvertex;
return;
}
void TMBMet::getVisMu(Float_t &visMuX, Float_t &visMuY, Float_t &visMuPt) const
{
visMuX=_visMuX;
visMuY=_visMuY;
visMuPt=_visMuPt;
return;
}
///////////////////////////////////////////////////////////////////////
//// begin methods to set/get p11-p14 variables
//
//// CAL + ICD Towers
//
//
void TMBMet::getMETT(Float_t &SETT, Float_t &METTx, Float_t &METTy, Float_t &METT) const
{
SETT = _SETT;
METTx = _METTx;
METTy = _METTy;
METT = _METT;
return;
}
void TMBMet::getMETTM(Float_t &SETTM, Float_t &METTMx, Float_t &METTMy, Float_t &METTM) const
{
SETTM = _SETTM;
METTMx = _METTMx;
METTMy = _METTMy;
METTM = _METTM;
return;
}
// CAL + ICD Towers Above eta limit, above cell threshold (Signal)
void TMBMet::getVETTAS(Float_t &SETTAS, Float_t &VETTASx,
Float_t &VETTASy, Float_t &VETTAS) const
{
SETTAS = _SETTAS;
VETTASx = _VETTASx;
VETTASy = _VETTASy;
VETTAS = _VETTAS;
return;
}
// CAL + ICD Towers Below eta limit, above cell threshold (Signal)
void TMBMet::getVETTBS(Float_t &SETTBS, Float_t &VETTBSx,
Float_t &VETTBSy, Float_t &VETTBS) const
{
SETTBS = _SETTBS;
VETTBSx = _VETTBSx;
VETTBSy = _VETTBSy;
VETTBS = _VETTBS;
return;
}
// CAL + ICD Towers Above eta limit, below cell threshold (Noise)
void TMBMet::getVETTAN(Float_t &SETTAN, Float_t &VETTANx,
Float_t &VETTANy, Float_t &VETTAN) const
{
SETTAN = _SETTAN;
VETTANx = _VETTANx;
VETTANy = _VETTANy;
VETTAN = _VETTAN;
return;
}
// CAL + ICD Towers Below eta limit, below cell threshold (Noise)
void TMBMet::getVETTBN(Float_t &SETTBN, Float_t &VETTBNx,
Float_t &VETTBNy, Float_t &VETTBN) const
{
SETTBN = _SETTBN;
VETTBNx = _VETTBNx;
VETTBNy = _VETTBNy;
VETTBN = _VETTBN;
return;
}
// CAL + ICD Cells
void TMBMet::getMETC(Float_t &SETC, Float_t &METCx, Float_t &METCy, Float_t &METC) const
{
SETC = _SETC;
METCx = _METCx;
METCy = _METCy;
METC = _METC;
return;
}
// CAL + ICD Cells + Muon correction
void TMBMet::getMETCM(Float_t &SETCM, Float_t &METCMx, Float_t &METCMy, Float_t &METCM) const
{
SETCM = _SETCM;
METCMx = _METCMx;
METCMy = _METCMy;
METCM = _METCM;
return;
}
// CAL + ICD Cells Above eta limit, above cell threshold (Signal)
void TMBMet::getVETCAS(Float_t &SETCAS, Float_t &VETCASx,
Float_t &VETCASy, Float_t &VETCAS) const
{
SETCAS = _SETCAS;
VETCASx = _VETCASx;
VETCASy = _VETCASy;
VETCAS = _VETCAS;
return;
}
// CAL + ICD Cells Below eta limit, above cell threshold (Signal)
void TMBMet::getVETCBS(Float_t &SETCBS, Float_t &VETCBSx,
Float_t &VETCBSy, Float_t &VETCBS) const
{
SETCBS = _SETCBS;
VETCBSx = _VETCBSx;
VETCBSy = _VETCBSy;
VETCBS = _VETCBS;
return;
}
// CAL + ICD Cells Above eta limit, below cell threshold (Noise)
void TMBMet::getVETCAN(Float_t &SETCAN, Float_t &VETCANx,
Float_t &VETCANy, Float_t &VETCAN) const
{
SETCAN = _SETCAN;
VETCANx = _VETCANx;
VETCANy = _VETCANy;
VETCAN = _VETCAN;
return;
}
// CAL + ICD Cells Below eta limit, below cell threshold (Noise)
void TMBMet::getVETCBN(Float_t &SETCBN, Float_t &VETCBNx,
Float_t &VETCBNy, Float_t &VETCBN) const
{
SETCBN = _SETCBN;
VETCBNx = _VETCBNx;
VETCBNy = _VETCBNy;
VETCBN = _VETCBN;
return;
}
// ICD Cells only
void TMBMet::getVETICD(Float_t &SETICD, Float_t &VETICDx,
Float_t &VETICDy, Float_t &VETICD) const
{
SETICD = _SETICD;
VETICDx = _VETICDx;
VETICDy = _VETICDy;
VETICD = _VETICD;
return;
}
// NADA
void TMBMet::getVETNADA(Float_t &SETNADA, Float_t &VETNADAx,
Float_t &VETNADAy, Float_t &VETNADA) const
{
SETNADA = _SETNADA;
VETNADAx = _VETNADAx;
VETNADAy = _VETNADAy;
VETNADA = _VETNADA;
return;
}
// Muon
void TMBMet::getVETMUON(Float_t &VETMUONx, Float_t &VETMUONy,
Float_t &VETMUONz, Float_t &VETMUON) const
{
VETMUONx = _VETMUONx;
VETMUONy = _VETMUONy;
VETMUONz = _VETMUONz;
VETMUON = _VETMUON;
return;
}
// end methods to set/get p11-p14 variables
//////////////////////////////////////////////////////////////////////
// begin methods to set/get new (p15) variables
// CAL + ICD Cells
void TMBMet::getVETC(Float_t &SETC, Float_t &VETCx, Float_t &VETCy, Float_t &METC) const
{
SETC = _SETC;
VETCx = _VETCx;
VETCy = _VETCy;
METC = _METC;
return;
}
// CAL + ICD Cells + Muon correction
void TMBMet::getVETCM(Float_t &SETCM, Float_t &VETCMx, Float_t &VETCMy, Float_t &METCM) const
{
SETCM = _SETCM;
VETCMx = _VETCMx;
VETCMy = _VETCMy;
METCM = _METCM;
return;
}
// CAL + ICD Cells, no CH
void TMBMet::getVETD(Float_t &SETD, Float_t &VETDx, Float_t &VETDy, Float_t &METD) const
{
SETD = _SETD;
VETDx = _VETDx;
VETDy = _VETDy;
METD = _METD;
return;
}
// CAL + ICD Cells (no CH) + Muon correction
void TMBMet::getVETDM(Float_t &SETDM, Float_t &VETDMx, Float_t &VETDMy, Float_t &METDM) const
{
SETDM = _SETDM;
VETDMx = _VETDMx;
VETDMy = _VETDMy;
METDM = _METDM;
return;
}
// Additonal accessors for missing (and not visible) ET w/out CH
void TMBMet::getMETD(Float_t &SETD, Float_t &METDx, Float_t &METDy, Float_t &METD) const
{
SETD = _SETD;
METDx = -1.0*_VETDx;
METDy = -1.0*_VETDy;
METD = _METD;
return;
}
void TMBMet::getMETDM(Float_t &SETDM, Float_t &METDMx, Float_t &METDMy, Float_t &METDM) const
{
SETDM = _SETDM;
METDMx = -1.0*_VETDMx;
METDMy = -1.0*_VETDMy;
METDM = _METDM;
return;
}
// EM Cells only
void TMBMet::getVETEM(Float_t &SETEM, Float_t &VETEMx,
Float_t &VETEMy, Float_t &METEM) const
{
SETEM = _SETEM;
VETEMx = _VETEMx;
VETEMy = _VETEMy;
METEM = _METEM;
return;
}
// MG Cells only
void TMBMet::getVETMG(Float_t &SETMG, Float_t &VETMGx,
Float_t &VETMGy, Float_t &METMG) const
{
SETMG = _SETMG;
VETMGx = _VETMGx;
VETMGy = _VETMGy;
METMG = _METMG;
return;
}
// FH Cells only
void TMBMet::getVETFH(Float_t &SETFH, Float_t &VETFHx,
Float_t &VETFHy, Float_t &METFH) const
{
SETFH = _SETFH;
VETFHx = _VETFHx;
VETFHy = _VETFHy;
METFH = _METFH;
return;
}
// CH Cells only
void TMBMet::getVETCH(Float_t &SETCH, Float_t &VETCHx,
Float_t &VETCHy, Float_t &METCH) const
{
SETCH = _SETCH;
VETCHx = _VETCHx;
VETCHy = _VETCHy;
METCH = _METCH;
return;
}
// CAL + ICD Cells below eta limit EDge
void TMBMet::getVETED(Float_t &EDGE, Float_t &SETED, Float_t &VETEDx,
Float_t &VETEDy, Float_t &METED) const
{
EDGE = _EDge;
SETED = _SETED;
VETEDx = _VETEDx;
VETEDy = _VETEDy;
METED = _METED;
return;
}
// Negative Cells
void TMBMet::getVETNG(Float_t &SETNG, Float_t &VETNGx,
Float_t &VETNGy, Float_t &METNG) const
{
SETNG = _SETNG;
VETNGx = _VETNGx;
VETNGy = _VETNGy;
METNG = _METNG;
return;
}
// CalT42 Noise Cells
void TMBMet::getVET42(Float_t &SET42, Float_t &VET42x,
Float_t &VET42y, Float_t &MET42) const
{
SET42 = _SET42;
VET42x = _VET42x;
VET42y = _VET42y;
MET42 = _MET42;
return;
}
// CH corrections :
void TMBMet::getDMETACHxy(Float_t &DMETACHx,Float_t &DMETACHy) const
{
DMETACHx=_DMETACHx;DMETACHy=_DMETACHy;
return;
}
void TMBMet::getDMETBCHxy(Float_t &DMETBCHx,Float_t &DMETBCHy) const
{
DMETBCHx=_DMETBCHx;DMETBCHy=_DMETBCHy;
return;
}
Float_t TMBMet::getDMETACH() const { return sqrt(_DMETACHx*_DMETACHx + _DMETACHy*_DMETACHy);}
Float_t TMBMet::getDMETBCH() const { return sqrt(_DMETBCHx*_DMETBCHx + _DMETBCHy*_DMETBCHy);}
Float_t TMBMet::getSETACH() const {return _SETACH;}
Float_t TMBMet::getSETBCH() const {return _SETBCH;}
// Electron corrections
void TMBMet::getDMETAELxy(Float_t &DMETAELx,Float_t &DMETAELy) const
{
DMETAELx=_DMETAELx;DMETAELy=_DMETAELy;
return;
}
void TMBMet::getDMETBELxy(Float_t &DMETBELx,Float_t &DMETBELy) const
{
DMETBELx=_DMETBELx;DMETBELy=_DMETBELy;
return;
}
Float_t TMBMet::getDMETAEL() const {return sqrt(_DMETAELx*_DMETAELx + _DMETAELy*_DMETAELy);}
Float_t TMBMet::getDMETBEL() const {return sqrt(_DMETBELx*_DMETBELx + _DMETBELy*_DMETBELy);}
Float_t TMBMet::getSETAEL() const {return _SETAEL;}
Float_t TMBMet::getSETBEL() const {return _SETBEL;}
// JES corrections :
void TMBMet::getDMETAJESxy(Float_t &DMETAJESx,Float_t &DMETAJESy) const
{
DMETAJESx=_DMETAJESx;DMETAJESy=_DMETAJESy;
return;
}
void TMBMet::getDMETBJESxy(Float_t &DMETBJESx,Float_t &DMETBJESy) const
{
DMETBJESx=_DMETBJESx;DMETBJESy=_DMETBJESy;
return;
}
Float_t TMBMet::getDMETAJES() const {return sqrt(_DMETAJESx*_DMETAJESx + _DMETAJESy*_DMETAJESy);}
Float_t TMBMet::getDMETBJES() const {return sqrt(_DMETBJESx*_DMETBJESx + _DMETBJESy*_DMETBJESy);}
Float_t TMBMet::getSETAJES() const {return _SETAJES;}
Float_t TMBMet::getSETBJES() const {return _SETBJES;}
// Muon corrections :
void TMBMet::getDMETAMUxy(Float_t &DMETAMUx,Float_t &DMETAMUy) const
{
DMETAMUx=_DMETAMUx;DMETAMUy=_DMETAMUy;
return;
}
void TMBMet::getDMETBMUxy(Float_t &DMETBMUx,Float_t &DMETBMUy) const
{
DMETBMUx=_DMETBMUx;DMETBMUy=_DMETBMUy;
return;
}
Float_t TMBMet::getDMETAMU() const {return sqrt(_DMETAMUx*_DMETAMUx + _DMETAMUy*_DMETAMUy);}
Float_t TMBMet::getDMETBMU() const {return sqrt(_DMETBMUx*_DMETBMUx + _DMETBMUy*_DMETBMUy);}
Float_t TMBMet::getSETAMU() const {return _SETAMU;}
Float_t TMBMet::getSETBMU() const {return _SETBMU;}
// Unclustered energy corrections :
void TMBMet::getDMETAUExy(Float_t &DMETAUEx,Float_t &DMETAUEy) const
{
DMETAUEx=_DMETAUEx;DMETAUEy=_DMETAUEy;
return;
}
void TMBMet::getDMETBUExy(Float_t &DMETBUEx,Float_t &DMETBUEy) const
{
DMETBUEx=_DMETBUEx;DMETBUEy=_DMETBUEy;
return;
}
Float_t TMBMet::getDMETAUE() const {return sqrt(_DMETAUEx*_DMETAUEx + _DMETAUEy*_DMETAUEy);}
Float_t TMBMet::getDMETBUE() const {return sqrt(_DMETBUEx*_DMETBUEx + _DMETBUEy*_DMETBUEy);}
Float_t TMBMet::getSETAUE() const {return _SETAUE;}
Float_t TMBMet::getSETBUE() const {return _SETBUE;}
// Bad jets corrections :
void TMBMet::getDMETABJxy(Float_t &DMETABJx,Float_t &DMETABJy) const
{
DMETABJx=_DMETABJx;DMETABJy=_DMETABJy;
return;
}
void TMBMet::getDMETBBJxy(Float_t &DMETBBJx,Float_t &DMETBBJy) const
{
DMETBBJx=_DMETBBJx;DMETBBJy=_DMETBBJy;
return;
}
Float_t TMBMet::getDMETABJ() const {return sqrt(_DMETABJx*_DMETABJx + _DMETABJy*_DMETABJy);}
Float_t TMBMet::getDMETBBJ() const {return sqrt(_DMETBBJx*_DMETBBJx + _DMETBBJy*_DMETBBJy);}
Float_t TMBMet::getSETABJ() const {return _SETABJ;}
Float_t TMBMet::getSETBBJ() const {return _SETBBJ;}
// New accessor functions :
Float_t TMBMet::getMETA() const
{
Float_t METx = -1.* _VETDx + _DMETACHx;
Float_t METy = -1.* _VETDy + _DMETACHy;
return sqrt(METx*METx+METy*METy);
}
Float_t TMBMet::getMETB() const
{
Float_t METx = -1.*_VETDx + _DMETBCHx;
Float_t METy = -1.*_VETDy + _DMETBCHy;
return sqrt(METx*METx+METy*METy);
}
void TMBMet::getMETAxy(Float_t &METx,Float_t &METy) const
{
METx = -1.*_VETDx + _DMETACHx;
METy = -1.*_VETDy + _DMETACHy;
return;
}
void TMBMet::getMETBxy(Float_t &METx,Float_t &METy) const
{
METx = -1.*_VETDx + _DMETBCHx;
METy = -1.*_VETDy + _DMETBCHy;
return;
}
Float_t TMBMet::getSETA() const { return _SETD + _SETACH;}
Float_t TMBMet::getSETB() const { return _SETD + _SETBCH;}
Float_t TMBMet::getMETACorrCALO() const
{
Float_t METx = -1.*_VETDx + _DMETACHx + _DMETAJESx + _DMETAELx;
Float_t METy = -1.*_VETDy + _DMETACHy + _DMETAJESy + _DMETAELy;
return sqrt(METx*METx+METy*METy);
}
Float_t TMBMet::getMETBCorrCALO() const
{
Float_t METx = -1.*_VETDx + _DMETBCHx + _DMETBJESx + _DMETBELx;
Float_t METy = -1.*_VETDy + _DMETBCHy + _DMETBJESy + _DMETBELy;
return sqrt(METx*METx+METy*METy);
}
void TMBMet::getMETACorrCALOxy(Float_t &METx,Float_t &METy) const
{
METx = -1.*_VETDx + _DMETACHx + _DMETAJESx + _DMETAELx;
METy = -1.*_VETDy + _DMETACHy + _DMETAJESy + _DMETAELy;
return;
}
Float_t TMBMet::getSETACorrCALO() const { return _SETD + _SETACH + _SETAJES + _SETAEL;}
Float_t TMBMet::getSETBCorrCALO() const { return _SETD + _SETBCH + _SETBJES + _SETBEL;}
void TMBMet::getMETBCorrCALOxy(Float_t &METx,Float_t &METy) const
{
METx = -1.*_VETDx + _DMETBCHx + _DMETBJESx + _DMETBELx;
METy = -1.*_VETDy + _DMETBCHy + _DMETBJESy + _DMETBELy;
return;
}
Float_t TMBMet::getMETACorrCALOMU() const
{
Float_t METx = -1.*_VETDx + _DMETACHx + _DMETAJESx + _DMETAELx + _DMETAMUx;
Float_t METy = -1.*_VETDy + _DMETACHy + _DMETAJESy + _DMETAELy + _DMETAMUy;
return sqrt(METx*METx+METy*METy);
}
Float_t TMBMet::getMETBCorrCALOMU() const
{
Float_t METx = -1.*_VETDx + _DMETBCHx + _DMETBJESx + _DMETBELx + _DMETBMUx;
Float_t METy = -1.*_VETDy + _DMETBCHy + _DMETBJESy + _DMETBELy + _DMETBMUy;
return sqrt(METx*METx+METy*METy);
}
void TMBMet::getMETACorrCALOMUxy(Float_t &METx,Float_t &METy) const
{
METx = -1.*_VETDx + _DMETACHx + _DMETAJESx + _DMETAELx + _DMETAMUx;
METy = -1.*_VETDy + _DMETACHy + _DMETAJESy + _DMETAELy + _DMETAMUy;
return;
}
void TMBMet::getMETBCorrCALOMUxy(Float_t &METx,Float_t &METy) const
{
METx = -1.*_VETDx + _DMETBCHx + _DMETBJESx + _DMETBELx + _DMETBMUx;
METy = -1.*_VETDy + _DMETBCHy + _DMETBJESy + _DMETBELy + _DMETBMUy;
return;
}
Float_t TMBMet::getSETACorrCALOMU() const { return _SETD + _SETACH + _SETAJES + _SETAEL + _SETAMU;}
Float_t TMBMet::getSETBCorrCALOMU() const { return _SETD + _SETBCH + _SETBJES + _SETBEL + _SETBMU;}
//______________________________________________________________________________
ROOT page - Class index - Class Hierarchy - Top of the page
This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.