BeamData.cc

Go to the documentation of this file.

#include "BeamData.h"
#include <OnlineUtil/rawBlockIds.h>
#include <OnlineUtil/rdChecksum.h>
#include <OnlineUtil/rototalk.h>
#include <OnlineUtil/rawBeamDataBlockLayout.h>

#include <map>
#include <string>
#include <vector>
#include <cassert>
#include <iostream>
#include <cstdio>
#include <unistd.h>

using namespace std;

struct Header {
    int nwords;
    int chksum;
    int blkid;
};
struct HeaderBlock {
    struct Header header;
    int sec, nsec, spill;
};


int make_block_id(int majorid, int minorid=0)
{
    int cfns=(1<<1) + (1<<0);
    int csf = 0;
    return (csf << 28) + (cfns<<24) + (majorid<<8) + (minorid<<0);
}
class BeamDataImp {
    string fCurrentFile;
    int fSeconds, fNanosecs, fSpillcount;
    int fTclkEvent, fTclkDelay;
    struct DeviceData {
        DeviceData() : sec(0),msec(0),data(vector<int>()) {}
        ~DeviceData() {}
        int sec, msec;          // per device timestamp;
        vector<int> data;       // per device data array
    };
    typedef map<string,DeviceData> Payload;
    typedef Payload::iterator PayloadItr;
    Payload fPayload;

public:

    BeamDataImp() { this->clear(); fCurrentFile = ""; }
    ~BeamDataImp() {}

    void clear() {
        fSeconds = fNanosecs = fSpillcount = 0;
        fTclkEvent = fTclkDelay = 0;
        fPayload.clear();
    }
    int words() {
        int s = 0;
        // header block is constant size
        s += zzzz_last;
        // Number of words to get to start of payload
        s += pld_indx_data_start; 

        // Offset from above index + 1 gives number of values in the
        // prefix of each device data
        s += (pld_nvalues_offset+1) * fPayload.size();

        // Finally count up the actual payloads
        PayloadItr it, done = fPayload.end();
        for (it = fPayload.begin(); it != done; ++it) {
            s += it->second.data.size();
        }
        return s;
    }

    long int* create_block() {
        int siz = this->words();
        long int* data = new long int[siz];
        
        // The header block
        long int* hdr = data;
        hdr[hdr_indx_size]     = zzzz_last;
        hdr[hdr_indx_checksum] = 0;
        hdr[hdr_indx_blockid]  = make_block_id(kMdBlockBeamMonHeader);
        hdr[hdr_indx_sec]      = fSeconds;
        hdr[hdr_indx_nsec]     = fNanosecs;
        hdr[hdr_indx_spillcnt] = fSpillcount;
        rdxsum_fill(hdr,0);

        // The payload block
        long int* pld = data+hdr[hdr_indx_size];
        siz -= hdr[hdr_indx_size];
        pld[pld_indx_size]        = siz;
        pld[pld_indx_checksum]    = 0;
        pld[pld_indx_blockid]     = make_block_id(kMdBlockBeamMonPayload);
        pld[pld_indx_clbk_event]  = fTclkEvent;
        pld[pld_indx_clbk_delay]  = fTclkDelay;
        pld[pld_indx_num_devices] = fPayload.size();

        int count=0, index = pld_indx_data_start;
        PayloadItr it, done = fPayload.end();
        for (it = fPayload.begin(); it != done; ++it) {
            string name = it->first;
            DeviceData& dd = it->second;

            // Pack the ACNET name.  This does it in machine order
            // unpacking assumes it is written on ix86 ordering.
            pld[index++] = (name[0]<<24)+(name[1]<<16)+(name[2]<<8)+name[3];
            pld[index++] = (name[4]<<24)+(name[5]<<16)+(name[6]<<8)+name[7];

            // Set the relative timestamp
            pld[index++] = dd.sec;
            pld[index++] = dd.msec;

            // Pack number of device values and the values themselves.
            int nvalues = dd.data.size();
            pld[index++] = nvalues;
            for (int ind=0; ind<nvalues; ++ind) pld[index++] = dd.data[ind];
            ++count;
        }
        rdxsum_fill(data+6,0);

        assert (siz == index);
        assert (count == pld[pld_indx_num_devices]);
        return data;
    }
    void delete_block(long int* data) { delete [] data; }

    int header(int sec, int nsec, int spill, int event, int delay) {
        fSeconds = sec;
        fNanosecs = nsec;
        fSpillcount = spill;
        fTclkEvent = event;
        fTclkDelay = delay;
    }

