MQinoDataReader.cc

Go to the documentation of this file.

/* Diana Reconstruction program
 *
 * Class QinoDataReader
 *
*/
 
 
#include "MQinoDataReader.hh"
#include "QInoDataReaderDebug.hh"
#include "QEvent.hh"
#include "QEventAssembler.hh"
#include "QRawEvent.hh"
#include <cstdlib>
#include <ctime>
#include <iostream>
 
REGISTER_MODULE(MQinoDataReader)
 
        using namespace std;
 
 
// ctor
MQinoDataReader::MQinoDataReader() 
{
    fTimeZone = getenv("TZ");
    setenv("TZ", ":Europe/Rome", 1);
    tzset();
}
 
// dtor
MQinoDataReader::~MQinoDataReader() 
{
    if (fTimeZone) {
        setenv("TZ", fTimeZone, 1);
    }
    else {
                unsetenv("TZ");
        }
        tzset();
}
 
// Init method is called before event loop
void MQinoDataReader::Init(QEventAssembler& evi) 
{
        // Reads multiple or single files
        InitFileManager();
        fIter =  fFileList.begin();
        fPreTriggerSamples = GetInt("PreTriggerSamples",128);
        fIsNoise = GetBool("NoiseFile",false);
    fDebugOn = GetBool("DebugOn",false,false);
        if(fDebugOn) {
        evi.GetEvent().Add<QInoDataReaderDebug>("DebugData");
    }
 
        fSamplingFrequency = 0.;
        NewRun();
        fEventNumber = 0;
        fFileUName = " ";
        fDetector = DN_UNKNOWN;
    // initialize event
 
    evi.Add<QHeader>("DAQ","Header");
    evi.Add<QPulse>("DAQ","Pulse");
    evi.Add<QPulseInfo>("DAQ","PulseInfo");
}
 
