---

Level1.cxx

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/trigger/src/Level1.cxx,v 1.6 2001/06/21 20:50:34 burnett Exp $

// Include files
// Gaudi system includes
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/AlgFactory.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/SmartDataPtr.h"
#include "GaudiKernel/Algorithm.h"

// ntuple interface
#include "ntupleWriterSvc/INTupleWriterSvc.h"

#include "instrument/DetectorConverter.h"
#include "instrument/Scintillator.h"
#include "instrument/SiDetector.h"
#include "instrument/CsIDetector.h"
#include "instrument/Tower.h"
#include "idents/ModuleId.h"
#include "idents/XtalId.h"

// TDS class declarations: input data,
#include "GlastEvent/data/TdGlastData.h"

// for access to instrument.ini
#include "GlastSvc/GlastDetSvc/IGlastDetSvc.h"
#include "xml/IFile.h"

#include <cassert>
#include <iomanip>

static inline bool three_in_a_row(unsigned bits)
{
    while( bits ) {
        if( (bits & 7) ==7) return true;
        bits >>= 1;
    }
    return false;
}
static inline unsigned layer_bit(int layer){ return 1 << layer;}
// Define the class here instead of in a header file: not needed anywhere but here!
//------------------------------------------------------------------------------
class Level1 : public Algorithm {
public: 
    enum  {
           // definition of  trigger bits
            b_ACDL =     1,  //  set if cover or side veto, low threshold
            b_ACDH =     2,   //  cover or side veto, high threshold
            b_Track=     4,   //  3 consecutive x-y layers hit
            b_CAL=       8,  //  single log above low threshold
            b_HI_CAL=   16   //  3 cal layers in a row above high threshold
            
    };
    Level1(const std::string& name, ISvcLocator* pSvcLocator);
    StatusCode initialize();
    StatusCode execute();
    StatusCode finalize();
    
    
    // call backs to these guys when data found by visitor
    void setId( idents::ModuleId id){m_id=id;}
    void cal(const CsIDetector& );
    void acd(const Scintillator& );
    void tkr(const SiDetector& );
    
private: 
    
    IGlastDetSvc*    m_detSvc; 
    INTupleWriterSvc *m_ntupleWriteSvc;
    std::string m_tupleName;
    
    idents::ModuleId m_id;
    unsigned m_mask;
    
#if 0
    std::vector<unsigned long> m_xbits, m_ybits;
#else
    unsigned long m_xbits[16];
    unsigned long m_ybits[16]; // temp to see in debugger!
#endif
    
    int m_acd_hits;
    int m_log_hits;
    bool m_local;
    bool m_hical;
    unsigned m_hical_bits[16];
    
    double m_tray_spacing;
    double m_z_first_plane;
    int m_planes;
    double m_LOCAL_threshold;
    double m_HICAL_threshold;
};
//------------------------------------------------------------------------

// necessary to define a Factory for this algorithm
// expect that the xxx_load.cxx file contains a call     
//     DLL_DECL_ALGORITHM( Level1 );

static const AlgFactory<Level1>  Factory;
const IAlgFactory& Level1Factory = Factory;

//------------------------------------------------------------------------
Level1::Level1(const std::string& name, ISvcLocator* pSvcLocator)
:Algorithm(name, pSvcLocator)
, m_detSvc(0)
{
    // declare properties with setProperties calls
    declareProperty("tupleName",  m_tupleName="");
    declareProperty("mask"     ,  m_mask=0xffffffff); // trigger mask
}

//------------------------------------------------------------------------
StatusCode Level1::initialize(){
    StatusCode  sc = StatusCode::SUCCESS;
    MsgStream log(msgSvc(), name());
    log << MSG::INFO << "initialize: Level1.mask= "<< std::setbase(16) << m_mask;
    if( m_mask==0) log << " (so inoperative)" ; 
    log <<endreq;
    
    // Use the Job options service to set the Algorithm's parameters
    setProperties();
    
    // now try to find the GlastDevSvc service
    if (service("GlastDetSvc", m_detSvc).isFailure()){
        log << MSG::ERROR << "Couldn't find the GlastDetSvc!" << endreq;
        return StatusCode::FAILURE;
    }
    
    // get the ini file and needed constants    
    xml::IFile * ini = const_cast<xml::IFile*>(m_detSvc->iniFile());
    assert(4==ini->getInt("glast", "xNum"));  // simple check
    m_tray_spacing = ini->getDouble("tracker","tray_spacing");
    m_z_first_plane = ini->getDouble("tracker","z_first_plane");
    m_planes = ini->getInt("tracker","num_trays")-1;
    m_LOCAL_threshold = ini->getDouble("trigger","LOCAL_threshold");
    m_HICAL_threshold = ini->getDouble("trigger","HICAL_threshold");
    
    
    // get a pointer to our ntupleWriterSvc
    if (service("ntupleWriterSvc", m_ntupleWriteSvc).isFailure()) {
        log << MSG::ERROR << "Failed to get the ntupleWriterSvc" << endreq;
        return StatusCode::FAILURE;
    }
    
    return sc;
}

