RawBeamMonBlock.cxx

Go to the documentation of this file.

// $Id: RawBeamMonBlock.cxx,v 1.13 2005/11/10 23:02:36 bv Exp $

#include "RawBeamMonBlock.h"
#include "RawBeamData.h"
#include "RawBlockRegistry.h"
REGISTERRAWBLOCK(RawBeamMonBlock,kMdBlockBeamMonPayload,1);

#include <OnlineUtil/rawBlockIds.h>
#include <OnlineUtil/rawBeamDataBlockLayout.h>

//UInt_t RawBeamMonBlock::fgDebugFlags = 0;

#include <ostream>
#include <cassert>

using namespace std;

RawBeamMonBlock::RawBeamMonBlock() : RawDataBlock()
{
    fEarliest = 0;
    fDevices.clear();
}

RawBeamMonBlock::RawBeamMonBlock(const Int_t *block)
   : RawDataBlock(block)
{
    fEarliest = 0;
    fDevices.clear();
}

RawBeamMonBlock::~RawBeamMonBlock()
{
    // delete any RawBeamData objects created!
    map<string,RawBeamData*>::iterator it, done = fDevices.end();
    for (it = fDevices.begin(); it != done; ++it) {
        if (it->second) delete it->second;
        it->second = 0;
    }
}

RawBeamMonBlock::RawBeamMonBlock(const RawBeamMonBlock &rhs)
    : RawDataBlock(rhs)
{
    fEarliest = rhs.fEarliest;
    fDevices.clear();
}

RawBeamMonBlock& RawBeamMonBlock::operator=(const RawBeamMonBlock& rhs)
{
    if (this == &rhs) return *this;
    RawDataBlock::operator=(rhs);
    fEarliest = rhs.fEarliest;
    fDevices.clear();
    return *this;
}


void RawBeamMonBlock::SetFiltered(bool filter)
{
    fEarliest = filter ? 0 : -1;
    fDevices.clear();
}

void RawBeamMonBlock::Unpacker() const
{
    const int* end = fRawBlock + fRawBlock[pld_indx_size];
    const int ndevs_tot = fRawBlock[pld_indx_num_devices];

    int ndevs = 0;

    for (int* data = fRawBlock+pld_indx_data_start;
         data < end;
         data += pld_nvalues_offset + data[pld_nvalues_offset] + 1, ++ndevs) {
        
        RawBeamData* rbd = new RawBeamData(data);

        if (fEarliest >= 0) {
            double t = rbd->GetSeconds() + rbd->GetMsecs()/1000.0;
            if (fEarliest < 1 || (t > 1 && t < fEarliest)) fEarliest = t;
        }
        
        string name = rbd->GetName();
        fDevices[name] = rbd;
    }
    assert (ndevs == ndevs_tot);

    if (fEarliest < 0) return;

    // Implement filter - this doesn't touch the underlying data, just
    // how it is mapped.
    map<string,RawBeamData*> newmap;
    map<string,RawBeamData*>::iterator it, done = fDevices.end();
    for (it = fDevices.begin(); it != done; ++it) {
        double t = it->second->GetSeconds() + it->second->GetMsecs()/1000.0;
        if (t - fEarliest > 1.0) {
            delete it->second;
            it->second = 0;
        }
        else newmap[it->first] = it->second;
    }

    fDevices.clear();
    fDevices = newmap;
}

std::vector<string> RawBeamMonBlock::GetNames() const
{
    if (0 == fDevices.size()) this->Unpacker();

    vector<string> res;
    map<string,RawBeamData*>::iterator it, done = fDevices.end();
    for (it=fDevices.begin(); it != done; ++it) {
        res.push_back(it->first);
    }
    return res;
}

const RawBeamData* RawBeamMonBlock::operator[](string device_name) const
{
    if (0 == fDevices.size()) this->Unpacker();

    map<string,RawBeamData*>::iterator it = fDevices.find(device_name);
    if (it == fDevices.end()) return 0;

    return it->second;
}


ostream& RawBeamMonBlock::FormatToOStream(ostream& os, Option_t *option) const
{
    if (0 == fDevices.size()) this->Unpacker();
    RawDataBlock::FormatToOStream(os,option);
    if (option[0] == 'X') return os;
    
    vector<string> names = this->GetNames();
    os << names.size() << " devices:\n";
    
    for (size_t ind = 0; ind < names.size(); ++ind) {
        string name = names[ind];
        const RawBeamData* rbd = (*this)[name];
        if (!rbd) {
            os << name << " has no data!!!\a\n";
            continue;
        }
        os.precision(20);
        os << name << " @ " << rbd->GetSeconds() << "." << rbd->GetMsecs() << endl;
        size_t ndata = rbd->GetDataLength();
        const double* data = rbd->GetData();
        for (size_t ind2 = 0; ind2 < ndata; ++ind2)
            os << "\t" << ind2 << ": " << data[ind2] << endl;
    }

    return os;
}

int RawBeamMonBlock::TclkTriggerEvent() const
{
    return fRawBlock[pld_indx_clbk_event];
}

int RawBeamMonBlock::TclkTriggerDelay() const
{
    return fRawBlock[pld_indx_clbk_delay];
}


ClassImp(RawBeamMonBlock)

---