ADCoincTagging.cc

Go to the documentation of this file.

//*****************************
//
// AD Coincidence Tag/Data
// chao@bnl.gov  2011-09-26
//
//*****************************

#include "ADCoincTagging.h"

#include "Context/Context.h"
#include "Context/TimeStamp.h"

#include "Event/HeaderObject.h"
#include "Event/RecHeader.h"
#include "Event/UserDataHeader.h"

#include "DataSvc/IDaqDetailsSvc.h"

#include "Context/ServiceMode.h"
#include "GaudiKernel/SystemOfUnits.h"


using namespace std;
using namespace Gaudi;
using namespace DayaBay;

ADCoincTagging::ADCoincTagging(const string& name, ISvcLocator* svcloc)
    : DybBaseAlg(name, svcloc),
    m_nTagged(0), m_nTaggedTriggers(0)
{
    declareProperty("RecLocation", m_recHeaderLoc="/Event/Rec/AdSimple",
            "the TES path of target event header location");
    declareProperty("Location", m_location="/Event/Data/Physics/CoincidenceLoose",
            "the TES path of AD Coincidence Data location");
    declareProperty("TagLocation", m_tagLocation="/Event/Tag/Physics/CoincidenceLoose",
            "the TES path of AD Coincidence Tag location");         
    declareProperty("TimeWindow", m_timeWindow=200*Gaudi::Units::microsecond,
        "AD coincidence time window");
    declareProperty("MaxGapWindow", m_maxGapWindow=0.2*Gaudi::Units::second,
        "Maximum Gap between two triggers in one AD");
}


ADCoincTagging::~ADCoincTagging()
{
}


StatusCode ADCoincTagging::initialize()
{
    info() << "initialize: coincidence time window: " << m_timeWindow/Gaudi::Units::microsecond << " microseconds" << endreq;    

    m_daqDetailsSvc = svc<IDaqDetailsSvc>("DetailsFromRecordSvc", true);
    if (!m_daqDetailsSvc) {
        error() << "Failed to load IDaqDetailsSvc" << endreq;
        return StatusCode::FAILURE;
    }
    
    // initialize
    m_inputHeaders[DetectorId::kAD1] = vector<const IHeader*>();
    m_inputHeaders[DetectorId::kAD2] = vector<const IHeader*>();
    m_inputHeaders[DetectorId::kAD3] = vector<const IHeader*>();
    m_inputHeaders[DetectorId::kAD4] = vector<const IHeader*>();
    
    return StatusCode::SUCCESS;
}



StatusCode ADCoincTagging::execute()
{   
    RecHeader* recHeader = get<RecHeader>(m_recHeaderLoc);
    if ( !recHeader ) {
        warning() << "Cannot find header at " << m_recHeaderLoc << endreq;
        return StatusCode::FAILURE;
    } 
    
    TimeStamp ts = recHeader->context().GetTimeStamp();
    DetectorId::DetectorId_t detectorId = recHeader->context().GetDetId();
    
    TimeStamp lastTS = ts;
    
    if(m_lastTimeStamp.find(detectorId) != m_lastTimeStamp.end()){
        lastTS = m_lastTimeStamp[detectorId];
    }       
    m_lastTimeStamp[detectorId] = ts;
        
    // only look for AD Coincidence
    if (   detectorId == DetectorId::kIWS 
        || detectorId == DetectorId::kOWS 
        || detectorId == DetectorId::kRPC) {
        return StatusCode::SUCCESS; 
    }
    
    TimeStamp dt = TimeStamp(ts);
    dt.Subtract(lastTS);
    double dt_sec = dt.GetSeconds();
    
    if (dt_sec*Gaudi::Units::second > m_timeWindow) {
        int multiplicity = m_inputHeaders[detectorId].size();
        if (multiplicity < 2) {
            m_inputHeaders[detectorId].clear();
        }
        else {
            // found a gap
            
            if (dt_sec*Gaudi::Units::second > m_maxGapWindow) {
                // long gap in DAQ, the previous multiplets not in memory any more
                warning() << "Event gap in AD " << detectorId << ": " << dt_sec << " sec" << endreq;
            } 
            else {
                // found a conincident multiplet
                vector<const IHeader*>& inputHeaders = m_inputHeaders[detectorId];
                                                
                // save a (redundant) tag header object into the tag location                
                HeaderObject *tag = MakeHeader<HeaderObject>(inputHeaders);                
                put(tag, m_tagLocation);
                                
                // make the UserData                
                UserDataHeader* data = MakeHeader<UserDataHeader>(inputHeaders);
                
                // store user-defined data
                SaveRecData(inputHeaders, data);
                SaveCalibStatsData(inputHeaders, data);
                SaveOtherData(inputHeaders, data);
                
                // save UserData to TES
                put(data, m_location);
                
                m_nTagged++;
                m_nTaggedTriggers += multiplicity;
                // info() << "found one: multiplicty " << multiplicity 
                //        << " execNumber: " << execNumber << endreq;
            }
            
            m_inputHeaders[detectorId].clear();
        }
    }
    
    m_inputHeaders[detectorId].push_back(recHeader);
     
    return StatusCode::SUCCESS;
}


StatusCode ADCoincTagging::finalize()
{
    info() << m_nTagged << " multiplets (" << m_nTaggedTriggers 
           << " triggers) tagged at " << m_location  << endreq;
    return StatusCode::SUCCESS;
}


