Changeset 12343


Ignore:
Timestamp:
10/31/11 14:52:20 (13 years ago)
Author:
tbretz
Message:
Moved some common code between MARS and FACT++ to DrsCalib.h as new class DrsCalibration; renamed CalibData to DrsCalibrate.
Location:
trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/FACT++/gui/RawEventsViewer/RawEventsViewer.cc

    r12310 r12343  
    477477    drawBlur = false;
    478478    loopCurrentEvent = false;
     479    fIsDrsCalibration = false;
    479480    SetAutoRefresh(true);
    480481#ifdef LOAD_RAW
    … …  
    10591060    //calibrationLoaded = false;
    10601061
    1061     MessageImp msg;
    1062     if (!DataCalib::ReadFits(file, msg))
    1063     {
    1064         DataCalib::Restart();
    1065         return;
    1066     }
    1067     /*
    1068 
    1069     calibInputFile = new fits(file);
    1070     if (!*calibInputFile)
    1071     {
    1072         delete calibInputFile;
    1073         calibInputFile = NULL;
    1074         return;
    1075     }
    1076 
    1077 //    if (calibInputFile->HasKey("NROI"))
    1078 //    {
    1079 //        cout << "Looks like you're trying to load a regular raw data file as DRS calib. aborting." << endl;
    1080 //        delete calibInputFile;
    1081 //        calibInputFile = NULL;
    1082 //        return;
    1083 //    }
    1084 
    1085     if (!calibInputFile->SetPtrAddress("BaselineMean", baseLineMean)){
    1086         cout << "Missing column " << "BaseLineMean" << " Aborting load..." << endl;
    1087         return;}
    1088     if (!calibInputFile->SetPtrAddress("GainMean", gainMean)){
    1089         cout << "Missing column " << "GainMean" << " Aborting load..." << endl;
    1090         return;}
    1091     if (!calibInputFile->SetPtrAddress("TriggerOffsetMean", triggerOffsetMean)){
    1092         cout << "Missing column " << "TriggerOffsetMean" << " Aborting load..." << endl;
    1093         return;}
    1094 
    1095     calibInputFile->GetNextRow();
    1096 
    1097  //   for (int i=0;i<1024;i++)
    1098  //       cout << gainMean[i] << " ";
    1099  //   cout << endl << endl;
    1100 
    1101     delete calibInputFile;
    1102 */
    1103     //calibrationLoaded = true;
    1104 
    1105     emit newFileLoaded();
    1106 
    1107     //if (calibratedCheckBox->isChecked())
     1062    string msg;
     1063    try
     1064    {
     1065        msg = fDrsCalib.ReadFitsImp(file);
     1066        if (msg.empty())
     1067        {
     1068            emit newFileLoaded();
     1069            updateGL();
     1070            return;
     1071        }
     1072    }
     1073    catch (const runtime_error &e)
     1074    {
     1075        msg = e.what();
     1076    }
     1077
     1078    cerr << msg << endl;
     1079    fDrsCalib.Clear();
     1080}
     1081
     1082/************************************************************
     1083 * PLUS EVENT
     1084 ************************************************************/
     1085void RawDataViewer::plusEvent()
     1086{
     1087    eventStepping(true);
     1088}
     1089/************************************************************
     1090 * MINUS EVENT
     1091 ************************************************************/
     1092void RawDataViewer::minusEvent()
     1093{
     1094    eventStepping(false);
     1095}
     1096/************************************************************
     1097 * SET EVENT STEP
     1098 ************************************************************/
     1099void RawDataViewer::setEventStep(int step)
     1100{
     1101    eventStep = step;
     1102}
     1103/************************************************************
     1104 * EVENT STEPPING
     1105 ************************************************************/
     1106
     1107void RawDataViewer::ApplyCalibration()
     1108{
     1109    for (int i=0;i<(1440+160)*nRoi;i++)
     1110        eventData[i] = (float)rawEventData[i];
     1111
     1112    if (fIsDrsCalibration)
     1113    {
     1114        fDrsCalib.Apply(eventData, rawEventData, startPix, nRoi);
     1115        DrsCalibrate::RemoveSpikes(eventData, nRoi);
     1116    }
     1117
     1118    vector<float> pixelStatsData(1440*4);
     1119    DrsCalibrate::GetPixelStats(pixelStatsData.data(), eventData, nRoi);
     1120
     1121    for (vector<PixelMapEntry>::const_iterator it=fPixelMap.begin(); it!=fPixelMap.end(); it++)
     1122        RMSvalues[it->index] = pixelStatsData[1*1440+it->hw()];
     1123
     1124    if (isVisible())
    11081125        updateGL();
    11091126}
    1110 /************************************************************
    1111  * PLUS EVENT
    1112  ************************************************************/
    1113 void RawDataViewer::plusEvent()
    1114 {
    1115     eventStepping(true);
    1116 }
    1117 /************************************************************
    1118  * MINUS EVENT
    1119  ************************************************************/
    1120 void RawDataViewer::minusEvent()
    1121 {
    1122     eventStepping(false);
    1123 }
    1124 /************************************************************
    1125  * SET EVENT STEP
    1126  ************************************************************/
    1127 void RawDataViewer::setEventStep(int step)
    1128 {
    1129     eventStep = step;
    1130 }
    1131 /************************************************************
    1132  * EVENT STEPPING
    1133  ************************************************************/
     1127
    11341128void RawDataViewer::eventStepping(bool plus)
    11351129{
    … …  
    11491143    inputFile->GetRow(rowNum);
    11501144//    cout << "Getting row " << rowNum << endl;
    1151     for (int i=0;i<(1440+160)*nRoi;i++)
    1152         eventData[i] = (float)rawEventData[i];
    11531145#endif
    11541146
    1155 //    if (drawCalibrationLoaded && calibrationLoaded)
    1156 //    {
    1157 
    1158 //    if (calibratedCheckBox->isChecked())
    1159         DataCalib::Apply(eventData, rawEventData, startPix, nRoi);
    1160         CalibData::RemoveSpikes(eventData, nRoi);
    1161 
    1162         vector<float> pixelStatsData(1440*4);
    1163         CalibData::GetPixelStats(pixelStatsData.data(), eventData, nRoi);
    1164 
    1165 
    1166         for (vector<PixelMapEntry>::const_iterator it=fPixelMap.begin(); it!=fPixelMap.end(); it++)
    1167         {
    1168             RMSvalues[it->index] = pixelStatsData[1*1440+it->hw()];
    1169         }
    1170 
    1171         /*
    1172 
    1173         for (int i=0;i<1440;i++)
    1174             for (int j=0;j<nRoi;j++)
    1175             {
    1176                 int realj = (j+startPix[i])%1024;
    1177                 eventData[i*1024+j] *= 2000.f/4096.f;
    1178                 eventData[i*1024+j] -= (baseLineMean[i*1024+realj]+triggerOffsetMean[i*1024+j]);
    1179                 eventData[i*1024+j] /= gainMean[i*1024+realj];
    1180                 eventData[i*1024+j] *= (50000.f/65536.f) * 2500.f;
    1181             }
    1182     }
    1183     */
    1184         if (isVisible())
    1185             updateGL();
     1147    ApplyCalibration();
     1148
    11861149    emit signalCurrentEvent(eventNum);
    11871150    emit signalCurrentPixel(selectedPixel);
    11881151}
     1152
    11891153/************************************************************
    11901154 * NEXT SLICE. deprec ?
    … …  
    13751339void UIConnector::on_calibratedCheckBox_stateChanged(int state)
    13761340{
    1377     for (int i=0;i<(1440+160)*GLWindow->nRoi;i++)
    1378         GLWindow->eventData[i] = (float)GLWindow->rawEventData[i];
    1379 
    1380 //    if (GLWindow->calibratedCheckBox->isChecked())
    1381     if (state)
    1382     {
    1383         DataCalib::Apply(GLWindow->eventData, GLWindow->rawEventData, GLWindow->startPix, GLWindow->nRoi);
    1384         CalibData::RemoveSpikes(GLWindow->eventData, GLWindow->nRoi);
    1385     }
    1386 
    1387     GLWindow->updateGL();
    1388 
    1389     //drawCalibrationCheckBox->setChecked(false);
     1341    GLWindow->fIsDrsCalibration = state;
     1342    GLWindow->ApplyCalibration();
    13901343
    13911344    on_autoScaleColor_clicked();
    … …  
    22202173    if (!autoScaleColor->isChecked())
    22212174    {
    2222         /*
    22232175        GLWindow->ss[0] = 0.496;
    22242176        GLWindow->ss[1] = 0.507;
    … …  
    22312183        colorRange3->setValue(GLWindow->ss[3]);
    22322184        colorRange4->setValue(GLWindow->ss[4]);
    2233         */
    22342185        return;
    22352186    }

  • trunk/FACT++/gui/RawEventsViewer/RawEventsViewer.h

    r12310 r12343  
    6161
    6262    friend class UIConnector;
     63
     64    DrsCalibration fDrsCalib;
     65
     66
    6367public:
     68    bool fIsDrsCalibration;
     69
    6470    RawDataViewer(QWidget *parent = 0);
    6571    ~RawDataViewer();
    … …  
    179185    double vCorr[1024];
    180186
     187    void ApplyCalibration();
     188
    181189//    GLfloat pixelsCoords[MAX_NUM_PIXELS][3];
    182190//    PixelsNeighbors neighbors[MAX_NUM_PIXELS];

  • trunk/FACT++/src/DataCalib.cc

    r12066 r12343  
    99using namespace std;
    1010
    11 int  DataCalib::fStep = 0;
     11DrsCalibration DataCalib::fData;
    1212bool DataCalib::fProcessing = false;
    13 
    14 vector<int32_t> DataCalib::fOffset(1440*1024, 0);
    15 vector<int64_t> DataCalib::fGain  (1440*1024, 4096);
    16 vector<int64_t> DataCalib::fTrgOff(1440*1024, 0);
    17 vector<float>   DataCalib::fStats (1440*1024*6+3);
    18 
    19 uint64_t DataCalib::fNumOffset = 1;
    20 uint64_t DataCalib::fNumGain   = 2000;
    21 uint64_t DataCalib::fNumTrgOff = 1;
     13vector<float> DataCalib::fStats(1440*1024*6+3);
    2214
    2315void DataCalib::Restart()
    2416{
    25     // Default gain:
    26     // 0.575*[45590]*2.5V / 2^16 = 0.99999 V
    27     fOffset.assign(1440*1024, 0);
    28     fGain.assign  (1440*1024, 4096);
    29     fTrgOff.assign(1440*1024, 0);
    30 
    31     fNumOffset = 1;
    32     fNumGain   = 2000;
    33     fNumTrgOff = 1;
     17    fData.Clear();
    3418
    3519    reinterpret_cast<uint32_t*>(fStats.data())[0] = 0;
    … …  
    4529        fStats[i++] = 0;   // Set everything else to 0
    4630
    47     fStep = 0;
    4831    fProcessing = false;
    4932}
    … …  
    7053    if (fProcessing)
    7154    {
    72         fMsg.Warn("Previous run not yet finished!");
    73         return false;
    74     }
    75 
    76     if (fStep==4)
     55        fMsg.Warn("Previous DRS calibration run not yet finished!");
     56        return false;
     57    }
     58
     59    if (fData.fStep==4)
    7760    {
    7861        fMsg.Warn("DRS Calibration already finished... please restart!");
    … …  
    8366
    8467    ostringstream name;
    85     name << "drs-calib-" << fStep;
     68    name << "drs-calib-" << fData.fStep;
    8669    fFileName = name.str();
    8770
    … …  
    8972    InitSize(1440, 1024);
    9073
    91     return true;
     74    return DataWriteFits::Open(h);
    9275}
    9376
    … …  
    9679    // FIXME: SET StartPix to 0 if StartPix is -1
    9780
    98     if (fStep==0)
     81    if (fData.fStep==0)
    9982    {
    10083        AddRel(e->Adc_Data, e->StartPix);
    10184    }
    102     if (fStep==1)
    103     {
    104         AddRel(e->Adc_Data, e->StartPix, fOffset.data(), fNumOffset);
    105     }
    106     if (fStep==2)
    107     {
    108         AddAbs(e->Adc_Data, e->StartPix, fOffset.data(), fNumOffset);
    109     }
    110 
    111     return true;
     85    if (fData.fStep==1)
     86    {
     87        AddRel(e->Adc_Data, e->StartPix, fData.fOffset.data(), fData.fNumOffset);
     88    }
     89    if (fData.fStep==2)
     90    {
     91        AddAbs(e->Adc_Data, e->StartPix, fData.fOffset.data(), fData.fNumOffset);
     92    }
     93
     94    return DataWriteFits::WriteEvt(e);
    11295}
    11396
    … …  
    122105    try
    123106    {
    124         fits file(str);
    125         if (!file)
    126         {
    127             msg.Error("Opening '"+str+"' failed: "+string(strerror(errno)));
    128             return false;
    129         }
    130 
    131         if (file.GetStr("TELESCOP")!="FACT")
    132         {
    133             msg.Error("Reading "+str+" failed: Not a valid FACT file (TELESCOP not FACT in header)");
    134             return false;
    135         }
    136 
    137         if (!file.HasKey("STEP"))
    138         {
    139             msg.Error("Reading "+str+" failed: Is not a DRS calib file (STEP not found in header)");
    140             return false;
    141         }
    142 
    143         if (file.GetNumRows()!=1)
    144         {
    145             msg.Error("Reading "+str+" failed: Number of rows in table is not 1.");
    146             return false;
    147         }
    148 
    149         vector<float> data(1440*1024*6+3);
    150 
    151         float *base = data.data();
    152 
    153         file.SetPtrAddress("RunNumberBaseline",      base,   1);
    154         file.SetPtrAddress("RunNumberGain",          base+1, 1);
    155         file.SetPtrAddress("RunNumberTriggerOffset", base+2, 1);
    156         file.SetPtrAddress("BaselineMean",           base+3 + 0*1024*1440, 1024*1440);
    157         file.SetPtrAddress("BaselineRms",            base+3 + 1*1024*1440, 1024*1440);
    158         file.SetPtrAddress("GainMean",               base+3 + 2*1024*1440, 1024*1440);
    159         file.SetPtrAddress("GainRms",                base+3 + 3*1024*1440, 1024*1440);
    160         file.SetPtrAddress("TriggerOffsetMean",      base+3 + 4*1024*1440, 1024*1440);
    161         file.SetPtrAddress("TriggerOffsetRms",       base+3 + 5*1024*1440, 1024*1440);
    162 
    163         if (!file.GetNextRow())
    164         {
    165             msg.Error("Reading data from "+str+" failed.");
    166             return false;
    167         }
    168 
    169         fStep      = file.GetUInt("STEP");
    170         fNumOffset = file.GetUInt("NBOFFSET");
    171         fNumGain   = file.GetUInt("NBGAIN");
    172         fNumTrgOff = file.GetUInt("NBTRGOFF");
    173 
    174         memcpy(fStats.data(), base, fStats.size()*sizeof(float));
    175 
    176         // Convert back to ADC counts: 256/125 = 4096/2000
    177         // Convert back to sum (mean * num_entries)
    178         for (int i=0; i<1024*1440; i++)
    179         {
    180             fOffset[i] = fNumOffset           *256*fStats[i+1024*1440*0+3]/125;
    181             fGain[i]   = fNumOffset*fNumGain  *256*fStats[i+1024*1440*2+3]/125;
    182             fTrgOff[i] = fNumOffset*fNumTrgOff*256*fStats[i+1024*1440*4+3]/125;
    183         }
    184 
    185         // DAC:  0..2.5V == 0..65535
    186         // V-mV: 1000
    187         //fNumGain *= 2500*50000;
    188         //for (int i=0; i<1024*1440; i++)
    189         //    fGain[i] *= 65536;
    190         if (fStep==0)
    191         {
    192             for (int i=0; i<1024*1440; i++)
    193                 fGain[i] = fNumOffset*4096;
    194         }
    195         else
    196         {
    197             fNumGain *= 1953125;
    198             for (int i=0; i<1024*1440; i++)
    199                 fGain[i] *= 1024;
    200         }
    201 
    202         // Now mark the stored DRS data as "officially valid"
    203         // However, this is not thread safe. It only ensures that
    204         // this data is not used before it is completely and correctly
    205         // read.
    206         fStep++;
    207 
    208         return true;
     107        const string txt = fData.ReadFitsImp(str, fStats);
     108        if (txt.empty())
     109            return true;
     110
     111        msg.Error(txt);
     112        return false;
    209113    }
    210114    catch (const runtime_error &e)
    … …  
    241145        return;
    242146
    243     if (!file.WriteKeyNT("STEP",     fStep, "") ||
     147    if (!file.WriteKeyNT("STEP",     fData.fStep, "") ||
    244148        !file.WriteKeyNT("ADCRANGE", 2000,             "Dynamic range of the ADC in mV") ||
    245149        !file.WriteKeyNT("DACRANGE", 2500,             "Dynamic range of the DAC in mV") ||
    … …  
    247151        !file.WriteKeyNT("DAC",      16,               "Resolution of DAC in bits")      ||
    248152        !file.WriteKeyNT("DACLEVEL", 50000,            "Applied DAC level in counts")    ||
    249         !file.WriteKeyNT("NBOFFSET", fNumOffset,       "Number of entries for offset calibration") ||
    250         !file.WriteKeyNT("NBGAIN",   fNumGain/1953125, "Number of entries for gain calibration")   ||
    251         !file.WriteKeyNT("NBTRGOFF", fNumTrgOff,       "Number of entries for trigger offset calibration") ||
     153        !file.WriteKeyNT("NBOFFSET", fData.fNumOffset,       "Number of entries for offset calibration") ||
     154        !file.WriteKeyNT("NBGAIN",   fData.fNumGain/1953125, "Number of entries for gain calibration")   ||
     155        !file.WriteKeyNT("NBTRGOFF", fData.fNumTrgOff,       "Number of entries for trigger offset calibration") ||
    252156        !file.WriteKeyNT("NPIX",     1440,             "Number of channels in the camera") ||
    253157        !file.WriteKeyNT("NROI",     1024,             "Region of interest")
    … …  
    276180
    277181    ostringstream str;
    278     str << "Wrote DRS calibration data (step=" << fStep << ") to '" << fFileName << "'";
     182    str << "Wrote DRS calibration data (step=" << fData.fStep << ") to '" << fFileName << "'";
    279183    Info(str.str());
    280184#endif
    281185}
    282186
    283 bool DataCalib::Close(RUN_TAIL *)
    284 {
    285     if (fStep==0)
    286     {
    287         fOffset.assign(fSum.begin(), fSum.end());
    288         fNumOffset = fNumEntries;
     187bool DataCalib::Close(RUN_TAIL *tail)
     188{
     189    if (fData.fStep==0)
     190    {
     191        fData.fOffset.assign(fSum.begin(), fSum.end());
     192        fData.fNumOffset = fNumEntries;
    289193
    290194        for (int i=0; i<1024*1440; i++)
    291             fGain[i] = 4096*fNumOffset;
     195            fData.fGain[i] = 4096*fNumEntries;
    292196
    293197        // Scale ADC data from 12bit to 2000mV
    … …  
    295199        reinterpret_cast<uint32_t*>(fStats.data())[0] = GetRunId();;
    296200    }
    297     if (fStep==1)
    298     {
    299         fGain.assign(fSum.begin(), fSum.end());
    300         fNumGain = fNumEntries;
     201    if (fData.fStep==1)
     202    {
     203        fData.fGain.assign(fSum.begin(), fSum.end());
     204        fData.fNumGain = fNumEntries;
    301205
    302206        // DAC:  0..2.5V == 0..65535
    … …  
    305209        //for (int i=0; i<1024*1440; i++)
    306210        //    fGain[i] *= 65536;
    307         fNumGain *= 1953125;
     211        fData.fNumGain *= 1953125;
    308212        for (int i=0; i<1024*1440; i++)
    309             fGain[i] *= 1024;
     213            fData.fGain[i] *= 1024;
    310214
    311215        // Scale ADC data from 12bit to 2000mV
    312         GetSampleStats(fStats.data()+1024*1440*2+3, 2000./4096/fNumOffset);//0.5);
     216        GetSampleStats(fStats.data()+1024*1440*2+3, 2000./4096/fData.fNumOffset);//0.5);
    313217        reinterpret_cast<uint32_t*>(fStats.data())[1] = GetRunId();;
    314218    }
    315     if (fStep==2)
    316     {
    317         fTrgOff.assign(fSum.begin(), fSum.end());
    318         fNumTrgOff = fNumEntries;
     219    if (fData.fStep==2)
     220    {
     221        fData.fTrgOff.assign(fSum.begin(), fSum.end());
     222        fData.fNumTrgOff = fNumEntries;
    319223
    320224        // Scale ADC data from 12bit to 2000mV
    321         GetSampleStats(fStats.data()+1024*1440*4+3, 2000./4096/fNumOffset);//0.5);
     225        GetSampleStats(fStats.data()+1024*1440*4+3, 2000./4096/fData.fNumOffset);//0.5);
    322226        reinterpret_cast<uint32_t*>(fStats.data())[2] = GetRunId();;
    323227    }
    324228
    325     if (fStep>=0 && fStep<=2)
     229    if (fData.fStep<=2)
    326230        WriteFits();
    327231
    328232    fDim.Update(fStats);
    329233
    330     fStep++;
     234    fData.fStep++;
    331235
    332236    fProcessing = false;
    333237
    334     return true;
    335 }
    336 
    337 void DataCalib::Apply(int16_t *val, const int16_t *start, uint32_t roi)
    338 {
    339     CalibData::Apply(val, start, roi,
    340                      fOffset.data(), fNumOffset,
    341                      fGain.data(),   fNumGain,
    342                      fTrgOff.data(), fNumTrgOff);
    343 }
    344 
    345 void DataCalib::Apply(float *vec, int16_t *val, const int16_t *start, uint32_t roi)
    346 {
    347     CalibData::Apply(vec, val, start, roi,
    348                      fOffset.data(), fNumOffset,
    349                      fGain.data(),   fNumGain,
    350                      fTrgOff.data(), fNumTrgOff);
    351 }
    352 
     238    return DataWriteFits::Close(tail);
     239}

  • trunk/FACT++/src/DataCalib.h

    r12044 r12343  
    22#define FACT_DataCalib
    33
    4 #include "DataProcessorImp.h"
    5 
    6 using namespace std;
     4#include "DataWriteFits.h"
    75#include "externals/DrsCalib.h"
    86
    97class DimDescribedService;
    108
    11 class DataCalib : public DataProcessorImp, CalibData
     9using namespace std;
     10
     11class DataCalib : public DataWriteFits, public DrsCalibrate
    1212{
    13     static std::vector<int32_t> fOffset;  /// Storage for physical baseline
    14     static std::vector<int64_t> fGain;    /// Storage for baseline corrected gain
    15     static std::vector<int64_t> fTrgOff;  /// Storage for logical baseline
     13    static DrsCalibration fData;
    1614
    17     static uint64_t fNumOffset;           /// Scale for physcial baseline
    18     static uint64_t fNumGain;             /// Scale for gain values
    19     static uint64_t fNumTrgOff;           /// Scale for logical baseline
    20 
    21     static std::vector<float>   fStats;   /// Storage for mean and rms values
     15    static std::vector<float> fStats;     /// Storage for mean and rms values
    2216
    2317    /// State of the DRS calibration: Positiove numbers mean that
    2418    /// we are in a run, negative mean that it is closed
    25     static int  fStep;
    2619    static bool fProcessing;
    2720
    … …  
    3124
    3225public:
    33     DataCalib(const std::string &path, uint32_t id, DimDescribedService &dim, MessageImp &imp) : DataProcessorImp(path, id, imp), fDim(dim)
     26    DataCalib(const std::string &path, uint32_t id, DimDescribedService &dim, MessageImp &imp) : DataWriteFits(path, id, imp), fDim(dim)
    3427    {
    3528    }
    … …  
    4235    bool Close(RUN_TAIL * = 0);
    4336
    44     static void Apply(int16_t *val, const int16_t *start, uint32_t roi);
    45     static void Apply(float *vec, int16_t *val, const int16_t *start, uint32_t roi);
     37    //static void Apply(int16_t *val, const int16_t *start, uint32_t roi);
     38    static void Apply(float *vec, int16_t *val, const int16_t *start, uint32_t roi)
     39    {
     40        fData.Apply(vec, val, start, roi);
     41    }
    4642
    4743    static bool ReadFits(const string &fname, MessageImp &msg);
    4844
    49     static bool IsValid() { return fStep>2; }
     45    static bool IsValid() { return fData.IsValid(); }
    5046};
    5147

  • trunk/FACT++/src/EventBuilderWrapper.h

    r12333 r12343  
    858858        fDimRawData.Update(data);
    859859
    860         CalibData::RemoveSpikes(vec, event->Roi);
     860        DrsCalibrate::RemoveSpikes(vec, event->Roi);
    861861
    862862        vector<float> data2(1440*4); // Mean, RMS, Max, Pos
    863         CalibData::GetPixelStats(data2.data(), vec, event->Roi);
     863        DrsCalibrate::GetPixelStats(data2.data(), vec, event->Roi);
    864864
    865865        fDimEventData.Update(data2);
    … …  
    893893        DataCalib::Apply(data.data(), event->Adc_Data, event->StartPix, event->Roi);
    894894
     895        DrsCalibrate::RemoveSpikes(data.data(), event->Roi);
     896
    895897        vector<float> data2(1440); // Mean, RMS, Max, Pos, first, last
    896         CalibData::GetPixelMax(data2.data(), data.data(), event->Roi, 0, event->Roi-1);
    897 
    898 //        dim_lock();
     898        DrsCalibrate::GetPixelMax(data2.data(), data.data(), event->Roi, 0, event->Roi-1);
     899
    899900        fDimFeedbackData.Update(data2);
    900 //        dim_unlock();
    901901    }
    902902

  • trunk/Mars/mcore/DrsCalib.h

    r12326 r12343  
    1 #ifndef MARS_CalibData
    2 #define MARS_CalibData
    3 
    4 class CalibData
     1#ifndef MARS_DrsCalib
     2#define MARS_DrsCalib
     3
     4#include "fits.h"
     5
     6class DrsCalibrate
    57{
    68protected:
    … …  
    1012    size_t fNumChannels;
    1113
    12     vector<int64_t> fSum;
    13     vector<int64_t> fSum2;
     14    std::vector<int64_t> fSum;
     15    std::vector<int64_t> fSum2;
    1416
    1517    /*
    … …  
    1820     */
    1921public:
    20     CalibData() : fNumEntries(0), fNumSamples(0), fNumChannels(0) { }
     22    DrsCalibrate() : fNumEntries(0), fNumSamples(0), fNumChannels(0) { }
    2123    void Reset()
    2224    {
    … …  
    240242    }
    241243
    242     pair<vector<double>,vector<double> > GetSampleStats() const
     244    std::pair<std::vector<double>,std::vector<double> > GetSampleStats() const
    243245    {
    244246        if (fNumEntries==0)
    245             return make_pair(vector<double>(),vector<double>());
    246 
    247         vector<double> mean(fSum.size());
    248         vector<double> error(fSum.size());
    249 
    250         vector<int64_t>::const_iterator it = fSum.begin();
    251         vector<int64_t>::const_iterator i2 = fSum2.begin();
    252         vector<double>::iterator        im = mean.begin();
    253         vector<double>::iterator        ie = error.begin();
     247            return make_pair(std::vector<double>(),std::vector<double>());
     248
     249        std::vector<double> mean(fSum.size());
     250        std::vector<double> error(fSum.size());
     251
     252        std::vector<int64_t>::const_iterator it = fSum.begin();
     253        std::vector<int64_t>::const_iterator i2 = fSum2.begin();
     254        std::vector<double>::iterator        im = mean.begin();
     255        std::vector<double>::iterator        ie = error.begin();
    254256
    255257        while (it!=fSum.end())
    … …  
    283285        }
    284286
    285         vector<int64_t>::const_iterator it = fSum.begin();
    286         vector<int64_t>::const_iterator i2 = fSum2.begin();
     287        std::vector<int64_t>::const_iterator it = fSum.begin();
     288        std::vector<int64_t>::const_iterator i2 = fSum2.begin();
    287289
    288290        while (it!=fSum.end())
    … …  
    348350    }
    349351
    350     const vector<int64_t> &GetSum() const { return fSum; }
     352    const std::vector<int64_t> &GetSum() const { return fSum; }
    351353
    352354    uint64_t GetNumEntries() const { return fNumEntries; }
    353355};
    354356
     357struct DrsCalibration
     358{
     359    std::vector<int32_t> fOffset;
     360    std::vector<int64_t> fGain;
     361    std::vector<int64_t> fTrgOff;
     362
     363    uint64_t fNumOffset;
     364    uint64_t fNumGain;
     365    uint64_t fNumTrgOff;
     366
     367    uint32_t fStep;
     368
     369    DrsCalibration() :
     370        fOffset(1440*1024, 0),
     371        fGain(1440*1024, 4096),
     372        fTrgOff(1440*1024, 0),
     373        fNumOffset(1),
     374        fNumGain(2000),
     375        fNumTrgOff(1),
     376        fStep(0)
     377    {
     378    }
     379
     380    void Clear()
     381    {
     382        // Default gain:
     383        // 0.575*[45590]*2.5V / 2^16 = 0.99999 V
     384        fOffset.assign(1440*1024, 0);
     385        fGain.assign  (1440*1024, 4096);
     386        fTrgOff.assign(1440*1024, 0);
     387
     388        fNumOffset = 1;
     389        fNumGain   = 2000;
     390        fNumTrgOff = 1;
     391
     392        fStep = 0;
     393    }
     394
     395    string ReadFitsImp(const string &str, std::vector<float> &vec)
     396    {
     397        std::fits file(str);
     398        if (!file)
     399        {
     400            std::ostringstream msg;
     401            msg << "Could not open file " << str << ": " << strerror(errno);
     402            return msg.str();
     403        }
     404
     405        if (file.GetStr("TELESCOP")!="FACT")
     406        {
     407            std::ostringstream msg;
     408            msg << "Reading " << str << " failed: Not a valid FACT file (TELESCOP not FACT in header)";
     409            return msg.str();
     410        }
     411
     412        if (!file.HasKey("STEP"))
     413        {
     414            std::ostringstream msg;
     415            msg << "Reading " << str << " failed: Is not a DRS calib file (STEP not found in header)";
     416            return msg.str();
     417        }
     418
     419        if (file.GetNumRows()!=1)
     420        {
     421            std::ostringstream msg;
     422            msg << "Reading " << str << " failed: Number of rows in table is not 1.";
     423            return msg.str();
     424        }
     425
     426        vec.resize(1440*1024*6+3);
     427
     428        float *base = vec.data();
     429
     430        file.SetPtrAddress("RunNumberBaseline",      base,   1);
     431        file.SetPtrAddress("RunNumberGain",          base+1, 1);
     432        file.SetPtrAddress("RunNumberTriggerOffset", base+2, 1);
     433        file.SetPtrAddress("BaselineMean",           base+0*1024*1440+3, 1024*1440);
     434        file.SetPtrAddress("BaselineRms",            base+1*1024*1440+3, 1024*1440);
     435        file.SetPtrAddress("GainMean",               base+2*1024*1440+3, 1024*1440);
     436        file.SetPtrAddress("GainRms",                base+3*1024*1440+3, 1024*1440);
     437        file.SetPtrAddress("TriggerOffsetMean",      base+4*1024*1440+3, 1024*1440);
     438        file.SetPtrAddress("TriggerOffsetRms",       base+5*1024*1440+3, 1024*1440);
     439
     440        if (!file.GetNextRow())
     441        {
     442            std::ostringstream msg;
     443            msg << "Reading data from " << str << " failed.";
     444            return msg.str();
     445        }
     446
     447        fStep      = file.GetUInt("STEP");
     448        fNumOffset = file.GetUInt("NBOFFSET");
     449        fNumGain   = file.GetUInt("NBGAIN");
     450        fNumTrgOff = file.GetUInt("NBTRGOFF");
     451
     452        fOffset.resize(1024*1440);
     453        fGain.resize(1024*1440);
     454        fTrgOff.resize(1024*1440);
     455
     456        // Convert back to ADC counts: 256/125 = 4096/2000
     457        // Convert back to sum (mean * num_entries)
     458        for (int i=0; i<1024*1440; i++)
     459        {
     460            fOffset[i] = fNumOffset           *256*base[i+1024*1440*0+3]/125;
     461            fGain[i]   = fNumOffset*fNumGain  *256*base[i+1024*1440*2+3]/125;
     462            fTrgOff[i] = fNumOffset*fNumTrgOff*256*base[i+1024*1440*4+3]/125;
     463        }
     464
     465        // DAC:  0..2.5V == 0..65535
     466        // V-mV: 1000
     467        //fNumGain *= 2500*50000;
     468        //for (int i=0; i<1024*1440; i++)
     469        //    fGain[i] *= 65536;
     470        if (fStep==0)
     471        {
     472            for (int i=0; i<1024*1440; i++)
     473                fGain[i] = fNumOffset*4096;
     474        }
     475        else
     476        {
     477            fNumGain *= 1953125;
     478            for (int i=0; i<1024*1440; i++)
     479                fGain[i] *= 1024;
     480        }
     481
     482        // Now mark the stored DRS data as "officially valid"
     483        // However, this is not thread safe. It only ensures that
     484        // this data is not used before it is completely and correctly
     485        // read.
     486        fStep++;
     487
     488        return string();
     489    }
     490    string ReadFitsImp(const string &str)
     491    {
     492        std::vector<float> vec;
     493        return ReadFitsImp(str, vec);
     494    }
     495
     496    bool IsValid() { return fStep>2; }
     497
     498    void Apply(float *vec, int16_t *val, const int16_t *start, uint32_t roi)
     499    {
     500        DrsCalibrate::Apply(vec, val, start, roi,
     501                            fOffset.data(), fNumOffset,
     502                            fGain.data(),   fNumGain,
     503                            fTrgOff.data(), fNumTrgOff);
     504
     505    }
     506};
     507
    355508#endif
Note: See TracChangeset for help on using the changeset viewer.