ScanResultWriter.cpp

00001 #include "ScanResultWriter.h"
00002 #include "ScanWriterFactory.h"
00003 #include "ScanDataWriter.h"
00004 #include "scan.h"
00005 #include "Sct/SctNames.h"
00006 #include "Sct/Serializable.h"
00007 #include "Sct/ISProxy/IOManagerISProxy.h"
00008 #include <CommonWithDsp/processor.h>
00009 
00010 #include <sstream>
00011 
00012 using namespace std;
00013 using namespace Sct;
00014 using namespace Sct::IS;
00015 using namespace Sct::ISProxy;
00016 
00017 /* READ NOTES ON STREAMERS AND VERSIONS BEFORE EDITING THIS FILE! */
00018 
00019 namespace SctData {
00020 
00025 class SerializableWrapper : public virtual Serializable {    
00026 public:
00027     SerializableWrapper(const string& className, const scan_result_ptrs& data) 
00028     : className(className), uniqueID(data.header.runNumber, data.header.scanNumber, data.header.moduleName) {
00029     }
00030 
00031     ~SerializableWrapper() throw() {}
00032     
00033     virtual string getClassName() const throw() {
00034     return className;
00035     }
00036     
00037     virtual Sct::UniqueID getUniqueID() const throw() {
00038     return uniqueID;
00039     }
00040     
00041 private:
00042     string className;
00043     Sct::UniqueID uniqueID;
00044 };
00045 
00046 /* READ NOTES ON STREAMERS AND VERSIONS BEFORE EDITING THIS FILE! */
00047 
00048 unsigned ScanResultWriter::getVersion() const throw(){
00049   return m_version;
00050 }
00051 
00052 //No need to do anything
00053 ScanResultWriter::ScanResultWriter(const string& className, unsigned version) 
00054     : scanResult(0), className(className), m_version(version) {}
00055 
00056 ScanResultWriter& ScanResultWriter::getRawWriter() {
00057   static ScanResultWriter* rawWriter = new ScanResultWriter("SctData::RawScanResult", 2);
00058   return *rawWriter;
00059 }
00060 
00061 bool ScanResultWriter::rawInMap = IOManager::addToMap("SctData::RawScanResult", auto_ptr<Streamer>(&getRawWriter()));
00062 
00063 /*ScanResultWriter& ScanResultWriter::getFitWriter() {
00064     static ScanResultWriter* fitWriter = new ScanResultWriter("FitScanResult");
00065     return *fitWriter;
00066 }*/
00067 
00068 
00069 bool ScanResultWriter::publish(scan_result_ptrs& scanResult) {
00070     //Now we can get hold of the ScanResultWriter we need
00071     ScanResultWriter& writer = ScanWriterFactory::getResultWriter(scanResult.header.dataType);
00072     writer.setData(scanResult);
00073 
00074     SerializableWrapper w(writer.className, scanResult);
00075     IOParamsIS params(SctNames::getEventDataName());
00076     IOManagerISProxy::instance().write(w, &params);
00077 
00078     return true;
00079 }
00080 
00081 void ScanResultWriter::write(OStream& out, const Streamable& ob, const IOManager& manager) const throw(LogicError, IoError) {
00082     writeHeader(out);
00083     writeScanPoints(out);
00084     writeConfiguration(out);
00085     writeData(out);
00086 }
00087     
00088 shared_ptr<Streamable> ScanResultWriter::read(IStream& in, const IOManager& manager) const throw(LogicError, IoError) {
00089     return shared_ptr<Streamable>();
00090 }
00091 
00092 void ScanResultWriter::read(IStream& in, Streamable& ob, const IOManager& manager) const throw(LogicError, IoError) {
00093 }
00094 
00095 
00096 
00097 void ScanResultWriter::setData(scan_result_ptrs& scanResult) {
00098     this->scanResult = &scanResult;
00099 }
00100 
00101 void ScanResultWriter::writeHeader(OStream& out) const {
00102     writeClass("SctData::ResultHeader", out);
00104     //out << scanResult->header.version
00105     out << scanResult->header.runNumber << scanResult->header.scanNumber << scanResult->header.moduleName 
00106     << scanResult->header.startTime << scanResult->header.endTime << scanResult->header.scanType;
00107 }
00108 
00109 void ScanResultWriter::writeScanPoints(OStream& out) const {
00110     writeClass("SctData::ScanPoints", out);
00111     //First the points header
00112     out << scanResult->header.npoints;
00113     //Now the points data
00114     out.put(scanResult->points, scanResult->header.npoints);
00115     out.put(scanResult->nEvents, scanResult->header.npoints);
00116     out.put(scanResult->nErrorEvents, scanResult->header.npoints);
00117 }
00118 
00119 void ScanResultWriter::writeConfiguration(OStream& out) const {
00120     writeClass("SctData::ModuleConfiguration", out);
00121     const ABCDModule& data = scanResult->header.config;
00122 
00123     for (unsigned int i=0; i<N_SCT_CHIPS; ++i) {
00124         writeChipConfig(out, data.chip[i]);
00125     }
00126     out << (UINT8)data.present << (UINT8)data.active << (UINT8)data.select 
00127     << (UINT8)data.groupId << (UINT8)data.pTTC << (UINT8)data.rTTC;
00128     out.put(data.rx, 2);
00129     //cout << "data.groupId: " << (int)data.groupId  << endl;
00130 }
00131 
00132 void ScanResultWriter::writeChipConfig(OStream& out, const ABCDChip& data) const{
00133     out << (UINT8)data.active << (UINT8)data.address << (UINT8)data.target;
00134       
00135     //ABCDBasic stuff:
00136     
00137     //Config values
00138     out << (UINT16)data.basic.config.readoutMode << (UINT16)data.basic.config.calibMode << (UINT16)data.basic.config.trimRange;
00139     out << (UINT16)data.basic.config.edgeDetect << (UINT16)data.basic.config.mask << (UINT16)data.basic.config.accumulate;
00140     out << (UINT16)data.basic.config.inputBypass << (UINT16)data.basic.config.outputBypass << (UINT16)data.basic.config.master;
00141     out << (UINT16)data.basic.config.end << (UINT16)data.basic.config.feedThrough;
00142     
00143     out << data.basic.vthr << data.basic.vcal << data.basic.delay << data.basic.preamp << data.basic.shaper;
00144     out.put(data.basic.mask, 4);
00145     
00146     //ABCDCalData
00147     out << (UINT8)data.caldata.rc_function;
00148     //cout << "rc_function: " << (int)data.caldata.rc_function << endl;
00149     out.put(data.caldata.rc_params, 3);
00150     out << data.caldata.c_factor;
00151     
00152     out.put(data.trim, N_SCT_CHANS);
00153     //cout << "data.trim[35]" << (int)data.trim[35] << endl;
00154 }
00155 
00156 
00157 void ScanResultWriter::writeData(OStream& out) const {
00158     ScanDataWriter& writer = ScanWriterFactory::getDataWriter(scanResult->header.dataType);
00159     writer.writeData(*scanResult, out);
00160 }
00161 
00162 
00163 //Writes any stuff necessary for a class - ie nothing atm
00164 void ScanResultWriter::writeClass(const string& name, OStream& out) {}
00165 }

Generated on Mon Feb 6 14:01:27 2006 for SCT DAQ/DCS Software - C++ by  doxygen 1.4.6