BDAnaModule.cxx

Go to the documentation of this file.

#include "BDAnaModule.h"

#include <HistMan/HistMan.h>

#include <MinosObjectMap/MomNavigator.h>
#include <JobControl/JobCModuleRegistry.h>
#include <RawData/RawBeamMonHeaderBlock.h>
#include <RawData/RawBeamMonBlock.h>
#include <RawData/RawBeamData.h>
#include <RawData/RawBeamSwicData.h>
#include <RawData/RawSnarlHeaderBlock.h>
#include <RawData/RawDigitDataBlock.h>
#include <RawData/RawRecord.h>
#include <Validity/VldTimeStamp.h>

#include <TIterator.h>
#include <TFile.h>
#include <TH1D.h>
#include <TH1I.h>
#include <TH2D.h>

#include <iostream>
using namespace std;

JOBMODULE(BDAnaModule,"BDAna","Do some BeamData/DAQ correlation checks");


BDAnaModule::BDAnaModule()
{
    n_bd_rec = n_daq_req = 0;
}

BDAnaModule::~BDAnaModule()
{
}

const int nswics = 14;
const char* swics[] = {
    "E:M101DS",
    "E:M105DS",
    "E:M107DS",
    "E:M108DS",
    "E:M112DS",
    "E:M114DS",
    "E:M115DS",
    "E:M117DS",
    "E:M121DS",
    "E:MTGTDS",
    "E:HADMDS",
    "E:MMA1DS",
    "E:MMA2DS",
    "E:MMA3DS",
    0
};
void BDAnaModule::BeginJob()
{
    HistMan hm("BDAna");

    hm.Book<TH1D>("head_dt","Time between DAQ and BeamData headers",
                  4000,-2,2);
    hm.Book<TH1D>("head_dt_wide","Time between DAQ and BeamData headers",
                  2400,-120,120);

    hm.Book<TH1D>("daq_vme_dt","Time between DAQ trigger and E:MTGTDS VME timestamp",
                  4000,-2,2);
    hm.Book<TH1D>("daq_dae_dt","Time between DAQ trigger and E:TORTGT DAE timestamp",
                  4000,-2,2);

    TH2D* h2d =
        hm.Book<TH2D>("dae_vme_dt","Time between DAE and VME ts for various devices",
                      nswics,0,nswics,200,-10,10);

    TH1I *h1i =
        hm.Book<TH1I>("swic_count","Count number of times a swic device shows up",
                      nswics,0,nswics);
    for (int ind=0; swics[ind]; ++ind) {
        h2d->GetXaxis()->SetBinLabel(ind+1,swics[ind]);
        h1i->GetXaxis()->SetBinLabel(ind+1,swics[ind]);
    }
}

void BDAnaModule::EndJob()
{
    HistMan hm("BDAna");

    TFile file("bdana.root","recreate");
    hm.WriteOut(file);
}


template<class BlockType>
const BlockType* get_block(const RawRecord& rr)
{
    TIter itr = rr.GetRawBlockIter();
    const RawDataBlock* rdb = 0;

    // loop over blocks in record
    while ((rdb = dynamic_cast<RawDataBlock*>(itr()))) {
        const BlockType *block =  dynamic_cast<const BlockType*>(rdb);
        if (block) return block;
    }
    return 0;
}


static void spew_record(const RawRecord& rr)
{
    static int count = 0;
    ++count;

    TIter itr = rr.GetRawBlockIter();
    cout << "[" << count << "]\tRawRecord: "
         << rr.GetTempTags().GetCharString("stream") << ": ";
    TObject* obj = 0;
    while ((obj = itr())) {
        cout << obj->GetName() << " ";
    }
    cout << rr.GetTempTags().GetCharString("file") << " ";
    cout << endl;
}
        


JobCResult BDAnaModule::Ana(const MomNavigator *mom)
{

    const RawRecord* daq_rec = 0;
    const RawRecord* bd_rec = 0;


    TIter mitr = mom -> FragmentIter();
    TObject* object;
    while ( (object = mitr.Next()) ) {
        const RawRecord* rr = dynamic_cast<const RawRecord*>(object);
        if ( !rr ) continue;

        spew_record(*rr);

        string stream_name = rr->GetTempTags().GetCharString("stream");
        if (stream_name == "BeamMon") bd_rec = rr;
        if (stream_name == "DaqSnarl") daq_rec = rr;
     }

    if (bd_rec) ++ n_bd_rec;
    if (daq_rec) ++ n_daq_req;

    if (!(bd_rec && daq_rec)) return JobCResult::kFailed;

    const RawBeamMonHeaderBlock* bd_head = get_block<RawBeamMonHeaderBlock>(*bd_rec);
    const RawBeamMonBlock* bd_block = get_block<RawBeamMonBlock>(*bd_rec);
    
    const RawSnarlHeaderBlock* daq_snarl = get_block<RawSnarlHeaderBlock>(*daq_rec);
    //const RawDigitDataBlock* daq_digit = get_block<RawDigitDataBlock>(*daq_rec);

    HistMan hm("BDAna");

    if (bd_block) {
        TH1I *swic_count = hm.Get<TH1I>("swic_count");
        TH2D *dae_vme_dt = hm.Get<TH2D>("dae_vme_dt");

        for (int ind=0; swics[ind]; ++ind) {
            const RawBeamData* rbd = (*bd_block)[swics[ind]];
            
            if (!rbd) continue;
            swic_count->Fill(ind);
            
            double t_dae = rbd->GetSeconds() + rbd->GetMsecs()*0.001;
            
            RawBeamSwicData swic(*rbd);
            
            double t_vme = swic.VmeSeconds() + swic.VmeNanoseconds()*1.0e-9;
            
            //cout << t_dae << " - " << t_vme << " = " << t_dae-t_vme << endl;
            
            dae_vme_dt->Fill(ind,t_dae-t_vme);
        }
    }


    if (bd_block && daq_snarl) {
        const RawBeamData* rbd = 0;

        rbd = (*bd_block)["E:MTGTDS"];
        
        if (rbd) {
            TH1D *daq_vme_dt = hm.Get<TH1D>("daq_vme_dt");

            RawBeamSwicData swic(*rbd);
        
            VldTimeStamp vld_daq = daq_snarl->GetTriggerTime();
            VldTimeStamp vld_vme(swic.VmeSeconds(),swic.VmeNanoseconds());
            
            daq_vme_dt->Fill(vld_daq-vld_vme);
        }

        rbd = (*bd_block)["E:TORTGT"];
        if (rbd) {
            TH1D *daq_dae_dt = hm.Get<TH1D>("daq_dae_dt");

            VldTimeStamp vld_daq = daq_snarl->GetTriggerTime();
            VldTimeStamp vld_dae(rbd->GetSeconds(),(int)(rbd->GetMsecs()*1e6));
            daq_dae_dt->Fill(vld_daq-vld_dae);
        }

    }

    if (bd_head && daq_snarl) {

        VldTimeStamp trig_vts = daq_snarl->GetTriggerTime();
        VldTimeStamp bd_vts = bd_head->GetTimeStamp();
        double head_dt = trig_vts - bd_vts;
        hm.Fill1d("head_dt",head_dt);
        hm.Fill1d("head_dt_wide",head_dt);
        cout << "daq=" << trig_vts << endl
             << "bd= " << bd_vts << endl
             << "\tdt=" << head_dt << endl;
    }

    

    return JobCResult::kAOK;    
}

---