// helper methods
void ADCoincTagging::SaveRecData(vector<const IHeader*>& inputHeaders, UserDataHeader* dataHeader)
{
    // initialize data vectors
    vector<float> e, x, y, z;
    vector<int> triggerNumber, triggerType, t_s, t_ns, dt_ns, energyStatus, positionStatus;
    
    int t0_s = 0; 
    int t0_ns = 0; 
    for (size_t i=0; i<inputHeaders.size(); i++) {
        const RecHeader* recHeader = dynamic_cast<const RecHeader*>(inputHeaders[i]);
        RecTrigger result = recHeader->recTrigger();
        e.push_back(result.energy()/Units::MeV);
        x.push_back(result.position().x()/Units::mm);
        y.push_back(result.position().y()/Units::mm);
        z.push_back(result.position().z()/Units::mm);
        triggerNumber.push_back(result.triggerNumber());
        triggerType.push_back(result.triggerType());

        energyStatus.push_back(result.energyStatus());
        positionStatus.push_back(result.positionStatus());
        int thisT_s = recHeader->timeStamp().GetSec();
        int thisT_ns = recHeader->timeStamp().GetNanoSec();
        if (0 == i) {
            t0_s = thisT_s;
            t0_ns = thisT_ns;
        }
        t_s.push_back(thisT_s);
        t_ns.push_back(thisT_ns);
        dt_ns.push_back( int((thisT_s-t0_s)*1e9 + thisT_ns - t0_ns));
    }
    
    dataHeader->set("e", e);
    dataHeader->set("x", x);
    dataHeader->set("y", y);
    dataHeader->set("z", z);
    dataHeader->set("triggerNumber", triggerNumber);
    dataHeader->set("triggerType", triggerType);
    dataHeader->set("t_s", t_s);
    dataHeader->set("t_ns", t_ns);
    dataHeader->set("dt_ns", dt_ns);
    dataHeader->set("energyStatus", energyStatus);
    dataHeader->set("positionStatus", positionStatus);
}


void ADCoincTagging::SaveCalibStatsData(vector<const IHeader*>& inputHeaders, UserDataHeader* dataHeader)
{
    int nDataInt = 1;
    int nDataFloat = 32;
    string dataStrInt[] = { "nHit" };
    string dataStrFloat[] = { 
        "nPESum", "nPERMS", "nPulseSum", "nPulseRMS", // PE distribution
        "tEarliest", "tLatest", "tMean", // time distribution
        "EarlyCharge", "NominalCharge", "LateCharge", // 3 diffrent charges
        "MaxQ", "Quadrant", "Kurtosis", "PeakRMS", "MiddleTimeRMS", // for flashers
        "dtLastAD1_ms", "dtLastAD2_ms", "dtLastAD3_ms", "dtLastAD4_ms", "dtLastIWS_ms", "dtLastOWS_ms", "dtLastRPC_ms",
        "dtNextAD1_ms", "dtNextAD2_ms", "dtNextAD3_ms", "dtNextAD4_ms", "dtNextIWS_ms", "dtNextOWS_ms", "dtNextRPC_ms",
        "dtLast_ADMuon_ms", "dtLast_ADShower_ms", "ELast_ADShower_pe"
    };
    vector< vector<int> > dataInt(nDataInt);
    vector< vector<float> > dataFloat(nDataFloat);
    
    for (size_t i=0; i<inputHeaders.size(); i++) {
        const RecHeader* recHeader = dynamic_cast<const RecHeader*>(inputHeaders[i]);
        vector<const IHeader*> inputHeaders = recHeader->findHeaders("/Event/Data/CalibStats");
        if ( 1 == inputHeaders.size() ) {
            // Fix:: UserDataHeader class need to make getBlahBlah() methods const. 
            UserDataHeader* calibStats =  const_cast<UserDataHeader*>(dynamic_cast<const UserDataHeader*>(inputHeaders[0]));
            for (int j=0; j<nDataInt; j++ ) {
                int value = calibStats->getInt(dataStrInt[j]);
                dataInt[j].push_back(value);
            }
            for (int j=0; j<nDataFloat; j++ ) {
                float value = calibStats->getFloat(dataStrFloat[j]);
                dataFloat[j].push_back(value);                
            }        
        }
        else {
            warning() << inputHeaders.size() << " Data at /Event/Data/CalibStats" << endreq;
        }
    }
    for (int j=0; j<nDataInt; j++ ) {
        dataHeader->set( string("calib_")+dataStrInt[j], dataInt[j] );
    }
    for (int j=0; j<nDataFloat; j++ ) {
        dataHeader->set( string("calib_")+dataStrFloat[j], dataFloat[j] );
    }
}


void ADCoincTagging::SaveOtherData(vector<const IHeader*>& inputHeaders, UserDataHeader* dataHeader)
{
    // initialize data vectors
    vector<int> I, J;
    
    int multiplicity = inputHeaders.size();
    for (int i=0; i<multiplicity-1; i++) {
        for (int j=i+1; j<multiplicity; j++) {
            I.push_back(i);
            J.push_back(j);
        }
    }
    
    dataHeader->set("multiplicity", multiplicity);
    dataHeader->set("I", I);
    dataHeader->set("J", J);
    
    int runNo = 0;
    int fileNo = 0;
    ServiceMode svcMode = ServiceMode(dynamic_cast<const HeaderObject*>(inputHeaders.at(0))->context(), 0);
    const DaqRunDetails& runDetails = m_daqDetailsSvc->runDetails(svcMode);
    if (&runDetails) {
        runNo = runDetails.runNumber();
    }
    const DaqFileDetails& fileDetails = m_daqDetailsSvc->fileDetails(svcMode);
    if (&fileDetails) {
        fileNo = fileDetails.fileNumber();
    }
    dataHeader->set("runNo", runNo);
    dataHeader->set("fileNo", fileNo);
}