In This Package:

TsFilterTool.cc

Go to the documentation of this file.

#include "TsFilterTool.h"

#include "Conventions/Site.h"
#include "Conventions/Trigger.h"

#include "Event/ElecCrateHeader.h"
#include "Event/ElecFeeCrate.h"

#include "Event/SimTrigCommand.h"
#include "Event/SimTrigCommandHeader.h"
#include "Event/SimTrigCommandCollection.h"
#include "CLHEP/Units/SystemOfUnits.h"

TsFilterTool::TsFilterTool(const std::string& type,
                                             const std::string& name, 
                                             const IInterface* parent)
    : GaudiTool(type,name,parent)
{
  declareInterface< ITsTriggerTool >(this) ;
  declareProperty("RecoveryTime",m_recoveryCycles=24,
                  "Number of nhit (80MHz) clock cycles for trigger dead time");
  declareProperty("ApplyFilter",m_active=false,
                  "If set to true the tool will filter trigger commands.");
}

TsFilterTool::~TsFilterTool(){}

StatusCode TsFilterTool::initialize()
{
  debug() << "Initializing TsFilterTool" << endreq;
  return StatusCode::SUCCESS;
}

StatusCode TsFilterTool::finalize()
{
  debug() << "Finalizing TsFilterTool" << endreq;
  return StatusCode::SUCCESS;
}

StatusCode TsFilterTool::mutate(DayaBay::SimTrigHeader* trigHeader,
                                         const DayaBay::ElecHeader& elecHeader)
{     
  if ( !m_active ){
      debug() << "TsFilterTool is not active, so doing nothing" << endreq;
      return StatusCode::SUCCESS;
  }
  
  debug() << "running mutate()" << endreq;
  const DayaBay::SimTrigCommandHeader *tch = trigHeader->commandHeader();
  const DayaBay::SimTrigCommandHeader::detCollMap trigCollMap 
                                                          = tch->collections();
  DayaBay::SimTrigCommandHeader::detCollMap::const_iterator trigIt;  
  //Loop over All trigger Collections
  for(trigIt  = trigCollMap.begin(); trigIt != trigCollMap.end(); ++trigIt)
  {
    DayaBay::Detector det(trigIt->first);
    debug() << "found " << (trigIt->second)->commands().size()
              << " commands for " << det.detName() << endreq;

    DayaBay::SimTrigCommandCollection *triggerColl = 
               const_cast<DayaBay::SimTrigCommandCollection*>(trigIt->second);

    // sort the trigger commands by clock cycle
    triggerColl->sort();

    DayaBay::SimTrigCommandCollection::CommandContainer& detTriggers = 
        const_cast<DayaBay::SimTrigCommandCollection::CommandContainer&>(triggerColl->commands());

    DayaBay::SimTrigCommandCollection::CommandContainer::iterator tcIt;
    // Loop over all triggers in each collection
    int prevCycle=-1;
    for(tcIt=detTriggers.begin();tcIt!=detTriggers.end();/*in loop*/){
         verbose() << "Trigger: " << **tcIt << endreq;
         int thiscycle = (*tcIt)->clockCycle();
         if(thiscycle == prevCycle){// combined triggers at same clock cycle
             verbose() << "Combining trigger with the previous one" 
                       << **tcIt << endreq;
             
             // combine the triggers
             DayaBay::Trigger::TriggerType_t type = (*tcIt)->type();
             tcIt = detTriggers.erase(tcIt); // returns next element
             --tcIt; // go back to previous one.
             int newtype = (int) (type | (*tcIt)->type()); // update its type
             (*tcIt)->setType( (DayaBay::Trigger::TriggerType_t) newtype );
             ++tcIt; // go to command for next pass through for loop
             
         }else if ((unsigned int) (thiscycle-prevCycle) < m_recoveryCycles ){
         
             // remove triggers within "recovery time"
             verbose() << "Removing trigger that occured during recovery window " 
                       << **tcIt << endreq;
             tcIt = detTriggers.erase(tcIt); // returns next element
         
         }else{ // leave this one as it is
         
             prevCycle=thiscycle;
             ++tcIt;
         }
    }
    verbose() << "Done Filtering. " << *triggerColl << endreq;
  }

  return StatusCode::SUCCESS;                               
}

---