TrigEDMChecker.cxx File Reference

#include "GaudiKernel/IToolSvc.h"
#include "AnalysisTriggerEvent/LVL1_ROI.h"
#include "AnalysisTriggerEvent/EmTau_ROI.h"
#include "AnalysisTriggerEvent/EnergySum_ROI.h"
#include "AnalysisTriggerEvent/Jet_ROI.h"
#include "xAODTrigger/TrigPassBitsContainer.h"
#include "xAODTrigger/TrigPassBits.h"
#include "xAODTrigger/TriggerMenuContainer.h"
#include "TrigNavStructure/TriggerElement.h"
#include "TrigConfHLTUtils/HLTUtils.h"
#include "AthContainers/debug.h"
#include "CxxUtils/checker_macros.h"
#include "xAODJet/JetContainer.h"
#include "xAODJet/JetConstituentVector.h"
#include "xAODTrigMissingET/TrigMissingETAuxContainer.h"
#include "xAODTrigMissingET/TrigMissingETContainer.h"
#include "TrigMissingEtEvent/TrigMissingETContainer.h"
#include "TrigMuonEvent/MuonFeature.h"
#include "TrigMuonEvent/TrigMuonEFInfoTrackContainer.h"
#include "TrigMuonEvent/TrigMuonEFInfoTrack.h"
#include "TrigMuonEvent/TrigMuonEFIsolationContainer.h"
#include "TrigMuonEvent/CombinedMuonFeatureContainer.h"
#include "TrigMuonEvent/TileMuFeatureContainer.h"
#include "TrigMuonEvent/TileTrackMuFeatureContainer.h"
#include "TrigParticle/TrigPhotonContainer.h"
#include "xAODTrigBphys/TrigBphysContainer.h"
#include "xAODTrigBphys/TrigBphys.h"
#include "TrigParticle/TrigEFBjetContainer.h"
#include "TrigParticle/TrigL2BjetContainer.h"
#include "TrigMuonEvent/TrigMuonEFContainer.h"
#include "TrigMuonEvent/TrigMuonEFInfoContainer.h"
#include "TrigMuonEvent/TrigMuonEFInfo.h"
#include "TrigMuonEvent/TrigMuonEFTrack.h"
#include "TrigMuonEvent/TrigMuonEFCbTrack.h"
#include "TrigParticle/TrigElectronContainer.h"
#include "TrigParticle/TrigTauContainer.h"
#include "TrigSteeringEvent/HLTResult.h"
#include "TrigInDetEvent/TrigInDetTrackCollection.h"
#include "TrigInDetTruthEvent/TrigInDetTrackTruthMap.h"
#include "TrigInDetEvent/TrigTauTracksInfo.h"
#include "TrigInDetEvent/TrigVertexCollection.h"
#include "TrigCaloEvent/TrigEMCluster.h"
#include "TrigCaloEvent/TrigEMClusterContainer.h"
#include "TrigCaloEvent/TrigTauClusterContainer.h"
#include "Particle/TrackParticleContainer.h"
#include "tauEvent/TauJetContainer.h"
#include "tauEvent/TauJet.h"
#include "xAODMuon/MuonContainer.h"
#include "xAODTracking/TrackParticleContainer.h"
#include "xAODTracking/VertexContainer.h"
#include "xAODTrigEgamma/TrigElectronContainer.h"
#include "xAODTrigEgamma/TrigElectron.h"
#include "xAODTrigEgamma/TrigPhotonContainer.h"
#include "xAODTrigEgamma/TrigPhoton.h"
#include "xAODTrigCalo/TrigEMCluster.h"
#include "xAODTrigCalo/TrigEMClusterContainer.h"
#include "xAODEgamma/ElectronContainer.h"
#include "xAODEgamma/Electron.h"
#include "xAODEgamma/PhotonContainer.h"
#include "xAODEgamma/Photon.h"
#include "xAODTau/TauJetContainer.h"
#include "xAODTau/TauJetAuxContainer.h"
#include "xAODTau/TauDefs.h"
#include "xAODTau/TauJet.h"
#include "TrigEDMChecker.h"
#include "xAODTrigMinBias/TrigSpacePointCountsContainer.h"
#include "xAODTrigMinBias/TrigSpacePointCounts.h"
#include "xAODTrigMinBias/TrigT2MbtsBitsContainer.h"
#include "xAODTrigMinBias/TrigT2MbtsBits.h"
#include "xAODTrigMinBias/TrigVertexCountsContainer.h"
#include "xAODTrigMinBias/TrigVertexCounts.h"
#include "xAODTrigMinBias/TrigTrackCountsContainer.h"
#include "xAODTrigMinBias/TrigTrackCounts.h"
#include "TrigSteeringEvent/TrigRoiDescriptor.h"
#include "TrigRoiConversion/RoiSerialise.h"
#include "xAODTrigger/RoiDescriptorStore.h"
#include "TrigT1Interfaces/RecEmTauRoI.h"
#include "AthViews/ViewHelper.h"
#include "AthViews/View.h"
#include "CxxUtils/starts_with.h"
#include <iostream>
#include <fstream>
#include <queue>

