Ignore:
Timestamp:
05/11/05 19:06:48 (20 years ago)
Author:
tbretz
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Mars/mcalib
Files:
6 edited

Legend:

Unmodified
Added
Removed

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

    r7005 r7013  
    334334// Read the setup from a TEnv, eg:
    335335//   MCalibCalcFromPast.UpdateWithFFactorMethod: Off, On
     336//   MCalibCalcFromPast.NumEventsDump: 500
    336337//
    337338Int_t MCalibCalcFromPast::ReadEnv(const TEnv &env, TString prefix, Bool_t print)
    … …  
    344345    }
    345346
     347    if (IsEnvDefined(env, prefix, "NumEventsDump", print))
     348    {
     349        SetNumEventsDump(GetEnvValue(env, prefix, "NumEventsDump", (Int_t)fNumEventsDump));
     350        rc = kTRUE;
     351    }
     352
    346353    return rc;
    347354}

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

    r6928 r7013  
    231231using namespace std;
    232232
    233 const Float_t MCalibrationChargeCalc::fgChargeLimit            = 2.5;
     233const Float_t MCalibrationChargeCalc::fgChargeLimit            = 4.5;
    234234const Float_t MCalibrationChargeCalc::fgChargeErrLimit         = 0.;
    235235const Float_t MCalibrationChargeCalc::fgChargeRelErrLimit      = 1.;
    … …  
    238238const Float_t MCalibrationChargeCalc::fgPheErrLimit            = 4.5;
    239239const Float_t MCalibrationChargeCalc::fgFFactorErrLimit        = 4.5;
     240const Float_t MCalibrationChargeCalc::fgArrTimeRmsLimit        = 3.5;
    240241const TString MCalibrationChargeCalc::fgNamePedestalCam = "MPedestalCam";
     242
    241243// --------------------------------------------------------------------------
    242244//
    … …  
    252254//
    253255// Initializes:
     256// - fArrTimeRmsLimit   to fgArrTimeRmsLimit
    254257// - fChargeLimit       to fgChargeLimit
    255258// - fChargeErrLimit    to fgChargeErrLimit   
    … …  
    282285  AddToBranchList("MRawEvtData.fLoGainFadcSamples");
    283286 
     287  SetArrTimeRmsLimit   ();
    284288  SetChargeLimit       ();
    285289  SetChargeErrLimit    (); 
    … …  
    294298  SetDebug       ( kFALSE );
    295299
     300  SetCheckArrivalTimes     ();
    296301  SetCheckDeadPixels       ();
    297302  SetCheckDeviatingBehavior();
    … …  
    732737      if (FinalizeCharges(pix,bad,"pixel  "))
    733738        nvalid++;
     739
     740      FinalizeArrivalTimes(pix,bad,"pixel  ");
    734741    }
    735742
    … …  
    760767      FinalizePedestals(ped,pix,aidx);
    761768      FinalizeCharges(pix, chargecam->GetAverageBadArea(aidx),"area id");
     769      FinalizeArrivalTimes(pix, chargecam->GetAverageBadArea(aidx), "area id");
    762770    }
    763771 
    … …  
    855863  PrintUncalibrated(MBadPixelsPix::kLoGainOverFlow,   
    856864                    "Pixels with Low Gain Overflow :                   ");
     865  PrintUncalibrated(MBadPixelsPix::kFluctuatingArrivalTimes,
     866                    "Fluctuating Pulse Arrival Times:                  ");
     867  PrintUncalibrated(MBadPixelsPix::kDeadPedestalRms,
     868                    "Presumably dead from Pedestal Rms:                ");
     869  PrintUncalibrated(MBadPixelsPix::kPreviouslyExcluded,
     870                    "Previously excluded:                              ");
    857871
    858872  *fLog << inf << endl;
    … …  
    10181032}
    10191033
    1020 
     1034// -----------------------------------------------------------------------------------
     1035//
     1036// Test the arrival Times RMS of the pixel and set the bit
     1037// - MBadPixelsPix::kFluctuatingArrivalTimes
     1038//
     1039void MCalibrationChargeCalc::FinalizeArrivalTimes(MCalibrationChargePix &cal, MBadPixelsPix &bad, const char* what)
     1040{
     1041    if (bad.IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
     1042        return;
     1043
     1044    if (cal.GetAbsTimeRms() > fArrTimeRmsLimit)
     1045    {
     1046        *fLog << warn;
     1047        *fLog << "RMS of pulse arrival times: " << Form("%2.1f", cal.GetAbsTimeRms());
     1048        *fLog << " FADC sl. < " << Form("%2.1", fArrTimeRmsLimit);
     1049        *fLog << "   in " << what << Form("%3i", cal.GetPixId()) << endl;
     1050        bad.SetUncalibrated( MBadPixelsPix::kFluctuatingArrivalTimes);
     1051    }
     1052}
    10211053
    10221054// -----------------------------------------------------------------------------------
    … …  
    10391071{
    10401072 
    1041   MBadPixelsCam         *badcam    = fIntensBad
    1042     ? (MBadPixelsCam*)        fIntensBad->GetCam()  : fBadPixels;
    1043   MCalibrationChargeCam *chargecam = fIntensCam
    1044     ? (MCalibrationChargeCam*)fIntensCam->GetCam()  : fCam;
     1073  MBadPixelsCam *badcam = fIntensBad ? (MBadPixelsCam*)fIntensBad->GetCam() : fBadPixels;
    10451074
    10461075  for (Int_t i=0; i<badcam->GetSize(); i++)
    10471076    {
    10481077     
    1049       MBadPixelsPix    &bad    = (*badcam)   [i];
    1050       MCalibrationPix  &pix    = (*chargecam)[i];
     1078      MBadPixelsPix &bad = (*badcam)[i];
    10511079
    10521080      if (IsCheckDeadPixels())
    … …  
    10861114        }
    10871115     
    1088       if (bad.IsUnsuitable(   MBadPixelsPix::kUnsuitableRun    ))
    1089         pix.SetExcluded();
     1116      if (IsCheckArrivalTimes())
     1117        {
     1118          if (bad.IsUncalibrated( MBadPixelsPix::kFluctuatingArrivalTimes ))
     1119            bad.SetUnsuitable(   MBadPixelsPix::kUnsuitableRun    );
     1120        }
    10901121
    10911122      if (bad.IsUncalibrated( MBadPixelsPix::kChargeSigmaNotValid ))
    … …  
    18121843          qepix.SetFFactorMethodValid(kFALSE,fPulserColor);
    18131844          pix.SetFFactorMethodValid(kFALSE);
    1814           pix.SetExcluded();
    18151845          continue;
    18161846        }
    … …  
    22002230      rc = kTRUE;
    22012231    }
     2232  if (IsEnvDefined(env, prefix, "ArrTimeRmsLimit", print))
     2233    {
     2234      SetArrTimeRmsLimit(GetEnvValue(env, prefix, "ArrTimeRmsLimit", fArrTimeRmsLimit));
     2235      rc = kTRUE;
     2236    }
    22022237  if (IsEnvDefined(env, prefix, "FFactorErrLimit", print))
    22032238    {
    … …  
    22452280      rc = kTRUE;
    22462281    }
    2247  
     2282  if (IsEnvDefined(env, prefix, "CheckArrivalTimes", print))
     2283    {
     2284      SetCheckArrivalTimes(GetEnvValue(env, prefix, "CheckArrivalTimes", IsCheckArrivalTimes()));
     2285      rc = kTRUE;
     2286    }
     2287
    22482288  return rc;
    22492289}

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

    r6153 r7013  
    5656  static const Float_t fgPheErrLimit;          //! Default for fPheErrLimit        (now set to: 4.5)
    5757  static const Float_t fgFFactorErrLimit;      //! Default for fFFactorErrLimit    (now set to: 4.5)
     58  static const Float_t fgArrTimeRmsLimit;      //! Default for fArrTimeRmsLimit    (now set to: 3.5)
    5859 
    5960  static const TString fgNamePedestalCam;      //! "MPedestalCam"
    … …  
    6970  Float_t fPheErrLimit;                        // Limit acceptance nr. phe's w.r.t. area idx mean (in sigmas)
    7071  Float_t fFFactorErrLimit;                    // Limit acceptance F-Factor w.r.t. area idx mean
     72  Float_t fArrTimeRmsLimit;                    // Limit acceptance RMS of absolute arrival times
    7173  Float_t fSqrtHiGainSamples;                  // Square root nr. High-Gain FADC slices used by extractor
    7274  Float_t fSqrtLoGainSamples;                  // Square root nr. Low -Gain FADC slices used by extractor
    … …  
    112114      kCheckHistOverflow,
    113115      kCheckDeviatingBehavior,
    114       kCheckOscillations
     116      kCheckOscillations,
     117      kCheckArrivalTimes
    115118    };                                         // Possible Checks
    116119
    … …  
    122125  // functions
    123126  void   FinalizePedestals       ( const MPedestalPix    &ped, MCalibrationChargePix &cal, const Int_t aidx );
     127  void   FinalizeArrivalTimes    ( MCalibrationChargePix &cal, MBadPixelsPix &bad, const char* what);
    124128  Bool_t FinalizeCharges         ( MCalibrationChargePix &cal, MBadPixelsPix &bad, const char* what);
    125129  Bool_t FinalizePINDiode        ();
    … …  
    141145  Bool_t IsCheckHistOverflow     () const { return TESTBIT(fCheckFlags,kCheckHistOverflow);      }
    142146  Bool_t IsCheckOscillations     () const { return TESTBIT(fCheckFlags,kCheckOscillations);      }
     147  Bool_t IsCheckArrivalTimes     () const { return TESTBIT(fCheckFlags,kCheckArrivalTimes);      }
    143148
    144149  void   PrintUncalibrated( MBadPixelsPix::UncalibratedType_t typ, const char *text) const;
    … …  
    182187
    183188  // Checks
     189  void SetCheckArrivalTimes( const Bool_t b=kTRUE ) {
     190    b ? SETBIT(fCheckFlags,kCheckArrivalTimes)
     191      : CLRBIT(fCheckFlags,kCheckArrivalTimes); }
    184192  void SetCheckDeadPixels( const Bool_t b=kTRUE ) {
    185193    b ? SETBIT(fCheckFlags,kCheckDeadPixels)
    … …  
    203211  void SetPedestals(MPedestalCam *cam) { fPedestals=cam; }
    204212                                                                         
     213  void SetArrTimeRmsLimit   ( const Float_t f=fgArrTimeRmsLimit        ) { fArrTimeRmsLimit   = f;     }
    205214  void SetFFactorErrLimit   ( const Float_t f=fgFFactorErrLimit        ) { fFFactorErrLimit   = f;     }
    206215  void SetLambdaErrLimit    ( const Float_t f=fgLambdaErrLimit         ) { fLambdaErrLimit    = f;     }

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

    r7005 r7013  
    289289    {
    290290     
    291       if (!pix->IsExcluded())
     291      if (pix->IsFFactorMethodValid())
    292292        {                           
    293293
    … …  
    311311   
    312312  *fLog << all << endl;
    313   *fLog << all << "Excluded pixels:" << endl;
     313  *fLog << all << "Previously Excluded pixels:" << endl;
    314314  *fLog << all << endl;
    315315 
    … …  
    329329  }
    330330 
     331  *fLog << all << endl;
     332  *fLog << all << "New Excluded pixels:" << endl;
     333  *fLog << all << endl;
     334 
     335  TIter Next5(fPixels);
     336  while ((pix=(MCalibrationChargePix*)Next5()))
     337  {
     338      if (!pix->IsFFactorMethodValid() && !pix->IsExcluded())
     339      {
     340        *fLog << all << pix->GetPixId() << " ";
     341        id++;
     342
     343        if (!(id % 25))
     344          *fLog << endl;
     345      }
     346  }
     347 
    331348  *fLog << endl;
    332349  *fLog << all << id << " Excluded pixels " << endl;
    … …  
    337354  *fLog << all << endl;
    338355
    339   TIter Next5(fAverageAreas);
    340   while ((pix=(MCalibrationChargePix*)Next5()))
     356  TIter Next6(fAverageAreas);
     357  while ((pix=(MCalibrationChargePix*)Next6()))
    341358  {
    342359    *fLog << all << Form("%s%3i","Area Idx: ",pix->GetPixId())
    … …  
    353370  *fLog << all << endl;
    354371
    355   TIter Next6(fAverageSectors);
    356   while ((pix=(MCalibrationChargePix*)Next6()))
     372  TIter Next7(fAverageSectors);
     373  while ((pix=(MCalibrationChargePix*)Next7()))
    357374  {
    358375    *fLog << all << Form("%s%3i","Sector: ",pix->GetPixId())
    … …  
    482499      break;
    483500    case 5:
    484       if (pix.IsExcluded())
     501      if (!pix.IsFFactorMethodValid())
    485502        return kFALSE;
    486503      if (pix.GetRSigma() == -1.)
    … …  
    489506      break;
    490507    case 6:
    491       if (pix.IsExcluded())
     508      if (!pix.IsFFactorMethodValid())
    492509        return kFALSE;   
    493510      if (pix.GetRSigma() == -1.)
    … …  
    496513      break;
    497514    case 7:
    498       if (pix.IsExcluded())
     515      if (!pix.IsFFactorMethodValid())
    499516        return kFALSE;
    500517      val = pix.GetRSigmaPerCharge();
    501518      break;
    502519    case 8:
    503       if (pix.IsExcluded())
     520      if (!pix.IsFFactorMethodValid())
    504521        return kFALSE;
    505522      val =  pix.GetRSigmaPerChargeErr();
    506523      break;
    507524    case 9:
    508       if (pix.IsExcluded() || !pix.IsFFactorMethodValid())
     525      if (!pix.IsFFactorMethodValid())
    509526        return kFALSE;
    510527      val = pix.GetPheFFactorMethod();
    511528      break;
    512529    case 10:
    513       if (pix.IsExcluded() || !pix.IsFFactorMethodValid())
     530      if (!pix.IsFFactorMethodValid())
    514531        return kFALSE;
    515532      val = pix.GetPheFFactorMethodErr();
    516533      break;
    517534    case 11:
    518       if (pix.IsExcluded() || !pix.IsFFactorMethodValid())
     535      if (!pix.IsFFactorMethodValid())
    519536        return kFALSE;
    520537      val = pix.GetMeanConvFADC2Phe();
    521538      break;
    522539    case 12:
    523       if (pix.IsExcluded() || !pix.IsFFactorMethodValid())
     540      if (!pix.IsFFactorMethodValid())
    524541        return kFALSE;
    525542      val = pix.GetMeanConvFADC2PheErr();
    526543      break;
    527544    case 13:
    528       if (pix.IsExcluded() || !pix.IsFFactorMethodValid())
     545      if (!pix.IsFFactorMethodValid())
    529546        return kFALSE;
    530547      val = pix.GetMeanFFactorFADC2Phot();
    531548      break;
    532549    case 14:
    533       if (pix.IsExcluded() || !pix.IsFFactorMethodValid())
     550      if (!pix.IsFFactorMethodValid())
    534551        return kFALSE;
    535552      val = pix.GetMeanFFactorFADC2PhotErr();
    … …  
    625642      break;
    626643    case 32:
     644      if (pix.IsExcluded())
     645        return kFALSE;
    627646      val = pix.GetMean() == 0. ? 0. : pix.GetRms()/pix.GetMean();
     647      break;
     648    case 33:
     649      if (pix.IsExcluded())
     650        return kFALSE;
     651      if (pix.GetMean() == 0.)
     652        val = 0.;
     653      else
     654        val = pix.GetSigmaErr()/pix.GetMean() + pix.GetRms()/pix.GetMean()/pix.GetMean()*pix.GetMeanErr();
    628655      break;
    629656    default:
    … …  
    633660  return val!=-1.;
    634661}
    635 
    636662
    637663

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

    r5200 r7013  
    6969//           MHCalibrationChargeCam, MHCalibrationChargePix
    7070//
     71//
     72// ClassVersion 3:
     73//  + fNumSaturated
     74//
    7175/////////////////////////////////////////////////////////////////////////////
    7276#include "MCalibrationChargePix.h"
    … …  
    9094const Float_t MCalibrationChargePix::fgPheFFactorMethodLimit    = 1.;
    9195const Float_t MCalibrationChargePix::fgConvFFactorRelErrLimit   = 0.85;
     96
    9297// --------------------------------------------------------------------------
    9398//
    … …  
    105110//
    106111MCalibrationChargePix::MCalibrationChargePix(const char *name, const char *title)
    107     : fCalibFlags(0)
     112    : fCalibFlags(0), fNumSaturated(0)
    108113{
    109114
    … …  
    158163  fMeanFFactorFADC2Phot             =  -1.;
    159164  fMeanFFactorFADC2PhotVar          =  -1.; 
     165
     166  fNumSaturated                     =   0;
    160167
    161168  MCalibrationPix::Clear();

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

    r5197 r7013  
    4141  Float_t fRSigmaSquare;                    // Square of Reduced sigma
    4242  Float_t fRSigmaSquareVar;                 // Variance Reduced sigma
     43
     44  Int_t   fNumSaturated;                    // Number of (high-gain) saturated events
    4345 
    4446  enum  { kFFactorMethodValid   };          // Possible bits to be set
    … …  
    7173  void SetPheFFactorMethodVar   ( const Float_t f)                          { fPheFFactorMethodVar    = f; } 
    7274  void SetPheFFactorMethodLimit ( const Float_t f=fgPheFFactorMethodLimit ) { fPheFFactorMethodLimit  = f; }
     75  void SetNumSaturated          ( const Int_t   i)                          { fNumSaturated           = i; }
    7376 
    7477  // Getters
    … …  
    9093  Float_t GetMeanFFactorFADC2PhotErr () const;
    9194  Float_t GetMeanFFactorFADC2PhotVar () const { return fMeanFFactorFADC2PhotVar; }   
     95  Int_t   GetNumSaturated            () const { return fNumSaturated;            }
    9296  Float_t GetPed                     () const { return fPed;                     }
    9397  Float_t GetPedErr                  () const { return TMath::Sqrt(fPedVar);     }
    … …  
    113117  Bool_t CalcMeanFFactor   ( const Float_t nphotons, const Float_t nphotonsrelvar );
    114118 
    115   ClassDef(MCalibrationChargePix, 2)    // Container Charge Calibration Results Pixel
     119  ClassDef(MCalibrationChargePix, 3)    // Container Charge Calibration Results Pixel
    116120};
    117121
Note: See TracChangeset for help on using the changeset viewer.