QRunData.cc

Go to the documentation of this file.

#include "QRunData.hh"
#include <sstream>
#include <TBuffer.h>
 
class TBuffer;
 
using std::stringstream;
 
QObjectImp(QRunData);
 
 
void QRunData::Clear()
{
    fNumber = Q_INT_DEFAULT;
    fSourceRun = Q_INT_DEFAULT;
    fDetector = DN_UNKNOWN;
    fType = RT_UNKNOWN;
    fSourceType = RT_UNKNOWN;
    fThermalDetectorChannels.clear();
    fBolometerChannels.clear();
    fThermometerChannels.clear();
    fStartDate = 0;
    fStopDate = 0;
    fDuration = 0;
    fChannelsRunData_ptr.clear();
    for (auto& entry : fChannelsRunData_ptr) {
        delete entry.second;
    }
}
 
void QRunData::Dump(std::ostream& o) const
{
    o<<"RunNumber         : "<<fNumber<<std::endl;
    o<<"SourceRun         : "<<fSourceRun<<std::endl;
    o<<"Detector          : "<<fDetector.AsString()<<std::endl;
    o<<"Type              : "<<fType.AsString()<<std::endl;
    o<<"SourceType        : "<<fSourceType.AsString()<<std::endl;
    o<<"# of thermal det. : "<<fThermalDetectorChannels.size()<<std::endl;
    o<<"# of bolometers   : "<<fBolometerChannels.size()<<std::endl;
    o<<"# of thermometers : "<<fThermometerChannels.size()<<std::endl;
    o<<"Start date        : "<<ctime(&fStartDate);
    o<<"Stop date         : "<<ctime(&fStopDate);
    o<<"Duration          : "<<fDuration<<" s"<<" ("<<float(fDuration)/3600<<" h)"<<std::endl;
 
    double samplMin = 1e15, samplMax=-1e15;
    double ADC2mVMin = 1e15, ADC2mVMax=-1e15;
//    for(size_t i = 0; i < fThermalDetectorChannels.size(); i++) {
      for(std::map<int,QChannelRunData*>::const_iterator it = fChannelsRunData_ptr.cbegin();it!=fChannelsRunData_ptr.cend();it++){
//        const QChannelRunData& chanRunData = GetChannelRunData(fThermalDetectorChannels[i]);
        const QChannelRunData& chanRunData = *it->second;
        if(chanRunData.fSamplingFrequency > samplMax) samplMax = chanRunData.fSamplingFrequency;
        if(chanRunData.fSamplingFrequency < samplMin) samplMin = chanRunData.fSamplingFrequency;
        if(chanRunData.fADC2mV > ADC2mVMax) ADC2mVMax = chanRunData.fADC2mV;
        if(chanRunData.fADC2mV < ADC2mVMin) ADC2mVMin = chanRunData.fADC2mV;
    }
    o<<"Sampling frequency: ";
    if(samplMin == samplMax) {
        o<<samplMin;
    } else {
        o<<"["<<samplMin<<","<<samplMax<<"]";
    }
    o<<" Hz"<<std::endl;
    o<<"ADC2mV            : ";
    if(ADC2mVMin == ADC2mVMax) {
        o<<ADC2mVMin;
    } else {
        o<<"["<<ADC2mVMin<<","<<ADC2mVMax<<"]";
    }
    o<<" mV/ADC units"<<std::endl;
 
}
 
