Ignore:
Timestamp:
09/09/04 17:56:49 (20 years ago)
Author:
gaug
Message:
*** empty log message ***
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r4882 r4908  
    194194#include "MParList.h"
    195195
    196 #include "MRawRunHeader.h"
    197 #include "MRawEvtPixelIter.h"
     196#include "MRawEvtHeader.h"
    198197
    199198#include "MGeomCam.h"
    … …  
    203202#include "MPedestalCam.h"
    204203#include "MPedestalPix.h"
     204
     205#include "MCalibrationIntensityChargeCam.h"
    205206
    206207#include "MCalibrationChargeCam.h"
    … …  
    260261//
    261262MCalibrationChargeCalc::MCalibrationChargeCalc(const char *name, const char *title)
    262     : fQECam(NULL), fGeom(NULL)
     263    : fQECam(NULL), fGeom(NULL), fSignal(NULL), fHeader(NULL)
    263264{
    264265       
    … …  
    307308    fBadPixels  = NULL;
    308309    fCam        = NULL;
     310    fIntensCam  = NULL;
    309311    fBlindPixel = NULL;
    310312    fBlindCam   = NULL;
    … …  
    312314    fPedestals  = NULL;
    313315
     316    fPulserPattern = 0;
    314317    SetPulserColor ( MCalibrationCam::kNONE );
    315318   
    … …  
    333336{
    334337 
     338  fHeader = (MRawEvtHeader*)pList->FindObject("MRawEvtHeader");
     339  if (!fHeader)
     340    {
     341      *fLog << err << "MRawEvtHeader not found... abort." << endl;
     342      return kFALSE;
     343    }
     344
    335345  //
    336346  // Containers that have to be there.
    … …  
    343353    }
    344354 
     355  fSignal = (MExtractedSignalCam*)pList->FindObject("MExtractedSignalCam");
     356  if (!fSignal)
     357    {
     358      *fLog << err << "MExtractedSignalCam not found... aborting" << endl;
     359      return kFALSE;
     360    }
     361 
    345362  //
    346363  // Containers that are created in case that they are not there.
    … …  
    360377    }
    361378
    362  
    363   //
    364   // Check the pulser colour --> FIXME: this solution is only valid until the arrival of the DM's
    365   //
    366   if (fPulserColor == MCalibrationCam::kNONE)
    367     {
    368       *fLog << endl;
    369       *fLog << err << GetDescriptor()
    370             << ": No Pulser colour has been chosen. Since the installation of the IFAE pulser box,"
    371             << " you HAVE to provide the LEDs colour, otherwise there is no calibration. " << endl;
    372       *fLog << "See e.g. the macro calibration.C " << endl;
     379  fHeader = (MRawEvtHeader*)pList->FindObject("MRawEvtHeader");
     380  if (!fHeader)
     381    {
     382      *fLog << err << "MRawEvtHeader not found... abort." << endl;
    373383      return kFALSE;
    374384    }
    375  
     385
     386
    376387  return kTRUE;
    377388}
    … …  
    395406// It defines the PixId of every pixel in:
    396407//
     408// - MCalibrationIntensityChargeCam
    397409// - MCalibrationChargeCam
    398410// - MCalibrationQECam
    … …  
    419431    }
    420432 
    421   fCam = (MCalibrationChargeCam*)pList->FindObject("MCalibrationChargeCam");
    422   if (!fCam)
    423     {
    424       *fLog << err << "Cannot find MCalibrationChargeCam... aborting" << endl;
    425       *fLog << err << "Maybe you forget to call an MFillH for the MHCalibrationChargeCam before..." << endl;
    426       return kFALSE;
    427     }
    428 
     433  fIntensCam = (MCalibrationIntensityChargeCam*)pList->FindObject(AddSerialNumber("MCalibrationIntensityChargeCam"));
     434  if (fIntensCam)
     435    *fLog << inf << "Found MCalibrationIntensityChargeCam ... " << endl;
     436  else
     437    {
     438      fCam = (MCalibrationChargeCam*)pList->FindObject(AddSerialNumber("MCalibrationChargeCam"));
     439      if (!fCam)
     440        {
     441          *fLog << err << "Cannot find MCalibrationChargeCam ... abort." << endl;
     442          *fLog << err << "Maybe you forget to call an MFillH for the MHCalibrationChargeCam before..." << endl;
     443          return kFALSE;
     444        }
     445    }
     446 
    429447  //
    430448  // Optional Containers
    … …  
    451469    }
    452470 
    453 
    454   //
    455   // Initialize the pulser colours
    456   //
    457   if (fCam->GetPulserColor() == MCalibrationCam::kNONE)
    458     {
    459       fCam->SetPulserColor( fPulserColor );
    460      
    461       if (fBlindPixel)
    462         fBlindPixel->SetColor( fPulserColor );
    463      
    464       if (fBlindCam)
    465         fBlindCam->SetColor( fPulserColor );
    466      
    467       if (fPINDiode)
    468         fPINDiode->SetColor( fPulserColor );
    469     }
    470 
    471   if (fPulserColor != fCam->GetPulserColor())
    472     {
    473       *fLog << err << GetDescriptor()
    474             << ": Pulser colour has changed w.r.t. last file in MCalibrationChargeCam" << endl;
    475       *fLog << err << "This feature is not yet implemented, sorry ... aborting " << endl;
    476       return kFALSE;
    477     }
    478 
    479   if (fBlindPixel)
    480     if (fPulserColor != fBlindPixel->GetColor())
    481       {
    482         *fLog << err << GetDescriptor()
    483               << ": Pulser colour has changed w.r.t. last file in MCalibrationChargeBlindPix." << endl;
    484         *fLog << err << "This feature is not yet implemented, sorry ... aborting " << endl;
    485         return kFALSE;
    486       }
    487 
    488   if (fBlindCam)
    489     if (fPulserColor != fBlindCam->GetColor())
    490       {
    491         *fLog << err << GetDescriptor()
    492               << ": Pulser colour has changed w.r.t. last file in MCalibrationChargeBlindCam." << endl;
    493         *fLog << err << "This feature is not yet implemented, sorry ... aborting " << endl;
    494         return kFALSE;
    495       }
    496  
    497   if (fPINDiode)
    498     if (fPulserColor != fPINDiode->GetColor())
    499       {
    500         *fLog << err << GetDescriptor()
    501               << ": Pulser colour has changed w.r.t. last file in MCalibrationChargePINDiode." << endl;
    502         *fLog << err << "This feature is not yet implemented, sorry ... aborting " << endl;
    503         return kFALSE;
    504       }
    505  
    506 
    507   fNumHiGainSamples  =  fCam->GetNumHiGainFADCSlices();
    508   fNumLoGainSamples  =  fCam->GetNumLoGainFADCSlices();
     471  fNumHiGainSamples  =  fSignal->GetNumUsedHiGainFADCSlices();
     472  fNumLoGainSamples  =  fSignal->GetNumUsedLoGainFADCSlices();
    509473
    510474  fSqrtHiGainSamples =  TMath::Sqrt(fNumHiGainSamples);
    … …  
    516480    {
    517481     
    518       MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)  [i];
     482      MCalibrationChargePix &pix = fIntensCam
     483        ? (MCalibrationChargePix&)(*fIntensCam)[i]
     484        : (MCalibrationChargePix&)(*fCam)      [i];
    519485      MCalibrationQEPix     &pqe = (MCalibrationQEPix&)    (*fQECam)[i];
    520486      MBadPixelsPix         &bad = (*fBadPixels)[i];
    … …  
    539505// ----------------------------------------------------------------------------------
    540506// 
    541 // Nothing to be done in Process, but have a look at MHCalibrationChargeCam, instead
     507// Set the correct colour to the charge containers
    542508//
    543509Int_t MCalibrationChargeCalc::Process()
    544510{
     511
     512  const UInt_t pattern = fHeader->GetCalibrationPattern();
     513
     514  if (pattern == fPulserPattern)
     515    return kTRUE;
     516
     517  enum ColorCode_t
     518    {
     519      kSlot1Green     = BIT(0),
     520      kSlot2Green     = BIT(1),
     521      kSlot3Blue      = BIT(2),
     522      kSlot4UV        = BIT(3),
     523      kSlot5UV        = BIT(4),
     524      kSlot6Blue      = BIT(5),
     525      kSlot7Blue      = BIT(6),
     526      kSlot8Blue      = BIT(7),
     527      kSlot9AttBlue   = BIT(8),
     528      kSlot10Blue     = BIT(9),
     529      kSlot11Blue     = BIT(10),
     530      kSlot12UV       = BIT(11),
     531      kSlot13UV       = BIT(12),
     532      kSlot14Blue     = BIT(13),
     533      kSlot15Green    = BIT(14),
     534      kSlot16AttGreen = BIT(15),
     535      kCT1Pulser      = BIT(16),
     536      kAnyGreen       = kSlot1Green  | kSlot2Green | kSlot15Green | kSlot16AttGreen,
     537      kAnyUV          = kSlot4UV     | kSlot5UV    | kSlot12UV    | kSlot13UV,
     538      kAnyBlue        = kSlot3Blue   | kSlot6Blue  | kSlot7Blue   | kSlot8Blue
     539                      | kSlot9AttBlue| kSlot10Blue | kSlot11Blue  | kSlot14Blue
     540    };
     541
     542  //
     543  // The pattern has changed, we have to initialize everything new!!!
     544  //
     545  *fLog << inf << " New pulser pattern: " ;
     546  for (Int_t i=16; i>= 0; i--)
     547    *fLog << (pattern >> i & 1);
     548  *fLog  << endl;
     549  fPulserPattern = pattern;
     550 
     551  //
     552  // Now retrieve the colour and check if not various colours have been used
     553  //
     554  fPulserColor = MCalibrationCam::kNONE;
     555 
     556  if (fPulserPattern & kAnyGreen )
     557    fPulserColor = MCalibrationCam::kGREEN;
     558 
     559  if (fPulserPattern & kAnyBlue )
     560    if (fPulserColor != MCalibrationCam::kNONE)
     561      {
     562        *fLog << err << GetDescriptor()
     563              << "Multiple colours used simultaneously in calibration file. Will skip this part!" << endl;
     564        return kCONTINUE;
     565      }
     566    else
     567      fPulserColor = MCalibrationCam::kBLUE;
     568 
     569  if (fPulserPattern & kAnyUV )
     570    if (fPulserColor != MCalibrationCam::kNONE)
     571      {
     572        *fLog << err << GetDescriptor()
     573              << "Multiple colours used simultaneously in calibration file. Will skip this part!" << endl;
     574        return kCONTINUE;
     575      }
     576    else
     577      fPulserColor = MCalibrationCam::kUV;
     578 
     579  if (fPulserPattern & kCT1Pulser )
     580    if (fPulserColor != MCalibrationCam::kNONE)
     581      {
     582        *fLog << err << GetDescriptor()
     583              << "Multiple colours used simultaneously in calibration file. Will skip this part!" << endl;
     584        return kCONTINUE;
     585      }
     586    else
     587      fPulserColor = MCalibrationCam::kCT1;
     588 
     589  *fLog << inf << GetDescriptor() << ": Found new colour ... " << endl;
     590 
     591  switch (fPulserColor)
     592    {
     593    case MCalibrationCam::kGREEN: *fLog << "Green.";  break;
     594    case MCalibrationCam::kBLUE:  *fLog << "Blue.";   break;
     595    case MCalibrationCam::kUV:    *fLog << "UV.";     break;
     596    case MCalibrationCam::kCT1:   *fLog << "CT1.";    break;
     597    }
     598  *fLog << endl;
     599 
     600  //
     601  // Initialize the pulser colours
     602  //
     603  if (fIntensCam)
     604    fIntensCam->SetPulserColor( fPulserColor );
     605  else
     606    fCam->SetPulserColor( fPulserColor );
     607 
     608  if (fBlindPixel)
     609    fBlindPixel->SetColor( fPulserColor );
     610 
     611  if (fBlindCam)
     612    fBlindCam->SetColor( fPulserColor );
     613 
     614  if (fPINDiode)
     615    fPINDiode->SetColor( fPulserColor );
     616
    545617  return kTRUE;
    546618}
    … …  
    570642// Call  FinalizeUnsuitablePixels()
    571643// 
    572 // Call MParContainer::SetReadyToSave() for fCam, fQECam, fBadPixels and
     644// Call MParContainer::SetReadyToSave() for fIntensCam, fCam, fQECam, fBadPixels and
    573645//                                          fBlindPixel and fPINDiode if they exist
    574646//
    … …  
    608680    {
    609681
    610       MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[pixid];
     682      MCalibrationChargePix &pix = fIntensCam
     683        ? (MCalibrationChargePix&)(*fIntensCam)[pixid]
     684        : (MCalibrationChargePix&)(*fCam)[pixid];
    611685      //
    612686      // Check if the pixel has been excluded from the fits
    … …  
    643717
    644718      const MPedestalPix     &ped = fPedestals->GetAverageArea(aidx);
    645       MCalibrationChargePix &pix = (MCalibrationChargePix&)fCam->GetAverageArea(aidx);
     719      MCalibrationChargePix &pix = fIntensCam
     720        ? (MCalibrationChargePix&)fIntensCam->GetAverageArea(aidx)
     721        : (MCalibrationChargePix&)fCam->GetAverageArea(aidx);
    646722
    647723      FinalizePedestals(ped,pix,aidx);
    648       FinalizeCharges(pix, fCam->GetAverageBadArea(aidx),"area id");
     724      FinalizeCharges(pix,
     725                      fIntensCam ? fIntensCam->GetAverageBadArea(aidx) : fCam->GetAverageBadArea(aidx),
     726                      "area id");
    649727    }
    650728 
    … …  
    656734      const MPedestalPix     &ped = fPedestals->GetAverageSector(sector);
    657735
    658       MCalibrationChargePix &pix = (MCalibrationChargePix&)fCam->GetAverageSector(sector);
     736      MCalibrationChargePix &pix = fIntensCam
     737        ? (MCalibrationChargePix&)fIntensCam->GetAverageSector(sector)
     738        : (MCalibrationChargePix&)fCam->GetAverageSector(sector);
    659739      FinalizePedestals(ped,pix, 0);
    660740    }
    … …  
    673753    {
    674754      *fLog << warn << "Could not calculate the photons flux from the F-Factor method " << endl;
    675       fCam->SetFFactorMethodValid(kFALSE);
     755      if (fIntensCam)
     756        fIntensCam->SetFFactorMethodValid(kFALSE);
     757      else
     758        fCam->SetFFactorMethodValid(kFALSE);
    676759      return kFALSE;
    677760    }
    678761  else
    679     fCam->SetFFactorMethodValid(kTRUE);
     762    if (fIntensCam)
     763      fIntensCam->SetFFactorMethodValid(kTRUE);
     764    else
     765      fCam->SetFFactorMethodValid(kTRUE);
    680766 
    681767  *fLog << endl;
    … …  
    721807  FinalizeUnsuitablePixels();
    722808
    723   fCam      ->SetReadyToSave();
     809  if (fIntensCam)
     810    fIntensCam->SetReadyToSave();
     811  else
     812    fCam      ->SetReadyToSave();
     813
    724814  fQECam    ->SetReadyToSave();
    725815  fBadPixels->SetReadyToSave();
    … …  
    9231013     
    9241014      MBadPixelsPix    &bad    = (*fBadPixels)[i];
    925       MCalibrationPix  &pix    = (*fCam)[i];
     1015      MCalibrationPix  &pix    = fIntensCam ? (*fIntensCam)[i] : (*fCam)[i];
    9261016
    9271017      if (bad.IsUncalibrated( MBadPixelsPix::kChargeIsPedestal))
    … …  
    9901080{
    9911081
    992   const UInt_t npixels  = fGeom->GetNumPixels();
    993   const UInt_t nareas   = fGeom->GetNumAreas();
    994   const UInt_t nsectors = fGeom->GetNumSectors();
     1082  const Int_t npixels  = fGeom->GetNumPixels();
     1083  const Int_t nareas   = fGeom->GetNumAreas();
     1084  const Int_t nsectors = fGeom->GetNumSectors();
    9951085
    9961086  TArrayF lowlim        (nareas);
    … …  
    10101100  MHCamera camphes(*fGeom,"Camphes","Phes in Camera");
    10111101
    1012   for (UInt_t i=0; i<npixels; i++)
    1013     {
    1014      
    1015       MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)  [i];
     1102  for (Int_t i=0; i<npixels; i++)
     1103    {
     1104     
     1105      MCalibrationChargePix &pix = fIntensCam
     1106        ? (MCalibrationChargePix&)(*fIntensCam)[i]
     1107        : (MCalibrationChargePix&)(*fCam)  [i];
    10161108      MBadPixelsPix         &bad = (*fBadPixels)[i];
    10171109     
    … …  
    10391131    }
    10401132
    1041   for (UInt_t i=0; i<nareas; i++)
     1133  for (Int_t i=0; i<nareas; i++)
    10421134    {
    10431135      if (numareavalid[i] == 0)
    … …  
    10711163      upplim  [i] = areaphes[i] + fPheErrLimit*TMath::Sqrt(areavars[i]);
    10721164
    1073       TArrayI area(1);
    1074       area[0] = i;
    1075 
    1076       TH1D *hist = camphes.ProjectionS(TArrayI(),area,"_py",100);
     1165      TH1D *hist = camphes.ProjectionS(TArrayI(),TArrayI(1,&i),"_py",100);
    10771166      hist->Fit("gaus","Q");
    10781167      const Float_t mean  = hist->GetFunction("gaus")->GetParameter(1);
    … …  
    10811170
    10821171      if (IsDebug())
    1083         camphes.DrawClone();
     1172        hist->DrawClone();
    10841173
    10851174      if (ndf < 2)
    … …  
    11261215  //              Set the conversion factor FADC counts to photo-electrons
    11271216  //
    1128   for (UInt_t i=0; i<npixels; i++)
    1129     {
    1130      
    1131       MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
     1217  for (Int_t i=0; i<npixels; i++)
     1218    {
     1219     
     1220      MCalibrationChargePix &pix = fIntensCam
     1221        ? (MCalibrationChargePix&)(*fIntensCam)[i]
     1222        : (MCalibrationChargePix&)(*fCam)[i];
    11321223
    11331224      if (!pix.IsFFactorMethodValid())
    … …  
    11771268  *fLog << endl;
    11781269
    1179   for (UInt_t aidx=0; aidx<nareas; aidx++)
    1180     {
    1181 
    1182       MCalibrationChargePix &apix = (MCalibrationChargePix&)fCam->GetAverageArea(aidx);
     1270  for (Int_t aidx=0; aidx<nareas; aidx++)
     1271    {
     1272
     1273      MCalibrationChargePix &apix = fIntensCam
     1274        ? (MCalibrationChargePix&)fIntensCam->GetAverageArea(aidx)
     1275        : (MCalibrationChargePix&)fCam->GetAverageArea(aidx);
    11831276
    11841277      if (numareavalid[aidx] == 1)
    … …  
    12181311  *fLog << endl;
    12191312
    1220   for (UInt_t sector=0; sector<nsectors; sector++)
     1313  for (Int_t sector=0; sector<nsectors; sector++)
    12211314    {
    12221315
    … …  
    12371330        }
    12381331     
    1239       MCalibrationChargePix &spix = (MCalibrationChargePix&)fCam->GetAverageSector(sector);
     1332      MCalibrationChargePix &spix = fIntensCam
     1333        ? (MCalibrationChargePix&)fIntensCam->GetAverageSector(sector)
     1334        : (MCalibrationChargePix&)fCam->GetAverageSector(sector);
    12401335
    12411336      if (sectorweights[sector] < 0. || sectorphes[sector] <= 0.)
    … …  
    12641359  //             only excluded as: MBadPixelsPix::kChargeSigmaNotValid
    12651360  //
    1266   for (UInt_t i=0; i<npixels; i++)
    1267     {
    1268      
    1269       MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
     1361  for (Int_t i=0; i<npixels; i++)
     1362    {
     1363     
     1364      MCalibrationChargePix &pix = fIntensCam
     1365        ? (MCalibrationChargePix&)(*fIntensCam)[i]
     1366        : (MCalibrationChargePix&)(*fCam)[i];
    12701367      MBadPixelsPix         &bad = (*fBadPixels)[i];
    12711368
    … …  
    12761373        {
    12771374          const Int_t            aidx = (*fGeom)[i].GetAidx();
    1278           MCalibrationChargePix &apix = (MCalibrationChargePix&)fCam->GetAverageArea(aidx);
     1375          MCalibrationChargePix &apix = fIntensCam
     1376            ? (MCalibrationChargePix&)fIntensCam->GetAverageArea(aidx)
     1377            : (MCalibrationChargePix&)fCam->GetAverageArea(aidx);
    12791378          pix.SetPheFFactorMethod   ( apix.GetPheFFactorMethod()    );
    12801379          pix.SetPheFFactorMethodVar( apix.GetPheFFactorMethodVar() );
    … …  
    14171516
    14181517  const Float_t photons = flux * (*fGeom)[0].GetA() / fQECam->GetPlexiglassQE();
    1419   fCam->SetNumPhotonsBlindPixelMethod(photons);
     1518  if (fIntensCam)
     1519    fIntensCam->SetNumPhotonsBlindPixelMethod(photons);
     1520  else
     1521    fCam->SetNumPhotonsBlindPixelMethod(photons);
    14201522 
    14211523  const Float_t photrelvar = fluxvar / flux / flux + fQECam->GetPlexiglassQERelVar();
    14221524  if (photrelvar > 0.)
    1423     fCam->SetNumPhotonsBlindPixelMethodErr(TMath::Sqrt( photrelvar * photons * photons)); 
     1525    if (fIntensCam)
     1526      fIntensCam->SetNumPhotonsBlindPixelMethodErr(TMath::Sqrt( photrelvar * photons * photons)); 
     1527    else
     1528      fCam->SetNumPhotonsBlindPixelMethodErr(TMath::Sqrt( photrelvar * photons * photons)); 
    14241529
    14251530  return kTRUE;
    … …  
    15291634    }
    15301635 
    1531   MCalibrationChargePix &avpix = (MCalibrationChargePix&)fCam->GetAverageArea(0);
     1636  MCalibrationChargePix &avpix = fIntensCam
     1637    ? (MCalibrationChargePix&)fIntensCam->GetAverageArea(0)
     1638    : (MCalibrationChargePix&)fCam->GetAverageArea(0);
    15321639  MCalibrationQEPix     &qepix = (MCalibrationQEPix&)  fQECam->GetAverageArea(0); 
    15331640
    … …  
    15491656  // Set the results in the MCalibrationChargeCam
    15501657  //
    1551   fCam->SetNumPhotonsFFactorMethod   (avphotons);
     1658  if (fIntensCam)
     1659    fIntensCam->SetNumPhotonsFFactorMethod   (avphotons);
     1660  else
     1661    fCam->SetNumPhotonsFFactorMethod   (avphotons);
     1662
    15521663  if (avphotrelvar > 0.)
    1553     fCam->SetNumPhotonsFFactorMethodErr(TMath::Sqrt( avphotrelvar * avphotons * avphotons)); 
     1664    if (fIntensCam)
     1665      fIntensCam->SetNumPhotonsFFactorMethodErr(TMath::Sqrt( avphotrelvar * avphotons * avphotons)); 
     1666    else
     1667      fCam->SetNumPhotonsFFactorMethodErr(TMath::Sqrt( avphotrelvar * avphotons * avphotons)); 
    15541668
    15551669  TArrayF lowlim           (nareas);
    … …  
    15661680    {
    15671681     
    1568       MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
     1682      MCalibrationChargePix &pix = fIntensCam
     1683        ? (MCalibrationChargePix&)(*fIntensCam)[i]
     1684        : (MCalibrationChargePix&)(*fCam)[i];
    15691685      MCalibrationQEPix   &qepix = (MCalibrationQEPix&)  (*fQECam)[i];
    15701686      MBadPixelsPix         &bad =                   (*fBadPixels)[i];
    … …  
    16811797    {
    16821798     
    1683       MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
     1799      MCalibrationChargePix &pix = fIntensCam
     1800        ? (MCalibrationChargePix&)(*fIntensCam)[i]
     1801        : (MCalibrationChargePix&)(*fCam)[i];
    16841802      MBadPixelsPix         &bad =                   (*fBadPixels)[i];
    16851803
    … …  
    17041822    {
    17051823     
    1706       MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
     1824      MCalibrationChargePix &pix = fIntensCam
     1825        ? (MCalibrationChargePix&)(*fIntensCam)[i]
     1826        : (MCalibrationChargePix&)(*fCam)[i];
    17071827      MCalibrationQEPix   &qepix = (MCalibrationQEPix&)  (*fQECam)[i];
    17081828      MBadPixelsPix         &bad =                   (*fBadPixels)[i];
    … …  
    17521872          const Float_t photons = fBlindPixel->GetFluxInsidePlexiglass() * (*fGeom)[0].GetA()
    17531873                               / fQECam->GetPlexiglassQE();
    1754           fCam->SetNumPhotonsBlindPixelMethod(photons);
     1874          if (fIntensCam)
     1875            fCam->SetNumPhotonsBlindPixelMethod(photons);
     1876          else
     1877            fCam->SetNumPhotonsBlindPixelMethod(photons);
    17551878
    17561879          const Float_t photrelvar = fBlindPixel->GetFluxInsidePlexiglassRelVar()
    17571880                                   + fQECam->GetPlexiglassQERelVar();
    17581881          if (photrelvar > 0.)
    1759             fCam->SetNumPhotonsBlindPixelMethodErr(TMath::Sqrt( photrelvar * photons * photons)); 
     1882            if (fIntensCam)
     1883              fIntensCam->SetNumPhotonsBlindPixelMethodErr(TMath::Sqrt( photrelvar * photons * photons)); 
     1884            else
     1885              fCam->SetNumPhotonsBlindPixelMethodErr(TMath::Sqrt( photrelvar * photons * photons)); 
    17601886        }
    17611887    }
    … …  
    17881914        }
    17891915     
    1790       MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
     1916      MCalibrationChargePix &pix = fIntensCam
     1917        ? (MCalibrationChargePix&)(*fIntensCam)[i]
     1918        : (MCalibrationChargePix&)(*fCam)[i];       
    17911919      MGeomPix              &geo =                        (*fGeom)[i];
    17921920     
    … …  
    18611989        }
    18621990     
    1863       MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
     1991      MCalibrationChargePix &pix = fIntensCam
     1992        ?  (MCalibrationChargePix&)(*fIntensCam)[i]     
     1993        :  (MCalibrationChargePix&)(*fCam)[i];
    18641994      MGeomPix              &geo =                        (*fGeom)[i];
    18651995     
    … …  
    19102040//
    19112041// - Print out statistics about BadPixels of type UnsuitableType_t
    1912 // - store numbers of bad pixels of each type in fCam
     2042// - store numbers of bad pixels of each type in fCam or fIntensCam
    19132043//
    19142044void MCalibrationChargeCalc::FinalizeUnsuitablePixels()
    … …  
    19502080
    19512081  for (Int_t aidx=0; aidx<nareas; aidx++)
    1952     fCam->SetNumUnsuitable(counts[aidx], aidx);
     2082    if (fIntensCam)
     2083      fIntensCam->SetNumUnsuitable(counts[aidx], aidx);
     2084    else
     2085      fCam->SetNumUnsuitable(counts[aidx], aidx);
    19532086
    19542087  if (fGeom->InheritsFrom("MGeomCamMagic"))
    … …  
    19692102
    19702103  for (Int_t aidx=0; aidx<nareas; aidx++)
    1971     fCam->SetNumUnreliable(counts[aidx], aidx);
     2104    if (fIntensCam)
     2105      fIntensCam->SetNumUnreliable(counts[aidx], aidx);
     2106    else
     2107      fCam->SetNumUnreliable(counts[aidx], aidx);
    19722108
    19732109  *fLog << " " << setw(7) << "Unreliable Pixels:              "
Note: See TracChangeset for help on using the changeset viewer.