Go to the source code of this file.

Functions
StatusCode TrigEDMChecker::do_execute	ATLAS_NOT_THREAD_SAFE ()
	Install fatal handler with default options. More...

Function Documentation

ATLAS_NOT_THREAD_SAFE()

StatusCode TrigEDMChecker::do_execute ATLAS_NOT_THREAD_SAFE ( )

inline

Install fatal handler with default options.

This is meant to be easy to call from python via ctypes.

Install fatal handler with default options.

getLorentzAngle() Read LorentzAngle from HIST and write out into local DB

getBSErrors() Read BSErrors from Monitoring HIST and write out into local DB

getEfficiency() Read Efficiency from Monitoring HIST and write out into local DB

getRawOccupancy() Read RawOccupancy from Monitoring HIST and write out into local DB

getNoiseOccupancy() Read NoiseOccupancy from HIST and write out into local DB

getNoisyStrip() Find noisy strips from hitmaps and write out into xml/db formats

Install fatal handler with default options.

called at the end of each athena event (can be used for eg.

called at the beginning of each athena event (can be used for eg.

return the simulation service ID

resetting dynamic selectors)

>= 14.2.10 /// -------------------------—

up to 14.2.0 /// -------------------------—

Definition at line 260 of file TrigEDMChecker.cxx.

                                                            {
 
  ATH_MSG_INFO( " ==========START of event===========" );
 
    if(m_doDumpTrackParticleContainer){
        StatusCode sc = dumpTrackParticleContainer();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpTrackParticleContainer() failed");
        }
    }
 
    if(m_doDumpAll || m_doDumpLVL1_ROI ){
        StatusCode sc = dumpLVL1_ROI();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpLVL1_ROI() failed");
        }
    }
 
    /*
    if(m_doDumpAll || m_doDumpTrigMissingET){
        StatusCode sc = dumpTrigMissingET();
        if (sc.isFailure()) {
            mLog << MSG::ERROR << "The method dumpTrigMissingET() failed" << endmsg;
 
        }
    }
    */
 
    if(m_doDumpAll || m_doDumpxAODTrigMissingET){
        StatusCode sc = dumpxAODTrigMissingET();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpxAODTrigMissingET() failed");
        }
    }
 
    if(m_doDumpAll || m_doDumpMuonFeature){
        StatusCode sc = dumpMuonFeature();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpMuonFeature() failed");
        }
    }
 
    if(m_doDumpAll || m_doDumpCombinedMuonFeature){
        StatusCode sc = dumpCombinedMuonFeature();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpCombinedMuonFeature() failed");
        }
        sc = dumpCombinedMuonFeatureContainer();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpCombinedMuonFeatureContainer() failed");
          return StatusCode::SUCCESS;
        }
    }
 
    if(m_doDumpAll || m_doDumpTileMuFeature) {
        StatusCode sc = dumpTileMuFeatureContainer();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpTileMuFeatureContainer() failed");          
        }
    }
 
    if(m_doDumpAll || m_doDumpTileTrackMuFeature) {
        StatusCode sc = dumpTileTrackMuFeatureContainer();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpTileTrackMuFeatureContainer() failed");
        }
    }
 
    if(m_doDumpAll || m_doDumpTrigEMCluster){
        StatusCode sc = dumpTrigEMCluster();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpTrigEMCluster() failed");
        }
    }
 
    if(m_doDumpAll || m_doDumpTrigEMClusterContainer){
        StatusCode sc = dumpTrigEMClusterContainer();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpTrigEMClusterContainer() failed");          
        }
    }
 
    if(m_doDumpAll || m_doDumpxAODTrigEMCluster){
      StatusCode sc = dumpxAODTrigEMCluster();
      if (sc.isFailure()) {
        ATH_MSG_ERROR("The method dumpxAODTrigEMCluster() failed");
      }
    }
 
    if(m_doDumpAll || m_doDumpxAODTrigEMClusterContainer){
      StatusCode sc = dumpxAODTrigEMClusterContainer();
      if (sc.isFailure()) {
        ATH_MSG_ERROR("The method dumpxAODTrigEMClusterContainer() failed");
      }
    }
 
    if(m_doDumpTrigTauClusterContainer){
        StatusCode sc = dumpTrigTauClusterContainer();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpTrigTauClusterContainer() failed");
        }
    }
 
    if(m_doDumpAll || m_doDumpTrigPhotonContainer){
        StatusCode sc = dumpTrigPhotonContainer();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpTrigPhotonContainer() failed");
        }
    }
 
    if(m_doDumpAll || m_doDumpxAODJetContainer){
        StatusCode sc = dumpxAODJetContainer();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpxAODJetContainer() failed");          
        }
    }
 
    if(m_doDumpAll || m_doDumpTrigL2BphysContainer){
        StatusCode sc = dumpTrigL2BphysContainer();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpTrigL2BphysContainer() failed");
        }
    }
 
    if(m_doDumpAll || m_doDumpTrigEFBphysContainer){
        StatusCode sc = dumpTrigEFBphysContainer();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpTrigEFBphysContainer() failed");
        }
    }
 
    if(m_doDumpAll || m_doDumpTrigEFBjetContainer){
        StatusCode sc = dumpTrigEFBjetContainer();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpTrigEFBjetContainer() failed");
        }
    }
 
    if(m_doDumpAll || m_doDumpTrigL2BjetContainer){
        StatusCode sc = dumpTrigL2BjetContainer();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpTrigL2BjetContainer() failed");
        }
    }
 
    if(m_doDumpAll || m_doDumpTrigMuonEFContainer){
        StatusCode sc = dumpTrigMuonEFContainer();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpTrigMuonEFContainer() failed");
        }
    }
 
    if(m_doDumpAll || m_doDumpTrigMuonEFInfoContainer){
        StatusCode sc = dumpTrigMuonEFInfoContainer();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpTrigMuonEFInfoContainer() failed");          
        }
    }
 
    if(m_doDumpAll || m_doDumpTrigMuonEFIsolationContainer) {
      StatusCode sc = dumpTrigMuonEFIsolationContainer();
      if(sc.isFailure()) {
        ATH_MSG_ERROR("The method dumpTrigMuonEFIsolationContainer() failed");
      }
    }
 
    if(m_doDumpAll || m_doDumpxAODMuonContainer) {
      StatusCode sc = dumpxAODMuonContainer();
      if(sc.isFailure()) {
        ATH_MSG_ERROR("The method dumpxAODMuonContainer() failed");
      }
    }
 
    if(m_doDumpAll || m_doDumpTrigElectronContainer){
        StatusCode sc = dumpTrigElectronContainer();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpTrigElectronContainer() failed");
        }
    }
 
    if(m_doDumpAll || m_doDumpxAODTrigElectronContainer){
        StatusCode sc = dumpxAODTrigElectronContainer();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpxAODTrigElectronContainer() failed");
        }
    }
 
    if(m_doDumpAll || m_doDumpxAODTrigPhotonContainer){
        StatusCode sc = dumpxAODTrigPhotonContainer();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpxAODTrigElectronContainer() failed");
        }
    }
 
    if(m_doDumpAll || m_doDumpxAODElectronContainer){
      StatusCode sc = dumpxAODElectronContainer();
      if (sc.isFailure()) {
        ATH_MSG_ERROR("The method dumpxAODTrigElectronContainer() failed");
      }
    }
 
    if(m_doDumpAll || m_doDumpxAODPhotonContainer){
      StatusCode sc = dumpxAODPhotonContainer();
      if (sc.isFailure()) {
        ATH_MSG_ERROR("The method dumpxAODTrigElectronContainer() failed");        
      }
    }
 
    if(m_doDumpTrigTauContainer){
      StatusCode sc = dumpTrigTauContainer();
      if (sc.isFailure()) {
        ATH_MSG_ERROR("The method dumpTrigTauContainer() failed");
      }
    }
 
    if(m_doDumpTrigTauTracksInfo){
        StatusCode sc = dumpTrigTauTracksInfo();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpTrigTauTracksInfo() failed");
        }
    }
 
    if(m_doDumpAll || m_doDumpHLTResult){
        StatusCode sc = dumpHLTResult();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpHLTResult() failed");
        }
    }
 
    if(m_doDumpTrigInDetTrackCollection){
        StatusCode sc = dumpTrigInDetTrackCollection();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpTrigInDetTrackCollection() failed");
        }
    }
 
    if(m_doDumpAll || m_doDumpTrigVertexCollection){
      StatusCode sc = dumpTrigVertexCollection();
      if (sc.isFailure()) {
        ATH_MSG_ERROR("The method dumpTrigVertexCollection() failed");
      }
    }
 
    if(m_doDumpAll || m_doDumpxAODTauJetContainer){
      StatusCode sc = dumpxAODTauJetContainer();
      if (sc.isFailure()) {
        ATH_MSG_ERROR("The method dumpxAODTauJetContainer() failed");
      }
    }
 
    if(m_doDumpTauJetContainer){
        StatusCode sc = dumpTauJetContainer();
        if (sc.isFailure()) {
          ATH_MSG_ERROR("The method dumpTauJetContainer() failed");
        }
    }
 
    if(m_doDumpAll || m_doDumpxAODTrackParticle){
      StatusCode sc = dumpxAODTrackParticle();
      if (sc.isFailure()) {
        ATH_MSG_ERROR("The method dumpxAODTrackParticle() failed");      
      }
    }
 
    if(m_doDumpAll || m_doDumpxAODVertex){
      StatusCode sc = dumpxAODVertex();
      if (sc.isFailure()) {
        ATH_MSG_ERROR("The method dumpxAODVertex() failed");
      }
    }
 
    if (m_doDumpAll || m_doDumpxAODTrigMinBias){
      StatusCode sc = dumpxAODTrigMinBias();
      if (sc.isFailure()) {
        ATH_MSG_ERROR("The method dumpxAODTrigMinBias() failed");
      }
    }
 
    if (m_doDumpTrigPassBits){
      StatusCode sc = dumpTrigPassBits();
      if (sc.isFailure()) {
        ATH_MSG_ERROR("The method dumpTrigPassBits() failed");
      }      
    }
    
  if (m_doDumpAll || m_doDumpStoreGate) {
    ATH_MSG_DEBUG(evtStore()->dump());
  }
 
  if (m_doDumpAll || m_doDumpNavigation) {
    StatusCode sc = dumpNavigation();
    if ( sc.isFailure() ) {
      ATH_MSG_ERROR("The method dumpNavigation() failed");
    }
  }
 
  if (m_doDumpAll || m_doTDTCheck) {
    ATH_CHECK(dumpTDT());
  }
 
  if (m_doDumpAll || m_doDumpAllTrigComposite || m_dumpTrigCompositeContainers.size() > 0) {
    ATH_CHECK( dumpTrigComposite() );
  }
 
  if (m_doDumpAll || m_doDumpTrigCompsiteNavigation) {
    std::string trigCompositeSteering;
    bool pass;
    ATH_CHECK(TrigCompositeNavigationToDot(trigCompositeSteering, pass));
    const EventContext& context = Gaudi::Hive::currentContext();
    const std::string evtNumber = std::to_string(context.eventID().event_number());
    const std::string passStr = (pass ? "Pass" : "Fail"); 
    std::ofstream ofile(std::string("NavGraph_" + m_dumpNavForChain + "_Ev" + evtNumber + "_" + passStr + ".dot").c_str());
    ofile << trigCompositeSteering;
  }
 
 
 
  ATH_MSG_INFO( " ==========END of event===========" );
    return StatusCode::SUCCESS;
 
}