Index: /trunk/MagicSoft/Mars/Changelog =================================================================== --- /trunk/MagicSoft/Mars/Changelog (revision 4669) +++ /trunk/MagicSoft/Mars/Changelog (revision 4670) @@ -60,4 +60,8 @@ function of MCalibrationCam + * mcalib/MCalibrationChargeCalc.cc + - some changes to the output + - call to MCalibrationChargeBlindCam->IsValid() removed + * mbadpixels/MBadPixelsCam.cc - included kDeviatingNumPhots in GetPixelContent() @@ -68,4 +72,6 @@ - found that the MFillH for the MHCalibrationChargeBlindCam had been replaced to MHCalibrationChargeBlindPix -> redone + - adapted InitBlindPixel() to new classes initializing the right + MCalibrationChargeBlindCam's * mcalib/MCalibrationTestPix.[h,cc] Index: /trunk/MagicSoft/Mars/mcalib/MCalibrationCam.cc =================================================================== --- /trunk/MagicSoft/Mars/mcalib/MCalibrationCam.cc (revision 4669) +++ /trunk/MagicSoft/Mars/mcalib/MCalibrationCam.cc (revision 4670) @@ -147,23 +147,7 @@ { - fPixels->ForEach(TObject, Clear)(); - - // - // another ForEach does not compile, thus have to do the loop ourselves: - // - for (Int_t i=0;iForEach(TObject, Clear)(); } + { fAverageAreas ->ForEach(TObject, Clear)(); } + { fAverageSectors->ForEach(TObject, Clear)(); } return; @@ -366,6 +350,9 @@ } +// -------------------------------------------------------------------------- +// // Returns the current size of the TClonesArray fPixels // independently if the MCalibrationPix is filled with values or not. +// const Int_t MCalibrationCam::GetSize() const { Index: /trunk/MagicSoft/Mars/mcalib/MCalibrationChargeBlindPix.cc =================================================================== --- /trunk/MagicSoft/Mars/mcalib/MCalibrationChargeBlindPix.cc (revision 4669) +++ /trunk/MagicSoft/Mars/mcalib/MCalibrationChargeBlindPix.cc (revision 4670) @@ -33,20 +33,20 @@ // // Currently, the following numbers are implemented: -// - gkBlindPixelArea: 100 mm^2 +// - fArea: 100 mm^2 // - Average QE of Blind Pixel: -// gkBlindPixelQEGreen: 0.154 -// gkBlindPixelQEBlue : 0.226 -// gkBlindPixelQEUV : 0.247 -// gkBlindPixelQECT1 : 0.247 +// fQEGreen: 0.154 +// fQEBlue : 0.226 +// fQEUV : 0.247 +// fQECT1 : 0.247 // - Average QE Error of Blind Pixel: -// gkBlindPixelQEGreenErr: 0.015; -// gkBlindPixelQEBlueErr : 0.02; -// gkBlindPixelQEUVErr : 0.02; -// gkBlindPixelQECT1Err : 0.02; +// fQEGreenErr: 0.015; +// fQEBlueErr : 0.02; +// fQEUVErr : 0.02; +// fQECT1Err : 0.02; // - Attenuation factor Blind Pixel: -// gkBlindPixelAttGreen : 1.97; -// gkBlindPixelAttBlue : 1.96; -// gkBlindPixelAttUV : 1.95; -// gkBlindPixelAttCT1 : 1.95; +// fAttGreen : 1.97; +// fAttBlue : 1.96; +// fAttUV : 1.95; +// fAttCT1 : 1.95; // // @@ -63,27 +63,23 @@ using namespace std; -const Float_t MCalibrationChargeBlindPix::gkBlindPixelArea = 100; -const Float_t MCalibrationChargeBlindPix::gkBlindPixelAttGreen = 1.97; -const Float_t MCalibrationChargeBlindPix::gkBlindPixelAttBlue = 1.96; -const Float_t MCalibrationChargeBlindPix::gkBlindPixelAttUV = 1.95; -const Float_t MCalibrationChargeBlindPix::gkBlindPixelAttCT1 = 1.95; -const Float_t MCalibrationChargeBlindPix::gkBlindPixelQEUnCoatedGreen = 0.154; -const Float_t MCalibrationChargeBlindPix::gkBlindPixelQEUnCoatedBlue = 0.226; -const Float_t MCalibrationChargeBlindPix::gkBlindPixelQEUnCoatedUV = 0.247; -const Float_t MCalibrationChargeBlindPix::gkBlindPixelQEUnCoatedCT1 = 0.247; -const Float_t MCalibrationChargeBlindPix::gkBlindPixelQEUnCoatedGreenErr = 0.005; -const Float_t MCalibrationChargeBlindPix::gkBlindPixelQEUnCoatedBlueErr = 0.007; -const Float_t MCalibrationChargeBlindPix::gkBlindPixelQEUnCoatedUVErr = 0.01; -const Float_t MCalibrationChargeBlindPix::gkBlindPixelQEUnCoatedCT1Err = 0.01; -const Float_t MCalibrationChargeBlindPix::gkBlindPixelQECoatedGreen = 0.192; -const Float_t MCalibrationChargeBlindPix::gkBlindPixelQECoatedBlue = 0.27; -const Float_t MCalibrationChargeBlindPix::gkBlindPixelQECoatedUV = 0.285; -const Float_t MCalibrationChargeBlindPix::gkBlindPixelQECoatedCT1 = 0.285; -const Float_t MCalibrationChargeBlindPix::gkBlindPixelQECoatedGreenErr = 0.007; -const Float_t MCalibrationChargeBlindPix::gkBlindPixelQECoatedBlueErr = 0.01; -const Float_t MCalibrationChargeBlindPix::gkBlindPixelQECoatedUVErr = 0.012; -const Float_t MCalibrationChargeBlindPix::gkBlindPixelQECoatedCT1Err = 0.012; -const Float_t MCalibrationChargeBlindPix::gkBlindPixelCollectionEff = 0.95; -const Float_t MCalibrationChargeBlindPix::gkBlindPixelCollectionEffErr = 0.02; +const Float_t MCalibrationChargeBlindPix::fgArea = 100; +const Float_t MCalibrationChargeBlindPix::fgAttGreen = 1.97; +const Float_t MCalibrationChargeBlindPix::fgAttBlue = 1.96; +const Float_t MCalibrationChargeBlindPix::fgAttUV = 1.95; +const Float_t MCalibrationChargeBlindPix::fgAttCT1 = 1.95; +const Float_t MCalibrationChargeBlindPix::fgAttErr = 0.01; +const Float_t MCalibrationChargeBlindPix::fgQEGreen = 0.154; +const Float_t MCalibrationChargeBlindPix::fgQEBlue = 0.226; +const Float_t MCalibrationChargeBlindPix::fgQEUV = 0.247; +const Float_t MCalibrationChargeBlindPix::fgQECT1 = 0.247; +const Float_t MCalibrationChargeBlindPix::fgQEErrGreen = 0.005; +const Float_t MCalibrationChargeBlindPix::fgQEErrBlue = 0.007; +const Float_t MCalibrationChargeBlindPix::fgQEErrUV = 0.01; +const Float_t MCalibrationChargeBlindPix::fgQEErrCT1 = 0.01; +const Float_t MCalibrationChargeBlindPix::fgCollEffGreen = 0.99; +const Float_t MCalibrationChargeBlindPix::fgCollEffBlue = 0.93; +const Float_t MCalibrationChargeBlindPix::fgCollEffUV = 0.90; +const Float_t MCalibrationChargeBlindPix::fgCollEffCT1 = 0.90; +const Float_t MCalibrationChargeBlindPix::fgCollEffErr = 0.05; // -------------------------------------------------------------------------- // @@ -92,5 +88,8 @@ // Calls: // - Clear() -// - SetCoated() +// +// For backward-compatibility reasons, quantum eff., coll. eff. and att. +// are intialized from the static members. This should, however, be +// overwritten by a class deriving from MCalibrationChargeBlindCam. // MCalibrationChargeBlindPix::MCalibrationChargeBlindPix(const char *name, const char *title) @@ -100,6 +99,45 @@ fTitle = title ? title : "Container of the fit results of the blind pixel"; - SetCoated(); Clear(); + + fArea = fgArea; + + fAtt .Set( MCalibrationCam::gkNumPulserColors ); + fAttErr .Set( MCalibrationCam::gkNumPulserColors ); + fQE .Set( MCalibrationCam::gkNumPulserColors ); + fQEErr .Set( MCalibrationCam::gkNumPulserColors ); + fCollEff .Set( MCalibrationCam::gkNumPulserColors ); + fCollEffErr.Set( MCalibrationCam::gkNumPulserColors ); + + SetAtt ( fgAttGreen, MCalibrationCam::kGREEN ); + SetAtt ( fgAttBlue, MCalibrationCam::kBLUE ); + SetAtt ( fgAttUV , MCalibrationCam::kUV ); + SetAtt ( fgAttCT1 , MCalibrationCam::kCT1 ); + + SetAttErr ( fgAttErr , MCalibrationCam::kGREEN ); + SetAttErr ( fgAttErr , MCalibrationCam::kBLUE ); + SetAttErr ( fgAttErr , MCalibrationCam::kUV ); + SetAttErr ( fgAttErr , MCalibrationCam::kCT1 ); + + SetQE ( fgQEGreen, MCalibrationCam::kGREEN ); + SetQE ( fgQEBlue, MCalibrationCam::kBLUE ); + SetQE ( fgQEUV , MCalibrationCam::kUV ); + SetQE ( fgQECT1 , MCalibrationCam::kCT1 ); + + SetQEErr ( fgQEErrGreen, MCalibrationCam::kGREEN ); + SetQEErr ( fgQEErrBlue, MCalibrationCam::kBLUE ); + SetQEErr ( fgQEErrUV , MCalibrationCam::kUV ); + SetQEErr ( fgQEErrCT1 , MCalibrationCam::kCT1 ); + + SetCollEff ( fgCollEffGreen, MCalibrationCam::kGREEN ); + SetCollEff ( fgCollEffBlue, MCalibrationCam::kBLUE ); + SetCollEff ( fgCollEffUV , MCalibrationCam::kUV ); + SetCollEff ( fgCollEffCT1 , MCalibrationCam::kCT1 ); + + SetCollEffErr ( fgCollEffErr, MCalibrationCam::kGREEN ); + SetCollEffErr ( fgCollEffErr, MCalibrationCam::kBLUE ); + SetCollEffErr ( fgCollEffErr, MCalibrationCam::kUV ); + SetCollEffErr ( fgCollEffErr, MCalibrationCam::kCT1 ); + } @@ -141,5 +179,5 @@ SetColor(MCalibrationCam::kNONE); - MCalibrationChargePix::Clear(); + MCalibrationPix::Clear(); } @@ -149,12 +187,4 @@ } -// -------------------------------------------------------------------------- -// -// Set the Coated Bit from outside -// -void MCalibrationChargeBlindPix::SetCoated( const Bool_t b) -{ - b ? SETBIT(fFlags,kCoated) : CLRBIT(fFlags,kCoated); -} // -------------------------------------------------------------------------- @@ -199,5 +229,5 @@ // Return square root of fFluxInsidePlexiglassVar // -Float_t MCalibrationChargeBlindPix::GetFluxInsidePlexiglassErr() const +const Float_t MCalibrationChargeBlindPix::GetFluxInsidePlexiglassErr() const { if (fFluxInsidePlexiglassVar < 0.) @@ -213,5 +243,5 @@ // Return fFluxInsidePlexiglassVar / fFluxInsidePlexiglass^2 // -Float_t MCalibrationChargeBlindPix::GetFluxInsidePlexiglassRelVar() const +const Float_t MCalibrationChargeBlindPix::GetFluxInsidePlexiglassRelVar() const { if (fFluxInsidePlexiglassVar < 0.) @@ -229,5 +259,5 @@ // Return square root of fLambdaVar // -Float_t MCalibrationChargeBlindPix::GetLambdaErr() const +const Float_t MCalibrationChargeBlindPix::GetLambdaErr() const { if (fLambdaVar < 0.) @@ -243,5 +273,5 @@ // Return fLambdaVar / (fLambda * fLambda ) // -Float_t MCalibrationChargeBlindPix::GetLambdaRelVar() const +const Float_t MCalibrationChargeBlindPix::GetLambdaRelVar() const { if (fLambdaVar < 0.) @@ -256,244 +286,72 @@ // -------------------------------------------------------------------------- // -// Return -1 if gkBlindPixelQEGreenErr is smaller than 0. -// Return -1 if gkBlindPixelQEGreen is 0. -// Return gkBlindPixelQEGreenErr^2 / (gkBlindPixelQEGreen^2 ) -// -const Float_t MCalibrationChargeBlindPix::GetBlindPixelQEGreen() const -{ - - if (IsCoated()) - { - if (gkBlindPixelQECoatedGreen < 0.) - return -1.; - - return gkBlindPixelQECoatedGreen; - } - else - { - if (gkBlindPixelQEUnCoatedGreen < 0.) - return -1.; - - return gkBlindPixelQEUnCoatedGreen; - } - -} - -// -------------------------------------------------------------------------- -// -// Return -1 if gkBlindPixelQEBlueErr is smaller than 0. -// Return -1 if gkBlindPixelQEBlue is 0. -// Return gkBlindPixelQEBlueErr^2 / gkBlindPixelQEBlue^2 -// -const Float_t MCalibrationChargeBlindPix::GetBlindPixelQEBlue() const -{ - if (IsCoated()) - { - if (gkBlindPixelQECoatedBlue < 0.) - return -1.; - - return gkBlindPixelQECoatedBlue; - } - else - { - if (gkBlindPixelQEUnCoatedBlue < 0.) - return -1.; - - return gkBlindPixelQEUnCoatedBlue; - } -} - -// -------------------------------------------------------------------------- -// -// Return -1 if gkBlindPixelQEUVErr is smaller than 0. -// Return -1 if gkBlindPixelQEUV is 0. -// Return gkBlindPixelQEUVErr ^2 / gkBlindPixelQEUV^2 -// -const Float_t MCalibrationChargeBlindPix::GetBlindPixelQEUV() const -{ - - if (IsCoated()) - { - if (gkBlindPixelQECoatedUV < 0.) - return -1.; - - return gkBlindPixelQECoatedUV; - } - else - { - if (gkBlindPixelQEUnCoatedUV < 0.) - return -1.; - - - return gkBlindPixelQEUnCoatedUV; - } -} - -// -------------------------------------------------------------------------- -// -// Return -1 if gkBlindPixelQECT1Err is smaller than 0. -// Return -1 if gkBlindPixelQECT1 is 0. -// Return gkBlindPixelQECT1Err ^2 / gkBlindPixelQECT1^2 -// -const Float_t MCalibrationChargeBlindPix::GetBlindPixelQECT1() const -{ - - if (IsCoated()) - { - if (gkBlindPixelQECoatedCT1 < 0.) - return -1.; - - return gkBlindPixelQECoatedCT1; - } - else - { - if (gkBlindPixelQEUnCoatedCT1 < 0.) - return -1.; - - return gkBlindPixelQEUnCoatedCT1; - } -} - -// -------------------------------------------------------------------------- -// -// Return -1 if gkBlindPixelQEGreenErr is smaller than 0. -// Return -1 if gkBlindPixelQEGreen is 0. -// Return gkBlindPixelQEGreenErr^2 / (gkBlindPixelQEGreen^2 ) -// -const Float_t MCalibrationChargeBlindPix::GetBlindPixelQEGreenRelVar() const -{ - - if (IsCoated()) - { - if (gkBlindPixelQECoatedGreenErr < 0.) - return -1.; - - if (gkBlindPixelQECoatedGreen == 0.) - return -1.; - - return gkBlindPixelQECoatedGreenErr * gkBlindPixelQECoatedGreenErr - / gkBlindPixelQECoatedGreen / gkBlindPixelQECoatedGreen ; - } - else - { - if (gkBlindPixelQEUnCoatedGreenErr < 0.) - return -1.; - - if (gkBlindPixelQEUnCoatedGreen == 0.) - return -1.; - - return gkBlindPixelQEUnCoatedGreenErr * gkBlindPixelQEUnCoatedGreenErr - / gkBlindPixelQEUnCoatedGreen / gkBlindPixelQEUnCoatedGreen ; - } - -} - -// -------------------------------------------------------------------------- -// -// Return -1 if gkBlindPixelQEBlueErr is smaller than 0. -// Return -1 if gkBlindPixelQEBlue is 0. -// Return gkBlindPixelQEBlueErr^2 / gkBlindPixelQEBlue^2 -// -const Float_t MCalibrationChargeBlindPix::GetBlindPixelQEBlueRelVar() const -{ - if (IsCoated()) - { - if (gkBlindPixelQECoatedBlueErr < 0.) - return -1.; - - if (gkBlindPixelQECoatedBlue == 0.) - return -1.; - - return gkBlindPixelQECoatedBlueErr * gkBlindPixelQECoatedBlueErr - / gkBlindPixelQECoatedBlue / gkBlindPixelQECoatedBlue ; - } - else - { - if (gkBlindPixelQEUnCoatedBlueErr < 0.) - return -1.; - - if (gkBlindPixelQEUnCoatedBlue == 0.) - return -1.; - - return gkBlindPixelQEUnCoatedBlueErr * gkBlindPixelQEUnCoatedBlueErr - / gkBlindPixelQEUnCoatedBlue / gkBlindPixelQEUnCoatedBlue ; - } -} - -// -------------------------------------------------------------------------- -// -// Return -1 if gkBlindPixelQEUVErr is smaller than 0. -// Return -1 if gkBlindPixelQEUV is 0. -// Return gkBlindPixelQEUVErr ^2 / gkBlindPixelQEUV^2 -// -const Float_t MCalibrationChargeBlindPix::GetBlindPixelQEUVRelVar() const -{ - - if (IsCoated()) - { - if (gkBlindPixelQECoatedUVErr < 0.) - return -1.; - - if (gkBlindPixelQECoatedUV == 0.) - return -1.; - - return gkBlindPixelQECoatedUVErr * gkBlindPixelQECoatedUVErr - / gkBlindPixelQECoatedUV / gkBlindPixelQECoatedUV ; - } - else - { - if (gkBlindPixelQEUnCoatedUVErr < 0.) - return -1.; - - if (gkBlindPixelQEUnCoatedUV == 0.) - return -1.; - - return gkBlindPixelQEUnCoatedUVErr * gkBlindPixelQEUnCoatedUVErr - / gkBlindPixelQEUnCoatedUV / gkBlindPixelQEUnCoatedUV ; - } -} - -// -------------------------------------------------------------------------- -// -// Return -1 if gkBlindPixelQECT1Err is smaller than 0. -// Return -1 if gkBlindPixelQECT1 is 0. -// Return gkBlindPixelQECT1Err ^2 / gkBlindPixelQECT1^2 -// -const Float_t MCalibrationChargeBlindPix::GetBlindPixelQECT1RelVar() const -{ - - if (IsCoated()) - { - if (gkBlindPixelQECoatedCT1Err < 0.) - return -1.; - - if (gkBlindPixelQECoatedCT1 == 0.) - return -1.; - - return gkBlindPixelQECoatedCT1Err * gkBlindPixelQECoatedCT1Err - / gkBlindPixelQECoatedCT1 / gkBlindPixelQECoatedCT1 ; - } - else - { - if (gkBlindPixelQEUnCoatedCT1Err < 0.) - return -1.; - - if (gkBlindPixelQEUnCoatedCT1 == 0.) - return -1.; - - return gkBlindPixelQEUnCoatedCT1Err * gkBlindPixelQEUnCoatedCT1Err - / gkBlindPixelQEUnCoatedCT1 / gkBlindPixelQEUnCoatedCT1 ; - } -} - -// -------------------------------------------------------------------------- -// -// Return gkBlindPixelCollectionEffErr^2 / (gkBlindPixelCollectionEff^2 ) -// -const Float_t MCalibrationChargeBlindPix::GetBlindPixelCollectionEffRelVar() const -{ - - return gkBlindPixelCollectionEffErr * gkBlindPixelCollectionEffErr - / gkBlindPixelCollectionEff / gkBlindPixelCollectionEff ; +// Return TMath::Power(10,fAtt[fColor]) +// +const Float_t MCalibrationChargeBlindPix::GetAtt() const +{ + return TMath::Power(10,fAtt[fColor]); +} + +// -------------------------------------------------------------------------- +// +// Return -1 if fAttErr[fColor] is smaller than 0. +// Error of TMath::Power(10,fAtt[fColor]) = TMath::Power(10,fAtt[fColor])*ln(10.)*fAttErr[fColor] +// Return fAttErr^2 / (fAtt^2 ) +// +const Float_t MCalibrationChargeBlindPix::GetAttRelVar() const +{ + + const Float_t err = fAttErr[fColor]; + + if (err < 0.) + return -1.; + + return err*err*2.3; +} + +// -------------------------------------------------------------------------- +// +// Return fQE[fColor] +// +const Float_t MCalibrationChargeBlindPix::GetQE() const +{ + return fQE[fColor]; +} + +// -------------------------------------------------------------------------- +// +// Return -1 if fQEErr[fColor] is smaller than 0. +// Return fQEErr^2 / (fQE^2 ) +// +const Float_t MCalibrationChargeBlindPix::GetQERelVar() const +{ + + if (fQEErr[fColor] < 0.) + return -1.; + + return fQEErr[fColor]* fQEErr[fColor] / GetQE() / GetQE(); +} + +// -------------------------------------------------------------------------- +// +// Return fCollEff[fColor] +// +const Float_t MCalibrationChargeBlindPix::GetCollEff() const +{ + return fCollEff[fColor]; +} + +// -------------------------------------------------------------------------- +// +// Return -1 if fCollEffErr[fColor] is smaller than 0. +// Return fCollEffErr^2 / (fCollEff^2 ) +// +const Float_t MCalibrationChargeBlindPix::GetCollEffRelVar() const +{ + + if (fCollEffErr[fColor] < 0.) + return -1.; + + return fCollEffErr[fColor]* fCollEffErr[fColor] / GetCollEff() / GetCollEff(); } @@ -502,5 +360,5 @@ // Test bit kChargeFitValid // -Bool_t MCalibrationChargeBlindPix::IsChargeFitValid() const +const Bool_t MCalibrationChargeBlindPix::IsChargeFitValid() const { return TESTBIT(fFlags,kChargeFitValid); @@ -509,16 +367,7 @@ // -------------------------------------------------------------------------- // -// Test bit kCoated -// -Bool_t MCalibrationChargeBlindPix::IsCoated() const -{ - return TESTBIT(fFlags,kCoated); -} - -// -------------------------------------------------------------------------- -// // Test bit kOscillating // -Bool_t MCalibrationChargeBlindPix::IsOscillating() const +const Bool_t MCalibrationChargeBlindPix::IsOscillating() const { return TESTBIT(fFlags,kOscillating); @@ -529,5 +378,5 @@ // Test bit kPedestalFitValid // -Bool_t MCalibrationChargeBlindPix::IsPedestalFitOK() const +const Bool_t MCalibrationChargeBlindPix::IsPedestalFitOK() const { return TESTBIT(fFlags,kPedestalFitOK); @@ -538,5 +387,5 @@ // Test bit kSinglePheFitValid // -Bool_t MCalibrationChargeBlindPix::IsSinglePheFitOK() const +const Bool_t MCalibrationChargeBlindPix::IsSinglePheFitOK() const { return TESTBIT(fFlags,kSinglePheFitOK); @@ -547,5 +396,5 @@ // Test bit kFluxInsidePlexiglassAvailable // -Bool_t MCalibrationChargeBlindPix::IsFluxInsidePlexiglassAvailable() const +const Bool_t MCalibrationChargeBlindPix::IsFluxInsidePlexiglassAvailable() const { return TESTBIT(fFlags,kFluxInsidePlexiglassAvailable); @@ -559,11 +408,12 @@ // Calculate fFluxInsidePlexiglass with the formula: // - fFluxInsidePlexiglass = fLambda -// / GetBlindPixelCollectionEff() -// / GetBlindPixelQE() -// * 10**gkBlindPixelAtt[color] -// / gkBlindPixelArea +// / GetCollEff() +// / GetQE() +// * GetAtt() +// / fArea // - fFluxInsidePlexiglassVar = sqrt( fLambdaVar / ( fLambda * fLambda ) -// + GetBlindPixelQERelVar() -// + GetBlindPixelCollectionEffRelVar() +// + GetQERelVar() +// + GetCollEffRelVar() +// + GetAttRelVar() // ) * fFluxInsidePlexiglass * * fFluxInsidePlexiglass // @@ -584,39 +434,15 @@ // The blind pixel has exactly 100 mm^2 area (with negligible error), // - switch (fColor) - { - case MCalibrationCam::kGREEN: - fFluxInsidePlexiglass = fLambda / GetBlindPixelQEGreen() * TMath::Power(10,gkBlindPixelAttGreen); - // attenuation has negligible error - fFluxInsidePlexiglassVar = GetLambdaRelVar() + GetBlindPixelQEGreenRelVar(); - break; - case MCalibrationCam::kBLUE: - fFluxInsidePlexiglass = fLambda / GetBlindPixelQEBlue() * TMath::Power(10,gkBlindPixelAttBlue); - // attenuation has negligible error - fFluxInsidePlexiglassVar = GetLambdaRelVar() + GetBlindPixelQEBlueRelVar(); - break; - case MCalibrationCam::kUV: - fFluxInsidePlexiglass = fLambda / GetBlindPixelQEUV() * TMath::Power(10,gkBlindPixelAttUV); - // attenuation has negligible error - fFluxInsidePlexiglassVar = GetLambdaRelVar() + GetBlindPixelQEUVRelVar(); - break; - case MCalibrationCam::kCT1: - default: - fFluxInsidePlexiglass = fLambda / GetBlindPixelQECT1() * TMath::Power(10,gkBlindPixelAttCT1); - // attenuation has negligible error - fFluxInsidePlexiglassVar = GetLambdaRelVar() + GetBlindPixelQECT1RelVar(); - break; - } - - fFluxInsidePlexiglass /= gkBlindPixelArea; - fFluxInsidePlexiglass /= gkBlindPixelCollectionEff; + fFluxInsidePlexiglass = fLambda / GetQE() * GetAtt() / GetCollEff() / fArea; + + if (fFluxInsidePlexiglass < 0.) + return kFALSE; + + fFluxInsidePlexiglassVar = GetLambdaRelVar() + GetQERelVar() + GetAttRelVar() + GetCollEffRelVar(); + // // Finish calculation of errors -> convert from relative variance to absolute variance // - fFluxInsidePlexiglassVar += GetBlindPixelCollectionEffRelVar(); fFluxInsidePlexiglassVar *= fFluxInsidePlexiglass * fFluxInsidePlexiglass; - - if (fFluxInsidePlexiglass < 0.) - return kFALSE; if (fFluxInsidePlexiglassVar < 0.) @@ -633,11 +459,31 @@ } - - - - - - - - - +void MCalibrationChargeBlindPix::Print(Option_t *opt) const +{ + + *fLog << all << GetDescriptor() + << Form("%s%3i","BlindPixel: ",GetPixId()) + << Form("%s%4.2f%s%4.2f"," Lambda: ",GetLambda(),"+-",GetLambdaErr()) + << Form("%s%4.2f%s%4.2f"," Mu0: ",GetMu0(),"+-",GetMu0Err()) + << Form("%s%4.2f%s%4.2f"," Mu1: ",GetMu1(),"+-",GetMu1Err()) + << Form("%s%4.2f%s%4.2f"," Sigma0: ",GetSigma0(),"+-",GetSigma0Err()) + << Form("%s%4.2f%s%4.2f"," Sigma1: ",GetSigma1(),"+-",GetSigma1Err()) + << endl; + *fLog << all + << " Pedestal Fit OK? :" << IsPedestalFitOK() + << Form("%s%4.2f%s%4.2f"," Lambda (Check): " ,GetLambdaCheck(),"+-",GetLambdaCheckErr()) + << endl; + *fLog << all + << " Flux available? :" << IsFluxInsidePlexiglassAvailable() + << Form("%s%4.2f%s%4.2f"," Flux: " ,GetFluxInsidePlexiglass(),"+-",GetFluxInsidePlexiglassErr()) + << endl; +} + + + + + + + + + Index: /trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCalc.cc =================================================================== --- /trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCalc.cc (revision 4669) +++ /trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCalc.cc (revision 4670) @@ -600,12 +600,4 @@ } - if (fBlindCam) - if (!fBlindCam->IsValid()) - { - *fLog << warn << GetDescriptor() - << ": MCalibrationChargeBlindCam is declared not valid... no Blind Pixel method! " << endl; - fBlindCam = NULL; - } - *fLog << endl; // @@ -839,5 +831,5 @@ *fLog << warn << GetDescriptor() << Form(": Fitted Charge: %5.2f is smaller than %2.1f",cal.GetMean(),fChargeLimit) - << Form(" Pedestal RMS: %5.2f in %s%4i",cal.GetPedRms(),what,cal.GetPixId()) << endl; + << Form(" Pedestal RMS: %5.2f in %s%4i",cal.GetPedRms(),what,cal.GetPixId()) << endl; bad.SetUncalibrated( MBadPixelsPix::kChargeIsPedestal); } @@ -1178,5 +1170,6 @@ } - *fLog << inf << "Average total number phes in area idx " << aidx << ": " + *fLog << inf << GetDescriptor() + << "Average total number phes in area idx " << aidx << ": " << Form("%7.2f%s%6.2f",areaphes[aidx]," +- ",TMath::Sqrt(areaweights[aidx])) << endl; @@ -1220,5 +1213,6 @@ } - *fLog << inf << "Average number phes per area in sector " << sector << ": " + *fLog << inf << GetDescriptor() + << "Average number phes per area in sector " << sector << ": " << Form("%5.2f+-%4.2f [phe/mm^2]",sectorphes[sector],TMath::Sqrt(sectorweights[sector])) << endl; @@ -1524,8 +1518,7 @@ } - *fLog << inf << endl; *fLog << inf << GetDescriptor() << ": Mean F-Factor " << "with area index #" << i << ": " - << Form("%4.2f+-%4.2f",mean,sigma) << "fadc/ph" << endl; + << Form("%4.2f+-%4.2f",mean,sigma) << endl; lowlim [i] = 1.1; Index: /trunk/MagicSoft/Mars/mjobs/MJCalibration.cc =================================================================== --- /trunk/MagicSoft/Mars/mjobs/MJCalibration.cc (revision 4669) +++ /trunk/MagicSoft/Mars/mjobs/MJCalibration.cc (revision 4670) @@ -119,5 +119,6 @@ #include "MCalibrationChargeBlindPix.h" #include "MCalibrationChargeBlindCam.h" -#include "MCalibrationChargeBlindPix.h" +#include "MCalibrationChargeBlindCamOneOldStyle.h" +#include "MCalibrationChargeBlindCamTwoNewStyle.h" #include "MCalibrationChargeCalc.h" @@ -1439,5 +1440,8 @@ if (run < gkSecondBlindPixelInstallation) { - blindext.SetModified(kFALSE); + + MCalibrationChargeBlindCamOneOldStyle blindresults; + blindresults.Copy(fCalibrationBlindCam); + blindext.SetExtractionType(MExtractBlindPixel::kIntegral); blindext.SetExtractionType(MExtractBlindPixel::kFilter); @@ -1446,7 +1450,14 @@ blindcam.SetFitFunc( MHCalibrationChargeBlindPix::kEPoisson5 ); } - else - { - blindext.SetModified(kTRUE); + else if (run < gkThirdBlindPixelInstallation) + { + + MCalibrationChargeBlindCamTwoNewStyle blindresults; + blindresults.Copy(fCalibrationBlindCam); + + blindext.SetNumBlindPixels(blindresults.GetNumBlindPixels()); + for (UInt_t i=0;i