---

TkrDigiAlg.cpp

Go to the documentation of this file.

#define GlastDigi_TkrDigiAlg_CPP 


#include <list>


// Include files
#include "TkrDigiAlg.h"

#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/AlgFactory.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/SmartDataPtr.h"

#include "GlastEvent/TopLevel/EventModel.h"
#include "GlastEvent/TopLevel/Event.h"
#include "GaudiKernel/ObjectVector.h"

#include "GlastEvent/TopLevel/IrfEvent.h"

//#include "xml/IFile.h"

#include "instrument/SiTracker.h"

static const AlgFactory<TkrDigiAlg>  Factory;
const IAlgFactory& TkrDigiAlgFactory = Factory;

//------------------------------------------------------------------------------
TkrDigiAlg::TkrDigiAlg(const std::string& name, ISvcLocator* pSvcLocator) :
Algorithm(name, pSvcLocator) 
{
    return;
}


//------------------------------------------------------------------------------
StatusCode TkrDigiAlg::initialize() 
{    
    MsgStream log(msgSvc(), name());
    log << MSG::INFO << "initialize" << endreq;
    
    nTrayMax = SiTracker::numTrays();

    if (nTrayMax <= 0) nTrayMax = 18;

    return StatusCode::SUCCESS;
}


//------------------------------------------------------------------------------
StatusCode TkrDigiAlg::execute()
{
    
    StatusCode  sc = StatusCode::SUCCESS;
    MsgStream   log( msgSvc(), name() );
    log << MSG::INFO << "execute" << endreq;

    //Create the collection of digi objects - will be empty at this point
    TkrDigiCol*  pTkrDigi   = new TkrDigiCol;

    //Look to see if the TdGlastData object is in the TDS
    SmartDataPtr<TdGlastData> glastData(eventSvc(), "/Event/TdGlastData");
    
    //If TdGlastData doesn't exist, presume that SiLayers does...
    if( 0 == glastData) 
    { 
        log << MSG::DEBUG << "could not find \""<< "/Event/TdGlastData" <<"\"" << endreq;

        //Look to see if the TbRecon format data exists (SiLayers)
        SiLayers*    pSiLayers  = SmartDataPtr<SiLayers>(eventSvc(),"/Event/TkrRecon/SiLayers");

        if (pSiLayers != 0)
        {
            fillTkrDigis(pSiLayers, pTkrDigi);
        }
        else
        {
            log << MSG::ERROR << "no TKR data is available" << endreq;
            return StatusCode::FAILURE;
        }
    }
    else
    //Fill the TkrDigis from the IRF data
    {
        TdGlastData* pGlastData = glastData;
        fillTkrDigis((const SiData*)pGlastData->getSiData(), pTkrDigi);
    }

    //Take care of insuring that data area has been created
    DataObject* pNode = 0;
    sc = eventSvc()->retrieveObject( "/Event/TkrRecon", pNode);

    if (sc.isFailure())
    {
        sc = eventSvc()->registerObject("/Event/TkrRecon",new DataObject);
        if( sc.isFailure() ) 
        {
            return sc;
        }
    }

    sc = eventSvc()->registerObject("/Event/TkrRecon/TkrDigis", pTkrDigi);

    if (sc != StatusCode::SUCCESS) log << MSG::INFO << "Failed to register TKR digi vector" << endreq;


    return sc;
}


//------------------------------------------------------------------------------
/*
Finalize is called once at the end of event processing.
Any cleanup to occur - will occur here.
*/
StatusCode TkrDigiAlg::finalize() {
    
    MsgStream log(msgSvc(), name());
    log << MSG::INFO << "finalize" << endreq;
    
    return StatusCode::SUCCESS;
}


//------------------------------------------------------------------------------
/*
This routine is used to fill the TkrDigi's depending upon what kind of 
input data we have... Here we fill from IRF format data
*/
void TkrDigiAlg::fillTkrDigis(const SiData* pSiData, TkrDigiCol* pTkrDigi)
{
    // loop in number of layers - conversion to planes!
    int nTrays   = pSiData->nTrays(SiData::X);

    while (nTrays--) 
    {
        fillALayer(pSiData, SiData::X, nTrays, pTkrDigi);
        fillALayer(pSiData, SiData::Y, nTrays, pTkrDigi);
    }

    return;
}

//------------------------------------------------------------------------------
/*
This function does the actual work of filling TkrDigi's from the SiData 
objects for a given layer and X-Y view. 
*/

void TkrDigiAlg::fillALayer(const SiData* pSiData, enum SiData::Axis view, int trayIdx, TkrDigiCol* pTkrDigi)
{
    int layerIdx = pSiData->layerNum(view, trayIdx);
    int ToT[2] = {0,0};
    std::list<unsigned int> hitStripList;

    //Start with the X view
    //How many hit strips this view?
    int nHitStrips = pSiData->nHits(view, trayIdx);

    //Clear the hit strip list
    hitStripList.clear();

    //Extract the hit strip info and fill the list with tower and strip info
    while(nHitStrips--)
    {
        unsigned int towerId  = pSiData->moduleId(view, trayIdx, nHitStrips);
        unsigned int stripId  = pSiData->hitId(view, trayIdx, nHitStrips);

        unsigned int hitStrip = ((towerId & 0xFF) << 16) | (stripId & 0xFFFF);
            
        hitStripList.push_back(hitStrip);
    }

    //Sort the list
    hitStripList.sort();

    //Now go back and extract the hit strip info by tower
    int      lastTowerId = -9999;
    TkrDigi* pDigi       = 0;

    std::list<unsigned int>::iterator pHitList = hitStripList.begin();

    nHitStrips = hitStripList.size();

    //Now go through the properly sorted list of strip hits and make digis
    while(nHitStrips--)
    {
        unsigned int hitStrip = *pHitList++;

        unsigned int towerId  = (hitStrip >> 16) & 0xFF;
        unsigned int stripId  = (hitStrip & 0xFFFF);

        //Have we encountered a new tower?
        if (towerId != lastTowerId)
        {
            pDigi       = new TkrDigi(layerIdx, view, towerId, ToT);
            lastTowerId = towerId;

            pTkrDigi->push_back(pDigi);
        }

        //Copy the hits into TkrDigi...
        pDigi->addHit(stripId);
    }

    return;
}


//------------------------------------------------------------------------------
/*
This routine is used to fill the TkrDigi's depending upon what kind of 
input data we have... Here we fill from Test Beam format data
*/
void TkrDigiAlg::fillTkrDigis(SiLayers* pSiLayers, TkrDigiCol* pTkrDigi)
{

    // loop in number of layers - conversion to planes!
    int nlayers = pSiLayers->num();

    for (int ilayer = 0; ilayer < nlayers; ilayer++) {
        SiLayer* layer  = pSiLayers->Layer(ilayer);
        
        int      klayer = layer->layer();
        int      iview  = layer->view();
        int      nHits  = layer->nstrips();
        int      tower  = 0;
        int      tot[2] = {0,0};

        //Create the new TkrDigi object
        TkrDigi* pDigi  = new TkrDigi(klayer, iview, tower, tot);
        
        //Copy the hits into TkrDigi...
        while(nHits--) pDigi->addHit(layer->idstrip(nHits));

        pTkrDigi->push_back(pDigi);
   }

    return;
}

---