source: fact/tools/pyscripts/sandbox/vogler/calfits.h

//********************************
//
// Class Calfits
// Wrapper class for fits.h or pyfits.h
// Provides fast access to calibrated events of FACT raw files
//
// written by Thomas Kraehenbuehl, ETH Zurich
// tpk@phys.ethz.ch, +41 44 633 3973
// April 2012
//
//********************************
//
// Compilation (root in pyfact directory)
// root [0] gSystem->Load("/usr/lib64/libz.so");
// root [1] .L pyfits.h++
// root [2] .L ../sandbox/kraehenb/calfits.h++
//
// Usage in Python:
// See CalFitsTest.py
//
//********************************

//ToDo: shared library creation debuggen

#ifndef CALFITS_H
#define CALFITS_H

#include <cstdio>
#include <string>

#ifndef __MARS__
#include <vector>
#include <iomanip>
#include <iostream>
#define gLog cerr
#define ___err___ ""
#define ___all___ ""
#else
#include "MLog.h"
#include "MLogManip.h"
#define ___err___ err
#define ___all___ all
#endif

#ifdef __EXCEPTIONS
#include <stdexcept>
#endif

#include "../../pyfact/pyfits.h"


class CalFits
{
public:
        //No standard constructor CalFits()!
        
        //Direct handlers of the files
        fits datafile, calibfile; //Class name should be PyFits or better FactPyFits...
        
        //Basic file parameters
        UInt_t calib_nroi, calib_npix;
        UInt_t calib_blm_size, calib_gm_size, calib_tom_size;
        UInt_t data_nroi, data_npix, data_ndata;
        
        //Common variables
        UInt_t nroi, npix, nevents;
        
        //Calibration variables
        float* calib_baselinemean;
        float* calib_gainmean;
        float* calib_triggeroffsetmean;
        //Using <vector> instead of arrays makes no visible difference
        //ToDo: use arrays of size 1440x1024 (x2 for wrap-arounds) and read all variables into those
        
        //Event variables
        UInt_t event_id;
        UShort_t event_triggertype;
        int16_t* event_data;
        int16_t* event_offset;
        int32_t* event_boardtimes;
        double* npcaldata;
        
        CalFits(const string &datafilename, const string &calibfilename) //Constructor with two filenames
                : datafile(datafilename),
                        calibfile(calibfilename),
                        npcaldata(NULL)
        {
                //Read basic parameters of the two files
//              std::cout << "...Reading basic file parameters..." << std::endl;
                calib_nroi = calibfile.GetUInt("NROI");
                calib_npix = calibfile.GetUInt("NPIX");
                data_nroi = datafile.GetUInt("NROI");
                data_npix = datafile.GetUInt("NPIX");
                data_ndata = datafile.GetN("Data");
                
                calib_blm_size = calibfile.GetN("BaselineMean")/calib_npix;
                calib_gm_size = calibfile.GetN("GainMean")/calib_npix;
                calib_tom_size = calibfile.GetN("TriggerOffsetMean")/calib_npix;
                
//              std::cout << "Column sizes: " << calib_blm_size << " " << calib_gm_size << " " << calib_tom_size << std::endl;
                
                //Define the common variables
                if((calib_nroi==data_nroi)&&(calib_npix==data_npix)&&(data_nroi*data_npix==data_ndata)&&(calib_blm_size==calib_gm_size)&&(calib_tom_size==calib_nroi)) {
                        nroi = data_nroi;
                        npix = data_npix;
                }
                else {
                        ostringstream str;
                        str << "Data/calib file error: NROI mismatch, NPIX mismatch, data column size wrong or calib columns mismatch.";
#ifdef __EXCEPTIONS
                        throw runtime_error(str.str());
#else
                        gLog << ___err___ << "ERROR - " << str.str() << endl;
                        return;
#endif
                }
                nevents = datafile.GetNumRows();
                
                //Read the calibration data
//              std::cout << "...Reading calibration data..." << std::endl;
                calib_baselinemean = new float[calibfile.GetN("BaselineMean")];
                calibfile.SetPtrAddress("BaselineMean", calib_baselinemean, calibfile.GetN("BaselineMean"));
                calib_gainmean = new float[calibfile.GetN("GainMean")];
                calibfile.SetPtrAddress("GainMean", calib_gainmean, calibfile.GetN("GainMean"));
                calib_triggeroffsetmean = new float[calibfile.GetN("TriggerOffsetMean")];
                calibfile.SetPtrAddress("TriggerOffsetMean", calib_triggeroffsetmean, calibfile.GetN("TriggerOffsetMean"));
                calibfile.GetRow(0);
                
                //Set the event pointers
//              std::cout << "...Setting event pointers..." << std::endl;
                datafile.SetRefAddress("EventNum", event_id);
                datafile.SetRefAddress("TriggerType", event_triggertype);
                
                event_data = new int16_t[data_ndata];
                datafile.SetPtrAddress("Data", event_data, data_ndata);
                
                event_offset = new int16_t[datafile.GetN("StartCellData")];
                datafile.SetPtrAddress("StartCellData", event_offset, datafile.GetN("StartCellData"));
                
                event_boardtimes = new int32_t[datafile.GetN("BoardTime")];
                datafile.SetPtrAddress("BoardTime", event_boardtimes, datafile.GetN("BoardTime"));
        }
        
        ~CalFits() //Standard destructor
        {
                delete[] calib_baselinemean;
                delete[] calib_gainmean;
                delete[] calib_triggeroffsetmean;
                delete[] event_data;
                delete[] event_offset;
                delete[] event_boardtimes;
        }
        
        bool GetCalEvent() //Read calibrated event into the event variables
        {
                if(!npcaldata) {
                        ostringstream str;
                        str << "Pointer to the calibrated data not initialized!";
#ifdef __EXCEPTIONS
                        throw runtime_error(str.str());
#else
                        gLog << ___err___ << "ERROR - " << str.str() << endl;
                        return false;
#endif
                }
                if(datafile.GetNextRow() == false) {
//                      std::cout << "Last event reached..." << std::endl;
                        return false;
                }
                else {
                        UInt_t drs_calib_offset;
                        for(UInt_t pixel=0;pixel<data_npix;pixel++) {
                                for(UInt_t slice=0;slice<data_nroi;slice++) {
                                        drs_calib_offset = (slice+event_offset[pixel])%calib_blm_size;
                                        npcaldata[pixel*data_nroi+slice] = double((event_data[pixel*data_nroi+slice]*2000./4096.-calib_baselinemean[pixel*calib_blm_size+drs_calib_offset]-calib_triggeroffsetmean[pixel*data_nroi+slice])/calib_gainmean[pixel*calib_blm_size+drs_calib_offset]*1907.35);
                                        //Note: data_nroi=calib_nroi, calib_blm_size=calib_gm_size
                                }
                        }
                }
                return true;
        }
        
        void SetNpcaldataPtr(double *numpyptr) //Set the pointer for the calibrated data to the numpy array
        {
                npcaldata = numpyptr;
                return;
        }
};
#endif