QError QRunData::WriteOnStream(std::ostream& o) const
{
  QError err = QERR_SUCCESS;
 
  o<<"fNumber"<<"\t"<<fNumber<<std::endl;
  o<<"fDetector"<<"\t"<<fDetector.AsString()<<std::endl;
  o<<"fType"<<"\t"<<fType.AsString()<<std::endl;
 
 
  // thermal detector channels
  o<<"fThermalDetectorChannels.size"<<"\t"<<fThermalDetectorChannels.size()<<std::endl;
  for(size_t i =0; i < fThermalDetectorChannels.size(); i++) {
    o<<"fThermalDetectorChannels["<<i<<"]\t"<<fThermalDetectorChannels[i]<<std::endl;
  }
 
  // bolometer channels
  o<<"fBolometerChannels.size"<<"\t"<<fBolometerChannels.size()<<std::endl;
  for(size_t i =0; i < fBolometerChannels.size(); i++) {
    o<<"fBolometerChannels["<<i<<"]\t"<<fBolometerChannels[i]<<std::endl;
  }
 
  // thermometer channels
  o<<"fThermometerChannels.size"<<"\t"<<fThermometerChannels.size()<<std::endl;
  for(size_t i =0; i < fThermometerChannels.size(); i++) {
    o<<"fThermometerChannels["<<i<<"]\t"<<fThermometerChannels[i]<<std::endl;
  }
  
  // channels run data
  for(size_t i =0; i < fThermalDetectorChannels.size(); i++) {
    int chan = fThermalDetectorChannels[i];
    const QChannelRunData & chrundata = GetChannelRunData(chan);
    
    o<<"fChannelsRunData["<<i<<"].fADC2mV"<<"\t"<<chrundata.fADC2mV<<std::endl;
    o<<"fChannelsRunData["<<i<<"].fSamplingFrequency"<<"\t"<<chrundata.fSamplingFrequency<<std::endl;
    o<<"fChannelsRunData["<<i<<"].fADCMax"<<"\t"<<chrundata.fADCMax<<std::endl;
    o<<"fChannelsRunData["<<i<<"].fADCMin"<<"\t"<<chrundata.fADCMin<<std::endl;
    o<<"fChannelsRunData["<<i<<"].fNumberOfSamples"<<"\t"<<chrundata.fNumberOfSamples<<std::endl;
    o<<"fChannelsRunData["<<i<<"].fIsBolometer"<<"\t"<<chrundata.fIsBolometer<<std::endl;
    o<<"fChannelsRunData["<<i<<"].fIsThermometer"<<"\t"<<chrundata.fIsThermometer<<std::endl;    
  }
  
  o<<"fStartDate"<<"\t"<<fStartDate<<std::endl;
  o<<"fStopDate"<<"\t"<<fStopDate<<std::endl;
  o<<"fDuration"<<"\t"<<fDuration<<std::endl;
  
  return err;
}
 
