Index: trunk/MagicSoft/Mars/Changelog =================================================================== --- trunk/MagicSoft/Mars/Changelog (revision 3074) +++ trunk/MagicSoft/Mars/Changelog (revision 3075) @@ -13,4 +13,9 @@ - fill histograms of single-phe events with higain and logain sampls + + * mcalib/MCalibrationCam.[h,cc] + * mcalib/MCalibrationConfig.h + - take all pixel areas out of MGeomPix::GetA(), remove all previous + areas Index: trunk/MagicSoft/Mars/mcalib/MCalibrationCalc.cc =================================================================== --- trunk/MagicSoft/Mars/mcalib/MCalibrationCalc.cc (revision 3074) +++ trunk/MagicSoft/Mars/mcalib/MCalibrationCalc.cc (revision 3075) @@ -445,5 +445,5 @@ fEvents++; - Float_t referencetime = 0.; + // Float_t referencetime = 0.; // @@ -468,7 +468,7 @@ Float_t abstime = 0.; +#if 0 Float_t reltime = 0.; -#if 0 if (TESTBIT(fFlags,kUseTimes)) { @@ -702,8 +702,10 @@ fCalibrations->SetBlindPixelMethodValid(kFALSE); } - - blindpixel.CheckOscillations(); - - fCalibrations->SetBlindPixelMethodValid(kTRUE); + else + fCalibrations->SetBlindPixelMethodValid(kTRUE); + + if (blindpixel.CheckOscillations()) + fCalibrations->SetBlindPixelMethodValid(kFALSE); + blindpixel.DrawClone(); } @@ -753,6 +755,5 @@ if (TESTBIT(fFlags,kUseBlindPixelFit) && fCalibrations->IsBlindPixelMethodValid()) { - - if (!fCalibrations->CalcNumPhotInsidePlexiglass()) + if (!fCalibrations->CalcFluxInsidePlexiglass()) { *fLog << err @@ -760,5 +761,5 @@ *fLog << err << "You can try to calibrate using the MCalibrationCalc::SkipBlindPixelFit()" << endl; - fCalibrations->SetBlindPixelMethodValid(kFALSE); + fCalibrations->SetBlindPixelMethodValid(kFALSE); } } @@ -769,6 +770,5 @@ if (TESTBIT(fFlags,kUsePinDiodeFit) && fCalibrations->IsPINDiodeMethodValid()) { - - if (!fCalibrations->CalcNumPhotInsidePlexiglass()) + if (!fCalibrations->CalcFluxOutsidePlexiglass()) { *fLog << err Index: trunk/MagicSoft/Mars/mcalib/MCalibrationCam.cc =================================================================== --- trunk/MagicSoft/Mars/mcalib/MCalibrationCam.cc (revision 3074) +++ trunk/MagicSoft/Mars/mcalib/MCalibrationCam.cc (revision 3075) @@ -184,8 +184,8 @@ fPINDiode->Clear(); - fMeanPhotInsidePlexiglass = -1.; - fMeanPhotErrInsidePlexiglass = -1.; - fMeanPhotOutsidePlexiglass = -1.; - fMeanPhotErrOutsidePlexiglass = -1.; + fMeanFluxInsidePlexiglass = -1.; + fMeanFluxErrInsidePlexiglass = -1.; + fMeanFluxOutsidePlexiglass = -1.; + fMeanFluxErrOutsidePlexiglass = -1.; fNumExcludedPixels = 0; @@ -193,6 +193,6 @@ CLRBIT(fFlags,kBlindPixelMethodValid); CLRBIT(fFlags,kPINDiodeMethodValid); - CLRBIT(fFlags,kNumPhotInsidePlexiglassAvailable); - CLRBIT(fFlags,kNumPhotOutsidePlexiglassAvailable); + CLRBIT(fFlags,kFluxInsidePlexiglassAvailable); + CLRBIT(fFlags,kFluxOutsidePlexiglassAvailable); return; @@ -231,12 +231,12 @@ -Bool_t MCalibrationCam::IsNumPhotInsidePlexiglassAvailable() const -{ - return TESTBIT(fFlags,kNumPhotInsidePlexiglassAvailable); -} - -Bool_t MCalibrationCam::IsNumPhotOutsidePlexiglassAvailable() const -{ - return TESTBIT(fFlags,kNumPhotOutsidePlexiglassAvailable); +Bool_t MCalibrationCam::IsFluxInsidePlexiglassAvailable() const +{ + return TESTBIT(fFlags,kFluxInsidePlexiglassAvailable); +} + +Bool_t MCalibrationCam::IsFluxOutsidePlexiglassAvailable() const +{ + return TESTBIT(fFlags,kFluxOutsidePlexiglassAvailable); } @@ -262,5 +262,5 @@ { - if (pix->IsChargeValid() && !pix->IsExcluded()) + if (pix->IsChargeValid() && !pix->IsExcluded() && !pix->IsOscillating() && pix->IsFitted()) { @@ -284,5 +284,5 @@ { - if (!pix->IsChargeValid() && !pix->IsExcluded()) + if (!pix->IsChargeValid() && !pix->IsExcluded() && !pix->IsFitted()) { @@ -294,4 +294,29 @@ } *fLog << all << id << " pixels with errors :-((" << endl; + + *fLog << all << endl; + *fLog << all << "Pixels with oscillations:" << endl; + *fLog << all << endl; + + id = 0; + + TIter Next3(fPixels); + while ((pix=(MCalibrationPix*)Next3())) + { + + if (pix->IsOscillating() && !pix->IsExcluded()) + { + + *fLog << all << pix->GetPixId() << " Pedestals: " << pix->GetPed() << " +- " + << pix->GetPedRms() << " Reduced Charge: " << pix->GetCharge() << " +- " + << pix->GetSigmaCharge() << " Reduced Sigma: " << pix->GetRSigmaCharge() << endl; + Float_t area = (*fGeomCam)[pix->GetPixId()].GetA(); + *fLog << "Area: " << area << endl; + pix->DrawClone(); + id++; + } + } + *fLog << all << id << " Oscillating pixels :-((" << endl; + *fLog << all << endl; @@ -299,7 +324,7 @@ *fLog << all << endl; - TIter Next3(fPixels); - while ((pix=(MCalibrationPix*)Next3())) - if (pix->IsExcluded()) + TIter Next4(fPixels); + while ((pix=(MCalibrationPix*)Next4())) + if (pix->IsExcluded()) *fLog << all << pix->GetPixId() << endl; @@ -381,7 +406,7 @@ return kFALSE; - Float_t arearatio = cam.GetPixRatio(idx); - - if (arearatio == 0) + Float_t area = cam[idx].GetA()/100.; + + if (area == 0) return kFALSE; @@ -475,38 +500,20 @@ if ((*this)[idx].IsExcluded()) return kFALSE; - if (arearatio == 1.) - val = GetMeanPhotInsidePlexiglass(); - else - val = GetMeanPhotInsidePlexiglass()*gkCalibrationOutervsInnerPixelArea; + val = GetMeanFluxInsidePlexiglass()*area; break; case 16: if ((*this)[idx].IsExcluded()) return kFALSE; - if (arearatio == 1.) - val = (double)fMeanPhotInsidePlexiglass; - else - val = (double)fMeanPhotInsidePlexiglass*gkCalibrationOutervsInnerPixelArea; + val = GetMeanFluxInsidePlexiglass()*area; break; case 17: if ((*this)[idx].IsExcluded()) return kFALSE; - if (arearatio == 1.) - val = (*this)[idx].GetMeanConversionBlindPixelMethod(); - else - val = (*this)[idx].GetMeanConversionBlindPixelMethod()*gkCalibrationOutervsInnerPixelArea; + val = (*this)[idx].GetMeanConversionBlindPixelMethod(); break; case 18: if ((*this)[idx].IsExcluded()) return kFALSE; - if (arearatio == 1.) - val = (*this)[idx].GetErrorConversionBlindPixelMethod(); - else - { - val = (*this)[idx].GetErrorConversionBlindPixelMethod()*(*this)[idx].GetErrorConversionBlindPixelMethod() - * gkCalibrationOutervsInnerPixelArea * gkCalibrationOutervsInnerPixelArea; - val += gkCalibrationOutervsInnerPixelAreaError * gkCalibrationOutervsInnerPixelAreaError - * (*this)[idx].GetMeanConversionBlindPixelMethod() *(*this)[idx].GetMeanConversionBlindPixelMethod(); - val = TMath::Sqrt(val); - } + val = (*this)[idx].GetErrorConversionBlindPixelMethod(); break; case 19: @@ -523,38 +530,20 @@ if ((*this)[idx].IsExcluded()) return kFALSE; - if (arearatio == 1.) - val = GetMeanPhotOutsidePlexiglass(); - else - val = GetMeanPhotOutsidePlexiglass()*gkCalibrationOutervsInnerPixelArea; + val = GetMeanFluxOutsidePlexiglass()*area; break; case 22: if ((*this)[idx].IsExcluded()) return kFALSE; - if (arearatio == 1.) - val = (double)fMeanPhotOutsidePlexiglass; - else - val = (double)fMeanPhotOutsidePlexiglass*gkCalibrationOutervsInnerPixelArea; + val = GetMeanFluxOutsidePlexiglass()*area; break; case 23: if ((*this)[idx].IsExcluded()) return kFALSE; - if (arearatio == 1.) - val = (*this)[idx].GetMeanConversionPINDiodeMethod(); - else - val = (*this)[idx].GetMeanConversionPINDiodeMethod()*gkCalibrationOutervsInnerPixelArea; + val = (*this)[idx].GetMeanConversionPINDiodeMethod(); break; case 24: if ((*this)[idx].IsExcluded()) return kFALSE; - if (arearatio == 1.) - val = (*this)[idx].GetErrorConversionPINDiodeMethod(); - else - { - val = (*this)[idx].GetErrorConversionPINDiodeMethod()*(*this)[idx].GetErrorConversionPINDiodeMethod() - * gkCalibrationOutervsInnerPixelArea * gkCalibrationOutervsInnerPixelArea; - val += gkCalibrationOutervsInnerPixelAreaError * gkCalibrationOutervsInnerPixelAreaError - * (*this)[idx].GetMeanConversionPINDiodeMethod() *(*this)[idx].GetMeanConversionPINDiodeMethod(); - val = TMath::Sqrt(val); - } + val = (*this)[idx].GetErrorConversionPINDiodeMethod(); break; case 25: @@ -694,5 +683,5 @@ // // -Bool_t MCalibrationCam::CalcNumPhotInsidePlexiglass() +Bool_t MCalibrationCam::CalcFluxInsidePlexiglass() { @@ -707,46 +696,44 @@ // // The blind pixel has exactly one cm^2 area (with negligible error), - // thus we omi division by 1. + // thus we omit division by 1. // - fMeanPhotInsidePlexiglass = mean * gkCalibrationInnerPixelArea; + fMeanFluxInsidePlexiglass = mean; // Start calculation of number of photons relative Variance (!!) - fMeanPhotErrInsidePlexiglass = merr*merr/mean/mean; - fMeanPhotErrInsidePlexiglass += gkCalibrationInnerPixelAreaError*gkCalibrationInnerPixelAreaError - / gkCalibrationInnerPixelArea/gkCalibrationInnerPixelArea; + fMeanFluxErrInsidePlexiglass = merr*merr/mean/mean; switch (fColor) { case kECGreen: - fMeanPhotInsidePlexiglass /= gkCalibrationBlindPixelQEGreen; - fMeanPhotErrInsidePlexiglass += gkCalibrationBlindPixelQEGreenError*gkCalibrationBlindPixelQEGreenError + fMeanFluxInsidePlexiglass /= gkCalibrationBlindPixelQEGreen; + fMeanFluxErrInsidePlexiglass += gkCalibrationBlindPixelQEGreenError*gkCalibrationBlindPixelQEGreenError / gkCalibrationBlindPixelQEGreen / gkCalibrationBlindPixelQEGreen; - fMeanPhotInsidePlexiglass *= TMath::Power(10,gkCalibrationBlindPixelAttGreen); // correct for absorption + fMeanFluxInsidePlexiglass *= TMath::Power(10,gkCalibrationBlindPixelAttGreen); // correct for absorption // attenuation has negligible error break; case kECBlue: - fMeanPhotInsidePlexiglass /= gkCalibrationBlindPixelQEBlue; - fMeanPhotErrInsidePlexiglass += gkCalibrationBlindPixelQEBlueError*gkCalibrationBlindPixelQEBlueError + fMeanFluxInsidePlexiglass /= gkCalibrationBlindPixelQEBlue; + fMeanFluxErrInsidePlexiglass += gkCalibrationBlindPixelQEBlueError*gkCalibrationBlindPixelQEBlueError / gkCalibrationBlindPixelQEBlue / gkCalibrationBlindPixelQEBlue; - fMeanPhotInsidePlexiglass *= TMath::Power(10,gkCalibrationBlindPixelAttBlue); // correct for absorption + fMeanFluxInsidePlexiglass *= TMath::Power(10,gkCalibrationBlindPixelAttBlue); // correct for absorption // attenuation has negligible error break; case kECUV: - fMeanPhotInsidePlexiglass /= gkCalibrationBlindPixelQEUV; - fMeanPhotErrInsidePlexiglass += gkCalibrationBlindPixelQEUVError*gkCalibrationBlindPixelQEUVError + fMeanFluxInsidePlexiglass /= gkCalibrationBlindPixelQEUV; + fMeanFluxErrInsidePlexiglass += gkCalibrationBlindPixelQEUVError*gkCalibrationBlindPixelQEUVError / gkCalibrationBlindPixelQEUV / gkCalibrationBlindPixelQEUV; - fMeanPhotInsidePlexiglass *= TMath::Power(10,gkCalibrationBlindPixelAttUV); // correct for absorption + fMeanFluxInsidePlexiglass *= TMath::Power(10,gkCalibrationBlindPixelAttUV); // correct for absorption // attenuation has negligible error break; case kECCT1: default: - fMeanPhotInsidePlexiglass /= gkCalibrationBlindPixelQECT1; - fMeanPhotErrInsidePlexiglass += gkCalibrationBlindPixelQECT1Error*gkCalibrationBlindPixelQECT1Error + fMeanFluxInsidePlexiglass /= gkCalibrationBlindPixelQECT1; + fMeanFluxErrInsidePlexiglass += gkCalibrationBlindPixelQECT1Error*gkCalibrationBlindPixelQECT1Error / gkCalibrationBlindPixelQECT1 / gkCalibrationBlindPixelQECT1; - fMeanPhotInsidePlexiglass *= TMath::Power(10,gkCalibrationBlindPixelAttCT1); // correct for absorption + fMeanFluxInsidePlexiglass *= TMath::Power(10,gkCalibrationBlindPixelAttCT1); // correct for absorption // attenuation has negligible error break; @@ -754,32 +741,30 @@ *fLog << inf << endl; - *fLog << inf << " Mean number of Photons for an Inner Pixel (inside Plexiglass): " - << fMeanPhotInsidePlexiglass << endl; - - if (fMeanPhotInsidePlexiglass > 0.) - SETBIT(fFlags,kNumPhotInsidePlexiglassAvailable); + *fLog << inf << " Photon flux [ph/cm^2] inside Plexiglass: " + << fMeanFluxInsidePlexiglass << endl; + + if (fMeanFluxInsidePlexiglass > 0.) + SETBIT(fFlags,kFluxInsidePlexiglassAvailable); else { - CLRBIT(fFlags,kNumPhotInsidePlexiglassAvailable); + CLRBIT(fFlags,kFluxInsidePlexiglassAvailable); return kFALSE; } - if (fMeanPhotErrInsidePlexiglass < 0.) - { - *fLog << warn << " Relative Variance on number of Photons for an Inner Pixel (inside Plexiglass): " - << fMeanPhotErrInsidePlexiglass << endl; - CLRBIT(fFlags,kNumPhotInsidePlexiglassAvailable); + if (fMeanFluxErrInsidePlexiglass < 0.) + { + *fLog << warn << " Relative Variance on Photon flux inside Plexiglass: " + << fMeanFluxErrInsidePlexiglass << endl; + CLRBIT(fFlags,kFluxInsidePlexiglassAvailable); return kFALSE; } // Finish calculation of errors -> convert from relative variance to absolute error - fMeanPhotErrInsidePlexiglass = TMath::Sqrt(fMeanPhotErrInsidePlexiglass); - fMeanPhotErrInsidePlexiglass *= fMeanPhotInsidePlexiglass; - - *fLog << inf << " Error on number of Photons for an Inner Pixel (inside Plexiglass): " - << fMeanPhotErrInsidePlexiglass << endl; + fMeanFluxErrInsidePlexiglass = TMath::Sqrt(fMeanFluxErrInsidePlexiglass); + fMeanFluxErrInsidePlexiglass *= fMeanFluxInsidePlexiglass; + + *fLog << inf << " Error on photon flux [ph/cm^2] inside Plexiglass: " + << fMeanFluxErrInsidePlexiglass << endl; *fLog << inf << endl; - - TIter Next(fPixels); @@ -790,30 +775,14 @@ if(pix->IsChargeValid()) { + + const Int_t idx = pix->GetPixId(); const Float_t charge = pix->GetCharge(); - const Float_t ratio = fGeomCam->GetPixRatio(pix->GetPixId()); + const Float_t area = (*fGeomCam)[idx].GetA()/100.; const Float_t chargeerr = pix->GetErrCharge(); - Float_t nphot; - Float_t nphoterr; - - if (ratio == 1.) - { - nphot = fMeanPhotInsidePlexiglass; - nphoterr = fMeanPhotErrInsidePlexiglass; - } - else - { - nphot = fMeanPhotInsidePlexiglass*gkCalibrationOutervsInnerPixelArea; - nphoterr = fMeanPhotErrInsidePlexiglass*gkCalibrationOutervsInnerPixelArea - *fMeanPhotErrInsidePlexiglass*gkCalibrationOutervsInnerPixelArea; - nphoterr += fMeanPhotInsidePlexiglass*gkCalibrationOutervsInnerPixelAreaError - *fMeanPhotInsidePlexiglass*gkCalibrationOutervsInnerPixelAreaError; - nphoterr = TMath::Sqrt(nphoterr); - } - - - - const Float_t conversion = nphot/charge; + const Float_t nphot = fMeanFluxInsidePlexiglass*area; + const Float_t nphoterr = fMeanFluxErrInsidePlexiglass*area; + const Float_t conversion = nphot/charge; Float_t conversionerr; @@ -837,5 +806,5 @@ -Bool_t MCalibrationCam::CalcNumPhotOutsidePlexiglass() +Bool_t MCalibrationCam::CalcFluxOutsidePlexiglass() { @@ -847,32 +816,32 @@ // Start calculation of number of photons - fMeanPhotOutsidePlexiglass = mean * gkCalibrationInnerPixelvsPINDiodeArea; + fMeanFluxOutsidePlexiglass = mean * gkCalibrationFluxCameravsPINDiode; // Start calculation of number of photons relative Variance (!!) - fMeanPhotErrOutsidePlexiglass = merr*merr/mean/mean; - fMeanPhotErrOutsidePlexiglass += gkCalibrationInnerPixelvsPINDiodeAreaError*gkCalibrationInnerPixelvsPINDiodeAreaError - / gkCalibrationInnerPixelvsPINDiodeArea/gkCalibrationInnerPixelvsPINDiodeArea; + fMeanFluxErrOutsidePlexiglass = merr*merr/mean/mean; + fMeanFluxErrOutsidePlexiglass += gkCalibrationFluxCameravsPINDiodeError*gkCalibrationFluxCameravsPINDiodeError + / gkCalibrationFluxCameravsPINDiode/gkCalibrationFluxCameravsPINDiode; switch (fColor) { case kECGreen: - fMeanPhotOutsidePlexiglass /= gkCalibrationPINDiodeQEGreen; - fMeanPhotErrOutsidePlexiglass += gkCalibrationPINDiodeQEGreenError*gkCalibrationPINDiodeQEGreenError + fMeanFluxOutsidePlexiglass /= gkCalibrationPINDiodeQEGreen; + fMeanFluxErrOutsidePlexiglass += gkCalibrationPINDiodeQEGreenError*gkCalibrationPINDiodeQEGreenError / gkCalibrationPINDiodeQEGreen/gkCalibrationPINDiodeQEGreen; break; case kECBlue: - fMeanPhotOutsidePlexiglass /= gkCalibrationPINDiodeQEBlue; - fMeanPhotErrOutsidePlexiglass += gkCalibrationPINDiodeQEBlueError*gkCalibrationPINDiodeQEBlueError + fMeanFluxOutsidePlexiglass /= gkCalibrationPINDiodeQEBlue; + fMeanFluxErrOutsidePlexiglass += gkCalibrationPINDiodeQEBlueError*gkCalibrationPINDiodeQEBlueError / gkCalibrationPINDiodeQEBlue/gkCalibrationPINDiodeQEBlue; break; case kECUV: - fMeanPhotOutsidePlexiglass /= gkCalibrationPINDiodeQEUV; - fMeanPhotErrOutsidePlexiglass += gkCalibrationPINDiodeQEUVError*gkCalibrationPINDiodeQEUVError + fMeanFluxOutsidePlexiglass /= gkCalibrationPINDiodeQEUV; + fMeanFluxErrOutsidePlexiglass += gkCalibrationPINDiodeQEUVError*gkCalibrationPINDiodeQEUVError / gkCalibrationPINDiodeQEUV/gkCalibrationPINDiodeQEUV; break; case kECCT1: default: - fMeanPhotOutsidePlexiglass /= gkCalibrationPINDiodeQECT1; - fMeanPhotErrOutsidePlexiglass += gkCalibrationPINDiodeQECT1Error*gkCalibrationPINDiodeQECT1Error + fMeanFluxOutsidePlexiglass /= gkCalibrationPINDiodeQECT1; + fMeanFluxErrOutsidePlexiglass += gkCalibrationPINDiodeQECT1Error*gkCalibrationPINDiodeQECT1Error / gkCalibrationPINDiodeQECT1/gkCalibrationPINDiodeQECT1; break; @@ -881,29 +850,29 @@ *fLog << inf << endl; - *fLog << inf << " Mean number of Photons for an Inner Pixel (outside Plexiglass): " - << fMeanPhotOutsidePlexiglass << endl; - - if (fMeanPhotOutsidePlexiglass > 0.) - SETBIT(fFlags,kNumPhotOutsidePlexiglassAvailable); + *fLog << inf << " Mean Photon flux [ph/cm^2] outside Plexiglass: " + << fMeanFluxOutsidePlexiglass << endl; + + if (fMeanFluxOutsidePlexiglass > 0.) + SETBIT(fFlags,kFluxOutsidePlexiglassAvailable); else { - CLRBIT(fFlags,kNumPhotOutsidePlexiglassAvailable); + CLRBIT(fFlags,kFluxOutsidePlexiglassAvailable); return kFALSE; } - if (fMeanPhotErrOutsidePlexiglass < 0.) - { - *fLog << warn << "Relative Variance on number of Photons for an Inner Pixel (outside Plexiglass): " - << fMeanPhotErrOutsidePlexiglass << endl; - CLRBIT(fFlags,kNumPhotOutsidePlexiglassAvailable); + if (fMeanFluxErrOutsidePlexiglass < 0.) + { + *fLog << warn << "Relative Variance on Photon flux outside Plexiglass: " + << fMeanFluxErrOutsidePlexiglass << endl; + CLRBIT(fFlags,kFluxOutsidePlexiglassAvailable); return kFALSE; } // Finish calculation of errors -> convert from relative variance to absolute error - fMeanPhotErrOutsidePlexiglass = TMath::Sqrt(fMeanPhotErrOutsidePlexiglass); - fMeanPhotErrOutsidePlexiglass *= fMeanPhotOutsidePlexiglass; - - *fLog << inf << " Error on number of Photons for an Inner Pixel (outside Plexiglass): " - << fMeanPhotErrOutsidePlexiglass << endl; + fMeanFluxErrOutsidePlexiglass = TMath::Sqrt(fMeanFluxErrOutsidePlexiglass); + fMeanFluxErrOutsidePlexiglass *= fMeanFluxOutsidePlexiglass; + + *fLog << inf << " Error on Photon flux [ph/cm^2] outside Plexiglass: " + << fMeanFluxErrOutsidePlexiglass << endl; *fLog << inf << endl; @@ -916,27 +885,14 @@ { + const Int_t idx = pix->GetPixId(); + const Float_t charge = pix->GetCharge(); - const Float_t ratio = fGeomCam->GetPixRatio(pix->GetPixId()); + const Float_t area = (*fGeomCam)[idx].GetA()/100.; const Float_t chargeerr = pix->GetErrCharge(); - Float_t nphot; - Float_t nphoterr; - - if (ratio == 1.) - { - nphot = fMeanPhotInsidePlexiglass; - nphoterr = fMeanPhotErrInsidePlexiglass; - } - else - { - nphot = fMeanPhotInsidePlexiglass*gkCalibrationOutervsInnerPixelArea; - nphoterr = fMeanPhotErrInsidePlexiglass*gkCalibrationOutervsInnerPixelArea - *fMeanPhotErrInsidePlexiglass*gkCalibrationOutervsInnerPixelArea; - nphoterr += fMeanPhotInsidePlexiglass*gkCalibrationOutervsInnerPixelAreaError - *fMeanPhotInsidePlexiglass*gkCalibrationOutervsInnerPixelAreaError; - nphoterr = TMath::Sqrt(nphoterr); - } - - const Float_t conversion = nphot/charge; + const Float_t nphot = fMeanFluxOutsidePlexiglass*area; + const Float_t nphoterr = fMeanFluxErrOutsidePlexiglass*area; + const Float_t conversion = nphot/charge; + Float_t conversionerr; @@ -951,8 +907,8 @@ const Float_t conversionsigma = 0.; - pix->SetConversionBlindPixelMethod(conversion, conversionerr, conversionsigma); + pix->SetConversionPINDiodeMethod(conversion, conversionerr, conversionsigma); if (conversionerr/conversion < 0.1) - pix->SetBlindPixelMethodValid(); + pix->SetPINDiodeMethodValid(); } @@ -969,6 +925,6 @@ return kFALSE; - if (!IsNumPhotInsidePlexiglassAvailable()) - if (!CalcNumPhotInsidePlexiglass()) + if (!IsFluxInsidePlexiglassAvailable()) + if (!CalcFluxInsidePlexiglass()) return kFALSE; @@ -1014,6 +970,6 @@ return kFALSE; - if (!IsNumPhotOutsidePlexiglassAvailable()) - if (!CalcNumPhotOutsidePlexiglass()) + if (!IsFluxOutsidePlexiglassAvailable()) + if (!CalcFluxOutsidePlexiglass()) return kFALSE; Index: trunk/MagicSoft/Mars/mcalib/MCalibrationCam.h =================================================================== --- trunk/MagicSoft/Mars/mcalib/MCalibrationCam.h (revision 3074) +++ trunk/MagicSoft/Mars/mcalib/MCalibrationCam.h (revision 3075) @@ -37,8 +37,8 @@ TH2D* fOffvsSlope; //! - Float_t fMeanPhotInsidePlexiglass; // The mean number of photons in an INNER PIXEL inside the plexiglass - Float_t fMeanPhotErrInsidePlexiglass; // The uncertainty about the number of photons in an INNER PIXEL - Float_t fMeanPhotOutsidePlexiglass; // The mean number of photons in an INNER PIXEL outside the plexiglass - Float_t fMeanPhotErrOutsidePlexiglass; // The uncertainty about the number of photons in an INNER PIXEL + Float_t fMeanFluxInsidePlexiglass; // The mean number of photons in an INNER PIXEL inside the plexiglass + Float_t fMeanFluxErrInsidePlexiglass; // The uncertainty about the number of photons in an INNER PIXEL + Float_t fMeanFluxOutsidePlexiglass; // The mean number of photons in an INNER PIXEL outside the plexiglass + Float_t fMeanFluxErrOutsidePlexiglass; // The uncertainty about the number of photons in an INNER PIXEL UInt_t fNumExcludedPixels; @@ -47,5 +47,5 @@ enum { kBlindPixelMethodValid, kPINDiodeMethodValid, - kNumPhotInsidePlexiglassAvailable, kNumPhotOutsidePlexiglassAvailable }; + kFluxInsidePlexiglassAvailable, kFluxOutsidePlexiglassAvailable }; public: @@ -83,8 +83,8 @@ MCalibrationPINDiode *GetPINDiode() { return fPINDiode; } - Float_t GetMeanPhotInsidePlexiglass() const { return fMeanPhotInsidePlexiglass; } - Float_t GetMeanPhotErrInsidePlexiglass() const { return fMeanPhotErrInsidePlexiglass; } - Float_t GetMeanPhotOutsidePlexiglass() const { return fMeanPhotOutsidePlexiglass; } - Float_t GetMeanPhotErrOutsidePlexiglass() const { return fMeanPhotErrOutsidePlexiglass; } + Float_t GetMeanFluxInsidePlexiglass() const { return fMeanFluxInsidePlexiglass; } + Float_t GetMeanFluxErrInsidePlexiglass() const { return fMeanFluxErrInsidePlexiglass; } + Float_t GetMeanFluxOutsidePlexiglass() const { return fMeanFluxOutsidePlexiglass; } + Float_t GetMeanFluxErrOutsidePlexiglass() const { return fMeanFluxErrOutsidePlexiglass; } Bool_t GetConversionFactorFFactor(Int_t ipx, Float_t &mean, Float_t &err, Float_t &sigma); @@ -99,6 +99,6 @@ Bool_t IsPINDiodeMethodValid() const; - Bool_t IsNumPhotInsidePlexiglassAvailable() const; - Bool_t IsNumPhotOutsidePlexiglassAvailable() const; + Bool_t IsFluxInsidePlexiglassAvailable() const; + Bool_t IsFluxOutsidePlexiglassAvailable() const; // Others @@ -119,6 +119,6 @@ Bool_t GetPixelContent(Double_t &val, Int_t idx, const MGeomCam &cam, Int_t type=0) const; - Bool_t CalcNumPhotInsidePlexiglass(); - Bool_t CalcNumPhotOutsidePlexiglass(); + Bool_t CalcFluxInsidePlexiglass(); + Bool_t CalcFluxOutsidePlexiglass(); ClassDef(MCalibrationCam, 1) // Container for calibration information of the camera Index: trunk/MagicSoft/Mars/mcalib/MCalibrationConfig.h =================================================================== --- trunk/MagicSoft/Mars/mcalib/MCalibrationConfig.h (revision 3074) +++ trunk/MagicSoft/Mars/mcalib/MCalibrationConfig.h (revision 3075) @@ -36,20 +36,4 @@ const Float_t gkCalibrationBlindPixelAttCT1 = 1.95; -// -// Area of Inner Pixel w.r.t. Blind Pixel (which is 1 sq. cm) -// -// Hexagone of diagonal axis b = 3.5 cm -// straight axis a = 3.0 cm +- 2% -// Area = sqrt(3)*a*a/2 = 7.79 sq.cm +- 4% = 7.8 +- 0.3 sq.cm -// -const Float_t gkCalibrationInnerPixelArea = 7.8; -const Float_t gkCalibrationInnerPixelAreaError = 0.3; -// -// Area of Outer Pixel w.r.t. Inner Pixel -// -// Hexagone of diagonal axis b = 7.0 cm -// straight axis a = 6.0 cm +- 1% -// Area = sqrt(3)*a*a/2 = 31.177 sq.cm +- 2% = 31.2 +- 0.6 sq.cm -// const Float_t gkCalibrationOutervsInnerPixelArea = 4.0; const Float_t gkCalibrationOutervsInnerPixelAreaError = 0.2; @@ -77,6 +61,6 @@ // C = 0.05 +- 0.02 // -const Float_t gkCalibrationInnerPixelvsPINDiodeArea = 0.05; -const Float_t gkCalibrationInnerPixelvsPINDiodeAreaError = 0.02; +const Float_t gkCalibrationFluxCameravsPINDiode = 0.05; +const Float_t gkCalibrationFluxCameravsPINDiodeError = 0.02; // Index: trunk/MagicSoft/Mars/mcalib/MHCalibrationBlindPixel.cc =================================================================== --- trunk/MagicSoft/Mars/mcalib/MHCalibrationBlindPixel.cc (revision 3074) +++ trunk/MagicSoft/Mars/mcalib/MHCalibrationBlindPixel.cc (revision 3075) @@ -289,5 +289,5 @@ fPSDExpFit->SetParNames("Area","slope"); fPSDExpFit->SetParLimits(0,0.,3.*area_guess); - fPSDExpFit->SetParLimits(1,5.,20.); + fPSDExpFit->SetParLimits(1,0.,20.); fPSDExpFit->SetRange(fMinFreq,fNyquistFreq); Index: trunk/MagicSoft/Mars/mcalib/MHCalibrationPixel.cc =================================================================== --- trunk/MagicSoft/Mars/mcalib/MHCalibrationPixel.cc (revision 3074) +++ trunk/MagicSoft/Mars/mcalib/MHCalibrationPixel.cc (revision 3075) @@ -61,7 +61,6 @@ const Int_t MHCalibrationPixel::fNDFLimit = 5; -const Axis_t MHCalibrationPixel::fMaxFreq = 30.5; const Axis_t MHCalibrationPixel::fMinFreq = 0.; -const Int_t MHCalibrationPixel::fPSDNbins = 30; +const Int_t MHCalibrationPixel::fPSDNbins = 50; // -------------------------------------------------------------------------- @@ -260,9 +259,8 @@ // - // This cuts only the non-used zero's, but MFFT will cut the rest + // This cuts only the non-used zero's, but MFFT will later cut the rest CutArrayBorder(fHiGains); CutArrayBorder(fLoGains); - MFFT fourier; @@ -272,10 +270,13 @@ Int_t entries; TArrayF *array; - + + const Double_t max_freq = (fChargeSigma > 0.) ? fChargeSigma*0.2 : 2.; + const Double_t min_freq = 0.; + if (IsUseLoGain()) { fHPSD = new TH1F(Form("%s%d","HPSD",fPixId), Form("%s%s","Power Spectrum Density Projection ","LoGain"), - fPSDNbins,fMinFreq,fMaxFreq); + fPSDNbins,min_freq,max_freq); array = fPSDLoGain; @@ -286,5 +287,5 @@ fHPSD = new TH1F(Form("%s%d","HPSD",fPixId), Form("%s%s","Power Spectrum Density Projection ","HiGain"), - fPSDNbins,fMinFreq,fMaxFreq); + fPSDNbins,min_freq,max_freq); array = fPSDHiGain; @@ -305,7 +306,7 @@ fPSDExpFit->SetParameters(area_guess,10.); fPSDExpFit->SetParNames("Area","slope"); - fPSDExpFit->SetParLimits(0,0.,3.*area_guess); - fPSDExpFit->SetParLimits(1,0.,20.); - fPSDExpFit->SetRange(fMinFreq,fMaxFreq); + fPSDExpFit->SetParLimits(0,0.,20.*area_guess); + fPSDExpFit->SetParLimits(1,0.,30.); + fPSDExpFit->SetRange(min_freq,max_freq); fHPSD->Fit(fPSDExpFit,"RQL0"); @@ -351,7 +352,8 @@ const Int_t diff = fChargeXaxis->GetSize()-n; + fChargeXaxis->Set(n); if (diff < 0) - for (Int_t i=n;in-diff-1;i--) fChargeXaxis->AddAt((Float_t)i,i); } @@ -582,4 +584,5 @@ TCanvas *c = MH::MakeDefCanvas(this,600,900); + c->SetBit(kCanDelete); c->Divide(2,5); @@ -714,4 +717,5 @@ gStyle->SetOptStat(111111); + gStyle->SetOptFit(); gPad->SetTicks(); @@ -729,4 +733,6 @@ c->Modified(); c->Update(); + + c->Iconify(); return; Index: trunk/MagicSoft/Mars/mcalib/MHCalibrationPixel.h =================================================================== --- trunk/MagicSoft/Mars/mcalib/MHCalibrationPixel.h (revision 3074) +++ trunk/MagicSoft/Mars/mcalib/MHCalibrationPixel.h (revision 3075) @@ -26,5 +26,4 @@ static const Int_t fNDFLimit; - static const Axis_t fMaxFreq; static const Axis_t fMinFreq; static const Int_t fPSDNbins;