DoubleTriggerNoiseTestResultStreamer_v3.cpp

#include "../DoubleTriggerNoiseTestResult.h"
#include "DoubleTriggerNoiseTestResultStreamer_v3.h"
#include <vector>

using namespace Sct;

namespace SctData {
namespace IO {

/* READ NOTES ON STREAMERS AND VERSIONS BEFORE EDITING THIS FILE! */
unsigned DoubleTriggerNoiseTestResultStreamer_v3::s_version=3;
    
DoubleTriggerNoiseTestResultStreamer_v3::DoubleTriggerNoiseTestResultStreamer_v3() throw() {
}

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

shared_ptr<Streamable> DoubleTriggerNoiseTestResultStreamer_v3::read(IStream& in, const IOManager& manager) const throw(LogicError, IoError) {
    shared_ptr<Streamable> ad (new DoubleTriggerNoiseTestResult());
    read(in, *ad, manager);
    return ad;
}

void DoubleTriggerNoiseTestResultStreamer_v3::write(OStream& out, const Streamable& ob, const IOManager& manager) const throw(LogicError, IoError) {
    //Let superclass do its work
    manager.writeImpl(out, ob, "SctData::TestResult");
    const DoubleTriggerNoiseTestResult& result=dynamic_cast<const DoubleTriggerNoiseTestResult&>(ob);
    
    float* vals=new float[nChipModule];
    for (unsigned ichip=0; ichip<nChipModule; ++ichip){
      vals[ichip]=result.getPedestalOccupancy(ichip);
    }
    out.put(vals,nChipModule);
    
    for (unsigned ichip=0; ichip<nChipModule; ++ichip){
      vals[ichip]=result.getPeakOccupancy(ichip);
    }
    out.put(vals,nChipModule);
    
    for (unsigned ichip=0; ichip<nChipModule; ++ichip){
      vals[ichip]=result.getPeakOccupancyBin(ichip);
    }
    out.put(vals,nChipModule);
    
    for (unsigned ichip=0; ichip<nChipModule; ++ichip){
      vals[ichip]=result.getPeakRatio(ichip);
    }
    out.put(vals,nChipModule);
    delete[] vals;
}

void DoubleTriggerNoiseTestResultStreamer_v3::read(IStream& in, Streamable& ob, const IOManager& manager) const throw(LogicError, IoError) {
    manager.readImpl(in, ob, "SctData::TestResult");
    DoubleTriggerNoiseTestResult& result=dynamic_cast<DoubleTriggerNoiseTestResult&>(ob);

    float* peaks;
    float* peakbins;
    float* peakratios;
    float* peds;

    unsigned length;
    in.get(&peds, length);
    if (length!=nChipModule) throw StreamCorruptedException("Wrong size of data",__FILE__, __LINE__);
    for (unsigned ichip=0; ichip<nChipModule; ++ichip){
      result.setPedestalOccupancy(ichip, peds[ichip]);
    }
    
    in.get(&peaks, length);
    if (length!=nChipModule) throw StreamCorruptedException("Wrong size of data",__FILE__, __LINE__);
    for (unsigned ichip=0; ichip<nChipModule; ++ichip){
      result.setPeakOccupancy(ichip, peaks[ichip]);
    }

    in.get(&peakbins, length);
    if (length!=nChipModule) throw StreamCorruptedException("Wrong size of data",__FILE__, __LINE__);
    for (unsigned ichip=0; ichip<nChipModule; ++ichip){
      result.setPeakOccupancyBin(ichip, peakbins[ichip]);
    }

    in.get(&peakratios, length);
    if (length!=nChipModule) throw StreamCorruptedException("Wrong size of data",__FILE__, __LINE__);
    for (unsigned ichip=0; ichip<nChipModule; ++ichip){
      result.setPeakRatio(ichip, peakratios[ichip]);
    }

    delete[] peds;
    delete[] peaks;
    delete[] peakratios;
    delete[] peakbins;
}

}
}

---