diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/CMakeLists.txt b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/CMakeLists.txt
index 8bff1abe2b008b5b2e8fa9204eb8294652bf1076..78261fb99f5604de87c60b2095d54a74cfa5ff58 100644
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/CMakeLists.txt
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/CMakeLists.txt
@@ -6,37 +6,38 @@
atlas_subdir( TrigEgammaAnalysisTools )
# Declare the package's dependencies:
-atlas_depends_on_subdirs(
- PUBLIC
- Control/AthToolSupport/AsgTools
- Event/xAOD/xAODCaloEvent
- Event/xAOD/xAODEgamma
- Event/xAOD/xAODEventInfo
- Event/xAOD/xAODJet
- Event/xAOD/xAODTracking
- Event/xAOD/xAODTrigCalo
- Event/xAOD/xAODTrigEgamma
- Event/xAOD/xAODTrigRinger
- Event/xAOD/xAODTrigger
- Event/xAOD/xAODTruth
- LumiBlock/LumiBlockComps
- PhysicsAnalysis/Interfaces/EgammaAnalysisInterfaces
- Reconstruction/RecoTools/RecoToolInterfaces
- PhysicsAnalysis/ElectronPhotonID/egammaMVACalibAnalysis
- Trigger/TrigAnalysis/TrigDecisionTool
- Trigger/TrigAnalysis/TrigEgammaMatchingTool
- Trigger/TrigAnalysis/TrigEgammaEmulationTool
- Trigger/TrigConfiguration/TrigConfHLTData
- Trigger/TrigEvent/TrigSteeringEvent
- Trigger/TrigMonitoring/TrigHLTMonitoring
- PhysicsAnalysis/AnalysisCommon/PATCore
- PRIVATE
- Control/AthenaBaseComps
- Control/AthenaMonitoring
- Control/StoreGate
- GaudiKernel
- Trigger/TrigConfiguration/TrigConfxAOD )
-
+atlas_depends_on_subdirs( PUBLIC
+ Control/AthToolSupport/AsgTools
+ Event/xAOD/xAODCaloEvent
+ Event/xAOD/xAODEgamma
+ Event/xAOD/xAODEventInfo
+ Event/xAOD/xAODJet
+ Event/xAOD/xAODPrimitives
+ Event/xAOD/xAODTracking
+ Event/xAOD/xAODTrigCalo
+ Event/xAOD/xAODTrigEgamma
+ Event/xAOD/xAODTrigRinger
+ Event/xAOD/xAODTrigger
+ Event/xAOD/xAODTruth
+ Event/xAOD/xAODMissingET
+ Event/xAOD/xAODCaloRings
+ LumiBlock/LumiBlockComps
+ PhysicsAnalysis/ElectronPhotonID/ElectronPhotonSelectorTools
+ Reconstruction/RecoTools/RecoToolInterfaces
+ Reconstruction/egamma/egammaMVACalib
+ Trigger/TrigAnalysis/TrigDecisionTool
+ Trigger/TrigAnalysis/TrigEgammaMatchingTool
+ Trigger/TrigAnalysis/TrigEgammaEmulationTool
+ Trigger/TrigConfiguration/TrigConfHLTData
+ Trigger/TrigEvent/TrigSteeringEvent
+ Trigger/TrigMonitoring/TrigHLTMonitoring
+ PhysicsAnalysis/AnalysisCommon/PATCore
+ PRIVATE
+ Control/AthenaBaseComps
+ Control/AthenaMonitoring
+ Control/StoreGate
+ GaudiKernel
+ Trigger/TrigConfiguration/TrigConfxAOD )
# External dependencies:
find_package( Boost )
find_package( ROOT COMPONENTS Core Hist Tree )
@@ -48,20 +49,25 @@ atlas_add_library( TrigEgammaAnalysisToolsLib
INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
PRIVATE_INCLUDE_DIRS ${Boost_INCLUDE_DIRS}
LINK_LIBRARIES ${ROOT_LIBRARIES} AsgTools xAODCaloEvent xAODEgamma
- xAODEventInfo xAODJet xAODTracking xAODTrigCalo xAODTrigEgamma xAODTrigRinger
- xAODTrigger xAODTruth LumiBlockCompsLib EgammaAnalysisInterfacesLib
+ xAODEventInfo xAODJet xAODTracking xAODTrigCalo xAODTrigEgamma xAODTrigRinger xAODMissingET
+ xAODTrigger xAODCaloRings xAODTruth LumiBlockCompsLib EgammaAnalysisInterfacesLib
RecoToolInterfaces egammaMVACalibAnalysisLib TrigDecisionToolLib
TrigEgammaMatchingToolLib TrigEgammaEmulationToolLib TrigConfHLTData
TrigSteeringEvent TrigHLTMonitoringLib PATCoreLib
PRIVATE_LINK_LIBRARIES ${Boost_LIBRARIES} TrigConfxAODLib )
atlas_add_component( TrigEgammaAnalysisTools
- src/*.h src/*.cxx src/components/*.cxx
- LINK_LIBRARIES AthenaBaseComps GaudiKernel AsgTools TrigHLTMonitoringLib
- AthenaMonitoringLib TrigDecisionToolLib TrigEgammaMatchingToolLib xAODEgamma
- TrigEgammaAnalysisToolsLib )
+ src/*.h
+ src/*.cxx
+ Root/*.cxx
+ src/components/*.cxx
+ INCLUDE_DIRS ${ROOT_INCLUDE_DIRS} ${Boost_INCLUDE_DIRS}
+ LINK_LIBRARIES ${ROOT_LIBRARIES} ${Boost_LIBRARIES} AsgTools xAODCaloEvent xAODMissingET xAODEgamma xAODEventInfo xAODJet xAODTracking xAODTrigCalo xAODTrigEgamma xAODTrigRinger xAODCaloRings xAODTrigger xAODTruth LumiBlockCompsLib ElectronPhotonSelectorToolsLib egammaMVACalibLib TrigDecisionToolLib TrigEgammaMatchingToolLib TrigEgammaEmulationTool TrigConfHLTData TrigSteeringEvent TrigHLTMonitoringLib AthenaBaseComps AthenaMonitoringLib StoreGateLib SGtests GaudiKernel PATCoreLib )
# Install files from the package:
atlas_install_python_modules( python/TrigEgamma*.py )
atlas_install_joboptions( share/test*.py )
-atlas_install_scripts( share/trigEgammaDQ.py share/get_trigEgammaDQ.sh )
+atlas_install_generic( share/trigEgammaDQ.py share/get_trigEgammaDQ.sh
+ DESTINATION share
+ EXECUTABLE )
+
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/EfficiencyTool.cxx b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/EfficiencyTool.cxx
index 073cef0276a1524ce30569e4a3048f1111ecd69a..f4baf74a26da1601a7ba15c8803bd889da15222a 100644
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/EfficiencyTool.cxx
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/EfficiencyTool.cxx
@@ -50,26 +50,25 @@ bool EfficiencyTool::analyseIsEMLH(const xAOD::Electron *eg, const std::string p
const std::string ineff = "Ineff" + pidword;
bool failIsEMLH = true;
- unsigned int isem = 9999;
try{
- ATH_MSG_DEBUG("Running selectionisEM("<<pidword<<")");
- isem = eg->selectionisEM(pidword);
-
- failIsEMLH = false;
- for (int ii = 0; ii < 11; ii++) {
- if ((isem >> ii) & 0x1) {
- failIsEMLH = true;
- hist1(fail)->Fill(ii + 0.5);
- hist1(ineff)->Fill(ii + 3.5, 1);
+ ATH_MSG_DEBUG("Running selectionisEM("<<pidword<<")");
+ unsigned int isem = eg->selectionisEM(pidword);
+
+ failIsEMLH = false;
+ for (int ii = 0; ii < 11; ii++) {
+ if ((isem >> ii) & 0x1) {
+ failIsEMLH = true;
+ hist1(fail)->Fill(ii + 0.5);
+ hist1(ineff)->Fill(ii + 3.5, 1);
+ }
}
- }
} catch (const ValidationException &e) {
- ATH_MSG_WARNING("Exception thrown: " << e.msg() );
- ATH_MSG_WARNING("Is " << pidword << " is a valid one? returning failed....");
- failIsEMLH = true;
+ ATH_MSG_WARNING("Exception thrown: " << e.msg() );
+ ATH_MSG_WARNING("Is " << pidword << " is a valid one? returning failed....");
+ failIsEMLH = true;
} catch(...) {
- ATH_MSG_WARNING("Unknown exception caught in analyseIsEMLH ... Is " << pidword << " is a valid one? returning failed....");
- failIsEMLH = true;
+ ATH_MSG_WARNING("Unknown exception caught in analyseIsEMLH ... Is " << pidword << " is a valid one? returning failed....");
+ failIsEMLH = true;
}
return failIsEMLH;
@@ -90,18 +89,7 @@ bool EfficiencyTool::analyseIsEM(const xAOD::Electron *eg, const std::string pid
bool failtrt = false;
bool failisem = false;
- unsigned int isem = 9999;
- try{
- isem = eg->selectionisEM(pidword);
- } catch (const ValidationException &eg) {
- ATH_MSG_WARNING("Exception thrown: " << eg.msg() );
- ATH_MSG_WARNING("Is " << pidword << " is a valid one? returning failed....");
- return(true);
- } catch(...) {
- ATH_MSG_WARNING("Unknown exception caught in analyseIsEMLH ... Is " << pidword << " is a valid one? returning failed....");
- return(true);
- }
-
+ unsigned int isem = eg->selectionisEM(pidword);
for (int ii = 0; ii < 29; ii++) {
if ((isem >> ii) & 0x1) {
@@ -255,8 +243,7 @@ void EfficiencyTool::fillInefficiency(const std::string& pid, const std::string
hist1(ineff)->Fill(lastbin - 4, 1);
hist1(ineff)->Fill(sumbin, 1);
}
- else {
- hist1(ineff)->Fill(lastbin - 3, 1);
+ else{
hist1(ineff)->Fill(sumbin, 1);
}
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaAnalysisBaseTool.cxx b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaAnalysisBaseTool.cxx
index fcd2a4aee400191fe2a3e27520bf5c87ecf1eac5..7909da2527e71ad979297000184fe3d58b9ae106 100644
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaAnalysisBaseTool.cxx
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaAnalysisBaseTool.cxx
@@ -66,6 +66,7 @@ TrigEgammaAnalysisBaseTool( const std::string& myname )
declareProperty("TPTrigger",m_tp=false)->declareUpdateHandler(&TrigEgammaAnalysisBaseTool::updateTP,this);
declareProperty("isEMResultNames",m_isemname,"isEM");
declareProperty("LHResultNames",m_lhname,"LH");
+ declareProperty("ForceTrigAttachment", m_forceTrigAttachment=false);
m_storeGate = nullptr;
m_histsvc = nullptr;
@@ -85,6 +86,9 @@ TrigEgammaAnalysisBaseTool( const std::string& myname )
m_nPVertex=0;
m_offmu=0.;
m_onlmu=0.;
+ m_sgContainsRnn=false;
+ m_sgContainsTrigPhoton=false;
+ m_forceTrigEmulation=false;
}
void TrigEgammaAnalysisBaseTool::updateDetail(Property& /*p*/){
@@ -101,14 +105,14 @@ void TrigEgammaAnalysisBaseTool::updateAltBinning(Property& /*p*/){
void TrigEgammaAnalysisBaseTool::updateTP(Property& /*p*/){
plot()->setTP(m_tp);
- for( auto& tool : m_tools) {
+ for( const auto& tool : m_tools) {
tool->setTP(m_tp);
}
}
void TrigEgammaAnalysisBaseTool::updateEmulation(Property& /*p*/){
plot()->setEmulation(m_doEmulation);
- for( auto& tool : m_tools) {
+ for( const auto& tool : m_tools) {
tool->setEmulation(m_doEmulation);
ATH_MSG_INFO("updateEmulation() property for tool with name: " << tool->name());
tool->setEmulationTool(m_emulationTool);
@@ -175,7 +179,7 @@ StatusCode TrigEgammaAnalysisBaseTool::initialize() {
// propagate the emulation tool for all tools
if( m_doEmulation ){
- for( auto& tool : m_tools) {
+ for( const auto& tool : m_tools) {
ATH_MSG_INFO("Propagate emulation tool handler to: " << tool->name() );
tool->setEmulationTool(m_emulationTool);
}
@@ -351,8 +355,10 @@ void TrigEgammaAnalysisBaseTool::setTrigInfo(const std::string trigger){
if(isL1) etthr=l1thr; // Should be handled elsewhere
- TrigInfo info{trigger,type,l1item,l1type,pidname,decorator,isL1,perf,etcut,etthr,l1thr};
+ TrigInfo info{trigger,type,l1item,l1type,pidname,decorator,isL1,perf,etcut,etthr,l1thr,m_forceTrigEmulation};
m_trigInfo[trigger] = info;
+
+ m_forceTrigEmulation=false; //hack disable
}
// return the TrigInfo from trigger name
@@ -557,6 +563,7 @@ bool TrigEgammaAnalysisBaseTool::isPrescaled(const std::string trigger){
asg::AcceptData
TrigEgammaAnalysisBaseTool::setAccept(const HLT::TriggerElement *te,const TrigInfo info){
+
ATH_MSG_DEBUG("setAccept");
asg::AcceptData acceptData (&m_accept);
bool passedL1Calo=false;
@@ -571,6 +578,16 @@ TrigEgammaAnalysisBaseTool::setAccept(const HLT::TriggerElement *te,const TrigIn
if(getFeature<xAOD::TrigRNNOutput>(te)){
hasRnn=true;
}
+
+ ATH_MSG_DEBUG("Rnn container " << getSGContainsRnn());
+ ATH_MSG_DEBUG("TrigPhotonContainer " << getSGContainsTrigPhoton());
+
+ if(getSGContainsRnn()){
+ if(getFeature<xAOD::TrigRNNOutput>(te)){
+ hasRnn=true;
+ }
+ }
+
if(!info.trigL1){ // HLT item get full decision
ATH_MSG_DEBUG("Check for active features: TrigEMCluster,CaloClusterContainer");
@@ -594,7 +611,9 @@ TrigEgammaAnalysisBaseTool::setAccept(const HLT::TriggerElement *te,const TrigIn
}
else if(info.trigType == "photon"){
ATH_MSG_DEBUG("Check for active features: TrigPhoton, PhotonContainer");
- passedL2=ancestorPassed<xAOD::TrigPhotonContainer>(te);
+ if(getSGContainsTrigPhoton()){
+ passedL2=ancestorPassed<xAOD::TrigPhotonContainer>(te);
+ }
passedEF = ancestorPassed<xAOD::PhotonContainer>(te);
passedEFTrk=true;// Assume true for photons
}
@@ -930,7 +949,7 @@ GETTER(pixeldEdx)
GETTER(deltaPhiRescaled3)
#undef GETTER
- std::string TrigEgammaAnalysisBaseTool::getProbePid(const std::string pidtype){
+std::string TrigEgammaAnalysisBaseTool::getProbePid(const std::string pidtype){
static std::map<std::string,std::string> PidMap; //no longer class member but static
// Note vloose/lhvloose trigger mapped to Loose/LHLoose offline PID
if(PidMap.empty()){
@@ -992,43 +1011,56 @@ bool TrigEgammaAnalysisBaseTool::getTrigCaloRings( const xAOD::TrigEMCluster *em
return false;
}
-bool TrigEgammaAnalysisBaseTool::getCaloRings( const xAOD::Electron * /*el*/, std::vector<float> & /*ringsE*/ ){
+bool TrigEgammaAnalysisBaseTool::getCaloRings( const xAOD::Electron * el, std::vector<float> &ringsE ){
- /*
+
if(!el) return false;
ringsE.clear();
-
- auto m_ringsELReader = xAOD::getCaloRingsReader();
+ auto ringsELReader = xAOD::getCaloRingsReader();
// First, check if we can retrieve decoration:
const xAOD::CaloRingsLinks *caloRingsLinks(nullptr);
try {
- caloRingsLinks = &(m_ringsELReader->operator()(*el));
+ ATH_MSG_DEBUG("getCaloRingsReader->operator()(*el)");
+ caloRingsLinks = &(ringsELReader->operator()(*el));
} catch ( const std::exception &e) {
ATH_MSG_WARNING("Couldn't retrieve CaloRingsELVec. Reason: " << e.what());
return false;
}
- if ( caloRingsLinks->empty() ){
- ATH_MSG_WARNING("Particle does not have CaloRings decoratorion.");
- return false;
- }
+ if( caloRingsLinks ){
+ if ( caloRingsLinks->empty() ){
+ ATH_MSG_WARNING("Particle does not have CaloRings decoratorion.");
+ return false;
+ }
+ const xAOD::CaloRings *clrings=nullptr;
+ try {
+ // For now, we are using only the first cluster
+ clrings = *(caloRingsLinks->at(0));
+ } catch(const std::exception &e){
+ ATH_MSG_WARNING("Couldn't retrieve CaloRings. Reason: " << e.what());
+ return false;
+ }
+ // For now, we are using only the first cluster
+ if(clrings) {
+ ATH_MSG_DEBUG("exportRingsTo...");
+ clrings->exportRingsTo(ringsE);
+ }else{
+ ATH_MSG_WARNING("There is a problem when try to attack the rings vector using exportRigsTo() method.");
+ return false;
+ }
- // For now, we are using only the first cluster
- const xAOD::CaloRings *clrings = *(caloRingsLinks->at(0));
- // For now, we are using only the first cluster
-
- if(clrings) clrings->exportRingsTo(ringsE);
- else{
- ATH_MSG_WARNING("There is a problem when try to attack the rings vector using exportRigsTo() method.");
+ }else{
+ ATH_MSG_WARNING("CaloRingsLinks in a nullptr...");
return false;
}
- */
+
return true;
}
+
void TrigEgammaAnalysisBaseTool::calculatePileupPrimaryVertex(){
// pileup calculation
m_nGoodVertex = 0.0; m_nPVertex = 0.0;
@@ -1050,8 +1082,6 @@ void TrigEgammaAnalysisBaseTool::calculatePileupPrimaryVertex(){
}
-
-
MonteCarlo::PDGID TrigEgammaAnalysisBaseTool::pdgid(const xAOD::Egamma *eg, const xAOD::TruthParticleContainer* truthContainer,
const xAOD::TruthParticle *&mc_match )
{
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaDistTool.cxx b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaDistTool.cxx
index 95ec6a52b47ee4b6a6dad33f3b025e77a0229636..de83d7d794ca60614295a02ab112a9a8c97cba34 100644
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaDistTool.cxx
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaDistTool.cxx
@@ -144,13 +144,14 @@ StatusCode TrigEgammaDistTool::toolExecute(const std::string basePath,TrigInfo i
const auto* obj = getFeature<xAOD::TrigEMCluster>(feat.te());
// Only consider passing objects
if(!obj) continue;
- if(!ancestorPassed<xAOD::TrigEMCluster>(feat.te())) continue;
cd(dir+"HLT");
- hist1("rejection")->Fill("L2Calo",1);
+ if(ancestorPassed<xAOD::TrigEMCluster>(feat.te()))
+ hist1("rejection")->Fill("L2Calo",1);
fillL2Calo(dir+"L2Calo",obj); // Fill HLT shower shapes
- if(boost::contains(info.trigName,"ringer") || info.trigEtcut || info.trigPerf)
- fillRinger(dir+"L2Calo",obj); // Fill HLT shower shapes
}
+
+
+
const auto vec_clus = fc.get<xAOD::CaloClusterContainer>("TrigEFCaloCalibFex",TrigDefs::alsoDeactivateTEs);
for(const auto feat : vec_clus){
if(feat.te()==nullptr) continue;
@@ -244,7 +245,7 @@ StatusCode TrigEgammaDistTool::toolExecute(const std::string basePath,TrigInfo i
return StatusCode::SUCCESS;
}
-void TrigEgammaDistTool::fillL1Calo(const std::string dir, const xAOD::EmTauRoI *l1){
+void TrigEgammaDistTool::fillL1Calo(const std::string &dir, const xAOD::EmTauRoI *l1){
cd(dir);
ATH_MSG_DEBUG("Fill L1Calo distributions" << dir);
hist1("eta")->Fill(l1->eta());
@@ -258,7 +259,7 @@ void TrigEgammaDistTool::fillL1Calo(const std::string dir, const xAOD::EmTauRoI
hist2("emClusVsHadCore")->Fill(l1->hadCore()*0.001, l1->emClus()*0.001);
}
-void TrigEgammaDistTool::fillEFCalo(const std::string dir, const xAOD::CaloCluster *clus){
+void TrigEgammaDistTool::fillEFCalo(const std::string &dir, const xAOD::CaloCluster *clus){
cd(dir);
ATH_MSG_DEBUG("Fill EFCalo distributions" << dir);
ATH_MSG_DEBUG("Energy " << clus->e()/1.e3);
@@ -286,7 +287,7 @@ void TrigEgammaDistTool::fillEFCalo(const std::string dir, const xAOD::CaloClust
hist1("phi_calo")->Fill(tmpphi);
}
-void TrigEgammaDistTool::fillL2Electron(const std::string dir, const xAOD::TrigElectron *el){
+void TrigEgammaDistTool::fillL2Electron(const std::string &dir, const xAOD::TrigElectron *el){
cd(dir);
if(!el) ATH_MSG_DEBUG("TrigElectron nullptr");
else {
@@ -297,7 +298,7 @@ void TrigEgammaDistTool::fillL2Electron(const std::string dir, const xAOD::TrigE
}
-void TrigEgammaDistTool::fillL2Calo(const std::string dir, const xAOD::TrigEMCluster *emCluster){
+void TrigEgammaDistTool::fillL2Calo(const std::string &dir, const xAOD::TrigEMCluster *emCluster){
cd(dir);
if(!emCluster) ATH_MSG_DEBUG("Online pointer fails");
else{
@@ -309,33 +310,9 @@ void TrigEgammaDistTool::fillL2Calo(const std::string dir, const xAOD::TrigEMClu
}
}
-void TrigEgammaDistTool::fillRinger(const std::string dir, const xAOD::TrigEMCluster *emCluster){
- cd(dir);
- if(!emCluster) ATH_MSG_DEBUG("Online pointer fails");
- else{
- bool hasRings = false;
- std::vector<float> ringsE;
- hasRings = getTrigCaloRings(emCluster, ringsE );
- if(hasRings){
- hist2("ringer_etVsEta")->Fill(emCluster->eta(), emCluster->et()/1.e3);
- ///Fill rings pdf for each ring
- if(m_detailedHists){
- for(unsigned layer =0; layer < 7; ++layer){
- unsigned minRing, maxRing; std::string strLayer;
- parseCaloRingsLayers( layer, minRing, maxRing, strLayer );
- cd(dir+"/rings_"+strLayer);
- for(unsigned r=minRing; r<=maxRing; ++r){
- std::stringstream ss;
- ss << "ringer_ring#" << r;
- hist1(ss.str())->Fill( ringsE.at(r) );
- }///loop into rings
- }///loop for each calo layer
- }
- }
- }
-}
-void TrigEgammaDistTool::fillShowerShapes(const std::string dir,const xAOD::Egamma *eg){
+
+void TrigEgammaDistTool::fillShowerShapes(const std::string &dir,const xAOD::Egamma *eg){
cd(dir);
ATH_MSG_DEBUG("Fill SS distributions " << dir);
if(!eg) ATH_MSG_WARNING("Egamma pointer fails");
@@ -362,13 +339,16 @@ void TrigEgammaDistTool::fillShowerShapes(const std::string dir,const xAOD::Egam
hist1("eta")->Fill(eg->eta());
hist1("phi")->Fill(eg->phi());
hist1("topoetcone20")->Fill(getIsolation_topoetcone20(eg)/1e3);
- if (eg->pt() > 0)
+ hist1("topoetcone40_shift")->Fill((getIsolation_topoetcone40(eg)-2450)/1e3);
+ if (eg->pt() > 0) {
hist1("topoetcone20_rel")->Fill(getIsolation_topoetcone20(eg)/eg->pt());
+ hist1("topoetcone40_shift_rel")->Fill((getIsolation_topoetcone40(eg)-2450)/eg->pt());
+ }
}
}
-void TrigEgammaDistTool::fillTracking(const std::string dir, const xAOD::Electron *eg){
+void TrigEgammaDistTool::fillTracking(const std::string &dir, const xAOD::Electron *eg){
cd(dir);
ATH_MSG_DEBUG("Fill tracking");
if(!eg) ATH_MSG_WARNING("Electron pointer fails");
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaEventSelection.cxx b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaEventSelection.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..bf313f2bde985292a10927d26d04d19ff8279c8c
--- /dev/null
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaEventSelection.cxx
@@ -0,0 +1,1206 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+/**********************************************************************
+ * AsgTool: TrigEgammaEventSelection
+ * Authors:
+ * Ryan Mackenzie White <ryan.white@cern.ch>
+ * Denis Damazio <denis.damazio@cern.ch>
+ * Contributors:
+ * Joao Victor da Fonseca Pinto <joao.victor.da.fonseca.pinto@cern.ch>
+ * Date: Mar 2015
+ * Description:
+ * Derived class for dumping the probe information into a ttree.
+ *
+ **********************************************************************/
+
+#include "TrigEgammaAnalysisTools/TrigEgammaEventSelection.h"
+#include "GaudiKernel/SystemOfUnits.h"
+using namespace std;
+
+TrigEgammaEventSelection::TrigEgammaEventSelection( const std::string& myname ):
+ TrigEgammaNavTPBaseTool(myname) , TrigEgammaPhysValBase()
+{
+ m_eventCounter = 0;
+ declareProperty("CutLabels" , m_cutlabels );
+ declareProperty("Analysis" , m_anatype="EventSelection");
+ declareProperty("SelectionZ" , m_selectionZ=true );
+ declareProperty("SelectionFakes" , m_selectionFakes=false );
+ declareProperty("SelectionMC" , m_selectionMC=false );
+ declareProperty("SelectionW" , m_selectionW=false );
+ declareProperty("SelectionJpsi" , m_selectionJpsi=false );
+ declareProperty("DumpTags" , m_dumpTags=false );
+ declareProperty("DetailedDataLevel" , m_detailedDataLevel=0 );
+ declareProperty("ElectronLHVLooseTool" , m_electronLHVLooseTool );
+
+
+ declareProperty("HLTElectronLikelihoodSelector" , m_HLTElectronLHSelectors );
+ declareProperty("EFCaloElectronLikelihoodSelector" , m_EFCaloElectronLHSelectors );
+ declareProperty("EFCaloElectronIsEMSelector" , m_EFCaloElectronIsEMSelectors );
+ declareProperty("HLTElectronIsEMSelector" , m_HLTElectronIsEMSelectors );
+
+ m_doCaloRings=false;
+}
+
+StatusCode TrigEgammaEventSelection::childInitialize(){
+
+ if ( (m_electronLHVLooseTool.retrieve()).isFailure() ){
+ ATH_MSG_ERROR( "Could not retrieve VeryLoose LH Selector Tool! Can't work");
+ return StatusCode::FAILURE;
+ }
+
+ if ( (m_EFCaloElectronLHSelectors.retrieve()).isFailure() ){
+ ATH_MSG_ERROR( "Could not retrieve EFCalo LH Selector Tool! Can't work");
+ return StatusCode::FAILURE;
+ }
+
+ if ( (m_EFCaloElectronIsEMSelectors.retrieve()).isFailure() ){
+ ATH_MSG_ERROR( "Could not retrieve EFCalo IsEM Selector Tool! Can't work");
+ return StatusCode::FAILURE;
+ }
+ if ( (m_HLTElectronLHSelectors.retrieve()).isFailure() ){
+ ATH_MSG_ERROR( "Could not retrieve HLT LH Selector Tool! Can't work");
+ return StatusCode::FAILURE;
+ }
+ if ( (m_HLTElectronIsEMSelectors.retrieve()).isFailure() ){
+ ATH_MSG_ERROR( "Could not retrieve HLT IsEM Selector Tool! Can't work");
+ return StatusCode::FAILURE;
+ }
+
+ return StatusCode::SUCCESS;
+}
+
+
+StatusCode TrigEgammaEventSelection::childBook(){
+
+ ATH_MSG_DEBUG("Now configuring chains for analysis");
+ //Set the base directory from the plot()
+ m_dir=plot()->getBasePath();
+ std::vector<std::string> chains = tdt()->getListOfTriggers("HLT_e.*, L1_EM.*, HLT_g.*");
+
+ TrigEgammaAnalysisBaseTool::write_trigger_list(chains);
+
+ if(!getEmulation()){
+ ATH_MSG_ERROR("Emulation tool was not set. This tool use the emulation to retrievea all support objects. Please, enable this!");
+ return StatusCode::FAILURE;
+ }
+
+
+ for(const auto trigName:m_trigInputList){
+ if (std::find(chains.begin(), chains.end(), trigName) != chains.end()){
+ if(plot()->getTrigInfoMap().count(trigName) != 0)
+ ATH_MSG_WARNING("Trigger already booked, removing from trigger list " << trigName);
+ else{
+ m_trigList.push_back(trigName);
+ setTrigInfo(trigName);
+ }
+ }else if(getEmulation() && m_forceTrigAttachment){//
+ ATH_MSG_DEBUG("Trigger doesn't exist in menu. Attach to emulate.");
+ if(plot()->getTrigInfoMap().count(trigName) == 0){
+ std::string parent;
+ m_trigList.push_back(trigName);
+ setTrigEmulation();
+ setTrigInfo(trigName);
+ }
+ }// emulation
+ }
+
+ // set the correct schema level to save
+ /* 0 is very slim schema
+ * 1 is slim
+ * 2 is full */
+ if(m_detailedDataLevel > 0 ){
+ m_doL2Detailed=true;
+ m_doL2CaloDetailed=true;
+ }
+ if(m_detailedDataLevel > 1){
+ m_doRecoDetailed=true;
+ m_doMCDetailed=true;
+ }
+
+
+ // Book histograms for average efficiencies and counters
+ //const int nTrigger = (int) m_trigList.size();
+ addDirectory(m_dir+"/Expert/Event");
+ std::string histname=m_anatype+"_ProbeCutCounter";
+ addHistogram(new TH1F(histname.c_str(), "Number of Probes; Cut ; Count", 12, 0., 12));
+ histname=m_anatype+"_TagCutCounter";
+ addHistogram(new TH1F(histname.c_str(), "Number of Tags; Cut ; Count", 10, 0., 10));
+ histname=m_anatype+"_Mee";
+ addHistogram(new TH1F(histname.c_str(), "Offline M(ee); m_ee [GeV] ; Count", 50, m_ZeeMassMin, m_ZeeMassMax));
+ histname=m_anatype+"_CutCounter";
+ addHistogram(new TH1I(histname.c_str(), "Event Selection; Cut ; Count", 6, 0., 6));
+ setLabels(hist1(histname),m_cutlabels);
+
+
+ addDirectory(m_dir+"/Egamma");
+
+ // create the TDT metadata for future access
+ TTree *tdtMetadata = new TTree("tdt", "Trigger metadata navigation");
+ createTDTMetadata( tdtMetadata, m_trigList );
+ addTree(tdtMetadata, m_dir+"/Egamma");
+
+ if(m_selectionZ){
+ if(m_dumpTags){
+ TTree *tag = new TTree( "tags", "tree of Offline Zee tags");
+ bookEventBranches( tag );
+ bookElectronBranches( tag );
+ bookTriggerBranches( tag );
+ bookTDTBranches( tag );
+ bookMonteCarloBranches( tag );
+ addTree(tag, m_dir+"/Egamma");
+ }
+ TTree *probe = new TTree( "probes", "tree of Zee probes");
+ bookEventBranches( probe );
+ bookElectronBranches( probe );
+ bookTriggerBranches( probe );
+ bookTDTBranches( probe );
+ bookMonteCarloBranches( probe );
+
+ addTree(probe, m_dir+"/Egamma");
+ }
+
+ if(m_selectionFakes){
+ TTree *fakes = new TTree( "fakes", "tree of Fakes");
+ bookEventBranches( fakes );
+ bookElectronBranches( fakes );
+ bookTriggerBranches( fakes );
+ bookTDTBranches( fakes );
+ bookMonteCarloBranches( fakes );
+ addTree(fakes, m_dir+"/Egamma");
+ }
+
+
+
+ // Check for Rnn container in SG
+ if(m_storeGate->contains<xAOD::TrigRNNOutputContainer>("HLT_xAOD__TrigRNNOutputContainer_TrigRingerNeuralFex")){
+ ATH_MSG_DEBUG("Rnn container in SG ");
+ setSGContainsRnn(true);
+ }
+
+
+ if(m_storeGate->contains<xAOD::CaloRingsContainer>("ElectronCaloRings")){
+ ATH_MSG_DEBUG("Offline electron calo rings in SG");
+ m_doCaloRings=true;
+ }
+
+
+ ///Alloc pointers
+ alloc_space();
+ return StatusCode::SUCCESS;
+}
+
+StatusCode TrigEgammaEventSelection::childExecute(){
+
+ m_eventCounter++;
+
+ cd(m_dir+"/Expert/Event");
+
+ // Event Wise Selection (independent of the required signatures)
+ if ( !TrigEgammaNavTPBaseTool::EventWiseSelection() ) return StatusCode::SUCCESS;
+
+ // Pass by errors in EventInfo
+ if( !TrigEgammaNavTPBaseTool::passesEventCleaning() ) return StatusCode::SUCCESS;
+
+ // nvtx > 0
+ if( getNPVtx() <= 0 ) return StatusCode::SUCCESS;
+
+ if(m_selectionZ)
+ EventSelectionZ();
+
+ if(m_selectionFakes)
+ EventSelectionFakes();
+
+
+ return StatusCode::SUCCESS;
+}
+
+bool TrigEgammaEventSelection::EventSelectionZ(){
+
+ ATH_MSG_INFO("In EventSelectonZ...");
+ // execute the standard tag and probe method
+ TrigEgammaNavTPBaseTool::executeTandP();
+ cd(m_dir+"/Egamma");
+
+ for(auto Z : m_Z){
+ const xAOD::Electron *elTag = m_offElectrons->at(Z.first);
+ const xAOD::Electron *elProbe = m_offElectrons->at(Z.second);
+ if(m_dumpTags)
+ fill( tree("tags" , m_dir+"/Egamma") , elTag );
+ fill( tree("probes", m_dir+"/Egamma") , elProbe );
+
+ }// Loop over pairs
+
+ return true;
+}
+
+bool TrigEgammaEventSelection::EventSelectionFakes(){
+
+
+ ATH_MSG_INFO("In EventSelectonFakes...");
+
+ for(const auto& elTag : *m_offElectrons){
+
+ // Remove electrons from Z or W if this is Monte Carlo
+ if(m_selectionMC && !isTruthElectronAny( elTag )) continue;
+
+ if (!elTag->isGoodOQ(xAOD::EgammaParameters::BADCLUSELECTRON)) continue;
+
+ if(!elTag->trackParticle()) continue;
+
+ // Default is 4 GeV
+ if( !(elTag->e()/cosh(elTag->trackParticle()->eta()) > m_probeMinEt*Gaudi::Units::GeV) ) continue;
+
+ //fiducial detector acceptance region
+ float absEta = fabs(elTag->caloCluster()->etaBE(2));
+ if (absEta > 2.47) continue;
+
+ if( !(getWTransverseMass(elTag) < 40000) ) continue;
+
+ bool passesZveto=true;
+
+ // If we can find any pair that falls in the Zmass window we fail the passesZveto cut
+ for(const auto& elProbe : *m_offElectrons){
+
+ if(elTag == elProbe) continue;
+
+ if(!elProbe->isGoodOQ(xAOD::EgammaParameters::BADCLUSELECTRON)) continue;
+
+ if(!elProbe->trackParticle()) continue;
+
+ // Must be higher than 4 GeV
+ if( (getEt(elProbe)) < 4*Gaudi::Units::GeV) continue;
+
+ if(!TrigEgammaNavTPBaseTool::ApplyElectronPid(elProbe,"LHMedium")) continue;
+
+ //Must be an easy way with IParticle
+ TLorentzVector el1;
+ TLorentzVector el2;
+ el1.SetPtEtaPhiE(elTag->pt(), elTag->trackParticle()->eta(), elTag->trackParticle()->phi(), elTag->e());
+ el2.SetPtEtaPhiE(elProbe->pt(), elProbe->trackParticle()->eta(), elProbe->trackParticle()->phi(), elProbe->e());
+ float tpPairMass = (el1 + el2).M();
+ if( !((tpPairMass > m_ZeeMassMin*Gaudi::Units::GeV) && (tpPairMass < m_ZeeMassMax*Gaudi::Units::GeV))){
+ ATH_MSG_DEBUG("tag and probe pair not in Z mass window");
+ continue;
+ }else{
+ ATH_MSG_INFO("tag and probe pain in Z mass window. Regect the electron...");
+ passesZveto=false;
+ break;
+ }
+ }// Loop over probes electrons
+
+ if(!passesZveto) continue;
+
+ ATH_MSG_INFO("Appling Fire trigger...");
+ if(!ApplyFireTriggers( elTag )) continue;
+
+ if(TrigEgammaNavTPBaseTool::ApplyElectronPid(elTag,"LHTight")) continue;
+
+ ATH_MSG_INFO("Fill electron...");
+ fill( tree("fakes" , m_dir+"/Egamma") , elTag );
+
+
+ }// Loop over electrons
+
+ return true;
+}
+
+
+
+bool TrigEgammaEventSelection::fill( TTree *t, const xAOD::Electron *el){
+
+
+ linkEventBranches(t);
+ linkElectronBranches(t);
+ linkTriggerBranches(t);
+ linkMonteCarloBranches(t);
+
+ const HLT::TriggerElement* feat=nullptr;
+
+ if(getEmulation())
+ emulation()->match( el, feat );
+ else{
+ ATH_MSG_ERROR("Emulation tool was not configurated. Impossible to match! Please, see your python config.");
+ return false;
+ }
+
+ if(feat){
+ clear();
+ fillEvent();
+ fillElectron( el );
+
+ if(!fillMonteCarlo( el ) ){
+ ATH_MSG_WARNING("Cound not found any TruthParticle for this Electron");
+ }
+
+ ///Start trigger analisys...
+ const xAOD::EmTauRoI *emTauRoI = getFeature<xAOD::EmTauRoI>(feat);
+ if(emTauRoI){
+ fillEmTauRoI( emTauRoI );
+ }else{
+ ATH_MSG_WARNING("Cound not found EmTauRoI in this TriggerElement..");
+ }
+
+ const xAOD::TrigEMCluster *emCluster = getFeature<xAOD::TrigEMCluster>(feat);
+ if(emCluster){
+ if(!fillTrigEMCluster( emCluster )){
+ ATH_MSG_WARNING("Cound not attach the trigEMCluster information into the tree.");
+ }
+
+ if(!fillTrigCaloRings( feat )){
+ ATH_MSG_WARNING("Cound not attach the TrigRingerRings information into the tree.");
+ }
+ }///cluster protection
+
+
+ const xAOD::TrigElectronContainer *trigElCont = getFeature<xAOD::TrigElectronContainer>(feat);
+ // Level 2 ID+Calo
+ if(trigElCont){
+ for(const auto& trigEl : *trigElCont){
+ if(!fillTrigElectron(trigEl)) {
+ ATH_MSG_WARNING("Cound not attach the trigElectron information into the tree.");
+ }
+ }// loop over all trigElectrons for this feat
+ }
+
+ const xAOD::CaloClusterContainer *caloCont = getFeature<xAOD::CaloClusterContainer>(feat);
+ if(caloCont){
+ for(const auto& cl : *caloCont){
+ if(!fillCaloCluster(cl)){
+ ATH_MSG_WARNING("Cound not attach the CaloCluster information into the tree.");
+ }
+ }// loop over calo cluster
+ }
+
+
+ const xAOD::ElectronContainer *elCont = getFeature<xAOD::ElectronContainer>(feat);
+
+ if(elCont){
+ for(const auto& hlt_el : *elCont){
+ if(!fillHLTElectron(hlt_el))
+ ATH_MSG_WARNING("Cound not attach the HLT Electron information into the tree.");
+ }
+ }
+
+
+ fillTDT( el, feat );
+
+
+ ATH_MSG_INFO("recording trigger information into the file.");
+ t->Fill();
+ }//loop over trigger objects
+
+ return true;
+}
+
+
+bool TrigEgammaEventSelection::fillTDT(const xAOD::Electron *el , const HLT::TriggerElement *te){
+
+ ATH_MSG_DEBUG("FillTDT...");
+ for(auto& trigItem : m_trigList){
+
+ const HLT::TriggerElement* feat=nullptr;
+ match()->match(el, trigItem, feat);
+ if(feat){
+ asg::AcceptData acceptData = setAccept(feat, getTrigInfo(trigItem));
+ bool passedL1Calo = acceptData.getCutResult("L1Calo");
+ bool passedL2Calo = acceptData.getCutResult("L2Calo");
+ bool passedL2 = acceptData.getCutResult("L2");
+ bool passedEFCalo = acceptData.getCutResult("EFCalo");
+ bool passedHLT = acceptData.getCutResult("HLT");
+ m_trig_tdt_L1_calo_accept->push_back( int(passedL1Calo) );
+ m_trig_tdt_L2_calo_accept->push_back( int(passedL2Calo) );
+ m_trig_tdt_L2_el_accept->push_back( int(passedL2) );
+ m_trig_tdt_EF_calo_accept->push_back( int(passedEFCalo) );
+ m_trig_tdt_EF_el_accept->push_back( int(passedHLT) );
+ //m_trig_tdt_emu_decision_mask
+ count("tdt_"+trigItem+"_total");
+ if(passedL1Calo) count("tdt_"+trigItem+"_L1Calo");
+ if(passedL2Calo) count("tdt_"+trigItem+"_L2Calo");
+ if(passedL2) count("tdt_"+trigItem+"_L2" );
+ if(passedEFCalo) count("tdt_"+trigItem+"_EFCalo");
+ if(passedHLT) count("tdt_"+trigItem+"_HLT" );
+
+ }else{
+ m_trig_tdt_L1_calo_accept->push_back( -1 );
+ m_trig_tdt_L2_calo_accept->push_back( -1 );
+ m_trig_tdt_L2_el_accept->push_back( -1 );
+ m_trig_tdt_EF_calo_accept->push_back( -1 );
+ m_trig_tdt_EF_el_accept->push_back( -1 );
+ }
+
+ if(te && getEmulation()){
+ asg::AcceptData acceptData = emulation()->executeTool(te, trigItem);
+ bool passedL1Calo = acceptData.getCutResult("L1Calo");
+ bool passedL2Calo = acceptData.getCutResult("L2Calo");
+ bool passedL2 = acceptData.getCutResult("L2");
+ bool passedEFCalo = acceptData.getCutResult("EFCalo");
+ bool passedHLT = acceptData.getCutResult("HLT");
+ m_trig_tdt_emu_L1_calo_accept->push_back( int(passedL1Calo) );
+ m_trig_tdt_emu_L2_calo_accept->push_back( int(passedL2Calo) );
+ m_trig_tdt_emu_L2_el_accept->push_back( int(passedL2) );
+ m_trig_tdt_emu_EF_calo_accept->push_back( int(passedEFCalo) );
+ m_trig_tdt_emu_EF_el_accept->push_back( int(passedHLT) );
+ //m_trig_tdt_emu_decision_mask
+ count("emu_"+trigItem+"_total");
+ if(passedL1Calo) count("emu_"+trigItem+"_L1Calo");
+ if(passedL2Calo) count("emu_"+trigItem+"_L2Calo");
+ if(passedL2) count("emu_"+trigItem+"_L2" );
+ if(passedEFCalo) count("emu_"+trigItem+"_EFCalo");
+ if(passedHLT) count("emu_"+trigItem+"_HLT" );
+ }else{
+ m_trig_tdt_emu_L1_calo_accept->push_back( -1 );
+ m_trig_tdt_emu_L2_calo_accept->push_back( -1 );
+ m_trig_tdt_emu_L2_el_accept->push_back( -1 );
+ m_trig_tdt_emu_EF_calo_accept->push_back( -1 );
+ m_trig_tdt_emu_EF_el_accept->push_back( -1 );
+ }
+
+
+ }// Loop over triggers
+
+
+ return true;
+
+}
+
+
+
+bool TrigEgammaEventSelection::fillTrigCaloRings( const HLT::TriggerElement *feat ){
+
+ ATH_MSG_DEBUG("FillTrigCaloRings...");
+ /* try to get the calo rings energy for this TE!*/
+ const xAOD::TrigRingerRings *ringer = getFeature<xAOD::TrigRingerRings>(feat);
+ if(ringer){// from this TE
+ for(unsigned r=0; r<ringer->size(); ++r){
+ m_trig_L2_calo_rings->push_back(ringer->rings()[r]);
+ }
+ }else{// from others TEs
+ const xAOD::TrigEMCluster *emCluster = getFeature<xAOD::TrigEMCluster>(feat);
+ if(emCluster){
+ // try to match without any other cluster.
+ TrigEgammaAnalysisBaseTool::getTrigCaloRings(emCluster, *m_trig_L2_calo_rings);
+ }else{
+ return false;
+ }
+ }
+
+ if(getSGContainsRnn()){
+ /* try to retrieve the NN output from this TE*/
+ const xAOD::TrigRNNOutput *rnn = getFeature<xAOD::TrigRNNOutput>(feat);
+ if(rnn){
+ for(unsigned o=0; o<rnn->rnnDecision().size(); ++o)
+ m_trig_L2_calo_rnnOutput->push_back(rnn->rnnDecision()[o]);
+ }else{
+ ATH_MSG_WARNING("Cound not attach the TrigRNNOutput information into the tree.");
+ }
+ }
+ return true;
+}
+
+
+
+
+bool TrigEgammaEventSelection::ApplyFireTriggers( const xAOD::Electron *el){
+
+ float et = getEt(el);
+
+ std::string trigger="";
+
+ if(et < 5*Gaudi::Units::GeV){
+ return false;
+ }else if(et >= 5*Gaudi::Units::GeV && et < 10*Gaudi::Units::GeV){
+ trigger = "HLT_e5_etcut";
+ }else if(et >= 10*Gaudi::Units::GeV && et < 15*Gaudi::Units::GeV){
+ trigger = "HLT_e10_etcut_L1EM7";
+ }else if(et >= 15*Gaudi::Units::GeV && et < 20*Gaudi::Units::GeV){
+ trigger = "HLT_e15_etcut_L1EM7";
+ }else if(et >= 20*Gaudi::Units::GeV && et < 25*Gaudi::Units::GeV){
+ trigger = "HLT_e20_etcut_L1EM12";
+ }else if(et >= 25*Gaudi::Units::GeV && et < 30*Gaudi::Units::GeV){
+ trigger = "HLT_e25_etcut_L1EM15";
+ }else if(et >= 30*Gaudi::Units::GeV && et < 40*Gaudi::Units::GeV){
+ trigger = "HLT_e30_etcut_L1EM15";
+ }else if(et >= 40*Gaudi::Units::GeV && et < 50*Gaudi::Units::GeV){
+ trigger = "HLT_e40_etcut_L1EM15";
+ }else if(et >= 50*Gaudi::Units::GeV && et < 60*Gaudi::Units::GeV){
+ trigger = "HLT_e50_etcut_L1EM15";
+ }else if(et >= 50*Gaudi::Units::GeV && et < 60*Gaudi::Units::GeV){
+ trigger = "HLT_e60_etcut";
+ }else if(et >= 60*Gaudi::Units::GeV && et < 70*Gaudi::Units::GeV){
+ trigger = "HLT_e70_etcut";
+ }else if(et >= 70*Gaudi::Units::GeV && et < 80*Gaudi::Units::GeV){
+ trigger = "HLT_e80_etcut";
+ }else if(et >= 80*Gaudi::Units::GeV && et < 100*Gaudi::Units::GeV){
+ trigger = "HLT_e100_etcut";
+ }else if(et >= 100*Gaudi::Units::GeV && et < 120*Gaudi::Units::GeV){
+ trigger = "HLT_e120_etcut";
+ }else{
+ return true;
+ }
+
+ const HLT::TriggerElement *te;
+ match()->match(el,trigger,te);
+ bool passedHLT = ancestorPassed<xAOD::ElectronContainer>(te);
+
+ if(!passedHLT) return false;
+
+ return true;
+}
+
+
+
+StatusCode TrigEgammaEventSelection::childFinalize(){
+
+ for(auto& trigItem : m_trigList){
+ ATH_MSG_DEBUG("From TDT tool:");
+ ATH_MSG_DEBUG(trigItem << " total = " << m_countMap["tdt_"+trigItem+"_total"] );
+ ATH_MSG_DEBUG(trigItem << " L1Calo = " << m_countMap["tdt_"+trigItem+"_L1Calo"]);
+ ATH_MSG_DEBUG(trigItem << " L2Calo = " << m_countMap["tdt_"+trigItem+"_L2Calo"]);
+ ATH_MSG_DEBUG(trigItem << " L2 = " << m_countMap["tdt_"+trigItem+"_L2"] );
+ ATH_MSG_DEBUG(trigItem << " EFCalo = " << m_countMap["tdt_"+trigItem+"_EFCalo"]);
+ ATH_MSG_DEBUG(trigItem << " HLT = " << m_countMap["tdt_"+trigItem+"_HLT"] );
+ ATH_MSG_DEBUG("From emulation tool:");
+ ATH_MSG_DEBUG(trigItem << " total = " << m_countMap["emu_"+trigItem+"_total"] );
+ ATH_MSG_DEBUG(trigItem << " L1Calo = " << m_countMap["emu_"+trigItem+"_L1Calo"]);
+ ATH_MSG_DEBUG(trigItem << " L2Calo = " << m_countMap["emu_"+trigItem+"_L2Calo"]);
+ ATH_MSG_DEBUG(trigItem << " L2 = " << m_countMap["emu_"+trigItem+"_L2"] );
+ ATH_MSG_DEBUG(trigItem << " EFCalo = " << m_countMap["emu_"+trigItem+"_EFCalo"]);
+ ATH_MSG_DEBUG(trigItem << " HLT = " << m_countMap["emu_"+trigItem+"_HLT"] );
+ }
+ return StatusCode::SUCCESS;
+}
+
+
+bool TrigEgammaEventSelection::fillEmTauRoI( const xAOD::EmTauRoI *emTauRoI ){
+
+ ATH_MSG_DEBUG("FillEmTauRoI...");
+ m_trig_L1_eta = emTauRoI->eta();
+ m_trig_L1_phi = emTauRoI->phi();
+ m_trig_L1_emClus = emTauRoI->emClus();
+ m_trig_L1_tauClus = emTauRoI->tauClus();
+ m_trig_L1_emIsol = emTauRoI->emIsol();
+ m_trig_L1_hadIsol = emTauRoI->hadIsol();
+ m_trig_L1_hadCore = emTauRoI->hadCore();
+ return true;
+}
+
+bool TrigEgammaEventSelection::fillTrigEMCluster( const xAOD::TrigEMCluster *emCluster ){
+
+ ATH_MSG_DEBUG("FillTrigEMCluster...");
+ m_trig_L2_calo_et = emCluster->et();
+ m_trig_L2_calo_eta = emCluster->eta();
+ m_trig_L2_calo_phi = emCluster->phi();
+ m_trig_L2_calo_emaxs1 = emCluster->emaxs1();
+ m_trig_L2_calo_e2tsts1 = emCluster->e2tsts1();
+ m_trig_L2_calo_e237 = emCluster->e237();
+ m_trig_L2_calo_e277 = emCluster->e277();
+ m_trig_L2_calo_ehad1 = emCluster->ehad1();
+ m_trig_L2_calo_weta2 = emCluster->weta2();
+ m_trig_L2_calo_wstot = emCluster->wstot();
+ m_trig_L2_calo_fracs1 = emCluster->fracs1();
+ for(unsigned i=0; i<emCluster->energySample().size(); ++i){
+ m_trig_L2_calo_energySample->push_back( emCluster->energySample().at(i));
+ }
+
+ return true;
+}
+
+
+bool TrigEgammaEventSelection::fillTrigElectron( const xAOD::TrigElectron *trigEl ){
+ ATH_MSG_DEBUG("FillTrigElectron...");
+ //const xAOD::TrackParticle* trkIter = trigEl->trackParticle();
+ //if (trkIter==nullptr) return false; // disconsider candidates without track
+ //int algoId = 0;
+ //if ( trkIter->patternRecoInfo()[xAOD::TrackPatternRecoInfo::FastTrackFinderSeed] ) algoId=9;
+ //if ( trkIter->patternRecoInfo()[xAOD::TrackPatternRecoInfo::strategyA] ) algoId=5;
+ //if ( trkIter->patternRecoInfo()[xAOD::TrackPatternRecoInfo::strategyB] ) algoId=6;
+ //if ( trkIter->patternRecoInfo()[xAOD::TrackPatternRecoInfo::strategyC] ) algoId=7;
+
+ //m_trig_L2_el_trackAlgID ->push_back(algoId);
+ m_trig_L2_el_caloEta ->push_back(trigEl->caloEta());
+ m_trig_L2_el_trkClusDphi ->push_back(trigEl->trkClusDphi());
+ m_trig_L2_el_trkClusDeta ->push_back(trigEl->trkClusDeta());
+ m_trig_L2_el_pt ->push_back(trigEl->pt());
+ m_trig_L2_el_phi ->push_back(trigEl->phi());
+ m_trig_L2_el_eta ->push_back(trigEl->eta());
+ m_trig_L2_el_etOverPt ->push_back(trigEl->etOverPt());
+ m_trig_L2_el_nTRTHits ->push_back(trigEl->nTRTHits());
+ m_trig_L2_el_nTRTHiThresholdHits->push_back(trigEl->nTRTHiThresholdHits());
+ m_trig_L2_el_charge ->push_back(trigEl->charge());
+ return true;
+}
+
+
+bool TrigEgammaEventSelection::fillCaloCluster( const xAOD::CaloCluster *cluster){
+
+ ATH_MSG_DEBUG("FillCaloCluster...");
+ m_trig_EF_calo_et->push_back(cluster->et());
+ m_trig_EF_calo_eta->push_back(cluster->eta());
+ m_trig_EF_calo_phi->push_back(cluster->phi());
+ m_trig_EF_calo_etaBE2->push_back(cluster->etaBE(2));
+ m_trig_EF_calo_e->push_back(cluster->e());
+
+ return true;
+}
+
+bool TrigEgammaEventSelection::fillEvent(){
+ ///Event information
+ ATH_MSG_DEBUG("FillEvent...");
+ m_runNumber = m_eventInfo->runNumber();
+ m_eventNumber = m_eventInfo->eventNumber();
+ m_lumiBlock = m_eventInfo->lumiBlock();
+ m_avgmu=getAvgMu();
+ return true;
+}
+
+bool TrigEgammaEventSelection::fillElectron( const xAOD::Electron *el ){
+
+ ATH_MSG_DEBUG("FillElectron...");
+ ///Cluster information
+ uint8_t nblayerhits(0);
+ uint8_t nblayerolhits(0);
+ uint8_t npixhits(0);
+ uint8_t npixolhits(0);
+ uint8_t nscthits(0);
+ uint8_t nsctolhits(0);
+ uint8_t ntrthighthreshits(0);
+ uint8_t ntrthighthresolhits(0);
+ uint8_t ntrthits(0);
+ uint8_t ntrtolhits(0);
+ uint8_t ntrtxenonhits(0);
+ uint8_t npixdeadsensors(0);
+ uint8_t nsctdeadsensors(0);
+ uint8_t expectblayerhit(true);
+ uint8_t expectNextToInnerMostLayer(true);
+ uint8_t nNextToInnerMostLayerHits(0);
+ uint8_t nNextToInnerMostLayerOutliers(0);
+ float val(0);
+ bool hasCalo(false);
+ bool hasTrack(false);
+
+
+
+ m_el_e = el->e();
+ m_el_et = el->pt();
+ m_el_eta = el->eta();
+ m_el_phi = el->phi();
+
+ el->showerShapeValue( m_el_ethad1 , xAOD::EgammaParameters::ShowerShapeType::ethad1 );
+ el->showerShapeValue( m_el_ehad1 , xAOD::EgammaParameters::ShowerShapeType::ehad1 );
+ el->showerShapeValue( m_el_f1 , xAOD::EgammaParameters::ShowerShapeType::f1 ); // LH
+ el->showerShapeValue( m_el_f3 , xAOD::EgammaParameters::ShowerShapeType::f3 ); // LH
+ el->showerShapeValue( m_el_f1core , xAOD::EgammaParameters::ShowerShapeType::f1core );
+ el->showerShapeValue( m_el_f3core , xAOD::EgammaParameters::ShowerShapeType::f3core );
+ el->showerShapeValue( m_el_weta1 , xAOD::EgammaParameters::ShowerShapeType::weta1 ); // LH (new)
+ el->showerShapeValue( m_el_weta2 , xAOD::EgammaParameters::ShowerShapeType::weta2 ); // LH
+ el->showerShapeValue( m_el_wtots1 , xAOD::EgammaParameters::ShowerShapeType::wtots1 );
+ el->showerShapeValue( m_el_fracs1 , xAOD::EgammaParameters::ShowerShapeType::fracs1 );
+ el->showerShapeValue( m_el_Reta , xAOD::EgammaParameters::ShowerShapeType::Reta ); // LH
+ el->showerShapeValue( m_el_Rphi , xAOD::EgammaParameters::ShowerShapeType::Rphi ); // LH
+ el->showerShapeValue( m_el_Eratio , xAOD::EgammaParameters::ShowerShapeType::Eratio ); // LH
+ el->showerShapeValue( m_el_Rhad , xAOD::EgammaParameters::ShowerShapeType::Rhad ); // LH
+ el->showerShapeValue( m_el_Rhad1 , xAOD::EgammaParameters::ShowerShapeType::Rhad1 ); // LH
+ el->showerShapeValue( m_el_deltaE , xAOD::EgammaParameters::ShowerShapeType::DeltaE ); // LH
+ el->showerShapeValue( m_el_e277 , xAOD::EgammaParameters::ShowerShapeType::e277 ); // LH
+ ///Combined track/Cluter information
+ el->trackCaloMatchValue( m_el_deta2 , xAOD::EgammaParameters::TrackCaloMatchType::deltaEta2 );
+ el->trackCaloMatchValue( m_el_dphi2 , xAOD::EgammaParameters::TrackCaloMatchType::deltaPhi2 );
+ el->trackCaloMatchValue( m_el_dphiresc , xAOD::EgammaParameters::TrackCaloMatchType::deltaPhiRescaled0 );
+ m_el_deltaPhiRescaled2 = get_el_deltaPhiRescaled2(el); // LH
+ m_el_deltaEta1 = get_el_deltaEta1(el); // LH
+
+ if(el->caloCluster()){
+ hasCalo=true;
+ m_el_calo_et = getCluster_et( el );
+ m_el_calo_eta = getCluster_eta( el );
+ m_el_calo_phi = getCluster_phi( el );
+ m_el_calo_etaBE2 = el->caloCluster()->etaBE(2); // LH
+ m_el_calo_e = el->caloCluster()->e(); // LH
+ }
+
+ ///Track particle information
+ const xAOD::TrackParticle *track = el->trackParticle();
+ if(track){
+ hasTrack=true;
+ track->summaryValue( nblayerhits , xAOD::SummaryType::numberOfBLayerHits );
+ track->summaryValue( nblayerolhits , xAOD::SummaryType::numberOfBLayerOutliers );
+ track->summaryValue( npixhits , xAOD::SummaryType::numberOfPixelHits );
+ track->summaryValue( npixolhits , xAOD::SummaryType::numberOfPixelOutliers );
+ track->summaryValue( npixdeadsensors , xAOD::SummaryType::numberOfPixelDeadSensors);
+ track->summaryValue( nscthits , xAOD::SummaryType::numberOfSCTHits );
+ track->summaryValue( nsctolhits , xAOD::SummaryType::numberOfSCTOutliers );
+ track->summaryValue( nsctdeadsensors , xAOD::SummaryType::numberOfSCTDeadSensors);
+ track->summaryValue( ntrthits , xAOD::SummaryType::numberOfTRTHits);
+ track->summaryValue( ntrtolhits , xAOD::SummaryType::numberOfTRTOutliers );
+ track->summaryValue( ntrthighthreshits , xAOD::SummaryType::numberOfTRTHighThresholdHits );
+ track->summaryValue( ntrthighthresolhits , xAOD::SummaryType::numberOfTRTHighThresholdOutliers );
+ track->summaryValue( ntrtxenonhits , xAOD::SummaryType::numberOfTRTXenonHits );
+ track->summaryValue( expectblayerhit , xAOD::SummaryType::expectBLayerHit );
+ track->summaryValue( expectNextToInnerMostLayer , xAOD::expectNextToInnermostPixelLayerHit);
+ track->summaryValue( nNextToInnerMostLayerHits , xAOD::numberOfNextToInnermostPixelLayerHits);
+ track->summaryValue( nNextToInnerMostLayerOutliers, xAOD::numberOfNextToInnermostPixelLayerOutliers);
+
+ m_el_trk_pt = track->pt();
+ m_el_trk_eta = track->eta();
+ m_el_trk_charge = track->charge(); // LH
+ m_el_trk_qOverP = track->qOverP(); // LH
+ m_el_trk_sigd0 = get_el_sigd0(el); // LH
+ m_el_trk_d0 = get_el_d0(el); // LH
+ m_el_trk_eProbabilityHT = get_el_eProbabilityHT(el); // LH
+ m_el_trk_transformed_eProbabilityHT=get_el_transformed_eProbabilityHT(el); // LH
+ m_el_trk_d0significance = get_el_d0significance(el);
+ m_el_trk_deltaPOverP = get_el_DeltaPOverP(el); // LH
+
+ }
+
+ ///Extra information about pileup
+ m_el_nGoodVtx = getNGoodVertex();
+ m_el_nPileupPrimaryVtx = getNPVtx();
+
+ auto ctx = Gaudi::Hive::currentContext() ;
+ // rerun Likelihood Veryloose selector tool
+ bool accept=(bool)m_electronLHVLooseTool->accept(ctx,el, getAvgMu());
+ m_el_lhVLoose = accept;
+ m_el_loose = ApplyElectronPid(el, "Loose");
+ m_el_medium = ApplyElectronPid(el, "Medium");
+ m_el_tight = ApplyElectronPid(el, "Tight");
+ m_el_lhLoose = ApplyElectronPid(el, "LHLoose");
+ m_el_lhMedium = ApplyElectronPid(el, "LHMedium");
+ m_el_lhTight = ApplyElectronPid(el, "LHTight");
+
+
+ // Do not change this order!
+ m_el_trk_summaryValues->push_back( nblayerhits );
+ m_el_trk_summaryValues->push_back( nblayerolhits );
+ m_el_trk_summaryValues->push_back( npixhits );
+ m_el_trk_summaryValues->push_back( npixolhits );
+ m_el_trk_summaryValues->push_back( npixdeadsensors );
+ m_el_trk_summaryValues->push_back( nscthits );
+ m_el_trk_summaryValues->push_back( nsctolhits );
+ m_el_trk_summaryValues->push_back( nsctdeadsensors );
+ m_el_trk_summaryValues->push_back( ntrthits );
+ m_el_trk_summaryValues->push_back( ntrtolhits );
+ m_el_trk_summaryValues->push_back( ntrthighthreshits );
+ m_el_trk_summaryValues->push_back( ntrthighthresolhits );
+ m_el_trk_summaryValues->push_back( ntrtxenonhits );
+ m_el_trk_summaryValues->push_back( expectblayerhit );
+ m_el_trk_summaryValues->push_back( expectNextToInnerMostLayer );
+ m_el_trk_summaryValues->push_back( nNextToInnerMostLayerHits );
+ m_el_trk_summaryValues->push_back( nNextToInnerMostLayerOutliers );
+
+ //Add isolations values
+ el->isolationValue(val,xAOD::Iso::etcone20);
+ m_el_etCone->push_back(val);
+ el->isolationValue(val,xAOD::Iso::etcone30);
+ m_el_etCone->push_back(val);
+ el->isolationValue(val,xAOD::Iso::etcone40);
+ m_el_etCone->push_back(val);
+ el->isolationValue(val,xAOD::Iso::ptcone20);
+ m_el_ptCone->push_back(val);
+ el->isolationValue(val,xAOD::Iso::ptcone30);
+ m_el_ptCone->push_back(val);
+ el->isolationValue(val,xAOD::Iso::ptcone40);
+ m_el_ptCone->push_back(val);
+ el->isolationValue(val,xAOD::Iso::ptvarcone20);
+ m_el_ptCone->push_back(val);
+ el->isolationValue(val,xAOD::Iso::ptvarcone30);
+ m_el_ptCone->push_back(val);
+ el->isolationValue(val,xAOD::Iso::ptvarcone40);
+ m_el_ptCone->push_back(val);
+
+ m_el_hasCalo=hasCalo;
+ m_el_hasTrack=hasTrack;
+
+
+ if(m_doCaloRings){
+ ATH_MSG_DEBUG("Fill Electron calo rings...");
+ if(!TrigEgammaAnalysisBaseTool::getCaloRings( el , *m_el_ringsE)){
+ ATH_MSG_WARNING("Could not attach the calorRings information.");
+ }
+ }
+
+
+
+ return true;
+}
+
+
+bool TrigEgammaEventSelection::fillHLTElectron( const xAOD::Electron *el ){
+
+ ATH_MSG_DEBUG("FillHLTElectron...");
+ float calo_e(0);
+ float calo_et(0);
+ float calo_eta(0);
+ float calo_phi(0);
+ float calo_etaBE2(0);
+ float eta(0);
+ float et(0);
+ //float eta2(0);
+ float phi(0);
+ float pt(0);
+ float trk_eta(0);
+ float ethad1(0);
+ float ehad1(0);
+ float f1(0);
+ float f3(0);
+ float f1core(0);
+ float f3core(0);
+ float weta1(0);
+ float weta2(0);
+ float wtots1(0);
+ float fracs1(0);
+ float Reta(0);
+ float Rphi(0);
+ float Eratio(0);
+ float Rhad(0);
+ float Rhad1(0);
+ float deta1(0);
+ float deta2(0);
+ float dphi2(0);
+ float dphiresc(0);
+ float charge(0);
+ float qOverP(0);
+ float sigd0(0);
+ float d0(0);
+ //float eprobht(0);
+ float eProbabilityHT(0);
+ float transformed_eProbabilityHT(0);
+ float d0significance(0);
+ float deltaPhiRescaled2(0);
+ float deltaPOverP(0);
+ float e(0);
+ float e277(0);
+ float deltaE(0);
+ uint8_t nblayerhits(0);
+ uint8_t nblayerolhits(0);
+ uint8_t npixhits(0);
+ uint8_t npixolhits(0);
+ uint8_t nscthits(0);
+ uint8_t nsctolhits(0);
+ uint8_t ntrthighthreshits(0);
+ uint8_t ntrthighthresolhits(0);
+ uint8_t ntrthits(0);
+ uint8_t ntrtolhits(0);
+ uint8_t ntrtxenonhits(0);
+ uint8_t npixdeadsensors(0);
+ uint8_t nsctdeadsensors(0);
+ uint8_t expectblayerhit(true);
+ uint8_t expectNextToInnerMostLayer(true);
+ uint8_t nNextToInnerMostLayerHits(0);
+ uint8_t nNextToInnerMostLayerOutliers(0);
+ float val(0) ;
+
+ bool hasCalo(false);
+ bool hasTrack(false);
+
+
+ ATH_MSG_DEBUG("FillElectron...");
+
+ ///Cluster information
+ e = el->e();
+ et = el->pt();
+ eta = el->eta();
+ phi = el->phi();
+
+ el->showerShapeValue( ethad1 , xAOD::EgammaParameters::ShowerShapeType::ethad1 );
+ el->showerShapeValue( ehad1 , xAOD::EgammaParameters::ShowerShapeType::ehad1 );
+ el->showerShapeValue( f1 , xAOD::EgammaParameters::ShowerShapeType::f1 ); // LH, isEM
+ el->showerShapeValue( f3 , xAOD::EgammaParameters::ShowerShapeType::f3 ); // LH, isEM
+ el->showerShapeValue( f1core , xAOD::EgammaParameters::ShowerShapeType::f1core );
+ el->showerShapeValue( f3core , xAOD::EgammaParameters::ShowerShapeType::f3core ); // isEM
+ el->showerShapeValue( weta1 , xAOD::EgammaParameters::ShowerShapeType::weta1 ); // LH, isEM (new)
+ el->showerShapeValue( weta2 , xAOD::EgammaParameters::ShowerShapeType::weta2 ); // LH, isEM
+ el->showerShapeValue( wtots1 , xAOD::EgammaParameters::ShowerShapeType::wtots1 ); // LH, isEM
+ el->showerShapeValue( fracs1 , xAOD::EgammaParameters::ShowerShapeType::fracs1 ); // isEM
+ el->showerShapeValue( Reta , xAOD::EgammaParameters::ShowerShapeType::Reta ); // LH, isEM
+ el->showerShapeValue( Rphi , xAOD::EgammaParameters::ShowerShapeType::Rphi ); // LH, isEM
+ el->showerShapeValue( Eratio , xAOD::EgammaParameters::ShowerShapeType::Eratio ); // LH, isEM
+ el->showerShapeValue( Rhad , xAOD::EgammaParameters::ShowerShapeType::Rhad ); // LH, isEM
+ el->showerShapeValue( Rhad1 , xAOD::EgammaParameters::ShowerShapeType::Rhad1 ); // LH, isEM
+ el->showerShapeValue( e277 , xAOD::EgammaParameters::e277 ); // isEM (new)
+ el->showerShapeValue( deltaE , xAOD::EgammaParameters::DeltaE ); // isEM (new)
+
+ ///Combined track/Cluter information
+ el->trackCaloMatchValue( deta2 , xAOD::EgammaParameters::TrackCaloMatchType::deltaEta2 );
+ el->trackCaloMatchValue( dphi2 , xAOD::EgammaParameters::TrackCaloMatchType::deltaPhi2 );
+ el->trackCaloMatchValue( dphiresc , xAOD::EgammaParameters::TrackCaloMatchType::deltaPhiRescaled0 );
+ deltaPhiRescaled2 = get_el_deltaPhiRescaled2(el); // LH
+ deta1 = get_el_deltaEta1(el); // LH
+
+ if(el->caloCluster()){
+ hasCalo=true;
+ calo_et = getCluster_et( el );
+ calo_eta = getCluster_eta( el );
+ calo_phi = getCluster_phi( el );
+ calo_etaBE2 = el->caloCluster()->etaBE(2); // LH
+ calo_e = el->caloCluster()->e(); // LH
+ }
+
+
+
+ ///Track particle information
+ const xAOD::TrackParticle *track = el->trackParticle();
+ if(track){
+ hasTrack=true;
+ // track->summaryValue( eprobht , xAOD::SummaryType::eProbabilityHT ); // LH
+ track->summaryValue( nblayerhits , xAOD::SummaryType::numberOfBLayerHits ); // LH, isEM
+ track->summaryValue( nblayerolhits , xAOD::SummaryType::numberOfBLayerOutliers ); // LH, isEM
+ track->summaryValue( npixhits , xAOD::SummaryType::numberOfPixelHits ); // LH, isEM
+ track->summaryValue( npixolhits , xAOD::SummaryType::numberOfPixelOutliers ); // isEM
+ track->summaryValue( npixdeadsensors , xAOD::SummaryType::numberOfPixelDeadSensors); // LH, isEM
+ track->summaryValue( nscthits , xAOD::SummaryType::numberOfSCTHits ); // LH, isEM
+ track->summaryValue( nsctolhits , xAOD::SummaryType::numberOfSCTOutliers ); // isEM
+ track->summaryValue( nsctdeadsensors , xAOD::SummaryType::numberOfSCTDeadSensors); // isEM
+ track->summaryValue( ntrthits , xAOD::SummaryType::numberOfTRTHits); // isEM
+ track->summaryValue( ntrtolhits , xAOD::SummaryType::numberOfTRTOutliers ); // isEM
+ track->summaryValue( ntrthighthreshits , xAOD::SummaryType::numberOfTRTHighThresholdHits ); // isEM
+ track->summaryValue( ntrthighthresolhits , xAOD::SummaryType::numberOfTRTHighThresholdOutliers ); // isEM
+ track->summaryValue( ntrtxenonhits , xAOD::SummaryType::numberOfTRTXenonHits ); // isEM
+ track->summaryValue( expectblayerhit , xAOD::SummaryType::expectBLayerHit ); // LH, isEM
+ track->summaryValue( expectNextToInnerMostLayer , xAOD::expectNextToInnermostPixelLayerHit); // LH, isEM
+ track->summaryValue( nNextToInnerMostLayerHits , xAOD::numberOfNextToInnermostPixelLayerHits); // LH, isEM
+ track->summaryValue( nNextToInnerMostLayerOutliers, xAOD::numberOfNextToInnermostPixelLayerOutliers); // LH, isEM
+
+ pt = track->pt();
+ trk_eta = track->eta(); // LH
+ charge = track->charge(); // LH
+ qOverP = track->qOverP(); // LH, isEM
+ sigd0 = get_el_sigd0(el); // LH
+ d0 = get_el_d0(el); // LH, isEM
+ eProbabilityHT = get_el_eProbabilityHT(el); // LH, isEM
+ transformed_eProbabilityHT=get_el_transformed_eProbabilityHT(el); // LH
+ d0significance = get_el_d0significance(el);
+ deltaPOverP = get_el_DeltaPOverP(el); // LH
+ }
+
+ auto avgmu=getAvgMu();
+
+ m_trig_EF_el_hasCalo ->push_back( hasCalo );
+ m_trig_EF_el_hasTrack ->push_back( hasTrack );
+
+ auto ctx = Gaudi::Hive::currentContext();
+ m_trig_EF_calo_tight ->push_back((bool)(m_EFCaloElectronIsEMSelectors[0]->accept(ctx,el)));
+ m_trig_EF_calo_medium ->push_back((bool)(m_EFCaloElectronIsEMSelectors[1]->accept(ctx,el)));
+ m_trig_EF_calo_loose ->push_back((bool)(m_EFCaloElectronIsEMSelectors[2]->accept(ctx,el)));
+ m_trig_EF_calo_lhtight ->push_back((bool)(m_EFCaloElectronLHSelectors[0]->accept(ctx,el,avgmu)));
+ m_trig_EF_calo_lhmedium ->push_back((bool)(m_EFCaloElectronLHSelectors[1]->accept(ctx,el,avgmu)));
+ m_trig_EF_calo_lhloose ->push_back((bool)(m_EFCaloElectronLHSelectors[2]->accept(ctx,el,avgmu)));
+ m_trig_EF_calo_lhvloose ->push_back((bool)(m_EFCaloElectronLHSelectors[3]->accept(ctx,el,avgmu)));
+
+ m_trig_EF_el_tight ->push_back((bool)(m_HLTElectronIsEMSelectors[0]->accept(ctx,el)));
+ m_trig_EF_el_medium ->push_back((bool)(m_HLTElectronIsEMSelectors[1]->accept(ctx,el)));
+ m_trig_EF_el_loose ->push_back((bool)(m_HLTElectronIsEMSelectors[2]->accept(ctx,el)));
+ m_trig_EF_el_lhtight ->push_back((bool)(m_HLTElectronLHSelectors[0]->accept(ctx,el,avgmu)));
+ m_trig_EF_el_lhmedium ->push_back((bool)(m_HLTElectronLHSelectors[1]->accept(ctx,el,avgmu)));
+ m_trig_EF_el_lhloose ->push_back((bool)(m_HLTElectronLHSelectors[2]->accept(ctx,el,avgmu)));
+ m_trig_EF_el_lhvloose ->push_back((bool)(m_HLTElectronLHSelectors[3]->accept(ctx,el,avgmu)));
+
+ m_trig_EF_el_calo_et ->push_back( calo_et);
+ m_trig_EF_el_calo_eta ->push_back( calo_eta );
+ m_trig_EF_el_calo_phi ->push_back( calo_phi );
+ m_trig_EF_el_calo_etaBE2 ->push_back( calo_etaBE2 );
+ m_trig_EF_el_calo_e ->push_back( calo_e );
+
+ m_trig_EF_el_et ->push_back( et );
+ m_trig_EF_el_eta ->push_back( eta );
+ m_trig_EF_el_phi ->push_back( phi );
+ m_trig_EF_el_e ->push_back( e );
+ m_trig_EF_el_e277 ->push_back( e277 );
+ m_trig_EF_el_deltaE ->push_back( deltaE );
+ m_trig_EF_el_ethad1 ->push_back( ethad1 );
+ m_trig_EF_el_ehad1 ->push_back( ehad1 );
+ m_trig_EF_el_f1 ->push_back( f1 );
+ m_trig_EF_el_f3 ->push_back( f3 );
+ m_trig_EF_el_f1core ->push_back( f1core );
+ m_trig_EF_el_f3core ->push_back( f3core );
+ m_trig_EF_el_weta1 ->push_back( weta1 );
+ m_trig_EF_el_weta2 ->push_back( weta2 );
+ m_trig_EF_el_wtots1 ->push_back( wtots1 );
+ m_trig_EF_el_fracs1 ->push_back( fracs1 );
+ m_trig_EF_el_Reta ->push_back( Reta );
+ m_trig_EF_el_Rphi ->push_back( Rphi );
+ m_trig_EF_el_Eratio ->push_back( Eratio );
+ m_trig_EF_el_Rhad ->push_back( Rhad );
+ m_trig_EF_el_Rhad1 ->push_back( Rhad1 );
+ m_trig_EF_el_deta2 ->push_back( deta2 );
+ m_trig_EF_el_dphi2 ->push_back( dphi2 );
+ m_trig_EF_el_dphiresc ->push_back( dphiresc );
+ m_trig_EF_el_deltaEta1 ->push_back( deta1 );
+ m_trig_EF_el_deltaPhiRescaled2 ->push_back( deltaPhiRescaled2 );
+
+ m_trig_EF_el_trk_pt ->push_back( pt );
+ m_trig_EF_el_trk_eta ->push_back( trk_eta );
+ m_trig_EF_el_trk_charge ->push_back( charge );
+ m_trig_EF_el_trk_qOverP ->push_back( qOverP );
+ m_trig_EF_el_trk_sigd0 ->push_back( sigd0 );
+ m_trig_EF_el_trk_d0 ->push_back( d0 );
+ m_trig_EF_el_trk_eProbabilityHT ->push_back( eProbabilityHT );
+ m_trig_EF_el_trk_transformed_eProbabilityHT ->push_back( transformed_eProbabilityHT );
+ m_trig_EF_el_trk_d0significance ->push_back( d0significance );
+ m_trig_EF_el_trk_deltaPOverP ->push_back( deltaPOverP );
+
+
+ m_trig_EF_el_trk_summaryValues->push_back( nblayerhits );
+ m_trig_EF_el_trk_summaryValues->push_back( nblayerolhits );
+ m_trig_EF_el_trk_summaryValues->push_back( npixhits );
+ m_trig_EF_el_trk_summaryValues->push_back( npixolhits );
+ m_trig_EF_el_trk_summaryValues->push_back( npixdeadsensors );
+ m_trig_EF_el_trk_summaryValues->push_back( nscthits );
+ m_trig_EF_el_trk_summaryValues->push_back( nsctolhits );
+ m_trig_EF_el_trk_summaryValues->push_back( nsctdeadsensors );
+ m_trig_EF_el_trk_summaryValues->push_back( ntrthits );
+ m_trig_EF_el_trk_summaryValues->push_back( ntrtolhits );
+ m_trig_EF_el_trk_summaryValues->push_back( ntrthighthreshits );
+ m_trig_EF_el_trk_summaryValues->push_back( ntrthighthresolhits );
+ m_trig_EF_el_trk_summaryValues->push_back( ntrtxenonhits );
+ m_trig_EF_el_trk_summaryValues->push_back( expectblayerhit );
+ m_trig_EF_el_trk_summaryValues->push_back( expectNextToInnerMostLayer );
+ m_trig_EF_el_trk_summaryValues->push_back( nNextToInnerMostLayerHits );
+ m_trig_EF_el_trk_summaryValues->push_back( nNextToInnerMostLayerOutliers );
+
+ //Add isolations values
+ el->isolationValue(val,xAOD::Iso::etcone20);
+ m_trig_EF_el_etCone->push_back(val);
+ el->isolationValue(val,xAOD::Iso::etcone30);
+ m_trig_EF_el_etCone->push_back(val);
+ el->isolationValue(val,xAOD::Iso::etcone40);
+ m_trig_EF_el_etCone->push_back(val);
+ el->isolationValue(val,xAOD::Iso::ptcone20);
+ m_trig_EF_el_ptCone->push_back(val);
+ el->isolationValue(val,xAOD::Iso::ptcone30);
+ m_trig_EF_el_ptCone->push_back(val);
+ el->isolationValue(val,xAOD::Iso::ptcone40);
+ m_trig_EF_el_ptCone->push_back(val);
+ el->isolationValue(val,xAOD::Iso::ptvarcone20);
+ m_trig_EF_el_ptCone->push_back(val);
+ el->isolationValue(val,xAOD::Iso::ptvarcone30);
+ m_trig_EF_el_ptCone->push_back(val);
+ el->isolationValue(val,xAOD::Iso::ptvarcone40);
+ m_trig_EF_el_ptCone->push_back(val);
+
+
+ return true;
+}
+
+
+
+// if true: is Z or W Or not MC if false: not electron or not Z||W mother
+bool TrigEgammaEventSelection::isTruthElectronAny(const xAOD::Egamma *eg ){
+ if(m_truthContainer){
+ const xAOD::TruthParticle *mc=nullptr;
+ MonteCarlo::PDGID pdg = pdgid(eg, m_truthContainer,mc);
+ if(mc){
+ bool Z,W,e;
+ Z=W=e=false;
+ if(pdg == MonteCarlo::PDGID::ZMother) Z = true;
+ if(pdg == MonteCarlo::PDGID::WMother) W = true;
+ if(mc->isElectron()) e=true;
+ return !(e && (Z||W));
+ }
+ }
+ return true;
+}
+
+
+bool TrigEgammaEventSelection::fillMonteCarlo(const xAOD::Egamma *eg){
+
+ if(m_truthContainer){
+ const xAOD::TruthParticle *mc=nullptr;
+ MonteCarlo::PDGID pdg = pdgid(eg, m_truthContainer,mc);
+ if(mc){
+ m_mc_hasMC = true;
+ m_mc_pt = mc->pt();
+ m_mc_eta = mc->eta();
+ m_mc_phi = mc->phi();
+ m_mc_isTop = mc->isTop();
+ m_mc_isQuark = mc->isQuark();
+ m_mc_isParton = mc->isParton();
+ m_mc_isMeson = mc->isMeson();
+ m_mc_isTau = mc->isTau();
+ m_mc_isMuon = mc->isMuon();
+ m_mc_isPhoton = mc->isPhoton();
+ m_mc_isElectron = mc->isElectron();
+ if(pdg == MonteCarlo::PDGID::ZMother) m_mc_hasZMother = true;
+ if(pdg == MonteCarlo::PDGID::WMother) m_mc_hasWMother = true;
+ return true;
+ }//has match
+ }//has truth container
+ return false;
+}
+
+
+bool TrigEgammaEventSelection::fillCaloRings( const xAOD::Electron *el ){
+ return TrigEgammaAnalysisBaseTool::getCaloRings(el, *m_el_ringsE );
+}
+
+
+//! ============================================================================================================
+
+
+double TrigEgammaEventSelection::get_el_sigd0(const xAOD::Electron *el){
+ float vard0 = el->trackParticle()->definingParametersCovMatrix()(0,0); // Cov matrix in vector form
+ if(vard0>0.0)
+ return sqrt(vard0); // variance of d0
+ return 0.0;
+}
+
+double TrigEgammaEventSelection::get_el_d0(const xAOD::Electron *el){
+ return el->trackParticle()->d0();
+}
+
+
+double TrigEgammaEventSelection::get_el_eProbabilityHT(const xAOD::Electron *el){
+ float TRT_PID = 0;
+ el->trackParticle()->summaryValue(TRT_PID, xAOD::eProbabilityHT);
+ return TRT_PID;
+}
+
+
+double TrigEgammaEventSelection::get_el_transformed_eProbabilityHT(const xAOD::Electron *el){
+ double TRT_PID = get_el_eProbabilityHT(el);
+ double epsilon = 1e-30;
+ if(TRT_PID >= 1.0) TRT_PID = 1.0 - 1.e-15;
+ else if(TRT_PID <= epsilon) TRT_PID = epsilon;
+ double tau = 15.0;
+ TRT_PID = -(1/tau) * log( (1.0/TRT_PID) - 1.0);
+ return TRT_PID;
+}
+
+
+double TrigEgammaEventSelection::get_el_d0significance(const xAOD::Electron *el){
+ double d0 = get_el_d0(el);
+ double sigd0 = get_el_sigd0(el);
+ return (sigd0 != 0) ? fabs(d0/sigd0) : 0;
+}
+
+double TrigEgammaEventSelection::get_el_deltaPhiRescaled2(const xAOD::Electron *el){
+ float deltaPhiRescaled2 = 0;
+ el->trackCaloMatchValue(deltaPhiRescaled2, xAOD::EgammaParameters::deltaPhiRescaled2);
+ return deltaPhiRescaled2;
+}
+
+
+double TrigEgammaEventSelection::get_el_deltaEta1(const xAOD::Electron *el){
+ float deltaEta1 = 0;
+ el->trackCaloMatchValue(deltaEta1, xAOD::EgammaParameters::deltaEta1);
+ return deltaEta1;
+}
+
+
+double TrigEgammaEventSelection::get_el_DeltaPOverP(const xAOD::Electron *el){
+ unsigned int index;
+ if(el->trackParticle()->indexOfParameterAtPosition(index,xAOD::LastMeasurement)){
+ double LMPX = el->trackParticle()->parameterPX(index);
+ double LMPY = el->trackParticle()->parameterPY(index);
+ double LMPZ = el->trackParticle()->parameterPZ(index);
+ double refittedTrack_LMP = sqrt(LMPX*LMPX + LMPY*LMPY + LMPZ*LMPZ);
+ double refittedTrack_LMqOverP = el->trackParticle()->charge() / refittedTrack_LMP;
+ double unrefittedTrack_qOverP = el->trackParticle()->qOverP();
+ return 1 - (unrefittedTrack_qOverP / refittedTrack_LMqOverP);
+ }
+ else
+ return 0.0;
+}
+
+
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaNavAnalysisTool.cxx b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaNavAnalysisTool.cxx
index 0c030885532abd2bc6681761433986678cc976d7..b071f53faa5365e5105c9582e00554a7d1e85d68 100644
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaNavAnalysisTool.cxx
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaNavAnalysisTool.cxx
@@ -27,13 +27,25 @@ StatusCode TrigEgammaNavAnalysisTool::childBook(){
m_dir=plot()->getBasePath();
std::vector<std::string> chains = tdt()->getListOfTriggers("HLT_e.*, L1_EM.*, HLT_g.*");
- for(const auto trigName:m_trigInputList){
- if (std::find(chains.begin(), chains.end(), trigName) != chains.end()) {
+ for(const auto trigName:m_trigInputList){
+ if (std::find(chains.begin(), chains.end(), trigName) != chains.end()){
if(plot()->getTrigInfoMap().count(trigName) != 0)
ATH_MSG_WARNING("Trigger already booked, removing from trigger list " << trigName);
- else
+ else {
m_trigList.push_back(trigName);
+ setTrigInfo(trigName);
+ }
}
+ // Special code to attach trigger without of the menu
+ else if(getEmulation() && m_forceTrigAttachment){//
+ ATH_MSG_INFO("Trigger doesn't exist in menu. Attach to emulate.");
+ if(plot()->getTrigInfoMap().count(trigName) == 0){
+ m_trigList.push_back(trigName);
+ setTrigEmulation();
+ setTrigInfo(trigName);
+ }
+ }
+
}
// Container level kinematic histograms
@@ -57,8 +69,6 @@ StatusCode TrigEgammaNavAnalysisTool::childBook(){
setLabels(plot()->hist1(m_anatype+"_trigger_counts"),m_trigList);
}
- for (const auto trigger: m_trigList)
- setTrigInfo(trigger);
plot()->setEmulation(getEmulation());
if(plot()->book(getTrigInfoMap()).isFailure()) {
@@ -79,6 +89,21 @@ StatusCode TrigEgammaNavAnalysisTool::childExecute(){
ATH_MSG_DEBUG("Fails EventWise selection");
return StatusCode::SUCCESS; //return nicely
}
+ // Check for Rnn container in SG
+ if(m_storeGate->contains<xAOD::TrigRNNOutputContainer>("HLT_xAOD__TrigRNNOutputContainer_TrigRingerNeuralFex")){
+ ATH_MSG_DEBUG("Rnn container in SG ");
+ setSGContainsRnn(true);
+ }
+ if(m_storeGate->contains<xAOD::TrigPhotonContainer>("HLT_xAOD__TrigPhotonContainer_L2PhotonFex")){
+ ATH_MSG_DEBUG("TrigPhotonContainer in SG ");
+ setSGContainsTrigPhoton(true);
+ }
+ ATH_MSG_DEBUG("Rnn container in SG " << getSGContainsRnn());
+ ATH_MSG_DEBUG("TrigPhotonContainer in SG " << getSGContainsTrigPhoton());
+ for( const auto& tool : m_tools) {
+ tool->setSGContainsRnn(getSGContainsRnn());
+ tool->setSGContainsTrigPhoton(getSGContainsTrigPhoton());
+ }
// Check HLTResult
if(tdt()->ExperimentalAndExpertMethods()->isHLTTruncated()){
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaNavBaseTool.cxx b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaNavBaseTool.cxx
index 8ae71d4a14294113e1e0674b4cb7019fe87ff3ea..4f313a9690957b425f89db0e7ea46592ea14c0e6 100644
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaNavBaseTool.cxx
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaNavBaseTool.cxx
@@ -13,11 +13,10 @@
* Description:
* Inherits from TrigEgammaAnalysisBaseTool.
**********************************************************************/
-#include "egammaMVACalibAnalysis/IegammaMVATool.h"
#include "TrigEgammaAnalysisTools/TrigEgammaNavBaseTool.h"
#include "TrigConfxAOD/xAODConfigTool.h"
#include "PATCore/AcceptData.h"
-
+#include "GaudiKernel/SystemOfUnits.h"
#include "string"
#include <algorithm>
#include "boost/algorithm/string.hpp"
@@ -138,6 +137,7 @@ bool TrigEgammaNavBaseTool::EventWiseSelection( ){
//Calculate number of vertex
TrigEgammaAnalysisBaseTool::calculatePileupPrimaryVertex();
+
return true;
}
@@ -218,10 +218,10 @@ StatusCode TrigEgammaNavBaseTool::executeElectronNavigation( std::string trigIte
if(m_forcePidSelection){///default is true
if(!ApplyElectronPid(eg,pidname)){
- ATH_MSG_DEBUG("Fails ElectronID "<< pidname);
- continue;
- }
- ATH_MSG_DEBUG("Passes ElectronID "<< pidname);
+ ATH_MSG_DEBUG("Fails ElectronID "<< pidname);
+ continue;
+ }
+ ATH_MSG_DEBUG("Passes ElectronID "<< pidname);
}
if (m_forceProbeIsolation) {///default is false
@@ -239,15 +239,20 @@ StatusCode TrigEgammaNavBaseTool::executeElectronNavigation( std::string trigIte
xAOD::Electron *el = new xAOD::Electron(*eg);
el->auxdecor<bool>(decor)=static_cast<bool>(true);
-
- if (match()->match(el, trigItem, te)){
- std::pair< const xAOD::Electron*, const HLT::TriggerElement* > pair(el,te);
- m_objTEList.push_back(pair);
- }
- else {
- std::pair< const xAOD::Electron*, const HLT::TriggerElement* > pair(el,nullptr);
- m_objTEList.push_back(pair);
+ bool isEmulation = getTrigInfo(trigItem).trigIsEmulation;
+ if(isEmulation && getEmulation()){
+ emulation()->match(el,te);
+ std::pair< const xAOD::Electron*, const HLT::TriggerElement* > pair(el,te);
+ m_objTEList.push_back(pair);
+ }else{
+ if (match()->match(el, trigItem, te)){
+ std::pair< const xAOD::Electron*, const HLT::TriggerElement* > pair(el,te);
+ m_objTEList.push_back(pair);
+ }else {
+ std::pair< const xAOD::Electron*, const HLT::TriggerElement* > pair(el,nullptr);
+ m_objTEList.push_back(pair);
+ }
}
}
@@ -269,7 +274,7 @@ StatusCode TrigEgammaNavBaseTool::executePhotonNavigation( std::string trigItem,
ATH_MSG_DEBUG("No caloCluster");
continue;
}
- if( !(getCluster_et(eg) > (etthr-5.)*1.e3)) continue; //Take 2GeV above threshold
+ if( !(getCluster_et(eg) > (etthr-5.)*Gaudi::Units::GeV)) continue; //Take 2GeV above threshold
if(!eg->passSelection(m_photonPid)) continue;
if(m_doUnconverted){
if (eg->vertex()){
@@ -279,13 +284,19 @@ StatusCode TrigEgammaNavBaseTool::executePhotonNavigation( std::string trigItem,
}
xAOD::Photon *ph = new xAOD::Photon(*eg);
ph->auxdecor<bool>(decor)=static_cast<bool>(true);
- if ( match()->match(ph, trigItem, te)){
- std::pair< const xAOD::Photon*, const HLT::TriggerElement* > pair(ph,te);
- m_objTEList.push_back(pair);
- }
- else {
- std::pair< const xAOD::Photon*, const HLT::TriggerElement* > pair(ph,nullptr);
- m_objTEList.push_back(pair);
+ bool isEmulation = getTrigInfo(trigItem).trigIsEmulation;
+ if(isEmulation && getEmulation()){
+ emulation()->match(ph,te);
+ std::pair< const xAOD::Photon*, const HLT::TriggerElement* > pair(ph,te);
+ m_objTEList.push_back(pair);
+ }else{
+ if (match()->match(ph, trigItem, te)){
+ std::pair< const xAOD::Photon*, const HLT::TriggerElement* > pair(ph,te);
+ m_objTEList.push_back(pair);
+ }else {
+ std::pair< const xAOD::Photon*, const HLT::TriggerElement* > pair(ph,nullptr);
+ m_objTEList.push_back(pair);
+ }
}
}
@@ -295,6 +306,9 @@ StatusCode TrigEgammaNavBaseTool::executePhotonNavigation( std::string trigItem,
}
void TrigEgammaNavBaseTool::clearList(){
+ for( auto paitIt : m_objTEList )
+ delete paitIt.first;
+
m_objTEList.clear();
}
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaNavNtuple.cxx b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaNavNtuple.cxx
deleted file mode 100755
index a15b46ae14857468d84e882fb5460bfc613c8087..0000000000000000000000000000000000000000
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaNavNtuple.cxx
+++ /dev/null
@@ -1,1138 +0,0 @@
-/*
- Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-*/
-
-
-#include "TrigEgammaAnalysisTools/TrigEgammaNavNtuple.h"
-using namespace std;
-
-TrigEgammaNavNtuple::TrigEgammaNavNtuple( const std::string& myname ): TrigEgammaNavBaseTool(myname)
-{
- declareProperty("Analysis", m_anatype="NavNtuple" );
- declareProperty("doOfflineDump", m_doOfflineDump=false );
- declareProperty("DoSupportTrigger", m_doSupport=true );
- declareProperty("ForceMCMatch", m_forceMCMatch=true );
- declareProperty("OfflineMinEtThreshold", m_minEt=-1 );
-
- ///Set base tool configuration
- m_forcePidSelection=false;
-
- m_el_ringsE=nullptr;
- m_trig_L1_thrNames=nullptr;
- m_trig_L2_calo_energySample=nullptr;
- m_trig_L2_calo_rings=nullptr;
- m_trig_L2_el_trackAlgID=nullptr;
- m_trig_L2_el_pt=nullptr;
- m_trig_L2_el_eta=nullptr;
- m_trig_L2_el_caloEta=nullptr;
- m_trig_L2_el_phi=nullptr;
- m_trig_L2_el_charge=nullptr;
- m_trig_L2_el_nTRTHits=nullptr;
- m_trig_L2_el_nTRTHiThresholdHits=nullptr;
- m_trig_L2_el_etOverPt=nullptr;
- m_trig_L2_el_trkClusDeta=nullptr;
- m_trig_L2_el_trkClusDphi=nullptr;
- m_trig_EF_calo_et=nullptr;
- m_trig_EF_calo_eta=nullptr;
-
-}
-
-
-StatusCode TrigEgammaNavNtuple::childInitialize(){
-
- return StatusCode::SUCCESS;
-}
-
-StatusCode TrigEgammaNavNtuple::childBook(){
-
- ATH_MSG_DEBUG("Now configuring chains for analysis");
- //Set the base directory from the plot()
- m_dir=plot()->getBasePath();
- std::vector<std::string> chains = tdt()->getListOfTriggers("HLT_e.*, L1_EM.*, HLT_g.*");
-
- TrigEgammaAnalysisBaseTool::write_trigger_list(chains);
-
- for(const auto trigName:m_trigInputList){
- if (std::find(chains.begin(), chains.end(), trigName) != chains.end()) {
- if(plot()->getTrigInfoMap().count(trigName) != 0)
- ATH_MSG_WARNING("Trigger already booked, removing from trigger list " << trigName);
- else
- m_trigList.push_back(trigName);
- }
- }
-
-
- // Container level kinematic histograms
- ATH_MSG_DEBUG("cd in: " << m_dir <<"/Expert/Event");
- addDirectory(m_dir+"/Expert/Event");
- const int nTrigger = (int) m_trigList.size();
-
- std::string histname=m_anatype+"_electrons";
- addHistogram(new TH1F(histname.c_str(), "Offline Electrons; ; N_{electrons}", 6, 1., 6));
- std::vector<std::string> el_labels;
- el_labels.push_back("loose");
- el_labels.push_back("medium");
- el_labels.push_back("tight");
- el_labels.push_back("lhloose");
- el_labels.push_back("lhmedium");
- el_labels.push_back("lhtight");
- setLabels(hist1(histname),el_labels);
-
- histname=m_anatype+"_trigger_counts";
- if(nTrigger>0) {
- addHistogram(new TH1F(histname.c_str(), "Trigger Counts; Trigger ; Count", nTrigger, 1, nTrigger));
- setLabels(plot()->hist1(m_anatype+"_trigger_counts"),m_trigList);
- }
-
- ///Only offline egamma ntuple
- if(m_doOfflineDump){
- ATH_MSG_DEBUG("Now configuting only the egamma analysis");
- addDirectory(m_dir+"/Expert/Offline");
- TTree *t_el = new TTree("electron", "tree of egamma and monte carlo information");
- TTree *t_ph = new TTree("photons", "tree of egamma and monte carlo information");
- bookEventBranches( t_ph );
- //bookPhotonBranches( t_ph );
- bookMonteCarloBranches( t_ph );
- bookEventBranches( t_el );
- bookElectronBranches( t_el );
- bookMonteCarloBranches( t_el );
- addTree( t_el, m_dir+"/Expert/Offline" );
- addTree( t_ph, m_dir+"/Expert/Offline" );
- }else if(m_doSupport){// all support trigger in one
- addDirectory(m_dir+"/Expert/support");
- TTree *t = new TTree( "trigger", "support trigger");
- bookEventBranches( t );
- bookElectronBranches( t );
- //bookPhotonBranches( t );
- bookTriggerBranches( t );
- bookMonteCarloBranches( t );
- for(auto& trigItem : m_trigList)
- setTrigInfo(trigItem);
- addTree(t, m_dir+"/Expert/support");
- }else{// each trigger
- for (int i = 0; i < (int) m_trigList.size(); i++) {
- std::string trigItem = m_trigList[i];
- addDirectory(m_dir+"/Expert/"+trigItem);
-
- TTree *t = new TTree( "trigger", "tree of trigger, egamma and monte carlo information");
- bookEventBranches( t );
- bookElectronBranches( t );
- //bookPhotonBranches( t );
- bookTriggerBranches( t );
- bookMonteCarloBranches( t );
- ATH_MSG_DEBUG("Already to attach the tree: " << trigItem);
- setTrigInfo(trigItem);
- addTree(t, m_dir+"/Expert/"+trigItem);
- }
- }
-
- // alloc memory to vector branchs
- alloc_space();
-
- return StatusCode::SUCCESS;
-}
-
-StatusCode TrigEgammaNavNtuple::childExecute(){
-
- m_eventCounter++;
-
- m_dir=plot()->getBasePath();
-
- cd(m_dir+"/Expert/Event");
- if( !EventWiseSelection() ) {
- ATH_MSG_DEBUG("Unable to retrieve offline containers");
- return StatusCode::FAILURE;
- }
-
- cd(m_dir+"/Expert");
-
-
- /// Egamma ntuple mode
- if(m_doOfflineDump){
- cd(m_dir+"/Expert/Offline");
- if(!executeElectronDump()) return StatusCode::FAILURE;
- if(!executePhotonDump()) return StatusCode::FAILURE;
- }else if(m_doSupport){
- if(!executeTrigSupportDump()) return StatusCode::FAILURE;
- }else{
- if(!executeTrigItemDump()) return StatusCode::FAILURE;
- }
-
- return StatusCode::SUCCESS;
-}
-
-
-StatusCode TrigEgammaNavNtuple::childFinalize(){
- //release_space();
- return StatusCode::SUCCESS;
-}
-
-
-bool TrigEgammaNavNtuple::executeElectronDump(){
-
- ATH_MSG_DEBUG("TrigEgammaNavNtuple::executeEgammaDump()");
-
- const xAOD::ElectronContainer* offElectrons = 0;
- if ( (m_storeGate->retrieve(offElectrons,m_offElContKey)).isFailure() ){
- ATH_MSG_ERROR("Failed to retrieve offline Electrons ");
- return false;
- }
-
- TTree *t = tree( "electron" , m_dir+"/Expert/Offline" );
- if(!t){
- ATH_MSG_ERROR("Can no get the ttree pointer into the store.");
- return false;
- }
-
- linkEventBranches(t);
- linkElectronBranches(t);
- linkMonteCarloBranches(t);
-
- for (const auto &eg : *offElectrons){
- clear();
- if(!eg->trackParticle()){
- ATH_MSG_DEBUG("No track Particle");
- continue;
- }
- if(!eg->caloCluster()){
- ATH_MSG_DEBUG("No caloCluster");
- continue;
- }
-
- if(m_rmCrack){///default is true
- if ( (fabs(eg->eta())>1.37 && fabs(eg->eta())<1.52) || fabs(eg->eta())>2.47 ) continue;
- }
-
- if (m_forceProbeIsolation) {///default is false
- if (!isIsolated(eg, "Loose")) continue;///default is Loose
- }
-
- if(m_forceMCEnhancedBias){///default is false
- const xAOD::TruthParticle *mc=nullptr;
- if( pdgid(eg,m_truthContainer,mc) != MonteCarlo::PDGID::EnhancedBias) continue;
- }
-
- const xAOD::Electron* el =static_cast<const xAOD::Electron*> (el);
-
- fillEvent();
- fillElectron( eg );
-
- if(!fillMonteCarlo( eg ) ){
- ATH_MSG_WARNING("Cound not found any TruthParticle for this Electron");
- }
-
- ATH_MSG_DEBUG("Record information into the ttree.");
- t->Fill();// save information
- }
-
- return true;
-}
-
-bool TrigEgammaNavNtuple::executePhotonDump(){
- return true;
-}
-
-
-bool TrigEgammaNavNtuple::executeTrigItemDump(){
-
-
- for(unsigned int ilist = 0; ilist != m_trigList.size(); ilist++) {
-
- std::string trigItem = m_trigList.at(ilist);
- const TrigInfo info = getTrigInfo(trigItem);
- if ( executeNavigation(info).isFailure() ){
- ATH_MSG_DEBUG("executeNavigation failure! continue...");
- return false;
- }
-
- TTree *t = tree( "trigger", m_dir+"/Expert/"+trigItem);
- linkEventBranches(t);
- linkElectronBranches(t);
- //linkPhotonBranches(t);
- linkTriggerBranches(t);
- linkMonteCarloBranches(t);
- ATH_MSG_DEBUG("ObjTEList size is: " << m_objTEList.size());
- for(unsigned int i = 0; i != m_objTEList.size(); ++i){
-
- const xAOD::Electron* el =static_cast<const xAOD::Electron*> (m_objTEList[i].first);
- //const xAOD::Photon* ph =static_cast<const xAOD::Photon*> (m_objTEList[i].first);
- const HLT::TriggerElement *feat = m_objTEList[i].second;
- if(feat == nullptr){
- ATH_MSG_WARNING("TriggerElement is nullptr");
- continue;
- }
-
- clear();
- fillEvent();
- fillElectron( el );
- //fillPhoton( ph );
-
- if(!fillMonteCarlo( el ) ){
- ATH_MSG_WARNING("Cound not found any TruthParticle for this Electron");
- }
-
- ///Start trigger analisys...
- const xAOD::EmTauRoI *emTauRoI = getFeature<xAOD::EmTauRoI>(feat);
- if(emTauRoI){
- fillEmTauRoI( emTauRoI );
- }else{
- ATH_MSG_WARNING("Cound not found EmTauRoI in this TriggerElement..");
- }
-
- const xAOD::TrigEMCluster *emCluster = getFeature<xAOD::TrigEMCluster>(feat);
- if(emCluster){
-
- if(!fillTrigEMCluster( emCluster )){
- ATH_MSG_WARNING("Cound not attach the trigEMCluster information into the tree.");
- }
-
- //const xAOD::TrigRNNOutput *rnnOutput=getFeature<xAOD::TrigRNNOutput>(feat);
- //if(rnnOutput) m_trig_L2_calo_rnnOutput = rnnOutput->rnnDecision().at(0);
-
- //if(TrigEgammaAnalysisBaseTool::getTrigCaloRings(emCluster, ringsContainer ,*m_trig_L2_calo_rings)){
- if(!fillTrigCaloRings( emCluster )){
- ATH_MSG_WARNING("Cound not attach the trigCaloRinger information into the tree.");
- }
-
- }///cluster protection
-
-
- const xAOD::TrigElectronContainer *trigElCont = getFeature<xAOD::TrigElectronContainer>(feat);
- // Level 2 ID+Calo
- if(trigElCont){
- for(const auto& trigEl : *trigElCont){
- if(!fillTrigElectron(trigEl)) {
- ATH_MSG_WARNING("Cound not attach the trigElectron information into the tree.");
- }
- }// loop over all trigElectrons for this feat
- }
-
- const xAOD::CaloClusterContainer *caloCont = getFeature<xAOD::CaloClusterContainer>(feat);
- if(caloCont){
- for(const auto& cl : *caloCont){
- if(!fillCaloCluster(cl)){
- ATH_MSG_WARNING("Cound not attach the CaloCluster information into the tree.");
- }
- }// loop over calo cluster
- }
-
- asg::AcceptData acceptData = setAccept(feat,info);
- m_trig_L1_accept = acceptData.getCutResult("L1Calo");
- m_trig_L2_calo_accept = acceptData.getCutResult("L2Calo");
- m_trig_L2_el_accept = acceptData.getCutResult("L2");
- m_trig_EF_calo_accept = acceptData.getCutResult("EFCalo");
- m_trig_EF_el_accept = acceptData.getCutResult("HLT");
-
- ATH_MSG_DEBUG("L1Calo: " << int(m_trig_L1_accept));
- ATH_MSG_DEBUG("L2Calo: " << int(m_trig_L2_calo_accept));
- ATH_MSG_DEBUG("L2 : " << int(m_trig_L2_el_accept));
- ATH_MSG_DEBUG("EFCalo: " << int(m_trig_EF_calo_accept));
- ATH_MSG_DEBUG("HLT : " << int(m_trig_EF_el_accept));
-
- ATH_MSG_DEBUG("Record information into the ttree.");
- t->Fill();// save information
- }// loop
- } // End loop over trigger
- return true;
-}
-
-
-bool TrigEgammaNavNtuple::executeTrigSupportDump(){
-
- double GeV=1000.;
- // Just do this to retrieve all offline electrons, dummy trigItem!
- const TrigInfo info = getTrigInfo(m_trigList[0]);
- if ( executeNavigation(info).isFailure() ){
- ATH_MSG_DEBUG("executeNavigation failure! continue...");
- return false;
- }//executeNavigation to collect electron
-
- std::vector<const HLT::TriggerElement *> vec_feat;
-
-
- cd(m_dir+"/Expert/support");
- TTree *t = tree( "trigger", m_dir+"/Expert/support");
- linkEventBranches(t);
- linkElectronBranches(t);
- linkTriggerBranches(t);
- linkMonteCarloBranches(t);
-
- // Loop over all good offline objects
- for(const auto& eg : m_objTEList){
-
- // Get the good electron
- const xAOD::Electron* el =static_cast<const xAOD::Electron*> (eg.first);
- // Force Et cut
- if(m_minEt > 0.0){
- if( !( getEt(el) > (m_minEt)*GeV) ) continue;
- }
- // Clear the vector
- vec_feat.clear();
- // Loop over support triggers
- for(auto& trigItem : m_trigList){
- const HLT::TriggerElement *feat;
- // Trigger match using Matching tool
- match()->match(el, trigItem, feat);
- if(feat){// If has a match!
- for(unsigned i=0; i < vec_feat.size(); ++i){
- if(getFeature<xAOD::EmTauRoI>(vec_feat[i])->roiWord() == getFeature<xAOD::EmTauRoI>(feat)->roiWord()){
- if(count_HLT_objects(feat) > count_HLT_objects(vec_feat[i])){
- vec_feat.erase(vec_feat.begin() + i); // Erase the trigger element lowest than the new feature
- vec_feat.push_back(feat); // attach the new trigger element
- break;
- }
- }// The same region in L1Calo trigger
- }
- if(vec_feat.empty()) vec_feat.push_back(feat);
- }
- }// Loop over support trigger
-
- ATH_MSG_DEBUG("Attach " << vec_feat.size() << " features ");
- for(auto& feat : vec_feat){
-
- clear();
- fillEvent();
- fillElectron( el );
-
- if(!fillMonteCarlo( el ) ){
- ATH_MSG_WARNING("Cound not found any TruthParticle for this Electron");
- if(m_forceMCMatch) continue;
- }
-
- ///Start trigger analisys...
- const xAOD::EmTauRoI *emTauRoI = getFeature<xAOD::EmTauRoI>(feat);
- if(emTauRoI){
- fillEmTauRoI( emTauRoI );
- }else{
- ATH_MSG_WARNING("Cound not found EmTauRoI in this TriggerElement..");
- }
-
- const xAOD::TrigEMCluster *emCluster = getFeature<xAOD::TrigEMCluster>(feat);
- if(emCluster){
- //ATH_MSG_INFO("AKI: Et = " << emCluster->et()*1e-3);
- //if(emCluster->et()*1e-3 < 20){
- // continue;
- //}
- if(!fillTrigEMCluster( emCluster )){
- ATH_MSG_WARNING("Cound not attach the trigEMCluster information into the tree.");
- }
-
- //if(TrigEgammaAnalysisBaseTool::getTrigCaloRings(emCluster, ringsContainer ,*m_trig_L2_calo_rings)){
- if(!fillTrigCaloRings( emCluster )){
- ATH_MSG_WARNING("Cound not attach the trigCaloRinger information into the tree.");
- }
- }///cluster protection
-
-
- const xAOD::TrigElectronContainer *trigElCont = getFeature<xAOD::TrigElectronContainer>(feat);
- // Level 2 ID+Calo
- if(trigElCont){
- for(const auto& trigEl : *trigElCont){
- if(!fillTrigElectron(trigEl)) {
- ATH_MSG_WARNING("Cound not attach the trigElectron information into the tree.");
- }
- }// loop over all trigElectrons for this feat
- }
-
- const xAOD::CaloClusterContainer *caloCont = getFeature<xAOD::CaloClusterContainer>(feat);
- if(caloCont){
- for(const auto& cl : *caloCont){
- if(!fillCaloCluster(cl)){
- ATH_MSG_WARNING("Cound not attach the CaloCluster information into the tree.");
- }
- }// loop over calo cluster
- }
-
- ATH_MSG_DEBUG("record trigger information into the file.");
- t->Fill();
- }//loop over trigger objects
-
- }// Loop over electrons
- return true;
-}
-
-
-
-
-
-
-
-bool TrigEgammaNavNtuple::fillEmTauRoI( const xAOD::EmTauRoI *emTauRoI ){
-
- m_trig_L1_eta = emTauRoI->eta();
- m_trig_L1_phi = emTauRoI->phi();
- m_trig_L1_emClus = emTauRoI->emClus();
- m_trig_L1_tauClus = emTauRoI->tauClus();
- m_trig_L1_emIsol = emTauRoI->emIsol();
- m_trig_L1_hadIsol = emTauRoI->hadIsol();
- for(unsigned i=0; i < emTauRoI->thrNames().size();++i) m_trig_L1_thrNames->push_back(emTauRoI->thrNames().at(i));
- return true;
-}
-
-bool TrigEgammaNavNtuple::fillCaloCluster( const xAOD::CaloCluster *cluster){
-
- m_trig_EF_calo_et->push_back(cluster->et());
- m_trig_EF_calo_eta->push_back(cluster->eta());
- return true;
-}
-
-bool TrigEgammaNavNtuple::fillTrigEMCluster( const xAOD::TrigEMCluster *emCluster ){
-
- m_trig_L2_calo_et = emCluster->et();
- m_trig_L2_calo_eta = emCluster->eta();
- m_trig_L2_calo_phi = emCluster->phi();
- m_trig_L2_calo_e237 = emCluster->e237();
- m_trig_L2_calo_e277 = emCluster->e277();
- m_trig_L2_calo_fracs1 = emCluster->fracs1();
- m_trig_L2_calo_weta2 = emCluster->weta2();
- m_trig_L2_calo_ehad1 = emCluster->ehad1();
- m_trig_L2_calo_emaxs1 = emCluster->emaxs1();
- m_trig_L2_calo_e2tsts1 = emCluster->e2tsts1();
- m_trig_L2_calo_wstot = emCluster->wstot();
- for(unsigned i=0; i<emCluster->energySample().size(); ++i){
- m_trig_L2_calo_energySample->push_back( emCluster->energySample().at(i));
- }
-
- return true;
-}
-
-
-bool TrigEgammaNavNtuple::fillTrigElectron( const xAOD::TrigElectron *trigEl ){
-
- const xAOD::TrackParticle* trkIter = trigEl->trackParticle();
- if (trkIter==nullptr) return false; // disconsider candidates without track
- int algoId = 0;
- if ( trkIter->patternRecoInfo()[xAOD::TrackPatternRecoInfo::FastTrackFinderSeed] ) algoId=9;
- if ( trkIter->patternRecoInfo()[xAOD::TrackPatternRecoInfo::strategyA] ) algoId=5;
- if ( trkIter->patternRecoInfo()[xAOD::TrackPatternRecoInfo::strategyB] ) algoId=6;
- if ( trkIter->patternRecoInfo()[xAOD::TrackPatternRecoInfo::strategyC] ) algoId=7;
-
- m_trig_L2_el_trackAlgID ->push_back(algoId);
- m_trig_L2_el_caloEta ->push_back(trigEl->caloEta());
- m_trig_L2_el_trkClusDphi ->push_back(trigEl->trkClusDphi());
- m_trig_L2_el_trkClusDeta ->push_back(trigEl->trkClusDeta());
- m_trig_L2_el_pt ->push_back(trigEl->pt());
- m_trig_L2_el_phi ->push_back(trigEl->phi());
- m_trig_L2_el_eta ->push_back(trigEl->eta());
- m_trig_L2_el_etOverPt ->push_back(trigEl->etOverPt());
- m_trig_L2_el_nTRTHits ->push_back(trigEl->nTRTHits());
- m_trig_L2_el_nTRTHiThresholdHits->push_back(trigEl->nTRTHiThresholdHits());
- m_trig_L2_el_charge ->push_back(trigEl->charge());
- return true;
-}
-
-
-
-bool TrigEgammaNavNtuple::fillEvent(){
- ///Event information
- m_runNumber = m_eventInfo->runNumber();
- m_eventNumber = m_eventInfo->eventNumber();
- m_avgmu=getAvgMu();
- return true;
-}
-
-bool TrigEgammaNavNtuple::fillElectron( const xAOD::Electron *el ){
-
- ///Cluster information
- m_el_et = el->pt();
- m_el_eta = el->eta();
- m_el_phi = el->phi();
- el->showerShapeValue( m_el_ethad1 , xAOD::EgammaParameters::ShowerShapeType::ethad1 );
- el->showerShapeValue( m_el_ehad1 , xAOD::EgammaParameters::ShowerShapeType::ehad1 );
- el->showerShapeValue( m_el_f1 , xAOD::EgammaParameters::ShowerShapeType::f1 );
- el->showerShapeValue( m_el_f3 , xAOD::EgammaParameters::ShowerShapeType::f3 );
- el->showerShapeValue( m_el_f1core , xAOD::EgammaParameters::ShowerShapeType::f1core );
- el->showerShapeValue( m_el_f3core , xAOD::EgammaParameters::ShowerShapeType::f3core );
- el->showerShapeValue( m_el_weta2 , xAOD::EgammaParameters::ShowerShapeType::weta2 );
- el->showerShapeValue( m_el_wtots1 , xAOD::EgammaParameters::ShowerShapeType::wtots1 );
- el->showerShapeValue( m_el_fracs1 , xAOD::EgammaParameters::ShowerShapeType::fracs1 );
- el->showerShapeValue( m_el_Reta , xAOD::EgammaParameters::ShowerShapeType::Reta );
- el->showerShapeValue( m_el_Rphi , xAOD::EgammaParameters::ShowerShapeType::Rphi );
- el->showerShapeValue( m_el_Eratio , xAOD::EgammaParameters::ShowerShapeType::Eratio );
- el->showerShapeValue( m_el_Rhad , xAOD::EgammaParameters::ShowerShapeType::Rhad );
- el->showerShapeValue( m_el_Rhad1 , xAOD::EgammaParameters::ShowerShapeType::Rhad1 );
-
- ///Combined track/Cluter information
- el->trackCaloMatchValue( m_el_deta1 , xAOD::EgammaParameters::TrackCaloMatchType::deltaEta1 );
- el->trackCaloMatchValue( m_el_deta2 , xAOD::EgammaParameters::TrackCaloMatchType::deltaEta2 );
- el->trackCaloMatchValue( m_el_dphi2 , xAOD::EgammaParameters::TrackCaloMatchType::deltaPhi2 );
- el->trackCaloMatchValue( m_el_dphiresc , xAOD::EgammaParameters::TrackCaloMatchType::deltaPhiRescaled0 );
- el->trackCaloMatchValue( m_el_dphiresc2 , xAOD::EgammaParameters::TrackCaloMatchType::deltaPhiRescaled2 );
-
-
- ///Track particle information
- const xAOD::TrackParticle *track = el->trackParticle();
- if(track){
- m_el_pt = track->pt();
- m_el_d0 = fabsf(track->d0());
- m_el_charge = el->charge();
-
- track->summaryValue( m_el_eprobht , xAOD::SummaryType::eProbabilityHT );
- track->summaryValue( m_el_nblayerhits , xAOD::SummaryType::numberOfInnermostPixelLayerHits );
- track->summaryValue( m_el_nblayerolhits , xAOD::SummaryType::numberOfInnermostPixelLayerOutliers );
- track->summaryValue( m_el_npixhits , xAOD::SummaryType::numberOfPixelHits );
- track->summaryValue( m_el_npixolhits , xAOD::SummaryType::numberOfPixelOutliers );
- track->summaryValue( m_el_nscthits , xAOD::SummaryType::numberOfSCTHits );
- track->summaryValue( m_el_nsctolhits , xAOD::SummaryType::numberOfSCTOutliers );
- track->summaryValue( m_el_ntrthightreshits , xAOD::SummaryType::numberOfTRTHighThresholdHits );
- track->summaryValue( m_el_ntrthits , xAOD::SummaryType::numberOfTRTHits);
- track->summaryValue( m_el_ntrthighthresolhits, xAOD::SummaryType::numberOfTRTHighThresholdOutliers );
- track->summaryValue( m_el_ntrtolhits , xAOD::SummaryType::numberOfTRTOutliers );
- track->summaryValue( m_el_ntrtxenonhits , xAOD::SummaryType::numberOfTRTXenonHits );
- //track->summaryValue( m_el_expectblayerhit , xAOD::SummaryType::expectInnermostPixelLayerHit );
- track->summaryValue( m_el_npixdeadsensors , xAOD::SummaryType::numberOfPixelDeadSensors);
- track->summaryValue( m_el_nsctdeadsensors , xAOD::SummaryType::numberOfSCTDeadSensors);
-
- m_el_nsideadsensors = m_el_npixdeadsensors + m_el_nsctdeadsensors;
- m_el_nsihits = m_el_npixhits + m_el_nscthits;
- }
-
- //m_el_loose = el->passSelection("Loose");
- //m_el_medium = el->passSelection("Medium");
- //m_el_tight = el->passSelection("Tight");
- //m_el_lhLoose = el->passSelection("LHLoose");
- //m_el_lhMedium = el->passSelection("LHMedium");
- //m_el_lhTight = el->passSelection("LHTight");
- //m_el_rgLoose = el->passSelection("RGLoose");
- //m_el_rgMedium = el->passSelection("RGMedium");
- //m_el_rgTight = el->passSelection("RGTight");
- //m_el_multiLepton = el->passSelection("MultiLepton");
- m_el_loose = ApplyElectronPid(el, "Loose");
- m_el_medium = ApplyElectronPid(el, "Medium");
- m_el_tight = ApplyElectronPid(el, "Tight");
- m_el_lhLoose = ApplyElectronPid(el, "LHLoose");
- m_el_lhMedium = ApplyElectronPid(el, "LHMedium");
- m_el_lhTight = ApplyElectronPid(el, "LHTight");
- //m_el_rgLoose = ApplyElectronPid(el, "RGLoose");
- //m_el_rgMedium = ApplyElectronPid(el, "RGMedium");
- //m_el_rgTight = ApplyElectronPid(el, "RGTight");
-
- m_calo_et = getCluster_et( el );
- m_calo_eta = getCluster_eta( el );
- m_calo_phi = getCluster_phi( el );
- ///Extra information about pileup
- m_el_nGoodVtx = getNGoodVertex();
- m_el_nPileupPrimaryVtx = getNPVtx();
-
-
- if(!fillCaloRings( el )){
- ATH_MSG_WARNING("Could not attach the calorRings information.");
- }
-
- return true;
-}
-
-
-/*bool TrigEgammaNavNtuple::fillPhoton( const xAOD::Photon *ph ){
- return true;
-}*/
-
-bool TrigEgammaNavNtuple::fillMonteCarlo(const xAOD::Egamma *eg){
-
- if(m_truthContainer){
- ATH_MSG_DEBUG("TruthParticle container size is: " << m_truthContainer->size());
- const xAOD::TruthParticle *mc=nullptr;
- MonteCarlo::PDGID pdg = pdgid(eg, m_truthContainer,mc);
- if(mc){
- m_mc_hasMC = true;
- m_mc_pt = mc->pt();
- m_mc_eta = mc->eta();
- m_mc_phi = mc->phi();
- m_mc_isTop = mc->isTop();
- m_mc_isQuark = mc->isQuark();
- m_mc_isParton = mc->isParton();
- m_mc_isMeson = mc->isMeson();
- m_mc_isTau = mc->isTau();
- m_mc_isMuon = mc->isMuon();
- m_mc_isPhoton = mc->isPhoton();
- m_mc_isElectron = mc->isElectron();
- if(pdg == MonteCarlo::PDGID::ZMother) m_mc_hasZMother = true;
- if(pdg == MonteCarlo::PDGID::WMother) m_mc_hasWMother = true;
- return true;
- }//has match
- }//has truth container
- return false;
-}
-
-
-bool TrigEgammaNavNtuple::fillTrigCaloRings( const xAOD::TrigEMCluster *emCluster ){
- return TrigEgammaAnalysisBaseTool::getTrigCaloRings(emCluster, *m_trig_L2_calo_rings);
-}
-
-
-bool TrigEgammaNavNtuple::fillCaloRings( const xAOD::Electron *el ){
- return TrigEgammaAnalysisBaseTool::getCaloRings(el, *m_el_ringsE );
-}
-
-/*
- * book, link, clear, alloc and release method divide in:
- * trigger, Egamma and MonteCarlo data base.
- */
-
-template <class T>
-void TrigEgammaNavNtuple::InitBranch(TTree* fChain, std::string branch_name, T* param, bool message){
-
- std::string bname = branch_name;
- if (fChain->GetAlias(bname.c_str()))
- bname = std::string(fChain->GetAlias(bname.c_str()));
-
- if (!fChain->FindBranch(bname.c_str()) && message) {
- ATH_MSG_WARNING("unknown branch " << bname);
- return;
- }
- fChain->SetBranchStatus(bname.c_str(), 1.);
- fChain->SetBranchAddress(bname.c_str(), param);
-}
-
-void TrigEgammaNavNtuple::bookEventBranches(TTree *t){
-
- t->Branch("RunNumber", &m_runNumber);
- t->Branch("EventNumber", &m_eventNumber);
- t->Branch("avgmu", &m_avgmu);
-}
-
-void TrigEgammaNavNtuple::bookTriggerBranches(TTree *t){
-
- // Level L1 cluster
- t->Branch( "trig_L1_eta", &m_trig_L1_eta);
- t->Branch( "trig_L1_phi", &m_trig_L1_phi);
- t->Branch( "trig_L1_emClus", &m_trig_L1_emClus);
- t->Branch( "trig_L1_tauClus", &m_trig_L1_tauClus);
- t->Branch( "trig_L1_emIsol", &m_trig_L1_emIsol);
- t->Branch( "trig_L1_hadIsol", &m_trig_L1_hadIsol);
- t->Branch( "trig_L1_thrNames", &m_trig_L1_thrNames);
- t->Branch( "trig_L1_accept", &m_trig_L1_accept);
- t->Branch( "trig_L2_calo_et", &m_trig_L2_calo_et);
- t->Branch( "trig_L2_calo_eta", &m_trig_L2_calo_eta);
- t->Branch( "trig_L2_calo_phi", &m_trig_L2_calo_phi);
- t->Branch( "trig_L2_calo_e237", &m_trig_L2_calo_e237 );
- t->Branch( "trig_L2_calo_e277", &m_trig_L2_calo_e277 );
- t->Branch( "trig_L2_calo_fracs1", &m_trig_L2_calo_fracs1);
- t->Branch( "trig_L2_calo_weta2", &m_trig_L2_calo_weta2);
- t->Branch( "trig_L2_calo_ehad1", &m_trig_L2_calo_ehad1);
- t->Branch( "trig_L2_calo_emaxs1", &m_trig_L2_calo_emaxs1);
- t->Branch( "trig_L2_calo_e2tsts1", &m_trig_L2_calo_e2tsts1);
- t->Branch( "trig_L2_calo_wstot", &m_trig_L2_calo_wstot);
- t->Branch( "trig_L2_calo_energySample",&m_trig_L2_calo_energySample );
- t->Branch( "trig_L2_calo_rings", &m_trig_L2_calo_rings );
- t->Branch( "trig_L2_calo_rnnOutput", &m_trig_L2_calo_rnnOutput );
- t->Branch( "trig_L2_calo_accept", &m_trig_L2_calo_accept);
- t->Branch( "trig_L2_el_trackAlgID" , &m_trig_L2_el_trackAlgID );
- t->Branch( "trig_L2_el_pt" , &m_trig_L2_el_pt );
- t->Branch( "trig_L2_el_eta", &m_trig_L2_el_eta);
- t->Branch( "trig_L2_el_phi", &m_trig_L2_el_phi );
- t->Branch( "trig_L2_el_caloEta", &m_trig_L2_el_caloEta );
- t->Branch( "trig_L2_el_charge", &m_trig_L2_el_charge);
- t->Branch( "trig_L2_el_nTRTHits", &m_trig_L2_el_nTRTHits);
- t->Branch( "trig_L2_el_nTRTHiThresholdHits", &m_trig_L2_el_nTRTHiThresholdHits);
- t->Branch( "trig_L2_el_etOverPt" , &m_trig_L2_el_etOverPt );
- t->Branch( "trig_L2_el_trkClusDeta" , &m_trig_L2_el_trkClusDeta );
- t->Branch( "trig_L2_el_trkClusDphi" , &m_trig_L2_el_trkClusDphi );
- t->Branch( "trig_L2_el_accept", &m_trig_L2_el_accept );
- t->Branch( "trig_EF_calo_accept", &m_trig_EF_calo_accept);
- t->Branch( "trig_EF_calo_et", &m_trig_EF_calo_et);
- t->Branch( "trig_EF_calo_eta", &m_trig_EF_calo_eta);
- t->Branch( "trig_EF_el_accept", &m_trig_EF_el_accept);
-}
-
-void TrigEgammaNavNtuple::bookElectronBranches(TTree *t){
-
- t->Branch("el_et", &m_el_et);
- t->Branch("el_pt", &m_el_pt);
- t->Branch("el_eta", &m_el_eta);
- t->Branch("el_phi", &m_el_phi);
- t->Branch("el_ethad1", &m_el_ethad1);
- t->Branch("el_ehad1", &m_el_ehad1);
- t->Branch("el_f1", &m_el_f1);
- t->Branch("el_f3", &m_el_f3);
- t->Branch("el_f1core", &m_el_f1core);
- t->Branch("el_f3core", &m_el_f3core);
- t->Branch("el_weta2", &m_el_weta2);
- t->Branch("el_d0", &m_el_d0);
- t->Branch("el_wtots1", &m_el_wtots1);
- t->Branch("el_fracs1", &m_el_fracs1);
- t->Branch("el_Reta", &m_el_Reta);
- t->Branch("el_Rphi", &m_el_Rphi);
- t->Branch("el_Eratio", &m_el_Eratio);
- t->Branch("el_Rhad", &m_el_Rhad);
- t->Branch("el_Rhad1", &m_el_Rhad1);
- t->Branch("el_deta1", &m_el_deta1);
- t->Branch("el_deta2", &m_el_deta2);
- t->Branch("el_dphi2", &m_el_dphi2);
- t->Branch("el_dphiresc", &m_el_dphiresc);
- t->Branch("el_dphiresc2", &m_el_dphiresc2);
- t->Branch("el_eprobht", &m_el_eprobht);
- t->Branch("el_charge", &m_el_charge);
- t->Branch("el_nblayerhits", &m_el_nblayerhits);
- t->Branch("el_nblayerolhits", &m_el_nblayerolhits);
- t->Branch("el_npixhits", &m_el_npixhits);
- t->Branch("el_npixolhits", &m_el_npixolhits);
- t->Branch("el_nscthits", &m_el_nscthits);
- t->Branch("el_nsctolhits", &m_el_nsctolhits);
- t->Branch("el_ntrthightreshits", &m_el_ntrthightreshits);
- t->Branch("el_ntrthits", &m_el_ntrthits);
- t->Branch("el_ntrthighthresolhits", &m_el_ntrthighthresolhits);
- t->Branch("el_ntrtolhits", &m_el_ntrtolhits);
- t->Branch("el_ntrtxenonhits", &m_el_ntrtxenonhits);
- t->Branch("el_expectblayerhit", &m_el_expectblayerhit);
- t->Branch("el_nsihits", &m_el_nsihits );
- t->Branch("el_nsideadsensors", &m_el_nsideadsensors );
- t->Branch("el_npixdeadsensors", &m_el_npixdeadsensors );
- t->Branch("el_nsctdeadsensors", &m_el_nsctdeadsensors );
- t->Branch("el_ringsE", &m_el_ringsE );
- t->Branch("el_loose", &m_el_loose );
- t->Branch("el_medium", &m_el_medium );
- t->Branch("el_tight", &m_el_tight );
- t->Branch("el_lhLoose", &m_el_lhLoose );
- t->Branch("el_lhMedium", &m_el_lhMedium );
- t->Branch("el_lhTight", &m_el_lhTight );
- t->Branch("el_rgLoose", &m_el_rgLoose );
- t->Branch("el_rgMedium", &m_el_rgMedium );
- t->Branch("el_rgTight", &m_el_rgTight );
- t->Branch("el_multiLepton", &m_el_multiLepton);
- t->Branch("el_nGoodVtx", &m_el_nGoodVtx);
- t->Branch("el_nPileupPrimaryVtx", &m_el_nPileupPrimaryVtx);
- t->Branch("calo_et", &m_calo_et);
- t->Branch("calo_eta", &m_calo_eta);
- t->Branch("calo_phi", &m_calo_phi);
-
-}
-
-
-/*void TrigEgammaNavNtuple::bookPhotonBranches(TTree *t){
-} */
-
-void TrigEgammaNavNtuple::bookMonteCarloBranches(TTree *t){
- // Monte Carlo
- t->Branch("mc_hasMC", &m_mc_hasMC);
- t->Branch("mc_pt", &m_mc_pt);
- t->Branch("mc_eta", &m_mc_eta);
- t->Branch("mc_phi", &m_mc_phi);
- t->Branch("mc_isTop", &m_mc_isTop);
- t->Branch("mc_isParton", &m_mc_isParton);
- t->Branch("mc_isMeson", &m_mc_isMeson);
- t->Branch("mc_isTau", &m_mc_isTau);
- t->Branch("mc_isMuon", &m_mc_isMuon);
- t->Branch("mc_isPhoton", &m_mc_isPhoton);
- t->Branch("mc_isElectron", &m_mc_isElectron);
- t->Branch("mc_hasZMother", &m_mc_hasZMother);
- t->Branch("mc_hasWMother", &m_mc_hasWMother);
-}
-
-void TrigEgammaNavNtuple::linkEventBranches(TTree *t){
-
- InitBranch( t, "RunNumber", &m_runNumber);
- InitBranch( t, "EventNumber", &m_eventNumber);
- InitBranch( t, "avgmu", &m_avgmu);
-}
-
-void TrigEgammaNavNtuple::linkElectronBranches( TTree *t ){
-
- InitBranch( t, "el_et", &m_el_et);
- InitBranch( t, "el_pt", &m_el_pt);
- InitBranch( t, "el_eta", &m_el_eta);
- InitBranch( t, "el_phi", &m_el_phi);
- InitBranch( t, "el_ethad1", &m_el_ethad1);
- InitBranch( t, "el_ehad1", &m_el_ehad1);
- InitBranch( t, "el_f1", &m_el_f1);
- InitBranch( t, "el_f3", &m_el_f3);
- InitBranch( t, "el_f1core", &m_el_f1core);
- InitBranch( t, "el_f3core", &m_el_f3core);
- InitBranch( t, "el_weta2", &m_el_weta2);
- InitBranch( t, "el_d0", &m_el_d0);
- InitBranch( t, "el_wtots1", &m_el_wtots1);
- InitBranch( t, "el_fracs1", &m_el_fracs1);
- InitBranch( t, "el_Reta", &m_el_Reta);
- InitBranch( t, "el_Rphi", &m_el_Rphi);
- InitBranch( t, "el_Eratio", &m_el_Eratio);
- InitBranch( t, "el_Rhad", &m_el_Rhad);
- InitBranch( t, "el_Rhad1", &m_el_Rhad1);
- InitBranch( t, "el_deta1", &m_el_deta1);
- InitBranch( t, "el_deta2", &m_el_deta2);
- InitBranch( t, "el_dphi2", &m_el_dphi2);
- InitBranch( t, "el_dphiresc", &m_el_dphiresc);
- InitBranch( t, "el_dphiresc2", &m_el_dphiresc2);
- InitBranch( t, "el_eprobht", &m_el_eprobht);
- InitBranch( t, "el_charge", &m_el_charge);
- InitBranch( t, "el_nblayerhits", &m_el_nblayerhits);
- InitBranch( t, "el_nblayerolhits", &m_el_nblayerolhits);
- InitBranch( t, "el_npixhits", &m_el_npixhits);
- InitBranch( t, "el_npixolhits", &m_el_npixolhits);
- InitBranch( t, "el_nscthits", &m_el_nscthits);
- InitBranch( t, "el_nsctolhits", &m_el_nsctolhits);
- InitBranch( t, "el_ntrthightreshits", &m_el_ntrthightreshits);
- InitBranch( t, "el_ntrthits", &m_el_ntrthits);
- InitBranch( t, "el_ntrthighthresolhits", &m_el_ntrthighthresolhits);
- InitBranch( t, "el_ntrtolhits", &m_el_ntrtolhits);
- InitBranch( t, "el_ntrtxenonhits", &m_el_ntrtxenonhits);
- InitBranch( t, "el_expectblayerhit", &m_el_expectblayerhit);
- InitBranch( t, "el_nsihits", &m_el_nsihits );
- InitBranch( t, "el_nsideadsensors", &m_el_nsideadsensors );
- InitBranch( t, "el_npixdeadsensors", &m_el_npixdeadsensors );
- InitBranch( t, "el_nsctdeadsensors", &m_el_nsctdeadsensors );
- InitBranch( t, "el_ringsE", &m_el_ringsE );
- InitBranch( t, "el_loose", &m_el_loose );
- InitBranch( t, "el_medium", &m_el_medium );
- InitBranch( t, "el_tight", &m_el_tight );
- InitBranch( t, "el_lhLoose", &m_el_lhLoose );
- InitBranch( t, "el_lhMedium", &m_el_lhMedium );
- InitBranch( t, "el_lhTight", &m_el_lhTight );
- InitBranch( t, "el_rgLoose", &m_el_rgLoose );
- InitBranch( t, "el_rgMedium", &m_el_rgMedium );
- InitBranch( t, "el_rgTight", &m_el_rgTight );
- InitBranch( t, "el_multiLepton", &m_el_multiLepton);
- InitBranch( t, "el_nGoodVtx", &m_el_nGoodVtx);
- InitBranch( t, "el_nPileupPrimaryVtx", &m_el_nPileupPrimaryVtx);
- InitBranch( t, "calo_et", &m_calo_et);
- InitBranch( t, "calo_eta", &m_calo_eta);
- InitBranch( t, "calo_phi", &m_calo_phi);
-
-}
-
-
-/*void TrigEgammaNavNtuple::linkPhotonBranches( TTree *t ){
-}*/
-
-void TrigEgammaNavNtuple::linkTriggerBranches( TTree *t ){
-
- InitBranch(t, "trig_L1_eta", &m_trig_L1_eta);
- InitBranch(t, "trig_L1_phi", &m_trig_L1_phi);
- InitBranch(t, "trig_L1_emClus", &m_trig_L1_emClus);
- InitBranch(t, "trig_L1_tauClus", &m_trig_L1_tauClus);
- InitBranch(t, "trig_L1_emIsol", &m_trig_L1_emIsol);
- InitBranch(t, "trig_L1_hadIsol", &m_trig_L1_hadIsol);
- InitBranch(t, "trig_L1_thrNames", &m_trig_L1_thrNames);
- InitBranch(t, "trig_L1_accept", &m_trig_L1_accept);
- InitBranch(t, "trig_L2_calo_et", &m_trig_L2_calo_et);
- InitBranch(t, "trig_L2_calo_eta", &m_trig_L2_calo_eta);
- InitBranch(t, "trig_L2_calo_phi", &m_trig_L2_calo_phi);
- InitBranch(t, "trig_L2_calo_e237", &m_trig_L2_calo_e237 );
- InitBranch(t, "trig_L2_calo_e277", &m_trig_L2_calo_e277 );
- InitBranch(t, "trig_L2_calo_fracs1", &m_trig_L2_calo_fracs1);
- InitBranch(t, "trig_L2_calo_weta2", &m_trig_L2_calo_weta2);
- InitBranch(t, "trig_L2_calo_ehad1", &m_trig_L2_calo_ehad1);
- InitBranch(t, "trig_L2_calo_emaxs1", &m_trig_L2_calo_emaxs1);
- InitBranch(t, "trig_L2_calo_e2tsts1", &m_trig_L2_calo_e2tsts1);
- InitBranch(t, "trig_L2_calo_wstot", &m_trig_L2_calo_wstot);
- InitBranch(t, "trig_L2_calo_rnnOutput", &m_trig_L2_calo_rnnOutput );
- InitBranch(t, "trig_L2_calo_rings", &m_trig_L2_calo_rings );
- InitBranch(t, "trig_L2_calo_energySample",&m_trig_L2_calo_energySample );
- InitBranch(t, "trig_L2_calo_accept", &m_trig_L2_calo_accept);
-
- InitBranch(t, "trig_L2_el_trackAlgID" , &m_trig_L2_el_trackAlgID );
- InitBranch(t, "trig_L2_el_pt" , &m_trig_L2_el_pt );
- InitBranch(t, "trig_L2_el_eta", &m_trig_L2_el_eta);
- InitBranch(t, "trig_L2_el_phi", &m_trig_L2_el_phi );
- InitBranch(t, "trig_L2_el_caloEta", &m_trig_L2_el_caloEta );
- InitBranch(t, "trig_L2_el_charge", &m_trig_L2_el_charge);
- InitBranch(t, "trig_L2_el_nTRTHits", &m_trig_L2_el_nTRTHits);
- InitBranch(t, "trig_L2_el_nTRTHiThresholdHits", &m_trig_L2_el_nTRTHiThresholdHits);
- InitBranch(t, "trig_L2_el_etOverPt" , &m_trig_L2_el_etOverPt );
- InitBranch(t, "trig_L2_el_trkClusDeta" , &m_trig_L2_el_trkClusDeta );
- InitBranch(t, "trig_L2_el_trkClusDphi" , &m_trig_L2_el_trkClusDphi );
-
- InitBranch(t, "trig_L2_el_accept", &m_trig_L2_el_accept );
- InitBranch(t, "trig_EF_el_accept", &m_trig_EF_el_accept );
- InitBranch(t, "trig_EF_calo_accept", &m_trig_EF_calo_accept );
- InitBranch(t, "trig_EF_calo_et", &m_trig_EF_calo_et );
- InitBranch(t, "trig_EF_calo_eta", &m_trig_EF_calo_eta );
-
-}
-
-
-void TrigEgammaNavNtuple::linkMonteCarloBranches(TTree *t){
-
- InitBranch(t, "mc_hasMC", &m_mc_hasMC);
- InitBranch(t, "mc_pt", &m_mc_pt);
- InitBranch(t, "mc_eta", &m_mc_eta);
- InitBranch(t, "mc_phi", &m_mc_phi);
- InitBranch(t, "mc_isTop", &m_mc_isTop);
- InitBranch(t, "mc_isParton", &m_mc_isParton);
- InitBranch(t, "mc_isMeson", &m_mc_isMeson);
- InitBranch(t, "mc_isTau", &m_mc_isTau);
- InitBranch(t, "mc_isMuon", &m_mc_isMuon);
- InitBranch(t, "mc_isPhoton", &m_mc_isPhoton);
- InitBranch(t, "mc_isElectron", &m_mc_isElectron);
- InitBranch(t, "mc_hasZMother", &m_mc_hasZMother);
- InitBranch(t, "mc_hasWMother", &m_mc_hasWMother);
-}
-
-
-void TrigEgammaNavNtuple::clear(){
-
- ///EventInfo
- m_runNumber = 0;
- m_eventNumber = 0;
- m_avgmu = 0;
- ///Egamma
- m_el_et = -1;
- m_el_pt = -1;
- m_el_eta = -1;
- m_el_phi = -1;
- m_el_ethad1 = -1;
- m_el_ehad1 = -1;
- m_el_f1 = -1;
- m_el_f3 = -1;
- m_el_f1core = -1;
- m_el_f3core = -1;
- m_el_weta2 = -1;
- m_el_d0 = -1;
- m_el_wtots1 = -1;
- m_el_fracs1 = -1;
- m_el_Reta = -1;
- m_el_Rphi = -1;
- m_el_Eratio = -1;
- m_el_Rhad = -1;
- m_el_Rhad1 = -1;
- m_el_deta1 = -1;
- m_el_deta2 = -1;
- m_el_dphi2 = -1;
- m_el_dphiresc = -1;
- m_el_dphiresc2 = -1;
- m_el_eprobht = -1;
- m_el_charge = 0;
- m_el_nblayerhits = 0;
- m_el_nblayerolhits = 0;
- m_el_npixhits = 0;
- m_el_npixolhits = 0;
- m_el_nscthits = 0;
- m_el_nsctolhits = 0;
- m_el_ntrthightreshits = 0;
- m_el_ntrthits = 0;
- m_el_ntrthighthresolhits= 0;
- m_el_ntrtolhits = 0;
- m_el_ntrtxenonhits = 0;
- m_el_expectblayerhit = false;
- m_el_nsihits = 0;
- m_el_nsideadsensors = 0;
- m_el_npixdeadsensors = 0;
- m_el_nsctdeadsensors = 0;
- m_el_loose = false;
- m_el_medium = false;
- m_el_tight = false;
- m_el_lhLoose = false;
- m_el_lhMedium = false;
- m_el_lhTight = false;
- m_el_rgLoose = false;
- m_el_rgMedium = false;
- m_el_rgTight = false;
- m_el_multiLepton = false;
- m_el_nGoodVtx = -1;
- m_el_nPileupPrimaryVtx = -1;
- m_calo_et = -1;
- m_calo_eta = -1;
- m_calo_phi = -1;
-
- ///Trigger
- m_trig_L1_eta = -1;
- m_trig_L1_phi = -1;
- m_trig_L1_emClus = -1;
- m_trig_L1_tauClus = -1;
- m_trig_L1_emIsol = -1;
- m_trig_L1_hadIsol = -1;
- m_trig_L1_accept = false;
- m_trig_L2_calo_et = -1;
- m_trig_L2_calo_eta = -1;
- m_trig_L2_calo_phi = -1;
- m_trig_L2_calo_e237 = -1;
- m_trig_L2_calo_e277 = -1;
- m_trig_L2_calo_fracs1 = -1;
- m_trig_L2_calo_weta2 = -1;
- m_trig_L2_calo_ehad1 = -1;
- m_trig_L2_calo_emaxs1 = -1;
- m_trig_L2_calo_e2tsts1 = -1;
- m_trig_L2_calo_wstot = -1;
- m_trig_L2_calo_rnnOutput = 999;
-
- m_trig_L1_accept = false;
- m_trig_L2_calo_accept = false;
- m_trig_L2_el_accept = false;
- m_trig_EF_calo_accept = false;
- m_trig_EF_el_accept = false;
-
- ///Monte Carlo
- m_mc_hasMC = false;
- m_mc_pt = -1;
- m_mc_eta = -1;
- m_mc_phi = -1;
- m_mc_isTop = false;
- m_mc_isParton = false;
- m_mc_isMeson = false;
- m_mc_isTau = false;
- m_mc_isMuon = false;
- m_mc_isPhoton = false;
- m_mc_isElectron = false;
- m_mc_hasZMother = false;
- m_mc_hasWMother = false;
-
- ///Some vectors
- m_trig_L1_thrNames ->clear();
- m_trig_L2_calo_energySample ->clear();
- m_trig_L2_calo_rings ->clear();
-
- m_trig_L2_el_trackAlgID ->clear();
- m_trig_L2_el_eta ->clear();
- m_trig_L2_el_phi ->clear();
- m_trig_L2_el_caloEta ->clear();
- m_trig_L2_el_trkClusDeta ->clear();
- m_trig_L2_el_trkClusDphi ->clear();
- m_trig_L2_el_pt ->clear();
- m_trig_L2_el_etOverPt ->clear();
- m_trig_L2_el_nTRTHits ->clear();
- m_trig_L2_el_nTRTHiThresholdHits ->clear();
- m_trig_L2_el_charge ->clear();
- m_trig_EF_calo_et ->clear();
-}
-
-void TrigEgammaNavNtuple::alloc_space(){
-
- m_el_ringsE = new std::vector<float>();
- m_trig_L1_thrNames = new std::vector<std::string>();
- m_trig_L2_calo_energySample = new std::vector<float>();
- m_trig_L2_calo_rings = new std::vector<float>();
- m_trig_L2_el_trackAlgID = new std::vector<int>();
- m_trig_L2_el_eta = new std::vector<float>();
- m_trig_L2_el_phi = new std::vector<float>();
- m_trig_L2_el_caloEta = new std::vector<float>();
- m_trig_L2_el_trkClusDeta = new std::vector<float>();
- m_trig_L2_el_trkClusDphi = new std::vector<float>();
- m_trig_L2_el_pt = new std::vector<float>();
- m_trig_L2_el_etOverPt = new std::vector<float>();
- m_trig_L2_el_nTRTHits = new std::vector<float>();
- m_trig_L2_el_nTRTHiThresholdHits = new std::vector<float>();
- m_trig_L2_el_charge = new std::vector<float>();
- m_trig_EF_calo_et = new std::vector<float>();
- m_trig_EF_calo_eta = new std::vector<float>();
-
-}
-
-void TrigEgammaNavNtuple::release_space(){
- delete m_el_ringsE ;
- delete m_trig_L1_thrNames ;
- delete m_trig_L2_calo_energySample;
- delete m_trig_L2_calo_rings ;
- delete m_trig_L2_el_trackAlgID ;
- delete m_trig_L2_el_pt ;
- delete m_trig_L2_el_eta ;
- delete m_trig_L2_el_caloEta ;
- delete m_trig_L2_el_phi ;
- delete m_trig_L2_el_charge ;
- delete m_trig_L2_el_nTRTHits ;
- delete m_trig_L2_el_nTRTHiThresholdHits ;
- delete m_trig_L2_el_etOverPt ;
- delete m_trig_L2_el_trkClusDeta ;
- delete m_trig_L2_el_trkClusDphi ;
- delete m_trig_EF_calo_et ;
- delete m_trig_EF_calo_eta ;
-}
-
-unsigned TrigEgammaNavNtuple::count_HLT_objects( const HLT::TriggerElement *feat )
-{
- unsigned nobj=0;
- if(getFeature<xAOD::ElectronContainer>(feat) ) nobj++; // HLT
- if(getFeature<xAOD::CaloClusterContainer>(feat) ) nobj++; // EFCalo
- if(getFeature<xAOD::TrigElectronContainer>(feat)) nobj++; // L2
- if(getFeature<xAOD::TrigEMCluster>(feat) ) nobj++; // L2Calo
- ATH_MSG_DEBUG("Number of objects counted in this feature: " << nobj);
- return nobj;
-}
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaNavTPAnalysisTool.cxx b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaNavTPAnalysisTool.cxx
index 57a1a2058f76f9e7f9fbca8b03424a9ad15f0f9e..c13b73ef8d1fbf887f923596d0735186e99d4c61 100644
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaNavTPAnalysisTool.cxx
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaNavTPAnalysisTool.cxx
@@ -48,9 +48,21 @@ StatusCode TrigEgammaNavTPAnalysisTool::childBook(){
if (std::find(chains.begin(), chains.end(), trigName) != chains.end()){
if(plot()->getTrigInfoMap().count(trigName) != 0)
ATH_MSG_WARNING("Trigger already booked, removing from trigger list " << trigName);
- else
+ else {
m_trigList.push_back(trigName);
+ setTrigInfo(trigName);
+ }
}
+
+ // specail code to add trigger without the menu
+ else if(getEmulation() && m_forceTrigAttachment){//
+ ATH_MSG_INFO("Trigger doesn't exist in menu. Attach to emulate.");
+ if(plot()->getTrigInfoMap().count(trigName) == 0){
+ m_trigList.push_back(trigName);
+ setTrigEmulation();
+ setTrigInfo(trigName);
+ }
+ }// emulation
}
// Book histograms for average efficiencies and counters
const int nTrigger = (int) m_trigList.size();
@@ -104,9 +116,6 @@ StatusCode TrigEgammaNavTPAnalysisTool::childBook(){
setLabels(hist1(m_anatype+"_EffHLT"),m_trigList);
setLabels(hist1(m_anatype+"_CutCounter"),m_cutlabels);
}
- // Book the histograms per signature
- for (int i = 0; i < (int) m_trigList.size(); i++)
- setTrigInfo(m_trigList[i]);
plot()->setEmulation(getEmulation());
if(plot()->book(getTrigInfoMap()).isFailure()){
@@ -136,6 +145,19 @@ StatusCode TrigEgammaNavTPAnalysisTool::childExecute()
ATH_MSG_DEBUG("Fails EventWise selection");
return StatusCode::SUCCESS;
}
+ // Check for Rnn container in SG
+ if(m_storeGate->contains<xAOD::TrigRNNOutputContainer>("HLT_xAOD__TrigRNNOutputContainer_TrigRingerNeuralFex")){
+ setSGContainsRnn(true);
+ }
+ if(m_storeGate->contains<xAOD::TrigPhotonContainer>("HLT_xAOD__TrigPhotonContainer_L2PhotonFex")){
+ setSGContainsTrigPhoton(true);
+ }
+ ATH_MSG_DEBUG("Rnn container in SG " << getSGContainsRnn());
+ ATH_MSG_DEBUG("TrigPhotonContainer in SG " << getSGContainsTrigPhoton());
+ for( const auto& tool : m_tools) {
+ tool->setSGContainsRnn(getSGContainsRnn());
+ tool->setSGContainsTrigPhoton(getSGContainsTrigPhoton());
+ }
// Event Wise Selection (independent of the required signatures)
hist1(m_anatype+"_CutCounter")->Fill("EventWise",1);
// Select TP Pairs
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaNavTPBaseTool.cxx b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaNavTPBaseTool.cxx
index 4dac467c9006890f13a19afe2a7ef296c5b30d36..90610ba04a1ee451369de5d41458e18e498f3d2d 100644
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaNavTPBaseTool.cxx
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaNavTPBaseTool.cxx
@@ -19,10 +19,10 @@
* All derived classes work with list of probes for a given trigger.
* As input property, pass a list of triggers to study.
**********************************************************************/
-#include "egammaMVACalibAnalysis/IegammaMVATool.h"
#include "TrigEgammaAnalysisTools/TrigEgammaNavTPBaseTool.h"
#include "TrigConfxAOD/xAODConfigTool.h"
#include "xAODEventInfo/EventInfo.h"
+#include "GaudiKernel/SystemOfUnits.h"
#include "PATCore/AcceptData.h"
#include "string"
#include <algorithm>
@@ -47,12 +47,14 @@ TrigEgammaNavTPBaseTool( const std::string& myname )
declareProperty("ForceProbePid", m_forceProbePid=false); // new
declareProperty("OppositeCharge",m_oppositeCharge=true);
declareProperty("OfflineTagMinEt",m_tagMinEt=25);
+ declareProperty("OfflineProbeMinEt",m_probeMinEt=4);
declareProperty("TagTriggerList", m_tagTrigList);
declareProperty("TriggerList",m_trigInputList);
declareProperty("CategoryList",m_categories);
declareProperty("RemoveCrack", m_rmCrack=true); //new
declareProperty("OfflineProbeIsolation", m_offProbeIsolation="Loose");
declareProperty("ForceProbeIsolation", m_forceProbeIsolation=false);
+ declareProperty("ApplyMinimalTrigger", m_applyMinimalTrigger=true);
// Maps should be static
m_PidToolMap["Tight"]=0;
@@ -64,9 +66,9 @@ TrigEgammaNavTPBaseTool( const std::string& myname )
m_jets=nullptr;
m_eventInfo=nullptr;
m_truthContainer=nullptr;
+ m_METContainer=nullptr;
m_applyJetNearProbeSelection=true;
- m_skipTrigger=false;
-
+ m_skipTrigger=false;
}
//**********************************************************************
@@ -81,7 +83,10 @@ StatusCode TrigEgammaNavTPBaseTool::childExecute() {
StatusCode TrigEgammaNavTPBaseTool::childFinalize() {
ATH_MSG_VERBOSE( "child Finalize tool " << name() );
+ // delete electron pointers alloc in the tap execute method and
+ // clear the list of pairs
clearProbeList();
+ // clear the list of pairs
clearPairList();
//m_offElectrons->clearDecorations();
@@ -104,9 +109,11 @@ TrigEgammaNavTPBaseTool::childInitialize() {
return StatusCode::SUCCESS;
}
+
StatusCode TrigEgammaNavTPBaseTool::childBook() {
return StatusCode::SUCCESS;
}
+
bool TrigEgammaNavTPBaseTool::EventWiseSelection(){
ATH_MSG_DEBUG("Apply EventWise selection");
@@ -122,7 +129,6 @@ bool TrigEgammaNavTPBaseTool::EventWiseSelection(){
m_offElectrons = 0;
m_jets = 0;
m_truthContainer=0;
-
if ( (m_storeGate->retrieve(m_eventInfo, "EventInfo")).isFailure() ){
ATH_MSG_WARNING("Failed to retrieve eventInfo ");
@@ -136,6 +142,15 @@ bool TrigEgammaNavTPBaseTool::EventWiseSelection(){
}
}// protection
+ if(m_storeGate->contains<xAOD::MissingETContainer>("MET_Reference_AntiKt4EMTopo")){
+ if(m_storeGate->retrieve(m_METContainer,"MET_Reference_AntiKt4EMTopo").isFailure()){
+ ATH_MSG_WARNING("Could not retrieve xAOD::MissingETContainer 'MET_Reference_AntiKt4EMTopo'");
+ return false;
+ }
+ }// protection
+
+
+
if (m_eventInfo->errorState(xAOD::EventInfo::LAr) == xAOD::EventInfo::Error) {
ATH_MSG_DEBUG("Event not passing LAr");
return false;
@@ -173,9 +188,11 @@ bool TrigEgammaNavTPBaseTool::EventWiseSelection(){
// missing more selections
// check Minimal Trigger Requirements
- if ( !MinimalTriggerRequirement() ) return false;
+ if(m_applyMinimalTrigger)
+ if ( !MinimalTriggerRequirement() ) return false;
hist1(m_anatype+"_CutCounter")->Fill("PassTrigger",1);
+
return true;
}
@@ -193,11 +210,18 @@ bool TrigEgammaNavTPBaseTool::MinimalTriggerRequirement(){
void TrigEgammaNavTPBaseTool::executeTandP(){
+ // clear all Z index pairs
+ m_Z.clear();
+ unsigned itag=0;
+
clearProbeList(); // Clear Probes after each trigger
ATH_MSG_DEBUG("Execute TandP BaseTool " << m_offElectrons->size());
for(const auto& elTag : *m_offElectrons){
+ itag++;
if( ! isTagElectron(elTag) ) continue;
+ unsigned iprobe=0;
for(const auto& elProbe : *m_offElectrons){ // Dress the probes with updated Pid decision
+ iprobe++;
hist1(m_anatype+"_ProbeCutCounter")->Fill("Electrons",1);
if(elProbe==elTag) continue;
hist1(m_anatype+"_ProbeCutCounter")->Fill("NotTag",1);
@@ -241,36 +265,56 @@ void TrigEgammaNavTPBaseTool::executeTandP(){
xAOD::Electron *selProbe = new xAOD::Electron(*elProbe);
DressPid(selProbe);
m_probeElectrons.push_back(selProbe);
+ m_Z.push_back( std::pair<unsigned,unsigned>(itag-1,iprobe-1) );
hist1(m_anatype+"_Mee")->Fill(tpPairMass/1.e3);
}
} // end of for in Probe
} // end of for in Tags
}
+
void TrigEgammaNavTPBaseTool::matchObjects(const std::string probeTrigItem){
clearPairList();
+ bool isEmulation = getTrigInfo(probeTrigItem).trigIsEmulation;
+
+
for(unsigned int i=0;i<m_probeElectrons.size();i++){
const HLT::TriggerElement *finalFC;
-
- // Use matching tool and create pair of offline probe and TE
- if ( match()->match(m_probeElectrons[i], probeTrigItem, finalFC)){
- std::pair<const xAOD::Electron*,const HLT::TriggerElement*> pairProbe(m_probeElectrons[i],finalFC);
- m_pairObj.push_back(pairProbe);
- } // end of check Probe
- else {
- std::pair<const xAOD::Electron*,const HLT::TriggerElement*> pairProbe(m_probeElectrons[i],nullptr);
- m_pairObj.push_back(pairProbe);
- } // still include the probe
+ if(isEmulation && getEmulation()){ // Collect from support match
+ emulation()->match( m_probeElectrons[i], finalFC );
+ std::pair<const xAOD::Electron*,const HLT::TriggerElement*> pairProbe(m_probeElectrons[i],finalFC);
+ m_pairObj.push_back(pairProbe);
+ }else{
+ // Use matching tool and create pair of offline probe and TE
+ if ( match()->match(m_probeElectrons[i], probeTrigItem, finalFC)){
+ std::pair<const xAOD::Electron*,const HLT::TriggerElement*> pairProbe(m_probeElectrons[i],finalFC);
+ m_pairObj.push_back(pairProbe);
+ } // end of check Probe
+ else {
+ std::pair<const xAOD::Electron*,const HLT::TriggerElement*> pairProbe(m_probeElectrons[i],nullptr);
+ m_pairObj.push_back(pairProbe);
+ } // still include the probe
+ }
}
}
void TrigEgammaNavTPBaseTool::clearProbeList(){
+
+ ATH_MSG_DEBUG("Clear all Probes...");
+ // this vector hold the Electron pointer and need to
+ // be deleted since we alloc such memory for than
+ for (auto it : m_probeElectrons)
+ delete it;
m_probeElectrons.clear();
+
m_probePhotons.clear();
}
void TrigEgammaNavTPBaseTool::clearPairList(){
+
+ ATH_MSG_DEBUG("Clear all Pairs...");
+ // this only hold < Electron * , TriggerElement * >
m_pairObj.clear();
}
@@ -285,7 +329,6 @@ bool TrigEgammaNavTPBaseTool::isTagElectron(const xAOD::Electron *el){
// Require offline tight electron
// Match to e24_tight1_L1EM20V
ATH_MSG_DEBUG("Selecting Tag Electron");
- double GeV = 1000.;
//Check constituents
const xAOD::TrackParticle *trk = el->trackParticle();
@@ -308,7 +351,7 @@ bool TrigEgammaNavTPBaseTool::isTagElectron(const xAOD::Electron *el){
hist1(m_anatype+"_TagCutCounter")->Fill("GoodPid",1);
ATH_MSG_DEBUG("Selecting Tag Electron Et");
//Require Et > 25 GeV
- if( !(el->e()/cosh(el->trackParticle()->eta()) > m_tagMinEt*GeV) ){
+ if( !(el->e()/cosh(el->trackParticle()->eta()) > m_tagMinEt*Gaudi::Units::GeV) ){
return false;
}
hist1(m_anatype+"_TagCutCounter")->Fill("Et",1);
@@ -375,13 +418,14 @@ bool TrigEgammaNavTPBaseTool::isTagElectron(const xAOD::Electron *el){
void TrigEgammaNavTPBaseTool::DressPid(const xAOD::Electron *eg){
+ auto ctx = Gaudi::Hive::currentContext() ;
for(int ipid=0;ipid<3;ipid++){
- bool accept = (bool) m_electronIsEMTool[ipid]->accept(eg);
+ bool accept = (bool) m_electronIsEMTool[ipid]->accept(ctx,eg);
const std::string pidname="is"+m_isemname[ipid];
eg->auxdecor<bool>(pidname)=static_cast<bool>(accept);
}
for(int ipid=0;ipid<2;ipid++){
- bool accept = (bool) m_electronLHTool[ipid]->accept(eg);
+ bool accept = (bool) m_electronLHTool[ipid]->accept(ctx,eg);
const std::string pidname="is"+m_lhname[ipid];
eg->auxdecor<bool>(pidname)=static_cast<bool>(accept);
}
@@ -389,34 +433,30 @@ void TrigEgammaNavTPBaseTool::DressPid(const xAOD::Electron *eg){
}
bool TrigEgammaNavTPBaseTool::ApplyElectronPid(const xAOD::Electron *eg, const std::string pidname){
-
+ auto ctx = Gaudi::Hive::currentContext() ;
if (pidname == "Tight"){
- bool accept = (bool) m_electronIsEMTool[0]->accept(eg);
- return static_cast<bool>(accept);
+ return (bool) m_electronIsEMTool[0]->accept(ctx,eg);
}
else if (pidname == "Medium"){
- bool accept = (bool) m_electronIsEMTool[1]->accept(eg);
- return static_cast<bool>(accept);
+ return (bool) m_electronIsEMTool[1]->accept(ctx,eg);
}
else if (pidname == "Loose"){
- bool accept = (bool) m_electronIsEMTool[2]->accept(eg);
- return static_cast<bool>(accept);
+ return (bool) m_electronIsEMTool[2]->accept(ctx,eg);
}
else if (pidname == "LHTight"){
- bool accept = (bool) m_electronLHTool[0]->accept(eg);
- return static_cast<bool>(accept);
+ return (bool) m_electronLHTool[0]->accept(ctx,eg);
}
else if (pidname == "LHMedium"){
- bool accept = (bool) m_electronLHTool[1]->accept(eg);
- return static_cast<bool>(accept);
+ return (bool) m_electronLHTool[1]->accept(ctx,eg);
}
else if (pidname == "LHLoose"){
- bool accept = (bool) m_electronLHTool[2]->accept(eg);
- return static_cast<bool>(accept);
+ return (bool) m_electronLHTool[2]->accept(ctx,eg);
}
else if (pidname == "LHMediumHI"){
- bool accept = (bool) m_electronLHTool[3]->accept(eg);
- return static_cast<bool>(accept);
+ return (bool) m_electronLHTool[3]->accept(ctx,eg);
+ }
+ else if (pidname == "LHMediumHI"){
+ return (bool) m_electronLHTool[3]->accept(ctx,eg);
}
else ATH_MSG_DEBUG("No Pid tool, continue without PID");
return false;
@@ -424,7 +464,6 @@ bool TrigEgammaNavTPBaseTool::ApplyElectronPid(const xAOD::Electron *eg, const s
bool TrigEgammaNavTPBaseTool::isGoodProbeElectron(const xAOD::Electron *el){
- double GeV = 1000.;
//Check constituents
if(!el->trackParticle()){
ATH_MSG_DEBUG("No track Particle");
@@ -444,7 +483,7 @@ bool TrigEgammaNavTPBaseTool::isGoodProbeElectron(const xAOD::Electron *el){
}
}
hist1(m_anatype+"_ProbeCutCounter")->Fill("Eta",1);
- /*if( !(el->e()/cosh(el->trackParticle()->eta()) > (etthr-5.0)*GeV) ){
+ /*if( !(el->e()/cosh(el->trackParticle()->eta()) > (etthr-5.0)*Gaudi::Units::GeV) ){
return false;
}
hist1("ProbeCutCounter")->Fill("Et",1);*/
@@ -461,7 +500,7 @@ bool TrigEgammaNavTPBaseTool::isGoodProbeElectron(const xAOD::Electron *el){
for(const auto &i_jet : *m_jets){
TLorentzVector jet;
jet.SetPtEtaPhiE(i_jet->pt(), i_jet->eta(), i_jet->phi(), i_jet->e());
- if( (jet.Et() > 20*GeV) && (jet.DeltaR(probeCandidate) < 0.4)) jetsAroundProbeElectron++;
+ if( (jet.Et() > 20*Gaudi::Units::GeV) && (jet.DeltaR(probeCandidate) < 0.4)) jetsAroundProbeElectron++;
}
//reject if more than 1 jet close to the probe electron
if ( jetsAroundProbeElectron >= 2 ) {
@@ -529,3 +568,32 @@ double TrigEgammaNavTPBaseTool::simple_lxy(int flag, double d1, double d2, do
else
return (a+b)/c;
}
+
+
+
+float TrigEgammaNavTPBaseTool::getWTransverseMass( const xAOD::Electron *el ){
+ float transverseMass=0.0;
+ if(m_METContainer){
+ TLorentzVector MET_4vec = TLorentzVector(getMET()->mpx(), getMET()->mpy(), 0, getMET()->met());
+ TLorentzVector electron;
+ electron.SetPtEtaPhiE(el->pt(), 0, el->phi(), el->pt());
+ transverseMass = (MET_4vec + electron).M();
+ }
+ return transverseMass;
+
+}
+
+bool TrigEgammaNavTPBaseTool::passesEventCleaning()
+{
+ ATH_MSG_DEBUG("Appling Event Cleaning...");
+ bool failsLAr = (m_eventInfo->errorState(xAOD::EventInfo::LAr) == xAOD::EventInfo::Error );
+ bool failsTile = (m_eventInfo->errorState(xAOD::EventInfo::Tile) == xAOD::EventInfo::Error );
+ bool failsSCT = (m_eventInfo->errorState(xAOD::EventInfo::SCT) == xAOD::EventInfo::Error );
+ bool failsTTC = (m_eventInfo->isEventFlagBitSet(xAOD::EventInfo::Core, 18)); // timing, trigger, control failed => some eventinfo missing
+ bool pass = !(failsLAr || failsTile || failsSCT || failsTTC);
+ if(!pass)
+ ATH_MSG_DEBUG("Event not clear! ");
+ return pass;
+}
+
+
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaNavTPNtuple.cxx b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaNavTPNtuple.cxx
deleted file mode 100755
index 680e786f42f35dbe1fe6acb46eb52ff672b9c156..0000000000000000000000000000000000000000
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaNavTPNtuple.cxx
+++ /dev/null
@@ -1,1066 +0,0 @@
-/*
- Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-*/
-
-/**********************************************************************
- * AsgTool: TrigEgammaNavTPNtuple
- * Authors:
- * Ryan Mackenzie White <ryan.white@cern.ch>
- * Denis Damazio <denis.damazio@cern.ch>
- * Contributors:
- * Joao Victor da Fonseca Pinto <joao.victor.da.fonseca.pinto@cern.ch>
- * Date: Mar 2015
- * Description:
- * Derived class for dumping the probe information into a ttree.
- *
- **********************************************************************/
-
-#include "TrigEgammaAnalysisTools/TrigEgammaNavTPNtuple.h"
-
-using namespace std;
-
-TrigEgammaNavTPNtuple::TrigEgammaNavTPNtuple( const std::string& myname ): TrigEgammaNavTPBaseTool(myname)
-{
- m_eventCounter = 0;
- declareProperty("CutLabels", m_cutlabels );
- declareProperty("Analysis", m_anatype="NavTPNtuple" );
- declareProperty("doOfflineDump", m_doOfflineDump=false );
- declareProperty("DoSupportTrigger", m_doSupport=true );
- declareProperty("OfflineProbeMinEt", m_probeMinEt=-1 );
-
- m_el_ringsE=nullptr;
- m_trig_L1_thrNames=nullptr;
- m_trig_L2_calo_energySample=nullptr;
- m_trig_L2_calo_rings=nullptr;
- m_trig_L2_el_trackAlgID=nullptr;
- m_trig_L2_el_pt=nullptr;
- m_trig_L2_el_eta=nullptr;
- m_trig_L2_el_caloEta=nullptr;
- m_trig_L2_el_phi=nullptr;
- m_trig_L2_el_charge=nullptr;
- m_trig_L2_el_nTRTHits=nullptr;
- m_trig_L2_el_nTRTHiThresholdHits=nullptr;
- m_trig_L2_el_etOverPt=nullptr;
- m_trig_L2_el_trkClusDeta=nullptr;
- m_trig_L2_el_trkClusDphi=nullptr;
- m_trig_EF_calo_et=nullptr;
- m_trig_EF_calo_eta=nullptr;
-}
-
-StatusCode TrigEgammaNavTPNtuple::childInitialize(){
- return StatusCode::SUCCESS;
-}
-
-
-StatusCode TrigEgammaNavTPNtuple::childBook(){
-
- ATH_MSG_DEBUG("Now configuring chains for analysis");
- //Set the base directory from the plot()
- m_dir=plot()->getBasePath();
- std::vector<std::string> chains = tdt()->getListOfTriggers("HLT_e.*, L1_EM.*, HLT_g.*");
-
- TrigEgammaAnalysisBaseTool::write_trigger_list(chains);
-
- for(const auto trigName:m_trigInputList){
- if (std::find(chains.begin(), chains.end(), trigName) != chains.end()) {
- if(plot()->getTrigInfoMap().count(trigName) != 0)
- ATH_MSG_WARNING("Trigger already booked, removing from trigger list " << trigName);
- else
- m_trigList.push_back(trigName);
- }
- }
-
-
-
- // Book histograms for average efficiencies and counters
- //const int nTrigger = (int) m_trigList.size();
- addDirectory(m_dir+"/Expert/Event");
- std::string histname=m_anatype+"_ProbeCutCounter";
- addHistogram(new TH1F(histname.c_str(), "Number of Probes; Cut ; Count", 12, 0., 12));
- histname=m_anatype+"_TagCutCounter";
- addHistogram(new TH1F(histname.c_str(), "Number of Tags; Cut ; Count", 10, 0., 10));
- histname=m_anatype+"_Mee";
- addHistogram(new TH1F(histname.c_str(), "Offline M(ee); m_ee [GeV] ; Count", 50, m_ZeeMassMin, m_ZeeMassMax));
- histname=m_anatype+"_CutCounter";
- addHistogram(new TH1I(histname.c_str(), "Event Selection; Cut ; Count", 6, 0., 6));
- setLabels(hist1(histname),m_cutlabels);
-
- if(m_doOfflineDump){
- addDirectory(m_dir+"/Expert/Offline");
- TTree *t = new TTree( "probes", "tree of Offline Zee probes");
- bookEventBranches( t );
- bookElectronBranches( t );
- //bookPhotonBranches( t );
- bookMonteCarloBranches( t );
- addTree(t, m_dir+"/Expert/Offline");
- }else if (m_doSupport){ // All trigger in one
- addDirectory(m_dir+"/Expert/support");
- TTree *t = new TTree( "probes", "tree of Zee probes");
- bookEventBranches( t );
- bookElectronBranches( t );
- //bookPhotonBranches( t );
- bookTriggerBranches( t );
- bookMonteCarloBranches( t );
- for(auto& trigItem : m_trigList)
- setTrigInfo(trigItem);
- addTree(t, m_dir+"/Expert/support");
- }else{// Each trigger
- for (auto& trigItem : m_trigList) {
- addDirectory(m_dir+"/Expert/"+trigItem);
- TTree *t = new TTree( "probes", "tree of Zee probes");
- bookEventBranches( t );
- bookElectronBranches( t );
- //bookPhotonBranches( t );
- bookTriggerBranches( t );
- bookMonteCarloBranches( t );
- setTrigInfo(trigItem);
- addTree(t, m_dir+"/Expert/"+trigItem);
- }// Loop over triggers
- }
-
- ///Alloc pointers
- alloc_space();
- return StatusCode::SUCCESS;
-}
-
-StatusCode TrigEgammaNavTPNtuple::childExecute(){
-
- m_eventCounter++;
- cd(m_dir+"/Expert/Event");
- // Event Wise Selection (independent of the required signatures)
- if ( !TrigEgammaNavTPBaseTool::EventWiseSelection() ) return StatusCode::SUCCESS;
-
- if(m_doOfflineDump){
- if(!executeProbesDump()) return StatusCode::FAILURE;
- }else if (m_doSupport){
- if(!executeProbesSupportDump()) return StatusCode::FAILURE;
- }else{
- if(!executeProbesItemDump()) return StatusCode::FAILURE;
- }
-
- return StatusCode::SUCCESS;
-}
-
-
-
-bool TrigEgammaNavTPNtuple::executeProbesDump(){
-
- // Select TP Pairs
- executeTandP();
-
- TTree *t = tree( "probes", m_dir+"/Expert/Offline");
- linkEventBranches(t);
- linkElectronBranches(t);
- linkMonteCarloBranches(t);
- for(unsigned int iprobe = 0; iprobe != m_probeElectrons.size(); ++iprobe){
- const xAOD::Electron *el = static_cast<const xAOD::Electron *> (m_probeElectrons[iprobe]);
- ATH_MSG_DEBUG("dumping probe electron information...");
- clear();
- fillEvent();
- fillElectron( el );
- if(!fillMonteCarlo( el ) ){
- ATH_MSG_WARNING("Cound not found any TruthParticle for this Electron");
- }
- ATH_MSG_DEBUG("record probe information into the file.");
- t->Fill();
- }// loop over offline probes
-
- return true;
-}
-
-
-bool TrigEgammaNavTPNtuple::executeProbesItemDump(){
-
- executeTandP();
-
- for(unsigned int ilist = 0; ilist != m_trigList.size(); ++ilist) {
-
- std::string trigItem = m_trigList.at(ilist);
- const TrigInfo info = getTrigInfo(trigItem);
- cd(m_dir+"/Expert/"+trigItem);
- TTree *t = tree( "probes", m_dir+"/Expert/"+trigItem);
- linkEventBranches(t);
- linkElectronBranches(t);
- linkTriggerBranches(t);
- linkMonteCarloBranches(t);
- //Try to find trigger objects
- TrigEgammaNavTPBaseTool::matchObjects(trigItem);
-
- for(unsigned int iprobe = 0; iprobe != m_pairObj.size(); ++iprobe){
-
- const xAOD::Electron *el = static_cast<const xAOD::Electron *> (m_pairObj[iprobe].first);
- const HLT::TriggerElement *feat = m_pairObj[iprobe].second;
- ATH_MSG_DEBUG("dumping probe electron information...");
-
- clear();
- fillEvent();
- fillElectron( el );
-
- if(!fillMonteCarlo( el ) ){
- ATH_MSG_WARNING("Cound not found any TruthParticle for this Electron");
- }
-
- if(feat){
- ///Start trigger analisys...
- const xAOD::EmTauRoI *emTauRoI = getFeature<xAOD::EmTauRoI>(feat);
- if(emTauRoI){
- fillEmTauRoI( emTauRoI );
- }else{
- ATH_MSG_WARNING("Cound not found EmTauRoI in this TriggerElement..");
- }
-
- const xAOD::TrigEMCluster *emCluster = getFeature<xAOD::TrigEMCluster>(feat);
- if(emCluster){
-
- if(!fillTrigEMCluster( emCluster )){
- ATH_MSG_WARNING("Cound not attach the trigEMCluster information into the tree.");
- }
-
- //if(TrigEgammaAnalysisBaseTool::getTrigCaloRings(emCluster, ringsContainer ,*m_trig_L2_calo_rings)){
- if(!fillTrigCaloRings( emCluster )){
- ATH_MSG_WARNING("Cound not attach the trigCaloRinger information into the tree.");
- }
- }///cluster protection
-
-
- const xAOD::TrigElectronContainer *trigElCont = getFeature<xAOD::TrigElectronContainer>(feat);
- // Level 2 ID+Calo
- if(trigElCont){
- for(const auto& trigEl : *trigElCont){
- if(!fillTrigElectron(trigEl)) {
- ATH_MSG_WARNING("Cound not attach the trigElectron information into the tree.");
- }
- }// loop over all trigElectrons for this feat
- }
-
- const xAOD::CaloClusterContainer *caloCont = getFeature<xAOD::CaloClusterContainer>(feat);
- if(caloCont){
- for(const auto& cl : *caloCont){
- if(!fillCaloCluster(cl)){
- ATH_MSG_WARNING("Cound not attach the CaloCluster information into the tree.");
- }
- }// loop over calo cluster
- }
-
-
- asg::AcceptData acceptData = setAccept(feat,info);
- m_trig_L1_accept = acceptData.getCutResult("L1Calo");
- m_trig_L2_calo_accept = acceptData.getCutResult("L2Calo");
- m_trig_L2_el_accept = acceptData.getCutResult("L2");
- m_trig_EF_calo_accept = acceptData.getCutResult("EFCalo");
- m_trig_EF_el_accept = acceptData.getCutResult("HLT");
-
- ATH_MSG_DEBUG("L1Calo: " << int(m_trig_L1_accept));
- ATH_MSG_DEBUG("L2Calo: " << int(m_trig_L2_calo_accept));
- ATH_MSG_DEBUG("L2 : " << int(m_trig_L2_el_accept));
- ATH_MSG_DEBUG("EFCalo: " << int(m_trig_EF_calo_accept));
- ATH_MSG_DEBUG("HLT : " << int(m_trig_EF_el_accept));
-
- }else{
- ATH_MSG_DEBUG("No TriggerElement for this probe!");
- }
- ATH_MSG_DEBUG("record probe information into the file.");
- t->Fill();
- }// loop over probes
- } // End loop over trigger list
-
- return true;
-}
-
-
-
-bool TrigEgammaNavTPNtuple::executeProbesSupportDump(){
-
- double GeV=1000.;
- std::vector<const HLT::TriggerElement *> vec_feat;
-
- // Tag and probe algorithm
- executeTandP();
-
- cd(m_dir+"/Expert/support");
- TTree *t = tree( "probes", m_dir+"/Expert/support");
- linkEventBranches(t);
- linkElectronBranches(t);
- linkMonteCarloBranches(t);
-
- for(const auto &eg : m_probeElectrons){
- // Get the good electron
- const xAOD::Electron* el =static_cast<const xAOD::Electron*> (eg);
- // Force Et cut
- if(m_probeMinEt > 0.0){
- if( !( getEt(el) > (m_probeMinEt)*GeV) ) continue;
- }
- // Clear the vector
- vec_feat.clear();
- // Loop over support triggers: Here, we will collect all good trigger elements to
- // dump on the ttree.
- for(auto& trigItem : m_trigList){
-
- const HLT::TriggerElement *feat=nullptr;
- // Trigger match using Matching tool
- match()->match(el, trigItem, feat);
-
- if(feat){// If has a match!
- for(unsigned i=0; i < vec_feat.size(); ++i){
- if(getFeature<xAOD::EmTauRoI>(vec_feat[i])->roiWord() == getFeature<xAOD::EmTauRoI>(feat)->roiWord()){
- if(count_HLT_objects(feat) > count_HLT_objects(vec_feat[i])){
- vec_feat.erase(vec_feat.begin() + i); // Erase the trigger element lowest than the new feature
- vec_feat.push_back(feat); // attach the new trigger element
- break;
- }
- }// The same region in L1Calo trigger
- }
- if(vec_feat.empty()) vec_feat.push_back(feat);
- }else{
- ATH_MSG_DEBUG("There is no match for this probe.");
- }
- }// Loop over support triggers
-
- ATH_MSG_DEBUG("Attached " << vec_feat.size() << " features ");
- for(auto& feat : vec_feat){
- clear();
- fillEvent();
- fillElectron( el );
-
- if(!fillMonteCarlo( el ) ){
- ATH_MSG_WARNING("Cound not found any TruthParticle for this Electron");
- }
-
- ///Start trigger analisys...
- const xAOD::EmTauRoI *emTauRoI = getFeature<xAOD::EmTauRoI>(feat);
- if(emTauRoI){
- fillEmTauRoI( emTauRoI );
- }else{
- ATH_MSG_WARNING("Cound not found EmTauRoI in this TriggerElement..");
- }
-
- const xAOD::TrigEMCluster *emCluster = getFeature<xAOD::TrigEMCluster>(feat);
- if(emCluster){
-
- if(!fillTrigEMCluster( emCluster )){
- ATH_MSG_WARNING("Cound not attach the trigEMCluster information into the tree.");
- }
-
- //if(TrigEgammaAnalysisBaseTool::getTrigCaloRings(emCluster, ringsContainer ,*m_trig_L2_calo_rings)){
- if(!fillTrigCaloRings( emCluster )){
- ATH_MSG_WARNING("Cound not attach the trigCaloRinger information into the tree.");
- }
- }///cluster protection
-
-
- const xAOD::TrigElectronContainer *trigElCont = getFeature<xAOD::TrigElectronContainer>(feat);
- // Level 2 ID+Calo
- if(trigElCont){
- for(const auto& trigEl : *trigElCont){
- if(!fillTrigElectron(trigEl)) {
- ATH_MSG_WARNING("Cound not attach the trigElectron information into the tree.");
- }
- }// loop over all trigElectrons for this feat
- }
-
- const xAOD::CaloClusterContainer *caloCont = getFeature<xAOD::CaloClusterContainer>(feat);
- if(caloCont){
- for(const auto& cl : *caloCont){
- if(!fillCaloCluster(cl)){
- ATH_MSG_WARNING("Cound not attach the CaloCluster information into the tree.");
- }
- }// loop over calo cluster
- }
-
- ATH_MSG_DEBUG("record trigger information into the file.");
- t->Fill();
- }//loop over trigger objects
-
- }// Loop over probes
- return true;
-}
-
-
-
-StatusCode TrigEgammaNavTPNtuple::childFinalize(){
- //release_space();
- return StatusCode::SUCCESS;
-}
-
-
-
-bool TrigEgammaNavTPNtuple::fillEmTauRoI( const xAOD::EmTauRoI *emTauRoI ){
-
- m_trig_L1_eta = emTauRoI->eta();
- m_trig_L1_phi = emTauRoI->phi();
- m_trig_L1_emClus = emTauRoI->emClus();
- m_trig_L1_tauClus = emTauRoI->tauClus();
- m_trig_L1_emIsol = emTauRoI->emIsol();
- m_trig_L1_hadIsol = emTauRoI->hadIsol();
- for(unsigned i=0; i < emTauRoI->thrNames().size();++i) m_trig_L1_thrNames->push_back(emTauRoI->thrNames().at(i));
- return true;
-}
-
-bool TrigEgammaNavTPNtuple::fillTrigEMCluster( const xAOD::TrigEMCluster *emCluster ){
-
- m_trig_L2_calo_et = emCluster->et();
- m_trig_L2_calo_eta = emCluster->eta();
- m_trig_L2_calo_phi = emCluster->phi();
- m_trig_L2_calo_e237 = emCluster->e237();
- m_trig_L2_calo_e277 = emCluster->e277();
- m_trig_L2_calo_fracs1 = emCluster->fracs1();
- m_trig_L2_calo_weta2 = emCluster->weta2();
- m_trig_L2_calo_ehad1 = emCluster->ehad1();
- m_trig_L2_calo_emaxs1 = emCluster->emaxs1();
- m_trig_L2_calo_e2tsts1 = emCluster->e2tsts1();
- m_trig_L2_calo_wstot = emCluster->wstot();
- for(unsigned i=0; i<emCluster->energySample().size(); ++i){
- m_trig_L2_calo_energySample->push_back( emCluster->energySample().at(i));
- }
-
- return true;
-}
-
-
-bool TrigEgammaNavTPNtuple::fillTrigElectron( const xAOD::TrigElectron *trigEl ){
-
- const xAOD::TrackParticle* trkIter = trigEl->trackParticle();
- if (trkIter==nullptr) return false; // disconsider candidates without track
- int algoId = 0;
- if ( trkIter->patternRecoInfo()[xAOD::TrackPatternRecoInfo::FastTrackFinderSeed] ) algoId=9;
- if ( trkIter->patternRecoInfo()[xAOD::TrackPatternRecoInfo::strategyA] ) algoId=5;
- if ( trkIter->patternRecoInfo()[xAOD::TrackPatternRecoInfo::strategyB] ) algoId=6;
- if ( trkIter->patternRecoInfo()[xAOD::TrackPatternRecoInfo::strategyC] ) algoId=7;
-
- m_trig_L2_el_trackAlgID ->push_back(algoId);
- m_trig_L2_el_caloEta ->push_back(trigEl->caloEta());
- m_trig_L2_el_trkClusDphi ->push_back(trigEl->trkClusDphi());
- m_trig_L2_el_trkClusDeta ->push_back(trigEl->trkClusDeta());
- m_trig_L2_el_pt ->push_back(trigEl->pt());
- m_trig_L2_el_phi ->push_back(trigEl->phi());
- m_trig_L2_el_eta ->push_back(trigEl->eta());
- m_trig_L2_el_etOverPt ->push_back(trigEl->etOverPt());
- m_trig_L2_el_nTRTHits ->push_back(trigEl->nTRTHits());
- m_trig_L2_el_nTRTHiThresholdHits->push_back(trigEl->nTRTHiThresholdHits());
- m_trig_L2_el_charge ->push_back(trigEl->charge());
- return true;
-}
-
-
-bool TrigEgammaNavTPNtuple::fillCaloCluster( const xAOD::CaloCluster *cluster){
-
- m_trig_EF_calo_et->push_back(cluster->et());
- m_trig_EF_calo_eta->push_back(cluster->eta());
- return true;
-}
-
-bool TrigEgammaNavTPNtuple::fillEvent(){
- ///Event information
- m_runNumber = m_eventInfo->runNumber();
- m_eventNumber = m_eventInfo->eventNumber();
- m_avgmu=getAvgMu();
- return true;
-}
-
-bool TrigEgammaNavTPNtuple::fillElectron( const xAOD::Electron *el ){
-
- ///Cluster information
- m_el_et = el->pt();
- m_el_eta = el->eta();
- m_el_phi = el->phi();
- el->showerShapeValue( m_el_ethad1 , xAOD::EgammaParameters::ShowerShapeType::ethad1 );
- el->showerShapeValue( m_el_ehad1 , xAOD::EgammaParameters::ShowerShapeType::ehad1 );
- el->showerShapeValue( m_el_f1 , xAOD::EgammaParameters::ShowerShapeType::f1 );
- el->showerShapeValue( m_el_f3 , xAOD::EgammaParameters::ShowerShapeType::f3 );
- el->showerShapeValue( m_el_f1core , xAOD::EgammaParameters::ShowerShapeType::f1core );
- el->showerShapeValue( m_el_f3core , xAOD::EgammaParameters::ShowerShapeType::f3core );
- el->showerShapeValue( m_el_weta2 , xAOD::EgammaParameters::ShowerShapeType::weta2 );
- el->showerShapeValue( m_el_wtots1 , xAOD::EgammaParameters::ShowerShapeType::wtots1 );
- el->showerShapeValue( m_el_fracs1 , xAOD::EgammaParameters::ShowerShapeType::fracs1 );
- el->showerShapeValue( m_el_Reta , xAOD::EgammaParameters::ShowerShapeType::Reta );
- el->showerShapeValue( m_el_Rphi , xAOD::EgammaParameters::ShowerShapeType::Rphi );
- el->showerShapeValue( m_el_Eratio , xAOD::EgammaParameters::ShowerShapeType::Eratio );
- el->showerShapeValue( m_el_Rhad , xAOD::EgammaParameters::ShowerShapeType::Rhad );
- el->showerShapeValue( m_el_Rhad1 , xAOD::EgammaParameters::ShowerShapeType::Rhad1 );
-
- ///Combined track/Cluter information
- el->trackCaloMatchValue( m_el_deta1 , xAOD::EgammaParameters::TrackCaloMatchType::deltaEta1 );
- el->trackCaloMatchValue( m_el_deta2 , xAOD::EgammaParameters::TrackCaloMatchType::deltaEta2 );
- el->trackCaloMatchValue( m_el_dphi2 , xAOD::EgammaParameters::TrackCaloMatchType::deltaPhi2 );
- el->trackCaloMatchValue( m_el_dphiresc , xAOD::EgammaParameters::TrackCaloMatchType::deltaPhiRescaled0 );
- el->trackCaloMatchValue( m_el_dphiresc2 , xAOD::EgammaParameters::TrackCaloMatchType::deltaPhiRescaled2 );
-
-
- ///Track particle information
- const xAOD::TrackParticle *track = el->trackParticle();
- if(track){
- m_el_pt = track->pt();
- m_el_d0 = fabsf(track->d0());
- m_el_charge = el->charge();
-
- track->summaryValue( m_el_eprobht , xAOD::SummaryType::eProbabilityHT );
- track->summaryValue( m_el_nblayerhits , xAOD::SummaryType::numberOfInnermostPixelLayerHits );
- track->summaryValue( m_el_nblayerolhits , xAOD::SummaryType::numberOfInnermostPixelLayerOutliers );
- track->summaryValue( m_el_npixhits , xAOD::SummaryType::numberOfPixelHits );
- track->summaryValue( m_el_npixolhits , xAOD::SummaryType::numberOfPixelOutliers );
- track->summaryValue( m_el_nscthits , xAOD::SummaryType::numberOfSCTHits );
- track->summaryValue( m_el_nsctolhits , xAOD::SummaryType::numberOfSCTOutliers );
- track->summaryValue( m_el_ntrthightreshits , xAOD::SummaryType::numberOfTRTHighThresholdHits );
- track->summaryValue( m_el_ntrthits , xAOD::SummaryType::numberOfTRTHits);
- track->summaryValue( m_el_ntrthighthresolhits, xAOD::SummaryType::numberOfTRTHighThresholdOutliers );
- track->summaryValue( m_el_ntrtolhits , xAOD::SummaryType::numberOfTRTOutliers );
- track->summaryValue( m_el_ntrtxenonhits , xAOD::SummaryType::numberOfTRTXenonHits );
- //track->summaryValue( m_el_expectblayerhit , xAOD::SummaryType::expectInnermostPixelLayerHit );
- track->summaryValue( m_el_npixdeadsensors , xAOD::SummaryType::numberOfPixelDeadSensors);
- track->summaryValue( m_el_nsctdeadsensors , xAOD::SummaryType::numberOfSCTDeadSensors);
-
- m_el_nsideadsensors = m_el_npixdeadsensors + m_el_nsctdeadsensors;
- m_el_nsihits = m_el_npixhits + m_el_nscthits;
- }
-
- //m_el_loose = el->passSelection("Loose");
- //m_el_medium = el->passSelection("Medium");
- //m_el_tight = el->passSelection("Tight");
- //m_el_lhLoose = el->passSelection("LHLoose");
- //m_el_lhMedium = el->passSelection("LHMedium");
- //m_el_lhTight = el->passSelection("LHTight");
- //m_el_rgLoose = el->passSelection("RGLoose");
- //m_el_rgMedium = el->passSelection("RGMedium");
- //m_el_rgTight = el->passSelection("RGTight");
- //m_el_multiLepton = el->passSelection("MultiLepton");
- m_el_loose = ApplyElectronPid(el, "Loose");
- m_el_medium = ApplyElectronPid(el, "Medium");
- m_el_tight = ApplyElectronPid(el, "Tight");
- m_el_lhLoose = ApplyElectronPid(el, "LHLoose");
- m_el_lhMedium = ApplyElectronPid(el, "LHMedium");
- m_el_lhTight = ApplyElectronPid(el, "LHTight");
- //m_el_rgLoose = ApplyElectronPid(el, "RGLoose");
- //m_el_rgMedium = ApplyElectronPid(el, "RGMedium");
- //m_el_rgTight = ApplyElectronPid(el, "RGTight");
-
- m_calo_et = getCluster_et( el );
- m_calo_eta = getCluster_eta( el );
- m_calo_phi = getCluster_phi( el );
- ///Extra information about pileup
- m_el_nGoodVtx = getNGoodVertex();
- m_el_nPileupPrimaryVtx = getNPVtx();
-
-
- if(!fillCaloRings( el )){
- ATH_MSG_WARNING("Could not attach the calorRings information.");
- }
-
- return true;
-}
-
-
-/*bool TrigEgammaNavTPNtuple::fillPhoton( const xAOD::Photon *ph ){
- return true;
-}*/
-
-
-bool TrigEgammaNavTPNtuple::fillMonteCarlo(const xAOD::Egamma *eg){
-
- if(m_truthContainer){
- const xAOD::TruthParticle *mc=nullptr;
- MonteCarlo::PDGID pdg = pdgid(eg, m_truthContainer,mc);
- if(mc){
- m_mc_hasMC = true;
- m_mc_pt = mc->pt();
- m_mc_eta = mc->eta();
- m_mc_phi = mc->phi();
- m_mc_isTop = mc->isTop();
- m_mc_isQuark = mc->isQuark();
- m_mc_isParton = mc->isParton();
- m_mc_isMeson = mc->isMeson();
- m_mc_isTau = mc->isTau();
- m_mc_isMuon = mc->isMuon();
- m_mc_isPhoton = mc->isPhoton();
- m_mc_isElectron = mc->isElectron();
- if(pdg == MonteCarlo::PDGID::ZMother) m_mc_hasZMother = true;
- if(pdg == MonteCarlo::PDGID::WMother) m_mc_hasWMother = true;
- return true;
- }//has match
- }//has truth container
- return false;
-}
-
-bool TrigEgammaNavTPNtuple::fillTrigCaloRings( const xAOD::TrigEMCluster *emCluster ){
- return TrigEgammaAnalysisBaseTool::getTrigCaloRings(emCluster, *m_trig_L2_calo_rings);
-}
-
-
-bool TrigEgammaNavTPNtuple::fillCaloRings( const xAOD::Electron *el ){
- return TrigEgammaAnalysisBaseTool::getCaloRings(el, *m_el_ringsE );
-}
-
-/*
- * book, link, clear, alloc and release method divide in:
- * trigger, Egamma and MonteCarlo data base.
- */
-
-template <class T>
-void TrigEgammaNavTPNtuple::InitBranch(TTree* fChain, std::string branch_name, T* param, bool message){
-
- std::string bname = branch_name;
- if (fChain->GetAlias(bname.c_str()))
- bname = std::string(fChain->GetAlias(bname.c_str()));
-
- if (!fChain->FindBranch(bname.c_str()) && message) {
- ATH_MSG_WARNING("unknown branch " << bname);
- return;
- }
- fChain->SetBranchStatus(bname.c_str(), 1.);
- fChain->SetBranchAddress(bname.c_str(), param);
-}
-
-void TrigEgammaNavTPNtuple::bookEventBranches(TTree *t){
-
- t->Branch("RunNumber", &m_runNumber);
- t->Branch("EventNumber", &m_eventNumber);
- t->Branch("avgmu", &m_avgmu);
-}
-
-void TrigEgammaNavTPNtuple::bookTriggerBranches(TTree *t){
-
- // Level L1 cluster
- t->Branch( "trig_L1_eta", &m_trig_L1_eta);
- t->Branch( "trig_L1_phi", &m_trig_L1_phi);
- t->Branch( "trig_L1_emClus", &m_trig_L1_emClus);
- t->Branch( "trig_L1_tauClus", &m_trig_L1_tauClus);
- t->Branch( "trig_L1_emIsol", &m_trig_L1_emIsol);
- t->Branch( "trig_L1_hadIsol", &m_trig_L1_hadIsol);
- t->Branch( "trig_L1_thrNames", &m_trig_L1_thrNames);
- t->Branch( "trig_L1_accept", &m_trig_L1_accept);
- t->Branch( "trig_L2_calo_et", &m_trig_L2_calo_et);
- t->Branch( "trig_L2_calo_eta", &m_trig_L2_calo_eta);
- t->Branch( "trig_L2_calo_phi", &m_trig_L2_calo_phi);
- t->Branch( "trig_L2_calo_e237", &m_trig_L2_calo_e237 );
- t->Branch( "trig_L2_calo_e277", &m_trig_L2_calo_e277 );
- t->Branch( "trig_L2_calo_fracs1", &m_trig_L2_calo_fracs1);
- t->Branch( "trig_L2_calo_weta2", &m_trig_L2_calo_weta2);
- t->Branch( "trig_L2_calo_ehad1", &m_trig_L2_calo_ehad1);
- t->Branch( "trig_L2_calo_emaxs1", &m_trig_L2_calo_emaxs1);
- t->Branch( "trig_L2_calo_e2tsts1", &m_trig_L2_calo_e2tsts1);
- t->Branch( "trig_L2_calo_wstot", &m_trig_L2_calo_wstot);
- t->Branch( "trig_L2_calo_energySample",&m_trig_L2_calo_energySample );
- t->Branch( "trig_L2_calo_rnnOutput", &m_trig_L2_calo_rnnOutput );
- t->Branch( "trig_L2_calo_rings", &m_trig_L2_calo_rings );
- t->Branch( "trig_L2_calo_accept", &m_trig_L2_calo_accept);
- t->Branch( "trig_L2_el_trackAlgID" , &m_trig_L2_el_trackAlgID );
- t->Branch( "trig_L2_el_pt" , &m_trig_L2_el_pt );
- t->Branch( "trig_L2_el_eta", &m_trig_L2_el_eta);
- t->Branch( "trig_L2_el_phi", &m_trig_L2_el_phi );
- t->Branch( "trig_L2_el_caloEta", &m_trig_L2_el_caloEta );
- t->Branch( "trig_L2_el_charge", &m_trig_L2_el_charge);
- t->Branch( "trig_L2_el_nTRTHits", &m_trig_L2_el_nTRTHits);
- t->Branch( "trig_L2_el_nTRTHiThresholdHits", &m_trig_L2_el_nTRTHiThresholdHits);
- t->Branch( "trig_L2_el_etOverPt" , &m_trig_L2_el_etOverPt );
- t->Branch( "trig_L2_el_trkClusDeta" , &m_trig_L2_el_trkClusDeta );
- t->Branch( "trig_L2_el_trkClusDphi" , &m_trig_L2_el_trkClusDphi );
- t->Branch( "trig_L2_el_accept", &m_trig_L2_el_accept );
- t->Branch( "trig_EF_calo_accept", &m_trig_EF_calo_accept);
- t->Branch( "trig_EF_calo_et", &m_trig_EF_calo_et);
- t->Branch( "trig_EF_calo_eta", &m_trig_EF_calo_eta);
- t->Branch( "trig_EF_el_accept", &m_trig_EF_el_accept);
-}
-
-void TrigEgammaNavTPNtuple::bookElectronBranches(TTree *t){
-
- t->Branch("el_et", &m_el_et);
- t->Branch("el_pt", &m_el_pt);
- t->Branch("el_eta", &m_el_eta);
- t->Branch("el_phi", &m_el_phi);
- t->Branch("el_ethad1", &m_el_ethad1);
- t->Branch("el_ehad1", &m_el_ehad1);
- t->Branch("el_f1", &m_el_f1);
- t->Branch("el_f3", &m_el_f3);
- t->Branch("el_f1core", &m_el_f1core);
- t->Branch("el_f3core", &m_el_f3core);
- t->Branch("el_weta2", &m_el_weta2);
- t->Branch("el_d0", &m_el_d0);
- t->Branch("el_wtots1", &m_el_wtots1);
- t->Branch("el_fracs1", &m_el_fracs1);
- t->Branch("el_Reta", &m_el_Reta);
- t->Branch("el_Rphi", &m_el_Rphi);
- t->Branch("el_Eratio", &m_el_Eratio);
- t->Branch("el_Rhad", &m_el_Rhad);
- t->Branch("el_Rhad1", &m_el_Rhad1);
- t->Branch("el_deta1", &m_el_deta1);
- t->Branch("el_deta2", &m_el_deta2);
- t->Branch("el_dphi2", &m_el_dphi2);
- t->Branch("el_dphiresc", &m_el_dphiresc);
- t->Branch("el_dphiresc2", &m_el_dphiresc2);
- t->Branch("el_eprobht", &m_el_eprobht);
- t->Branch("el_charge", &m_el_charge);
- t->Branch("el_nblayerhits", &m_el_nblayerhits);
- t->Branch("el_nblayerolhits", &m_el_nblayerolhits);
- t->Branch("el_npixhits", &m_el_npixhits);
- t->Branch("el_npixolhits", &m_el_npixolhits);
- t->Branch("el_nscthits", &m_el_nscthits);
- t->Branch("el_nsctolhits", &m_el_nsctolhits);
- t->Branch("el_ntrthightreshits", &m_el_ntrthightreshits);
- t->Branch("el_ntrthits", &m_el_ntrthits);
- t->Branch("el_ntrthighthresolhits", &m_el_ntrthighthresolhits);
- t->Branch("el_ntrtolhits", &m_el_ntrtolhits);
- t->Branch("el_ntrtxenonhits", &m_el_ntrtxenonhits);
- t->Branch("el_expectblayerhit", &m_el_expectblayerhit);
- t->Branch("el_nsihits", &m_el_nsihits );
- t->Branch("el_nsideadsensors", &m_el_nsideadsensors );
- t->Branch("el_npixdeadsensors", &m_el_npixdeadsensors );
- t->Branch("el_nsctdeadsensors", &m_el_nsctdeadsensors );
- t->Branch("el_ringsE", &m_el_ringsE );
- t->Branch("el_loose", &m_el_loose );
- t->Branch("el_medium", &m_el_medium );
- t->Branch("el_tight", &m_el_tight );
- t->Branch("el_lhLoose", &m_el_lhLoose );
- t->Branch("el_lhMedium", &m_el_lhMedium );
- t->Branch("el_lhTight", &m_el_lhTight );
- t->Branch("el_rgLoose", &m_el_rgLoose );
- t->Branch("el_rgMedium", &m_el_rgMedium );
- t->Branch("el_rgTight", &m_el_rgTight );
- t->Branch("el_multiLepton", &m_el_multiLepton);
- t->Branch("el_nGoodVtx", &m_el_nGoodVtx);
- t->Branch("el_nPileupPrimaryVtx", &m_el_nPileupPrimaryVtx);
- t->Branch("calo_et", &m_calo_et);
- t->Branch("calo_eta", &m_calo_eta);
- t->Branch("calo_phi", &m_calo_phi);
-
-}
-
-
-/*void TrigEgammaNavTPNtuple::bookPhotonBranches(TTree *t){
-} */
-
-void TrigEgammaNavTPNtuple::bookMonteCarloBranches(TTree *t){
- // Monte Carlo
- t->Branch("mc_hasMC", &m_mc_hasMC);
- t->Branch("mc_pt", &m_mc_pt);
- t->Branch("mc_eta", &m_mc_eta);
- t->Branch("mc_phi", &m_mc_phi);
- t->Branch("mc_isTop", &m_mc_isTop);
- t->Branch("mc_isParton", &m_mc_isParton);
- t->Branch("mc_isMeson", &m_mc_isMeson);
- t->Branch("mc_isTau", &m_mc_isTau);
- t->Branch("mc_isMuon", &m_mc_isMuon);
- t->Branch("mc_isPhoton", &m_mc_isPhoton);
- t->Branch("mc_isElectron", &m_mc_isElectron);
- t->Branch("mc_hasZMother", &m_mc_hasZMother);
- t->Branch("mc_hasWMother", &m_mc_hasWMother);
-}
-
-void TrigEgammaNavTPNtuple::linkEventBranches(TTree *t){
-
- InitBranch( t, "RunNumber", &m_runNumber);
- InitBranch( t, "EventNumber", &m_eventNumber);
- InitBranch( t, "avgmu", &m_avgmu);
-}
-
-void TrigEgammaNavTPNtuple::linkElectronBranches( TTree *t ){
-
- InitBranch( t, "el_et", &m_el_et);
- InitBranch( t, "el_pt", &m_el_pt);
- InitBranch( t, "el_eta", &m_el_eta);
- InitBranch( t, "el_phi", &m_el_phi);
- InitBranch( t, "el_ethad1", &m_el_ethad1);
- InitBranch( t, "el_ehad1", &m_el_ehad1);
- InitBranch( t, "el_f1", &m_el_f1);
- InitBranch( t, "el_f3", &m_el_f3);
- InitBranch( t, "el_f1core", &m_el_f1core);
- InitBranch( t, "el_f3core", &m_el_f3core);
- InitBranch( t, "el_weta2", &m_el_weta2);
- InitBranch( t, "el_d0", &m_el_d0);
- InitBranch( t, "el_wtots1", &m_el_wtots1);
- InitBranch( t, "el_fracs1", &m_el_fracs1);
- InitBranch( t, "el_Reta", &m_el_Reta);
- InitBranch( t, "el_Rphi", &m_el_Rphi);
- InitBranch( t, "el_Eratio", &m_el_Eratio);
- InitBranch( t, "el_Rhad", &m_el_Rhad);
- InitBranch( t, "el_Rhad1", &m_el_Rhad1);
- InitBranch( t, "el_deta1", &m_el_deta1);
- InitBranch( t, "el_deta2", &m_el_deta2);
- InitBranch( t, "el_dphi2", &m_el_dphi2);
- InitBranch( t, "el_dphiresc", &m_el_dphiresc);
- InitBranch( t, "el_dphiresc2", &m_el_dphiresc2);
- InitBranch( t, "el_eprobht", &m_el_eprobht);
- InitBranch( t, "el_charge", &m_el_charge);
- InitBranch( t, "el_nblayerhits", &m_el_nblayerhits);
- InitBranch( t, "el_nblayerolhits", &m_el_nblayerolhits);
- InitBranch( t, "el_npixhits", &m_el_npixhits);
- InitBranch( t, "el_npixolhits", &m_el_npixolhits);
- InitBranch( t, "el_nscthits", &m_el_nscthits);
- InitBranch( t, "el_nsctolhits", &m_el_nsctolhits);
- InitBranch( t, "el_ntrthightreshits", &m_el_ntrthightreshits);
- InitBranch( t, "el_ntrthits", &m_el_ntrthits);
- InitBranch( t, "el_ntrthighthresolhits", &m_el_ntrthighthresolhits);
- InitBranch( t, "el_ntrtolhits", &m_el_ntrtolhits);
- InitBranch( t, "el_ntrtxenonhits", &m_el_ntrtxenonhits);
- InitBranch( t, "el_expectblayerhit", &m_el_expectblayerhit);
- InitBranch( t, "el_nsihits", &m_el_nsihits );
- InitBranch( t, "el_nsideadsensors", &m_el_nsideadsensors );
- InitBranch( t, "el_npixdeadsensors", &m_el_npixdeadsensors );
- InitBranch( t, "el_nsctdeadsensors", &m_el_nsctdeadsensors );
- InitBranch( t, "el_ringsE", &m_el_ringsE );
- InitBranch( t, "el_loose", &m_el_loose );
- InitBranch( t, "el_medium", &m_el_medium );
- InitBranch( t, "el_tight", &m_el_tight );
- InitBranch( t, "el_lhLoose", &m_el_lhLoose );
- InitBranch( t, "el_lhMedium", &m_el_lhMedium );
- InitBranch( t, "el_lhTight", &m_el_lhTight );
- InitBranch( t, "el_rgLoose", &m_el_rgLoose );
- InitBranch( t, "el_rgMedium", &m_el_rgMedium );
- InitBranch( t, "el_rgTight", &m_el_rgTight );
- InitBranch( t, "el_multiLepton", &m_el_multiLepton);
- InitBranch( t, "el_nGoodVtx", &m_el_nGoodVtx);
- InitBranch( t, "el_nPileupPrimaryVtx", &m_el_nPileupPrimaryVtx);
- InitBranch( t, "calo_et", &m_calo_et);
- InitBranch( t, "calo_eta", &m_calo_eta);
- InitBranch( t, "calo_phi", &m_calo_phi);
-
-}
-
-
-/*void TrigEgammaNavTPNtuple::linkPhotonBranches( TTree *t ){
-}*/
-
-void TrigEgammaNavTPNtuple::linkTriggerBranches( TTree *t ){
-
- InitBranch(t, "trig_L1_eta", &m_trig_L1_eta);
- InitBranch(t, "trig_L1_phi", &m_trig_L1_phi);
- InitBranch(t, "trig_L1_emClus", &m_trig_L1_emClus);
- InitBranch(t, "trig_L1_tauClus", &m_trig_L1_tauClus);
- InitBranch(t, "trig_L1_emIsol", &m_trig_L1_emIsol);
- InitBranch(t, "trig_L1_hadIsol", &m_trig_L1_hadIsol);
- InitBranch(t, "trig_L1_thrNames", &m_trig_L1_thrNames);
- InitBranch(t, "trig_L1_accept", &m_trig_L1_accept);
- InitBranch(t, "trig_L2_calo_et", &m_trig_L2_calo_et);
- InitBranch(t, "trig_L2_calo_eta", &m_trig_L2_calo_eta);
- InitBranch(t, "trig_L2_calo_phi", &m_trig_L2_calo_phi);
- InitBranch(t, "trig_L2_calo_e237", &m_trig_L2_calo_e237 );
- InitBranch(t, "trig_L2_calo_e277", &m_trig_L2_calo_e277 );
- InitBranch(t, "trig_L2_calo_fracs1", &m_trig_L2_calo_fracs1);
- InitBranch(t, "trig_L2_calo_weta2", &m_trig_L2_calo_weta2);
- InitBranch(t, "trig_L2_calo_ehad1", &m_trig_L2_calo_ehad1);
- InitBranch(t, "trig_L2_calo_emaxs1", &m_trig_L2_calo_emaxs1);
- InitBranch(t, "trig_L2_calo_e2tsts1", &m_trig_L2_calo_e2tsts1);
- InitBranch(t, "trig_L2_calo_wstot", &m_trig_L2_calo_wstot);
- InitBranch(t, "trig_L2_calo_rnnOutput", &m_trig_L2_calo_rnnOutput );
- InitBranch(t, "trig_L2_calo_rings", &m_trig_L2_calo_rings );
- InitBranch(t, "trig_L2_calo_energySample",&m_trig_L2_calo_energySample );
- InitBranch(t, "trig_L2_calo_accept", &m_trig_L2_calo_accept);
-
- InitBranch(t, "trig_L2_el_trackAlgID" , &m_trig_L2_el_trackAlgID );
- InitBranch(t, "trig_L2_el_pt" , &m_trig_L2_el_pt );
- InitBranch(t, "trig_L2_el_eta", &m_trig_L2_el_eta);
- InitBranch(t, "trig_L2_el_phi", &m_trig_L2_el_phi );
- InitBranch(t, "trig_L2_el_caloEta", &m_trig_L2_el_caloEta );
- InitBranch(t, "trig_L2_el_charge", &m_trig_L2_el_charge);
- InitBranch(t, "trig_L2_el_nTRTHits", &m_trig_L2_el_nTRTHits);
- InitBranch(t, "trig_L2_el_nTRTHiThresholdHits", &m_trig_L2_el_nTRTHiThresholdHits);
- InitBranch(t, "trig_L2_el_etOverPt" , &m_trig_L2_el_etOverPt );
- InitBranch(t, "trig_L2_el_trkClusDeta" , &m_trig_L2_el_trkClusDeta );
- InitBranch(t, "trig_L2_el_trkClusDphi" , &m_trig_L2_el_trkClusDphi );
-
- InitBranch(t, "trig_L2_el_accept", &m_trig_L2_el_accept );
- InitBranch(t, "trig_EF_el_accept", &m_trig_EF_el_accept );
- InitBranch(t, "trig_EF_calo_accept", &m_trig_EF_calo_accept );
- InitBranch(t, "trig_EF_calo_et", &m_trig_EF_calo_et );
- InitBranch(t, "trig_EF_calo_eta", &m_trig_EF_calo_eta );
-
-}
-
-
-void TrigEgammaNavTPNtuple::linkMonteCarloBranches(TTree *t){
-
- InitBranch(t, "mc_hasMC", &m_mc_hasMC);
- InitBranch(t, "mc_pt", &m_mc_pt);
- InitBranch(t, "mc_eta", &m_mc_eta);
- InitBranch(t, "mc_phi", &m_mc_phi);
- InitBranch(t, "mc_isTop", &m_mc_isTop);
- InitBranch(t, "mc_isParton", &m_mc_isParton);
- InitBranch(t, "mc_isMeson", &m_mc_isMeson);
- InitBranch(t, "mc_isTau", &m_mc_isTau);
- InitBranch(t, "mc_isMuon", &m_mc_isMuon);
- InitBranch(t, "mc_isPhoton", &m_mc_isPhoton);
- InitBranch(t, "mc_isElectron", &m_mc_isElectron);
- InitBranch(t, "mc_hasZMother", &m_mc_hasZMother);
- InitBranch(t, "mc_hasWMother", &m_mc_hasWMother);
-}
-
-void TrigEgammaNavTPNtuple::clear(){
-
- ///EventInfo
- m_runNumber = 0;
- m_eventNumber = 0;
- m_avgmu = 0;
- ///Egamma
- m_el_et = -1;
- m_el_pt = -1;
- m_el_eta = -1;
- m_el_phi = -1;
- m_el_ethad1 = -1;
- m_el_ehad1 = -1;
- m_el_f1 = -1;
- m_el_f3 = -1;
- m_el_f1core = -1;
- m_el_f3core = -1;
- m_el_weta2 = -1;
- m_el_d0 = -1;
- m_el_wtots1 = -1;
- m_el_fracs1 = -1;
- m_el_Reta = -1;
- m_el_Rphi = -1;
- m_el_Eratio = -1;
- m_el_Rhad = -1;
- m_el_Rhad1 = -1;
- m_el_deta1 = -1;
- m_el_deta2 = -1;
- m_el_dphi2 = -1;
- m_el_dphiresc = -1;
- m_el_dphiresc2 = -1;
- m_el_eprobht = -1;
- m_el_charge = 0;
- m_el_nblayerhits = 0;
- m_el_nblayerolhits = 0;
- m_el_npixhits = 0;
- m_el_npixolhits = 0;
- m_el_nscthits = 0;
- m_el_nsctolhits = 0;
- m_el_ntrthightreshits = 0;
- m_el_ntrthits = 0;
- m_el_ntrthighthresolhits= 0;
- m_el_ntrtolhits = 0;
- m_el_ntrtxenonhits = 0;
- m_el_expectblayerhit = false;
- m_el_nsihits = 0;
- m_el_nsideadsensors = 0;
- m_el_npixdeadsensors = 0;
- m_el_nsctdeadsensors = 0;
- m_el_loose = false;
- m_el_medium = false;
- m_el_tight = false;
- m_el_lhLoose = false;
- m_el_lhMedium = false;
- m_el_lhTight = false;
- m_el_rgLoose = false;
- m_el_rgMedium = false;
- m_el_rgTight = false;
- m_el_multiLepton = false;
- m_el_nGoodVtx = -1;
- m_el_nPileupPrimaryVtx = -1;
- m_calo_et = -1;
- m_calo_eta = -1;
- m_calo_phi = -1;
-
- ///Trigger
- m_trig_L1_eta = -1;
- m_trig_L1_phi = -1;
- m_trig_L1_emClus = -1;
- m_trig_L1_tauClus = -1;
- m_trig_L1_emIsol = -1;
- m_trig_L1_hadIsol = -1;
- m_trig_L1_accept = false;
- m_trig_L2_calo_et = -1;
- m_trig_L2_calo_eta = -1;
- m_trig_L2_calo_phi = -1;
- m_trig_L2_calo_e237 = -1;
- m_trig_L2_calo_e277 = -1;
- m_trig_L2_calo_fracs1 = -1;
- m_trig_L2_calo_weta2 = -1;
- m_trig_L2_calo_ehad1 = -1;
- m_trig_L2_calo_emaxs1 = -1;
- m_trig_L2_calo_e2tsts1 = -1;
- m_trig_L2_calo_wstot = -1;
- m_trig_L2_calo_rnnOutput = 999;
-
- m_trig_L1_accept = false;
- m_trig_L2_calo_accept = false;
- m_trig_L2_el_accept = false;
- m_trig_EF_calo_accept = false;
- m_trig_EF_el_accept = false;
-
- ///Monte Carlo
- m_mc_hasMC = false;
- m_mc_pt = -1;
- m_mc_eta = -1;
- m_mc_phi = -1;
- m_mc_isTop = false;
- m_mc_isParton = false;
- m_mc_isMeson = false;
- m_mc_isTau = false;
- m_mc_isMuon = false;
- m_mc_isPhoton = false;
- m_mc_isElectron = false;
- m_mc_hasZMother = false;
- m_mc_hasWMother = false;
-
- ///Some vectors
- m_trig_L1_thrNames ->clear();
- m_trig_L2_calo_energySample ->clear();
- m_trig_L2_calo_rings ->clear();
-
- m_trig_L2_el_trackAlgID ->clear();
- m_trig_L2_el_eta ->clear();
- m_trig_L2_el_phi ->clear();
- m_trig_L2_el_caloEta ->clear();
- m_trig_L2_el_trkClusDeta ->clear();
- m_trig_L2_el_trkClusDphi ->clear();
- m_trig_L2_el_pt ->clear();
- m_trig_L2_el_etOverPt ->clear();
- m_trig_L2_el_nTRTHits ->clear();
- m_trig_L2_el_nTRTHiThresholdHits ->clear();
- m_trig_L2_el_charge ->clear();
- m_trig_EF_calo_et ->clear();
- m_trig_EF_calo_eta ->clear();
-
-
-}
-
-void TrigEgammaNavTPNtuple::alloc_space(){
-
- m_el_ringsE = new std::vector<float>();
- m_trig_L1_thrNames = new std::vector<std::string>();
- m_trig_L2_calo_energySample = new std::vector<float>();
- m_trig_L2_calo_rings = new std::vector<float>();
- m_trig_L2_el_trackAlgID = new std::vector<int>();
- m_trig_L2_el_eta = new std::vector<float>();
- m_trig_L2_el_phi = new std::vector<float>();
- m_trig_L2_el_caloEta = new std::vector<float>();
- m_trig_L2_el_trkClusDeta = new std::vector<float>();
- m_trig_L2_el_trkClusDphi = new std::vector<float>();
- m_trig_L2_el_pt = new std::vector<float>();
- m_trig_L2_el_etOverPt = new std::vector<float>();
- m_trig_L2_el_nTRTHits = new std::vector<float>();
- m_trig_L2_el_nTRTHiThresholdHits = new std::vector<float>();
- m_trig_L2_el_charge = new std::vector<float>();
- m_trig_EF_calo_et = new std::vector<float>();
- m_trig_EF_calo_eta = new std::vector<float>();
-
-}
-
-
-void TrigEgammaNavTPNtuple::release_space(){
- delete m_el_ringsE ;
- delete m_trig_L1_thrNames ;
- delete m_trig_L2_calo_energySample;
- delete m_trig_L2_calo_rings ;
- delete m_trig_L2_el_trackAlgID ;
- delete m_trig_L2_el_pt ;
- delete m_trig_L2_el_eta ;
- delete m_trig_L2_el_caloEta ;
- delete m_trig_L2_el_phi ;
- delete m_trig_L2_el_charge ;
- delete m_trig_L2_el_nTRTHits ;
- delete m_trig_L2_el_nTRTHiThresholdHits ;
- delete m_trig_L2_el_etOverPt ;
- delete m_trig_L2_el_trkClusDeta ;
- delete m_trig_L2_el_trkClusDphi ;
- delete m_trig_EF_calo_et ;
- delete m_trig_EF_calo_eta ;
-}
-
-unsigned TrigEgammaNavTPNtuple::count_HLT_objects( const HLT::TriggerElement *feat )
-{
- unsigned nobj=0;
- if(getFeature<xAOD::ElectronContainer>(feat) ) nobj++; // HLT
- if(getFeature<xAOD::CaloClusterContainer>(feat) ) nobj++; // EFCalo
- if(getFeature<xAOD::TrigElectronContainer>(feat)) nobj++; // L2
- if(getFeature<xAOD::TrigEMCluster>(feat) ) nobj++; // L2Calo
- ATH_MSG_DEBUG("Number of objects counted in this feature: " << nobj);
- return nobj;
-}
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaPhysValBase.cxx b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaPhysValBase.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..c5c99d9f982b87994d37284f574100e4f1a8090a
--- /dev/null
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaPhysValBase.cxx
@@ -0,0 +1,1005 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include <iostream>
+#include "TrigEgammaAnalysisTools/TrigEgammaPhysValBase.h"
+using namespace std;
+
+TrigEgammaPhysValBase::TrigEgammaPhysValBase(){
+
+ m_el_ringsE=nullptr;
+ m_trig_L1_thrNames=nullptr;
+ m_trig_L2_calo_energySample=nullptr;
+ m_trig_L2_calo_rings=nullptr;
+ m_trig_L2_el_trackAlgID=nullptr;
+ m_trig_L2_el_pt=nullptr;
+ m_trig_L2_el_eta=nullptr;
+ m_trig_L2_el_caloEta=nullptr;
+ m_trig_L2_el_phi=nullptr;
+ m_trig_L2_el_charge=nullptr;
+ m_trig_L2_el_nTRTHits=nullptr;
+ m_trig_L2_el_nTRTHiThresholdHits=nullptr;
+ m_trig_L2_el_etOverPt=nullptr;
+ m_trig_L2_el_trkClusDeta=nullptr;
+ m_trig_L2_el_trkClusDphi=nullptr;
+ m_trig_EF_calo_et=nullptr;
+ m_trig_EF_calo_eta=nullptr;
+
+ m_doMCDetailed=false;
+ m_doL2Detailed=false;
+ m_doL2CaloDetailed=false;
+ m_doRecoDetailed=false;
+}
+
+/*
+ * book, link, clear, alloc and release method divide in:
+ * trigger, Egamma and MonteCarlo data base.
+ */
+template <class T>
+void TrigEgammaPhysValBase::InitBranch(TTree* fChain, std::string branch_name, T* param, bool message){
+
+ std::string bname = branch_name;
+ if (fChain->GetAlias(bname.c_str()))
+ bname = std::string(fChain->GetAlias(bname.c_str()));
+
+ if (!fChain->FindBranch(bname.c_str()) && message) {
+ return;
+ }
+ fChain->SetBranchStatus(bname.c_str(), 1.);
+ fChain->SetBranchAddress(bname.c_str(), param);
+}
+
+void TrigEgammaPhysValBase::bookEventBranches(TTree *t){
+
+ t->Branch("RunNumber", &m_runNumber);
+ t->Branch("EventNumber", &m_eventNumber);
+ t->Branch("LumiBlock", &m_lumiBlock);
+ t->Branch("avgmu", &m_avgmu);
+}
+
+void TrigEgammaPhysValBase::bookTriggerBranches(TTree *t){
+
+ // Level L1 cluster
+ t->Branch( "trig_L1_eta", &m_trig_L1_eta);
+ t->Branch( "trig_L1_phi", &m_trig_L1_phi);
+ t->Branch( "trig_L1_emClus", &m_trig_L1_emClus);
+ t->Branch( "trig_L1_tauClus", &m_trig_L1_tauClus);
+ t->Branch( "trig_L1_emIsol", &m_trig_L1_emIsol);
+ t->Branch( "trig_L1_hadIsol", &m_trig_L1_hadIsol);
+ t->Branch( "trig_L1_hadCore", &m_trig_L1_hadCore);
+ t->Branch( "trig_L2_calo_et", &m_trig_L2_calo_et);
+ t->Branch( "trig_L2_calo_eta", &m_trig_L2_calo_eta);
+ t->Branch( "trig_L2_calo_phi", &m_trig_L2_calo_phi);
+
+ if(m_doL2CaloDetailed){
+ t->Branch( "trig_L2_calo_e237", &m_trig_L2_calo_e237 );
+ t->Branch( "trig_L2_calo_e277", &m_trig_L2_calo_e277 );
+ t->Branch( "trig_L2_calo_fracs1", &m_trig_L2_calo_fracs1);
+ t->Branch( "trig_L2_calo_weta2", &m_trig_L2_calo_weta2);
+ t->Branch( "trig_L2_calo_ehad1", &m_trig_L2_calo_ehad1);
+ t->Branch( "trig_L2_calo_emaxs1", &m_trig_L2_calo_emaxs1);
+ t->Branch( "trig_L2_calo_e2tsts1", &m_trig_L2_calo_e2tsts1);
+ t->Branch( "trig_L2_calo_wstot", &m_trig_L2_calo_wstot);
+ t->Branch( "trig_L2_calo_energySample",&m_trig_L2_calo_energySample);
+ }
+
+ t->Branch( "trig_L2_calo_rings", &m_trig_L2_calo_rings );
+ t->Branch( "trig_L2_calo_rnnOutput", &m_trig_L2_calo_rnnOutput );
+
+
+ if(m_doL2Detailed){
+ t->Branch( "trig_L2_el_pt" , &m_trig_L2_el_pt );
+ t->Branch( "trig_L2_el_eta", &m_trig_L2_el_eta);
+ t->Branch( "trig_L2_el_phi", &m_trig_L2_el_phi );
+ t->Branch( "trig_L2_el_caloEta", &m_trig_L2_el_caloEta );
+ t->Branch( "trig_L2_el_charge", &m_trig_L2_el_charge);
+ t->Branch( "trig_L2_el_nTRTHits", &m_trig_L2_el_nTRTHits);
+ t->Branch( "trig_L2_el_nTRTHiThresholdHits", &m_trig_L2_el_nTRTHiThresholdHits);
+ t->Branch( "trig_L2_el_etOverPt" , &m_trig_L2_el_etOverPt );
+ t->Branch( "trig_L2_el_trkClusDeta" , &m_trig_L2_el_trkClusDeta );
+ t->Branch( "trig_L2_el_trkClusDphi" , &m_trig_L2_el_trkClusDphi );
+ t->Branch( "trig_L2_el_trackAlgID" , &m_trig_L2_el_trackAlgID );
+ }
+
+ t->Branch( "trig_EF_calo_e", &m_trig_EF_calo_e );
+ t->Branch( "trig_EF_calo_et", &m_trig_EF_calo_et );
+ t->Branch( "trig_EF_calo_eta", &m_trig_EF_calo_eta );
+ t->Branch( "trig_EF_calo_phi", &m_trig_EF_calo_phi );
+ t->Branch( "trig_EF_calo_etaBE2", &m_trig_EF_calo_etaBE2 );
+
+#define BRANCH(_name_) t->Branch( #_name_ , & m_##_name_ );\
+
+ BRANCH( trig_EF_calo_tight );
+ BRANCH( trig_EF_calo_medium );
+ BRANCH( trig_EF_calo_loose );
+ BRANCH( trig_EF_calo_lhtight );
+ BRANCH( trig_EF_calo_lhmedium );
+ BRANCH( trig_EF_calo_lhloose );
+ BRANCH( trig_EF_calo_lhvloose );
+
+ BRANCH( trig_EF_el_calo_e );
+ BRANCH( trig_EF_el_calo_et );
+ BRANCH( trig_EF_el_calo_eta );
+ BRANCH( trig_EF_el_calo_phi );
+ BRANCH( trig_EF_el_calo_etaBE2 );
+
+ BRANCH( trig_EF_el_hasCalo );
+ BRANCH( trig_EF_el_hasTrack );
+ BRANCH( trig_EF_el_e );
+ BRANCH( trig_EF_el_et );
+ BRANCH( trig_EF_el_eta );
+ BRANCH( trig_EF_el_phi );
+ BRANCH( trig_EF_el_e277 );
+ BRANCH( trig_EF_el_ethad1 );
+ BRANCH( trig_EF_el_ehad1 );
+ BRANCH( trig_EF_el_f1 );
+ BRANCH( trig_EF_el_f3 );
+ BRANCH( trig_EF_el_f1core );
+ BRANCH( trig_EF_el_f3core );
+ BRANCH( trig_EF_el_weta1 );
+ BRANCH( trig_EF_el_weta2 );
+ BRANCH( trig_EF_el_wtots1 );
+ BRANCH( trig_EF_el_fracs1 );
+ BRANCH( trig_EF_el_Reta );
+ BRANCH( trig_EF_el_Rphi );
+ BRANCH( trig_EF_el_Eratio );
+ BRANCH( trig_EF_el_Rhad );
+ BRANCH( trig_EF_el_Rhad1 );
+ BRANCH( trig_EF_el_deta2 );
+ BRANCH( trig_EF_el_dphi2 );
+ BRANCH( trig_EF_el_dphiresc );
+ BRANCH( trig_EF_el_deltaPhiRescaled2 );
+ BRANCH( trig_EF_el_deltaEta1 );
+ BRANCH( trig_EF_el_deltaE );
+ BRANCH( trig_EF_el_etCone );
+ BRANCH( trig_EF_el_ptCone );
+
+ BRANCH( trig_EF_el_trk_pt );
+ BRANCH( trig_EF_el_trk_eta );
+ BRANCH( trig_EF_el_trk_charge );
+ BRANCH( trig_EF_el_trk_qOverP );
+ BRANCH( trig_EF_el_trk_sigd0 );
+ BRANCH( trig_EF_el_trk_d0 );
+ BRANCH( trig_EF_el_trk_eProbabilityHT );
+ BRANCH( trig_EF_el_trk_transformed_eProbabilityHT );
+ BRANCH( trig_EF_el_trk_d0significance );
+ BRANCH( trig_EF_el_trk_deltaPOverP );
+ BRANCH( trig_EF_el_trk_summaryValues );
+
+ BRANCH( trig_EF_el_tight );
+ BRANCH( trig_EF_el_medium );
+ BRANCH( trig_EF_el_loose );
+ BRANCH( trig_EF_el_lhtight );
+ BRANCH( trig_EF_el_lhmedium );
+ BRANCH( trig_EF_el_lhloose );
+ BRANCH( trig_EF_el_lhvloose );
+
+
+
+#undef BRANCH
+
+
+
+}
+
+
+
+void TrigEgammaPhysValBase::bookElectronBranches(TTree *t){
+
+ t->Branch("el_calo_e", &m_el_calo_e);
+ t->Branch("el_calo_et", &m_el_calo_et);
+ t->Branch("el_calo_eta", &m_el_calo_eta);
+ t->Branch("el_calo_etaBE2", &m_el_calo_etaBE2);
+ t->Branch("el_calo_phi", &m_el_calo_phi);
+
+ t->Branch("el_hasCalo", &m_el_hasCalo );
+ t->Branch("el_hasTrack", &m_el_hasTrack );
+ t->Branch("el_e", &m_el_e );
+ t->Branch("el_et", &m_el_et );
+ t->Branch("el_eta", &m_el_eta );
+ t->Branch("el_phi", &m_el_phi );
+
+ if(m_doRecoDetailed){
+ t->Branch("el_ethad1", &m_el_ethad1);
+ t->Branch("el_ehad1", &m_el_ehad1);
+ t->Branch("el_e277", &m_el_e277);
+ t->Branch("el_f1", &m_el_f1);
+ t->Branch("el_f3", &m_el_f3);
+ t->Branch("el_f1core", &m_el_f1core);
+ t->Branch("el_f3core", &m_el_f3core);
+ t->Branch("el_weta1", &m_el_weta1);
+ t->Branch("el_weta2", &m_el_weta2);
+ t->Branch("el_wtots1", &m_el_wtots1);
+ t->Branch("el_fracs1", &m_el_fracs1);
+ t->Branch("el_Reta", &m_el_Reta);
+ t->Branch("el_Rphi", &m_el_Rphi);
+ t->Branch("el_Eratio", &m_el_Eratio);
+ t->Branch("el_Rhad", &m_el_Rhad);
+ t->Branch("el_Rhad1", &m_el_Rhad1);
+ t->Branch("el_deta2", &m_el_deta2);
+ t->Branch("el_dphi2", &m_el_dphi2);
+ t->Branch("el_dphiresc", &m_el_dphiresc);
+ t->Branch("el_deltaPhiRescaled2" , &m_el_deltaPhiRescaled2 );
+ t->Branch("el_deltaEta1" , &m_el_deltaEta1 );
+ t->Branch("el_deltaE", &m_el_deltaE );
+ t->Branch("el_etCone" , &m_el_etCone );
+ t->Branch("el_ptCone" , &m_el_ptCone );
+
+
+ t->Branch("el_trk_pt", &m_el_trk_pt );
+ t->Branch("el_trk_eta", &m_el_trk_eta );
+ t->Branch("el_trk_charge", &m_el_trk_charge);
+ t->Branch("el_trk_qOverP", &m_el_trk_qOverP);
+ t->Branch("el_trk_sigd0" , &m_el_trk_sigd0 );
+ t->Branch("el_trk_d0" , &m_el_trk_d0 );
+ t->Branch("el_trk_eProbabilityHT" , &m_el_trk_eProbabilityHT );
+ t->Branch("el_trk_transformed_eProbabilityHT", &m_el_trk_transformed_eProbabilityHT);
+ t->Branch("el_trk_d0significance" , &m_el_trk_d0significance );
+ t->Branch("el_trk_deltaPOverP" , &m_el_trk_deltaPOverP );
+ t->Branch("el_trk_summaryValues" , &m_el_trk_summaryValues );
+ }
+
+ t->Branch("el_ringsE", &m_el_ringsE );
+ t->Branch("el_nGoodVtx", &m_el_nGoodVtx);
+ t->Branch("el_nPileupPrimaryVtx", &m_el_nPileupPrimaryVtx);
+
+
+ t->Branch("el_loose", &m_el_loose );
+ t->Branch("el_medium", &m_el_medium );
+ t->Branch("el_tight", &m_el_tight );
+ t->Branch("el_lhvloose", &m_el_lhVLoose );
+ t->Branch("el_lhloose", &m_el_lhLoose );
+ t->Branch("el_lhmedium", &m_el_lhMedium );
+ t->Branch("el_lhtight", &m_el_lhTight );
+ t->Branch("el_multiLepton", &m_el_multiLepton);
+
+
+
+}
+
+
+void TrigEgammaPhysValBase::createTDTMetadata( TTree *t, std::vector<std::string> trigList ){
+
+ std::vector<std::string> *trig_tdt_triggerList;
+ t->Branch("trig_tdt_triggerList", &trig_tdt_triggerList );
+ trig_tdt_triggerList = new std::vector<std::string>();
+ for(auto& trigger : trigList ){
+ trig_tdt_triggerList->push_back(trigger);
+ }
+ t->Fill();
+ delete trig_tdt_triggerList;
+}
+
+
+void TrigEgammaPhysValBase::bookTDTBranches(TTree *t){
+
+ t->Branch("trig_tdt_L1_calo_accept", &m_trig_tdt_L1_calo_accept);
+ t->Branch("trig_tdt_L2_calo_accept", &m_trig_tdt_L2_calo_accept);
+ t->Branch("trig_tdt_L2_el_accept", &m_trig_tdt_L2_el_accept );
+ t->Branch("trig_tdt_EF_calo_accept", &m_trig_tdt_EF_calo_accept);
+ t->Branch("trig_tdt_EF_el_accept", &m_trig_tdt_EF_el_accept );
+ t->Branch("trig_tdt_emu_L1_calo_accept", &m_trig_tdt_emu_L1_calo_accept);
+ t->Branch("trig_tdt_emu_L2_calo_accept", &m_trig_tdt_emu_L2_calo_accept);
+ t->Branch("trig_tdt_emu_L2_el_accept", &m_trig_tdt_emu_L2_el_accept );
+ t->Branch("trig_tdt_emu_EF_calo_accept", &m_trig_tdt_emu_EF_calo_accept);
+ t->Branch("trig_tdt_emu_EF_el_accept", &m_trig_tdt_emu_EF_el_accept );
+
+}
+
+
+
+void TrigEgammaPhysValBase::bookMonteCarloBranches(TTree *t){
+ // Monte Carlo
+ t->Branch("mc_hasMC", &m_mc_hasMC);
+ t->Branch("mc_pt", &m_mc_pt);
+ t->Branch("mc_eta", &m_mc_eta);
+ t->Branch("mc_phi", &m_mc_phi);
+
+ if(m_doMCDetailed){
+ t->Branch("mc_isTop", &m_mc_isTop);
+ t->Branch("mc_isParton", &m_mc_isParton);
+ t->Branch("mc_isMeson", &m_mc_isMeson);
+ t->Branch("mc_isTau", &m_mc_isTau);
+ t->Branch("mc_isMuon", &m_mc_isMuon);
+ }
+
+ t->Branch("mc_isPhoton", &m_mc_isPhoton);
+ t->Branch("mc_isElectron", &m_mc_isElectron);
+ t->Branch("mc_hasZMother", &m_mc_hasZMother);
+ t->Branch("mc_hasWMother", &m_mc_hasWMother);
+}
+
+
+void TrigEgammaPhysValBase::linkTDTBranches(TTree *t){
+
+ InitBranch( t, "trig_tdt_L1_calo_accept", &m_trig_tdt_L1_calo_accept);
+ InitBranch( t, "trig_tdt_L2_calo_accept", &m_trig_tdt_L2_calo_accept);
+ InitBranch( t, "trig_tdt_L2_el_accept", &m_trig_tdt_L2_el_accept );
+ InitBranch( t, "trig_tdt_EF_calo_accept", &m_trig_tdt_EF_calo_accept);
+ InitBranch( t, "trig_tdt_EF_el_accept", &m_trig_tdt_EF_el_accept );
+ InitBranch( t, "trig_tdt_emu_L1_calo_accept", &m_trig_tdt_emu_L1_calo_accept);
+ InitBranch( t, "trig_tdt_emu_L2_calo_accept", &m_trig_tdt_emu_L2_calo_accept);
+ InitBranch( t, "trig_tdt_emu_L2_el_accept", &m_trig_tdt_emu_L2_el_accept );
+ InitBranch( t, "trig_tdt_emu_EF_calo_accept", &m_trig_tdt_emu_EF_calo_accept);
+ InitBranch( t, "trig_tdt_emu_EF_el_accept", &m_trig_tdt_emu_EF_el_accept );
+
+}
+
+
+
+void TrigEgammaPhysValBase::linkEventBranches(TTree *t){
+
+ InitBranch( t, "RunNumber", &m_runNumber);
+ InitBranch( t, "EventNumber", &m_eventNumber);
+ InitBranch( t, "LumiBlock", &m_lumiBlock);
+ InitBranch( t, "avgmu", &m_avgmu);
+}
+
+void TrigEgammaPhysValBase::linkElectronBranches( TTree *t ){
+
+ InitBranch( t, "el_calo_e", &m_el_calo_e);
+ InitBranch( t, "el_calo_et", &m_el_calo_et);
+ InitBranch( t, "el_calo_eta", &m_el_calo_eta);
+ InitBranch( t, "el_calo_etaBE2", &m_el_calo_etaBE2);
+ InitBranch( t, "el_calo_phi", &m_el_calo_phi);
+
+ InitBranch( t, "el_hasCalo", &m_el_hasCalo);
+ InitBranch( t, "el_hasTrack", &m_el_hasTrack);
+ InitBranch( t, "el_e", &m_el_e);
+ InitBranch( t, "el_et", &m_el_et);
+ InitBranch( t, "el_eta", &m_el_eta);
+ InitBranch( t, "el_phi", &m_el_phi);
+
+
+ if(m_doRecoDetailed){
+ InitBranch( t, "el_ethad1", &m_el_ethad1);
+ InitBranch( t, "el_ehad1", &m_el_ehad1);
+ InitBranch( t, "el_f1", &m_el_f1);
+ InitBranch( t, "el_f3", &m_el_f3);
+ InitBranch( t, "el_f1core", &m_el_f1core);
+ InitBranch( t, "el_f3core", &m_el_f3core);
+ InitBranch( t, "el_weta1", &m_el_weta2);
+ InitBranch( t, "el_weta2", &m_el_weta2);
+ InitBranch( t, "el_wtots1", &m_el_wtots1);
+ InitBranch( t, "el_fracs1", &m_el_fracs1);
+ InitBranch( t, "el_Reta", &m_el_Reta);
+ InitBranch( t, "el_Rphi", &m_el_Rphi);
+ InitBranch( t, "el_Eratio", &m_el_Eratio);
+ InitBranch( t, "el_Rhad", &m_el_Rhad);
+ InitBranch( t, "el_Rhad1", &m_el_Rhad1);
+ InitBranch( t, "el_deta2", &m_el_deta2);
+ InitBranch( t, "el_dphi2", &m_el_dphi2);
+ InitBranch( t, "el_dphiresc", &m_el_dphiresc);
+ InitBranch( t, "el_deltaPhiRescaled2" , &m_el_deltaPhiRescaled2 );
+ InitBranch( t, "el_e277" , &m_el_e277 );
+ InitBranch( t, "el_deltaE" , &m_el_e277 );
+ InitBranch( t, "el_deltaEta1" , &m_el_deltaEta1 );
+ InitBranch( t, "el_etCone" , &m_el_etCone );
+ InitBranch( t, "el_ptCone" , &m_el_ptCone );
+
+ InitBranch( t, "el_trk_pt", &m_el_trk_pt);
+ InitBranch( t, "el_trk_eta" , &m_el_trk_eta);
+ InitBranch( t, "el_trk_charge", &m_el_trk_charge);
+ InitBranch( t, "el_trk_qOverP", &m_el_trk_qOverP);
+ InitBranch( t, "el_trk_deltaPOverP" , &m_el_trk_deltaPOverP );
+ InitBranch( t, "el_trk_sigd0" , &m_el_trk_sigd0 );
+ InitBranch( t, "el_trk_d0" , &m_el_trk_d0 );
+ InitBranch( t, "el_trk_eProbabilityHT" , &m_el_trk_eProbabilityHT );
+ InitBranch( t, "el_trk_transformed_eProbabilityHT", &m_el_trk_transformed_eProbabilityHT);
+ InitBranch( t, "el_trk_d0significance" , &m_el_trk_d0significance );
+ InitBranch( t, "el_trk_summaryValues" , &m_el_trk_summaryValues );
+
+
+ }
+
+ InitBranch( t, "el_nGoodVtx", &m_el_nGoodVtx);
+ InitBranch( t, "el_ringsE", &m_el_ringsE );
+ InitBranch( t, "el_nPileupPrimaryVtx", &m_el_nPileupPrimaryVtx);
+
+ InitBranch( t, "el_loose", &m_el_loose );
+ InitBranch( t, "el_medium", &m_el_medium );
+ InitBranch( t, "el_tight", &m_el_tight );
+ InitBranch( t, "el_lhvloose", &m_el_lhVLoose );
+ InitBranch( t, "el_lhloose", &m_el_lhLoose );
+ InitBranch( t, "el_lhmedium", &m_el_lhMedium );
+ InitBranch( t, "el_lhtight", &m_el_lhTight );
+ InitBranch( t, "el_multiLepton", &m_el_multiLepton);
+}
+
+
+
+void TrigEgammaPhysValBase::linkTriggerBranches( TTree *t ){
+
+ InitBranch(t, "trig_L1_eta", &m_trig_L1_eta);
+ InitBranch(t, "trig_L1_phi", &m_trig_L1_phi);
+ InitBranch(t, "trig_L1_emClus", &m_trig_L1_emClus);
+ InitBranch(t, "trig_L1_tauClus", &m_trig_L1_tauClus);
+ InitBranch(t, "trig_L1_emIsol", &m_trig_L1_emIsol);
+ InitBranch(t, "trig_L1_hadIsol", &m_trig_L1_hadIsol);
+ InitBranch(t, "trig_L1_hadCore", &m_trig_L1_hadCore);
+ InitBranch(t, "trig_L2_calo_et", &m_trig_L2_calo_et);
+ InitBranch(t, "trig_L2_calo_eta", &m_trig_L2_calo_eta);
+ InitBranch(t, "trig_L2_calo_phi", &m_trig_L2_calo_phi);
+
+ if(m_doL2CaloDetailed){
+ InitBranch(t, "trig_L2_calo_e237", &m_trig_L2_calo_e237 );
+ InitBranch(t, "trig_L2_calo_e277", &m_trig_L2_calo_e277 );
+ InitBranch(t, "trig_L2_calo_fracs1", &m_trig_L2_calo_fracs1);
+ InitBranch(t, "trig_L2_calo_weta2", &m_trig_L2_calo_weta2);
+ InitBranch(t, "trig_L2_calo_ehad1", &m_trig_L2_calo_ehad1);
+ InitBranch(t, "trig_L2_calo_emaxs1", &m_trig_L2_calo_emaxs1);
+ InitBranch(t, "trig_L2_calo_e2tsts1", &m_trig_L2_calo_e2tsts1);
+ InitBranch(t, "trig_L2_calo_wstot", &m_trig_L2_calo_wstot);
+ InitBranch(t, "trig_L2_calo_energySample", &m_trig_L2_calo_energySample);
+ }
+
+ InitBranch(t, "trig_L2_calo_rings", &m_trig_L2_calo_rings );
+ InitBranch(t, "trig_L2_calo_rnnOutput", &m_trig_L2_calo_rnnOutput);
+
+ if(m_doL2Detailed){
+ InitBranch(t, "trig_L2_el_trackAlgID" , &m_trig_L2_el_trackAlgID );
+ InitBranch(t, "trig_L2_el_pt" , &m_trig_L2_el_pt );
+ InitBranch(t, "trig_L2_el_eta", &m_trig_L2_el_eta);
+ InitBranch(t, "trig_L2_el_phi", &m_trig_L2_el_phi );
+ InitBranch(t, "trig_L2_el_caloEta", &m_trig_L2_el_caloEta );
+ InitBranch(t, "trig_L2_el_charge", &m_trig_L2_el_charge);
+ InitBranch(t, "trig_L2_el_nTRTHits", &m_trig_L2_el_nTRTHits);
+ InitBranch(t, "trig_L2_el_nTRTHiThresholdHits", &m_trig_L2_el_nTRTHiThresholdHits);
+ InitBranch(t, "trig_L2_el_etOverPt" , &m_trig_L2_el_etOverPt );
+ InitBranch(t, "trig_L2_el_trkClusDeta" , &m_trig_L2_el_trkClusDeta );
+ InitBranch(t, "trig_L2_el_trkClusDphi" , &m_trig_L2_el_trkClusDphi );
+
+ }
+
+
+
+#define INIT(_name_) TrigEgammaPhysValBase::InitBranch(t, #_name_, & m_##_name_);\
+
+ INIT( trig_EF_calo_et );
+ INIT( trig_EF_calo_eta );
+ INIT( trig_EF_calo_phi );
+ INIT( trig_EF_calo_etaBE2 );
+ INIT( trig_EF_calo_e );
+
+ INIT( trig_EF_el_calo_e );
+ INIT( trig_EF_el_calo_et );
+ INIT( trig_EF_el_calo_eta );
+ INIT( trig_EF_el_calo_phi );
+ INIT( trig_EF_el_calo_etaBE2 );
+
+ INIT( trig_EF_el_hasCalo );
+ INIT( trig_EF_el_hasTrack );
+ INIT( trig_EF_el_et );
+ INIT( trig_EF_el_eta );
+ INIT( trig_EF_el_phi );
+ INIT( trig_EF_el_e );
+ INIT( trig_EF_el_ethad1 );
+ INIT( trig_EF_el_ehad1 );
+ INIT( trig_EF_el_f1 );
+ INIT( trig_EF_el_f3 );
+ INIT( trig_EF_el_f1core );
+ INIT( trig_EF_el_f3core );
+ INIT( trig_EF_el_weta1 );
+ INIT( trig_EF_el_weta2 );
+ INIT( trig_EF_el_wtots1 );
+ INIT( trig_EF_el_fracs1 );
+ INIT( trig_EF_el_Reta );
+ INIT( trig_EF_el_Rphi );
+ INIT( trig_EF_el_Eratio );
+ INIT( trig_EF_el_Rhad );
+ INIT( trig_EF_el_Rhad1 );
+ INIT( trig_EF_el_deta2 );
+ INIT( trig_EF_el_dphi2 );
+ INIT( trig_EF_el_e277 );
+ INIT( trig_EF_el_deltaE );
+ INIT( trig_EF_el_dphiresc );
+ INIT( trig_EF_el_deltaPhiRescaled2 );
+ INIT( trig_EF_el_deltaEta1 );
+ INIT( trig_EF_el_etCone );
+ INIT( trig_EF_el_ptCone );
+
+ INIT( trig_EF_el_trk_pt );
+ INIT( trig_EF_el_trk_eta );
+ INIT( trig_EF_el_trk_charge );
+ INIT( trig_EF_el_trk_qOverP );
+ INIT( trig_EF_el_trk_sigd0 );
+ INIT( trig_EF_el_trk_d0 );
+ INIT( trig_EF_el_trk_eProbabilityHT );
+ INIT( trig_EF_el_trk_transformed_eProbabilityHT );
+ INIT( trig_EF_el_trk_d0significance );
+ INIT( trig_EF_el_trk_deltaPOverP );
+ INIT( trig_EF_el_trk_summaryValues );
+
+ INIT( trig_EF_calo_tight );
+ INIT( trig_EF_calo_medium );
+ INIT( trig_EF_calo_loose );
+ INIT( trig_EF_calo_lhtight );
+ INIT( trig_EF_calo_lhmedium );
+ INIT( trig_EF_calo_lhloose );
+ INIT( trig_EF_calo_lhvloose );
+ INIT( trig_EF_el_tight );
+ INIT( trig_EF_el_medium );
+ INIT( trig_EF_el_loose );
+ INIT( trig_EF_el_lhtight );
+ INIT( trig_EF_el_lhmedium );
+ INIT( trig_EF_el_lhloose );
+ INIT( trig_EF_el_lhvloose );
+
+
+
+#undef INIT
+
+
+}
+
+
+
+void TrigEgammaPhysValBase::linkMonteCarloBranches(TTree *t){
+
+ InitBranch(t, "mc_hasMC", &m_mc_hasMC);
+ InitBranch(t, "mc_pt", &m_mc_pt);
+ InitBranch(t, "mc_eta", &m_mc_eta);
+ InitBranch(t, "mc_phi", &m_mc_phi);
+
+ if(m_doMCDetailed){
+ InitBranch(t, "mc_isTop", &m_mc_isTop);
+ InitBranch(t, "mc_isParton", &m_mc_isParton);
+ InitBranch(t, "mc_isMeson", &m_mc_isMeson);
+ InitBranch(t, "mc_isTau", &m_mc_isTau);
+ InitBranch(t, "mc_isMuon", &m_mc_isMuon);
+ }
+
+ InitBranch(t, "mc_isPhoton", &m_mc_isPhoton);
+ InitBranch(t, "mc_isElectron", &m_mc_isElectron);
+ InitBranch(t, "mc_hasZMother", &m_mc_hasZMother);
+ InitBranch(t, "mc_hasWMother", &m_mc_hasWMother);
+}
+
+
+void TrigEgammaPhysValBase::clear(){
+
+ ///EventInfo
+ m_runNumber = 0;
+ m_eventNumber = 0;
+ m_lumiBlock = 0;
+ m_avgmu = 0;
+
+ ///Egamma
+ m_el_hasCalo = false;
+ m_el_hasTrack = false;
+
+
+ m_el_calo_e = 0;
+ m_el_calo_et = 0;
+ m_el_calo_eta = 0;
+ m_el_calo_phi = 0;
+ m_el_calo_etaBE2 = 0;
+
+ m_el_e = 0;
+ m_el_et = 0;
+ m_el_eta = 0;
+ m_el_phi = 0;
+ m_el_ethad1 = 0;
+ m_el_ehad1 = 0;
+ m_el_f1 = 0;
+ m_el_f3 = 0;
+ m_el_f1core = 0;
+ m_el_f3core = 0;
+ m_el_weta1 = 0;
+ m_el_weta2 = 0;
+ m_el_wtots1 = 0;
+ m_el_fracs1 = 0;
+ m_el_e277 = 0;
+ m_el_Reta = 0;
+ m_el_Rphi = 0;
+ m_el_Eratio = 0;
+ m_el_Rhad = 0;
+ m_el_Rhad1 = 0;
+ m_el_deta2 = 0;
+ m_el_dphi2 = 0;
+ m_el_dphiresc = 0;
+ m_el_deltaPhiRescaled2 = 0;
+ m_el_deltaEta1 = 0;
+ m_el_deltaE = 0;
+ m_el_etCone ->clear();
+ m_el_ptCone ->clear();
+
+ m_el_trk_pt = 0;
+ m_el_trk_eta = 0;
+ m_el_trk_charge = 0;
+ m_el_trk_sigd0 = 0;
+ m_el_trk_d0 = 0;
+ m_el_trk_eProbabilityHT = 0;
+ m_el_trk_transformed_eProbabilityHT=0;
+ m_el_trk_d0significance = 0;
+ m_el_trk_deltaPOverP = 0;
+ m_el_trk_qOverP = 0;
+ m_el_trk_summaryValues ->clear();
+
+
+
+ m_el_medium = false;
+ m_el_tight = false;
+ m_el_lhVLoose = false;
+ m_el_lhLoose = false;
+ m_el_lhMedium = false;
+ m_el_lhTight = false;
+ m_el_rgLoose = false;
+ m_el_rgMedium = false;
+ m_el_rgTight = false;
+ m_el_multiLepton = false;
+
+ m_el_nGoodVtx = -1;
+ m_el_nPileupPrimaryVtx = -1;
+ m_el_ringsE ->clear();
+
+ // Trigger L1
+ m_trig_L1_eta = 0;
+ m_trig_L1_phi = 0;
+ m_trig_L1_emClus = 0;
+ m_trig_L1_tauClus = 0;
+ m_trig_L1_emIsol = 0;
+ m_trig_L1_hadIsol = 0;
+ m_trig_L1_hadCore = 0;
+
+ // Trigger L2 Calo
+ m_trig_L2_calo_et = 0;
+ m_trig_L2_calo_eta = 0;
+ m_trig_L2_calo_phi = 0;
+ m_trig_L2_calo_e237 = 0;
+ m_trig_L2_calo_e277 = 0;
+ m_trig_L2_calo_fracs1 = 0;
+ m_trig_L2_calo_weta2 = 0;
+ m_trig_L2_calo_ehad1 = 0;
+ m_trig_L2_calo_emaxs1 = 0;
+ m_trig_L2_calo_e2tsts1 = 0;
+ m_trig_L2_calo_wstot = 0;
+
+
+ m_trig_L2_calo_energySample ->clear();
+ m_trig_L2_calo_rings ->clear();
+ m_trig_L2_calo_rnnOutput ->clear();
+
+
+ // L2 Electron
+ m_trig_L2_el_pt ->clear();
+ m_trig_L2_el_eta ->clear();
+ m_trig_L2_el_phi ->clear();
+ m_trig_L2_el_charge ->clear();
+ m_trig_L2_el_caloEta ->clear();
+ m_trig_L2_el_trkClusDeta ->clear();
+ m_trig_L2_el_trkClusDphi ->clear();
+ m_trig_L2_el_etOverPt ->clear();
+ m_trig_L2_el_nTRTHits ->clear();
+ m_trig_L2_el_nTRTHiThresholdHits ->clear();
+ m_trig_L2_el_trackAlgID ->clear();
+
+ m_trig_EF_el_hasCalo ->clear();
+ m_trig_EF_el_hasTrack ->clear();
+
+ // EF Calo
+ m_trig_EF_calo_e ->clear();
+ m_trig_EF_calo_et ->clear();
+ m_trig_EF_calo_eta ->clear();
+ m_trig_EF_calo_phi ->clear();
+ m_trig_EF_calo_etaBE2 ->clear();
+
+ m_trig_EF_calo_tight ->clear();
+ m_trig_EF_calo_medium ->clear();
+ m_trig_EF_calo_loose ->clear();
+ m_trig_EF_calo_lhtight ->clear();
+ m_trig_EF_calo_lhmedium ->clear();
+ m_trig_EF_calo_lhloose ->clear();
+ m_trig_EF_calo_lhvloose ->clear();
+
+ // HLT electron
+ m_trig_EF_el_calo_e ->clear();
+ m_trig_EF_el_calo_et ->clear();
+ m_trig_EF_el_calo_eta ->clear();
+ m_trig_EF_el_calo_phi ->clear();
+ m_trig_EF_el_calo_etaBE2 ->clear();
+
+ m_trig_EF_el_e ->clear();
+ m_trig_EF_el_et ->clear();
+ m_trig_EF_el_eta ->clear();
+ m_trig_EF_el_phi ->clear();
+ m_trig_EF_el_deltaE ->clear();
+ m_trig_EF_el_ethad1 ->clear();
+ m_trig_EF_el_ehad1 ->clear();
+ m_trig_EF_el_f1 ->clear();
+ m_trig_EF_el_f3 ->clear();
+ m_trig_EF_el_f1core ->clear();
+ m_trig_EF_el_f3core ->clear();
+ m_trig_EF_el_weta1 ->clear();
+ m_trig_EF_el_weta2 ->clear();
+ m_trig_EF_el_wtots1 ->clear();
+ m_trig_EF_el_fracs1 ->clear();
+ m_trig_EF_el_Reta ->clear();
+ m_trig_EF_el_Rphi ->clear();
+ m_trig_EF_el_Eratio ->clear();
+ m_trig_EF_el_Rhad ->clear();
+ m_trig_EF_el_Rhad1 ->clear();
+ m_trig_EF_el_e277 ->clear();
+ m_trig_EF_el_deta2 ->clear();
+ m_trig_EF_el_dphi2 ->clear();
+ m_trig_EF_el_dphiresc ->clear();
+ m_trig_EF_el_deltaPhiRescaled2 ->clear();
+ m_trig_EF_el_deltaEta1 ->clear();
+ m_trig_EF_el_etCone ->clear();
+ m_trig_EF_el_ptCone ->clear();
+
+ m_trig_EF_el_trk_pt ->clear();
+ m_trig_EF_el_trk_eta ->clear();
+ m_trig_EF_el_trk_charge ->clear();
+ m_trig_EF_el_trk_qOverP ->clear();
+ m_trig_EF_el_trk_sigd0 ->clear();
+ m_trig_EF_el_trk_d0 ->clear();
+ m_trig_EF_el_trk_eProbabilityHT ->clear();
+ m_trig_EF_el_trk_transformed_eProbabilityHT->clear();
+ m_trig_EF_el_trk_d0significance ->clear();
+ m_trig_EF_el_trk_deltaPOverP ->clear();
+ m_trig_EF_el_trk_summaryValues ->clear();
+
+
+ m_trig_EF_el_tight ->clear();
+ m_trig_EF_el_medium ->clear();
+ m_trig_EF_el_loose ->clear();
+ m_trig_EF_el_lhtight ->clear();
+ m_trig_EF_el_lhmedium ->clear();
+ m_trig_EF_el_lhloose ->clear();
+ m_trig_EF_el_lhvloose ->clear();
+
+ m_trig_tdt_L1_calo_accept ->clear();
+ m_trig_tdt_L2_calo_accept ->clear();
+ m_trig_tdt_L2_el_accept ->clear();
+ m_trig_tdt_EF_calo_accept ->clear();
+ m_trig_tdt_EF_el_accept ->clear();
+ m_trig_tdt_emu_L1_calo_accept ->clear();
+ m_trig_tdt_emu_L2_calo_accept ->clear();
+ m_trig_tdt_emu_L2_el_accept ->clear();
+ m_trig_tdt_emu_EF_calo_accept ->clear();
+ m_trig_tdt_emu_EF_el_accept ->clear();
+
+ ///Monte Carlo
+ m_mc_hasMC = false;
+ m_mc_pt = -1;
+ m_mc_eta = -1;
+ m_mc_phi = -1;
+ m_mc_isTop = false;
+ m_mc_isParton = false;
+ m_mc_isMeson = false;
+ m_mc_isTau = false;
+ m_mc_isMuon = false;
+ m_mc_isPhoton = false;
+ m_mc_isElectron = false;
+ m_mc_hasZMother = false;
+ m_mc_hasWMother = false;
+
+
+}
+
+void TrigEgammaPhysValBase::alloc_space(){
+
+ m_el_ringsE = new std::vector<float>();
+ m_el_trk_summaryValues = new std::vector<uint8_t>();
+ m_el_etCone = new std::vector<float>();
+ m_el_ptCone = new std::vector<float>();
+
+
+ m_trig_L2_calo_energySample = new std::vector<float>();
+ m_trig_L2_calo_rings = new std::vector<float>();
+ m_trig_L2_calo_rnnOutput = new std::vector<float>();
+
+ m_trig_L2_el_trackAlgID = new std::vector<int>();
+ m_trig_L2_el_eta = new std::vector<float>();
+ m_trig_L2_el_phi = new std::vector<float>();
+ m_trig_L2_el_caloEta = new std::vector<float>();
+ m_trig_L2_el_trkClusDeta = new std::vector<float>();
+ m_trig_L2_el_trkClusDphi = new std::vector<float>();
+ m_trig_L2_el_pt = new std::vector<float>();
+ m_trig_L2_el_etOverPt = new std::vector<float>();
+ m_trig_L2_el_nTRTHits = new std::vector<float>();
+ m_trig_L2_el_nTRTHiThresholdHits = new std::vector<float>();
+ m_trig_L2_el_charge = new std::vector<float>();
+
+ m_trig_EF_calo_et = new std::vector<float>();
+ m_trig_EF_calo_eta = new std::vector<float>();
+ m_trig_EF_calo_phi = new std::vector<float>();
+ m_trig_EF_calo_etaBE2 = new std::vector<float>();
+ m_trig_EF_calo_e = new std::vector<float>();
+
+ m_trig_EF_el_calo_et = new std::vector<float>();
+ m_trig_EF_el_calo_eta = new std::vector<float>();
+ m_trig_EF_el_calo_phi = new std::vector<float>();
+ m_trig_EF_el_calo_etaBE2 = new std::vector<float>();
+ m_trig_EF_el_calo_e = new std::vector<float>();
+
+ m_trig_EF_el_hasCalo = new std::vector<bool>();
+ m_trig_EF_el_hasTrack = new std::vector<bool>();
+
+ m_trig_EF_el_et = new std::vector<float>();
+ m_trig_EF_el_eta = new std::vector<float>();
+ m_trig_EF_el_phi = new std::vector<float>();
+ m_trig_EF_el_e = new std::vector<float>();
+ m_trig_EF_el_deltaE = new std::vector<float>();
+ m_trig_EF_el_ethad1 = new std::vector<float>();
+ m_trig_EF_el_ehad1 = new std::vector<float>();
+ m_trig_EF_el_f1 = new std::vector<float>();
+ m_trig_EF_el_f3 = new std::vector<float>();
+ m_trig_EF_el_f1core = new std::vector<float>();
+ m_trig_EF_el_f3core = new std::vector<float>();
+ m_trig_EF_el_weta1 = new std::vector<float>();
+ m_trig_EF_el_weta2 = new std::vector<float>();
+ m_trig_EF_el_wtots1 = new std::vector<float>();
+ m_trig_EF_el_fracs1 = new std::vector<float>();
+ m_trig_EF_el_e277 = new std::vector<float>();
+ m_trig_EF_el_Reta = new std::vector<float>();
+ m_trig_EF_el_Rphi = new std::vector<float>();
+ m_trig_EF_el_Eratio = new std::vector<float>();
+ m_trig_EF_el_Rhad = new std::vector<float>();
+ m_trig_EF_el_Rhad1 = new std::vector<float>();
+ m_trig_EF_el_deta2 = new std::vector<float>();
+ m_trig_EF_el_dphi2 = new std::vector<float>();
+ m_trig_EF_el_dphiresc = new std::vector<float>();
+ m_trig_EF_el_deltaPhiRescaled2 = new std::vector<float>();
+ m_trig_EF_el_deltaEta1 = new std::vector<float>();
+ m_trig_EF_el_etCone = new std::vector<float>();
+ m_trig_EF_el_ptCone = new std::vector<float>();
+
+ m_trig_EF_el_trk_pt = new std::vector<float>();
+ m_trig_EF_el_trk_eta = new std::vector<float>();
+ m_trig_EF_el_trk_charge = new std::vector<float>();
+ m_trig_EF_el_trk_qOverP = new std::vector<float>();
+ m_trig_EF_el_trk_sigd0 = new std::vector<float>();
+ m_trig_EF_el_trk_d0 = new std::vector<float>();
+ m_trig_EF_el_trk_eProbabilityHT = new std::vector<float>();
+ m_trig_EF_el_trk_transformed_eProbabilityHT = new std::vector<float>();
+ m_trig_EF_el_trk_d0significance = new std::vector<float>();
+ m_trig_EF_el_trk_deltaPOverP = new std::vector<float>();
+ m_trig_EF_el_trk_summaryValues = new std::vector<uint8_t>();
+
+ m_trig_EF_calo_tight = new std::vector<bool>();
+ m_trig_EF_calo_medium = new std::vector<bool>();
+ m_trig_EF_calo_loose = new std::vector<bool>();
+ m_trig_EF_calo_lhtight = new std::vector<bool>();
+ m_trig_EF_calo_lhmedium = new std::vector<bool>();
+ m_trig_EF_calo_lhloose = new std::vector<bool>();
+ m_trig_EF_calo_lhvloose = new std::vector<bool>();
+
+ m_trig_EF_el_tight = new std::vector<bool>();
+ m_trig_EF_el_medium = new std::vector<bool>();
+ m_trig_EF_el_loose = new std::vector<bool>();
+ m_trig_EF_el_lhtight = new std::vector<bool>();
+ m_trig_EF_el_lhmedium = new std::vector<bool>();
+ m_trig_EF_el_lhloose = new std::vector<bool>();
+ m_trig_EF_el_lhvloose = new std::vector<bool>();
+
+ m_trig_tdt_L1_calo_accept = new std::vector<int>();
+ m_trig_tdt_L2_calo_accept = new std::vector<int>();
+ m_trig_tdt_L2_el_accept = new std::vector<int>();
+ m_trig_tdt_EF_calo_accept = new std::vector<int>();
+ m_trig_tdt_EF_el_accept = new std::vector<int>();
+
+ m_trig_tdt_emu_L1_calo_accept = new std::vector<int>();
+ m_trig_tdt_emu_L2_calo_accept = new std::vector<int>();
+ m_trig_tdt_emu_L2_el_accept = new std::vector<int>();
+ m_trig_tdt_emu_EF_calo_accept = new std::vector<int>();
+ m_trig_tdt_emu_EF_el_accept = new std::vector<int>();
+
+
+
+}
+
+void TrigEgammaPhysValBase::release_space(){
+
+ delete m_el_ringsE ;
+ delete m_el_trk_summaryValues ;
+ delete m_el_etCone ;
+ delete m_el_ptCone ;
+
+
+
+ delete m_trig_L2_calo_energySample;
+ delete m_trig_L2_calo_rings ;
+ delete m_trig_L2_calo_rnnOutput ;
+ delete m_trig_L2_el_trackAlgID ;
+ delete m_trig_L2_el_pt ;
+ delete m_trig_L2_el_eta ;
+ delete m_trig_L2_el_caloEta ;
+ delete m_trig_L2_el_phi ;
+ delete m_trig_L2_el_charge ;
+ delete m_trig_L2_el_nTRTHits ;
+ delete m_trig_L2_el_nTRTHiThresholdHits ;
+ delete m_trig_L2_el_etOverPt ;
+ delete m_trig_L2_el_trkClusDeta ;
+ delete m_trig_L2_el_trkClusDphi ;
+
+ delete m_trig_EF_calo_et ;
+ delete m_trig_EF_calo_eta ;
+ delete m_trig_EF_calo_phi ;
+ delete m_trig_EF_calo_etaBE2 ;
+ delete m_trig_EF_calo_e ;
+
+ delete m_trig_EF_el_calo_et ;
+ delete m_trig_EF_el_calo_eta ;
+ delete m_trig_EF_el_calo_phi ;
+ delete m_trig_EF_el_calo_etaBE2 ;
+ delete m_trig_EF_el_calo_e ;
+
+ delete m_trig_EF_el_et ;
+ delete m_trig_EF_el_eta ;
+ delete m_trig_EF_el_phi ;
+ delete m_trig_EF_el_e ;
+ delete m_trig_EF_el_deltaE ;
+ delete m_trig_EF_el_ethad1 ;
+ delete m_trig_EF_el_ehad1 ;
+ delete m_trig_EF_el_f1 ;
+ delete m_trig_EF_el_f3 ;
+ delete m_trig_EF_el_f1core ;
+ delete m_trig_EF_el_f3core ;
+ delete m_trig_EF_el_weta1 ;
+ delete m_trig_EF_el_weta2 ;
+ delete m_trig_EF_el_wtots1 ;
+ delete m_trig_EF_el_fracs1 ;
+ delete m_trig_EF_el_e277 ;
+ delete m_trig_EF_el_Reta ;
+ delete m_trig_EF_el_Rphi ;
+ delete m_trig_EF_el_Eratio ;
+ delete m_trig_EF_el_Rhad ;
+ delete m_trig_EF_el_Rhad1 ;
+ delete m_trig_EF_el_deta2 ;
+ delete m_trig_EF_el_dphi2 ;
+ delete m_trig_EF_el_dphiresc ;
+ delete m_trig_EF_el_deltaPhiRescaled2 ;
+ delete m_trig_EF_el_deltaEta1 ;
+ delete m_trig_EF_el_etCone ;
+ delete m_trig_EF_el_ptCone ;
+
+ delete m_trig_EF_el_trk_pt ;
+ delete m_trig_EF_el_trk_eta ;
+ delete m_trig_EF_el_trk_charge ;
+ delete m_trig_EF_el_trk_qOverP ;
+ delete m_trig_EF_el_trk_sigd0 ;
+ delete m_trig_EF_el_trk_d0 ;
+ delete m_trig_EF_el_trk_eProbabilityHT ;
+ delete m_trig_EF_el_trk_transformed_eProbabilityHT ;
+ delete m_trig_EF_el_trk_d0significance ;
+ delete m_trig_EF_el_trk_deltaPOverP ;
+ delete m_trig_EF_el_trk_summaryValues ;
+
+ delete m_trig_EF_calo_tight ;
+ delete m_trig_EF_calo_medium ;
+ delete m_trig_EF_calo_loose ;
+ delete m_trig_EF_calo_lhtight ;
+ delete m_trig_EF_calo_lhmedium ;
+ delete m_trig_EF_calo_lhloose ;
+ delete m_trig_EF_calo_lhvloose ;
+ delete m_trig_EF_el_tight ;
+ delete m_trig_EF_el_medium ;
+ delete m_trig_EF_el_loose ;
+ delete m_trig_EF_el_lhtight ;
+ delete m_trig_EF_el_lhmedium ;
+ delete m_trig_EF_el_lhloose ;
+ delete m_trig_EF_el_lhvloose ;
+
+ delete m_trig_tdt_L1_calo_accept ;
+ delete m_trig_tdt_L2_calo_accept ;
+ delete m_trig_tdt_L2_el_accept ;
+ delete m_trig_tdt_EF_calo_accept ;
+ delete m_trig_tdt_EF_el_accept ;
+ delete m_trig_tdt_emu_L1_calo_accept ;
+ delete m_trig_tdt_emu_L2_calo_accept ;
+ delete m_trig_tdt_emu_L2_el_accept ;
+ delete m_trig_tdt_emu_EF_calo_accept ;
+ delete m_trig_tdt_emu_EF_el_accept ;
+
+
+
+ delete m_trig_EF_el_hasCalo ;
+ delete m_trig_EF_el_hasTrack ;
+
+
+}
+
+
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaPlotTool.cxx b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaPlotTool.cxx
index 1b1436394b59689968d6a065e678557e4f98ceee..f384b20e234476eef0a3f3ba83ba72a45fe2d792 100644
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaPlotTool.cxx
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaPlotTool.cxx
@@ -161,23 +161,6 @@ void TrigEgammaPlotTool::setBinning(){
20,20.5,21,21.5,22,22.5,23,23.5,24,24.5,
25,25.5};
- /* Ringer bins pdfs for each layer */
- m_minBin_ringer.assign
- ({-500 ,-500 ,-1000,-1500,-1500,-1000,-1000,-1000,-500 ,-500 ,-500 ,-500 ,-500 ,-500 ,-500 ,-800,
- -800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800,
- -800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800,
- -800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800,
- -800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-800 ,-500 ,-500 ,-500 ,-500 ,-1000,-1000,-1000,-500,
- -500 ,-500 ,-500 ,-500 ,-500 ,-500 ,-500 ,-500 ,-600 ,-1000,-1500,-2000,-400 ,-1000,-1500,-1500,
- -1000,-2000,-2000,-2000});
- m_maxBin_ringer.assign
- ({9000 , 7000, 2000, 2000, 2000, 2000, 2000, 2000, 20000, 20000, 6000, 4000, 3000, 2000, 2000, 800,
- 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800,
- 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800,
- 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800,
- 800 , 800 , 800 , 800 , 800 , 800 , 800 , 800 , 40000, 40000, 6000, 4000, 2000, 2000, 2000, 2000,
- 500 , 500 , 500 , 500 , 500 , 500 ,500 , 500 , 3000 , 3000 , 3000 ,3000, 2000, 2000, 2000, 2000,
- 8000, 5000 ,4000 ,3000});
if(m_doJpsiee){
m_nEtbins=51;
@@ -608,24 +591,13 @@ TTree *TrigEgammaPlotTool::tree(const std::string &treeName, const std::string &
return treeItr->second;
}
-void TrigEgammaPlotTool::parseCaloRingsLayers( unsigned layer, unsigned &minRing,
- unsigned &maxRing, std::string &caloLayerName)
-{
- if(layer == 0){minRing = 0; maxRing = 7 ; caloLayerName = "PreSampler";}
- if(layer == 1){minRing = 8; maxRing = 71; caloLayerName = "EM1";}
- if(layer == 2){minRing = 72; maxRing = 79; caloLayerName = "EM2";}
- if(layer == 3){minRing = 80; maxRing = 87; caloLayerName = "EM3";}
- if(layer == 4){minRing = 88; maxRing = 91; caloLayerName = "HAD1";}
- if(layer == 5){minRing = 92; maxRing = 95; caloLayerName = "HAD2";}
- if(layer == 6){minRing = 96; maxRing = 99; caloLayerName = "HAD3";}
-}
-void TrigEgammaPlotTool::bookAbsResolutionHistos(const std::string directory){
+void TrigEgammaPlotTool::bookAbsResolutionHistos(const std::string &directory){
cd(directory);
addHistogram(new TH1F("res_pt", "HLT p_{T} resolution; (p_{T}(on)-p_{T}(off)) ; Count", 200, -1.5, 1.5));
addHistogram(new TH1F("res_et", "HLT E_{T} resolution; (E_{T}(on)-E_{T}(off)) ; Count", 200, -0.5, 0.5));
- addHistogram(new TH1F("res_eta", "#eta resolution; (#eta(on)-#eta(off)) ; Count", 40, -0.2, 0.2));
- addHistogram(new TH1F("res_phi", "#phi resolution; (#phi(on)-#phi(off)) ; Count", 40, -0.2, 0.2));
+ addHistogram(new TH1F("res_eta", "#eta resolution; (#eta(on)-#eta(off)) ; Count", 40, -0.001, 0.001));
+ addHistogram(new TH1F("res_phi", "#phi resolution; (#phi(on)-#phi(off)) ; Count", 40, -0.001, 0.001));
addHistogram(new TH2F("res_etVsEta", "HLT E_{T} resolution as function of #eta; #eta; (E_{T}(on)-E_{T}(off)); Count",
50, -2.47, 2.47,
@@ -696,11 +668,11 @@ void TrigEgammaPlotTool::bookAbsResolutionHistos(const std::string directory){
}
-void TrigEgammaPlotTool::bookResolutionHistos(const std::string directory){
+void TrigEgammaPlotTool::bookResolutionHistos(const std::string &directory){
cd(directory);
addHistogram(new TH1F("res_et", "E_{T} resolution; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 100, -0.1, 0.1));
- addHistogram(new TH1F("res_eta", "#eta resolution; (#eta(on)-#eta(off))/#eta(off) ; Count", 40, -0.2, 0.2));
- addHistogram(new TH1F("res_phi", "#phi resolution; (#phi(on)-#phi(off))/#phi(off) ; Count", 40, -0.2, 0.2));
+ addHistogram(new TH1F("res_eta", "#eta resolution; (#eta(on)-#eta(off))/#eta(off) ; Count", 40, -0.001, 0.001));
+ addHistogram(new TH1F("res_phi", "#phi resolution; (#phi(on)-#phi(off))/#phi(off) ; Count", 40, -0.001, 0.001));
addHistogram(new TH2F("res_etVsEta", "E_{T} resolution as function of #eta; #eta; (E_{T}(on)-E_{T}(off))/E_{T}(off); Count",
25, -2.5, 2.5,
50, -0.1, 0.1));
@@ -721,7 +693,7 @@ void TrigEgammaPlotTool::bookResolutionHistos(const std::string directory){
}
-void TrigEgammaPlotTool::bookElectronResolutionHistos(const std::string directory){
+void TrigEgammaPlotTool::bookElectronResolutionHistos(const std::string &directory){
cd(directory);
//Electron
addHistogram(new TH1F("res_pt", "p_{T} resolution; (p_{T}(on)-p_{T}(off))/p_{T}(off) ; Count", 120, -1.5, 1.5));
@@ -743,7 +715,7 @@ void TrigEgammaPlotTool::bookElectronResolutionHistos(const std::string director
50, 0., 1.));
}
-void TrigEgammaPlotTool::bookElectronIsoResolutionHistos(const std::string directory){
+void TrigEgammaPlotTool::bookElectronIsoResolutionHistos(const std::string &directory){
cd(directory);
addHistogram(new TH1F("res_ptcone20", "resolution ptcone20; ptcone20 (on-off)/off; Count", 200, -0.1, 0.1));
addHistogram(new TH1F("res_ptcone20_rel", "resolution ptcone20/pt; ptcone20/pt (on-off)/off; Count", 100, -0.1, 0.1));
@@ -789,7 +761,7 @@ void TrigEgammaPlotTool::bookElectronIsoResolutionHistos(const std::string direc
}
-void TrigEgammaPlotTool::bookPhotonResolutionHistos(const std::string directory){
+void TrigEgammaPlotTool::bookPhotonResolutionHistos(const std::string &directory){
cd(directory);
addHistogram(new TH1F("res_et_cnv", "HLT E_{T} resolution for converted Photons; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1));
addHistogram(new TH1F("res_et_uncnv", "HLT E_{T} resolution for unconverted Photons; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1));
@@ -818,7 +790,7 @@ void TrigEgammaPlotTool::bookPhotonResolutionHistos(const std::string directory)
addHistogram(new TH1F("res_uncnv_etInEta3", "HLT E_{T} resolution in #eta = [1.8,2.45]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1));
}
-void TrigEgammaPlotTool::bookPhotonIsoResolutionHistos(const std::string directory){
+void TrigEgammaPlotTool::bookPhotonIsoResolutionHistos(const std::string &directory){
cd(directory);
addHistogram(new TH1F("res_topoetcone20", "resolution topoetcone20; ptcone20 (on-off)/off; Count", 200, -0.1, 0.1));
addHistogram(new TH1F("res_topoetcone20_rel", "resolution topoetcone20/pt; ptcone20/pt (on-off)/off; Count", 100, -0.1, 0.1));
@@ -834,15 +806,21 @@ void TrigEgammaPlotTool::bookPhotonIsoResolutionHistos(const std::string directo
addHistogram(new TH2F("res_topoetcone20_relVsMu", "HLT topoetcone20/pt resolution as function of avg #mu; #mu; (on-off)/off; Count",
50, 0, 100,
100, -0.1, 0.1));
- addHistogram(new TH2F("res_topoetcone20_onVsOff", "online topoetcone20 vs offline topoetcone20; offline [MeV]; online [MeV]; Count",
- 100, 0.0, 10000.0,
- 100, 0.0, 10000.0));
+ addHistogram(new TH2F("res_topoetcone20_onVsOff", "online topoetcone20 vs offline topoetcone20; offline [GeV]; online [GeV]; Count",
+ 100, -10.0, 10.0,
+ 100, -10.0, 10.0));
addHistogram(new TH2F("res_topoetcone20_rel_onVsOff", "online topoetcone20/pt vs offline topoetcone20/pt; offline; online; Count",
- 100, 0.0, 0.2,
- 100, 0.0, 0.2));
+ 100, -0.5, 0.5,
+ 100, -0.5, 0.5));
+ addHistogram(new TH2F("res_topoetcone40_shift_onVsOff", "online topoetcone40-2.45 GeV vs offline topoetcone40-2.45 GeV; offline [GeV]; online [GeV]; Count",
+ 100, -10.0, 10.0,
+ 100, -10.0, 10.0));
+ addHistogram(new TH2F("res_topoetcone40_shift_rel_onVsOff", "online (topoetcone40-2.45 GeV)/pt vs offline (topoetcone40-2.45 GeV)/pt; offline; online; Count",
+ 100, -0.5, 0.5,
+ 100, -0.5, 0.5));
}
-void TrigEgammaPlotTool::bookExpertResolutionHistos(const std::string directory){
+void TrigEgammaPlotTool::bookExpertResolutionHistos(const std::string &directory){
cd(directory);
addHistogram(new TH1F("res_etInEta0", "HLT E_{T} resolution in #eta = [0,1.37]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1));
@@ -943,7 +921,7 @@ void TrigEgammaPlotTool::bookExpertResolutionHistos(const std::string directory)
}
}
-void TrigEgammaPlotTool::bookExpertL2CaloResolutionHistos(const std::string directory){
+void TrigEgammaPlotTool::bookExpertL2CaloResolutionHistos(const std::string &directory){
cd(directory);
addHistogram(new TH2F("res_f3VsEta", "L2Calo f3 resolution as function of #eta; #eta; (f3(on)-f3(off))/f3(off); Count",
50, -2.47, 2.47,
@@ -1007,14 +985,14 @@ void TrigEgammaPlotTool::bookExpertL2CaloResolutionHistos(const std::string dire
50, -0.001, 0.001));
}
-void TrigEgammaPlotTool::bookDistributionHistos(const std::string directory){
+void TrigEgammaPlotTool::bookDistributionHistos(const std::string &directory){
cd(directory);
addHistogram(new TH1F("et", "ET; ET [GeV] ; Count", 100, 0., 100.));
addHistogram(new TH1F("eta", "eta; eta ; Count", m_nEtabins,m_etabins.data()));
addHistogram(new TH1F("phi", "phi; phi ; Count", 20, -3.2, 3.2));
}
-void TrigEgammaPlotTool::bookEgammaDistributionHistos(const std::string directory){
+void TrigEgammaPlotTool::bookEgammaDistributionHistos(const std::string &directory){
cd(directory);
addHistogram(new TH1F("highet", "Offline E_{T}; E_{T} [GeV] ; Count", 100, 0., 2000.));
//addHistogram(new TH1F("e011", "e011; e011 ; Count", 165, -15., 150.));
@@ -1033,11 +1011,13 @@ void TrigEgammaPlotTool::bookEgammaDistributionHistos(const std::string director
addHistogram(new TH1F("Rhad", "Rhad; Rhad ; Count", 35, -0.3, 0.3));
addHistogram(new TH1F("Rhad1", "Rhad1; Rhad1 ; Count", 30, -0.3, 0.3));
addHistogram(new TH1F("eratio","eratio; eratio; Count",20, 0, 2));
- addHistogram(new TH1F("topoetcone20", "topoetcone20; topoetcone20; Count", 50, 0.0, 5.0));
- addHistogram(new TH1F("topoetcone20_rel", "topoetcone20/pt; topoetcone20/pt; Count", 50, 0.0, 1.0));
+ addHistogram(new TH1F("topoetcone20", "topoetcone20; topoetcone20 [GeV] ; Count", 100, -10.0, 10.0));
+ addHistogram(new TH1F("topoetcone20_rel", "topoetcone20/pt; topoetcone20/pt ; Count", 100, -0.5, 0.5));
+ addHistogram(new TH1F("topoetcone40_shift", "topoetcone40-2.45 GeV; topoetcone40-2.45 GeV [GeV] ; Count", 100, -10.0, 10.0));
+ addHistogram(new TH1F("topoetcone40_shift_rel", "(topoetcone40-2.45 GeV)/pt; (topoetcone40-2.45 GeV)/pt ; Count", 100, -0.5, 0.5));
}
-void TrigEgammaPlotTool::bookElectronDistributionHistos(const std::string directory){
+void TrigEgammaPlotTool::bookElectronDistributionHistos(const std::string &directory){
cd(directory);
addHistogram(new TH1F("pt", "p_{T}; p_{T} [GeV] ; Count", 100,0.,100.));
addHistogram(new TH1F("deta1", "deta1; deta1 ; Count", 40, -0.01, 0.01));
@@ -1067,7 +1047,7 @@ void TrigEgammaPlotTool::bookElectronDistributionHistos(const std::string direct
}
-void TrigEgammaPlotTool::bookEfficiency2DHistos(const std::string directory){
+void TrigEgammaPlotTool::bookEfficiency2DHistos(const std::string &directory){
cd(directory);
addHistogram(new TH2F("match_coarse_et_eta","Trigger Matched Offline #eta vs et; E_{T} GeV ;#eta; Count",
@@ -1088,7 +1068,7 @@ void TrigEgammaPlotTool::bookEfficiency2DHistos(const std::string directory){
}
-void TrigEgammaPlotTool::bookEfficiencyTProfile(const std::string directory){
+void TrigEgammaPlotTool::bookEfficiencyTProfile(const std::string &directory){
cd(directory);
addHistogram(new TProfile("eff_pt", "#epsilon(p_T); p_{T} ; Efficiency",m_nEtbins,m_etbins.data()));
addHistogram(new TProfile("eff_et", "#epsilon(E_T); E_{T} [GeV] ; Efficiency", m_nEtbins,m_etbins.data()));
@@ -1101,7 +1081,7 @@ void TrigEgammaPlotTool::bookEfficiencyTProfile(const std::string directory){
addHistogram(new TProfile("eff_npvtx", "#epsilon(npvtx); npvtx ; Efficiency", 16, 0, 80));
}
-void TrigEgammaPlotTool::bookEfficiencyHistos(const std::string directory){
+void TrigEgammaPlotTool::bookEfficiencyHistos(const std::string &directory){
cd(directory);
bookEfficiencyTProfile(directory);
// Numerator
@@ -1185,6 +1165,7 @@ void TrigEgammaPlotTool::bookL1Histos(TrigInfo trigInfo){
}
+
void TrigEgammaPlotTool::bookExpertHistos(TrigInfo trigInfo){
const std::string basePath=m_baseDir+"/Expert/"+trigInfo.trigName;
@@ -1338,29 +1319,6 @@ void TrigEgammaPlotTool::bookExpertHistos(TrigInfo trigInfo){
dirnames.push_back(dirname);
addDirectory(dirname);
- // Store ringer in trigInfo
- if(boost::contains(trigInfo.trigName,"ringer") || trigInfo.trigEtcut || trigInfo.trigPerf){
- addHistogram(new TH1F("ringer_nnOutput", "Discriminator distribution; nnOutput ; Count", 100, -1, 1));
- addHistogram(new TH2F("ringer_etVsEta", "ringer count as function of #eta and E_{t}; #eta; E_{t} [GeV]; Count",
- m_ndefaultEtabins,m_defaultEtabins.data(), m_ndefaultEtbins, m_defaultEtbins.data() ));
- if(m_detailedHists){
- unsigned rCount=0;
- for(unsigned layer =0; layer < 7; ++layer){
- unsigned minRing, maxRing; std::string strLayer;
- parseCaloRingsLayers( layer, minRing, maxRing, strLayer );
- addDirectory(dirname+"/rings_"+strLayer);
- for(unsigned r=minRing; r<=maxRing; ++r){
- std::stringstream ss_title, ss;
- ss_title << "ringer_ring#" << r; ss << "L2Calo ringer ("<< strLayer <<"); ring#" << r << " E [MeV]; Count";
- addHistogram(new TH1F(ss_title.str().c_str(), ss.str().c_str(), 100, m_minBin_ringer[rCount], m_maxBin_ringer[rCount]));
- rCount++;
- }
- }///Loop for each calo layers
- }
- }
-
-
-
//Book the kinematic plots for each trigger level
for(const auto dir:dirnames)
bookDistributionHistos(dir);
@@ -1376,7 +1334,7 @@ void TrigEgammaPlotTool::bookExpertHistos(TrigInfo trigInfo){
}
if(trigInfo.trigType=="photon"){
bookPhotonResolutionHistos(dirname);
- if(boost::contains(trigInfo.trigName,"iloose"))
+ if(boost::contains(trigInfo.trigName,"icaloloose") ||boost::contains(trigInfo.trigName,"icalovloose") || boost::contains(trigInfo.trigName,"icalotight"))
bookPhotonIsoResolutionHistos(dirname);
}
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaResolutionTool.cxx b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaResolutionTool.cxx
index c2d851d919f7ed4f46e9f8ac0f9b5c691291f37c..66e0a7441e5df957ab7f70c2aa54730dc16949ff 100644
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaResolutionTool.cxx
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/Root/TrigEgammaResolutionTool.cxx
@@ -47,6 +47,7 @@ StatusCode TrigEgammaResolutionTool::toolExecute(const std::string basePath,Trig
const std::string dir = basePath+"/"+info.trigName;
bool filliso=false;
if(boost::contains(info.trigName,"iloose") || boost::contains(info.trigName,"ivarloose")) filliso=true;
+ if(boost::contains(info.trigName,"icaloloose") || boost::contains(info.trigName,"icalovloose") || boost::contains(info.trigName,"icalotight")) filliso=true;
ATH_MSG_DEBUG("Executing resolution for " << dir);
for(const auto pairObj : pairObjs){
const xAOD::Egamma* eg =pairObj.first;
@@ -142,14 +143,17 @@ void TrigEgammaResolutionTool::resolutionElectron(const std::string basePath,std
void TrigEgammaResolutionTool::resolutionL2Photon(const std::string dir,std::pair< const xAOD::Egamma*,const HLT::TriggerElement*> pairObj){
cd(dir);
+ ATH_MSG_DEBUG("L2 Photon Resolution");
float dRmax = 100;
const xAOD::TrigPhoton *phL2 = nullptr;
- if(pairObj.second){
- if(ancestorPassed<xAOD::TrigPhotonContainer>(pairObj.second))
- phL2=closestObject<xAOD::TrigPhoton,xAOD::TrigPhotonContainer>(pairObj,dRmax);
- if(phL2){
- if(dRmax < 0.05){
- //Do something here
+ if(getSGContainsTrigPhoton()){
+ if(pairObj.second){
+ if(ancestorPassed<xAOD::TrigPhotonContainer>(pairObj.second))
+ phL2=closestObject<xAOD::TrigPhoton,xAOD::TrigPhotonContainer>(pairObj,dRmax);
+ if(phL2){
+ if(dRmax < 0.05){
+ //Do something here
+ }
}
}
}
@@ -498,8 +502,6 @@ void TrigEgammaResolutionTool::fillIsolationResolution(const std::string dir,con
float etoff=off->pt();
if (val_off > 0.) {
hist1("res_topoetcone20")->Fill((getIsolation_topoetcone20(onl)-val_off)/val_off);
- hist2("res_topoetcone20_onVsOff")->Fill(getIsolation_topoetcone20(off),
- getIsolation_topoetcone20(onl));
if (etonl > 0. && etoff > 0.) {
const float reliso_onl=getIsolation_topoetcone20(onl)/etonl;
const float reliso_off=getIsolation_topoetcone20(off)/etoff;
@@ -512,10 +514,18 @@ void TrigEgammaResolutionTool::fillIsolationResolution(const std::string dir,con
(reliso_onl-reliso_off)/reliso_off);
hist2("res_topoetcone20VsMu")->Fill(getAvgMu(),
(reliso_onl-reliso_off)/reliso_off);
- hist2("res_topoetcone20_rel_onVsOff")->Fill(getIsolation_topoetcone20(off)/etoff,
- getIsolation_topoetcone20(onl)/etonl);
}
}
+ hist2("res_topoetcone20_onVsOff")->Fill(getIsolation_topoetcone20(off)/1e3,
+ getIsolation_topoetcone20(onl)/1e3);
+ hist2("res_topoetcone40_shift_onVsOff")->Fill((getIsolation_topoetcone40(off)-2450)/1e3,
+ (getIsolation_topoetcone40(onl)-2450)/1e3);
+ if (etonl > 0. && etoff > 0.) {
+ hist2("res_topoetcone20_rel_onVsOff")->Fill(getIsolation_topoetcone20(off)/etoff,
+ getIsolation_topoetcone20(onl)/etonl);
+ hist2("res_topoetcone40_shift_rel_onVsOff")->Fill((getIsolation_topoetcone40(off)-2450)/etoff,
+ (getIsolation_topoetcone40(onl)-2450)/etonl);
+ }
}
}
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/ITrigEgammaAnalysisBaseTool.h b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/ITrigEgammaAnalysisBaseTool.h
index 366d3441c265dbbe286b6e097faa9703cf5d98a0..2b201ce53549c6654068388fb981a6ba798fb4f1 100644
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/ITrigEgammaAnalysisBaseTool.h
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/ITrigEgammaAnalysisBaseTool.h
@@ -42,6 +42,8 @@ public:
virtual void setEmulationTool(ToolHandle<Trig::ITrigEgammaEmulationTool>)=0;
virtual void setAvgMu(const float, const float)=0;
virtual void setPVertex(const float, const float)=0;
+ virtual void setSGContainsRnn(bool)=0;
+ virtual void setSGContainsTrigPhoton(bool)=0;
virtual StatusCode childInitialize(){return StatusCode::SUCCESS;};
virtual StatusCode childBook(){return StatusCode::SUCCESS;};
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaAnalysisBaseTool.h b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaAnalysisBaseTool.h
index 5a67bcefb1e402147f282fcb5b5e86b363879c60..2057c3376397b60fce660b5311c7b3b89a75d7e8 100644
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaAnalysisBaseTool.h
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaAnalysisBaseTool.h
@@ -27,20 +27,16 @@
#include "xAODEgamma/ElectronAuxContainer.h"
#include "xAODTrigRinger/TrigRingerRings.h"
#include "xAODTrigRinger/TrigRingerRingsContainer.h"
+#include "xAODTrigRinger/TrigRNNOutput.h"
+#include "xAODTrigRinger/TrigRNNOutputContainer.h"
#include "xAODTracking/TrackParticleContainer.h"
#include "xAODTrigger/TrigPassBits.h"
#include "xAODEgamma/PhotonAuxContainer.h"
-
-/*
- Ringer offline to be include for future
-/////////////////////////////////////////////////////////
-#include "xAODCaloRings/RingSet.h" //
-#include "xAODCaloRings/RingSetContainer.h" //
-#include "xAODCaloRings/CaloRings.h" //
-#include "xAODCaloRings/CaloRingsContainer.h" //
-#include "xAODCaloRings/tools/getCaloRingsDecorator.h" //
-/////////////////////////////////////////////////////////
-*/
+#include "xAODCaloRings/RingSet.h"
+#include "xAODCaloRings/RingSetContainer.h"
+#include "xAODCaloRings/CaloRings.h"
+#include "xAODCaloRings/CaloRingsContainer.h"
+#include "xAODCaloRings/tools/getCaloRingsDecorator.h"
class TrigEgammaAnalysisBaseTool
: public asg::AsgTool,
@@ -50,12 +46,12 @@ ASG_TOOL_CLASS(TrigEgammaAnalysisBaseTool, ITrigEgammaAnalysisBaseTool)
public:
TrigEgammaAnalysisBaseTool( const std::string& myname);
- virtual ~TrigEgammaAnalysisBaseTool() {};
+ ~TrigEgammaAnalysisBaseTool() {};
- virtual StatusCode initialize() override;
- virtual StatusCode book() override;
- virtual StatusCode execute() override;
- virtual StatusCode finalize() override;
+ StatusCode initialize() ;
+ StatusCode book() ;
+ StatusCode execute() ;
+ StatusCode finalize() ;
template<class T, class B> std::unique_ptr<xAOD::TrigPassBits> createBits(const T* CONT, const B* BITS);
template<class T> std::unique_ptr<xAOD::TrigPassBits> getBits(const HLT::TriggerElement* te,const T* CONT);
template<class T> const T* getFeature(const HLT::TriggerElement* te,const std::string key="");
@@ -63,15 +59,18 @@ public:
template <class T1, class T2> const T1* closestObject(const std::pair<const xAOD::Egamma *, const HLT::TriggerElement *>,
float &, bool usePassbits=true,const std::string key="");
// Interface class methods needed to pass information to additional tools or to set common tools
- virtual void setParent(IHLTMonTool *parent) override { m_parent = parent;};
- virtual void setPlotTool(ToolHandle<ITrigEgammaPlotTool> tool) override {m_plot=tool;}
- virtual void setDetail(bool detail) override {m_detailedHists=detail;}
- virtual void setTP(bool tp) override {m_tp=tp;}
- virtual void setEmulation(bool doEmu) override {m_doEmulation=doEmu;}
- virtual void setEmulationTool(ToolHandle<Trig::ITrigEgammaEmulationTool> tool) override {m_emulationTool=tool;}
- virtual void setPVertex(const float onvertex, const float ngoodvertex) override {m_nPVertex = onvertex; m_nGoodVertex = ngoodvertex;}
- virtual void setAvgMu(const float onlmu, const float offmu) override {m_onlmu=onlmu; m_offmu=offmu;} //For tools called by tools
-
+ void setParent(IHLTMonTool *parent) { m_parent = parent;};
+ void setPlotTool(ToolHandle<ITrigEgammaPlotTool> tool) {m_plot=tool;}
+ void setDetail(bool detail) {m_detailedHists=detail;}
+ void setTP(bool tp) {m_tp=tp;}
+ void setEmulation(bool doEmu) {m_doEmulation=doEmu;}
+ void setEmulationTool(ToolHandle<Trig::ITrigEgammaEmulationTool> tool) {m_emulationTool=tool;}
+ void setPVertex(const float onvertex, const float ngoodvertex) {m_nPVertex = onvertex; m_nGoodVertex = ngoodvertex;}
+ void setAvgMu(const float onlmu, const float offmu) {m_onlmu=onlmu; m_offmu=offmu;} //For tools called by tools
+
+ void setSGContainsRnn(bool contains) {m_sgContainsRnn=contains;}
+ void setSGContainsTrigPhoton(bool contains) {m_sgContainsTrigPhoton=contains;}
+
// Set current MonGroup
void cd(const std::string &dir);
// Accessor members
@@ -112,7 +111,10 @@ private:
float m_offmu;
float m_nGoodVertex;
float m_nPVertex;
-
+
+ /*! Hook to check for RNN features in SG */
+ bool m_sgContainsRnn;
+ bool m_sgContainsTrigPhoton;
// Properties
ToolHandle<Trig::TrigDecisionTool> m_trigdec;
ToolHandle<Trig::ITrigEgammaMatchingTool> m_matchTool;
@@ -137,6 +139,8 @@ protected:
void bookAnalysisHistos(const std::string);
void setTrigInfo(const std::string);
+ void setTrigEmulation(){m_forceTrigEmulation=true;};
+
TrigInfo getTrigInfo(const std::string);
std::map<std::string,TrigInfo> getTrigInfoMap() { return m_trigInfo; }
@@ -169,7 +173,11 @@ protected:
float getNPVtx(){return m_nPVertex;}
float getNGoodVertex(){return m_nGoodVertex;}
- /* trig rings and offline rings helper method for feature extraction from xaod */
+ /* Protection for Holders not in AOD */
+ bool getSGContainsRnn() { return m_sgContainsRnn;}
+ bool getSGContainsTrigPhoton() { return m_sgContainsTrigPhoton;}
+
+ /* trig rings and offline rings helper method for feature extraction from xaod */
bool getCaloRings( const xAOD::Electron *, std::vector<float> & );
bool getTrigCaloRings( const xAOD::TrigEMCluster *, std::vector<float> & );
void parseCaloRingsLayers( unsigned layer, unsigned &minRing, unsigned &maxRing, std::string &caloLayerName);
@@ -213,6 +221,11 @@ protected:
bool m_tp;
/*! Emulation Analysis */
bool m_doEmulation;
+ /*! force emulation trigger */
+ bool m_forceTrigEmulation;
+ /* force trigger attachment into the list */
+ bool m_forceTrigAttachment;
+
// Infra-structure members
std::string m_file;
/*! String for offline container key */
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaDistTool.h b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaDistTool.h
index 56a0eeb5119e60d389dc1f9262b6dc3b77b3a1f4..24d996c39876363fa9bca776b08977f2671d4735 100644
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaDistTool.h
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaDistTool.h
@@ -27,13 +27,12 @@ public:
protected:
private:
/*! fill kinematic histograms, et,eta,phi,lumi and efficiency */
- void fillShowerShapes(const std::string, const xAOD::Egamma *); // Online and Offline fillers
- void fillTracking(const std::string, const xAOD::Electron *); // Online and Offline fillers
- void fillEFCalo(const std::string,const xAOD::CaloCluster *);
- void fillL2Electron(const std::string,const xAOD::TrigElectron *);
- void fillL2Calo(const std::string,const xAOD::TrigEMCluster *);
- void fillRinger(const std::string,const xAOD::TrigEMCluster *);
- void fillL1Calo(const std::string,const xAOD::EmTauRoI *);
+ void fillShowerShapes(const std::string &, const xAOD::Egamma *); // Online and Offline fillers
+ void fillTracking(const std::string &, const xAOD::Electron *); // Online and Offline fillers
+ void fillEFCalo(const std::string &,const xAOD::CaloCluster *);
+ void fillL2Electron(const std::string &,const xAOD::TrigElectron *);
+ void fillL2Calo(const std::string &,const xAOD::TrigEMCluster *);
+ void fillL1Calo(const std::string &,const xAOD::EmTauRoI *);
/*! Include more detailed histograms */
bool m_detailedHists;
};
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaEventSelection.h b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaEventSelection.h
new file mode 100644
index 0000000000000000000000000000000000000000..eb112b0d1a4a571e8d52a7f94788e6d52eee4ea7
--- /dev/null
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaEventSelection.h
@@ -0,0 +1,118 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+#ifndef TRIGEGAMMAANALYSISTOOLS_TRIGEGAMMANAVTPNTUPLE_H
+#define TRIGEGAMMAANALYSISTOOLS_TRIGEGAMMANAVTPNTUPLE_H
+
+#include "TrigEgammaAnalysisTools/TrigEgammaNavTPBaseTool.h"
+#include "TrigEgammaAnalysisTools/TrigEgammaPhysValBase.h"
+#include "xAODTracking/TrackParticle.h"
+#include "xAODTracking/Vertex.h"
+#include "xAODEventInfo/EventInfo.h"
+#include "xAODEgamma/EgammaEnums.h"
+#include "xAODTracking/TrackingPrimitives.h"
+#include <map>
+
+class TrigEgammaEventSelection : public TrigEgammaNavTPBaseTool, public TrigEgammaPhysValBase,
+ virtual public ITrigEgammaAnalysisBaseTool
+{
+ ASG_TOOL_CLASS(TrigEgammaEventSelection, ITrigEgammaAnalysisBaseTool)
+
+ public:
+
+ TrigEgammaEventSelection( const std::string& myname );
+ ~TrigEgammaEventSelection() {};
+ StatusCode childInitialize();
+ StatusCode childBook();
+ StatusCode childExecute();
+ StatusCode childFinalize();
+
+ private:
+
+ /* Dump trigger and offline probe object */
+ bool EventSelectionZ();
+ bool EventSelectionFakes();
+
+ bool ApplyFireTriggers( const xAOD::Electron *el);
+ bool isTruthElectronAny(const xAOD::Egamma *eg );
+
+ bool fill(TTree *t, const xAOD::Electron *el );
+
+ /* parse between objects and local variables connected to the
+ * ttree pointer */
+ bool fillEvent ( );
+ bool fillMonteCarlo ( const xAOD::Egamma *eg );
+ bool fillElectron ( const xAOD::Electron *el );
+ bool fillCaloRings ( const xAOD::Electron *el );
+ bool fillEmTauRoI ( const xAOD::EmTauRoI *emTauRoI );
+ bool fillTrigEMCluster( const xAOD::TrigEMCluster *emCluster );
+ bool fillTrigElectron ( const xAOD::TrigElectron *trigEl );
+ bool fillCaloCluster ( const xAOD::CaloCluster *cluster );
+ bool fillAccept ( const HLT::TriggerElement * );
+ bool fillTrigCaloRings( const HLT::TriggerElement *feat );
+ bool fillHLTElectron ( const xAOD::Electron *el );
+ bool fillTDT ( const xAOD::Electron *el , const HLT::TriggerElement *te );
+
+ // Helper methods
+ double get_el_sigd0(const xAOD::Electron *el);
+ double get_el_d0(const xAOD::Electron *el);
+ double get_el_eProbabilityHT(const xAOD::Electron *el);
+ double get_el_transformed_eProbabilityHT(const xAOD::Electron *el);
+ double get_el_d0significance(const xAOD::Electron *el);
+ double get_el_deltaPhiRescaled2(const xAOD::Electron *el);
+ double get_el_deltaEta1(const xAOD::Electron *el);
+ double get_el_DeltaPOverP(const xAOD::Electron *el);
+
+
+ private:
+
+ std::map<std::string, unsigned >m_countMap;
+
+ void count( std::string key ){
+ if(m_countMap.find(key) == m_countMap.end()){
+ m_countMap[key]= 1;
+ }else{
+ m_countMap[key]++;
+ }
+ }
+
+
+
+
+ ToolHandleArray<IAsgElectronIsEMSelector> m_EFCaloElectronIsEMSelectors;
+ ToolHandleArray<IAsgElectronIsEMSelector> m_HLTElectronIsEMSelectors;
+ ToolHandleArray<IAsgElectronLikelihoodTool> m_EFCaloElectronLHSelectors;
+ ToolHandleArray<IAsgElectronLikelihoodTool> m_HLTElectronLHSelectors;
+ ToolHandle<IAsgElectronLikelihoodTool> m_electronLHVLooseTool;
+
+ std::vector<std::string> m_supportingTrigList;
+ int m_detailedDataLevel;
+ bool m_selectionZ;
+ bool m_selectionW;
+ bool m_selectionMC;
+ bool m_selectionJpsi;
+ bool m_selectionFakes;
+ bool m_doCaloRings;
+ bool m_dumpTags;
+
+#define GETTER(_name_) void get_##_name_(const xAOD::Electron*, float);
+ GETTER(trig_EF_calo_isLHTightCaloOnly_rel21_20170217 )
+ GETTER(trig_EF_calo_isLHMediumCaloOnly_rel21_20170217)
+ GETTER(trig_EF_calo_isLHLooseCaloOnly_rel21_20170217 )
+ GETTER(trig_EF_calo_isLHVLooseCaloOnly_rel21_20170217)
+ GETTER(trig_EF_el_isLHTight_rel21_20170217 )
+ GETTER(trig_EF_el_isLHMedium_rel21_20170217)
+ GETTER(trig_EF_el_isLHLoose_rel21_20170217 )
+ GETTER(trig_EF_el_isLHVLoose_rel21_20170217)
+ GETTER(trig_EF_el_isLHTightNoD0_rel21_20170217 )
+ GETTER(trig_EF_el_isLHMediumNoD0_rel21_20170217)
+ GETTER(trig_EF_el_isLHLooseNoD0_rel21_20170217 )
+ GETTER(trig_EF_el_isLHVLooseNoD0_rel21_20170217)
+#undef GETTER
+
+
+};
+
+
+
+#endif
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaInfo.h b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaInfo.h
index b977da3bd5acd45f4af971f1fb16d443b2acbd51..8f6e1f62c7a2f9d1b7f74ca9a7e3a2a35bd1c7df 100644
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaInfo.h
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaInfo.h
@@ -16,6 +16,7 @@ typedef struct _triginfo
bool trigEtcut; // Et cut only chain
float trigThrHLT; // HLT Et threshold
float trigThrL1; // L1 Et threshold
+ bool trigIsEmulation;
} TrigInfo;
// Enums
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaNavBaseTool.h b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaNavBaseTool.h
index 850ed18d98bd213822bbd8bbcc3d891768e8324b..9952cbcdc6ed932c6097a8d0f830542af00eb667 100755
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaNavBaseTool.h
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaNavBaseTool.h
@@ -26,6 +26,8 @@
#include "xAODTracking/TrackParticleContainer.h"
#include "xAODTracking/TrackParticleAuxContainer.h"
#include "xAODTrigCalo/TrigEMCluster.h"
+#include "xAODTrigRinger/TrigRNNOutput.h"
+#include "xAODTrigRinger/TrigRNNOutputContainer.h"
#include "xAODCaloEvent/CaloClusterContainer.h"
#include "xAODCaloEvent/CaloClusterAuxContainer.h"
#include "xAODJet/JetContainer.h"
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaNavNtuple.h b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaNavNtuple.h
deleted file mode 100755
index 4383d5db040eb9a4038318c750247bd5df56f42c..0000000000000000000000000000000000000000
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaNavNtuple.h
+++ /dev/null
@@ -1,221 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-
-#ifndef TRIGEGAMMAANALYSISTOOLS_TRIGEGAMMANAVNTUPLE_H
-#define TRIGEGAMMAANALYSISTOOLS_TRIGEGAMMANAVNTUPLE_H
-
-#include "TrigEgammaAnalysisTools/TrigEgammaNavBaseTool.h"
-#include "xAODTruth/TruthParticle.h"
-#include "xAODTruth/TruthParticleContainer.h"
-#include "xAODEventInfo/EventInfo.h"
-#include "xAODEgamma/EgammaEnums.h"
-#include "xAODTracking/TrackingPrimitives.h"
-
-class TrigEgammaNavNtuple : public TrigEgammaNavBaseTool,
- virtual public ITrigEgammaAnalysisBaseTool
-{
- ASG_TOOL_CLASS(TrigEgammaNavNtuple, ITrigEgammaAnalysisBaseTool)
-
- public:
-
- TrigEgammaNavNtuple( const std::string& myname );
- ~TrigEgammaNavNtuple() {};
- StatusCode childInitialize ();
- StatusCode childBook();
- StatusCode childExecute();
- StatusCode childFinalize();
-
- private:
-
- /* Dump offline photons */
- bool executePhotonDump();
- /* Dump offline electrons */
- bool executeElectronDump();
- /* Dump Trigger, electron and photons matched with the trigger object */
- bool executeTrigItemDump();
- /* Dump using trigger supports */
- bool executeTrigSupportDump();
-
-
- /* helper function */
- template <class T> void InitBranch(TTree* fChain, std::string branch_name, T* param, bool message = true);
-
- unsigned count_HLT_objects(const HLT::TriggerElement *);
-
- /* Create branches */
- void bookEventBranches( TTree *t );
- void bookElectronBranches( TTree *t );
- //void bookPhotonBranches( TTree *t );
- void bookTriggerBranches( TTree *t );
- void bookMonteCarloBranches( TTree *t );
-
- /* uses InitBranch to connect the local variable and ttree pointer */
- void linkEventBranches( TTree *t);
- void linkElectronBranches( TTree *t);
- //void linkPhotonBranches( TTree *t);
- void linkTriggerBranches( TTree *t);
- void linkMonteCarloBranches( TTree *t);
-
- /* parse between objects and local variables connected to the
- * ttree pointer */
- bool fillEvent ( );
- bool fillMonteCarlo ( const xAOD::Egamma *eg );
- bool fillElectron ( const xAOD::Electron *el );
- //bool fillPhoton ( const xAOD::Photon *ph );
-
- bool fillCaloRings ( const xAOD::Electron *el );
- bool fillTrigCaloRings( const xAOD::TrigEMCluster *emCluster );
- bool fillEmTauRoI ( const xAOD::EmTauRoI *emTauRoI );
- bool fillTrigEMCluster( const xAOD::TrigEMCluster *emCluster );
- bool fillTrigElectron ( const xAOD::TrigElectron *trigEl );
- bool fillCaloCluster ( const xAOD::CaloCluster *cluster );
-
- /* Space memory manager */
- void alloc_space();
- void release_space();
- void clear();
-
-
-
- private:
-
- /* Offline variables only */
- bool m_doOfflineDump;
- bool m_doSupport;
- bool m_forceMCMatch;
- float m_minEt; // default is -1
-
- /* Branch variables */
- uint32_t m_runNumber{};
- unsigned long long m_eventNumber{};
- unsigned int m_eventCounter{};
- float m_avgmu{};
-
- /* Egamma */
- float m_el_et{};
- float m_el_pt{};
- float m_el_eta{};
- float m_el_phi{};
- float m_el_ethad1{};
- float m_el_ehad1{};
- float m_el_f1{};
- float m_el_f3{};
- float m_el_d0{};
- float m_el_f1core{};
- float m_el_f3core{};
- float m_el_weta2{};
- float m_el_wtots1{};
- float m_el_fracs1{};
- float m_el_Reta{};
- float m_el_Rphi{};
- float m_el_Eratio{};
- float m_el_Rhad{};
- float m_el_Rhad1{};
- float m_el_deta1{};
- float m_el_deta2{};
- float m_el_dphi2{};
- float m_el_dphiresc{};
- float m_el_dphiresc2{};
- float m_el_eprobht{};
- float m_el_charge{};
- uint8_t m_el_nblayerhits{};
- uint8_t m_el_nblayerolhits{};
- uint8_t m_el_npixhits{};
- uint8_t m_el_npixolhits{};
- uint8_t m_el_nscthits{};
- uint8_t m_el_nsctolhits{};
- uint8_t m_el_ntrthightreshits{};
- uint8_t m_el_ntrthits{};
- uint8_t m_el_ntrthighthresolhits{};
- uint8_t m_el_ntrtolhits{};
- uint8_t m_el_ntrtxenonhits{};
- bool m_el_expectblayerhit{};
- uint8_t m_el_nsihits{} ;
- uint8_t m_el_nsideadsensors{} ;
- uint8_t m_el_npixdeadsensors{} ;
- uint8_t m_el_nsctdeadsensors{} ;
- bool m_el_loose{};
- bool m_el_medium{};
- bool m_el_tight{};
- bool m_el_lhLoose{};
- bool m_el_lhMedium{};
- bool m_el_lhTight{};
- bool m_el_rgLoose{};
- bool m_el_rgMedium{};
- bool m_el_rgTight{};
- bool m_el_multiLepton{};
- std::vector<float> *m_el_ringsE;
- int m_el_nGoodVtx{};
- int m_el_nPileupPrimaryVtx{};
- ///Egamma Calo
- float m_calo_et{};
- float m_calo_eta{};
- float m_calo_phi{};
-
- // Level 1
- float m_trig_L1_eta{};
- float m_trig_L1_phi{};
- float m_trig_L1_emClus{};
- float m_trig_L1_tauClus{};
- float m_trig_L1_emIsol{};
- float m_trig_L1_hadIsol{};
- std::vector<std::string> *m_trig_L1_thrNames;
- bool m_trig_L1_accept{};
- // Level 2 Calo
- float m_trig_L2_calo_et{};
- float m_trig_L2_calo_eta{};
- float m_trig_L2_calo_phi{};
- float m_trig_L2_calo_e237{};
- float m_trig_L2_calo_e277{};
- float m_trig_L2_calo_fracs1{};
- float m_trig_L2_calo_weta2{};
- float m_trig_L2_calo_ehad1{};
- float m_trig_L2_calo_emaxs1{};
- float m_trig_L2_calo_e2tsts1{};
- float m_trig_L2_calo_wstot{};
- float m_trig_L2_calo_rnnOutput{};
- std::vector<float> *m_trig_L2_calo_energySample;
- std::vector<float> *m_trig_L2_calo_rings;
- bool m_trig_L2_calo_accept{};
- // level 2 id
- std::vector<int> *m_trig_L2_el_trackAlgID;
- std::vector<float> *m_trig_L2_el_pt;
- std::vector<float> *m_trig_L2_el_caloEta;
- std::vector<float> *m_trig_L2_el_eta;
- std::vector<float> *m_trig_L2_el_phi;
- std::vector<float> *m_trig_L2_el_charge;
- std::vector<float> *m_trig_L2_el_nTRTHits;
- std::vector<float> *m_trig_L2_el_nTRTHiThresholdHits;
- std::vector<float> *m_trig_L2_el_etOverPt;
- std::vector<float> *m_trig_L2_el_trkClusDeta;
- std::vector<float> *m_trig_L2_el_trkClusDphi;
- bool m_trig_L2_el_accept{};
- // Level EF
- bool m_trig_EF_calo_accept{};
- std::vector<float> *m_trig_EF_calo_et;
- std::vector<float> *m_trig_EF_calo_eta;
- bool m_trig_EF_el_accept{};
-
-
- // Monte Carlo
- bool m_mc_hasMC{} ;
- float m_mc_pt{} ;
- float m_mc_eta{} ;
- float m_mc_phi{} ;
- bool m_mc_isTop{} ;
- bool m_mc_isParton{} ;
- bool m_mc_isMeson{} ;
- bool m_mc_isQuark{} ;
- bool m_mc_isTau{} ;
- bool m_mc_isMuon{} ;
- bool m_mc_isPhoton{} ;
- bool m_mc_isElectron{};
- bool m_mc_hasZMother{};
- bool m_mc_hasWMother{};
-
-};
-
-
-#endif
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaNavTPBaseTool.h b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaNavTPBaseTool.h
index 317521db5d47f6ac02bc32ebd26abb8ec1f37e78..aa6a54f060ec62062a82269b26b8afee1a1e8b00 100644
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaNavTPBaseTool.h
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaNavTPBaseTool.h
@@ -1,7 +1,6 @@
/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
*/
-
#ifndef TrigEgammaNavTPBaseTool_H
#define TrigEgammaNavTPBaseTool_H
@@ -25,9 +24,12 @@
#include "xAODTracking/TrackParticleContainer.h"
#include "xAODTracking/TrackParticleAuxContainer.h"
#include "xAODTrigCalo/TrigEMCluster.h"
+#include "xAODTrigRinger/TrigRNNOutput.h"
+#include "xAODTrigRinger/TrigRNNOutputContainer.h"
#include "xAODCaloEvent/CaloClusterContainer.h"
#include "xAODCaloEvent/CaloClusterAuxContainer.h"
#include "xAODJet/JetContainer.h"
+#include "xAODMissingET/MissingETContainer.h"
#include "xAODTrigger/EmTauRoIContainer.h"
#include "EgammaAnalysisInterfaces/IAsgElectronIsEMSelector.h"
#include "EgammaAnalysisInterfaces/IAsgPhotonIsEMSelector.h"
@@ -37,125 +39,139 @@ namespace Trig{
class FeatureContainer;
}
-class TrigEgammaNavTPBaseTool
-: public TrigEgammaAnalysisBaseTool,
+class TrigEgammaNavTPBaseTool: public TrigEgammaAnalysisBaseTool,
virtual public ITrigEgammaAnalysisBaseTool {
ASG_TOOL_CLASS(TrigEgammaNavTPBaseTool, ITrigEgammaAnalysisBaseTool)
-public:
-
- TrigEgammaNavTPBaseTool( const std::string& myname );
- ~TrigEgammaNavTPBaseTool() {};
-
- StatusCode childInitialize();
- StatusCode childBook();
- StatusCode childExecute();
- StatusCode childFinalize();
-protected:
- /*! things like LAr-error, Tile-error, etc, should come here */
- bool EventWiseSelection();
- /*! at least one chain should pass. e28_tight_iloose? */
- bool MinimalTriggerRequirement ();
- /*! Tag and Probe method called by derived classes */
- void executeTandP();
- /*! Match probes called by derived classes */
- void matchObjects(const std::string trigItem);
- /*! Tag Electron selection */
- bool isTagElectron(const xAOD::Electron *el);
- /*! Rerun offline selection */
- bool ApplyElectronPid(const xAOD::Electron *eg,const std::string);
- /*! Rerun offline selection */
- void DressPid(const xAOD::Electron *eg);
- /*! Probe selection */
- bool isGoodProbeElectron(const xAOD::Electron *el);//,const std::string,const float,const std::string);
- /*! Event-wise trigger selection */
- bool passedTrigger(const HLT::TriggerElement* obj);
- /*! Clears list of probes after each trigger item per event */
- void clearProbeList();
- /*! Clears list of matched probes after each trigger item per event */
- void clearPairList();
- /* Clears decorations offline objects */
- void clearDecorations();
- /*! Return pseudo-lifetime of Jpsi */
- float GetPseudoLifetime(const xAOD::Electron*,const xAOD::Electron*);
- /*! Calculate the displacement of the Jpsi vertex w.r.t. the primary vertex in the transverse plane */
- double simple_lxy(int ,double, double, double , double , double , double , double, double );
- /*! vector of electron probes */
- std::vector<const xAOD::Electron*> m_probeElectrons;
- /*! vector of photon probes */
- std::vector<const xAOD::Photon*> m_probePhotons;
- /*! vector of offline electron probe and matched TE */
- std::vector<std::pair<const xAOD::Egamma*,const HLT::TriggerElement*> > m_pairObj;
- /* vector of offline photon probe and matched TE */
- //std::vector<std::pair<const xAOD::Photon*,const HLT::TriggerElement*> > m_probePhotons;
- /*! List of triggers from menu */
- std::vector<std::string> m_trigInputList;
- /*! List of trigger categories for MaM */
- std::vector<std::string> m_categories;
- /*! List of triggers to study */
- std::vector<std::string> m_trigList;
- /*! Zee lower mass cut */
- float m_ZeeMassMin;
- /*! Zee upper mass cut */
- float m_ZeeMassMax;
- /*! Remove crack region for Probe default True */
- bool m_rmCrack;
- /*! Directory name for each algorithm */
- std::string m_dir;
- /*! Directory name for each algorithm */
- std::string m_anatype;
+ public:
- const xAOD::EventInfo* m_eventInfo;
- const xAOD::TruthParticleContainer* m_truthContainer;
-
-
-private:
- // ToolHandles
- //
- //Offline ++ selectors
- // In python order will matter. Should always be tight, medium, loose
- // Order no longer important since using a map
- ///*! Offline isEM Selectors */
- ToolHandleArray<IAsgElectronIsEMSelector> m_electronIsEMTool;
- /*! Offline LH Selectors */
- ToolHandleArray<IAsgElectronLikelihoodTool> m_electronLHTool;
+ TrigEgammaNavTPBaseTool( const std::string& myname );
+ ~TrigEgammaNavTPBaseTool() {};
+
+ StatusCode childInitialize();
+ StatusCode childBook();
+ StatusCode childExecute();
+ StatusCode childFinalize();
+
+ protected:
+
+ /*! things like LAr-error, Tile-error, etc, should come here */
+ bool EventWiseSelection();
+ /*! pass without detector errors */
+ bool passesEventCleaning();
+ /*! at least one chain should pass. e28_tight_iloose? */
+ bool MinimalTriggerRequirement ();
+ /*! Tag and Probe method called by derived classes */
+ void executeTandP();
+ /*! Match probes called by derived classes */
+ void matchObjects(const std::string trigItem);
+ /*! Tag Electron selection */
+ bool isTagElectron(const xAOD::Electron *el);
+ /*! Rerun offline selection */
+ bool ApplyElectronPid(const xAOD::Electron *eg,const std::string);
+ /*! Rerun offline selection */
+ void DressPid(const xAOD::Electron *eg);
+ /*! Probe selection */
+ bool isGoodProbeElectron(const xAOD::Electron *el);//,const std::string,const float,const std::string);
+ /*! Event-wise trigger selection */
+ bool passedTrigger(const HLT::TriggerElement* obj);
+ /*! Clears list of probes after each trigger item per event */
+ void clearProbeList();
+ /*! Clears list of matched probes after each trigger item per event */
+ void clearPairList();
+ /* Clears decorations offline objects */
+ void clearDecorations();
+ /*! Return pseudo-lifetime of Jpsi */
+ float GetPseudoLifetime(const xAOD::Electron*,const xAOD::Electron*);
+ /*! Calculate the displacement of the Jpsi vertex w.r.t. the primary vertex in the transverse plane */
+ double simple_lxy(int ,double, double, double , double , double , double , double, double );
+ /*! get the W mass */
+ float getWTransverseMass( const xAOD::Electron *el );
+ /*! Return MissingEt obj */
+ const xAOD::MissingET* getMET(){
+ return (*m_METContainer)["FinalClus"];
+ }
- std::map< std::string, unsigned int > m_PidToolMap; /*! Pass a string to pick up correct selector */
- //std::map< std::string, std::string > m_PidMap; /*! Map trigger pid to selector pid */
- //
- /*! Event Wise offline ElectronContainer Access and end iterator */
- const xAOD::ElectronContainer* m_offElectrons;
- /*! Jet container for probe selection */
- const xAOD::JetContainer* m_jets;
- /* TP selection properties */
+ /*! The pair index for each electron */
+ std::vector<std::pair<unsigned,unsigned>> m_Z;
+ /*! vector of electron probes */
+ std::vector<const xAOD::Electron*> m_probeElectrons;
+ /*! vector of photon probes */
+ std::vector<const xAOD::Photon*> m_probePhotons;
+ /*! vector of offline electron probe and matched TE */
+ std::vector<std::pair<const xAOD::Egamma*,const HLT::TriggerElement*> > m_pairObj;
+ /* vector of offline photon probe and matched TE */
+ //std::vector<std::pair<const xAOD::Photon*,const HLT::TriggerElement*> > m_probePhotons;
+ /*! List of triggers from menu */
+ std::vector<std::string> m_trigInputList;
+ /*! List of trigger categories for MaM */
+ std::vector<std::string> m_categories;
+ /*! List of triggers to study */
+ std::vector<std::string> m_trigList;
+ /*! Zee lower mass cut */
+ float m_ZeeMassMin;
+ /*! Zee upper mass cut */
+ float m_ZeeMassMax;
+ /*! Remove crack region for Probe default True */
+ bool m_rmCrack;
+ /*! Enable the requirement of triggers */
+ bool m_applyMinimalTrigger;
+ /*! Directory name for each algorithm */
+ std::string m_dir;
+ /*! Directory name for each algorithm */
+ std::string m_anatype;
+ /*! Select opposite or same-sign pairs -- for background studies */
+ bool m_oppositeCharge;
+ /*! Minimum tag Et */
+ float m_tagMinEt;
+ /*! Minimum probe Et */
+ float m_probeMinEt;
+
+ // Containers
+ /*! Event Wise offline ElectronContainer Access and end iterator */
+ const xAOD::ElectronContainer* m_offElectrons;
+ /*! Jet container for probe selection */
+ const xAOD::JetContainer* m_jets;
+ /*! Missing Et container */
+ const xAOD::MissingETContainer* m_METContainer;
+ /*! EventInfo Container */
+ const xAOD::EventInfo* m_eventInfo;
+ /* Truth Container */
+ const xAOD::TruthParticleContainer* m_truthContainer;
- /*! Not needed */
- // unsigned int m_isEMoffTag;
- /*! Define the PID for tag electron */
- std::string m_offTagTightness;
- /*! define the Pid of Probe from the trigger name */
- std::string m_offProbeTightness;
- /*! define the Pid of Probe from the user */
- std::string m_defaultProbeTightness;
- /*! force user defined probe for pid triggers */
- bool m_forceProbePid;
- /*! Select opposite or same-sign pairs -- for background studies */
- bool m_oppositeCharge;
- /*! Minimum tag Et */
- float m_tagMinEt;
- /*! Minimum probe Et */
- float m_probeMinEt;
- /*! Trigger for tag and event wise selection */
- std::vector<std::string> m_tagTrigList;
- /*! Apply nearby jet selection */
- bool m_applyJetNearProbeSelection;
- /*! force probe isolation */
- bool m_forceProbeIsolation;
- /*! Define isolation working point for Probe electron */
- std::string m_offProbeIsolation;
- /*! skip trigger for offline Tag and Probe analysis */
- bool m_skipTrigger;
+ private:
+ // In python order will matter. Should always be tight, medium, loose
+ // Order no longer important since using a map
+ ///*! Offline isEM Selectors */
+ ToolHandleArray<IAsgElectronIsEMSelector> m_electronIsEMTool;
+ /*! Offline LH Selectors */
+ ToolHandleArray<IAsgElectronLikelihoodTool> m_electronLHTool;
+
+ std::map< std::string, unsigned int > m_PidToolMap; /*! Pass a string to pick up correct selector */
+ //std::map< std::string, std::string > m_PidMap; /*! Map trigger pid to selector pid */
+
+ /* TP selection properties */
+ /*! Not needed */
+ // unsigned int m_isEMoffTag;
+ /*! Define the PID for tag electron */
+ std::string m_offTagTightness;
+ /*! define the Pid of Probe from the trigger name */
+ std::string m_offProbeTightness;
+ /*! define the Pid of Probe from the user */
+ std::string m_defaultProbeTightness;
+ /*! force user defined probe for pid triggers */
+ bool m_forceProbePid;
+ /*! Trigger for tag and event wise selection */
+ std::vector<std::string> m_tagTrigList;
+ /*! Apply nearby jet selection */
+ bool m_applyJetNearProbeSelection;
+ /*! force probe isolation */
+ bool m_forceProbeIsolation;
+ /*! Define isolation working point for Probe electron */
+ std::string m_offProbeIsolation;
+ /*! skip trigger for offline Tag and Probe analysis */
+ bool m_skipTrigger;
};
#endif
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaNavTPNtuple.h b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaNavTPNtuple.h
deleted file mode 100755
index cfe8b5a74cec06131cf3851270c4ea7b6bb1464f..0000000000000000000000000000000000000000
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaNavTPNtuple.h
+++ /dev/null
@@ -1,220 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef TRIGEGAMMAANALYSISTOOLS_TRIGEGAMMANAVTPNTUPLE_H
-#define TRIGEGAMMAANALYSISTOOLS_TRIGEGAMMANAVTPNTUPLE_H
-
-#include "TrigEgammaAnalysisTools/TrigEgammaNavTPBaseTool.h"
-#include "xAODTracking/TrackParticle.h"
-#include "xAODTracking/Vertex.h"
-#include "xAODEventInfo/EventInfo.h"
-#include "xAODEgamma/EgammaEnums.h"
-#include "xAODTracking/TrackingPrimitives.h"
-
-class TrigEgammaNavTPNtuple : public TrigEgammaNavTPBaseTool,
- virtual public ITrigEgammaAnalysisBaseTool
-{
- ASG_TOOL_CLASS(TrigEgammaNavTPNtuple, ITrigEgammaAnalysisBaseTool)
-
- public:
-
- TrigEgammaNavTPNtuple( const std::string& myname );
- ~TrigEgammaNavTPNtuple() {};
- StatusCode childInitialize();
- StatusCode childBook();
- StatusCode childExecute();
- StatusCode childFinalize();
-
- private:
-
- /* Dump trigger and offline probe object */
- bool executeProbesDump();
- bool executeProbesSupportDump();
- bool executeProbesItemDump();
-
-
- /* helper function */
- template <class T> void InitBranch(TTree* fChain, std::string branch_name, T* param, bool message = true);
-
- unsigned count_HLT_objects(const HLT::TriggerElement *);
-
- /* Create branches */
- void bookEventBranches( TTree *t );
- void bookElectronBranches( TTree *t );
- //void bookPhotonBranches( TTree *t );
- void bookTriggerBranches( TTree *t );
- void bookMonteCarloBranches( TTree *t );
-
- /* uses InitBranch to connect the local variable and ttree pointer */
- void linkEventBranches( TTree *t);
- void linkElectronBranches( TTree *t);
- void linkPhotonBranches( TTree *t);
- void linkTriggerBranches( TTree *t);
- void linkMonteCarloBranches( TTree *t);
-
- /* parse between objects and local variables connected to the
- * ttree pointer */
- bool fillEvent ( );
- bool fillMonteCarlo ( const xAOD::Egamma *eg );
- bool fillElectron ( const xAOD::Electron *el );
- //bool fillPhoton ( const xAOD::Photon *ph );
-
- bool fillCaloRings ( const xAOD::Electron *el );
- bool fillTrigCaloRings( const xAOD::TrigEMCluster *emCluster );
- bool fillEmTauRoI ( const xAOD::EmTauRoI *emTauRoI );
- bool fillTrigEMCluster( const xAOD::TrigEMCluster *emCluster );
- bool fillTrigElectron ( const xAOD::TrigElectron *trigEl );
- bool fillCaloCluster ( const xAOD::CaloCluster *cluster );
-
-
- /* Space memory manager */
- void alloc_space();
- void release_space();
- void clear();
-
-
- private:
-
-
- /* Offline variables only */
- bool m_doOfflineDump;
- /* Support triggers dump */
- bool m_doSupport;
- float m_probeMinEt;
-
- /* Branch variables */
- uint32_t m_runNumber{};
- unsigned long long m_eventNumber{};
- unsigned int m_eventCounter{};
- float m_avgmu{};
- /* Egamma */
- float m_el_et{};
- float m_el_pt{};
- float m_el_eta{};
- float m_el_phi{};
- float m_el_ethad1{};
- float m_el_ehad1{};
- float m_el_f1{};
- float m_el_f3{};
- float m_el_d0{};
- float m_el_f1core{};
- float m_el_f3core{};
- float m_el_weta2{};
- float m_el_wtots1{};
- float m_el_fracs1{};
- float m_el_Reta{};
- float m_el_Rphi{};
- float m_el_Eratio{};
- float m_el_Rhad{};
- float m_el_Rhad1{};
- float m_el_deta1{};
- float m_el_deta2{};
- float m_el_dphi2{};
- float m_el_dphiresc{};
- float m_el_dphiresc2{};
- float m_el_eprobht{};
- float m_el_charge{};
- uint8_t m_el_nblayerhits{};
- uint8_t m_el_nblayerolhits{};
- uint8_t m_el_npixhits{};
- uint8_t m_el_npixolhits{};
- uint8_t m_el_nscthits{};
- uint8_t m_el_nsctolhits{};
- uint8_t m_el_ntrthightreshits{};
- uint8_t m_el_ntrthits{};
- uint8_t m_el_ntrthighthresolhits{};
- uint8_t m_el_ntrtolhits{};
- uint8_t m_el_ntrtxenonhits{};
- bool m_el_expectblayerhit{};
- uint8_t m_el_nsihits{} ;
- uint8_t m_el_nsideadsensors{} ;
- uint8_t m_el_npixdeadsensors{} ;
- uint8_t m_el_nsctdeadsensors{} ;
- bool m_el_loose{};
- bool m_el_medium{};
- bool m_el_tight{};
- bool m_el_lhLoose{};
- bool m_el_lhMedium{};
- bool m_el_lhTight{};
- bool m_el_rgLoose{};
- bool m_el_rgMedium{};
- bool m_el_rgTight{};
- bool m_el_multiLepton{};
- std::vector<float> *m_el_ringsE;
- int m_el_nGoodVtx{};
- int m_el_nPileupPrimaryVtx{};
- ///Egamma Calo
- float m_calo_et{};
- float m_calo_eta{};
- float m_calo_phi{};
-
- // Level 1
- float m_trig_L1_eta{};
- float m_trig_L1_phi{};
- float m_trig_L1_emClus{};
- float m_trig_L1_tauClus{};
- float m_trig_L1_emIsol{};
- float m_trig_L1_hadIsol{};
- std::vector<std::string> *m_trig_L1_thrNames;
- bool m_trig_L1_accept{};
- // Level 2 Calo
- float m_trig_L2_calo_et{};
- float m_trig_L2_calo_eta{};
- float m_trig_L2_calo_phi{};
- float m_trig_L2_calo_e237{};
- float m_trig_L2_calo_e277{};
- float m_trig_L2_calo_fracs1{};
- float m_trig_L2_calo_weta2{};
- float m_trig_L2_calo_ehad1{};
- float m_trig_L2_calo_emaxs1{};
- float m_trig_L2_calo_e2tsts1{};
- float m_trig_L2_calo_wstot{};
- float m_trig_L2_calo_rnnOutput{};
- std::vector<float> *m_trig_L2_calo_energySample;
- std::vector<float> *m_trig_L2_calo_rings;
- bool m_trig_L2_calo_accept{};
- // level 2 id
- std::vector<int> *m_trig_L2_el_trackAlgID;
- std::vector<float> *m_trig_L2_el_pt;
- std::vector<float> *m_trig_L2_el_caloEta;
- std::vector<float> *m_trig_L2_el_eta;
- std::vector<float> *m_trig_L2_el_phi;
- std::vector<float> *m_trig_L2_el_charge;
- std::vector<float> *m_trig_L2_el_nTRTHits;
- std::vector<float> *m_trig_L2_el_nTRTHiThresholdHits;
- std::vector<float> *m_trig_L2_el_etOverPt;
- std::vector<float> *m_trig_L2_el_trkClusDeta;
- std::vector<float> *m_trig_L2_el_trkClusDphi;
-
-
- bool m_trig_L2_el_accept{};
- // Level EF
- bool m_trig_EF_calo_accept{};
- std::vector<float> *m_trig_EF_calo_et;
- std::vector<float> *m_trig_EF_calo_eta;
- bool m_trig_EF_el_accept{};
-
-
- // Monte Carlo
- bool m_mc_hasMC{} ;
- float m_mc_pt{} ;
- float m_mc_eta{} ;
- float m_mc_phi{} ;
- bool m_mc_isTop{} ;
- bool m_mc_isQuark{} ;
- bool m_mc_isParton{} ;
- bool m_mc_isMeson{} ;
- bool m_mc_isTau{} ;
- bool m_mc_isMuon{} ;
- bool m_mc_isPhoton{} ;
- bool m_mc_isElectron{};
- bool m_mc_hasZMother{};
- bool m_mc_hasWMother{};
-
-
-};
-
-
-
-#endif
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaPhysValBase.h b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaPhysValBase.h
new file mode 100644
index 0000000000000000000000000000000000000000..6b77c0d095ad3a618aafaa64ea4996f86faa60e5
--- /dev/null
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaPhysValBase.h
@@ -0,0 +1,276 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TRIGEGAMMAANALYSISTOOLS_TRIGEGAMMAPHYSVALBASE_H
+#define TRIGEGAMMAANALYSISTOOLS_TRIGEGAMMAPHYSVALBASE_H
+
+#include "xAODEventInfo/EventInfo.h"
+#include "xAODTruth/TruthParticle.h"
+#include "xAODTruth/TruthParticleContainer.h"
+#include "xAODEventInfo/EventInfo.h"
+#include "xAODEgamma/EgammaEnums.h"
+#include "xAODTracking/TrackingPrimitives.h"
+#include "TrigDecisionTool/TrigDecisionTool.h"
+#include "TTree.h"
+
+class TrigEgammaPhysValBase
+{
+ public:
+ TrigEgammaPhysValBase();
+ ~TrigEgammaPhysValBase() {};
+
+ protected:
+ /* helper function */
+ template <class T> void InitBranch(TTree* fChain, std::string branch_name, T* param, bool message = true);
+
+ /* Create branches */
+ void bookEventBranches( TTree *t );
+ void bookElectronBranches( TTree *t );
+ void bookTriggerBranches( TTree *t );
+ void bookMonteCarloBranches( TTree *t );
+ void bookTDTBranches( TTree *t );
+
+ /* uses InitBranch to connect the local variable and ttree pointer */
+ void linkEventBranches( TTree *t);
+ void linkElectronBranches( TTree *t);
+ void linkTriggerBranches( TTree *t);
+ void linkSelectorBranches( TTree *t);
+ void linkMonteCarloBranches( TTree *t);
+ void linkTDTBranches( TTree *t);
+
+ /* Space memory manager */
+ void alloc_space();
+ void release_space();
+ void clear();
+ void createTDTMetadata( TTree *t, std::vector<std::string> trigList );
+
+ bool m_doMCDetailed;
+ bool m_doL2Detailed;
+ bool m_doL2CaloDetailed;
+ bool m_doRecoDetailed;
+
+ /* Branch variables */
+ uint32_t m_runNumber{};
+ unsigned long long m_eventNumber{};
+ unsigned int m_eventCounter{};
+ float m_avgmu{};
+ float m_lumiBlock{};
+
+ /* Egamma */
+
+ bool m_el_hasCalo ;
+ bool m_el_hasTrack ;
+ float m_el_e;
+ float m_el_et;
+ float m_el_eta;
+ float m_el_phi;
+ float m_el_ethad1;
+ float m_el_ehad1;
+ float m_el_f1;
+ float m_el_f3;
+ float m_el_f1core;
+ float m_el_f3core;
+ float m_el_weta1;
+ float m_el_weta2;
+ float m_el_wtots1;
+ float m_el_fracs1;
+ float m_el_Reta;
+ float m_el_Rphi;
+ float m_el_Eratio;
+ float m_el_Rhad;
+ float m_el_Rhad1;
+ float m_el_deta1;
+ float m_el_deta2;
+ float m_el_dphi2;
+ float m_el_dphiresc;
+ float m_el_deltaPhiRescaled2;
+ float m_el_deltaEta1;
+ float m_el_deltaE;
+ float m_el_e277;
+ std::vector<float> *m_el_etCone;
+ std::vector<float> *m_el_ptCone;
+
+
+
+ float m_el_trk_pt;
+ float m_el_trk_eta;
+ float m_el_trk_charge;
+ float m_el_trk_sigd0;
+ float m_el_trk_d0;
+ float m_el_trk_eProbabilityHT;
+ float m_el_trk_transformed_eProbabilityHT;
+ float m_el_trk_d0significance;
+ float m_el_trk_deltaPOverP;
+ float m_el_trk_qOverP;
+ std::vector<uint8_t> *m_el_trk_summaryValues;
+
+ bool m_el_loose{};
+ bool m_el_medium{};
+ bool m_el_tight{};
+ bool m_el_lhVLoose{};
+ bool m_el_lhLoose{};
+ bool m_el_lhMedium{};
+ bool m_el_lhTight{};
+ bool m_el_rgLoose{};
+ bool m_el_rgMedium{};
+ bool m_el_rgTight{};
+ bool m_el_multiLepton{};
+ std::vector<float> *m_el_ringsE;
+ int m_el_nGoodVtx{};
+ int m_el_nPileupPrimaryVtx{};
+ ///Egamma Calo
+ float m_el_calo_et{};
+ float m_el_calo_eta{};
+ float m_el_calo_phi{};
+ float m_el_calo_etaBE2{};
+ float m_el_calo_e{};
+ // Level 1
+ float m_trig_L1_eta{};
+ float m_trig_L1_phi{};
+ float m_trig_L1_emClus{};
+ float m_trig_L1_tauClus{};
+ float m_trig_L1_emIsol{};
+ float m_trig_L1_hadIsol{};
+ float m_trig_L1_hadCore{};
+ std::vector<std::string> *m_trig_L1_thrNames;
+
+ // Level 2 Calo
+ float m_trig_L2_calo_et{};
+ float m_trig_L2_calo_eta{};
+ float m_trig_L2_calo_phi{};
+ float m_trig_L2_calo_e237{};
+ float m_trig_L2_calo_e277{};
+ float m_trig_L2_calo_fracs1{};
+ float m_trig_L2_calo_weta2{};
+ float m_trig_L2_calo_ehad1{};
+ float m_trig_L2_calo_emaxs1{};
+ float m_trig_L2_calo_e2tsts1{};
+ float m_trig_L2_calo_wstot{};
+ float m_trig_L2_calo_nnOutput{};
+ std::vector<float> *m_trig_L2_calo_energySample;
+ std::vector<float> *m_trig_L2_calo_rings;
+ std::vector<float> *m_trig_L2_calo_rnnOutput;
+ // level 2 id
+ std::vector<int> *m_trig_L2_el_trackAlgID;
+ std::vector<float> *m_trig_L2_el_pt;
+ std::vector<float> *m_trig_L2_el_caloEta;
+ std::vector<float> *m_trig_L2_el_eta;
+ std::vector<float> *m_trig_L2_el_phi;
+ std::vector<float> *m_trig_L2_el_charge;
+ std::vector<float> *m_trig_L2_el_nTRTHits;
+ std::vector<float> *m_trig_L2_el_nTRTHiThresholdHits;
+ std::vector<float> *m_trig_L2_el_etOverPt;
+ std::vector<float> *m_trig_L2_el_trkClusDeta;
+ std::vector<float> *m_trig_L2_el_trkClusDphi;
+
+ // EFCalo and HLT steps
+
+ std::vector<float> *m_trig_EF_calo_e;
+ std::vector<float> *m_trig_EF_calo_et;
+ std::vector<float> *m_trig_EF_calo_eta;
+ std::vector<float> *m_trig_EF_calo_phi;
+ std::vector<float> *m_trig_EF_calo_etaBE2;
+
+ std::vector<float> *m_trig_EF_el_calo_e;
+ std::vector<float> *m_trig_EF_el_calo_et;
+ std::vector<float> *m_trig_EF_el_calo_eta;
+ std::vector<float> *m_trig_EF_el_calo_phi;
+ std::vector<float> *m_trig_EF_el_calo_etaBE2;
+
+ std::vector<float> *m_trig_EF_el_e;
+ std::vector<float> *m_trig_EF_el_et;
+ std::vector<float> *m_trig_EF_el_eta;
+ std::vector<float> *m_trig_EF_el_phi;
+ std::vector<float> *m_trig_EF_el_ethad1;
+ std::vector<float> *m_trig_EF_el_ehad1;
+ std::vector<float> *m_trig_EF_el_f1;
+ std::vector<float> *m_trig_EF_el_f3;
+ std::vector<float> *m_trig_EF_el_f1core;
+ std::vector<float> *m_trig_EF_el_f3core;
+ std::vector<float> *m_trig_EF_el_weta1;
+ std::vector<float> *m_trig_EF_el_weta2;
+ std::vector<float> *m_trig_EF_el_wtots1;
+ std::vector<float> *m_trig_EF_el_fracs1;
+ std::vector<float> *m_trig_EF_el_Reta;
+ std::vector<float> *m_trig_EF_el_Rphi;
+ std::vector<float> *m_trig_EF_el_Eratio;
+ std::vector<float> *m_trig_EF_el_Rhad;
+ std::vector<float> *m_trig_EF_el_Rhad1;
+ std::vector<float> *m_trig_EF_el_deta2;
+ std::vector<float> *m_trig_EF_el_dphi2;
+ std::vector<float> *m_trig_EF_el_dphiresc;
+ std::vector<float> *m_trig_EF_el_e277;
+ std::vector<float> *m_trig_EF_el_deltaPhiRescaled2;
+ std::vector<float> *m_trig_EF_el_deltaEta1;
+ std::vector<float> *m_trig_EF_el_deltaE;
+ std::vector<float> *m_trig_EF_el_etCone;
+ std::vector<float> *m_trig_EF_el_ptCone;
+
+
+ std::vector<float> *m_trig_EF_el_trk_pt;
+ std::vector<float> *m_trig_EF_el_trk_eta;
+ std::vector<float> *m_trig_EF_el_trk_charge;
+ std::vector<float> *m_trig_EF_el_trk_sigd0;
+ std::vector<float> *m_trig_EF_el_trk_d0;
+ std::vector<float> *m_trig_EF_el_trk_eProbabilityHT;
+ std::vector<float> *m_trig_EF_el_trk_transformed_eProbabilityHT;
+ std::vector<float> *m_trig_EF_el_trk_d0significance;
+ std::vector<float> *m_trig_EF_el_trk_deltaPOverP;
+ std::vector<float> *m_trig_EF_el_trk_qOverP;
+ std::vector<uint8_t> *m_trig_EF_el_trk_summaryValues;
+
+
+ std::vector<bool> *m_trig_EF_el_hasCalo ;
+ std::vector<bool> *m_trig_EF_el_hasTrack ;
+
+
+
+ std::vector<bool> *m_trig_EF_el_loose;
+ std::vector<bool> *m_trig_EF_el_medium;
+ std::vector<bool> *m_trig_EF_el_tight;
+ std::vector<bool> *m_trig_EF_el_lhvloose;
+ std::vector<bool> *m_trig_EF_el_lhloose;
+ std::vector<bool> *m_trig_EF_el_lhmedium;
+ std::vector<bool> *m_trig_EF_el_lhtight;
+ std::vector<bool> *m_trig_EF_calo_loose;
+ std::vector<bool> *m_trig_EF_calo_medium;
+ std::vector<bool> *m_trig_EF_calo_tight;
+ std::vector<bool> *m_trig_EF_calo_lhvloose;
+ std::vector<bool> *m_trig_EF_calo_lhloose;
+ std::vector<bool> *m_trig_EF_calo_lhmedium;
+ std::vector<bool> *m_trig_EF_calo_lhtight;
+
+ std::vector<int> *m_trig_tdt_L1_calo_accept;
+ std::vector<int> *m_trig_tdt_L2_calo_accept;
+ std::vector<int> *m_trig_tdt_L2_el_accept ;
+ std::vector<int> *m_trig_tdt_EF_calo_accept;
+ std::vector<int> *m_trig_tdt_EF_el_accept ;
+ std::vector<int> *m_trig_tdt_emu_L1_calo_accept;
+ std::vector<int> *m_trig_tdt_emu_L2_calo_accept;
+ std::vector<int> *m_trig_tdt_emu_L2_el_accept ;
+ std::vector<int> *m_trig_tdt_emu_EF_calo_accept;
+ std::vector<int> *m_trig_tdt_emu_EF_el_accept ;
+
+
+
+ // Monte Carlo
+ bool m_mc_hasMC{} ;
+ float m_mc_pt{} ;
+ float m_mc_eta{} ;
+ float m_mc_phi{} ;
+ bool m_mc_isTop{} ;
+ bool m_mc_isParton{} ;
+ bool m_mc_isMeson{} ;
+ bool m_mc_isQuark{} ;
+ bool m_mc_isTau{} ;
+ bool m_mc_isMuon{} ;
+ bool m_mc_isPhoton{} ;
+ bool m_mc_isElectron{};
+ bool m_mc_hasZMother{};
+ bool m_mc_hasWMother{};
+
+};
+
+
+#endif
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaPlotTool.h b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaPlotTool.h
index c1cd6fa59b9bd0efde9f3486ce30e7153f136f28..fd45b130a13977445e14be86be6493d91a44acfe 100644
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaPlotTool.h
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/TrigEgammaAnalysisTools/TrigEgammaPlotTool.h
@@ -73,8 +73,6 @@ class TrigEgammaPlotTool
int m_ncoarseEtabins; //2D
std::vector<float> m_etbins;
std::vector<float> m_etabins;
- std::vector<float> m_minBin_ringer;
- std::vector<float> m_maxBin_ringer;
std::vector<double> m_defaultEtbins;
std::vector<double> m_defaultEtabins;
std::vector<double> m_coarseEtbins;
@@ -117,21 +115,20 @@ class TrigEgammaPlotTool
void bookL1Histos(TrigInfo);
void bookShifterHistos();
//void bookAnalysisHistos(const std::string dir);
- void bookEfficiencyTProfile(const std::string dir);
- void bookEfficiencyHistos(const std::string dir);
- void bookEfficiency2DHistos(const std::string dir);
- void bookEgammaDistributionHistos(const std::string dir);
- void bookElectronDistributionHistos(const std::string dir);
- void bookDistributionHistos(const std::string dir);
- void bookResolutionHistos(const std::string dir);
- void bookElectronResolutionHistos(const std::string dir);
- void bookElectronIsoResolutionHistos(const std::string dir);
- void bookPhotonResolutionHistos(const std::string dir);
- void bookPhotonIsoResolutionHistos(const std::string dir);
- void bookExpertResolutionHistos(const std::string dir);
- void bookExpertL2CaloResolutionHistos(const std::string dir);
- void bookAbsResolutionHistos(const std::string dir);
- void parseCaloRingsLayers( unsigned layer, unsigned &minRing, unsigned &maxRing, std::string &caloLayerName);
+ void bookEfficiencyTProfile(const std::string &dir);
+ void bookEfficiencyHistos(const std::string &dir);
+ void bookEfficiency2DHistos(const std::string &dir);
+ void bookEgammaDistributionHistos(const std::string &dir);
+ void bookElectronDistributionHistos(const std::string &dir);
+ void bookDistributionHistos(const std::string &dir);
+ void bookResolutionHistos(const std::string &dir);
+ void bookElectronResolutionHistos(const std::string &dir);
+ void bookElectronIsoResolutionHistos(const std::string &dir);
+ void bookPhotonResolutionHistos(const std::string &dir);
+ void bookPhotonIsoResolutionHistos(const std::string &dir);
+ void bookExpertResolutionHistos(const std::string &dir);
+ void bookExpertL2CaloResolutionHistos(const std::string &dir);
+ void bookAbsResolutionHistos(const std::string &dir);
};
#endif
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/python/TrigEgammaAnalysisToolsConfig.py b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/python/TrigEgammaAnalysisToolsConfig.py
index 2159a9dd78156d32bf3c67810a0ee605bc4ddf7b..6b5d24fa7d7f24ed6f0031425b39433c008f53e1 100644
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/python/TrigEgammaAnalysisToolsConfig.py
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/python/TrigEgammaAnalysisToolsConfig.py
@@ -1,10 +1,11 @@
-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+
from TrigEgammaAnalysisTools import TrigEgammaAnalysisToolsConf
from AthenaCommon import CfgMgr
from AthenaCommon.AppMgr import ToolSvc
-from egammaRec.Factories import ToolFactory,FcnWrapper,AlgFactory, getPropertyValue
+from egammaRec.Factories import PublicToolFactory,FcnWrapper,AlgFactory, getPropertyValue
import PyUtils.RootUtils as ru
ROOT = ru.import_root()
@@ -29,22 +30,29 @@ MediumElectronSelector = CfgMgr.AsgElectronIsEMSelector("T0HLTMediumE
TightElectronSelector = CfgMgr.AsgElectronIsEMSelector("T0HLTTightElectronSelector")
LooseLHSelector = CfgMgr.AsgElectronLikelihoodTool("T0HLTLooseLHSelector")
MediumLHSelector = CfgMgr.AsgElectronLikelihoodTool("T0HLTMediumLHSelector")
-MediumLHHISelector = CfgMgr.AsgElectronLikelihoodTool("T0HLTMediumLHHISelector")
TightLHSelector = CfgMgr.AsgElectronLikelihoodTool("T0HLTTightLHSelector")
+VeryLooseLHSelector = CfgMgr.AsgElectronLikelihoodTool("T0HLTVeryLooseLHSelector")
+
+# see the configuration calib paths below
LooseElectronSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20150712/ElectronIsEMLooseSelectorCutDefs.conf"
MediumElectronSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20150712/ElectronIsEMMediumSelectorCutDefs.conf"
TightElectronSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20150712/ElectronIsEMTightSelectorCutDefs.conf"
+# 2018 (vtest)
LooseLHSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc16_20170828/ElectronLikelihoodLooseOfflineConfig2017_CutBL_Smooth.conf"
MediumLHSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc16_20170828/ElectronLikelihoodMediumOfflineConfig2017_Smooth.conf"
-MediumLHHISelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20160907_HI/ElectronLikelihoodMediumOfflineConfig2016_HI.conf"
TightLHSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc16_20170828/ElectronLikelihoodTightOfflineConfig2017_Smooth.conf"
+VeryLooseLHSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc16_20170828/ElectronLikelihoodVeryLooseOfflineConfig2017_Smooth.conf"
+
+
+
+
ToolSvc+=LooseElectronSelector
ToolSvc+=MediumElectronSelector
ToolSvc+=TightElectronSelector
ToolSvc+=LooseLHSelector
ToolSvc+=MediumLHSelector
-ToolSvc+=MediumLHHISelector
ToolSvc+=TightLHSelector
+ToolSvc+=VeryLooseLHSelector
#from LumiBlockComps.LuminosityToolDefault import LuminosityToolOnline
@@ -69,81 +77,43 @@ EgammaMatchTool = Trig__TrigEgammaMatchingTool()
ToolSvc += EgammaMatchTool
# Plot Tool sets the base path for histograms of all tools
-TrigEgammaPlotTool = ToolFactory(TrigEgammaAnalysisToolsConf.TrigEgammaPlotTool, name="TrigEgammaPlotTool",
+TrigEgammaPlotTool = PublicToolFactory(TrigEgammaAnalysisToolsConf.TrigEgammaPlotTool, name="TrigEgammaPlotTool",
DirectoryPath="/HLT/Egamma",
MaM=monitoring_mam,
Efficiency=["eff_et","eff_eta","eff_mu"],
Distribution=["et","eta"],
Resolution=["res_et","res_eta"],
OutputLevel=0)
-EfficiencyTool = ToolFactory(TrigEgammaAnalysisToolsConf.EfficiencyTool,
+
+EfficiencyTool = PublicToolFactory(TrigEgammaAnalysisToolsConf.EfficiencyTool,
name="EfficiencyTool",
PlotTool=TrigEgammaPlotTool,
isEMResultNames=["Tight","Medium","Loose"],
LHResultNames=["LHTight","LHMedium","LHLoose"],
OutputLevel=0)
-ResolutionTool = ToolFactory(TrigEgammaAnalysisToolsConf.TrigEgammaResolutionTool,
+
+ResolutionTool = PublicToolFactory(TrigEgammaAnalysisToolsConf.TrigEgammaResolutionTool,
name="ResolutionTool",
PlotTool=TrigEgammaPlotTool,
OutputLevel=0)
-DistTool = ToolFactory(TrigEgammaAnalysisToolsConf.TrigEgammaDistTool,
+
+DistTool = PublicToolFactory(TrigEgammaAnalysisToolsConf.TrigEgammaDistTool,
name="DistTool",
PlotTool=TrigEgammaPlotTool,
OutputLevel=0)
# import emulator egamma trigger tool
-from TrigEgammaEmulationTool.TrigEgammaEmulationToolConfig import TrigEgammaEmulationTool
+#from TrigEgammaEmulationTool.TrigEgammaEmulationToolConfig import TrigEgammaEmulationTool
# Copy the default config w/ list
# Allows factories below to instantiate emulator once Factories are instantiated
-EmulationTool = TrigEgammaEmulationTool.copy( name = "TrigEgammaEmulationTool",
- TriggerList = monitoringTP_electron)
-
-TrigEgammaNavTPNtuple = ToolFactory(TrigEgammaAnalysisToolsConf.TrigEgammaNavTPNtuple, name ="TrigEgammaNavTPNtuple",
- Analysis='ZeeTPNtuple',
- ElectronKey = 'Electrons',
- MatchTool = EgammaMatchTool,
- PlotTool=TrigEgammaPlotTool,
- EmulationTool=EmulationTool,
- Tools=[],
- isEMResultNames=["Tight","Medium","Loose"],
- LHResultNames=["LHTight","LHMedium","LHLoose"],
- ElectronIsEMSelector =[TightElectronSelector,MediumElectronSelector,LooseElectronSelector],
- ElectronLikelihoodTool =[TightLHSelector,MediumLHSelector,LooseLHSelector],
- ZeeLowerMass=80,
- ZeeUpperMass=100,
- doOfflineDump=False,
- doEmulation=False,
- OfflineTagSelector='Tight', # 1=tight, 2=medium, 3=loose
- OfflineProbeSelector='Loose',
- ForceProbePid=False,
- OppositeCharge=True,
- OfflineTagMinEt=25,
- CutLabels=["Events","LAr","RetrieveElectrons","TwoElectrons","PassTrigger","EventWise","Success"],
- TagTriggerList=["e24_tight_iloose"],
- TriggerList=monitoringTP_electron
+#EmulationTool = TrigEgammaEmulationTool.copy( name = "TrigEgammaEmulationTool",
+# TriggerList = monitoringTP_electron)
- )
+################################################################################################
+# Build factory
-TrigEgammaNavNtuple = ToolFactory(TrigEgammaAnalysisToolsConf.TrigEgammaNavNtuple, name ="TrigEgammaNavNtuple",
- Analysis='Ntuple',
- ElectronKey = 'Electrons',
- MatchTool = EgammaMatchTool,
- PlotTool=TrigEgammaPlotTool,
- EmulationTool=EmulationTool,
- Tools=[],
- ElectronIsEMSelector =[TightElectronSelector,MediumElectronSelector,LooseElectronSelector],
- ElectronLikelihoodTool =[TightLHSelector,MediumLHSelector,LooseLHSelector],
- TriggerList=monitoringTP_electron,
- doOfflineDump=False,
- doEmulation=False,
- ForcePidSelection=True,
- ForceProbeIsolation=False,
- ForceEtThreshold=True,
- ForceMCEnhancedBias=False,
- RemoveCrack=True,
- )
-TrigEgammaNavTPAnalysisTool = ToolFactory(TrigEgammaAnalysisToolsConf.TrigEgammaNavTPAnalysisTool, name = "TrigEgammaNavTPAnalysisTool",
+TrigEgammaNavTPAnalysisTool = PublicToolFactory(TrigEgammaAnalysisToolsConf.TrigEgammaNavTPAnalysisTool, name = "TrigEgammaNavTPAnalysisTool",
Analysis='Zee',
ElectronKey = 'Electrons',
MatchTool = EgammaMatchTool,
@@ -162,6 +132,7 @@ TrigEgammaNavTPAnalysisTool = ToolFactory(TrigEgammaAnalysisToolsConf.TrigEgamma
OppositeCharge=True,
doJpsiee=False,
doEmulation=False,
+ ForceTrigAttachment=False,
TPTrigger=False,
OfflineTagMinEt=25,
RemoveCrack=True,
@@ -173,7 +144,7 @@ TrigEgammaNavTPAnalysisTool = ToolFactory(TrigEgammaAnalysisToolsConf.TrigEgamma
TagLabels=["Electrons","HasTrack","HasCluster","GoodPid","Et","Eta","IsGoodOQ","PassTrigger","MatchTrigger"],
)
-TrigEgammaNavTPJpsieeAnalysisTool = ToolFactory(TrigEgammaAnalysisToolsConf.TrigEgammaNavTPAnalysisTool,
+TrigEgammaNavTPJpsieeAnalysisTool = PublicToolFactory(TrigEgammaAnalysisToolsConf.TrigEgammaNavTPAnalysisTool,
name = "TrigEgammaNavTPJpsieeAnalysisTool",
Analysis='Jpsiee',
ElectronKey = 'Electrons',
@@ -184,7 +155,7 @@ TrigEgammaNavTPJpsieeAnalysisTool = ToolFactory(TrigEgammaAnalysisToolsConf.Trig
isEMResultNames=["Tight","Medium","Loose"],
LHResultNames=["LHTight","LHMedium","LHLoose"],
ElectronIsEMSelector =[TightElectronSelector,MediumElectronSelector,LooseElectronSelector],
- ElectronLikelihoodTool =[TightLHSelector,MediumLHSelector,LooseLHSelector, MediumLHHISelector],
+ ElectronLikelihoodTool =[TightLHSelector,MediumLHSelector,LooseLHSelector],
ZeeLowerMass=2,
ZeeUpperMass=5,
OfflineTagSelector='Tight', # 1=tight, 2=medium, 3=loose
@@ -193,6 +164,7 @@ TrigEgammaNavTPJpsieeAnalysisTool = ToolFactory(TrigEgammaAnalysisToolsConf.Trig
OppositeCharge=True,
doJpsiee=True,
doEmulation=False,
+ ForceTrigAttachment=False,
TPTrigger=False,
OfflineTagMinEt=5,
RemoveCrack=True,
@@ -204,7 +176,7 @@ TrigEgammaNavTPJpsieeAnalysisTool = ToolFactory(TrigEgammaAnalysisToolsConf.Trig
TagLabels=["Electrons","HasTrack","HasCluster","GoodPid","Et","Eta","PassTrigger","MatchTrigger"],
)
-TrigEgammaNavAnalysisTool = ToolFactory(TrigEgammaAnalysisToolsConf.TrigEgammaNavAnalysisTool, name ="TrigEgammaNavAnalysisTool",
+TrigEgammaNavAnalysisTool = PublicToolFactory(TrigEgammaAnalysisToolsConf.TrigEgammaNavAnalysisTool, name ="TrigEgammaNavAnalysisTool",
Analysis='Analysis',
ElectronKey = 'Electrons',
MatchTool = EgammaMatchTool,
@@ -212,42 +184,140 @@ TrigEgammaNavAnalysisTool = ToolFactory(TrigEgammaAnalysisToolsConf.TrigEgammaNa
#EmulationTool=EmulationTool,
Tools=[EfficiencyTool,ResolutionTool,DistTool],
ElectronIsEMSelector =[TightElectronSelector,MediumElectronSelector,LooseElectronSelector],
- ElectronLikelihoodTool =[TightLHSelector,MediumLHSelector,LooseLHSelector,MediumLHHISelector],
+ ElectronLikelihoodTool =[TightLHSelector,MediumLHSelector,LooseLHSelector],
+ ElectronLHVLooseTool=VeryLooseLHSelector,
IsEMLabels=IneffLabels,
TriggerList=monitoring_electron + monitoring_photon,
ForcePidSelection=True,
ForceProbeIsolation=False,
ForceEtThreshold=True,
+ ForceTrigAttachment=False,
RemoveCrack=True,
doEmulation=False,
)
-TrigEgammaNavEnhancedBiasAnalysisTool = ToolFactory(TrigEgammaAnalysisToolsConf.TrigEgammaNavAnalysisTool, name ="TrigEgammaNavEnhancedBiasAnalysisTool",
- Analysis='EnhancedBias',
- ElectronKey = 'Electrons',
- MatchTool = EgammaMatchTool,
- EmulationTool=EmulationTool,
- PlotTool=TrigEgammaPlotTool,
- Tools=[EfficiencyTool,ResolutionTool,DistTool],
- ElectronIsEMSelector =[TightElectronSelector,MediumElectronSelector,LooseElectronSelector],
- ElectronLikelihoodTool =[TightLHSelector,MediumLHSelector,LooseLHSelector],
- IsEMLabels=IneffLabels,
- TriggerList=monitoring_electron + monitoring_photon,
- ForcePidSelection=False,
- ForceProbeIsolation=False,
- ForceEtThreshold=False,
- ForceMCEnhancedBias=False,
- RemoveCrack=False,
- doEmulation=False,
- )
+#############################################################################################
+# Functions
# Function to return triggerlist tools
def getAllTools():
return [TrigEgammaNavZeeTPCounts(),TrigEgammaNavZeeTPEff(),TrigEgammaNavZeeTPIneff(),TrigEgammaNavZeeTPRes(),]
+
+def setRunFlag( runFlag ):
+ if runFlag == '2018':
+ # cut based
+ LooseElectronSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20150712/ElectronIsEMLooseSelectorCutDefs.conf"
+ MediumElectronSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20150712/ElectronIsEMMediumSelectorCutDefs.conf"
+ TightElectronSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20150712/ElectronIsEMTightSelectorCutDefs.conf"
+
+ # 2018 (vtest)
+ LooseLHSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc16_20170828/ElectronLikelihoodLooseOfflineConfig2017_CutBL_Smooth.conf"
+ MediumLHSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc16_20170828/ElectronLikelihoodMediumOfflineConfig2017_Smooth.conf"
+ TightLHSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc16_20170828/ElectronLikelihoodTightOfflineConfig2017_Smooth.conf"
+ VeryLooseLHSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc16_20170828/ElectronLikelihoodVeryLooseOfflineConfig2017_Smooth.conf"
+ elif runFlag == '2017':
+ # cut based
+ LooseElectronSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20150712/ElectronIsEMLooseSelectorCutDefs.conf"
+ MediumElectronSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20150712/ElectronIsEMMediumSelectorCutDefs.conf"
+ TightElectronSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20150712/ElectronIsEMTightSelectorCutDefs.conf"
+
+ # 2017 (v11)
+ LooseLHSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20160512/ElectronLikelihoodLooseOfflineConfig2016_CutBL_Smooth.conf"
+ MediumLHSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20160512/ElectronLikelihoodMediumOfflineConfig2016_Smooth.conf"
+ TightLHSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20160512/ElectronLikelihoodTightOfflineConfig2016_Smooth.conf"
+ VeryLooseLHSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20160512/ElectronLikelihoodVeryLooseOfflineConfig2016_Smooth.conf"
+ else:
+ print 'Wrong run flag configuration'
+
+
+
# The main algorithm
# Add triggerlist tools to ToolHandleArray
TrigEgammaAnalysisAlg = AlgFactory(TrigEgammaAnalysisToolsConf.TrigEgammaAnalysisAlg,
name='TrigEgammaAnalysisAlg',
Tools = FcnWrapper(getAllTools),
)
+
+
+
+# This function will be used to collect events from Zee,JF17 and PhysicsMain samples.
+# Use this if you really know. (for experts)
+def getEventSelectionTool(runFlag):
+
+ from TrigEgammaEmulationTool.TrigEgammaEmulationPidToolsConfig import getEgammaIsEMSelectorCaloOnly, \
+ getElectronIsEMSelector,\
+ getEgammaLikelihoodSelectorCaloOnly, \
+ getElectronLikelihoodSelector2015,\
+ getElectronLikelihoodSelectorNoD0
+ from AthenaCommon import CfgMgr
+ from AthenaCommon.AppMgr import ToolSvc
+ # create all selector list. Here, the order is matter. Please check the
+
+ setRunFlag(runFlag)
+ if runFlag == '2017':
+
+ # trigger configuration
+ EFCaloIsEMSelectorList = getEgammaIsEMSelectorCaloOnly( "ElectronPhotonSelectorTools/trigger/rel21_20170217")
+ HLTIsEMSelectorList = getElectronIsEMSelector( "ElectronPhotonSelectorTools/trigger/rel21_20170217")
+ EFCaloLikelihoodSelectorList = getEgammaLikelihoodSelectorCaloOnly( "ElectronPhotonSelectorTools/trigger/rel21_20170217")
+ HLTLikelihoodSelectorList = getElectronLikelihoodSelectorNoD0( "ElectronPhotonSelectorTools/trigger/rel21_20170217")
+
+ elif runFlag == '2018':
+ # trigger configuration
+ EFCaloIsEMSelectorList = getEgammaIsEMSelectorCaloOnly( "ElectronPhotonSelectorTools/trigger/rel21_20180312")
+ HLTIsEMSelectorList = getElectronIsEMSelector( "ElectronPhotonSelectorTools/trigger/rel21_20180312")
+ EFCaloLikelihoodSelectorList = getEgammaLikelihoodSelectorCaloOnly( "ElectronPhotonSelectorTools/trigger/rel21_20180312")
+ HLTLikelihoodSelectorList = getElectronLikelihoodSelectorNoD0( "ElectronPhotonSelectorTools/trigger/rel21_20180312")
+
+ else:
+ print 'Wrong run flag configuration'
+
+ # create the event selection tool
+ TrigEgammaEventSelection = PublicToolFactory(TrigEgammaAnalysisToolsConf.TrigEgammaEventSelection, name ="TrigEgammaEventSelection",
+ Analysis='EventsSelection',
+ ElectronKey = 'Electrons',
+ MatchTool = EgammaMatchTool,
+ PlotTool=TrigEgammaPlotTool,
+ EmulationTool=EmulationTool, # The emulation must be on in this tool.
+ doEmulation=True,
+ Tools=[],
+ isEMResultNames=["Tight","Medium","Loose"],
+ LHResultNames=["LHTight","LHMedium","LHLoose"],
+ ElectronLHVLooseTool=VeryLooseLHSelector,
+ ZeeLowerMass=80,
+ ZeeUpperMass=100,
+ OfflineTagSelector='Tight', # 1=tight, 2=medium, 3=loose
+ OfflineProbeSelector='Loose',
+ ForceProbePid=False,
+ OppositeCharge=True,
+ RemoveCrack=False,
+ OfflineTagMinEt=25,
+ OfflineProbeMinEt=4,
+ CutLabels=["Events","LAr","RetrieveElectrons","TwoElectrons","PassTrigger","EventWise","Success"],
+ TagTriggerList=["e24_tight_iloose"],
+ TriggerList=monitoringTP_electron,
+ ApplyMinimalTrigger = False,
+ SelectionZ=True,
+ SelectionW=False,
+ SelectionJpsi=False,
+ SelectionFakes=False,
+ SelectionMC=False,
+ ForceTrigAttachment=True,
+ DetailedDataLevel=0, # 0 = VerySlim, 1 = Slim and 2 = Full
+ # Asg selectors to decorate my final skimmed ntuple.
+ EFCaloElectronLikelihoodSelector=EFCaloLikelihoodSelectorList,
+ EFCaloElectronIsEMSelector=EFCaloIsEMSelectorList,
+ HLTElectronLikelihoodSelector=HLTLikelihoodSelectorList,
+ HLTElectronIsEMSelector=HLTIsEMSelectorList,
+ ElectronIsEMSelector =[TightElectronSelector,MediumElectronSelector,LooseElectronSelector],
+ ElectronLikelihoodTool =[TightLHSelector,MediumLHSelector,LooseLHSelector],
+
+ )
+
+
+ # Return the template
+ return TrigEgammaEventSelection
+
+
+
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/python/TrigEgammaProbelist.py b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/python/TrigEgammaProbelist.py
index c0e9cfe8cca733442ba604187a026c2f51a0bdcf..be86a3aa05aee9ad112d55350dde2e3caac6bb9c 100644
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/python/TrigEgammaProbelist.py
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/python/TrigEgammaProbelist.py
@@ -484,6 +484,7 @@ defaultJpsi=[
"HLT_e5_lhvloose",
]
+
# Lowest single electron triggers for TP analysis
monitoringTP_electron_extra =[
'HLT_e24_lhmedium_L1EM18VH',
@@ -547,5 +548,3 @@ supportingTriggerList.extend( [
-
-
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/share/testTrigEgammaAnalysisTools_emulator.py b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/share/testTrigEgammaAnalysisTools_emulator.py
new file mode 100644
index 0000000000000000000000000000000000000000..8dc82ce612d578237100e11f346d5d4291163087
--- /dev/null
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/share/testTrigEgammaAnalysisTools_emulator.py
@@ -0,0 +1,250 @@
+# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+
+####################################################################################################
+# Job options for standalone and Tier0 running of AnalysisTools
+# Authors:
+# Ryan Mackenzie White <ryan.white@cern.ch>
+# Joao Victor Pinto <jodafons@cern.ch>
+#
+# Tool and algorithm configuration done using egamma Factories
+#
+# To run
+# athena -l DEBUG -c "DIR='/afs/cern.ch/work/j/jolopezl/datasets/\
+# valid1.147406.PowhegPythia8_AZNLO_Zee.recon.AOD.e3099_s2578_r6220_tid05203475_00'"
+# -c "NOV=50" test_ZeeElectronLowPtSupportingTrigAnalysis.py
+# where NOV is the number of events to run
+####################################################################################################
+
+
+from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
+from RecExConfig.RecFlags import rec
+from RecExConfig.RecAlgsFlags import recAlgs
+from AthenaCommon.AppMgr import ToolSvc
+import os
+
+# Define triggers for tagging
+tagList = ['HLT_e24_lhtight_nod0_ivarloose',
+ 'HLT_e26_lhtight_nod0_ivarloose',
+ 'HLT_e28_lhtight_nod0_ivarloose']
+
+triggerList_commissioning_v1 = [
+
+ # standard monitoring chains
+ #'HLT_e17_lhvloose_nod0_L1EM15VHI',
+ 'HLT_e17_lhvloose_nod0',
+ 'HLT_e26_lhloose_nod0',
+ 'HLT_e26_lhmedium_nod0',
+ #'HLT_e26_lhtight_nod0',
+ #'HLT_e26_lhtight_nod0_ivarloose',
+ 'HLT_e28_lhtight_nod0_ivarloose',
+ 'HLT_e60_lhmedium_nod0_L1EM24VHI',
+ 'HLT_e140_lhloose_nod0_L1EM24VHI',
+ # ringer chains for the commissioning...
+ #'HLT_e17_lhvloose_nod0_ringer_L1EM15VHI',
+ 'HLT_e17_lhvloose_nod0_ringer',
+ 'HLT_e26_lhloose_nod0_ringer',
+ 'HLT_e26_lhmedium_nod0_ringer',
+ #'HLT_e26_lhtight_nod0_ringer',
+ #'HLT_e26_lhtight_nod0_ringer_ivarloose',
+ 'HLT_e28_lhtight_nod0_ringer_ivarloose',
+ 'HLT_e60_lhmedium_nod0_ringer_L1EM24VHI',
+ 'HLT_e140_lhloose_nod0_ringer_L1EM24VHI',
+ ]
+
+
+triggerList_monitoring_v1 = [
+ # standard monitoring chains
+ 'HLT_e17_lhvloose_nod0_L1EM15VHI',
+ 'HLT_e26_lhtight_nod0_ivarloose',
+ 'HLT_e28_lhtight_nod0_icaloloose',
+ 'HLT_e60_lhmedium_nod0_L1EM24VHI',
+ 'HLT_e140_lhloose_nod0_L1EM24VHI',
+ # no ringer chains for pos-commissioning...
+ 'HLT_e17_lhvloose_nod0_noringer_L1EM15VHI',
+ 'HLT_e26_lhtight_nod0_noringer_ivarloose',
+ 'HLT_e28_lhtight_nod0_noringer_ivarloose',
+ 'HLT_e60_lhmedium_nod0_noringer_L1EM24VHI',
+ 'HLT_e140_lhloose_nod0_noringer_L1EM24VHI',
+
+ ]
+
+
+triggerList = triggerList_monitoring_v1
+
+doGRL=False
+doEmulation=True
+DetailedHistograms=False
+####################################################################################################
+dirtouse = str()
+finallist=[]
+grllist=[]
+
+from AthenaCommon.AthenaCommonFlags import athenaCommonFlags as acf
+from glob import glob
+
+if ('FILE' in dir()):
+ acf.FilesInput=[FILE]
+elif ('DIR' in dir()):
+ inputFiles = glob(DIR+'*')
+ acf.FilesInput=inputFiles
+if 'NOV' in dir():
+ nov=NOV
+else :
+ nov=500
+if 'GRL' in dir():
+ grllist.append(GRL)
+else:
+ #grllist.append('/afs/cern.ch/work/j/jodafons/public/data/data15_13TeV.periodAllYear_DetStatus-v79-repro20-02_DQDefects-00-02-02_PHYS_StandardGRL_All_Good_25ns.xml')
+ #grllist.append('data15_13TeV.periodAllYear_DetStatus-v79-repro20-02_DQDefects-00-02-02_PHYS_StandardGRL_All_Good_25ns.xml')
+ #grllist.append('/afs/cern.ch/work/j/jodafons/public/data/data16_13TeV.periodAllYear_DetStatus-v81-pro20-10_DQDefects-00-02-02_PHYS_StandardGRL_All_Good_25ns.xml')
+ #grllist.append('data16_13TeV.periodAllYear_DetStatus-v81-pro20-10_DQDefects-00-02-02_PHYS_StandardGRL_All_Good_25ns.xml')
+ grllist.append('data17_13TeV.periodAllYear_DetStatus-v92-pro21-05_Unknown_PHYS_StandardGRL_All_Good_25ns_Triggerno17e33prim.xml')
+
+####################################################################################################
+
+acf.EvtMax=nov
+rec.readAOD=True
+# switch off detectors
+rec.doForwardDet=False
+rec.doInDet=False
+rec.doCalo=False
+rec.doMuon=False
+rec.doEgamma=False
+rec.doTrigger=True
+recAlgs.doTrigger=False # disable trigger (maybe necessary if detectors switched off)
+rec.doMuon=False
+rec.doMuonCombined=False
+rec.doWriteAOD=True
+rec.doWriteESD=False
+rec.doDPD=False
+rec.doTruth=False
+# autoconfiguration might trigger undesired feature
+rec.doESD.set_Value_and_Lock(False) # uncomment if do not run ESD making algorithms
+rec.doWriteESD.set_Value_and_Lock(False) # uncomment if do not write ESD
+rec.doAOD.set_Value_and_Lock(True) # uncomment if do not run AOD making algorithms
+rec.doWriteAOD.set_Value_and_Lock(False) # uncomment if do not write AOD
+rec.doWriteTAG.set_Value_and_Lock(False) # uncomment if do not write TAG
+
+# main jobOption
+include ("RecExCommon/RecExCommon_topOptions.py")
+MessageSvc.debugLimit = 20000000
+MessageSvc.infoLimit = 20000000
+
+# Add Trigger Decision Tool
+from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool
+tdt = Trig__TrigDecisionTool( "TrigDecisionTool" )
+tdt.TrigDecisionKey='xTrigDecision'
+tdt.Navigation.ReadonlyHolders=True
+ToolSvc+=tdt
+
+try:
+ include ("AthenaMonitoring/DataQualityInit_jobOptions.py")
+except Exception:
+ treatException("Could not load AthenaMonitoring/DataQualityInit_jobOptions.py")
+
+
+
+
+# Call top sequence
+from AthenaCommon.AlgSequence import AlgSequence, AthSequencer
+topSequence = AlgSequence()
+
+
+##################################### GRL Tools ##########################################
+# Good Run List (GRL)
+if doGRL:
+ from RecExConfig.InputFilePeeker import inputFileSummary
+ try:
+ if inputFileSummary['evt_type'][0] == "IS_DATA":
+ from GoodRunsLists.GoodRunsListsConf import *
+ ToolSvc += GoodRunsListSelectorTool()
+ GoodRunsListSelectorTool.GoodRunsListVec = grllist
+ from GoodRunsListsUser.GoodRunsListsUserConf import *
+ seq = AthSequencer("AthFilterSeq")
+ seq += GRLTriggerSelectorAlg('GRLTriggerAlg1')
+ #seq.GRLTriggerAlg1.GoodRunsListArray = ['PHYS_StandardGRL_All_Good_25ns']
+ seq.GRLTriggerAlg1.GoodRunsListArray = [grllist[0].replace('.xml','')]
+ except:
+ print "GRL not available!"
+
+##################################### Mon Tools ##########################################
+
+from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager
+topSequence += AthenaMonManager( "HLTMonManager")
+HLTMonManager = topSequence.HLTMonManager
+################ Mon Tools #################
+#Global HLTMonTool
+from TrigHLTMonitoring.TrigHLTMonitoringConf import HLTMonTool
+HLTMon = HLTMonTool(name = 'HLTMon', histoPathBase = "HLT");
+ToolSvc += HLTMon;
+HLTMonManager.AthenaMonTools += [ "HLTMonTool/HLTMon" ];
+
+####################################################################################################
+#Define the base path for all histograms
+
+
+
+basePath = '/HLT/Egamma'
+#Configure the TrigEgammaPlotTool
+from TrigEgammaAnalysisTools.TrigEgammaAnalysisToolsConfig import TrigEgammaNavTPAnalysisTool, TrigEgammaPlotTool, EfficiencyTool, DistTool, ResolutionTool
+from TrigEgammaAnalysisTools.TrigEgammaProbelist import monitoring_mam, monitoring_electron, monitoring_photon
+from TrigEgammaAnalysisTools.TrigEgammaProbelist import probeListLowMidPtSupportingTriggers, probeListHighPtSupportingTriggers
+
+PlotTool = TrigEgammaPlotTool.copy( name="TrigEgammaPlotTool",
+ DirectoryPath=basePath,
+ MaM=monitoring_mam,
+ Efficiency=[],
+ Distribution=[],
+ Resolution=[])
+
+EffTool = EfficiencyTool.copy(name="EfficiencyTool",
+ PlotTool=PlotTool,
+ isEMResultNames=["Tight","Medium","Loose"],
+ LHResultNames=["LHTight","LHMedium","LHLoose"],
+ OutputLevel=0)
+
+
+
+####################################################################################################
+from TrigEgammaEmulationTool.TrigEgammaEmulationToolConfig import TrigEgammaEmulationTool
+from TrigEgammaEmulationTool.TrigEgammaEmulationEFConfig import EgammaEFElectronDefaultEmulator,EgammaEFElectronNoD0Emulator
+from TriggerJobOpts.TriggerFlags import TriggerFlags
+
+# Force this emulation selector path
+TriggerFlags.EgammaSlice.pidVersion.set_Value_and_Lock("ElectronPhotonSelectorTools/trigger/rel21_20170217/")
+TriggerFlags.EgammaSlice.ringerVersion.set_Value_and_Lock("RingerSelectorTools/TrigL2_20170505_v6")
+
+EmulationElectronTool = TrigEgammaEmulationTool.copy( name="TrigEgammaEmulationTool",
+ TriggerList = triggerList,
+ DoL2ElectronFex=True,
+ DoEFCaloPid=False,
+ DoRinger=True,
+ OutputLevel=0)
+
+####################################################################################################
+
+AnalysisTool = TrigEgammaNavTPAnalysisTool( name = "TrigEgammaNavTPAnalysisTool",
+ Analysis='Zee',
+ PlotTool=PlotTool,
+ Tools=[EffTool],
+ OfflineTagSelector='Tight', # 1=tight, 2=medium, 3=loose
+ OfflineProbeSelector='Loose',
+ DefaultProbePid='LHMedium',
+ doEmulation=doEmulation,
+ DetailedHistograms=DetailedHistograms,
+ EmulationTool=EmulationElectronTool,
+ TPTrigger=False,
+ RemoveCrack=False,
+ TagTriggerList=tagList,
+ TriggerList=triggerList,
+ OutputLevel=0)
+
+####################################################################################################
+Tools=['TrigEgammaNavTPAnalysisTool/TrigEgammaNavTPAnalysisTool']
+from TrigEgammaAnalysisTools.TrigEgammaAnalysisToolsConf import TrigEgammaMonTool
+TrigEgammaMonTool = TrigEgammaMonTool( name = "HLTEgammaMon", histoPathBase=basePath, Tools=Tools)
+ToolSvc += TrigEgammaMonTool
+HLTMonManager.AthenaMonTools += [ "TrigEgammaMonTool/HLTEgammaMon" ]
+HLTMonManager.FileKey = "GLOBAL"
+ToolSvc.TrigDecisionTool.Navigation.OutputLevel = WARNING
+####################################################################################################
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/share/testTrigEgammaEventSelectionTool.py b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/share/testTrigEgammaEventSelectionTool.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba72df178c83f6d1e99bf66c96169841bb2868a5
--- /dev/null
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/share/testTrigEgammaEventSelectionTool.py
@@ -0,0 +1,195 @@
+# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+
+# Job options for standalone and Tier0 running of AnalysisTools
+# Authors:
+# Ryan Mackenzie White <ryan.white@cern.ch>
+#
+# Tool and algorithm configuration done using egamma Factories
+# Default configurations found in TrigEgammaAnalysisToolsConfig
+#
+# To run
+# athena -l DEBUG -c "DIR='/afs/cern.ch/work/j/jolopezl/datasets/valid1.147406.PowhegPythia8_AZNLO_Zee.recon.AOD.e3099_s2578_r6220_tid05203475_00'"
+# -c "NOV=50" test_ZeeElectronLowPtSupportingTrigAnalysis.py
+# where NOV is the number of events to run
+
+from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
+from RecExConfig.RecFlags import rec
+from RecExConfig.RecAlgsFlags import recAlgs
+from AthenaCommon.AppMgr import ToolSvc
+import os
+
+doZ=True
+doFakes=True
+
+# Define triggers for tagging
+triggerTags = ['HLT_e24_lhtight_nod0_ivarloose',
+ 'HLT_e26_lhtight_nod0_ivarloose',
+ 'HLT_e28_lhtight_nod0_ivarloose']
+
+triggerList = [
+ # standard monitoring chains
+ 'HLT_e26_lhtight_nod0_ivarloose',
+ 'HLT_e28_lhtight_nod0_ivarloose',
+ 'HLT_e60_lhmedium_nod0_L1EM24VHI',
+ # no ringer chains for pos-commissioning...
+ 'HLT_e26_lhtight_nod0_noringer_ivarloose_L1EM22VHI',
+ 'HLT_e28_lhtight_nod0_noringer_ivarloose', # get real TDT
+ 'HLT_e28_lhtight_nod0_noringer_ivarloose_L1EM24VHI',
+ 'HLT_e60_lhmedium_nod0_noringer_L1EM24VHI',
+ ]
+
+
+
+#print 'Set some variables for job'
+dirtouse = str()
+finallist=[]
+
+if 'FILE' in dir() :
+ finallist.append(FILE)
+
+if 'DIR' in dir() :
+ dirtouse=DIR
+ print 'DIR = ',dirtouse
+ while( dirtouse.endswith('/') ) :
+ dirtouse= dirtouse.rstrip('/')
+ listfiles=os.listdir(dirtouse)
+ for ll in listfiles:
+ finallist.append(dirtouse+'/'+ll)
+
+if 'NOV' in dir():
+ nov=NOV
+else :
+ nov=-1
+
+
+print finallist
+athenaCommonFlags.FilesInput=finallist
+athenaCommonFlags.EvtMax=nov
+rec.readAOD=True
+# switch off detectors
+rec.doForwardDet=False
+rec.doInDet=False
+rec.doCalo=False
+rec.doMuon=False
+rec.doEgamma=False
+rec.doTrigger = True; recAlgs.doTrigger=False # disable trigger (maybe necessary if detectors switched off)
+rec.doMuon=False
+rec.doAOD=False
+rec.doMuonCombined=False
+rec.doWriteAOD=False
+rec.doWriteESD=False
+rec.doDPD=False
+rec.doTruth=False
+
+# autoconfiguration might trigger undesired feature
+rec.doESD.set_Value_and_Lock(False) # uncomment if do not run ESD making algorithms
+rec.doWriteESD.set_Value_and_Lock(False) # uncomment if do not write ESD
+rec.doAOD.set_Value_and_Lock(True) # uncomment if do not run AOD making algorithms
+rec.doWriteAOD.set_Value_and_Lock(False) # uncomment if do not write AOD
+rec.doWriteTAG.set_Value_and_Lock(False) # uncomment if do not write TAG
+
+# main jobOption
+include ("RecExCommon/RecExCommon_topOptions.py")
+MessageSvc.debugLimit = 20000000
+MessageSvc.infoLimit = 20000000
+# TDT
+from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool
+tdt = Trig__TrigDecisionTool( "TrigDecisionTool" )
+tdt.TrigDecisionKey='xTrigDecision'
+tdt.Navigation.ReadonlyHolders=True
+ToolSvc+=tdt
+
+try:
+ include ("AthenaMonitoring/DataQualityInit_jobOptions.py")
+except Exception:
+ treatException("Could not load AthenaMonitoring/DataQualityInit_jobOptions.py")
+
+from AthenaCommon.AlgSequence import AlgSequence
+topSequence = AlgSequence()
+
+from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager
+topSequence += AthenaMonManager( "HLTMonManager")
+HLTMonManager = topSequence.HLTMonManager
+
+################ Mon Tools #################
+#Global HLTMonTool
+
+from TrigHLTMonitoring.TrigHLTMonitoringConf import HLTMonTool
+HLTMon = HLTMonTool(name = 'HLTMon', histoPathBase = "HLT");
+
+ToolSvc += HLTMon;
+HLTMonManager.AthenaMonTools += [ "HLTMonTool/HLTMon" ];
+
+from TrigEgammaAnalysisTools.TrigEgammaAnalysisToolsConfig import TrigEgammaPlotTool, getEventSelectionTool
+#Define the base path for all histograms
+basePath = '/HLT/Physval'
+
+#Configure the TrigEgammaPlotTool
+PlotTool = TrigEgammaPlotTool.copy( name="TrigEgammaPlotTool",
+ DirectoryPath=basePath,
+ #MaM=monitoring_mam,
+ Efficiency=[],
+ Distribution=[],
+ Resolution=[])
+
+TrigEgammaEventSelection = getEventSelectionTool()
+
+####################################################################################################
+
+from TrigEgammaEmulationTool.TrigEgammaEmulationToolConfig import TrigEgammaEmulationTool
+from TrigEgammaEmulationTool.TrigEgammaEmulationEFConfig import EgammaEFElectronDefaultEmulator,EgammaEFElectronNoD0Emulator
+from TriggerJobOpts.TriggerFlags import TriggerFlags
+
+# Force this emulation selector path
+TriggerFlags.EgammaSlice.pidVersion.set_Value_and_Lock("ElectronPhotonSelectorTools/trigger/rel21_20170217/")
+TriggerFlags.EgammaSlice.ringerVersion.set_Value_and_Lock("RingerSelectorTools/TrigL2_20170505_v6")
+
+EmulationElectronTool = TrigEgammaEmulationTool.copy( name="TrigEgammaEmulationTool",
+ TriggerList = triggerList,
+ DoL2ElectronFex=True,
+ DoEFCaloPid=False,
+ DoRinger=True,
+ OutputLevel=0)
+
+####################################################################################################
+
+
+Tool = TrigEgammaEventSelection( name='EventSelection',
+ Analysis='Probes',
+ PlotTool=PlotTool,
+ EmulationTool=EmulationElectronTool,
+ File="",
+ OutputLevel=0,
+ DetailedHistograms=False,
+ isEMResultNames=["Tight","Medium","Loose"],
+ LHResultNames=["LHTight","LHMedium","LHLoose"],
+ ZeeLowerMass=80,
+ ZeeUpperMass=100,
+ OfflineTagSelector='Tight', # 1=tight, 2=medium, 3=loose
+ OfflineProbeSelector='Loose',
+ ForceProbePid=False,
+ OppositeCharge=True,
+ OfflineTagMinEt=25,
+ TagTriggerList=triggerTags,
+ SelectionZ=doZ,
+ SelectionFakes=doFakes,
+ ApplyMinimalTrigger=False,
+ DetailedDataLevel=2,
+ DumpTags=False,
+ TriggerList=triggerList)
+
+Tools=['TrigEgammaEventSelection/EventSelection']
+
+from TrigEgammaAnalysisTools.TrigEgammaAnalysisToolsConf import TrigEgammaMonTool
+TrigEgammaMonTool = TrigEgammaMonTool( name = "HLTEgammaMon",
+ histoPathBase=basePath,
+ Tools=Tools)
+
+ToolSvc += TrigEgammaMonTool
+
+#TrigEgammaMonToolConfig.TrigEgammaMonTool()
+HLTMonManager.AthenaMonTools += [ "TrigEgammaMonTool/HLTEgammaMon" ]
+HLTMonManager.FileKey = "GLOBAL"
+
+
+
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/src/TrigEgammaMonTool.cxx b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/src/TrigEgammaMonTool.cxx
index dd7bd078d5cafd27abcf966fe9f249a9caf90725..84c3551dfebaa04a6d898a422187b459a61147ac 100644
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/src/TrigEgammaMonTool.cxx
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/src/TrigEgammaMonTool.cxx
@@ -27,20 +27,23 @@ TrigEgammaMonTool( const std::string & type, const std::string & name, const IIn
}
TrigEgammaMonTool::~TrigEgammaMonTool(){}
-StatusCode TrigEgammaMonTool::init(){
-
+
+
+StatusCode TrigEgammaMonTool::init(){
return StatusCode::SUCCESS;
}
StatusCode TrigEgammaMonTool::book(){
ATH_MSG_INFO("Initializing " << name() << "...");
- ATH_MSG_INFO("Retrieving tools...");
+ ATH_MSG_INFO("Retrieving tools..." << m_asgToolNames.size());
for(const auto toolname : m_asgToolNames){
+ ATH_MSG_INFO("Add "<<toolname<<"..." );
m_asgtools.push_back(ToolHandle<ITrigEgammaAnalysisBaseTool>(toolname));
}
for ( ToolHandleArray<ITrigEgammaAnalysisBaseTool>::const_iterator itoo=m_asgtools.begin();
itoo!=m_asgtools.end(); ++itoo ) {
+ ATH_MSG_INFO("Initializing..." );
ToolHandle<ITrigEgammaAnalysisBaseTool> htool = *itoo;
htool->setParent(this);
StatusCode sc = htool->initialize();
@@ -56,8 +59,6 @@ StatusCode TrigEgammaMonTool::book(){
}
ATH_MSG_INFO("Tool retrieval completed.");
-
-
return StatusCode::SUCCESS;
}
diff --git a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/src/components/TrigEgammaAnalysisTools_entries.cxx b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/src/components/TrigEgammaAnalysisTools_entries.cxx
index 77b8a9677f6efc5eeab05dc99eb9e46bd6699c90..9facf0a35fafc63e7a0002d0f270795aacfbb8bc 100644
--- a/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/src/components/TrigEgammaAnalysisTools_entries.cxx
+++ b/Trigger/TrigAnalysis/TrigEgammaAnalysisTools/src/components/TrigEgammaAnalysisTools_entries.cxx
@@ -5,28 +5,25 @@
#include "TrigEgammaAnalysisTools/TrigEgammaNavAnalysisTool.h"
#include "TrigEgammaAnalysisTools/TrigEgammaNavTPBaseTool.h"
#include "TrigEgammaAnalysisTools/TrigEgammaNavTPAnalysisTool.h"
-#include "TrigEgammaAnalysisTools/TrigEgammaNavNtuple.h"
-#include "TrigEgammaAnalysisTools/TrigEgammaNavTPNtuple.h"
#include "TrigEgammaAnalysisTools/EfficiencyTool.h"
#include "TrigEgammaAnalysisTools/TrigEgammaResolutionTool.h"
#include "TrigEgammaAnalysisTools/TrigEgammaDistTool.h"
#include "TrigEgammaAnalysisTools/TrigEgammaPlotTool.h"
+#include "TrigEgammaAnalysisTools/TrigEgammaEventSelection.h"
#include "../TrigEgammaAnalysisAlg.h"
#include "../TrigEgammaTDToolTest.h"
-DECLARE_COMPONENT( TrigEgammaAnalysisBaseTool )
-DECLARE_COMPONENT( TrigEgammaMonTool )
-DECLARE_COMPONENT( TrigEgammaPhysValMonTool )
-DECLARE_COMPONENT( TrigEgammaNavTPBaseTool )
-DECLARE_COMPONENT( TrigEgammaNavTPNtuple )
-DECLARE_COMPONENT( TrigEgammaNavAnalysisTool )
-DECLARE_COMPONENT( TrigEgammaNavTPAnalysisTool )
-DECLARE_COMPONENT( TrigEgammaNavNtuple )
-DECLARE_COMPONENT( EfficiencyTool )
-DECLARE_COMPONENT( TrigEgammaResolutionTool )
-DECLARE_COMPONENT( TrigEgammaDistTool )
-DECLARE_COMPONENT( TrigEgammaPlotTool )
-DECLARE_COMPONENT( TrigEgammaAnalysisAlg )
-DECLARE_COMPONENT( TrigEgammaTDToolTest )
-
+DECLARE_COMPONENT(TrigEgammaAnalysisBaseTool)
+DECLARE_COMPONENT(TrigEgammaMonTool)
+DECLARE_COMPONENT(TrigEgammaPhysValMonTool)
+DECLARE_COMPONENT(TrigEgammaNavTPBaseTool)
+DECLARE_COMPONENT(TrigEgammaNavAnalysisTool)
+DECLARE_COMPONENT(TrigEgammaNavTPAnalysisTool)
+DECLARE_COMPONENT(EfficiencyTool)
+DECLARE_COMPONENT(TrigEgammaResolutionTool)
+DECLARE_COMPONENT(TrigEgammaDistTool)
+DECLARE_COMPONENT(TrigEgammaPlotTool)
+DECLARE_COMPONENT(TrigEgammaEventSelection)
+DECLARE_COMPONENT(TrigEgammaAnalysisAlg)
+DECLARE_COMPONENT(TrigEgammaTDToolTest)