Changeset 4542


Ignore:
Timestamp:
08/07/04 15:40:59 (20 years ago)
Author:
gaug
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Mars
Files:
2 added
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/MagicSoft/Mars/Changelog

    r4541 r4542  
    2323 2004/08/06: Markus Gaug
    2424 
     25   * mcalib/MCalibrationTestCalc.[h,cc]
     26   * mcalib/Makefile
     27   * mcalib/CalibLinkDef.h
     28     - new class to retrieve the results of MHCalbirationTestCam
     29     - outputs the results of the bad pixels interpolation and the
     30       new relative flat-fielding of the camera.
     31
    2532   * mjobs/MJExtractCalibTest.cc
    2633     - uncomment (and use) the interpolation of bad pixels
     34     - use the class MCalibrationTestCalc
    2735
    2836   * mcalib/MHCalibrationChargeHiGainPix.cc

  • trunk/MagicSoft/Mars/mbadpixels/MBadPixelsPix.cc

    r4456 r4542  
    6363// BIT(13): kMeanTimeInLast2Bins :  The signal has its mean maximum in the last two used FADC slice - signal extractor bad
    6464// BIT(14): kDeviatingNumPhes    :  The calculated number of photo-electrons deviates too much from the mean - inconsistency
    65 // BIT(15): kDeviatingFFactor    :  The calculated overall F-Factor deviates too much from the mean - inconsistency
     65// BIT(15): kDeviatingNumPhots   :  The calculated number of calibrated photons deviates too much from the mean - inconsistency
     66// BIT(16): kDeviatingFFactor    :  The calculated overall F-Factor deviates too much from the mean - inconsistency
    6667//
    6768// * Set bits leading to not useable low-gain signal:
    6869//
    69 // BIT(16): kConversionHiLoNotValid: The calibrated Conversion between Hi-Gain and Low Gain gives absurd results
     70// BIT(17): kConversionHiLoNotValid: The calibrated Conversion between Hi-Gain and Low Gain gives absurd results
    7071//
    7172// These bits can be called with the enum MBadPixelsPix::UncalibratedType_t in combination

  • trunk/MagicSoft/Mars/mbadpixels/MBadPixelsPix.h

    r4464 r4542  
    4545      kMeanTimeInLast2Bins      = BIT(13),
    4646      kDeviatingNumPhes         = BIT(14),
    47       kDeviatingFFactor         = BIT(15),
    48       kDeviatingTimeResolution  = BIT(16),
    49       kConversionHiLoNotValid   = BIT(17)
     47      kDeviatingNumPhots        = BIT(15),
     48      kDeviatingFFactor         = BIT(16),
     49      kDeviatingTimeResolution  = BIT(17),
     50      kConversionHiLoNotValid   = BIT(18)
    5051    };
    5152   

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

    r4402 r4542  
    1717#pragma link C++ class MCalibrationQECam+;
    1818#pragma link C++ class MCalibrationQEPix+;
     19#pragma link C++ class MCalibrationTestCalc+;
    1920#pragma link C++ class MCalibrationChargeCalc+;
    2021#pragma link C++ class MCalibrationChargeCam+;

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

    r4541 r4542  
    949949  Float_t lowlim      [nareas];
    950950  Float_t upplim      [nareas];
    951   Float_t areavars    [nareas];
    952   Float_t areaweights [nareas], sectorweights [nsectors];
    953   Float_t areaphes    [nareas], sectorphes    [nsectors];
     951  Double_t areavars   [nareas];
     952  Double_t areaweights[nareas], sectorweights [nsectors];
     953  Double_t areaphes   [nareas], sectorphes    [nsectors];
    954954  Int_t   numareavalid[nareas], numsectorvalid[nsectors];
    955955
    956956  memset(lowlim        ,0, nareas   * sizeof(Float_t));
    957957  memset(upplim        ,0, nareas   * sizeof(Float_t));
    958   memset(areaphes      ,0, nareas   * sizeof(Float_t));
    959   memset(areavars      ,0, nareas   * sizeof(Float_t));
    960   memset(areaweights   ,0, nareas   * sizeof(Float_t));
     958  memset(areaphes      ,0, nareas   * sizeof(Double_t));
     959  memset(areavars      ,0, nareas   * sizeof(Double_t));
     960  memset(areaweights   ,0, nareas   * sizeof(Double_t));
    961961  memset(numareavalid  ,0, nareas   * sizeof(Int_t  ));
    962   memset(sectorweights ,0, nsectors * sizeof(Float_t));
    963   memset(sectorphes    ,0, nsectors * sizeof(Float_t));
     962  memset(sectorweights ,0, nsectors * sizeof(Double_t));
     963  memset(sectorphes    ,0, nsectors * sizeof(Double_t));
    964964  memset(numsectorvalid,0, nsectors * sizeof(Int_t  ));
    965965 
    … …  
    10661066
    10671067  memset(numareavalid,0,nareas*sizeof(Int_t));
    1068   memset(areaphes    ,0,nareas*sizeof(Float_t));
    1069   memset(areavars    ,0,nareas*sizeof(Float_t));
     1068  memset(areaphes    ,0,nareas*sizeof(Double_t));
     1069  memset(areavars    ,0,nareas*sizeof(Double_t));
    10701070
    10711071  //
    … …  
    13671367  Float_t lowlim           [nareas];
    13681368  Float_t upplim           [nareas];
    1369   Float_t avffactorphotons [nareas];
    1370   Float_t avffactorphotvar [nareas];
     1369  Double_t avffactorphotons [nareas];
     1370  Double_t avffactorphotvar [nareas];
    13711371  Int_t   numffactor       [nareas];
    13721372
    13731373  memset(lowlim          ,0, nareas   * sizeof(Float_t));
    13741374  memset(upplim          ,0, nareas   * sizeof(Float_t));
    1375   memset(avffactorphotons,0, nareas   * sizeof(Float_t));
    1376   memset(avffactorphotvar,0, nareas   * sizeof(Float_t));
     1375  memset(avffactorphotons,0, nareas   * sizeof(Double_t));
     1376  memset(avffactorphotvar,0, nareas   * sizeof(Double_t));
    13771377  memset(numffactor      ,0, nareas   * sizeof(Int_t));
    13781378

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

    r4402 r4542  
    4848private:
    4949
    50   static const Float_t fgChargeLimit;          //! Default for fChargeLimit            (now set to: 2.5)
    51   static const Float_t fgChargeErrLimit;       //! Default for fChargeErrLimit         (now set to: 0.)
    52   static const Float_t fgChargeRelErrLimit;    //! Default for fChargeRelErrLimit      (now set to: 1.)
    53   static const Float_t fgLambdaCheckLimit;     //! Default for fLambdaCheckLimit       (now set to: 0.2)
    54   static const Float_t fgLambdaErrLimit;       //! Default for fLabmdaErrLimit         (now set to: 0.5)
    55   static const Float_t fgPheErrLimit;          //! Default for fPheErrLimit            (now set to: 4.)
    56   static const Float_t fgFFactorErrLimit;      //! Default for fFFactorErrLimit        (now set to: 4.)
     50  static const Float_t fgChargeLimit;          //! Default for fChargeLimit        (now set to: 2.5)
     51  static const Float_t fgChargeErrLimit;       //! Default for fChargeErrLimit     (now set to: 0.)
     52  static const Float_t fgChargeRelErrLimit;    //! Default for fChargeRelErrLimit  (now set to: 1.)
     53  static const Float_t fgLambdaCheckLimit;     //! Default for fLambdaCheckLimit   (now set to: 0.2)
     54  static const Float_t fgLambdaErrLimit;       //! Default for fLabmdaErrLimit     (now set to: 0.5)
     55  static const Float_t fgPheErrLimit;          //! Default for fPheErrLimit        (now set to: 4.)
     56  static const Float_t fgFFactorErrLimit;      //! Default for fFFactorErrLimit    (now set to: 4.)
    5757 
    5858  // Variables
    … …  
    107107  void   PrintUncalibrated( MBadPixelsPix::UncalibratedType_t typ, const char *text) const;
    108108
    109   void   SetPheFitOK          ( const Int_t aidx, const Bool_t b=kTRUE ) { b ? SETBIT(fResultFlags[aidx], kPheFitOK)
    110                                                                              : CLRBIT(fResultFlags[aidx], kPheFitOK);      }
    111   void   SetFFactorFitOK      ( const Int_t aidx, const Bool_t b=kTRUE ) { b ? SETBIT(fResultFlags[aidx], kFFactorFitOK)
    112                                                                              : CLRBIT(fResultFlags[aidx], kFFactorFitOK);  }
    113   void   SetBlindPixelFitOK   ( const Int_t  idx, const Bool_t b=kTRUE ) { b ? SETBIT(fBlindPixelFlags[idx], kBlindPixelFitOK)
    114                                                                              : CLRBIT(fBlindPixelFlags[idx], kBlindPixelFitOK); }
    115   void   SetBlindPixelPedFitOK( const Int_t  idx, const Bool_t b=kTRUE ) { b ? SETBIT(fBlindPixelFlags[idx], kBlindPixelPedFitOK)
    116                                                                              : CLRBIT(fBlindPixelFlags[idx], kBlindPixelPedFitOK); }
    117   void   SetPINDiodeFitOK     ( const Int_t  idx, const Bool_t b=kTRUE ) { b ? SETBIT(fPINDiodeFlags[idx], kPINDiodeFitOK)
    118                                                                              : CLRBIT(fPINDiodeFlags[idx], kPINDiodeFitOK); }
     109  void   SetPheFitOK          ( const Int_t aidx, const Bool_t b=kTRUE ) {
     110    b ? SETBIT(fResultFlags[aidx], kPheFitOK)
     111      : CLRBIT(fResultFlags[aidx], kPheFitOK);      }
     112  void   SetFFactorFitOK      ( const Int_t aidx, const Bool_t b=kTRUE ) {
     113    b ? SETBIT(fResultFlags[aidx], kFFactorFitOK)
     114      : CLRBIT(fResultFlags[aidx], kFFactorFitOK);  }
     115  void   SetBlindPixelFitOK   ( const Int_t  idx, const Bool_t b=kTRUE ) {
     116    b ? SETBIT(fBlindPixelFlags[idx], kBlindPixelFitOK)
     117      : CLRBIT(fBlindPixelFlags[idx], kBlindPixelFitOK); }
     118  void   SetBlindPixelPedFitOK( const Int_t  idx, const Bool_t b=kTRUE ) {
     119    b ? SETBIT(fBlindPixelFlags[idx], kBlindPixelPedFitOK)
     120      : CLRBIT(fBlindPixelFlags[idx], kBlindPixelPedFitOK); }
     121  void   SetPINDiodeFitOK     ( const Int_t  idx, const Bool_t b=kTRUE ) {
     122    b ? SETBIT(fPINDiodeFlags[idx], kPINDiodeFitOK)
     123      : CLRBIT(fPINDiodeFlags[idx], kPINDiodeFitOK); }
    119124
    120125  Int_t  PreProcess (MParList *pList);

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

    r4539 r4542  
    116116 
    117117  SetAverageNbins(5000);
     118
     119  fNotInterpolateablePixels.Set(0);
    118120}
    119121
    … …  
    376378      if (hist.IsEmpty())
    377379        {
    378           *fLog << warn << GetDescriptor() << ": WARNING: Not interpolated histogram pixel: " << i << endl;
     380          const Int_t size = fNotInterpolateablePixels.GetSize();
     381          fNotInterpolateablePixels.Set(size+1);
     382          fNotInterpolateablePixels[size] = i;
    379383          continue;
    380384        }
    … …  
    441445}
    442446
    443 // --------------------------------------------------------------------------
    444 //
    445 // Sets all pixels to MBadPixelsPix::kUnreliableRun, if following flags are set:
    446 // - MBadPixelsPix::kTestNotFitted
    447 // - MBadPixelsPix::kTestOscillating
    448 //
    449 void MHCalibrationTestCam::FinalizeBadPixels()
    450 {
    451 
    452 }
    453447
    454448// --------------------------------------------------------------------------

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

    r4152 r4542  
    77#ifndef ROOT_TArrayF
    88#include "TArrayF.h"
     9#endif
     10#ifndef ROOT_TArrayI
     11#include "TArrayI.h"
    912#endif
    1013
    … …  
    1922  TArrayF fMeanSigmaPhotPerArea;
    2023  TArrayF fRmsSigmaPhotPerArea   ;
     24
     25  TArrayI fNotInterpolateablePixels;
    2126 
    2227  Bool_t ReInitHists(MParList *pList);
    2328  Bool_t FillHists(const MParContainer *par, const Stat_t w=1);
    2429  Bool_t FinalizeHists();
    25   void    FinalizeBadPixels();
    2630 
    2731public:
    … …  
    3337  void DrawPixelContent(Int_t idx) const;
    3438
    35   const Float_t GetMeanMeanPhotPerArea       ( const Int_t aidx ) const   { return fMeanMeanPhotPerArea [aidx]; }
    36   const Float_t GetRmsMeanPhotPerArea        ( const Int_t aidx ) const   { return fRmsMeanPhotPerArea [aidx]; }
    37   const Float_t GetMeanSigmaPhotPerArea      ( const Int_t aidx ) const   { return fMeanSigmaPhotPerArea [aidx]; }
    38   const Float_t GetRmsSigmaPhotPerArea       ( const Int_t aidx ) const  { return fRmsSigmaPhotPerArea  [aidx]; }
     39  const Float_t  GetMeanMeanPhotPerArea  ( const Int_t aidx ) const { return fMeanMeanPhotPerArea [aidx]; }
     40  const Float_t  GetMeanSigmaPhotPerArea ( const Int_t aidx ) const { return fMeanSigmaPhotPerArea [aidx]; }
     41  const Float_t  GetRmsMeanPhotPerArea   ( const Int_t aidx ) const { return fRmsMeanPhotPerArea  [aidx]; }
     42  const Float_t  GetRmsSigmaPhotPerArea  ( const Int_t aidx ) const { return fRmsSigmaPhotPerArea  [aidx]; }
    3943
     44  const TArrayI &GetNotInterpolateablePixels ()               const { return fNotInterpolateablePixels;    }
     45 
    4046  void CalcAverageSigma();
    4147 
    42   ClassDef(MHCalibrationTestCam, 0)     // Histogram class for Relative Time Camera Calibration
     48  ClassDef(MHCalibrationTestCam, 1)     // Histogram class for Relative Time Camera Calibration
    4349};
    4450

  • trunk/MagicSoft/Mars/mcalib/Makefile

    r4401 r4542  
    4242           MCalibrationQEPix.cc  \
    4343           MCalibrationPedCam.cc \
     44           MCalibrationTestCalc.cc \
    4445           MCalibrationChargeCalc.cc \
    4546           MCalibrationChargeCam.cc \

  • trunk/MagicSoft/Mars/mjobs/MJExtractCalibTest.cc

    r4532 r4542  
    5353#include "MCalibrationRelTimeCam.h"
    5454#include "MCalibrationQECam.h"
     55#include "MCalibrationTestCalc.h"
    5556#include "MHCamEvent.h"
    5657
    … …  
    262263  badtreat.SetUseInterpolation();
    263264  badtreat.SetSloppyTreatment();
     265  MCalibrationTestCalc  testcalc;
     266  testcalc.SetOutputPath(fOutputPath);
     267  testcalc.SetOutputFile(Form("%s-TestCalibStat.txt",(const char*)fRuns->GetRunsAsFileName()));
    264268
    265269  MHCamEvent evt("ExtSignal");
    … …  
    294298  tlist.AddToList(&badtreat);
    295299  tlist.AddToList(&fillcam);
     300  tlist.AddToList(&testcalc);
    296301 
    297302  // Create and setup the eventloop
Note: See TracChangeset for help on using the changeset viewer.