DerivationFramework::TriggerTowerThinningAlg Class Reference

#include <TriggerTowerThinningAlg.h>

Inheritance diagram for DerivationFramework::TriggerTowerThinningAlg:

Collaboration diagram for DerivationFramework::TriggerTowerThinningAlg:

Public Member Functions
	TriggerTowerThinningAlg (const std::string &t, const std::string &n, const IInterface *p)
virtual	~TriggerTowerThinningAlg ()
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual StatusCode	doThinning () const override

Private Attributes
StringProperty	m_streamName { this, "StreamName", "", "Name of the stream being thinned" }
SG::ThinningHandleKey< xAOD::TriggerTowerContainer >	m_triggerTowerLocation { this, "TriggerTowerLocation", LVL1::TrigT1CaloDefs::xAODTriggerTowerLocation, "" }
SG::ReadDecorHandleKey< xAOD::TriggerTowerContainer >	m_caloCellETByLayerKey { this, "CaloCellETByLayerKey", m_triggerTowerLocation.key()+".CaloCellETByLayer", "" }
double	m_minCaloCellET
int	m_minADC
bool	m_useRandom
double	m_minRandom
std::atomic< unsigned long >	m_nEventsProcessed
std::atomic< unsigned long >	m_nEventsAllTriggerTowersKeptByRandom
std::atomic< unsigned long >	m_nTriggerTowersProcessed
std::atomic< unsigned long >	m_nTriggerTowersKept
std::atomic< unsigned long >	m_nTriggerTowersRejected
ServiceHandle< IAthRNGSvc >	m_rndmSvc { this, "RndmSvc", "AthRNGSvc", "" }

Detailed Description

Definition at line 41 of file TriggerTowerThinningAlg.h.

Constructor & Destructor Documentation

TriggerTowerThinningAlg()

TriggerTowerThinningAlg::TriggerTowerThinningAlg	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

Definition at line 34 of file TriggerTowerThinningAlg.cxx.

                                                                                                              :
    base_class(t,n,p),
    m_minCaloCellET(0.4),
    m_minADC(32),
    m_useRandom(false),
    m_minRandom(0.03),
    m_nEventsProcessed(0),
    m_nEventsAllTriggerTowersKeptByRandom(0),
    m_nTriggerTowersProcessed(0),
    m_nTriggerTowersKept(0),
    m_nTriggerTowersRejected(0)
  {
    declareProperty("MinCaloCellET",m_minCaloCellET);
    declareProperty("MinADC",m_minADC);
    declareProperty("UseRandom",m_useRandom);
    declareProperty("MinRandom",m_minRandom);
  }

~TriggerTowerThinningAlg()

TriggerTowerThinningAlg::~TriggerTowerThinningAlg ( )

virtual

Definition at line 52 of file TriggerTowerThinningAlg.cxx.

  {
  }

Member Function Documentation

doThinning()

StatusCode TriggerTowerThinningAlg::doThinning ( ) const

overridevirtual

Definition at line 67 of file TriggerTowerThinningAlg.cxx.

                                                      {
    const EventContext& ctx = Gaudi::Hive::currentContext();
 
    // Create the mask to be used for thinning
    std::vector<bool> mask;
 
    // Counters
    unsigned long nKeep(0),nReject(0),nTotal(0);
    ++m_nEventsProcessed;
    
    SG::ThinningHandle<xAOD::TriggerTowerContainer> tts
      (m_triggerTowerLocation, ctx);
    
    mask.assign(tts->size(),false); // default: don't keep any clusters
    
    // Should we save the trigger tower or not???
    // If this is calibration data, then yes - save the lot
    // Randomly save all trigger towers m_minRandom % of the time.
    //
    // If this is collisions data then only save if:
    // 1.) Any ADC value is greater than m_minADC  OR
    // 2.) The CaloCell ET is greater than m_minCaloCellET
 
    bool globalSaveMe(false);
    // Random number save all
    if(m_useRandom == true){
      if(globalSaveMe == false){
        ATHRNG::RNGWrapper* wrapper = m_rndmSvc->getEngine (this);
        wrapper->setSeed (this->name(), ctx);
        CLHEP::HepRandomEngine* engine = wrapper->getEngine (ctx);
        if (CLHEP::RandFlat::shoot (engine) < m_minRandom) {
          globalSaveMe = true;
          m_nEventsAllTriggerTowersKeptByRandom++;
        }
      }
    }
 
    SG::ReadDecorHandle<xAOD::TriggerTowerContainer, std::vector<float> > caloCellETByLayerHandle(m_caloCellETByLayerKey, ctx);
    bool isDecorAvailable = caloCellETByLayerHandle.isAvailable();
 
    // Iterate over all trigger towers
    for(auto tt : *tts){
 
      bool saveMe(false);
      if(globalSaveMe == true){saveMe = true;}
      
      // Test for Calo ET
      if(saveMe == false){
    if (isDecorAvailable) {
      const std::vector<float>& caloCellETByLayer = caloCellETByLayerHandle(*tt);
 
          float totalCaloCellET(0.);
          for (float c : caloCellETByLayer) {
            totalCaloCellET += c;
          }
          if (totalCaloCellET > m_minCaloCellET) {
            saveMe = true;
          }
        }
      }
      
 
      // Test for ADC values
      if (saveMe == false) {
        const std::vector<uint16_t>& ttADC = tt->adc();
        for (uint16_t i : ttADC) {
          if ( i > m_minADC) {
            saveMe = true;
            break;
          }
        }
      }
 
      // assign result to mask
      mask[nTotal] = saveMe;
      
      ++nTotal;
    } // End loop over trigger towers
 
 
    tts.keep (mask);
 
    // Counters
    m_nTriggerTowersProcessed += nTotal;
    // FIXME: nKeep is always 0
    m_nTriggerTowersKept += nKeep;
    m_nTriggerTowersRejected += nReject;
 
    ATH_MSG_DEBUG(" L1Calo Trigger Tower Thinning statistics: keeping " << nKeep << " cells"
          << " and rejecting " << nReject << " cells");
 
 
    return StatusCode::SUCCESS;
  }

