LHDRGlobalReader.cc

Go to the documentation of this file.

#include "LHDRGlobalReader.hh"
#include "QRunData.hh"
#include "QTime.hh"
#include <sstream>
#include <cmath>
 
REGISTER_GLOBAL_READER(LHDRGlobalReader,".hdr")
 
using namespace Diana;
using std::stringstream;
using std::string;
using std::iostream;
using std::ios;
using std::vector;
 
LHDRGlobalReader::LHDRGlobalReader() : QGlobalReader("HDRGlobalReader")
{
    fQObjectCache = new std::map<std::string, QObject*>;
}
 
LHDRGlobalReader::~LHDRGlobalReader()
{
    Close();
    delete fQObjectCache;
    fQObjectCache = 0;
}
 
QError LHDRGlobalReader::Open(const std::string& filename, const std::string& opt)
{
        QError err = QERR_SUCCESS;
        fFile.open(filename.c_str(),ios::in); 
        if(!fFile) 
        {
                err = QERR_CANNOT_OPEN_FILE;
                err.SetDescription(filename);
        fFile.close();
        } else {
        fName = filename;
        Parse();
    }
        return err;
}
 
 
QError LHDRGlobalReader::Close()
{
    QError err = QERR_SUCCESS;
    fFile.close();
    fName = "";
    if(!fQObjectCache) return err;
 
    std::map<std::string, QObject*>::iterator iter = fQObjectCache->begin();
    while(iter != fQObjectCache->end()) {
        if(iter->second) delete iter->second;
        iter++;
    }
    fQObjectCache->clear();
    return err;
}
 
const QObject* LHDRGlobalReader::GetQObject(const std::string& name,const std::string& className, QError& err) const
{
 
    err = QERR_SUCCESS;
    if(className == "QRunData") {
        std::map<std::string, QObject*>::const_iterator object = fQObjectCache->find(name);
        if(object != fQObjectCache->end()) {
            return object->second;
        } else {
            err = QERR_UNKNOWN_ERR;
            err.SetDescription(GetName(),__LINE__,std::string("Could not find object \"")+name+"\"");
        }
 
    } else {
        err = QERR_UNKNOWN_ERR;
        err.SetDescription(GetName(),__LINE__,std::string("Invalid type \"")+className+"\"");
    }
    return 0;
}
 
void LHDRGlobalReader::Parse()
{
    // basics
    std::string suffix = fName.substr(fName.size()-9 ,5);
    DetectorName detector;
    detector = DN_UNKNOWN;
    if(suffix.at(0) == 'c') { 
        detector = DN_HALLC;
    }
    else if(suffix.at(0) == 'q') {
        detector = DN_CUORICINO;
    }
    string sRunNumber = fName;
    sRunNumber = sRunNumber.substr(sRunNumber.size()-8,4);
    int runNumber = atoi(sRunNumber.c_str())+(int)detector*100000;
 
 
    float minADC,maxADC;
    int numSamples,pulseDurationMs;
    fFile>>minADC>>maxADC;
    fFile>>numSamples>>pulseDurationMs;
    float samplingFrequency =  float(numSamples) / pulseDurationMs * 1000;
 
    std::string line;
    getline(fFile,line);
    // channels
    vector<int> channels;
    while(1) {
        getline(fFile,line);
        if(line.size() > 0) line = line.substr(0,line.size()-1);
        bool blank = false;
        if(line.empty() || line[0] ==' ' || line[0] =='\n' || line[0] == '\0') blank = true;
        if(blank) break;
        else {
            std::stringstream str(line);
            int chan, active;
            str>>chan>>active;
            if(active) channels.push_back(chan);
        }
    }
    // start time, duration;
    std::string date;
    float duration;
    while(1) {
        getline(fFile,line);
        std::stringstream str(line);
        std::string word1,word2,word3;
        str>>word1;
        if(word1 == "Start") {
            str>>word2;
            str>>word3;
            if(word2 == "date") {
                date += word3 + " ";
            }
            else if(word2 == "time") {
                date += word3;
            }
        }
        if(word1 == "Timer") {
            str>>duration;
        }
        if(!fFile.good()) break;
    }
 
    QTime time;
    int month=atoi(date.substr(0,2).c_str());
    int day=atoi(date.substr(3,2).c_str());
    int year=atoi(date.substr(6,4).c_str());
    int hour=atoi(date.substr(11,2).c_str());
    int min=atoi(date.substr(14,2).c_str());
    int sec=atoi(date.substr(17,2).c_str());
    time.SetStartRunUnix(year,month,day,hour,min,sec);
    int ADCScale = (int)pow(2,16);
 
    QRunData* runData = new QRunData;
    runData->fNumber = runNumber;
    runData->fDetector = detector;
    runData->fType = RT_UNKNOWN;
    runData->fStartDate = time.GetStartRunUnix();
    runData->fStopDate = runData->fStartDate+(int)duration;
    runData->fDuration = (int)duration;
    runData->fThermalDetectorChannels = channels;
    runData->fBolometerChannels = channels;
    
    for(size_t i = 0; i < channels.size(); i++) {
        QChannelRunData cr;
        cr.fADC2mV = (maxADC-minADC)*1000./ADCScale;
        cr.fSamplingFrequency = samplingFrequency;
        cr.fADCMax = (int)ceil(maxADC*1000./cr.fADC2mV);
        cr.fADCMin = (int)floor(minADC*1000./cr.fADC2mV);
        cr.fNumberOfSamples = (int)(pulseDurationMs*samplingFrequency)/1000;
        cr.fIsBolometer = true;
        cr.fIsThermometer = false;
 
        runData->SetChannelRunData(channels[i],cr);
    }
 
    std::string name="DAQ@RunData_run";
    char runss[128];
    sprintf(runss,"%06d",runNumber);
    name += runss;
    runData->Validate();
    (*fQObjectCache)[name] = runData;
}