Changeset 5946 for trunk/MagicSoft


Ignore:
Timestamp:
01/23/05 13:49:09 (20 years ago)
Author:
mazin
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Mars
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/MagicSoft/Mars/Changelog

    r5942 r5946  
    2020
    2121                                                 -*-*- END OF LINE -*-*-
     22
     23 2005/01/23 Markus Gaug
     24 
     25  * mhcalib/MHCalibrationHiLoCam.[h,cc]
     26    - updated to new logain switch setting in MExtractTimeAndCharge
     27    - extract also high-gain vs. low-gain time difference
     28
     29  * mhcalib/MCalibrationHiLoCam.[h,cc]
     30  * mhcalib/MCalibrationHiLoPix.[h,cc]
     31  * mhcalib/MCalibrationIntensityHiLoCam.[h,cc]
     32    - updated accordingly
    2233
    2334 2005/01/22 Markus Gaug

  • trunk/MagicSoft/Mars/mcalib/MCalibrationHiLoCam.cc

    r5749 r5946  
    139139          *fLog << all
    140140                << Form("%s%4i%s%4.2f%s%4.2f%s%4.2f%s%4.2f","Pix  ",pix->GetPixId(),
    141                         ":            Ratio: ",pix->GetHiLoRatio()," +- ",pix->GetHiLoRatioErr(),
    142                         "   Sigma: ",pix->GetHiLoSigma()," +- ",pix->GetHiLoSigmaErr())
     141                        ":            Ratio: ",pix->GetHiLoChargeRatio()," +- ",pix->GetHiLoChargeRatioErr(),
     142                        "   Sigma: ",pix->GetHiLoChargeRatioSigma()," +- ",pix->GetHiLoChargeRatioSigmaErr())
    143143                << endl;
    144144          id++;
    … …  
    173173    *fLog << all
    174174          << Form("%s%4i%s%4.2f%s%4.2f%s%4.2f%s%4.2f","Average Area   ",pix->GetPixId(),
    175                   ":  Ratio: ",pix->GetHiLoRatio()," +- ",pix->GetHiLoRatioErr(),
    176                   "   Sigma: ",pix->GetHiLoSigma()," +- ",pix->GetHiLoSigmaErr())
     175                  ":  Ratio: ",pix->GetHiLoChargeRatio()," +- ",pix->GetHiLoChargeRatioErr(),
     176                  "   Sigma: ",pix->GetHiLoChargeRatioSigma()," +- ",pix->GetHiLoChargeRatioSigmaErr())
    177177          << endl;
    178178  }
    … …  
    183183    *fLog << all
    184184          << Form("%s%4i%s%4.2f%s%4.2f%s%4.2f%s%4.2f","Average Sector ",pix->GetPixId(),
    185                   ":  Ratio: ",pix->GetHiLoRatio()," +- ",pix->GetHiLoRatioErr(),
    186                   "   Sigma: ",pix->GetHiLoSigma()," +- ",pix->GetHiLoSigmaErr())
     185                  ":  Ratio: ",pix->GetHiLoChargeRatio()," +- ",pix->GetHiLoChargeRatioErr(),
     186                  "   Sigma: ",pix->GetHiLoChargeRatioSigma()," +- ",pix->GetHiLoChargeRatioSigmaErr())
    187187          << endl;
    188188  }
    … …  
    225225      if (pix.IsExcluded())
    226226        return kFALSE;
    227       val = pix.GetMean();
     227      val = pix.GetHiLoChargeRatio();
    228228      break;
    229229    case 1:
    230230      if (pix.IsExcluded())
    231231        return kFALSE;
    232       val = pix.GetMeanErr();
     232      val = pix.GetHiLoChargeRatioErr();
    233233      break;
    234234    case 2:
    235235      if (pix.IsExcluded())
    236236        return kFALSE;
    237       val = pix.GetSigma();
     237      val = pix.GetHiLoChargeRatioSigma();
    238238      break;
    239239    case 3:
    240240      if (pix.IsExcluded())
    241241        return kFALSE;
    242       val = pix.GetSigmaErr();
     242      val = pix.GetHiLoChargeRatioSigmaErr();
    243243      break;
    244244    case 4:
    245245      if (pix.IsExcluded())
    246246        return kFALSE;
    247       val = pix.GetProb();
     247      val = pix.GetHiLoChargeRatioProb();
     248      break;
     249    case 5:
     250      if (pix.IsExcluded())
     251        return kFALSE;
     252      val = pix.GetHiLoTimeDiff();
     253      break;
     254    case 6:
     255      if (pix.IsExcluded())
     256        return kFALSE;
     257      val = pix.GetHiLoTimeDiffErr();
     258      break;
     259    case 7:
     260      if (pix.IsExcluded())
     261        return kFALSE;
     262      val = pix.GetHiLoTimeDiffSigma();
     263      break;
     264    case 8:
     265      if (pix.IsExcluded())
     266        return kFALSE;
     267      val = pix.GetHiLoTimeDiffSigmaErr();
     268      break;
     269    case 9:
     270      if (pix.IsExcluded())
     271        return kFALSE;
     272      val = pix.GetHiLoTimeDiffProb();
    248273      break;
    249274    default:

  • trunk/MagicSoft/Mars/mcalib/MCalibrationHiLoPix.h

    r5749 r5946  
    1515  ~MCalibrationHiLoPix() {}
    1616 
    17   Float_t GetHiLoRatio()    const { return GetMean();        }
    18   Float_t GetHiLoRatioErr() const { return GetMeanErr();     }
    19   Float_t GetHiLoSigma()    const { return GetSigma();       }
    20   Float_t GetHiLoSigmaErr() const { return GetSigmaErr();    }
     17  Float_t GetHiLoChargeRatio()         const { return GetHiGainMean();     }
     18  Float_t GetHiLoChargeRatioErr()      const { return GetHiGainMeanErr();  }
     19  Float_t GetHiLoChargeRatioSigma()    const { return GetHiGainSigma();    }
     20  Float_t GetHiLoChargeRatioSigmaErr() const { return GetHiGainSigmaErr(); }
     21  Float_t GetHiLoChargeRatioProb()     const { return GetHiGainProb();     }
     22                                                                           
     23  Float_t GetHiLoTimeDiff()            const { return GetLoGainMean();     }
     24  Float_t GetHiLoTimeDiffErr()         const { return GetLoGainMeanErr();  }
     25  Float_t GetHiLoTimeDiffSigma()       const { return GetLoGainSigma();    }
     26  Float_t GetHiLoTimeDiffSigmaErr()    const { return GetLoGainSigmaErr(); }
     27  Float_t GetHiLoTimeDiffProb()        const { return GetLoGainProb();     }
    2128
    2229  ClassDef(MCalibrationHiLoPix, 1)      // Container HiLo conversion Calibration Results Pixel

  • trunk/MagicSoft/Mars/mcalib/MCalibrationIntensityHiLoCam.cc

    r5749 r5946  
    139139        continue;
    140140      //
    141       ratio[cnt]    = relpix.GetHiLoRatio();
    142       ratioerr[cnt] = relpix.GetHiLoRatioErr();
     141      ratio[cnt]    = relpix.GetHiLoChargeRatio();
     142      ratioerr[cnt] = relpix.GetHiLoChargeRatioErr();
    143143      //
    144144      sig   [cnt] = pix.GetPheFFactorMethod();
    … …  
    219219            continue;
    220220         
    221           ratiool  += relpix.GetHiLoRatio();
    222           ratiool2 += relpix.GetHiLoRatio()*relpix.GetHiLoRatio();
     221          ratiool  += relpix.GetHiLoChargeRatio();
     222          ratiool2 += relpix.GetHiLoChargeRatio()*relpix.GetHiLoChargeRatio();
    223223          num++;
    224224        }

  • trunk/MagicSoft/Mars/mhcalib/MHCalibrationHiLoCam.cc

    r5864 r5946  
    9595#include "MExtractedSignalCam.h"
    9696#include "MExtractedSignalPix.h"
    97 
    98 #include "MRawEvtPixelIter.h"
     97#include "MArrivalTimeCam.h"
     98#include "MArrivalTimePix.h"
    9999
    100100#include "MGeomCam.h"
    … …  
    128128const TString MHCalibrationHiLoCam::gsHistXTitle = "Amplification Ratio [1]";
    129129const TString MHCalibrationHiLoCam::gsHistYTitle = "Nr. events";
    130 const Byte_t  MHCalibrationHiLoCam::fgLowerLim   = 200;
    131 const Byte_t  MHCalibrationHiLoCam::fgUpperLim   = 252;
    132130// --------------------------------------------------------------------------
    133131//
    … …  
    164162  SetHistYTitle(gsHistYTitle.Data());
    165163
    166   SetLowerLim();
    167   SetUpperLim();
    168164}
    169165
    … …  
    207203
    208204  const Int_t navhi   =  fAverageHiGainAreas->GetSize();
     205  const Int_t navlo   =  fAverageLoGainAreas->GetSize();
    209206
    210207  for (int i=0; i<navhi; i++)
    211208    cam->fAverageHiGainAreas->AddAt(GetAverageHiGainArea(i).Clone(),i);
    212209
     210  for (int i=0; i<navlo; i++)
     211    cam->fAverageLoGainAreas->AddAt(GetAverageLoGainArea(i).Clone(),i);
     212
    213213  return cam;
    214 }
    215 
    216 // --------------------------------------------------------------------------
    217 //
    218 // Gets the pointers to:
    219 // - MRawEvtData
    220 //
    221 Bool_t MHCalibrationHiLoCam::SetupHists(const MParList *pList)
    222 {
    223 
    224   fRawEvt = (MRawEvtData*)pList->FindObject("MRawEvtData");
    225   if (!fRawEvt)
    226   {
    227       *fLog << err << dbginf << "MRawEvtData not found... aborting." << endl;
    228       return kFALSE;
    229   }
    230 
    231   return kTRUE;
    232214}
    233215
    … …  
    239221// Searches pointer to:
    240222// - MExtractedSignalCam
     223// - MArrivalTimeCam
    241224//
    242225// Calls:
    243226// - MHCalibrationCam::InitHiGainArrays()
     227// - MHCalibrationCam::InitLoGainArrays()
    244228//
    245229// Sets:
    246 // - SetLoGain(kFALSE);
    247230// - fSumarea   to nareas
    248231// - fSumsector to nareas
    … …  
    263246  }
    264247
     248  MArrivalTimeCam *times = (MArrivalTimeCam*)pList->FindObject("MArrivalTimeCam");
     249  if (!times)
     250  {
     251      *fLog << warn << "MArrivalTimeCam not found... cannot calibrated arrival times between "
     252            <<"high and low-gain" << endl;
     253      SetLoGain(kFALSE);
     254  }
     255
    265256  const Int_t npixels  = fGeom->GetNumPixels();
    266257  const Int_t nsectors = fGeom->GetNumSectors();
    … …  
    268259
    269260  InitHiGainArrays(npixels,nareas,nsectors);
    270 
    271   fSumarea  .Set(nareas);
    272   fSumsector.Set(nsectors);
    273   fNumarea  .Set(nareas);
    274   fNumsector.Set(nsectors);
    275 
    276   SetLoGain(kFALSE);
    277 
     261  InitLoGainArrays(npixels,nareas,nsectors);
     262
     263  fSumareahi  .Set(nareas);
     264  fSumsectorhi.Set(nsectors);
     265  fNumareahi  .Set(nareas);
     266  fNumsectorhi.Set(nsectors);
     267  if (IsLoGain())
     268    {
     269      fSumarealo  .Set(nareas);
     270      fSumsectorlo.Set(nsectors);
     271      fNumarealo  .Set(nareas);
     272      fNumsectorlo.Set(nsectors);
     273    }
    278274  return kTRUE;
    279275}
    … …  
    290286// Fills histograms (MHGausEvents::FillHistAndArray()) with:
    291287// - MExtractedSignalPix::GetExtractedSignalHiGain(pixid) / MExtractedSignalPix::GetExtractedSignalLoGain;
    292 //   if the high-gain signal lies in between the limits: fLowerLim and fUpperLim
     288//   if the high-gain signal does not show high-gain saturation, but the low-gain
     289//   has been extracted.
     290// - MArrivalTimePix::GetArrivalTimeHiGain(pixid) / MArrivalTimePix::GetArrivalTimeLoGain;
     291//   if the high-gain signal does not show high-gain saturation, but the low-gain
     292//   has been extracted.
    293293//
    294294Bool_t MHCalibrationHiLoCam::FillHists(const MParContainer *par, const Stat_t w)
    … …  
    302302    }
    303303 
     304  MArrivalTimeCam *times = (MArrivalTimeCam*)par;
     305 
     306  const Int_t npixels  = fGeom->GetNumPixels();
    304307  const Int_t nareas   = fGeom->GetNumAreas();
    305308  const Int_t nsectors = fGeom->GetNumSectors();
    306309
    307   fSumarea  .Reset();
    308   fSumsector.Reset();
    309   fNumarea  .Reset();
    310   fNumsector.Reset();
    311 
    312   MRawEvtPixelIter pixel(fRawEvt);
    313 
    314   while (pixel.Next())
    315     {
    316      
    317       const Byte_t max = pixel.GetMaxHiGainSample();
    318      
    319       if (max < fLowerLim || max > fUpperLim)
    320        continue;
    321 
    322       const UInt_t pixidx = pixel.GetPixelId();
    323 
    324       MHCalibrationPix &hist = (*this)[pixidx];
    325 
    326       if (hist.IsExcluded())
     310  fSumareahi  .Reset();
     311  fSumsectorhi.Reset();
     312  fNumareahi  .Reset();
     313  fNumsectorhi.Reset();
     314  fSumarealo  .Reset();
     315  fSumsectorlo.Reset();
     316  fNumarealo  .Reset();
     317  fNumsectorlo.Reset();
     318
     319  for (Int_t i=0; i<npixels; i++)
     320    {
     321      const MExtractedSignalPix &pix = (*signal)[i];
     322      const Int_t aidx   = (*fGeom)[i].GetAidx();
     323      const Int_t sector = (*fGeom)[i].GetSector();
     324
     325      const Float_t siglo = pix.GetExtractedSignalLoGain();
     326
     327      //
     328      // Skip all pixels with:
     329      // - Saturated high-gain
     330      // - Not extracted low-gain
     331      //   (see MExtractTimeAndCharge::fLoGainSwitch for setting the criteria)
     332      //
     333      if (siglo < 0.5 || pix.GetNumHiGainSaturated() > 0)
    327334        continue;
    328335
    329       const MExtractedSignalPix &pix = (*signal)[pixidx];
    330       const Int_t aidx   = (*fGeom)[pixidx].GetAidx();
    331       const Int_t sector = (*fGeom)[pixidx].GetSector();
    332 
    333       const Float_t ratio = pix.GetExtractedSignalHiGain() / pix.GetExtractedSignalLoGain();
    334      
    335       hist.FillHistAndArray(ratio) ;
    336       fSumarea  [aidx]   += ratio;
    337       fNumarea  [aidx]   ++;
    338       fSumsector[sector] += ratio;
    339       fNumsector[sector] ++;
     336      const Float_t sighi = pix.GetExtractedSignalHiGain();
     337      const Float_t ratio = sighi / siglo;
     338     
     339      MHCalibrationPix &histhi = (*this)[i];
     340
     341      histhi.FillHistAndArray(ratio);
     342      fSumareahi  [aidx]   += ratio;
     343      fNumareahi  [aidx]   ++;
     344      fSumsectorhi[sector] += ratio;
     345      fNumsectorhi[sector] ++;
     346
     347      if (IsLoGain())
     348        {
     349          const MArrivalTimePix &tix = (*times)[i];
     350          MHCalibrationPix &histlo = (*this)(i);         
     351
     352          const Float_t diff = tix.GetArrivalTimeLoGain() - tix.GetArrivalTimeHiGain();
     353
     354          histlo.FillHistAndArray(diff);
     355          fSumarealo  [aidx]   += diff;
     356          fNumarealo  [aidx]   ++;
     357          fSumsectorlo[sector] += diff;
     358          fNumsectorlo[sector] ++;
     359        }
    340360    }
    341361 
    342362  for (Int_t j=0; j<nareas; j++)
    343363    {
    344       MHCalibrationPix &hist = GetAverageHiGainArea(j);
    345       hist.FillHistAndArray(fNumarea[j] == 0 ? 0. : fSumarea[j]/fNumarea[j]);
     364      MHCalibrationPix &histhi = GetAverageHiGainArea(j);
     365      histhi.FillHistAndArray(fNumareahi[j] == 0 ? 0. : fSumareahi[j]/fNumareahi[j]);
     366
     367      if (IsLoGain())
     368        {
     369          MHCalibrationPix &histlo = GetAverageLoGainArea(j);
     370          histlo.FillHistAndArray(fNumarealo[j] == 0 ? 0. : fSumarealo[j]/fNumarealo[j]);
     371        }
    346372    }
    347373 
    … …  
    349375    {
    350376      MHCalibrationPix &hist = GetAverageHiGainSector(j);
    351       hist.FillHistAndArray(fNumsector[j] == 0 ? 0. : fSumsector[j]/fNumsector[j]);
     377      hist.FillHistAndArray(fNumsectorhi[j] == 0 ? 0. : fSumsectorhi[j]/fNumsectorhi[j]);
     378
     379      if (IsLoGain())
     380        {
     381          MHCalibrationPix &histlo = GetAverageLoGainSector(j);
     382          histlo.FillHistAndArray(fNumsectorlo[j] == 0 ? 0. : fSumsectorlo[j]/fNumsectorlo[j]);
     383        }
    352384    }
    353385
    … …  
    369401
    370402  MCalibrationCam *hilocam = fIntensCam ? fIntensCam->GetCam() : fCam;
    371   MBadPixelsCam   *badcam = fIntensBad ? fIntensBad->GetCam() : fBadPixels;
    372 
    373   const Int_t nareas = fAverageHiGainAreas->GetSize();
     403  MBadPixelsCam   *badcam  = fIntensBad ? fIntensBad->GetCam() : fBadPixels;
     404
     405  const Int_t nareas   = fAverageHiGainAreas->GetSize();
    374406  const Int_t nsectors = fAverageHiGainSectors->GetSize();
    375 
    376   TArrayI satarea(nareas);
    377   TArrayI satsect(nsectors);
    378   fNumarea  .Reset();
    379   fNumsector.Reset();
    380407
    381408  for (Int_t i=0; i<fHiGainArray->GetSize(); i++)
    … …  
    387414        continue;
    388415     
    389       const Int_t aidx   = (*fGeom)[i].GetAidx();
    390       const Int_t sector = (*fGeom)[i].GetSector();
    391 
    392       fNumarea[aidx]++;
    393       fNumsector[sector]++;
    394       //
    395       // Check histogram overflow
    396       //
    397416      CheckOverflow(hist);
    398417    }
    … …  
    422441                  MBadPixelsPix::kHiLoOscillating);
    423442 
     443  if (!IsLoGain())
     444    return kTRUE;
     445
     446  for (Int_t i=0; i<fLoGainArray->GetSize(); i++)
     447    {
     448     
     449      MHCalibrationPix &hist = (*this)(i);
     450
     451      if (hist.IsExcluded())
     452        continue;
     453     
     454      CheckOverflow(hist);
     455    }
     456
     457  for (Int_t j=0; j<nareas; j++)
     458    {
     459     
     460      MHCalibrationPix    &hist = GetAverageLoGainArea(j);     
     461      CheckOverflow(hist);
     462   }
     463 
     464  for (Int_t j=0; j<nsectors; j++)
     465    {
     466     
     467      MHCalibrationPix &hist = GetAverageLoGainSector(j);     
     468      CheckOverflow(hist);
     469    }
     470
     471  FitLoGainArrays(*hilocam,*badcam,
     472                  MBadPixelsPix::kHiLoNotFitted,
     473                  MBadPixelsPix::kHiLoOscillating);
     474 
    424475  return kTRUE;
    425476}
    … …  
    478529    return kFALSE;
    479530
    480   const MHCalibrationPix &pix = (*this)[idx];
     531  const MHCalibrationPix &pixhi = (*this)[idx];
     532  const MHCalibrationPix &pixlo = (*this)(idx);
    481533
    482534  switch (type)
    483535    {
    484536    case 0:
    485       val = pix.GetMean();
     537      val = pixhi.GetMean();
    486538      break;
    487539    case 1:
    488       val = pix.GetMeanErr();
     540      val = pixhi.GetMeanErr();
    489541      break;
    490542    case 2:
    491       val = pix.GetSigma();
     543      val = pixhi.GetSigma();
    492544      break;
    493545    case 3:
    494       val = pix.GetSigmaErr();
     546      val = pixhi.GetSigmaErr();
    495547      break;
    496548    case 4:
    497       val = pix.GetProb();
     549      val = pixhi.GetProb();
    498550      break;
    499551    case 5:
    500       if (!pix.IsGausFitOK())
     552      if (!pixhi.IsGausFitOK())
    501553        val = 1.;
    502554      break;
    503555    case 6:
    504       if (!pix.IsFourierSpectrumOK())
     556      if (!pixhi.IsFourierSpectrumOK())
     557        val = 1.;
     558      break;
     559    case 7:
     560      if (!IsLoGain())
     561        break;
     562      val = pixlo.GetMean();
     563      break;
     564    case 8:
     565      if (!IsLoGain())
     566        break;
     567      val = pixlo.GetMeanErr();
     568      break;
     569    case 9:
     570      if (!IsLoGain())
     571        break;
     572      val = pixlo.GetSigma();
     573      break;
     574    case 10:
     575      if (!IsLoGain())
     576        break;
     577      val = pixlo.GetSigmaErr();
     578      break;
     579    case 11:
     580      if (!IsLoGain())
     581        break;
     582      val = pixlo.GetProb();
     583      break;
     584    case 12:
     585      if (!IsLoGain())
     586        break;
     587      if (!pixlo.IsGausFitOK())
     588        val = 1.;
     589      break;
     590    case 13:
     591      if (!IsLoGain())
     592        break;
     593      if (!pixlo.IsFourierSpectrumOK())
    505594        val = 1.;
    506595      break;

  • trunk/MagicSoft/Mars/mhcalib/MHCalibrationHiLoCam.h

    r5749 r5946  
    3333  static const TString gsHistYTitle;                 //! Default Histogram y-axis titles
    3434
    35   static const Byte_t  fgLowerLim;                   //! Default for fLowerLimt        (now set to: 200)
    36   static const Byte_t  fgUpperLim;                   //! Default for fUpperLimt        (now set to: 252)
     35  MArrayD fSumareahi  ;                               //
     36  MArrayD fSumsectorhi;                               //
     37  MArrayI fNumareahi  ;                               //
     38  MArrayI fNumsectorhi;                               //
     39  MArrayD fSumarealo  ;                               //
     40  MArrayD fSumsectorlo;                               //
     41  MArrayI fNumarealo  ;                               //
     42  MArrayI fNumsectorlo;                               //
    3743
    38   Byte_t fLowerLim;                                 //  Lower allowed FADC value limit for max. slicey
    39   Byte_t fUpperLim;                                 //  Upper allowed FADC value limit for max. slicey
    40  
    41   MArrayD fSumarea  ;                               //
    42   MArrayD fSumsector;                               //
    43   MArrayI fNumarea  ;                               //
    44   MArrayI fNumsector;                               //
    45 
    46   MRawEvtData                       *fRawEvt;       //!  Raw event data
    47 
    48   Bool_t SetupHists(const MParList *pList); 
    4944  Bool_t ReInitHists(MParList *pList);
    5045  Bool_t FillHists(const MParContainer *par, const Stat_t w=1);
    … …  
    6257  TObject *Clone(const char *name="") const;
    6358
    64   Byte_t GetLowerLim() const { return fLowerLim; }
    65   Byte_t GetUpperLim() const { return fUpperLim; }   
    66 
    67   void  SetLowerLim( const UInt_t i=fgLowerLim) { fLowerLim = i; }
    68   void  SetUpperLim( const UInt_t i=fgUpperLim) { fUpperLim = i; }
    69 
    7059  Bool_t GetPixelContent(Double_t &val, Int_t idx, const MGeomCam &cam, Int_t type=0) const;
    7160  void DrawPixelContent(Int_t idx) const;
Note: See TracChangeset for help on using the changeset viewer.