// MARIA
const QError& MQinoDataReader::JumpToEvent(Long64_t event)
{
  // CHECK IF THE PARTIAL IS CORRECT 
  int partial = filesIter-files.begin();
  if (partial!=fPartialToJump) 
  {
    Info("Jumping to event %d. Closing partial %d. Opening %d",event, partial, fPartialToJump);
    gzclose(fCurrentFile);
    filesIter = files.begin()+fPartialToJump;
    fCurrentFile = gzopen(filesIter->filename.data(),"rb");
  }
 
  z_off_t off = gzseek(fCurrentFile, event*frecord_size, SEEK_SET);
 
  if (off==-1) 
  {
    fErr = QERR_OUT_OF_RANGE;
    char buf[128];
    sprintf(buf,"Cannot jump to event : %llu", event);
    fErr.SetDescription(buf);
  } 
  else 
  {
    fErr = QERR_SUCCESS;
    fEventNumber = event;
  }
  return fErr;
}
 
 
// Doit method is called for each event, getting the event as argument
bool MQinoDataReader::Do( QEventAssembler& evi) {
        // if first event open first file
        if(fEventNumber == 0){
                fCurrentFile = gzopen(filesIter->filename.data(),"rb");
        }
        // loop over events
        struct QBinRecStruct_t p;
        int ret = gzread(fCurrentFile,&p,frecord_size);
        // end of file?
        if ( ret != frecord_size) {
                //end of partial measurement
                Debug("End of file %s at event %d",filesIter->filename.data(),fEventNumber);
                gzclose(fCurrentFile);
                filesIter++;
                if(filesIter != filesEnd){                                      
                        fCurrentFile = gzopen(filesIter->filename.data(),"rb");                         
                        return Do(evi);
                }
                else {
                        fIter++;
                        //end of run 
                        if (fIter != fFileList.end()){
                                NewRun();
                                fCurrentFile = gzopen(filesIter->filename.data(),"rb");
                                return Do(evi);
                        }
                        else{
                                // end of file list
                                return false;
                        }
                }
        }       
    
        QHeader &header = evi.Get<QHeader>("DAQ","Header");
        QPulse &pulse = evi.Get<QPulse>("DAQ","Pulse");
        QPulseInfo &pulseInfo = evi.Get<QPulseInfo>("DAQ","PulseInfo");
    
 
        QTime &time = header.GetTime();
        header.SetEventNumber(fRunEventNumber);
        QSampleInfo &sampleInfo = pulseInfo.GetMasterSample();
        pulseInfo.SetChannelId(p.chan + 1); 
        QVectorI samplesADC;
        sampleInfo.SetTriggerNumber(0);
        sampleInfo.SetEventNumber(fRunEventNumber);
 
    WriteHandle<QInoDataReaderDebug> debugHandle("DebugData");
    evi.GetEvent().Get(debugHandle);
    
 
    if(fDebugOn) {
        QInoDataReaderDebug& readerDebug = debugHandle.Get();
        readerDebug.fEventNumber = fRunEventNumber;
        readerDebug.fChannel = p.chan+1;
    }
    std::string headFlag = p.cHeader;
    headFlag = headFlag.substr(0,8);
    headFlag += "\0";
 
        // stabilization heater
        if((headFlag == "HEADSRCE") || (headFlag == "headsrce")){
                sampleInfo.SetIsPulser();
                //sampleInfo.SetStabPulser(true);
                sampleInfo.SetPulserDelay(1);
                if(debugHandle.IsValid()) {
            QInoDataReaderDebug& readerDebug = debugHandle.Get();
            readerDebug.fIsHeater = true;
                        readerDebug.fIsStabHeater = true;
                }
        } 
 
        // high amplitude heater
        else if((headFlag == "HEADSRCH") || (headFlag == "headsrch")){
                sampleInfo.SetIsPulser();
                //sampleInfo.SetStabPulser(false);
                sampleInfo.SetPulserDelay(2);
                if(debugHandle.IsValid()) {
            QInoDataReaderDebug& readerDebug = debugHandle.Get();
            readerDebug.fIsHeater = true;
                        readerDebug.fIsHighHeater = true;
                }
        } 
 
        // low amplitude heater
        else if((headFlag == "HEADSRCL") || (headFlag == "headsrcl")){
                sampleInfo.SetIsPulser();
                // sampleInfo.SetStabPulser(false);
                sampleInfo.SetPulserDelay(3);
                if(debugHandle.IsValid()) {
            QInoDataReaderDebug& readerDebug = debugHandle.Get();
            readerDebug.fIsHeater = true;
                        readerDebug.fIsLowHeater = true;
                }
        }       
 
        //physical pulses
        else if((headFlag == "HEADSIGN") or (headFlag == "headsign") or 
                        (headFlag == "HEADFLAG") or (headFlag == "headflag")){
                sampleInfo.SetIsSignal();
                sampleInfo.SetTriggerNumber(1);
                if(debugHandle.IsValid()) {
            QInoDataReaderDebug& readerDebug = debugHandle.Get();
            readerDebug.fIsSignal = true;
            readerDebug.fTriggerType = 1;
                }
        }
        //random trigger
        else if((headFlag == "HEADTRND") or (headFlag == "headtrnd") or 
                        (headFlag == "HEADNOIS") or (headFlag == "headnois") ){
                sampleInfo.SetIsNoise();
                sampleInfo.SetTriggerNumber(2);
                if(debugHandle.IsValid()) {
            QInoDataReaderDebug& readerDebug = debugHandle.Get();
            readerDebug.fTriggerType = 2;
            readerDebug.fIsNoise = true;
                }
        }
        else{
                Debug(" record structure: %s at event %d, channel %d",headFlag.c_str(), fEventNumber,p.chan);
        }
 
        if(fIsNoise == true) 
        {
                sampleInfo.SetIsNoise();
                sampleInfo.SetTriggerNumber(2);
                if(debugHandle.IsValid()) {
            QInoDataReaderDebug& readerDebug = debugHandle.Get();
            readerDebug.fIsNoise = true;
                }
        }
 
        UInt_t timetenthms = (UInt_t)(p.pulseTime2 << 16) + (UInt_t)p.pulseTime1;
        unsigned long long tNs = (unsigned long long)(timetenthms*1e5);
        time.SetFromStartRunNs(tNs);
        // parsing time of start of run
        int month=atoi(fDate.substr(0,2).c_str()); 
        int day=atoi(fDate.substr(3,2).c_str()); 
        int year=atoi(fDate.substr(6,4).c_str()); 
        int hour=atoi(fDate.substr(11,2).c_str()); 
        int min=atoi(fDate.substr(14,2).c_str()); 
        int sec=atoi(fDate.substr(17,2).c_str()); 
        time.SetStartRunUnix(year,month,day,hour,min,sec);
 
    if(debugHandle.IsValid()) {
        QInoDataReaderDebug& readerDebug = debugHandle.Get();
        readerDebug.fTime = time;
    }
 
    static UInt_t offset; 
    if(f.isDiff){
        offset = 32768;
    }
    else{
                offset = 0;
        }
        sampleInfo.SetSampleIndex(fPreTriggerSamples);
        samplesADC.Resize(fNumSamples);
        samplesADC[0] = p.first_sampl; 
        samplesADC[0] += offset; 
        if(f.isDiff){
                samplesADC[1] = ((int)p.sampl[0] + samplesADC[0]);  
                for(Int_t i = 2; i < fNumSamples; i++){
                        samplesADC[i] = (int)(p.sampl[i-1] + samplesADC[i-1]);  
                }
        }
        else{
                samplesADC[1] = ((int)p.sampl[0] );  
                for(Int_t i = 2; i < fNumSamples; i++){
                        samplesADC[i] = (int)(p.sampl[i-1] );  
                }
        }
    pulse.SetSamplesADC(samplesADC);
    if(debugHandle.IsValid()) {
        QInoDataReaderDebug& readerDebug = debugHandle.Get();
        readerDebug.fSamples = samplesADC;
        readerDebug.fTimedSample = fPreTriggerSamples;
        }
 
        if(fName != fFileUName){
                // notify open new file
                OpenNewFile(fName + ".hdr");
                fFileUName = fName;
                std::string suffix = fName.substr(fName.length()-5 ,5);
                fDetector = DN_UNKNOWN;
                if(suffix.at(0) == 'c') { 
                        fDetector = DN_HALLC;
                }
                else if(suffix.at(0) == 'q') {
                        fDetector = DN_CUORICINO;
                }
 
                Info("Current file is %s", fFileUName.c_str());
        }
        int runInt = strtol(fRunNumber.c_str(),0,10)+(int)fDetector*100000;
        //if(fIsNoise == true) runInt +=70000;
        header.SetRun(runInt);
    if(debugHandle.IsValid()) {
        QInoDataReaderDebug& readerDebug = debugHandle.Get();
        readerDebug.fRun = runInt;
        }
 
        fEventNumber++;
        fRunEventNumber++;
        return true;
}
 
