RawBeamSwicData.cxx

Go to the documentation of this file.

#include "RawBeamSwicData.h"

#include <iostream>
using namespace std;

ClassImp(RawBeamSwicData)

RawBeamSwicData::RawBeamSwicData()
{
    fData.SetData(0);
}

RawBeamSwicData::RawBeamSwicData(const RawBeamData& data)
{
    this->SetData(data);
}

RawBeamSwicData::~RawBeamSwicData()
{
    fData.SetData(0);
}

RawBeamData& RawBeamSwicData::GetData()
{
    return fData;
}
const RawBeamData& RawBeamSwicData::GetData() const
{
    return fData;
}
bool RawBeamSwicData::SetData(const RawBeamData& data)
{
    fData = data;

    if (!fData.GetData()) return false;

    // Sanity checks
    const size_t swic_data_size = 216;
    const size_t siz = fData.GetDataLength();
    if (siz != swic_data_size) {
        cerr << "Not right size: 216 != " << siz << endl;
        fData.SetData(0);
        return false;
    }

    return true;
}
    
bool RawBeamSwicData::IsValid()  const
{
    return fData.GetData() != 0;
}


// This stuff is from SwicScaled from Jim Patrick @ FNAL

/*
   Example of reading and displaying SWIC display buffer.
   The data comes from the front-end as an array of
   216 (16 bit) shorts. The control system converts ("scales")
   this into an array of 216 doubles by the transformation:
    readings[i] = (double) ((10. * (double)raw[i]) / 32767.)
   (This transformation is specified in the definition
    of the device in the device database).
   In order to interpret the data properly, it
   is necessary to invert this transformation.
   Furthermore, the data is not simply an array of
   shorts, but a structure that contains some floats
   and (32 bit) longs as well. Hence it is necessary
   to combine some of the short elements to get
   the correct data. See the "readings" method below.
*/

/* Note all RawBeamData comes over the wire as 32 bit ints.  In the
 * case of things that are scaled doubles in XML-RPC, they are
 * downcasted to floats, memcpy'ed to ints, then packed in to raw
 * blocks and sent to rotorooter.
 */

// Offsets defining elements of the structure

// First part of the structure is a set of 8 blocks
// of calculation results.
static const int CALCULATION_OFFSET = 0;
static const int CALCULATION_BLOCK_COUNT = 8;
// Offsets within one of the 8 calculation blocks
// Flags for what was calculated; each a "short"
static const int MEAN_FLAG_OFFSET = 0;
static const int SIGMA_FLAG_OFFSET = 1;
static const int INTENSITY_FLAG_OFFSET = 2;
static const int FOM_FLAG_OFFSET = 3; // "Figure of merit"
static const int STATUS_FLAG_OFFSET = 4;
// Actual calculation results
// These are 32 bit "floats" and have to be constructed
// from 2 of the returned array elements
static const int MEAN_OFFSET = 5;
static const int SIGMA_OFFSET = 7;
static const int INTENSITY_OFFSET = 9;
static const int FOM_OFFSET = 11;

static const int CALCULATION_BLOCK_LENGTH = 13;

// The raw data
static const int RAW_OFFSET = CALCULATION_BLOCK_LENGTH * CALCULATION_BLOCK_COUNT + CALCULATION_OFFSET;
static const int RAW_LENGTH = 96;

// Flag indicating position of chamber (in/out/unknown/etc.)
static const int POSITION_OFFSET = 200;
// Timestamp block
// Only the GPS timestamp is relevant for non-miniBoone SWICs
static const int EVENT8FTIMESTAMP_OFFSET = 201;
// The first 2 words are combined to form a 32 bit seconds since 1/1/70
// The second 2 words are combined to form a ns offset to the above
static const int GPSTIMESTAMP_OFFSET = EVENT8FTIMESTAMP_OFFSET + 4;
// Below not generally filled in except for miniBoone
static const int SAMPLEEVENT_OFFSET = GPSTIMESTAMP_OFFSET + 4;
static const int RESETEVENT_OFFSET = SAMPLEEVENT_OFFSET + 1;
static const int N0CEVENT_OFFSET = RESETEVENT_OFFSET + 1;
static const int MILLISLASTMI_OFFSET = N0CEVENT_OFFSET + 1;
static const int N1DEVENTMIRESET_OFFSET = MILLISLASTMI_OFFSET + 1;
static const int N1DEVENT00_OFFSET = N1DEVENTMIRESET_OFFSET + 1;

/* 
   block 0 = horizontal chamber results
   block 1 = vertical chamber results
   block 2 = unused
   block 3 = unused
   block 4 = unused
   block 5 = unused
   block 6 = unused
   block 7 = unused
*/
static const int HORIZONTAL_BLOCK_NUMBER = 0;
static const int VERTICAL_BLOCK_NUMBER = 1;



int unscale(const double& d)
{
//    double temp_needed_to_avoid_gcc_bug = d*32767./10.;
//    return (int)temp_needed_to_avoid_gcc_bug;
    return (int)(d*32767.001/10.);
}

// upper-lower to integer
int ul2int(const double& d1, const double& d2)
{
    int id1 = unscale(d1);
    int id2 = unscale(d2);
    return (id1<<16)+(id2&0xffff);
}
    


int RawBeamSwicData::VmeSeconds() const
{
    const double* data = fData.GetData();
    return ul2int(data[GPSTIMESTAMP_OFFSET],
                  data[GPSTIMESTAMP_OFFSET+1]);
}

int RawBeamSwicData::VmeNanoseconds() const
{
    const double* data = fData.GetData();
    return ul2int(data[GPSTIMESTAMP_OFFSET+2],
                  data[GPSTIMESTAMP_OFFSET+3]);
}

void RawBeamSwicData::UnscaledWireData(vector<int>& wd) const
{
    const double* data = fData.GetData();
    for (int ind=0; ind < RAW_LENGTH; ++ind) {
        wd.push_back(unscale(data[RAW_OFFSET+ind]));
    }
}
void RawBeamSwicData::ScaledWireData(vector<double>& wd) const
{
    const double* data = fData.GetData();
    for (int ind=0; ind < RAW_LENGTH; ++ind) {
        wd.push_back(data[RAW_OFFSET+ind]);
    }
}

---