Bmnt.cxx

Go to the documentation of this file.

#include "Bmnt.h"

#include "bmnt/AcnetDevice.h"

#include <Validity/VldContext.h>
#include <RawData/RawRecord.h>
#include <RawData/RawBeamMonHeader.h>
#include <RawData/RawBeamMonBlock.h>
#include <RawData/RawDataBlock.h>
#include <RawData/RawBeamData.h>

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

#include <cassert>
#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <algorithm>
using namespace std;

struct BmntImp {
    TFile* fFile;
    TTree* fTree;
    typedef map<string,AcnetDevice*> DeviceMap;
    DeviceMap fDevices;

    BmntImp() : fFile(0), fTree(0) {}
    ~BmntImp() { this->Stop(); }
    bool Start(const char* outfile);
    void Stop();
    void ProcessFile(const char* filename, bool prefill,int nentries=0);
    bool Fill(const RawBeamMonBlock* rbmb, bool prefill);
};

static string acnet2branchname(string n)
{
    string out = "";
    out.push_back(tolower(n[0]));
    for (size_t ind=2; ind<8 && ind<n.size(); ++ind) { 
        if (n[ind] == '[') break;
        out.push_back(tolower(n[ind]));
    }
    out += ".";
    return out;
}
bool BmntImp::Start(const char* outfile)
{
    this->Stop();
    if (!gSystem->AccessPathName(outfile,kReadPermission)) {
        cerr << "File already exists: " << outfile << endl;
        return false;
    }
    fFile = new TFile(outfile,"new");
    fTree = new TTree("bd", "Beam Monitoring Data");
    return true;
}
void BmntImp::Stop()
{
    if (fFile) {
        fFile->Close();
        delete fFile;
        fFile = 0;
        fTree = 0;
    }
}
bool BmntImp::Fill(const RawBeamMonBlock* rbmb, bool prefill)
{
    DeviceMap::iterator it, done = fDevices.end();
    for (it=fDevices.begin(); it != done; ++it) {
        it->second->clear();
    }

    vector<string> namelist = rbmb->GetNames();

    //cerr << "Callback has " << namelist.size() << " devices\n";
    for (size_t ind=0; ind<namelist.size(); ++ ind) {
        string name = namelist[ind];
        string branchname = acnet2branchname(name);

        AcnetDevice* dev = fDevices[branchname];
        if (! dev) {
            dev = new AcnetDevice(name.c_str());
            fDevices[branchname] = dev;

            this->fTree->Branch(branchname.c_str(),"AcnetDevice",
                                &(fDevices[branchname]));

            //cerr << "New device: " << name
            // << " stored as " << branchname << endl;
        }
        dev->clear();

        if (prefill) continue;

        const RawBeamData* rbd = (*rbmb)[name];
        assert(rbd);

        dev->event = rbmb->TclkTriggerEvent();
        dev->delay = rbmb->TclkTriggerDelay();

        dev->sec = rbd->GetSeconds();
        dev->msec = rbd->GetMsecs();
        dev->timestamp = (1.0*dev->sec) + (dev->msec/1000.0);

        dev->ndata = rbd->GetDataLength();
        dev->data = (double*)rbd->GetData(); // does this do bad things?

    }

    if (!prefill) this->fTree->Fill();

    return true;
}


Bmnt::Bmnt()  : fImp(new BmntImp)
{
}

Bmnt::Bmnt(const char* outfile)  : fImp(new BmntImp)
{
    fImp->Start(outfile);
}

Bmnt::~Bmnt()
{
    if (!fImp) return;

    delete fImp; fImp = 0;
}

void Bmnt::ProcessFile(const char* filename, int nentries)
{
    fImp->ProcessFile(filename, false, nentries);
}


void Bmnt::ProcessFiles(const char** filenames)
{
    for (int ind=0; filenames[ind]; ++ind) fImp->ProcessFile(filenames[ind],true);
    for (int ind=0; filenames[ind]; ++ind) fImp->ProcessFile(filenames[ind],false);
}

