Changeset 3672 for trunk/MagicSoft
- Timestamp:
- 04/06/04 17:25:58 (20 years ago)
- Location:
- trunk/MagicSoft/Mars
- Files:
-
- 10 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/MagicSoft/Mars/Changelog
r3671 r3672 154 154 - updated and enlarged documentation 155 155 156 * mcalib/MCalibrationPix.[h,cc]157 156 * mcalib/MHCalibrationChargePINDiode.cc 158 157 * mcalib/MHCalibrationChargeCam.[h,cc] 159 158 - rename Setter for fMeanVar from SetMeanErr() to SetMeanVar() 160 159 - rename arrays of fAverageSigmaErr to AverageSigmaVar 160 161 * mcalib/MCalibrationPix.[h,cc] 162 * mcalib/MCalibrationChargePix.[h,cc] 163 * mcalib/MCalibrationChargeBlindPix.[h,cc] 164 * mcalib/MCalibrationChargePINDiode.[h,cc] 161 165 - add Getters to the relative variance 162 166 -
trunk/MagicSoft/Mars/mcalib/MCalibrationChargeBlindPix.cc
r3662 r3672 197 197 // -------------------------------------------------------------------------- 198 198 // 199 // Return -1 if fLambdaVar is smaller than 0. 200 // Return -1 if fLambda is 0. 201 // Return fLambdaVar / (fLambda * fLambda ) 202 // 203 Float_t MCalibrationChargeBlindPix::GetLambdaRelVar() const 204 { 205 if (fLambdaVar < 0.) 206 return -1.; 207 208 if (fLambda == 0.) 209 return -1.; 210 211 return fLambdaVar / fLambda / fLambda ; 212 } 213 214 // -------------------------------------------------------------------------- 215 // 216 // Return -1 if gkBlindPixelQEGreenErr is smaller than 0. 217 // Return -1 if gkBlindPixelQEGreen is 0. 218 // Return gkBlindPixelQEGreenErr^2 / (gkBlindPixelQEGreen^2 ) 219 // 220 const Float_t MCalibrationChargeBlindPix::GetBlindPixelQEGreenRelVar() const 221 { 222 if (gkBlindPixelQEGreenErr < 0.) 223 return -1.; 224 225 if (gkBlindPixelQEGreen == 0.) 226 return -1.; 227 228 return gkBlindPixelQEGreenErr * gkBlindPixelQEGreenErr / gkBlindPixelQEGreen / gkBlindPixelQEGreen ; 229 } 230 231 // -------------------------------------------------------------------------- 232 // 233 // Return -1 if gkBlindPixelQEBlueErr is smaller than 0. 234 // Return -1 if gkBlindPixelQEBlue is 0. 235 // Return gkBlindPixelQEBlueErr^2 / gkBlindPixelQEBlue^2 236 // 237 const Float_t MCalibrationChargeBlindPix::GetBlindPixelQEBlueRelVar() const 238 { 239 if (gkBlindPixelQEBlueErr < 0.) 240 return -1.; 241 242 if (gkBlindPixelQEBlue == 0.) 243 return -1.; 244 245 return gkBlindPixelQEBlueErr * gkBlindPixelQEBlueErr / gkBlindPixelQEBlue / gkBlindPixelQEBlue ; 246 } 247 248 // -------------------------------------------------------------------------- 249 // 250 // Return -1 if gkBlindPixelQEUVErr is smaller than 0. 251 // Return -1 if gkBlindPixelQEUV is 0. 252 // Return gkBlindPixelQEUVErr ^2 / gkBlindPixelQEUV^2 253 // 254 const Float_t MCalibrationChargeBlindPix::GetBlindPixelQEUVRelVar() const 255 { 256 if (gkBlindPixelQEUVErr < 0.) 257 return -1.; 258 259 if (gkBlindPixelQEUV == 0.) 260 return -1.; 261 262 return gkBlindPixelQEUVErr * gkBlindPixelQEUVErr / gkBlindPixelQEUV / gkBlindPixelQEUV ; 263 } 264 265 // -------------------------------------------------------------------------- 266 // 267 // Return -1 if gkBlindPixelQECT1Err is smaller than 0. 268 // Return -1 if gkBlindPixelQECT1 is 0. 269 // Return gkBlindPixelQECT1Err ^2 / gkBlindPixelQECT1^2 270 // 271 const Float_t MCalibrationChargeBlindPix::GetBlindPixelQECT1RelVar() const 272 { 273 if (gkBlindPixelQECT1Err < 0.) 274 return -1.; 275 276 if (gkBlindPixelQECT1 == 0.) 277 return -1.; 278 279 return gkBlindPixelQECT1Err * gkBlindPixelQECT1Err / gkBlindPixelQECT1 / gkBlindPixelQECT1 ; 280 } 281 282 283 // -------------------------------------------------------------------------- 284 // 199 285 // Test bit kChargeFitValid 200 286 // … … 267 353 // The blind pixel has exactly 100 mm^2 area (with negligible error), 268 354 // 269 fFluxInsidePlexiglass = fLambda*gkBlindPixelArea;270 271 //272 // Start calculation of number of photons relative Variance273 //274 const Float_t lambdaRelVar = fLambdaVar / ( fLambda * fLambda );275 fFluxInsidePlexiglassVar = lambdaRelVar;276 277 355 switch (fColor) 278 356 { 279 357 case kGREEN: 280 fFluxInsidePlexiglass /= gkBlindPixelQEGreen; 281 fFluxInsidePlexiglassVar += gkBlindPixelQEGreenErr * gkBlindPixelQEGreenErr 282 / ( gkBlindPixelQEGreen * gkBlindPixelQEGreen ); 283 284 fFluxInsidePlexiglass *= TMath::Power(10,gkBlindPixelAttGreen); // correct for absorption 358 fFluxInsidePlexiglass = fLambda * gkBlindPixelQEGreen * TMath::Power(10,gkBlindPixelAttGreen); 285 359 // attenuation has negligible error 360 fFluxInsidePlexiglassVar = GetLambdaRelVar() + GetBlindPixelQEGreenRelVar(); 286 361 break; 287 362 case kBLUE: 288 fFluxInsidePlexiglass /= gkBlindPixelQEBlue; 289 fFluxInsidePlexiglassVar += gkBlindPixelQEBlueErr * gkBlindPixelQEBlueErr 290 / ( gkBlindPixelQEBlue * gkBlindPixelQEBlue ); 291 292 fFluxInsidePlexiglass *= TMath::Power(10,gkBlindPixelAttBlue); // correct for absorption 363 fFluxInsidePlexiglass = fLambda * gkBlindPixelQEBlue * TMath::Power(10,gkBlindPixelAttBlue); 293 364 // attenuation has negligible error 365 fFluxInsidePlexiglassVar = GetLambdaRelVar() + GetBlindPixelQEBlueRelVar(); 294 366 break; 295 367 case kUV: 296 fFluxInsidePlexiglass /= gkBlindPixelQEUV; 297 fFluxInsidePlexiglassVar += gkBlindPixelQEUVErr* gkBlindPixelQEUVErr 298 / ( gkBlindPixelQEUV * gkBlindPixelQEUV ); 299 300 fFluxInsidePlexiglass *= TMath::Power(10,gkBlindPixelAttUV); // correct for absorption 368 fFluxInsidePlexiglass = fLambda * gkBlindPixelQEUV * TMath::Power(10,gkBlindPixelAttUV); 301 369 // attenuation has negligible error 370 fFluxInsidePlexiglassVar = GetLambdaRelVar() + GetBlindPixelQEUVRelVar(); 302 371 break; 303 372 case kCT1: 304 373 default: 305 fFluxInsidePlexiglass /= gkBlindPixelQECT1; 306 fFluxInsidePlexiglassVar += gkBlindPixelQECT1Err * gkBlindPixelQECT1Err 307 / ( gkBlindPixelQECT1 * gkBlindPixelQECT1 ); 308 309 fFluxInsidePlexiglass *= TMath::Power(10,gkBlindPixelAttCT1); // correct for absorption 374 fFluxInsidePlexiglass = fLambda * gkBlindPixelQECT1 * TMath::Power(10,gkBlindPixelAttCT1); 310 375 // attenuation has negligible error 376 fFluxInsidePlexiglassVar = GetLambdaRelVar() + GetBlindPixelQECT1RelVar(); 311 377 break; 312 378 } 313 314 *fLog << inf << endl;315 *fLog << inf << " Photon flux [ph/mm^2] inside Plexiglass: "316 << fFluxInsidePlexiglass << endl;317 318 if (fFluxInsidePlexiglass < 0.)319 return kFALSE;320 321 if (fFluxInsidePlexiglassVar < 0.)322 return kFALSE;323 324 SetFluxInsidePlexiglassAvailable(kTRUE);325 379 326 380 // … … 329 383 fFluxInsidePlexiglassVar *= fFluxInsidePlexiglass * fFluxInsidePlexiglass; 330 384 331 *fLog << inf << " Error on photon flux [ph/mm^2] inside Plexiglass: " 332 << GetFluxInsidePlexiglass() << endl; 385 if (fFluxInsidePlexiglass < 0.) 386 return kFALSE; 387 388 if (fFluxInsidePlexiglassVar < 0.) 389 return kFALSE; 390 391 SetFluxInsidePlexiglassAvailable(kTRUE); 392 333 393 *fLog << inf << endl; 394 *fLog << inf << " Photon flux [ph/mm^2] inside Plexiglass: " 395 << Form("%5.3f%s%5.3f",fFluxInsidePlexiglass," +- ",GetFluxInsidePlexiglassErr()) << endl; 334 396 335 397 return kTRUE; -
trunk/MagicSoft/Mars/mcalib/MCalibrationChargeBlindPix.h
r3662 r3672 44 44 PulserColor_t fColor; 45 45 46 public: 46 const Float_t GetBlindPixelQEGreenRelVar() const; 47 const Float_t GetBlindPixelQEBlueRelVar () const; 48 const Float_t GetBlindPixelQEUVRelVar () const; 49 const Float_t GetBlindPixelQECT1RelVar () const; 50 51 public: 47 52 48 53 MCalibrationChargeBlindPix(const char *name=NULL, const char *title=NULL); … … 52 57 53 58 // Setters 54 void SetColor ( const PulserColor_t color ) { fColor = color; }55 void SetLambda ( const Float_t f ) { fLambda = f;}56 void SetLambda Err ( const Float_t f ) { fLambdaVar = f*f;}57 void SetLambdaCheck ( const Float_t f ) { fLambdaCheck = f;}58 void SetLambdaCheckErr ( const Float_t f ) { fLambdaCheckErr = f;}59 void SetMu0 ( const Float_t f ) { fMu0 = f;}60 void SetMu0Err ( const Float_t f ) { fMu0Err = f;}61 void SetMu1 ( const Float_t f ) { fMu1 = f;}62 void SetMu1Err ( const Float_t f ) { fMu1Err = f;}63 void SetSigma0 ( const Float_t f ) { fSigma0 = f;}64 void SetSigma0Err ( const Float_t f ) { fSigma0Err = f;}65 void SetSigma1 ( const Float_t f ) { fSigma1 = f;}66 void SetSigma1Err ( const Float_t f ) { fSigma1Err = f;}59 void SetColor ( const PulserColor_t color ) { fColor = color; } 60 void SetLambda ( const Float_t f ) { fLambda = f; } 61 void SetLambdaVar ( const Float_t f ) { fLambdaVar = f; } 62 void SetLambdaCheck ( const Float_t f ) { fLambdaCheck = f; } 63 void SetLambdaCheckErr ( const Float_t f ) { fLambdaCheckErr = f; } 64 void SetMu0 ( const Float_t f ) { fMu0 = f; } 65 void SetMu0Err ( const Float_t f ) { fMu0Err = f; } 66 void SetMu1 ( const Float_t f ) { fMu1 = f; } 67 void SetMu1Err ( const Float_t f ) { fMu1Err = f; } 68 void SetSigma0 ( const Float_t f ) { fSigma0 = f; } 69 void SetSigma0Err ( const Float_t f ) { fSigma0Err = f; } 70 void SetSigma1 ( const Float_t f ) { fSigma1 = f; } 71 void SetSigma1Err ( const Float_t f ) { fSigma1Err = f; } 67 72 68 73 void SetOscillating ( const Bool_t b=kTRUE); … … 75 80 Float_t GetLambda() const { return fLambda; } 76 81 Float_t GetLambdaErr() const; 82 Float_t GetLambdaRelVar() const; 77 83 Float_t GetLambdaCheck() const { return fLambdaCheck; } 78 84 Float_t GetLambdaCheckErr() const { return fLambdaCheckErr; } -
trunk/MagicSoft/Mars/mcalib/MCalibrationChargePINDiode.cc
r3662 r3672 193 193 } 194 194 195 // -------------------------------------------------------------------------- 196 // 197 // Return -1 if fNumPhotonsVar is smaller than 0. 198 // Return square root of fNumPhotonsVar 199 // 200 Float_t MCalibrationChargePINDiode::GetNumPhotonsErr() const 201 { 202 if (fNumPhotonsVar < 0.) 203 return -1.; 204 205 return TMath::Sqrt(fNumPhotonsVar); 206 } 207 208 // -------------------------------------------------------------------------- 209 // 210 // Return -1 if fNumPhotonsVar is smaller than 0. 211 // Return -1 if fNumPhotons is 0. 212 // Return fNumPhotonsVar / (fNumPhotons^2 ) 213 // 214 Float_t MCalibrationChargePINDiode::GetNumPhotonsRelVar() const 215 { 216 if (fNumPhotonsVar < 0.) 217 return -1.; 218 219 if (fNumPhotons == 0.) 220 return -1.; 221 222 return fNumPhotonsVar / fNumPhotons / fNumPhotons ; 223 } 224 225 226 // -------------------------------------------------------------------------- 227 // 228 // Return -1 if gkPINDiodeQEGreenErr is smaller than 0. 229 // Return -1 if gkPINDiodeQEGreen is 0. 230 // Return gkPINDiodeQEGreenErr^2 / (gkPINDiodeQEGreen^2 ) 231 // 232 const Float_t MCalibrationChargePINDiode::GetPINDiodeQEGreenRelVar() const 233 { 234 if (gkPINDiodeQEGreenErr < 0.) 235 return -1.; 236 237 if (gkPINDiodeQEGreen == 0.) 238 return -1.; 239 240 return gkPINDiodeQEGreenErr * gkPINDiodeQEGreenErr / gkPINDiodeQEGreen / gkPINDiodeQEGreen ; 241 } 242 243 // -------------------------------------------------------------------------- 244 // 245 // Return -1 if gkPINDiodeQEBlueErr is smaller than 0. 246 // Return -1 if gkPINDiodeQEBlue is 0. 247 // Return gkPINDiodeQEBlueErr^2 / gkPINDiodeQEBlue^2 248 // 249 const Float_t MCalibrationChargePINDiode::GetPINDiodeQEBlueRelVar() const 250 { 251 if (gkPINDiodeQEBlueErr < 0.) 252 return -1.; 253 254 if (gkPINDiodeQEBlue == 0.) 255 return -1.; 256 257 return gkPINDiodeQEBlueErr * gkPINDiodeQEBlueErr / gkPINDiodeQEBlue / gkPINDiodeQEBlue ; 258 } 259 260 // -------------------------------------------------------------------------- 261 // 262 // Return -1 if gkPINDiodeQEUVErr is smaller than 0. 263 // Return -1 if gkPINDiodeQEUV is 0. 264 // Return gkPINDiodeQEUVErr ^2 / gkPINDiodeQEUV^2 265 // 266 const Float_t MCalibrationChargePINDiode::GetPINDiodeQEUVRelVar() const 267 { 268 if (gkPINDiodeQEUVErr < 0.) 269 return -1.; 270 271 if (gkPINDiodeQEUV == 0.) 272 return -1.; 273 274 return gkPINDiodeQEUVErr * gkPINDiodeQEUVErr / gkPINDiodeQEUV / gkPINDiodeQEUV ; 275 } 276 277 // -------------------------------------------------------------------------- 278 // 279 // Return -1 if gkPINDiodeQECT1Err is smaller than 0. 280 // Return -1 if gkPINDiodeQECT1 is 0. 281 // Return gkPINDiodeQECT1Err ^2 / gkPINDiodeQECT1^2 282 // 283 const Float_t MCalibrationChargePINDiode::GetPINDiodeQECT1RelVar() const 284 { 285 if (gkPINDiodeQECT1Err < 0.) 286 return -1.; 287 288 if (gkPINDiodeQECT1 == 0.) 289 return -1.; 290 291 return gkPINDiodeQECT1Err * gkPINDiodeQECT1Err / gkPINDiodeQECT1 / gkPINDiodeQECT1 ; 292 } 293 294 // -------------------------------------------------------------------------- 295 // 296 // Return -1 if gkSolidAngleRatioErr is smaller than 0. 297 // Return -1 if gkSolidAngleRatio is 0. 298 // Return gkSolidAngleRatioErr ^2 / gkSolidAngleRatio^2 299 // 300 const Float_t MCalibrationChargePINDiode::GetSolidAngleRatioRelVar() const 301 { 302 if (gkSolidAngleRatioErr < 0.) 303 return -1.; 304 305 if (gkSolidAngleRatio == 0.) 306 return -1.; 307 308 return gkSolidAngleRatioErr * gkSolidAngleRatioErr / gkSolidAngleRatio / gkSolidAngleRatio ; 309 } 310 195 311 196 312 // -------------------------------------------------------------------------- … … 257 373 // Correct for the distance between camera and PIN Diode and for different areas. 258 374 // 259 fFluxOutsidePlexiglass = fNumPhotons * gkSolidAngleRatio;260 261 //262 // Start calculation of number of photons relative Variance (!!)263 //264 const Float_t numphotRelVar = fNumPhotonsVar / ( fNumPhotons * fNumPhotons ) ;265 const Float_t solidangleRelVar = gkSolidAngleRatioErr* gkSolidAngleRatioErr266 / ( gkSolidAngleRatio * gkSolidAngleRatio );267 Float_t fluxRelVar = numphotRelVar + solidangleRelVar ;268 269 375 switch (fColor) 270 376 { 271 377 case kGREEN: 272 fFluxOutsidePlexiglass /= gkPINDiodeQEGreen; 273 fluxRelVar += gkPINDiodeQEGreenErr* gkPINDiodeQEGreenErr 274 / ( gkPINDiodeQEGreen * gkPINDiodeQEGreen ); 378 fFluxOutsidePlexiglass = fNumPhotons * gkSolidAngleRatio * gkPINDiodeQEGreen; 379 fFluxOutsidePlexiglassVar = GetNumPhotonsRelVar() + GetSolidAngleRatioRelVar() + GetPINDiodeQEGreenRelVar(); 275 380 break; 276 381 case kBLUE: 277 fFluxOutsidePlexiglass /= gkPINDiodeQEBlue; 278 fluxRelVar += gkPINDiodeQEBlueErr* gkPINDiodeQEBlueErr 279 / ( gkPINDiodeQEBlue * gkPINDiodeQEBlue ); 382 fFluxOutsidePlexiglass = fNumPhotons * gkSolidAngleRatio * gkPINDiodeQEBlue; 383 fFluxOutsidePlexiglassVar = GetNumPhotonsRelVar() + GetSolidAngleRatioRelVar() + GetPINDiodeQEBlueRelVar(); 280 384 break; 281 385 case kUV: 282 fFluxOutsidePlexiglass /= gkPINDiodeQEUV; 283 fluxRelVar += gkPINDiodeQEUVErr* gkPINDiodeQEUVErr 284 / ( gkPINDiodeQEUV * gkPINDiodeQEUV ); 386 fFluxOutsidePlexiglass = fNumPhotons * gkSolidAngleRatio * gkPINDiodeQEUV; 387 fFluxOutsidePlexiglassVar = GetNumPhotonsRelVar() + GetSolidAngleRatioRelVar() + GetPINDiodeQEUVRelVar(); 285 388 break; 286 389 case kCT1: 287 390 default: 288 fFluxOutsidePlexiglass /= gkPINDiodeQECT1; 289 fluxRelVar += gkPINDiodeQECT1Err* gkPINDiodeQECT1Err 290 / ( gkPINDiodeQECT1 * gkPINDiodeQECT1 ); 391 fFluxOutsidePlexiglass = fNumPhotons * gkSolidAngleRatio * gkPINDiodeQECT1; 392 fFluxOutsidePlexiglassVar = GetNumPhotonsRelVar() + GetSolidAngleRatioRelVar() + GetPINDiodeQECT1RelVar(); 291 393 break; 292 394 } 293 294 295 *fLog << inf << endl;296 *fLog << inf << " Mean Photon flux [ph/mm^2] outside Plexiglass: "297 << fFluxOutsidePlexiglass << endl;298 299 if (fFluxOutsidePlexiglass < 0.)300 return kFALSE;301 302 if (fluxRelVar < 0.)303 return kFALSE;304 305 SetFluxOutsidePlexiglassAvailable();306 395 307 396 // 308 397 // Finish calculation of errors -> convert from relative variance to absolute variance 309 398 // 310 fFluxOutsidePlexiglassVar *= fluxRelVar * fFluxOutsidePlexiglass * fFluxOutsidePlexiglass; 311 312 *fLog << inf << " Error on Photon flux [ph/mm^2] outside Plexiglass: " 313 << GetFluxOutsidePlexiglassErr() << endl; 399 fFluxOutsidePlexiglassVar *= fFluxOutsidePlexiglass * fFluxOutsidePlexiglass; 400 401 if (fFluxOutsidePlexiglass < 0.) 402 return kFALSE; 403 404 if (fFluxOutsidePlexiglassVar < 0.) 405 return kFALSE; 406 407 SetFluxOutsidePlexiglassAvailable(); 408 314 409 *fLog << inf << endl; 410 *fLog << inf << " Mean Photon flux [ph/mm^2] outside Plexiglass: " 411 << Form("%5.3f%s%5.3f",fFluxOutsidePlexiglass," +- ",GetFluxOutsidePlexiglassErr()) << endl; 315 412 316 413 return kTRUE; -
trunk/MagicSoft/Mars/mcalib/MCalibrationChargePINDiode.h
r3662 r3672 47 47 kFluxOutsidePlexiglassAvailable }; // Possible bits to be set 48 48 49 public: 49 const Float_t GetPINDiodeQEGreenRelVar() const; 50 const Float_t GetPINDiodeQEBlueRelVar () const; 51 const Float_t GetPINDiodeQEUVRelVar () const; 52 const Float_t GetPINDiodeQECT1RelVar () const; 53 const Float_t GetSolidAngleRatioRelVar() const; 54 55 public: 50 56 51 57 MCalibrationChargePINDiode(const char *name=NULL, const char *title=NULL); … … 75 81 76 82 // Pedestals 77 Float_t GetAbsTimeMean() const { return fAbsTimeMean; } 78 Float_t GetAbsTimeRms () const { return fAbsTimeRms; } 79 Float_t GetPed() const { return fPed; } 80 Float_t GetPedRms() const { return fPedRms; } 83 Float_t GetAbsTimeMean () const { return fAbsTimeMean; } 84 Float_t GetAbsTimeRms () const { return fAbsTimeRms; } 85 Float_t GetNumPhotons () const { return fNumPhotons; } 86 Float_t GetNumPhotonsErr() const; 87 Float_t GetNumPhotonsRelVar() const; 88 Float_t GetPed() const { return fPed; } 89 Float_t GetPedRms() const { return fPedRms; } 81 90 82 Bool_t IsChargeFitValid() const;83 Bool_t IsTimeFitValid() const;84 Bool_t IsOscillating() const;91 Bool_t IsChargeFitValid() const; 92 Bool_t IsTimeFitValid() const; 93 Bool_t IsOscillating() const; 85 94 Bool_t IsFluxOutsidePlexiglassAvailable() const; 86 95 -
trunk/MagicSoft/Mars/mcalib/MCalibrationChargePix.cc
r3663 r3672 274 274 fPedVar = pederr*pederr; 275 275 } 276 277 278 // -------------------------------------------------------------------------- 276 277 // ------------------------------------------------------------------------------- 278 // 279 // Get the conversion Error Hi-Gain to Low-Gain: 280 // - If fConversionHiLoVar is smaller than 0 (i.e. has not yet been set), return -1. 281 // 282 Float_t MCalibrationChargePix::GetConversionHiLoErr() const 283 { 284 if (fConversionHiLoVar < 0.) 285 return -1.; 286 287 return TMath::Sqrt(fConversionHiLoVar); 288 } 289 290 // -------------------------------------------------------------------------- 291 // 292 // Get the relative variance of the conversion factor between higain and logain: 293 // - If fConversionHiLo is 0, return -1. 294 // - If fConversionHiLoVar is smaller than 0, return -1. 295 // - Else returns: fConversionHiLoVar / fConversionHiLo^2 296 // 297 const Float_t MCalibrationChargePix::GetConversionHiLoRelVar() const 298 { 299 300 if (fConversionHiLoVar < 0.) 301 return -1.; 302 303 if (fConversionHiLo == 0.) 304 return -1.; 305 306 return fConversionHiLoVar / (fConversionHiLo * fConversionHiLo); 307 } 308 309 310 // -------------------------------------------------------------------------- 311 // 312 // Get the relative variance of the conversion factor between higain and logain: 313 // - If gkFFactor is 0, return -1. 314 // - If gkFFactorErr is smaller than 0, return -1. 315 // - Else returns: gkFFactorErr^2 / gkFFactor*^2 316 // 317 const Float_t MCalibrationChargePix::GetFFactorRelVar() const 318 { 319 320 if (gkFFactorErr < 0.) 321 return -1.; 322 323 if (gkFFactor == 0.) 324 return -1.; 325 326 return gkFFactorErr * gkFFactorErr / (gkFFactor * gkFFactor); 327 } 328 329 279 330 // 280 331 // Get the Error of the Mean pedestals: … … 348 399 Float_t MCalibrationChargePix::GetConvertedLoGainMeanErr() const 349 400 { 350 351 if (fLoGainMeanVar < 0.) 352 return -1.; 353 354 if (fLoGainMean < 0.) 355 return -1.; 356 357 const Float_t chargeRelVar = fLoGainMeanVar 358 /( fLoGainMean * fLoGainMean ); 359 360 return TMath::Sqrt(chargeRelVar+GetConversionHiLoRelVar()) * GetConvertedLoGainMean(); 401 402 const Float_t logainrelvar = GetLoGainMeanRelVar(); 403 404 if (logainrelvar < 0.) 405 return -1.; 406 407 return TMath::Sqrt(logainrelvar + GetConversionHiLoRelVar()) * GetConvertedLoGainMean(); 361 408 } 362 409 … … 445 492 // -------------------------------------------------------------------------- 446 493 // 447 // Get the conversion Error Hi-Gain to Low-Gain: 448 // - If fConversionHiLoVar is smaller than 0 (i.e. has not yet been set), return -1. 449 // - Else returns the square root of fConversionHiLoVar 450 // 451 Float_t MCalibrationChargePix::GetConversionHiLoErr() const 452 { 453 if (fConversionHiLoVar < 0.) 454 return -1.; 455 456 return TMath::Sqrt(fConversionHiLoVar); 494 // Get the relative variance of the reduced Sigma: 495 // - If fRSigmaSquareVar is smaller than 0 (i.e. has not yet been set), return -1. 496 // - Calculate the relative variance of the reduced sigma squares with the formula: 497 // reduced sigma rel. variance = 0.25 * fRSigmaSquareVar / fRSigmaSquare / fRSigmaSquare 498 // - Test bit kHiGainSaturation: 499 // If yes, returns the sum of the relative variances of the reduced sigma and fConversionHiLo 500 // Else returns the relative variance of the reduced sigma 501 // 502 Float_t MCalibrationChargePix::GetRSigmaRelVar() const 503 { 504 505 if (fRSigmaSquareVar < 0) 506 return -1; 507 508 // 509 // SigmaSquareVar = 4. * Sigma * Sigma * Var(sigma) 510 // ==> Var(sigma) = 0.25 * SigmaSquareVar / (Sigma * Sigma) 511 // 512 const Float_t rsigmaRelVar = 0.25 * fRSigmaSquareVar / ( fRSigmaSquare * fRSigmaSquare ); 513 514 if (IsHiGainSaturation()) 515 return rsigmaRelVar + GetConversionHiLoRelVar(); 516 else 517 return rsigmaRelVar; 457 518 } 458 519 … … 705 766 } 706 767 707 const Float_t mean = IsHiGainSaturation() ? fLoGainMean : fHiGainMean ;708 const Float_t var = IsHiGainSaturation() ? fLoGainMeanVar : fHiGainMeanVar;709 710 768 // 711 769 // Square all variables in order to avoid applications of square root 712 770 // 713 const Float_t meanSquare = mean * mean;714 const Float_t meanSquareRelVar = 4.* var / meanSquare;771 const Float_t meanSquare = GetMean() * GetMean(); 772 const Float_t meanSquareRelVar = 4.* GetMeanRelVar(); 715 773 716 774 const Float_t ffactorsquare = gkFFactor * gkFFactor; 717 const Float_t ffactorsquareRelVar = 4.* gkFFactorErr * gkFFactorErr / ffactorsquare;775 const Float_t ffactorsquareRelVar = 4.* GetFFactorRelVar(); 718 776 719 777 const Float_t rsigmaSquareRelVar = fRSigmaSquareVar / fRSigmaSquare; … … 804 862 const Float_t conversionSquareRelVar = 4.* GetConversionHiLoRelVar(); 805 863 806 const Float_t logainNsbSquare = higainNsbSquare/ conversionSquare;807 const Float_t logainNsbSquareVar =( higainNsbSquareRelVar + conversionSquareRelVar )808 864 const Float_t logainNsbSquare = higainNsbSquare / conversionSquare; 865 const Float_t logainNsbSquareVar = ( higainNsbSquareRelVar + conversionSquareRelVar ) 866 * logainNsbSquare * logainNsbSquare; 809 867 810 868 fLoGainPedRmsSquare = logainNsbSquare + elecRmsSquare; … … 812 870 } 813 871 814 // --------------------------------------------------------------------------815 //816 // Get the relative variance of the conversion factor between higain and logain:817 // - If fConversionHiLo is smaller than 0, return -1.818 // - Else returns: fConversionHiLoVar / (fConversionHiLo * fConversionHiLo)819 //820 const Float_t MCalibrationChargePix::GetConversionHiLoRelVar() const821 {822 if (fConversionHiLo == 0.)823 return 0.;824 825 return fConversionHiLoVar / (fConversionHiLo * fConversionHiLo);826 }827 -
trunk/MagicSoft/Mars/mcalib/MCalibrationChargePix.h
r3663 r3672 59 59 60 60 const Float_t GetConversionHiLoRelVar() const; 61 const Float_t Get ChargeRelVar()const;62 61 const Float_t GetFFactorRelVar() const; 62 63 63 public: 64 64 … … 93 93 94 94 // Getters 95 Float_t GetAbsTimeMean ()const { return fAbsTimeMean; }96 Float_t GetAbsTimeRms ()const { return fAbsTimeRms; }97 Float_t GetConversionHiLo ()const { return fConversionHiLo; }98 Float_t GetConversionHiLoErr ()const;95 Float_t GetAbsTimeMean () const { return fAbsTimeMean; } 96 Float_t GetAbsTimeRms () const { return fAbsTimeRms; } 97 Float_t GetConversionHiLo () const { return fConversionHiLo; } 98 Float_t GetConversionHiLoErr () const; 99 99 Float_t GetConversionBlindPixelMethodErr() const; 100 Float_t GetConversionFFactorMethodErr ()const;100 Float_t GetConversionFFactorMethodErr () const; 101 101 Float_t GetConversionPINDiodeMethodErr() const; 102 102 Float_t GetConversionCombinedMethodErr() const; … … 121 121 Float_t GetRSigma () const; 122 122 Float_t GetRSigmaErr () const; 123 Float_t GetRSigmaRelVar () const; 123 124 Float_t GetTotalFFactorBlindPixelMethod() const { return fTotalFFactorBlindPixelMethod; } 124 125 Float_t GetTotalFFactorBlindPixelMethodErr() const; … … 136 137 137 138 // Miscellaneous 138 void CalcLoGainPedestal(const Float_t logainsamples);139 void CalcLoGainPedestal(const Float_t logainsamples); 139 140 Bool_t CalcReducedSigma(); 140 141 Bool_t CalcFFactorMethod(); -
trunk/MagicSoft/Mars/mcalib/MCalibrationPix.cc
r3671 r3672 208 208 // -------------------------------------------------------------------------- 209 209 // 210 // Get the Low Gain Mean Rel Variance 211 // 212 Float_t MCalibrationPix::GetLoGainMeanRelVar() const 213 { 214 if (fLoGainMeanVar < 0.) 215 return -1.; 216 if (fLoGainMean == 0.) 217 return -1.; 218 219 return fLoGainMeanVar / ( fLoGainMean * fLoGainMean); 220 } 221 222 // -------------------------------------------------------------------------- 223 // 210 224 // Get the Low Gain Sigma Error: Takes square root of fHiGainSigmaVar 211 225 // -
trunk/MagicSoft/Mars/mcalib/MCalibrationPix.h
r3671 r3672 73 73 Float_t GetHiGainNumPickup() const { return fHiGainNumPickup; } 74 74 75 virtual Float_t GetLoGainMean () const { return fLoGainMean ; } 76 virtual Float_t GetLoGainMeanErr () const; 77 virtual Float_t GetLoGainProb () const { return fLoGainProb ; } 78 virtual Float_t GetLoGainSigma () const { return fLoGainSigma ; } 79 virtual Float_t GetLoGainSigmaErr () const; 80 virtual Float_t GetLoGainNumPickup() const { return fLoGainNumPickup; } 75 virtual Float_t GetLoGainMean () const { return fLoGainMean ; } 76 virtual Float_t GetLoGainMeanErr () const; 77 virtual Float_t GetLoGainMeanRelVar() const; 78 virtual Float_t GetLoGainProb () const { return fLoGainProb ; } 79 virtual Float_t GetLoGainSigma () const { return fLoGainSigma ; } 80 virtual Float_t GetLoGainSigmaErr () const; 81 virtual Float_t GetLoGainNumPickup () const { return fLoGainNumPickup; } 81 82 82 83 Float_t GetMean () const { return IsHiGainSaturation() ? GetLoGainMean() : GetHiGainMean() ; } -
trunk/MagicSoft/Mars/mcalib/MHCalibrationChargeBlindPix.cc
r3639 r3672 441 441 fBlindPix->SetSinglePheFitOK(); 442 442 443 fBlindPix->SetLambda ( fLambda ); 444 fBlindPix->SetMu0 ( fMu0 ); 445 fBlindPix->SetMu0Err ( fMu0Err ); 446 fBlindPix->SetMu1 ( fMu1 ); 447 fBlindPix->SetMu1Err ( fMu1Err ); 448 fBlindPix->SetSigma0 ( fSigma0 ); 449 fBlindPix->SetSigma0Err ( fSigma0Err ); 450 fBlindPix->SetSigma1 ( fSigma1 ); 451 fBlindPix->SetSigma1Err ( fSigma1Err ); 452 fBlindPix->SetProb ( fProb ); 453 454 fBlindPix->SetLambdaCheck ( fLambdaCheck ); 455 fBlindPix->SetLambdaCheckErr ( fLambdaCheckErr ); 443 fBlindPix->SetLambda ( fLambda ); 444 fBlindPix->SetLambdaVar ( fLambdaErr*fLambdaErr ); 445 fBlindPix->SetMu0 ( fMu0 ); 446 fBlindPix->SetMu0Err ( fMu0Err ); 447 fBlindPix->SetMu1 ( fMu1 ); 448 fBlindPix->SetMu1Err ( fMu1Err ); 449 fBlindPix->SetSigma0 ( fSigma0 ); 450 fBlindPix->SetSigma0Err ( fSigma0Err ); 451 fBlindPix->SetSigma1 ( fSigma1 ); 452 fBlindPix->SetSigma1Err ( fSigma1Err ); 453 fBlindPix->SetProb ( fProb ); 454 455 fBlindPix->SetLambdaCheck ( fLambdaCheck ); 456 fBlindPix->SetLambdaCheckErr ( fLambdaCheckErr ); 456 457 457 458 return kTRUE;
Note:
See TracChangeset
for help on using the changeset viewer.