// Done method is called after event loop
void MQinoDataReader::Done() {
}
 
void MQinoDataReader::NewRun(){
        fRunEventNumber = 0;
        fName = fIter->c_str(); 
        fRunNumber = fName;
        fRunNumber.erase(0,fRunNumber.size()-4);
        files.clear();
 
        char s[200];
        sprintf(s,"%s.hdr",fName.c_str());
        Info("Opening file: %s",s);
 
        // check that header exists
        FILE *fp = fopen(s,"rt");
        if ( !fp && !fIsNoise ) {
                Panic("Cannot find file %s",s);
        }
    else if (fp){
        // read from header
        int pulseDurationMs;
        if(GetBool("NewHDR",false,false)) {
            float minADC, maxADC;
            fscanf(fp,"%f %f\n",&minADC,&maxADC);
            fMinAdcRange = minADC;
            fMaxAdcRange = maxADC;
            fscanf(fp,"%d\n",&fNumSamples);
            fscanf(fp,"%i\n",&pulseDurationMs);
        } else {
            int minADC, maxADC;
            fscanf(fp,"%d %d %i\n",&minADC,&maxADC, &fNumSamples);
            fMinAdcRange = minADC;
            fMaxAdcRange = maxADC;
            fscanf(fp,"%i\n",&pulseDurationMs);
        }
 
        fSamplingFrequency = float(fNumSamples) / pulseDurationMs * 1000; 
 
        char c1[50],c2[50], d[50];
        while(fscanf(fp,"%s %s \n",c1,c2)!=EOF){          
 
            if(std::string(c1)=="Start"&&std::string(c2)=="date"){
                fscanf(fp,"%s \n",d);
                fDate=d+std::string(" ");
 
            }
            if(std::string(c1)=="Start"&&std::string(c2)=="time"){
                fscanf(fp,"%s \n",d);
                fDate+=d;
            }
 
        }
 
        fclose(fp);
        Debug("header file closed");
        Debug("%s",fDate.c_str());
    }
    else{//the file read is a noise one and no header file is prensent
        Info("Header fime not found: using default values for ADC range, number of samples, sampling frequency and date");
        fMinAdcRange = 0;
        fMaxAdcRange = 10;
        fNumSamples = 512;
        fSamplingFrequency = 125;
        fDate = "01-01-1980 00:00:00";
    }
 
    frecord_size = 8 + 2 + 4 + (2 * fNumSamples);
 
    int NumFiles = 0;
    bool isDiff;
    if(fIsNoise == false){
        while(1) {
            char s[100];
            sprintf(s,"%s.%03d.gz",fName.c_str(),NumFiles);
            FILE *fp = fopen(s,"rb");
            // try the differential option
            if(!fp){
                sprintf(s,"%s.%03d_d.gz",fName.c_str(),NumFiles);
                fp = fopen(s,"rb");
                isDiff=true;    
            } else {
                isDiff=false;   
            }
            if (fp) {
                Debug("Found file %s.%03d_d.gz",fName.c_str(),NumFiles); 
                NumFiles++;
                f.filename=s;
                f.isDiff=isDiff;
                files.push_back(f);
                fclose(fp);
            } else {
                break;
            }
        }
    }
    else{
        char s[100];
        sprintf(s,"%s.noi",fName.c_str());
        FILE *fp = fopen(s,"rb");
        // try the differential option
        if(!fp){
            sprintf(s,"%s.noi_d.gz",fName.c_str());
            fp = fopen(s,"rb");
            isDiff=true;        
        } else {
            isDiff=false;       
        }
        if (fp) {
            Debug("Found file %s.noi_d.gz",fName.c_str(),NumFiles); 
            NumFiles++;
            f.filename=s;
            f.isDiff=isDiff;
            files.push_back(f);
            fclose(fp);
        } else {
            Panic("No noise file found: exiting");
        }
 
    }
 
    filesIter=files.begin();
    filesEnd=files.end();
 
    if (NumFiles)
        Debug("%d files found for header=%s",NumFiles,fName.c_str());
    else
        Panic("%d files found for header=%s",NumFiles,fName.c_str());
 
    Debug("NumSamples %d, SamplFreq %f, MinADC %f, MaxADC %f",fNumSamples, fSamplingFrequency, fMinAdcRange, fMaxAdcRange);
}