void Bmnt::ProcessDirectory(const char* in_directory, const char* out_directory,
                            bool skip_last)
{
    void *dir = gSystem->OpenDirectory(in_directory);
    if (!dir) {
        cerr << "No such directory: " << in_directory << endl;
        return;
    }

    vector<string> files;
    while (const char* file = gSystem->GetDirEntry(dir)) {
        string filename = file;
        if ( filename.length() > 5
             && filename[0] == 'B'
             && filename.find(".mbeam.root") == filename.length()-11 ) {
            files.push_back(file);
        }
    }
    std::sort(files.begin(),files.end());
    if (skip_last) files.pop_back();
    for (size_t ind = 0; ind < files.size(); ++ind) {

        string infile = in_directory;
        infile += "/";
        infile += files[ind];

        string outfile = out_directory;
        size_t start = infile.rfind("/");
        size_t len = infile.find(".mbeam.root") - start;
        outfile += infile.substr(start,len);
        outfile += ".bmnt.root";

        if (!fImp->Start(outfile.c_str())) continue;

        cerr << infile << " --> " << outfile << endl;

        fImp->ProcessFile(infile.c_str(),true);
        fImp->ProcessFile(infile.c_str(),false);
        this->Write();
        fImp->Stop();
        delete fImp;
        fImp = new BmntImp();
    }
}

void BmntImp::ProcessFile(const char* filename, bool prefill, int nentries)
{
    TFile file(filename,"READ");
    TTree* tree = (TTree*)(file.Get("BeamMon"));

    if (!tree) {
        cerr << "Can not find BeamMon tree in " << filename << endl;
        return;
    }

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

        if (!ient) {
            const VldContext* vld = record->GetVldContext();
            cout << "Reading " << filename << ":\n"
                 << *vld << endl;
        }

        TIter itr = record->GetRawBlockIter();
        const RawDataBlock* rdb = 0;

        //cerr << "Entry " << ient << endl;

        // loop over blocks in record
        while ((rdb = dynamic_cast<RawDataBlock*>(itr()))) {
            if (! rdb->InheritsFrom("RawBeamMonBlock")) {
                //cerr << "Doesn't inherit from RawBeamMonBlock" << endl;
                continue;
            }
            const RawBeamMonBlock* rbmb = 
                dynamic_cast<const RawBeamMonBlock*>(rdb);
            assert(rbmb);

            this->Fill(rbmb,prefill);
        }
#if 0
        if (tree->GetEntries()-ient == 1) {
            const VldContext* vld = record->GetVldContext();
            cout << "finishing " << filename << ":\n"
                 << *vld << endl;
        }
#endif
        delete record; record = 0;
    }
    
}
TTree* Bmnt::GetTree() { return fImp->fTree; }

void Bmnt::Write()
{
    fImp->fFile->cd();
    fImp->fTree->Write();
    fImp->fFile->Close();
}


    
void make_bmnt_one_per_dir(const char* indir, const char* outdir, bool skip_last)
{
    void *dir = gSystem->OpenDirectory(indir);
    if (!dir) {
        cerr << "No such directory: " << indir << endl;
        return;
    }

    vector<string> files;
    while (const char* file = gSystem->GetDirEntry(dir)) {
        string filename = file;
        if ( filename.length() > 5
             && filename[0] == 'B'
             && filename.find(".mbeam.root") == filename.length()-11 ) {
            files.push_back(file);
        }
    }
    std::sort(files.begin(),files.end());
    if (skip_last) files.pop_back();
    for (size_t ind = 0; ind < files.size(); ++ind) {

        string infile = indir;
        infile += "/";
        infile += files[ind];

        string outfile = outdir;
        size_t start = infile.rfind("/");
        size_t len = infile.find(".mbeam.root") - start;
        outfile += infile.substr(start,len);
        outfile += ".bmnt.root";

        if (!gSystem->AccessPathName(outfile.c_str(),kReadPermission)) {
            cerr << "File already exists: " << outfile << endl;
            return;
        }

        Bmnt* bd = new Bmnt(outfile.c_str());
        const char* file_array[] = { infile.c_str(), 0 };
        bd->ProcessFiles(file_array);
        bd->Write();
        delete bd;
    }
}

---