STND_BMS.cxx

Go to the documentation of this file.

#include "STND_BMS.h"
#include "FileGap.h"

#include <SpillTiming/SpillTimeFinder.h>
#include <BeamDataUtil/BDSpillAccessor.h>
#include <BeamDataUtil/BeamMonSpill.h>

#include <Validity/VldContext.h>
#include <Validity/VldTimeStamp.h>

#include <HistMan/HistMan.h>

#include <TH1F.h>
#include <TProfile.h>

#include <iostream>
using namespace std;

STND_BMS::STND_BMS()
{
}
STND_BMS::~STND_BMS()
{
}

void STND_BMS::Scan(VldTimeStamp begin_run, VldTimeStamp end_run,
                    const char* folder)
{

    FileGap fg;
    FileGap::BoundList bounds = fg.GetFileBounds(begin_run,end_run);
    FileGap::Bound& first = bounds.front();
    if (first.first < begin_run) first.first = begin_run;
    FileGap::Bound& last = bounds.back();
    if (last.second > end_run) last.second = end_run;

    int nfiles = bounds.size();

    HistMan hm(folder);
    TProfile* h_dt_file =
        hm.Book<TProfile>("dt_file",
                          "SpillTimeND - BeamMonSPill vs file",
                          nfiles,0,nfiles);
    TH1F* h_missing_file =
        hm.Book<TH1F>("missing_file","Number BMS > .5 sec away from STND",
                      nfiles,0,nfiles);
    TH1F* h_miss_per_file =
        hm.Book<TH1F>("miss_per_file","Percent BMS > .5 sec away from STND",
                      nfiles,0,nfiles);


    TH1F* h_notor_file =
        hm.Book<TH1F>("notor_file","Number BMS < .5 sec away from STND, no toroids",
                      nfiles,0,nfiles);
    TH1F* h_notor_per_file =
        hm.Book<TH1F>("notor_per_file","Percent BMS < .5 sec away from STND, no toroids",
                      nfiles,0,nfiles);
    
    TH1F* h_dt_in = hm.Book<TH1F>("dt_in","SpillTimeND - BeamMonSPill",
                                  2000,-0.1,0.1);
    TH1F* h_dt_out = hm.Book<TH1F>("dt_out","SpillTimeND - BeamMonSPill",
                                   2000,-10,10);

    TH1F* h_rep_stnd = hm.Book<TH1F>("rep_stnd","Rep period for SpillTimeND",
                                     600,0,60);
    TH1F* h_rep_bms = hm.Book<TH1F>("rep_bms","Rep period for BeamMonSpill",
                                    600,0,60);
    
    SpillTimeFinder& stf = SpillTimeFinder::Instance();
    BDSpillAccessor& sa = BDSpillAccessor::Get();

    Detector::Detector_t det = Detector::kNear;
    SimFlag::SimFlag_t simflag = SimFlag::kData;

    VldTimeStamp numi_start(2005,1,1,0,0,0);
    

    FileGap::BoundList::iterator it, done = bounds.end();

    VldTimeStamp last_stnd(VldTimeStamp::GetBOT()), last_bms(VldTimeStamp::GetBOT());

    int file=0;
    for (it = bounds.begin(); it != done; ++it) {
        int missing_stnd=0;
        int no_toroids = 0;
        
        VldTimeStamp beg = it->first;
        VldTimeStamp end = it->second;

        cerr << beg << " --> " << end << endl;

        VldTimeStamp vts = beg;
        int nspills = 0;

        while (vts <= end) {
            ++nspills;

            const BeamMonSpill* bms = sa.LoadSpill(vts,+1);
            VldTimeStamp bms_vts;
            if (!bms) {
                cerr << "No BeamMonSpill for " << vts << endl;
                bms_vts = VldTimeStamp::GetEOT();
            }
            else bms_vts = bms->SpillTime();

            VldContext vc(det,simflag,bms_vts);
            VldTimeStamp stnd_vts = stf.GetTimeOfNearestSpill(vc);

            if (stnd_vts < numi_start) {
                cerr << "Bailing on file after " << nspills
                     << " due to getting early SpillTimeND: "
                     << stnd_vts
                     << " last vts = " << vts
                     << endl;
                break;
            }

            h_rep_stnd->Fill(stnd_vts-last_stnd);
            h_rep_bms->Fill(bms_vts-last_bms);

            last_stnd = stnd_vts;
            last_bms  =  bms_vts;

            double dt = stnd_vts-bms_vts;
            h_dt_in->Fill(dt);
            h_dt_out->Fill(dt);
            h_dt_file->Fill(file,dt);

            if (fabs(dt)>0.5) {
                ++missing_stnd;
                h_missing_file->Fill(file,1);
            }

            if (bms->fTor101 == 0.0 && bms->fTr101d == 0.0 &&
                bms->fTortgt == 0.0 && bms->fTrtgtd == 0.0)
            {
                ++no_toroids;
                h_notor_file->Fill(file,1);
            }

            if (vts >= stnd_vts) {
                cerr << "Error, infinite loop, bailing with\n\tbms= " << vts
                     << " stnd= " << stnd_vts << endl;
                break;
            }
            vts = bms_vts;
            
        } // loop over one file
        if (missing_stnd)
            cerr << "File " << file << " no SpillTimeND "
                 << missing_stnd << " times\n";

        h_miss_per_file->Fill(file,(1.0*missing_stnd)/nspills);
        h_notor_per_file->Fill(file,(1.0*no_toroids)/nspills);
        ++file;
    }


    HistMan io("");
    io.WriteOut("stnd_bms.root");
}

---