ROsTriggerDataPackerTool.cc

Go to the documentation of this file.

#include "ROsTriggerDataPackerTool.h"

#include "Conventions/Electronics.h"
#include "Event/SimTrigCommand.h"
#include "Event/SimRpcTrigCommand.h"
#include "Event/SimTrigCommandHeader.h"
#include "Event/SimTrigCommandCollection.h"
#include "Event/ReadoutTriggerDataPkg.h"
#include "Event/ReadoutTriggerDataFrame.h"

#include "CLHEP/Units/SystemOfUnits.h"

#include <vector>
#include <map>

ROsTriggerDataPackerTool::ROsTriggerDataPackerTool(const std::string& type,
                                     const std::string& name,
                                     const IInterface* parent)
  : GaudiTool(type,name,parent)
{
  declareInterface< IROsTriggerDataPackerTool >(this) ;
  declareProperty("RecoveryTime",m_recoveryCycles=12,
                  "Number of (80 MHz) clock cycles for trigger recovery time");
  //declareProperty("ReadoutCycles",m_roCycles,
  //                "Clock Cycles to readout relative to reference");
}

ROsTriggerDataPackerTool::~ROsTriggerDataPackerTool(){}

StatusCode ROsTriggerDataPackerTool::initialize()
{
  debug() << "Initializing Trigger Data Packer" << endreq;
  return StatusCode::SUCCESS;
}

StatusCode ROsTriggerDataPackerTool::finalize()
{
  debug() << "Finalizing Trigger Data Packer" << endreq;
  return StatusCode::SUCCESS;
}

StatusCode ROsTriggerDataPackerTool::fillDataPackages(std::vector<DayaBay::ReadoutTriggerDataPkg*>& dataPkgs,
                                                     const DayaBay::SimTrigHeader& trigHeader)
{
  debug() << "Packing Trigger Data" << endreq;

  const DayaBay::SimTrigCommandHeader *tch = trigHeader.commandHeader();
  const DayaBay::SimTrigCommandHeader::detCollMap trigCollMap = tch->collections();

  DayaBay::SimTrigCommandHeader::detCollMap::const_iterator trigIt;

  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 = trigIt->second ;
    const DayaBay::SimTrigCommandCollection::CommandContainer& detTriggers = triggerColl->commands();
    DayaBay::SimTrigCommandCollection::CommandContainer::const_iterator tcIt;

    DayaBay::ReadoutTriggerDataPkg *tdpkg = 0;
    int prevCycle=0;

    if (!det.isRPC()) { // treat RPC triggers separately
        for(tcIt=detTriggers.begin();tcIt!=detTriggers.end();++tcIt){
             verbose() << "Trigger: " << **tcIt << endreq;
             verbose() << "Creating Trigger Data Frame" << endreq;

             DayaBay::ReadoutTriggerDataFrame *tdf = new DayaBay::ReadoutTriggerDataFrame();
             tdf->setCycle((*tcIt)->clockCycle());
             TimeStamp triggerTime( trigHeader.earliest() );
             triggerTime.Add((*tcIt)->clockCycle() / double(DayaBay::NhitFrequencyHz));
             tdf->setTriggerTime(triggerTime);
             tdf->setTriggerType((*tcIt)->type());
             tdf->setNhit((*tcIt)->nhit());
             tdf->setEsumAdc((*tcIt)->esumAdc());
             tdf->setEsumComp((*tcIt)->esumComp());

             //tdf->setReadoutType();
             //tdf->setCrossSource();
             //tdf->setSeqNumber();

             // done by addFrame() so don't set package here
             // tdf->setPackage()

             int thiscycle = (*tcIt)->clockCycle();
             unsigned int dt = (unsigned int) (thiscycle-prevCycle);
             bool shouldBeMasked =  dt < m_recoveryCycles;

             if ( ! tdpkg || ! shouldBeMasked ){
                 verbose() << "Creating a new trigger data package" << endreq;
                 tdpkg = new DayaBay::ReadoutTriggerDataPkg();
                 tdpkg->setDetector(det);
                 tdpkg->addFrame(tdf);
                 dataPkgs.push_back(tdpkg);
                 prevCycle=thiscycle;
             }else{
                 debug() << "Adding a masked trigger" << endreq;
                 if(!tdpkg){
                     fatal() << "This should never happen!!!\n"
                         << "A trigger frame was produced "
                         << "with not package to put it in"
                         << endreq;
                     return StatusCode::FAILURE;
                 }
                 tdpkg->addFrame(tdf);
             }
        verbose() << "Done Packing Detector " << *tdpkg << endreq;
        }
    } else { // we do RPC stuff
        // Q: is any RPC command masked?
        // A: don't think so
        // Q: how to treat different clock frequencies?
        // A: simply implement it.

        // Loop over trigger commands for RPCs
        for(tcIt=detTriggers.begin();tcIt!=detTriggers.end();++tcIt){
            const DayaBay::SimRpcTrigCommand* rtc = dynamic_cast<const DayaBay::SimRpcTrigCommand*>(*tcIt);
            if (!rtc) {
                return StatusCode::FAILURE;
                // FIXME: treat case when the trigger command is not RPC,
                // but still in the RPC detector. (Which should never happen)
            }

            // Create and fill trigger data frame
            DayaBay::ReadoutRpcTriggerDataFrame *tdf = new DayaBay::ReadoutRpcTriggerDataFrame();
            tdf->setIsRpc(true);
            tdf->setCycle(rtc->clockCycle());

            TimeStamp triggerTime( trigHeader.earliest() );
            triggerTime.Add(rtc->clockCycle() / double(DayaBay::BaseFrequencyHz));

            tdf->setTriggerTime(triggerTime);
            tdf->setTriggerType((*tcIt)->type());
            tdf->setInTriggers(rtc->inTriggers());
            tdf->setOutTriggers(rtc->outTriggers());

            // create, fill, and register trigger data package
            tdpkg = new DayaBay::ReadoutTriggerDataPkg();
            tdpkg->setDetector(det);
            tdpkg->addFrame(tdf);
            dataPkgs.push_back(tdpkg);
            tdpkg = 0;
        }
    }
    debug() << "Done Packing Triggers. " <<  endreq;
  }

  return StatusCode::SUCCESS;
}