00001 #include "Sct/VersionNotSupportedException.h"
00002 #include "Sct/IoExceptions.h"
00003
00004 #include "../TrimRangeTestResult.h"
00005 #include "TrimRangeTestResultStreamer_v1.h"
00006
00007 #include <TF1.h>
00008 #include <vector>
00009
00010 using std::ostringstream;
00011 using std::pair;
00012 using namespace Sct;
00013
00014 namespace SctData {
00015 namespace IO {
00016
00017
00018 unsigned TrimRangeTestResultStreamer_v1::s_version=1;
00019
00020 TrimRangeTestResultStreamer_v1::TrimRangeTestResultStreamer_v1() throw() {
00021
00022 }
00023
00024 bool TrimRangeTestResultStreamer_v1::inMap = IOManager::addToMap("SctData::TrimRangeTestResult", auto_ptr<Streamer>(new TrimRangeTestResultStreamer_v1()));
00025
00026
00027 shared_ptr<Streamable> TrimRangeTestResultStreamer_v1::read(IStream& in, const IOManager& manager) const throw(LogicError, IoError) {
00028 shared_ptr<Streamable> ad (new TrimRangeTestResult());
00029 read(in, *ad, manager);
00030 return ad;
00031 }
00032
00033 void TrimRangeTestResultStreamer_v1::write(OStream& out, const Streamable& ob, const IOManager& manager) const throw(LogicError, IoError) {
00034
00035
00036 manager.writeImpl(out, ob, "SctData::TestResult");
00037
00038 const TrimRangeTestResult& mytest = dynamic_cast <const TrimRangeTestResult&>(ob);
00039
00040 out << (int) mytest.chipTrimData.size();
00041 for (unsigned int i = 0; i < mytest.chipTrimData.size(); ++i) {
00042 writeData(out, *mytest.chipTrimData[i], manager);
00043 }
00044
00045 out << (int) mytest.chipTrim.size();
00046 for (unsigned int i = 0; i < mytest.chipTrim.size(); ++i) {
00047 writeTrim(out, *mytest.chipTrim[i], manager);
00048 }
00049
00050 out << mytest.charge << mytest.type << mytest.algorithm;
00051 }
00052
00053 void TrimRangeTestResultStreamer_v1::read(IStream& in, Streamable& ob, const IOManager& manager) const throw(LogicError, IoError) {
00054 manager.readImpl(in, ob, "SctData::TestResult");
00055
00056 TrimRangeTestResult& mytest = dynamic_cast < TrimRangeTestResult & >(ob);
00057
00058 int n = 0;
00059 in >> n;
00060 mytest.chipTrimData.resize(n);
00061 for (unsigned int i = 0; i<n; ++i) {
00062 mytest.chipTrimData[i] = shared_ptr<TrimRangeTestResult::ChipTrimData>(new TrimRangeTestResult::ChipTrimData() );
00063 readData(in, mytest, const_cast<TrimRangeTestResult::ChipTrimData&>(*mytest.chipTrimData[i]), manager);
00064 }
00065
00066 in >> n;
00067 mytest.chipTrim.resize(n);
00068 for (unsigned int i = 0; i<n; ++i) {
00069 mytest.chipTrim[i] = shared_ptr<TrimRangeTestResult::ChipTrim>(new TrimRangeTestResult::ChipTrim() );
00070 readTrim(in, mytest, const_cast<TrimRangeTestResult::ChipTrim&>(*mytest.chipTrim[i]), manager);
00071 }
00072
00073 in >> mytest.charge >> mytest.type >> mytest.algorithm;
00074 }
00075
00076 void TrimRangeTestResultStreamer_v1::writeTrim(OStream& out, const TrimRangeTestResult::ChipTrim& trim, const IOManager& manager) const throw(Sct::LogicError, Sct::IoError){
00077 out << trim.target << (int) trim.range;
00078 if (trim.channelTrim.size()!=nChannelChip){
00079 ostringstream os;
00080 os << "TrimRangeTestResultStreamer_v1::writeTrim, bad size " << trim.channelTrim.size();
00081 throw StreamCorruptedException(os.str(), __FILE__, __LINE__ );
00082 }
00083 out << (int) trim.channelTrim.size();
00084 for (unsigned i=0; i<trim.channelTrim.size(); ++i){
00085 Stat<TrimRangeTestResult::Trim> t=trim.channelTrim.getAt(i);
00086 int trim_i = t.value.trim;
00087 out << t.valid << trim_i << t.value.vthr;
00088 }
00089 }
00090
00091 void TrimRangeTestResultStreamer_v1::readTrim(IStream& in, TrimRangeTestResult& mytest, TrimRangeTestResult::ChipTrim& trim, const IOManager& manager) const throw(Sct::LogicError, Sct::IoError){
00092 in >> trim.target;
00093 int range; in >> range ; trim.range=range;
00094 int size; in >> size; trim.channelTrim.resize(size);
00095 if (size!=nChannelChip){
00096 ostringstream os;
00097 os << "TrimRangeTestResultStreamer_v1::readTrim, bad size " << trim.channelTrim.size();
00098 throw StreamCorruptedException(os.str(), __FILE__, __LINE__ );
00099 }
00100 for (unsigned i=0; i<size; ++i){
00101 Stat<TrimRangeTestResult::Trim>& t=trim.channelTrim.modifyAt(i);
00102 int trim_i;
00103 in >> t.valid >> trim_i >> t.value.vthr;
00104 t.value.trim=trim_i;
00105 }
00106 }
00107
00108 void TrimRangeTestResultStreamer_v1::writeData(OStream& out, const TrimRangeTestResult::ChipTrimData& chiptrim, const IOManager& manager) const throw(LogicError, IoError) {
00109 out << (int) chiptrim.channelData.size();
00110 for (unsigned i=0; i<chiptrim.channelData.size(); ++i){
00111 Stat<TrimRangeTestResult::TrimData> d=chiptrim.channelData.getAt(i);
00112
00113 out << d.valid << d.value.p0 << d.value.p1;
00114 out << (int) d.value.graph.size();
00115 for (unsigned ipt=0; ipt<d.value.graph.size(); ++ipt){
00116 out << d.value.graph[ipt].first << d.value.graph[ipt].second;
00117 }
00118 }
00119 }
00120
00121 void TrimRangeTestResultStreamer_v1::readData(IStream& in, TrimRangeTestResult& mytest, TrimRangeTestResult::ChipTrimData& chipTrim, const IOManager& manager) const throw(LogicError, IoError) {
00122 int size; in >> size;
00123 chipTrim.channelData.resize(nChannelChip);
00124 for (unsigned i=0; i<nChannelChip; ++i){
00125 Stat<TrimRangeTestResult::TrimData>& d=chipTrim.channelData.modifyAt(i);
00126 in >> d.valid >> d.value.p0 >> d.value.p1;
00127
00128 in >> size; d.value.graph.resize(size);
00129 for (int ipt=0; ipt<size; ++ipt){
00130 float first, second;
00131 in >> first; in >> second;
00132 d.value.graph[ipt]=pair<float,float>(first,second);
00133 }
00134 }
00135 }
00136 }
00137
00138
00139 }
00140