Ignore:
Timestamp:
02/09/04 22:50:52 (21 years ago)
Author:
gaug
Message:
*** empty log message ***
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r3065 r3075  
    184184  fPINDiode->Clear();
    185185
    186   fMeanPhotInsidePlexiglass          = -1.;
    187   fMeanPhotErrInsidePlexiglass       = -1.;
    188   fMeanPhotOutsidePlexiglass         = -1.;
    189   fMeanPhotErrOutsidePlexiglass      = -1.;
     186  fMeanFluxInsidePlexiglass          = -1.;
     187  fMeanFluxErrInsidePlexiglass       = -1.;
     188  fMeanFluxOutsidePlexiglass         = -1.;
     189  fMeanFluxErrOutsidePlexiglass      = -1.;
    190190
    191191  fNumExcludedPixels                 = 0;
    … …  
    193193  CLRBIT(fFlags,kBlindPixelMethodValid);
    194194  CLRBIT(fFlags,kPINDiodeMethodValid);
    195   CLRBIT(fFlags,kNumPhotInsidePlexiglassAvailable);
    196   CLRBIT(fFlags,kNumPhotOutsidePlexiglassAvailable); 
     195  CLRBIT(fFlags,kFluxInsidePlexiglassAvailable);
     196  CLRBIT(fFlags,kFluxOutsidePlexiglassAvailable); 
    197197
    198198  return;
    … …  
    231231
    232232
    233 Bool_t  MCalibrationCam::IsNumPhotInsidePlexiglassAvailable()   const
    234 {
    235   return TESTBIT(fFlags,kNumPhotInsidePlexiglassAvailable);
    236 }
    237 
    238 Bool_t  MCalibrationCam::IsNumPhotOutsidePlexiglassAvailable()   const
    239 {
    240   return TESTBIT(fFlags,kNumPhotOutsidePlexiglassAvailable);
     233Bool_t  MCalibrationCam::IsFluxInsidePlexiglassAvailable()   const
     234{
     235  return TESTBIT(fFlags,kFluxInsidePlexiglassAvailable);
     236}
     237
     238Bool_t  MCalibrationCam::IsFluxOutsidePlexiglassAvailable()   const
     239{
     240  return TESTBIT(fFlags,kFluxOutsidePlexiglassAvailable);
    241241}
    242242
    … …  
    262262    {
    263263     
    264       if (pix->IsChargeValid() && !pix->IsExcluded())
     264      if (pix->IsChargeValid() && !pix->IsExcluded() && !pix->IsOscillating() && pix->IsFitted())
    265265        {
    266266
    … …  
    284284      {
    285285       
    286         if (!pix->IsChargeValid() && !pix->IsExcluded())
     286        if (!pix->IsChargeValid() && !pix->IsExcluded() && !pix->IsFitted())
    287287          {
    288288
    … …  
    294294      }
    295295    *fLog << all << id << " pixels with errors :-((" << endl;
     296
     297  *fLog << all << endl;
     298  *fLog << all << "Pixels with oscillations:" << endl;
     299  *fLog << all << endl;
     300 
     301  id = 0;
     302
     303  TIter Next3(fPixels);
     304  while ((pix=(MCalibrationPix*)Next3()))
     305    {
     306     
     307      if (pix->IsOscillating() && !pix->IsExcluded())
     308        {
     309         
     310          *fLog << all << pix->GetPixId() << " Pedestals: " << pix->GetPed() << " +- "
     311                << pix->GetPedRms() << " Reduced Charge: " << pix->GetCharge() << " +- "
     312                << pix->GetSigmaCharge() << " Reduced Sigma: " << pix->GetRSigmaCharge() << endl;
     313          Float_t area = (*fGeomCam)[pix->GetPixId()].GetA();
     314          *fLog << "Area: " << area << endl;
     315          pix->DrawClone();
     316          id++;
     317        }
     318    }
     319  *fLog << all << id << " Oscillating pixels :-((" << endl;
     320 
    296321   
    297322  *fLog << all << endl;
    … …  
    299324  *fLog << all << endl;
    300325 
    301   TIter Next3(fPixels);
    302     while ((pix=(MCalibrationPix*)Next3()))
    303       if (pix->IsExcluded())
     326  TIter Next4(fPixels);
     327  while ((pix=(MCalibrationPix*)Next4()))
     328    if (pix->IsExcluded())
    304329        *fLog << all << pix->GetPixId() << endl;
    305330
    … …  
    381406    return kFALSE;
    382407
    383   Float_t arearatio = cam.GetPixRatio(idx);
    384 
    385  if (arearatio == 0)
     408  Float_t area = cam[idx].GetA()/100.;
     409
     410 if (area == 0)
    386411    return kFALSE;
    387412
    … …  
    475500      if ((*this)[idx].IsExcluded())
    476501        return kFALSE;
    477       if (arearatio == 1.)
    478         val = GetMeanPhotInsidePlexiglass();
    479       else
    480         val = GetMeanPhotInsidePlexiglass()*gkCalibrationOutervsInnerPixelArea;
     502      val = GetMeanFluxInsidePlexiglass()*area;
    481503      break;
    482504    case 16:
    483505      if ((*this)[idx].IsExcluded())
    484506        return kFALSE;
    485       if (arearatio == 1.)
    486         val = (double)fMeanPhotInsidePlexiglass;
    487       else
    488         val = (double)fMeanPhotInsidePlexiglass*gkCalibrationOutervsInnerPixelArea;
     507      val = GetMeanFluxInsidePlexiglass()*area;
    489508      break;
    490509    case 17:
    491510      if ((*this)[idx].IsExcluded())
    492511        return kFALSE;
    493       if (arearatio == 1.)
    494         val = (*this)[idx].GetMeanConversionBlindPixelMethod();
    495       else
    496         val = (*this)[idx].GetMeanConversionBlindPixelMethod()*gkCalibrationOutervsInnerPixelArea;
     512      val = (*this)[idx].GetMeanConversionBlindPixelMethod();
    497513      break;
    498514    case 18:
    499515      if ((*this)[idx].IsExcluded())
    500516        return kFALSE;
    501       if (arearatio == 1.)
    502         val = (*this)[idx].GetErrorConversionBlindPixelMethod();
    503       else
    504         {
    505         val =  (*this)[idx].GetErrorConversionBlindPixelMethod()*(*this)[idx].GetErrorConversionBlindPixelMethod()
    506                           * gkCalibrationOutervsInnerPixelArea * gkCalibrationOutervsInnerPixelArea;
    507         val +=  gkCalibrationOutervsInnerPixelAreaError * gkCalibrationOutervsInnerPixelAreaError
    508          * (*this)[idx].GetMeanConversionBlindPixelMethod() *(*this)[idx].GetMeanConversionBlindPixelMethod();
    509         val = TMath::Sqrt(val);
    510         }
     517      val = (*this)[idx].GetErrorConversionBlindPixelMethod();
    511518      break;
    512519    case 19:
    … …  
    523530      if ((*this)[idx].IsExcluded())
    524531        return kFALSE;
    525       if (arearatio == 1.)
    526         val = GetMeanPhotOutsidePlexiglass();
    527       else
    528         val = GetMeanPhotOutsidePlexiglass()*gkCalibrationOutervsInnerPixelArea;
     532      val = GetMeanFluxOutsidePlexiglass()*area;
    529533      break;
    530534    case 22:
    531535      if ((*this)[idx].IsExcluded())
    532536        return kFALSE;
    533       if (arearatio == 1.)
    534         val = (double)fMeanPhotOutsidePlexiglass;
    535       else
    536         val = (double)fMeanPhotOutsidePlexiglass*gkCalibrationOutervsInnerPixelArea;
     537      val = GetMeanFluxOutsidePlexiglass()*area;
    537538      break;
    538539    case 23:
    539540      if ((*this)[idx].IsExcluded())
    540541        return kFALSE;
    541       if (arearatio == 1.)
    542         val = (*this)[idx].GetMeanConversionPINDiodeMethod();
    543       else
    544         val = (*this)[idx].GetMeanConversionPINDiodeMethod()*gkCalibrationOutervsInnerPixelArea;
     542      val = (*this)[idx].GetMeanConversionPINDiodeMethod();
    545543      break;
    546544    case 24:
    547545      if ((*this)[idx].IsExcluded())
    548546        return kFALSE;
    549       if (arearatio == 1.)
    550         val = (*this)[idx].GetErrorConversionPINDiodeMethod();
    551       else
    552         {
    553           val =  (*this)[idx].GetErrorConversionPINDiodeMethod()*(*this)[idx].GetErrorConversionPINDiodeMethod()
    554                           * gkCalibrationOutervsInnerPixelArea * gkCalibrationOutervsInnerPixelArea;
    555           val +=  gkCalibrationOutervsInnerPixelAreaError * gkCalibrationOutervsInnerPixelAreaError
    556                * (*this)[idx].GetMeanConversionPINDiodeMethod() *(*this)[idx].GetMeanConversionPINDiodeMethod();
    557           val = TMath::Sqrt(val);
    558         }
     547      val = (*this)[idx].GetErrorConversionPINDiodeMethod();
    559548      break;
    560549    case 25:
    … …  
    694683//
    695684//
    696 Bool_t MCalibrationCam::CalcNumPhotInsidePlexiglass()
     685Bool_t MCalibrationCam::CalcFluxInsidePlexiglass()
    697686{
    698687
    … …  
    707696  //
    708697  // The blind pixel has exactly one cm^2 area (with negligible error),
    709   // thus we omi division by 1.
     698  // thus we omit division by 1.
    710699  //
    711   fMeanPhotInsidePlexiglass    = mean * gkCalibrationInnerPixelArea;
     700  fMeanFluxInsidePlexiglass    = mean;
    712701
    713702  // Start calculation of number of photons relative Variance (!!)
    714   fMeanPhotErrInsidePlexiglass  = merr*merr/mean/mean;
    715   fMeanPhotErrInsidePlexiglass += gkCalibrationInnerPixelAreaError*gkCalibrationInnerPixelAreaError
    716                                 / gkCalibrationInnerPixelArea/gkCalibrationInnerPixelArea;
     703  fMeanFluxErrInsidePlexiglass  = merr*merr/mean/mean;
    717704 
    718705  switch (fColor)
    719706    {
    720707    case kECGreen:
    721       fMeanPhotInsidePlexiglass    /= gkCalibrationBlindPixelQEGreen;   
    722       fMeanPhotErrInsidePlexiglass += gkCalibrationBlindPixelQEGreenError*gkCalibrationBlindPixelQEGreenError
     708      fMeanFluxInsidePlexiglass    /= gkCalibrationBlindPixelQEGreen;   
     709      fMeanFluxErrInsidePlexiglass += gkCalibrationBlindPixelQEGreenError*gkCalibrationBlindPixelQEGreenError
    723710                                    / gkCalibrationBlindPixelQEGreen  /   gkCalibrationBlindPixelQEGreen;   
    724711
    725       fMeanPhotInsidePlexiglass *= TMath::Power(10,gkCalibrationBlindPixelAttGreen); // correct for absorption
     712      fMeanFluxInsidePlexiglass *= TMath::Power(10,gkCalibrationBlindPixelAttGreen); // correct for absorption
    726713      // attenuation has negligible error
    727714      break;
    728715    case kECBlue:
    729       fMeanPhotInsidePlexiglass    /= gkCalibrationBlindPixelQEBlue;   
    730       fMeanPhotErrInsidePlexiglass += gkCalibrationBlindPixelQEBlueError*gkCalibrationBlindPixelQEBlueError
     716      fMeanFluxInsidePlexiglass    /= gkCalibrationBlindPixelQEBlue;   
     717      fMeanFluxErrInsidePlexiglass += gkCalibrationBlindPixelQEBlueError*gkCalibrationBlindPixelQEBlueError
    731718                                    / gkCalibrationBlindPixelQEBlue  /   gkCalibrationBlindPixelQEBlue;   
    732719
    733       fMeanPhotInsidePlexiglass *= TMath::Power(10,gkCalibrationBlindPixelAttBlue); // correct for absorption
     720      fMeanFluxInsidePlexiglass *= TMath::Power(10,gkCalibrationBlindPixelAttBlue); // correct for absorption
    734721      // attenuation has negligible error
    735722      break;
    736723    case kECUV:
    737       fMeanPhotInsidePlexiglass    /= gkCalibrationBlindPixelQEUV;   
    738       fMeanPhotErrInsidePlexiglass += gkCalibrationBlindPixelQEUVError*gkCalibrationBlindPixelQEUVError
     724      fMeanFluxInsidePlexiglass    /= gkCalibrationBlindPixelQEUV;   
     725      fMeanFluxErrInsidePlexiglass += gkCalibrationBlindPixelQEUVError*gkCalibrationBlindPixelQEUVError
    739726                                    / gkCalibrationBlindPixelQEUV  /   gkCalibrationBlindPixelQEUV;   
    740727
    741       fMeanPhotInsidePlexiglass *= TMath::Power(10,gkCalibrationBlindPixelAttUV); // correct for absorption
     728      fMeanFluxInsidePlexiglass *= TMath::Power(10,gkCalibrationBlindPixelAttUV); // correct for absorption
    742729      // attenuation has negligible error
    743730      break;
    744731    case kECCT1:
    745732    default:
    746       fMeanPhotInsidePlexiglass    /= gkCalibrationBlindPixelQECT1;   
    747       fMeanPhotErrInsidePlexiglass += gkCalibrationBlindPixelQECT1Error*gkCalibrationBlindPixelQECT1Error
     733      fMeanFluxInsidePlexiglass    /= gkCalibrationBlindPixelQECT1;   
     734      fMeanFluxErrInsidePlexiglass += gkCalibrationBlindPixelQECT1Error*gkCalibrationBlindPixelQECT1Error
    748735                                    / gkCalibrationBlindPixelQECT1  /   gkCalibrationBlindPixelQECT1;   
    749736
    750       fMeanPhotInsidePlexiglass *= TMath::Power(10,gkCalibrationBlindPixelAttCT1); // correct for absorption
     737      fMeanFluxInsidePlexiglass *= TMath::Power(10,gkCalibrationBlindPixelAttCT1); // correct for absorption
    751738      // attenuation has negligible error
    752739      break;
    … …  
    754741
    755742  *fLog << inf << endl;
    756   *fLog << inf << " Mean number of Photons for an Inner Pixel (inside Plexiglass): "
    757         << fMeanPhotInsidePlexiglass << endl;
    758 
    759   if (fMeanPhotInsidePlexiglass > 0.)
    760     SETBIT(fFlags,kNumPhotInsidePlexiglassAvailable); 
     743  *fLog << inf << " Photon flux [ph/cm^2] inside Plexiglass: "
     744        << fMeanFluxInsidePlexiglass << endl;
     745
     746  if (fMeanFluxInsidePlexiglass > 0.)
     747    SETBIT(fFlags,kFluxInsidePlexiglassAvailable); 
    761748  else
    762749    {
    763       CLRBIT(fFlags,kNumPhotInsidePlexiglassAvailable);       
     750      CLRBIT(fFlags,kFluxInsidePlexiglassAvailable);       
    764751      return kFALSE;
    765752    }
    766753
    767   if (fMeanPhotErrInsidePlexiglass < 0.)
    768     {
    769       *fLog << warn << " Relative Variance on number of Photons for an Inner Pixel (inside Plexiglass): "
    770             << fMeanPhotErrInsidePlexiglass << endl;
    771       CLRBIT(fFlags,kNumPhotInsidePlexiglassAvailable);       
     754  if (fMeanFluxErrInsidePlexiglass < 0.)
     755    {
     756      *fLog << warn << " Relative Variance on Photon flux inside Plexiglass: "
     757            << fMeanFluxErrInsidePlexiglass << endl;
     758      CLRBIT(fFlags,kFluxInsidePlexiglassAvailable);       
    772759      return kFALSE;
    773760    }
    774761
    775762  // Finish calculation of errors -> convert from relative variance to absolute error
    776   fMeanPhotErrInsidePlexiglass = TMath::Sqrt(fMeanPhotErrInsidePlexiglass);
    777   fMeanPhotErrInsidePlexiglass *= fMeanPhotInsidePlexiglass;
    778 
    779   *fLog << inf << " Error on number of Photons for an Inner Pixel (inside Plexiglass): "
    780         << fMeanPhotErrInsidePlexiglass << endl;
     763  fMeanFluxErrInsidePlexiglass = TMath::Sqrt(fMeanFluxErrInsidePlexiglass);
     764  fMeanFluxErrInsidePlexiglass *= fMeanFluxInsidePlexiglass;
     765
     766  *fLog << inf << " Error on photon flux [ph/cm^2] inside Plexiglass: "
     767        << fMeanFluxErrInsidePlexiglass << endl;
    781768  *fLog << inf << endl;
    782 
    783 
    784769
    785770  TIter Next(fPixels);
    … …  
    790775      if(pix->IsChargeValid())
    791776        {
     777         
     778          const Int_t idx = pix->GetPixId();
    792779
    793780          const Float_t charge    = pix->GetCharge();
    794           const Float_t ratio     = fGeomCam->GetPixRatio(pix->GetPixId());
     781          const Float_t area      = (*fGeomCam)[idx].GetA()/100.;
    795782          const Float_t chargeerr = pix->GetErrCharge();         
    796783
    797           Float_t nphot;
    798           Float_t nphoterr;
    799          
    800           if (ratio == 1.)
    801             {
    802               nphot    = fMeanPhotInsidePlexiglass;
    803               nphoterr = fMeanPhotErrInsidePlexiglass;
    804             }
    805           else
    806             {
    807               nphot = fMeanPhotInsidePlexiglass*gkCalibrationOutervsInnerPixelArea;
    808               nphoterr = fMeanPhotErrInsidePlexiglass*gkCalibrationOutervsInnerPixelArea
    809                         *fMeanPhotErrInsidePlexiglass*gkCalibrationOutervsInnerPixelArea;
    810               nphoterr += fMeanPhotInsidePlexiglass*gkCalibrationOutervsInnerPixelAreaError
    811                          *fMeanPhotInsidePlexiglass*gkCalibrationOutervsInnerPixelAreaError;
    812               nphoterr = TMath::Sqrt(nphoterr);
    813             }
    814 
    815          
    816 
    817           const Float_t conversion      = nphot/charge;
     784          const Float_t nphot      = fMeanFluxInsidePlexiglass*area;
     785          const Float_t nphoterr   = fMeanFluxErrInsidePlexiglass*area;
     786          const Float_t conversion = nphot/charge;
    818787          Float_t conversionerr;
    819788         
    … …  
    837806
    838807
    839 Bool_t MCalibrationCam::CalcNumPhotOutsidePlexiglass()
     808Bool_t MCalibrationCam::CalcFluxOutsidePlexiglass()
    840809{
    841810
    … …  
    847816
    848817  // Start calculation of number of photons
    849   fMeanPhotOutsidePlexiglass = mean * gkCalibrationInnerPixelvsPINDiodeArea;
     818  fMeanFluxOutsidePlexiglass = mean * gkCalibrationFluxCameravsPINDiode;
    850819
    851820  // Start calculation of number of photons relative Variance (!!)
    852   fMeanPhotErrOutsidePlexiglass  = merr*merr/mean/mean;
    853   fMeanPhotErrOutsidePlexiglass += gkCalibrationInnerPixelvsPINDiodeAreaError*gkCalibrationInnerPixelvsPINDiodeAreaError
    854                                  / gkCalibrationInnerPixelvsPINDiodeArea/gkCalibrationInnerPixelvsPINDiodeArea;
     821  fMeanFluxErrOutsidePlexiglass  = merr*merr/mean/mean;
     822  fMeanFluxErrOutsidePlexiglass += gkCalibrationFluxCameravsPINDiodeError*gkCalibrationFluxCameravsPINDiodeError
     823                                 / gkCalibrationFluxCameravsPINDiode/gkCalibrationFluxCameravsPINDiode;
    855824 
    856825  switch (fColor)
    857826    {
    858827    case kECGreen:
    859       fMeanPhotOutsidePlexiglass    /= gkCalibrationPINDiodeQEGreen;
    860       fMeanPhotErrOutsidePlexiglass += gkCalibrationPINDiodeQEGreenError*gkCalibrationPINDiodeQEGreenError
     828      fMeanFluxOutsidePlexiglass    /= gkCalibrationPINDiodeQEGreen;
     829      fMeanFluxErrOutsidePlexiglass += gkCalibrationPINDiodeQEGreenError*gkCalibrationPINDiodeQEGreenError
    861830                                     / gkCalibrationPINDiodeQEGreen/gkCalibrationPINDiodeQEGreen;
    862831      break;
    863832    case kECBlue:
    864       fMeanPhotOutsidePlexiglass    /= gkCalibrationPINDiodeQEBlue;
    865       fMeanPhotErrOutsidePlexiglass += gkCalibrationPINDiodeQEBlueError*gkCalibrationPINDiodeQEBlueError
     833      fMeanFluxOutsidePlexiglass    /= gkCalibrationPINDiodeQEBlue;
     834      fMeanFluxErrOutsidePlexiglass += gkCalibrationPINDiodeQEBlueError*gkCalibrationPINDiodeQEBlueError
    866835                                     / gkCalibrationPINDiodeQEBlue/gkCalibrationPINDiodeQEBlue;
    867836      break;
    868837    case kECUV:
    869       fMeanPhotOutsidePlexiglass    /= gkCalibrationPINDiodeQEUV;
    870       fMeanPhotErrOutsidePlexiglass += gkCalibrationPINDiodeQEUVError*gkCalibrationPINDiodeQEUVError
     838      fMeanFluxOutsidePlexiglass    /= gkCalibrationPINDiodeQEUV;
     839      fMeanFluxErrOutsidePlexiglass += gkCalibrationPINDiodeQEUVError*gkCalibrationPINDiodeQEUVError
    871840                                     / gkCalibrationPINDiodeQEUV/gkCalibrationPINDiodeQEUV;
    872841      break;
    873842    case kECCT1:
    874843    default:
    875       fMeanPhotOutsidePlexiglass    /= gkCalibrationPINDiodeQECT1;
    876       fMeanPhotErrOutsidePlexiglass += gkCalibrationPINDiodeQECT1Error*gkCalibrationPINDiodeQECT1Error
     844      fMeanFluxOutsidePlexiglass    /= gkCalibrationPINDiodeQECT1;
     845      fMeanFluxErrOutsidePlexiglass += gkCalibrationPINDiodeQECT1Error*gkCalibrationPINDiodeQECT1Error
    877846                                     / gkCalibrationPINDiodeQECT1/gkCalibrationPINDiodeQECT1;
    878847      break;
    … …  
    881850
    882851  *fLog << inf << endl;
    883   *fLog << inf << " Mean number of Photons for an Inner Pixel (outside Plexiglass): "
    884         << fMeanPhotOutsidePlexiglass << endl;
    885 
    886   if (fMeanPhotOutsidePlexiglass > 0.)
    887     SETBIT(fFlags,kNumPhotOutsidePlexiglassAvailable); 
     852  *fLog << inf << " Mean Photon flux [ph/cm^2] outside Plexiglass: "
     853        << fMeanFluxOutsidePlexiglass << endl;
     854
     855  if (fMeanFluxOutsidePlexiglass > 0.)
     856    SETBIT(fFlags,kFluxOutsidePlexiglassAvailable); 
    888857  else
    889858    {
    890       CLRBIT(fFlags,kNumPhotOutsidePlexiglassAvailable);       
     859      CLRBIT(fFlags,kFluxOutsidePlexiglassAvailable);       
    891860      return kFALSE;
    892861    }
    893862
    894   if (fMeanPhotErrOutsidePlexiglass < 0.)
    895     {
    896       *fLog << warn << "Relative Variance on number of Photons for an Inner Pixel (outside Plexiglass): "
    897             << fMeanPhotErrOutsidePlexiglass << endl;
    898       CLRBIT(fFlags,kNumPhotOutsidePlexiglassAvailable);       
     863  if (fMeanFluxErrOutsidePlexiglass < 0.)
     864    {
     865      *fLog << warn << "Relative Variance on Photon flux outside Plexiglass: "
     866            << fMeanFluxErrOutsidePlexiglass << endl;
     867      CLRBIT(fFlags,kFluxOutsidePlexiglassAvailable);       
    899868      return kFALSE;
    900869    }
    901870
    902871  // Finish calculation of errors -> convert from relative variance to absolute error
    903   fMeanPhotErrOutsidePlexiglass = TMath::Sqrt(fMeanPhotErrOutsidePlexiglass);
    904   fMeanPhotErrOutsidePlexiglass *= fMeanPhotOutsidePlexiglass;
    905 
    906   *fLog << inf << " Error on number of Photons for an Inner Pixel (outside Plexiglass): "
    907         << fMeanPhotErrOutsidePlexiglass << endl;
     872  fMeanFluxErrOutsidePlexiglass = TMath::Sqrt(fMeanFluxErrOutsidePlexiglass);
     873  fMeanFluxErrOutsidePlexiglass *= fMeanFluxOutsidePlexiglass;
     874
     875  *fLog << inf << " Error on Photon flux [ph/cm^2] outside Plexiglass: "
     876        << fMeanFluxErrOutsidePlexiglass << endl;
    908877  *fLog << inf << endl;
    909878
    … …  
    916885        {
    917886
     887          const Int_t idx = pix->GetPixId();
     888
    918889          const Float_t charge    = pix->GetCharge();
    919           const Float_t ratio = fGeomCam->GetPixRatio(pix->GetPixId());
     890          const Float_t area      = (*fGeomCam)[idx].GetA()/100.;
    920891          const Float_t chargeerr = pix->GetErrCharge();         
    921892
    922           Float_t nphot;
    923           Float_t nphoterr;
    924          
    925           if (ratio == 1.)
    926             {
    927               nphot    = fMeanPhotInsidePlexiglass;
    928               nphoterr = fMeanPhotErrInsidePlexiglass;
    929             }
    930           else
    931             {
    932               nphot = fMeanPhotInsidePlexiglass*gkCalibrationOutervsInnerPixelArea;
    933               nphoterr = fMeanPhotErrInsidePlexiglass*gkCalibrationOutervsInnerPixelArea
    934                         *fMeanPhotErrInsidePlexiglass*gkCalibrationOutervsInnerPixelArea;
    935               nphoterr += fMeanPhotInsidePlexiglass*gkCalibrationOutervsInnerPixelAreaError
    936                          *fMeanPhotInsidePlexiglass*gkCalibrationOutervsInnerPixelAreaError;
    937               nphoterr = TMath::Sqrt(nphoterr);
    938             }
    939 
    940           const Float_t conversion      = nphot/charge;
     893          const Float_t nphot      = fMeanFluxOutsidePlexiglass*area;
     894          const Float_t nphoterr   = fMeanFluxErrOutsidePlexiglass*area;
     895          const Float_t conversion = nphot/charge;
     896
    941897          Float_t conversionerr;
    942898         
    … …  
    951907          const Float_t conversionsigma = 0.;
    952908
    953           pix->SetConversionBlindPixelMethod(conversion, conversionerr, conversionsigma);
     909          pix->SetConversionPINDiodeMethod(conversion, conversionerr, conversionsigma);
    954910
    955911          if (conversionerr/conversion < 0.1)
    956             pix->SetBlindPixelMethodValid();
     912            pix->SetPINDiodeMethodValid();
    957913         
    958914        }
    … …  
    969925    return kFALSE;
    970926
    971   if (!IsNumPhotInsidePlexiglassAvailable())
    972     if (!CalcNumPhotInsidePlexiglass())
     927  if (!IsFluxInsidePlexiglassAvailable())
     928    if (!CalcFluxInsidePlexiglass())
    973929      return kFALSE;
    974930
    … …  
    1014970    return kFALSE;
    1015971
    1016   if (!IsNumPhotOutsidePlexiglassAvailable())
    1017     if (!CalcNumPhotOutsidePlexiglass())
     972  if (!IsFluxOutsidePlexiglassAvailable())
     973    if (!CalcFluxOutsidePlexiglass())
    1018974      return kFALSE;
    1019975
Note: See TracChangeset for help on using the changeset viewer.