RawScanResultStreamer_v1.cpp

#include "RawScanResultStreamer_v1.h"
#include "Sct/SctNames.h"
#include "Sct/SctParameters.h"
#include "Sct/LogicErrors.h"
#include "Sct/VersionNotSupportedException.h"
#include "Sct/UnsupportedOperationError.h"
#include "../RawScanResult.h"
#include "ScanResultWriter/dataTypes.h"

#include "TH2.h"

#include <iostream>
#include <sstream>
#include <boost/lexical_cast.hpp>

using namespace std;
using namespace Sct;
using namespace boost;

namespace SctData {
namespace IO {

/* READ NOTES ON STREAMERS AND VERSIONS BEFORE EDITING THIS FILE! */
unsigned RawScanResultStreamer_v1::s_version=1;

RawScanResultStreamer_v1::RawScanResultStreamer_v1() throw() {}

bool RawScanResultStreamer_v1::inMap = IOManager::addToMap("SctData::RawScanResult",  auto_ptr<Streamer>(new RawScanResultStreamer_v1()));

shared_ptr<Streamable> RawScanResultStreamer_v1::read(IStream& in, const IOManager& manager) const {
    shared_ptr<Streamable> ad (&helper.create());
    read(in, *ad, manager);
    return ad;
}

void RawScanResultStreamer_v1::write(OStream& out, const Streamable& ob, const IOManager& manager) const {
    manager.writeImpl(out, ob, "SctData::ScanResult");

    //Downcast should always work!
    const RawScanResult& raw = dynamic_cast<const RawScanResult&>(ob);
    helper.set(raw);

    //Now publish data - we publish using the ROOTHIST format.
    TH2D* link0 = helper.getScanData(0);
    TH2D* link1 = helper.getScanData(1);
    out << (link0->GetNbinsX()+2)*(link0->GetNbinsY()+2);   //Note, size is number in 1 link ie no bins * no points
    out << SR_DT_ROOTHIST << SR_WD_64;
    
    out.put ( link0->GetArray(), (link0->GetNbinsX()+2)*(link0->GetNbinsY()+2) );
    out.put ( link1->GetArray(), (link1->GetNbinsX()+2)*(link1->GetNbinsY()+2) );
}

void RawScanResultStreamer_v1::read(IStream& in, Streamable& ob, const IOManager& manager) const {
    manager.readImpl(in, ob, "SctData::ScanResult");

    RawScanResult& raw = dynamic_cast<RawScanResult&>(ob);
    helper.set(raw);

    //cout <<"Parent finished" << endl;
    //cout << raw.getHeader().getRunNumber() << "  " << raw.getHeader().getScanNumber()
    //     << "  " << raw.getHeader().getModuleName() << endl;

    //Now refresh and fill the data
    readData(in, raw);
    
    // cout <<"Done" << endl;
}


void RawScanResultStreamer_v1::setHistSize(RawScanResult& raw, unsigned nbinsx, short unsigned ilink) const{
  //cout << "RawScanResultStreamer_v1 setHistSize " << nbinsx <<" "<< ilink<<endl;
  // check its not already the right size!
  if ( helper.getScanData(ilink) && (unsigned) helper.getScanData(ilink)->GetNbinsX()==nbinsx ) return;

  //Create hists
  double* bins = raw.getPoints().getEdgesAscending();
  
  ostringstream name; name << raw.getUniqueID() << "_link" << ilink;
  auto_ptr<TH2D> link_hist (new TH2D(name.str().c_str(), name.str().c_str(), nbinsx, -0.5, nbinsx-0.5,
                     raw.getPoints().getNPoints(), bins));
  
  delete [] bins;
  
  link_hist->SetEntries(1);
  helper.setScanData(ilink, link_hist);
}

void RawScanResultStreamer_v1::readData(IStream& in, RawScanResult& raw) const {
    unsigned int size;
    unsigned short type;
    unsigned short width;
    in >> size >> type >> width;

    helper.setDataType(type);

    switch (type) {
    case SR_DT_SLICE:
        readSliceData(size, width, in, raw);
        return;
    case SR_DT_ROOTHIST:
        readRootData(size, width, in, raw);
        return;
    case SR_DT_RAWHIST:
        readRawData(size, width, in, raw);
        return;
    default:
    ostringstream oss;
    oss << "RawScanResultIS::refreshData Unknown data format: " << type << " size was: " << size;
        throw VersionNotSupportedException(oss.str(), __FILE__, __LINE__); 
    }
}

void RawScanResultStreamer_v1::readRootData(unsigned int isize, unsigned short width, IStream& in, RawScanResult& raw) const {
    
    for (unsigned ilink=0; ilink<2; ++ilink){
      double* data;
      unsigned int size = 0;
      in.get(&data, size);    
      
      unsigned size_y= raw.getPoints().getNPoints() + 2 ;
      if (size % size_y !=0 ) {
    ostringstream oss;
    oss << "RawScanResultIS::readRootData.  Link " << ilink << " size = " << size << ", not divisible by " << size_y;
    throw StreamCorruptedException(oss.str(), __FILE__, __LINE__);
      }
      unsigned size_x=size/size_y;
      if (size_x<=1){
    ostringstream oss;
    oss << "X-size of root data must be 2 or greater! Got "<< size_x;
    throw StreamCorruptedException(oss.str(), __FILE__, __LINE__);
      }
      setHistSize(raw, size_x-2, ilink);
      //cout << "link 0 size_y = " << size_x << " nbins_x= " << size_x << endl;
      for (unsigned int i=0; i<size; ++i) {
        helper.getScanData(ilink)->SetBinContent(i, data[i]);
      }
      delete [] data;
    }
}

void RawScanResultStreamer_v1::readRawData(unsigned int isize, unsigned short width, IStream& in, RawScanResult& raw) const {
  int npoints = raw.getPoints().getNPoints();
  unsigned wid_mult = width==SR_WD_16 ? 1 : width==SR_WD_32 ? 2 : width==SR_WD_64 ? 4 : 0;
  unsigned quotient = npoints * wid_mult;
  if (quotient==0 || isize % quotient != 0) {
    ostringstream oss; oss << "Data size  = " << isize << " but trying to divide by " << quotient;
    throw StreamCorruptedException(oss.str(), __FILE__, __LINE__);
  } 
  unsigned x_size = isize / quotient;

  for (unsigned ilink=0; ilink<2; ++ilink){
    setHistSize(raw, x_size, ilink);
  }
  
  TH2D* link0 = helper.getScanData(0);
  TH2D* link1 = helper.getScanData(1);

  unsigned size=0;
  bool ascending=raw.getPoints().ascending();
  switch (width) {
  case SR_WD_16:{
    UINT16* data = 0;
    in.get(&data, size);
    if (size!=isize){
      ostringstream oss; oss << "Size (" << size << ") dosent match header size(" << isize << ")";
      throw StreamCorruptedException(oss.str(), __FILE__, __LINE__);
    }
    for (int j=0; j<npoints; ++j) {
      int ipt=ascending ? j : npoints-j-1;
      for (unsigned int i=0; i<x_size; ++i) {
    //+1 because bin 0 is underflow
    link0->SetBinContent(link0->GetBin(i+1,j+1), data[ipt*x_size*2 + i]);
    link1->SetBinContent(link1->GetBin(i+1,j+1), data[ipt*x_size*2 + i+x_size]);
      }
    }
    delete[] data; return;
  }
  case SR_WD_32: {
    UINT32* data = 0;
    in.get(&data, size);
    if (size!=isize){
      ostringstream oss; oss << "Size (" << size << ") dosent match header size(" << isize << ")";
      throw StreamCorruptedException(oss.str(), __FILE__, __LINE__);
    }
    for (int j=0; j<npoints; ++j) {
      int ipt=ascending ? j : npoints-j-1;
      for (unsigned int i=0; i<x_size; ++i) {
    //+1 because bin 0 is underflow
    link0->SetBinContent(link0->GetBin(i+1,j+1), data[ipt*x_size*2 + i]);
    link1->SetBinContent(link1->GetBin(i+1,j+1), data[ipt*x_size*2 + i+x_size]);
      }
    }
    delete[] data; return;
  }
  default : {
    ostringstream oss; oss << "Dont know how to interpret data of width " << width;
    throw UnsupportedOperationError(oss.str(), __FILE__, __LINE__);
  }
  }
}

void RawScanResultStreamer_v1::readSliceData(unsigned int isize, unsigned short width, IStream& in, RawScanResult& raw) const {
    int npoints = raw.getPoints().getNPoints();
    unsigned expectedSize=2048u * npoints;

    //cout << width << endl;
    if (isize != expectedSize) 
    throw StreamCorruptedException("RawScanResultIS::readSliceData. Expected and header sizes not equal.  Expected: " + lexical_cast<string>(expectedSize) + 
                       " but header: " + lexical_cast<string>(isize), __FILE__, __LINE__);
    
    setHistSize(raw, nChannelLink, 0);
    setHistSize(raw, nChannelLink, 1);
    
    TH2D* link0 = helper.getScanData(0);
    TH2D* link1 = helper.getScanData(1);
    unsigned int size = 0;
    bool ascending=raw.getPoints().ascending();
    switch (width) {
    case SR_WD_16:{
    UINT16* data = 0;
    in.get(&data, size);
    
    //cout << "16bit: expected: " << expectedSize << " header: " << isize << " actual: " << size << endl;
    if (size != expectedSize)
        throw StreamCorruptedException("RawScanResultIS::readSliceData. Expected and actual sizes not equal.  Expected: " + lexical_cast<string>(expectedSize) + 
                       " but actual: " + lexical_cast<string>(size), __FILE__, __LINE__);
    
    for (int j=0; j<npoints; ++j) {
      int ipt=ascending ? j : npoints-j-1;
      for (unsigned int i=0; i<nChannelLink; ++i) {
        //+1 because bin 0 is underflow
        link0->SetBinContent(link0->GetBin(i+1,j+1), data[ipt*2048 + i]);
        link1->SetBinContent(link1->GetBin(i+1,j+1), data[ipt*2048 + i+1024]);
        }
    }
    delete[] data;  
    }
    return;
    
    case SR_WD_32: {
    UINT32* data = 0;
    in.get(&data, size);
    
    //cout << "32bit: expected: " << expectedSize << " header: " << isize << " actual: " << size << endl;
    if (size != expectedSize)
        throw StreamCorruptedException("RawScanResultIS::readSliceData. Expected and actual sizes not equal.  Expected: " + lexical_cast<string>(expectedSize) + 
                       " but actual: " + lexical_cast<string>(size), __FILE__, __LINE__);
    
    for (int j=0; j<npoints; ++j) {
      int ipt=ascending ? j : npoints-j-1;
      for (unsigned int i=0; i<nChannelLink; ++i) {
        //+1 because bin 0 is underflow
        link0->SetBinContent(link0->GetBin(i+1,j+1), data[ipt*2048 + i]);
        link1->SetBinContent(link1->GetBin(i+1,j+1), data[ipt*2048 + i+1024]);
        }
    }
    delete[] data;  
    }
    return;
    }
    

}

}
}

---