finalize()

StatusCode TriggerTowerThinningAlg::finalize ( )

overridevirtual

Definition at line 162 of file TriggerTowerThinningAlg.cxx.

                                              {
 
        ATH_MSG_INFO(
          "==> finalize " << name() << "...\n"
          << "***************************************************************\n"
          << "Results of " << name() << " thinning algorithm:\n"
          << "-------------");
        ATH_MSG_INFO(" Number of processed events:  " << m_nEventsProcessed);
 
        if(m_nTriggerTowersProcessed > 0) { 
          ATH_MSG_INFO(
            " Average percent of Trigger Towers kept = "
            << 100.0 * m_nTriggerTowersKept / (double)m_nTriggerTowersProcessed << " %");
        }
        if(m_useRandom == true && m_nEventsProcessed > 0){
          ATH_MSG_INFO(
            " Percentage of events where all Trigger Towers were kept (should be approx "<< 100.0*m_minRandom << ") = "
            << 100.0 * m_nEventsAllTriggerTowersKeptByRandom / (double)m_nEventsProcessed);
        }
      
 
    return StatusCode::SUCCESS;
  }

initialize()

StatusCode TriggerTowerThinningAlg::initialize ( )

overridevirtual

Definition at line 56 of file TriggerTowerThinningAlg.cxx.

                                                {
    ATH_MSG_INFO("L1Calo TriggerTowerThinningAlg::initialize()");
 
    ATH_CHECK( m_triggerTowerLocation.initialize (m_streamName) );
    ATH_CHECK( m_caloCellETByLayerKey.initialize(SG::AllowEmpty) );
 
    ATH_CHECK( m_rndmSvc.retrieve() );
 
    return StatusCode::SUCCESS;
  }

Member Data Documentation

m_caloCellETByLayerKey

SG::ReadDecorHandleKey<xAOD::TriggerTowerContainer> DerivationFramework::TriggerTowerThinningAlg::m_caloCellETByLayerKey { this, "CaloCellETByLayerKey", m_triggerTowerLocation.key()+".CaloCellETByLayer", "" }

private

Definition at line 58 of file TriggerTowerThinningAlg.h.

m_minADC

int DerivationFramework::TriggerTowerThinningAlg::m_minADC

private

Definition at line 63 of file TriggerTowerThinningAlg.h.

m_minCaloCellET

double DerivationFramework::TriggerTowerThinningAlg::m_minCaloCellET

private

Definition at line 62 of file TriggerTowerThinningAlg.h.

m_minRandom

double DerivationFramework::TriggerTowerThinningAlg::m_minRandom

private

Definition at line 65 of file TriggerTowerThinningAlg.h.

m_nEventsAllTriggerTowersKeptByRandom

std::atomic<unsigned long> DerivationFramework::TriggerTowerThinningAlg::m_nEventsAllTriggerTowersKeptByRandom

mutableprivate

Definition at line 69 of file TriggerTowerThinningAlg.h.

m_nEventsProcessed

std::atomic<unsigned long> DerivationFramework::TriggerTowerThinningAlg::m_nEventsProcessed

mutableprivate

Definition at line 68 of file TriggerTowerThinningAlg.h.

m_nTriggerTowersKept

std::atomic<unsigned long> DerivationFramework::TriggerTowerThinningAlg::m_nTriggerTowersKept

mutableprivate

Definition at line 71 of file TriggerTowerThinningAlg.h.

m_nTriggerTowersProcessed

std::atomic<unsigned long> DerivationFramework::TriggerTowerThinningAlg::m_nTriggerTowersProcessed

mutableprivate

Definition at line 70 of file TriggerTowerThinningAlg.h.

m_nTriggerTowersRejected

std::atomic<unsigned long> DerivationFramework::TriggerTowerThinningAlg::m_nTriggerTowersRejected

mutableprivate

Definition at line 72 of file TriggerTowerThinningAlg.h.

m_rndmSvc

ServiceHandle<IAthRNGSvc> DerivationFramework::TriggerTowerThinningAlg::m_rndmSvc { this, "RndmSvc", "AthRNGSvc", "" }

private

Definition at line 75 of file TriggerTowerThinningAlg.h.

m_streamName

StringProperty DerivationFramework::TriggerTowerThinningAlg::m_streamName { this, "StreamName", "", "Name of the stream being thinned" }

private

Definition at line 52 of file TriggerTowerThinningAlg.h.

m_triggerTowerLocation

SG::ThinningHandleKey<xAOD::TriggerTowerContainer> DerivationFramework::TriggerTowerThinningAlg::m_triggerTowerLocation { this, "TriggerTowerLocation", LVL1::TrigT1CaloDefs::xAODTriggerTowerLocation, "" }

private

Definition at line 55 of file TriggerTowerThinningAlg.h.

m_useRandom

bool DerivationFramework::TriggerTowerThinningAlg::m_useRandom

private

Definition at line 64 of file TriggerTowerThinningAlg.h.

---

The documentation for this class was generated from the following files:

• TriggerTowerThinningAlg.h
• TriggerTowerThinningAlg.cxx