//------------------------------------------------------------------------
StatusCode Level1::execute()
{
    StatusCode  sc = StatusCode::SUCCESS;
    MsgStream   log( msgSvc(), name() );
    
    // initialize counters, flags
    m_acd_hits=0;
    m_log_hits=0;
    m_local=m_hical=false;
    for(int k=0; k<16; ++k) m_hical_bits[k]=0;

#if 0
    m_xbits.clear(); m_xbits.resize(m_planes);
    m_ybits.clear(); m_ybits.resize(m_planes);
#else
    for(int i=0; i<16; ++i) m_xbits[i]=m_ybits[i]=0;
#endif
    // define inline visitor class that will walk through the detector tree and call back for data
    class TriggerAnalyzer : public DetectorConverter {
    public:
        TriggerAnalyzer(Level1* ta):m_ta(ta){}
        
        void forward (const Tower& t) { m_ta->setId( t.getId());}
        
        void forward ( const CsIDetector& csi_det) { if( !(csi_det.empty()) ) m_ta->cal(csi_det);       }
        void forward ( const SiDetector& si_det)   { if( !(si_det.empty()) )  m_ta->tkr(si_det);        }
        void forward ( const Scintillator& scint)  { if( !(scint.empty()) )   m_ta->acd(scint);         }
        Level1* m_ta;
    } trig(this);
    
    m_detSvc->accept(trig);
    
    // now process the bits, look for 3-in-a row
    bool triggered=false;
    for( int j=0; j<16; ++j) {
        unsigned and_bits= m_xbits[j] & m_ybits[j];
        triggered = triggered || three_in_a_row(and_bits);
        m_hical = m_hical || three_in_a_row(m_hical_bits[j]);
    }
    
    // set bits in the Level 1 trigger word
    unsigned trigger_bits = 0;
    if( m_acd_hits>0 ) trigger_bits |= Level1::b_ACDL;
    if( m_acd_hits>2 ) trigger_bits |= Level1::b_ACDH;
    if( triggered)     trigger_bits |= Level1::b_Track;
    if( m_local)       trigger_bits |= Level1::b_CAL;
    if( m_hical)       trigger_bits |= Level1::b_HI_CAL;
    
    
    
    // apply filter for subsequent processing.
    if( m_mask!=0 && ( trigger_bits & m_mask) == 0) {
        setFilterPassed( false );
        log << MSG::INFO << "Event did not trigger" << endreq;
        m_ntupleWriteSvc->storeRowFlag(false);
    }else {
        log << MSG::INFO << "Event triggered, masked bits = "
            << std::setbase(16) << (m_mask==0?trigger_bits:trigger_bits& m_mask) << endreq;
        if(!m_tupleName.empty() ) sc = m_ntupleWriteSvc->addItem(m_tupleName.c_str(), "Trig_Bits", trigger_bits );
    }
    
    return sc;
}
//------------------------------------------------------------------------
void Level1::tkr(const SiDetector& plane)
{
    CoordTransform T = plane.localToGlobal(); // for converting the coords following
    Point p(0,0,0); p.transform(T); 
    int layer = static_cast<int>(((p.z() - m_z_first_plane)/m_tray_spacing) + 0.5);
    unsigned int planebit = layer_bit(layer);
    
    bool x=plane.isXplane();
    if( x) m_xbits[m_id] |= planebit;
    else   m_ybits[m_id] |= planebit;
}

void Level1::acd(const Scintillator& tile)
{
    m_acd_hits++;
}
void Level1::cal(const CsIDetector& log)
{
    m_log_hits++;

    if(log.energy()>m_LOCAL_threshold) m_local=true;
    if(log.energy()>m_HICAL_threshold){
        idents::XtalId logId(log.xtalId());
        m_hical_bits[m_id] |= layer_bit(logId.layer());

    }
}



//------------------------------------------------------------------------
StatusCode Level1::finalize(){
    StatusCode  sc = StatusCode::SUCCESS;
    MsgStream log(msgSvc(), name());
    
    return sc;
}

---