BDCheckDB.cxx

Go to the documentation of this file.

#include "BDCheckDB.h"

#include <BeamDataUtil/BDSpillAccessor.h>
#include <BeamDataUtil/BeamMonSpill.h>
#include <BeamDataUtil/BDEarliest.h>

#include <Validity/VldContext.h>
#include <Validity/VldTimeStamp.h>
#include <RawData/RawRecord.h>
#include <RawData/RawBeamMonHeaderBlock.h>
#include <RawData/RawBeamMonBlock.h>
#include <RawData/RawDataBlock.h>
#include <RawData/RawBeamData.h>
#include <Util/UtilMath.h>
#include <Conventions/Munits.h>
#include <HistMan/HistMan.h>

#include <Conventions/Detector.h>
#include <Conventions/SimFlag.h>
#include <SpillTiming/SpillTimeFinder.h>

#include <TSystem.h>
#include <TTree.h>
#include <TFile.h>

#include <list>
#include <string>
#include <iostream>
using namespace std;

const char* TOROIDS[] = { "E:TOR101", "E:TR101D", "E:TORTGT", "E:TRTGTD", 0 };
const char* toroids[] = { "tor101", "tr101d", "tortgt", "trtgtd", 0 };

BDCheckDB::BDCheckDB()
{
    HistMan hm("bd_check_db");

    hm.Book<TH1F>("dt","Time from file VldContext to spill time, less delay",
            1000,-0.1,0.1);
    hm.Book<TH1F>("dtnd","Time from file VldContext to SpillTimeND",
            1000,-0.1,0.1);
    hm.Book<TH1F>("dh","File-DB horn diff (kAmp)",
            200,-0.001,0.001);

    for (int ind=0; toroids[ind]; ++ind) {
        hm.Book<TH1F>(toroids[ind],Form("File-DB for %s",TOROIDS[ind]),
                      200,-0.0001,0.0001);
    }
}

BDCheckDB::~BDCheckDB()
{
    HistMan hm("");
    hm.WriteOut("bd_check_db.root");
}

bool BDCheckDB::SpinFile(const char* filename)
{
    TFile infile(filename,"READ");
    TTree* intree=(TTree*)(infile.Get("BeamMon"));

    int bad_spills = 0, count=0;

    RawRecord* record = 0;
    int nentries = intree->GetEntries();
    for ( Int_t ient = 0; ient < nentries; ient++ ) {
        intree -> SetBranchAddress("RawRecord",&record);
        intree->GetEntry(ient);

        const RawBeamMonBlock* rbmb = 0;
        const RawBeamMonHeaderBlock* rbmhb = 0;
        TObject *obj = 0;
        TIter itr = record->GetRawBlockIter();
        while ((obj = itr())) {
            const RawBeamMonBlock* b =
                dynamic_cast<const RawBeamMonBlock*>(obj);
            if (b) rbmb = b;
            const RawBeamMonHeaderBlock* h =
                dynamic_cast<const RawBeamMonHeaderBlock*>(obj);
            if (h) rbmhb = h;
        }

        if (!(rbmb && rbmhb)) continue;

        ++count;
        bool good = this->CheckSpill(*rbmb,*rbmhb);
        if (!good) ++bad_spills;

    }

    if (bad_spills)
        cerr << filename << " " << bad_spills << " bad spills out of "
             << count << endl;

    infile.Close();
    return !bad_spills;
}

void BDCheckDB::SpinDir(const char* dirname)
{
    void* dir = gSystem->OpenDirectory(dirname);
    if (!dir) {
        cerr << "Failed to open directory \"" << dirname << "\"\n";
        return;
    }
    list<string> file_names;
    const char* cptr=0;
    while ( (cptr = gSystem->GetDirEntry(dir)) )
        if (cptr) file_names.push_back(cptr);
    if (!file_names.size()) return;
    file_names.sort();
    list<string>::iterator it, done = file_names.end();

    int bad_files = 0;

    for (it=file_names.begin(); it != done; ++it) {
        string file = *it;
        if (string::npos == file.find(".mbeam.root") || file[0] != 'B') {
            cerr << "Skipping unmatched file \"" << file << "\"\n";
            continue;
        }
        
        string path = dirname;
        path += "/" + file;
        cerr << "Processing " << path << endl;
        
        bool good = this->SpinFile(path.c_str());
        if (!good) {
            ++bad_files;
            cerr << path << " is bad\n";
        }
    }
    
    cerr << bad_files << " bad files\n";
}