    DeviceData& get_device(string name) {
        // space pad name
        while (name.size() < 8u) name.push_back(' ');

        PayloadItr it = fPayload.find(name);
        if (it == fPayload.end()) {
            fPayload[name] = DeviceData();
            return fPayload[name];
        }
        else return it->second;
    }
    void set_device_header(string name, int sec, int msec) {
        DeviceData& d = get_device(name);
        d.sec = sec;
        d.msec = msec;
    }
    void append_payload(string name, int value[2]) {
        DeviceData& d = get_device(name);
        d.data.push_back(value[0]);
        d.data.push_back(value[1]);
    }

    string& current_file() { return fCurrentFile; }
};


BeamData::BeamData()
{
    fImp = new BeamDataImp;
}
BeamData::~BeamData()
{
    if (fImp) delete fImp;
}

int BeamData::open_connection(const char* host)
{
    return roto_open_BeamMon_connection(host);
}

int BeamData::close_connection()
{
    return roto_close_connection();
}

// Ripped to match Rotorooter/RotoServer.cxx and Validity/VldTimeStamp.cxx
string secnsec2filename(int sec, int nsec)
{
    const int nspersec = 1000000000;
    while (nsec<0) {
        nsec += nspersec;
        sec -= 1;
    }
    while (nsec >= nspersec) {
        nsec -= nspersec;
        sec -= 1;
    }

    time_t atime = sec;
    struct tm *ptm = gmtime(&atime);
    int dat = (1900+ptm->tm_year)*10000+(1+ptm->tm_mon)*100+ptm->tm_mday;
    if (dat>19700000) dat %= 100000;
    int tim = ptm->tm_hour*10000 + ptm->tm_min*100 + ptm->tm_sec;

    char buf[80];
    snprintf(buf,80,"B%6.6d_%6.6d.mbeam.root",dat,tim);
    string fname = buf;
    return fname;
}

int BeamData::open_file(int sec, int nanosec)
{
    int ret = roto_open_beammonfile(sec,nanosec);
    if (ret) {
        fImp->current_file() = "";
        return ret;
    }
    fImp->current_file() = secnsec2filename(sec,nanosec);
    return ret;
}
int BeamData::close_file()
{
    int ret = roto_close_beammonfile();
    fImp->current_file() = "";
    return ret;
}

int BeamData::send_data()
{
    long int* data = fImp->create_block();
    //cerr << data[9] << " devices, block 1 " << data[0] << " words, block 2 " << data[6] << " words, total words = " << fImp->words() << endl;
    int res = roto_send_record(data,fImp->words()*4);
    fImp->delete_block(data);
    return res;
}

void BeamData::start_block(int seconds, int nanosecs, int spillcount, 
                           int event, int delay)
{
    fImp->clear();
    fImp->header(seconds,nanosecs,spillcount,event,delay);
}

void BeamData::set_device_header(const char* name, int sec, int msec)
{
    fImp->set_device_header(name,sec,msec);
}
void BeamData::add_device_value(const char* name, double value)
{
    int temp[2] = { 0 };
    // Egads!  Avert yer eye's if ye worry about yer sanity
    memcpy(temp,&value,sizeof(double));
    fImp->append_payload(name,temp);
}

const char* BeamData::current_filename()
{
    return fImp->current_file().c_str();
}

const char* BeamData::error(int err)
{
    const char* errtable[] = {
        "rototalk_success",
        "rototalk_err_whoami",
        "rototalk_err_alreadyconn",
        "rototalk_err_unknownhost",
        "rototalk_err_notinethost",
        "rototalk_err_socketfail",
        "rototalk_err_connectfail",
        "rototalk_err_notconnected",
        "rototalk_err_illegalmethod",
        "rototalk_err_badsender",
        "rototalk_err_badsendcmd",
        "rototalk_err_badsendsize",
        "rototalk_err_badsenddata",
        "rototalk_err_badrecvack",
        "rototalk_err_badrecvacksize",
        "rototalk_err_badrecvackdata",
        "rototalk_err_badrecvstate",
        "rototalk_err_nack",
        "rototalk_err_reallocate",
        "rototalk_err_badconfig",
        "rototalk_last_of_errors",
        0
    };
    if (err < 0 || err >= rototalk_last_of_errors) return "unknown";
    return errtable[err];
}

---