Changeset 12343 for trunk/FACT++/src


Ignore:
Timestamp:
10/31/11 14:52:20 (14 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/FACT++/src
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • 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
Note: See TracChangeset for help on using the changeset viewer.