VldTimeStamp get_timestamp(const RawBeamMonBlock& rbmb)
{
    double dae=0, vme=0;
    BDEarliest::CalculateEarliest(rbmb,dae,vme);
    if (vme == 0) {
        int t = (int)dae;
        return VldTimeStamp(t,(int)((dae-t)*1e9));
    }
    else {
        int t = (int)vme;
        return VldTimeStamp(t,(int)((vme-t)*1e9));
    }
}


bool BDCheckDB::CheckSpill(const RawBeamMonBlock& rbmb,
                           const RawBeamMonHeaderBlock& /*rbmhb*/)
{
    HistMan hm("bd_check_db");

    VldTimeStamp file_vts = get_timestamp(rbmb);
    const BeamMonSpill* spill = BDSpillAccessor::Get().LoadSpill(file_vts);
    if (!spill) {
        cerr << file_vts << " no DB entry\n";
        return false;
    }
    Detector::Detector_t det = Detector::kNear;
    SimFlag::SimFlag_t simflag = SimFlag::kData;
    VldContext file_vc(det,simflag,file_vts);
    VldTimeStamp spilltimend = SpillTimeFinder::Instance().GetTimeOfNearestSpill(file_vc);

    double nd_file_diff_time = (double)(file_vts - spilltimend);
    hm.Fill1d("dtnd",nd_file_diff_time);

    if (fabs(nd_file_diff_time) > 0.5) {
        cerr << "spilltimend: "
             << file_vts << " " << spilltimend << " " << nd_file_diff_time << endl;
    }

    VldTimeStamp db_vts = spill->SpillTime();
    double diff_time = file_vts - db_vts;
    hm.Fill1d("dt",diff_time);
    if (fabs(diff_time) > 0.5) {
        cerr << "timing: "
             << file_vts << " " << db_vts << " " << diff_time << endl;
        return false;
    }


    int errors=0;

    double db_toroids[4] = {
        spill->fTor101, spill->fTr101d, spill->fTortgt, spill->fTrtgtd
    };

    for (int ind=0; TOROIDS[ind]; ++ind) {
        double file_tor = 0;
        const RawBeamData* data = rbmb[TOROIDS[ind]];
        if (data && data->GetDataLength()) file_tor = data->GetData()[0];
        if (UtilMath::sameValue(file_tor, db_toroids[ind],true)) continue;
        double dt = file_tor - db_toroids[ind];
        hm.Fill1d(toroids[ind],dt);
        if (fabs(dt/(file_tor+db_toroids[ind])) > 1e-5) {
            cerr << "toroids: "
                 << db_vts << " " << TOROIDS[ind] << " "
                 << file_tor << " - " << db_toroids[ind] << " = "
                 << dt << " rel = " << dt/(file_tor+db_toroids[ind])
                 << endl;
            ++errors;
        }
    }

    double file_horn = 0;
    const char* horns[] = { "E:NSLINA","E:NSLINB","E:NSLINC","E:NSLIND",0 };
    for (int ind=0; horns[ind]; ++ind) {
        const RawBeamData* data = rbmb[horns[ind]];
        if (data && data->GetDataLength()) file_horn += data->GetData()[0];
    }
    double dh = file_horn-spill->fHornCur;
    hm.Fill1d("dh",dh);
    if (fabs(dh) > 0.01) {
        cerr << "horn: file=" << file_horn << " db="<<spill->fHornCur 
             << " dh=" << dh << endl;
        ++errors;
    }

    return !errors;
}

---