QError QRunData::ReadFromStream(std::istream& ob) 
{
  QError err = QERR_SUCCESS;
  
  std::string tag, det, type;
  size_t td_size, b_size, t_size;
  int nrun, tdc, bc, tc;
  double adc2mv, samplf;
  int adcmax, adcmin, nsamples;
  bool isbol, istherm;
  time_t start, stop, duration;
 
  // fNumber 
  ob >> tag >> nrun;
  if(tag != "fNumber") {
    err = QERR_UNKNOWN_ERR;
    err.SetDescription("Expected tag fNumber");
    return err;  
  }
  fNumber = nrun;
 
  // fDetector
  ob >> tag >> det;
  if(tag != "fDetector") {
    err = QERR_UNKNOWN_ERR;
    err.SetDescription("Expected tag fDetector");
    return err;  
  }
  fDetector.Set(nrun);
 
  // fType
  ob >> tag >> type;
  if(tag != "fType") {
    err = QERR_UNKNOWN_ERR;
    err.SetDescription("Expected tag fType");
    return err;  
  }
  fType.Set(type);
 
  // fThermalDetectorChannels
 
  fThermalDetectorChannels.clear();
  ob >> tag >> td_size;
 
  if(tag != "fThermalDetectorChannels.size") {
    err = QERR_UNKNOWN_ERR;
    err.SetDescription("Expected tag fThermalDetectorChannels.size()");
    return err;  
  }
 
  for(size_t i =0; i < td_size; i++) {
    ob >> tag >> tdc;
    stringstream tagstr;
    tagstr<<"fThermalDetectorChannels["<<i<<"]";
    if(tag != tagstr.str()) {
      err = QERR_UNKNOWN_ERR;
      err.SetDescription(std::string("Expected tag ")+tagstr.str());
      return err;
    }
    fThermalDetectorChannels.push_back(tdc);
  }
 
  // fBolometerChannels
 
  fBolometerChannels.clear();
  ob >> tag >> b_size;
 
  if(tag != "fBolometerChannels.size") {
    err = QERR_UNKNOWN_ERR;
    err.SetDescription("Expected tag fBolometerChannels.size()");
    return err;  
  }
 
  for(size_t i =0; i < b_size; i++) {
    ob >> tag >> bc;
    stringstream tagstr;
    tagstr<<"fBolometerChannels["<<i<<"]";
    if(tag != tagstr.str()) {
      err = QERR_UNKNOWN_ERR;
      err.SetDescription(std::string("Expected tag ")+tagstr.str());
      return err;
    }
    fBolometerChannels.push_back(bc);
  }
 
 // fThermometerChannels
 
  fThermometerChannels.clear();
  ob >> tag >> t_size;
 
  if(tag != "fThermometerChannels.size") {
    err = QERR_UNKNOWN_ERR;
    err.SetDescription("Expected tag fThermometerChannels.size()");
    return err;  
  }
 
  for(size_t i =0; i < t_size; i++) {
    ob >> tag >> tc;
    stringstream tagstr;
    tagstr<<"fThermometerChannels["<<i<<"]";
    if(tag != tagstr.str()) {
      err = QERR_UNKNOWN_ERR;
      err.SetDescription(std::string("Expected tag ")+tagstr.str());
      return err;
    }
    fThermometerChannels.push_back(tc);
  }
 
  // fChannelsRunData
 
  for(size_t i =0; i < td_size; i++) {
    int chan = fThermalDetectorChannels[i];
    QChannelRunData chrundata;
 
    ob >> tag >> adc2mv;
    stringstream tagstr;
    tagstr<<"fChannelsRunData["<<i<<"].fADC2mV";
    if(tag != tagstr.str()) {
      err = QERR_UNKNOWN_ERR;
      err.SetDescription(std::string("Expected tag ")+tagstr.str());
      return err;
    }
    chrundata.fADC2mV = adc2mv;
 
    ob >> tag >> samplf;
    tagstr.str("");
    tagstr<<"fChannelsRunData["<<i<<"].fSamplingFrequency";
    if(tag != tagstr.str()) {
      err = QERR_UNKNOWN_ERR;
      err.SetDescription(std::string("Expected tag ")+tagstr.str());
      return err;
    }
    chrundata.fSamplingFrequency = samplf;
 
    ob >> tag >> adcmax;
    tagstr.str("");
    tagstr<<"fChannelsRunData["<<i<<"].fADCMax";
    if(tag != tagstr.str()) {
      err = QERR_UNKNOWN_ERR;
      err.SetDescription(std::string("Expected tag ")+tagstr.str());
      return err;
    }
    chrundata.fADCMax = adcmax;
 
    ob >> tag >> adcmin;
    tagstr.str("");
    tagstr<<"fChannelsRunData["<<i<<"].fADCMin";
    if(tag != tagstr.str()) {
      err = QERR_UNKNOWN_ERR;
      err.SetDescription(std::string("Expected tag ")+tagstr.str());
      return err;
    }
    chrundata.fADCMin = adcmin;
 
    ob >> tag >> nsamples;
    tagstr.str("");
    tagstr<<"fChannelsRunData["<<i<<"].fNumberOfSamples";
    if(tag != tagstr.str()) {
      err = QERR_UNKNOWN_ERR;
      err.SetDescription(std::string("Expected tag ")+tagstr.str());
      return err;
    }
    chrundata.fNumberOfSamples = nsamples;
 
    ob >> tag >> isbol;
    tagstr.str("");
    tagstr<<"fChannelsRunData["<<i<<"].fIsBolometer";
    if(tag != tagstr.str()) {
      err = QERR_UNKNOWN_ERR;
      err.SetDescription(std::string("Expected tag ")+tagstr.str());
      return err;
    }
    chrundata.fIsBolometer = isbol;
 
    ob >> tag >> istherm;
    tagstr.str("");
    tagstr<<"fChannelsRunData["<<i<<"].fIsThermometer";
    if(tag != tagstr.str()) {
      err = QERR_UNKNOWN_ERR;
      err.SetDescription(std::string("Expected tag ")+tagstr.str());
      return err;
    }
    chrundata.fIsBolometer = istherm;
 
    SetChannelRunData(chan,chrundata);
 
  }
 
  // fStartTime 
  ob >> tag >> start;
  if(tag != "fStartDate") {
    err = QERR_UNKNOWN_ERR;
    err.SetDescription("Expected tag fStartDate");
    return err;  
  }
  fStartDate = start;
 
  // fStopTime 
  ob >> tag >> stop;
  if(tag != "fStopDate") {
    err = QERR_UNKNOWN_ERR;
    err.SetDescription("Expected tag fStopDate");
    return err;  
  }
  fStopDate = stop;
 
  // fDuration 
  ob >> tag >> duration;
  if(tag != "fDuration") {
    err = QERR_UNKNOWN_ERR;
    err.SetDescription("Expected tag fDuration");
    return err;  
  }
  fDuration = duration;
 
  return err;
}
 
const QChannelRunData& QRunData::GetChannelRunData(const int channel) const
{
    std::map<int,QChannelRunData*>::const_iterator iter = fChannelsRunData_ptr.find(channel);
    if(iter == fChannelsRunData_ptr.end()) {
        QError err=QERR_OUT_OF_RANGE;
        stringstream msg;
        msg<<"Cannot find QChannelRunData for channel "<<channel<<" in QRunData of run "<<fNumber;
        err.SetDescription(__FILE__,__LINE__,msg.str());
        throw err;
    }
    return *(iter->second);
}
 
void QRunData::SetChannelRunData(const int channel,const QChannelRunData& chanRunData)
{
    const QChannelRunData* chptr = &chanRunData;
    QChannelRunData* newptr= dynamic_cast<QChannelRunData*>(chptr->Duplicate());
    chptr->Fill(newptr);
    fChannelsRunData_ptr[channel] = newptr;
}
 
QRunData& QRunData::operator=(const QRunData& other){
//    this->QObject::operator=(other);
    fNumber = other.fNumber;
    fType = other.fType;
    fSourceType = other.fSourceType;
    fSourceRun = other.fSourceRun;
    fDetector = other.fDetector;
    fStartDate = other.fStartDate;
    fStopDate = other.fStopDate;
    fDuration = other.fDuration;
    
    fBolometerChannels=other.fBolometerChannels;
    fThermometerChannels=other.fThermometerChannels;
    fThermalDetectorChannels = other.fThermalDetectorChannels;
   
    for(auto it=other.fChannelsRunData_ptr.cbegin();it!=other.fChannelsRunData_ptr.cend();it++){
        SetChannelRunData(it->first,other.GetChannelRunData(it->first));
    }    
 
    return *this;
}
/*
void QRunData::Streamer(TBuffer &R__b){
    if(R__b.IsReading()){
        UInt_t R__s,R__c;
        Version_t R__v = R__b.ReadVersion(&R__s,&R__c);
        if(R__v<5){
            QObject::Streamer(R__b);
            R__b>>fNumber;
            R__b.ReadClassBuffer(TClass::GetClass<DetectorName>(),&fDetector);
            R__b.ReadClassBuffer(TClass::GetClass<RunType>(),&fType);//Working until here
//            R__b.StreamObject(&fThermalDetectorChannels);
//            StreamVector(R__b, fThermalDetectorChannels);
            size_t vsize;
            R__b>>vsize;
            std::cout<<"Thermal Size:"<<vsize<<std::endl;
            R__b>>vsize;
            std::cout<<"Bolo Size:"<<vsize<<std::endl;
            R__b>>vsize;
            std::cout<<"Thermo Size:"<<vsize<<std::endl;
            R__b>>fStartDate;
            R__b>>fStopDate;
            R__b>>fDuration;
            
            //std::map<int,QChannelRunData> fChannelsRunData;
            //R__b>>fSourceRun;
            //R__b.ReadClassBuffer(TClass::GetClass<RunType>(),&fSourceType);//Working until here
            //Dump(std::cout);
            //std::cout<<"Thermal "<<vsize<<std::endl;
            //fThermalDetectorChannels.resize(vsize);
            //for(auto& element:fThermalDetectorChannels){
            //    R__b>>element;
            //}
            //R__b>>fThermalDetectorChannels;
            //R__b>>fBolometerChannels;
            //R__b>>fThermometerChannels;
            //R__b>>fStartDate;
            //R__b>>fStopDate;
            //R__b>>fDuration;
            //std::map<int,QChannelRunData> fmap;
            //R__b>>fmap;
            //std::map<int,QChannelRunData>::iterator it;
            //for(it = fmap.begin();it!=fmap.end();it++){
            //    SetChannelRunData(it->first,it->second);
            //}
            //R__b>>fSourceRun;
            //R__b>>fSourceType;
 //           R__b.ReadClassBuffer(QRunData::Class(),this,R__v,R__s,R__c);
        }else{
            R__b.ReadClassBuffer(QRunData::Class(),this,R__v,R__s,R__c);
        }
    }else{
        QRunData::Class()->WriteBuffer(R__b,this);
    }
}
*/