/* ======================================================================== *\ ! ! * ! * This file is part of MARS, the MAGIC Analysis and Reconstruction ! * Software. It is distributed to you in the hope that it can be a useful ! * and timesaving tool in analysing Data of imaging Cerenkov telescopes. ! * It is distributed WITHOUT ANY WARRANTY. ! * ! * Permission to use, copy, modify and distribute this software and its ! * documentation for any purpose is hereby granted without fee, ! * provided that the above copyright notice appear in all copies and ! * that both that copyright notice and this permission notice appear ! * in supporting documentation. It is provided "as is" without express ! * or implied warranty. ! * ! ! ! Author(s): Markus Gaug 11/2003 ! ! Copyright: MAGIC Software Development, 2000-2004 ! ! \* ======================================================================== */ ///////////////////////////////////////////////////////////////////////////// // // MCalibrationRelTimeCam // // Storage container for relative arrival time calibration results // of the whole camera. // // Individual pixels have to be cast when retrieved e.g.: // MCalibrationRelTimePix &avpix = (MCalibrationRelTimePix&)(*fRelCam)[i] // // The following "calibration" constants can be retrieved from each pixel: // - GetTimeOffset(): The mean offset in relative times, // has to be added to any calculated relative time in the camera. // - GetTimePrecision(): The Gauss sigma of histogrammed relative arrival // times for the calibration run. Gives an estimate about the timing // resolution. // // ALL RELATIVE TIMES HAVE TO BE CALCULATED W.R.T. PIXEL IDX 1 // (HARDWARE NUMBER: 2) !! // // Averaged values over one whole area index (e.g. inner or outer pixels for // the MAGIC camera), can be retrieved via: // MCalibrationRelTimePix &avpix = (MCalibrationRelTimePix&)fRelCam->GetAverageArea(i) // // Averaged values over one whole camera sector can be retrieved via: // MCalibrationRelTimePix &avpix = (MCalibrationRelTimePix&)fRelCam->GetAverageSector(i) // // Note the averageing has been done on an event-by-event basis. Resulting // Sigma's of the Gauss fit have been multiplied with the square root of the number // of involved pixels in order to make a direct comparison possible with the mean of // sigmas. // // See also: MHCalibrationRelTimePix, MHCalibrationRelTimeCam // // The calculated values (types of GetPixelContent) are: // // Fitted values: // ============== // // 0: Mean Time Offset // 1: Error of Mean Time Offset // 2: Sigma of Time Offset == Time Resolution // 3: Error of Sigma of Time Offset // // Useful variables derived from the fit results: // ============================================= // // 4: Returned probability of Gauss fit to Rel. Arrival Time distribution // ///////////////////////////////////////////////////////////////////////////// #include "MCalibrationRelTimeCam.h" #include "MCalibrationCam.h" #include #include "MLog.h" #include "MLogManip.h" #include "MGeomCam.h" #include "MGeomPix.h" #include "MCalibrationRelTimePix.h" ClassImp(MCalibrationRelTimeCam); using namespace std; // -------------------------------------------------------------------------- // // Default constructor. // // Creates a TClonesArray of MCalibrationRelTimePix containers, initialized to 1 entry, destinated // to hold one container per pixel. Later, a call to MCalibrationRelTimeCam::InitSize() // has to be performed (in MGeomApply). // // Creates a TClonesArray of MCalibrationRelTimePix containers, initialized to 1 entry, destinated // to hold one container per pixel AREA. Later, a call to MCalibrationRelTimeCam::InitAreas() // has to be performed (in MGeomApply). // // Creates a TClonesArray of MCalibrationRelTimePix containers, initialized to 1 entry, destinated // to hold one container per camera SECTOR. Later, a call to MCalibrationRelTimeCam::InitSectors() // has to be performed (in MGeomApply). // MCalibrationRelTimeCam::MCalibrationRelTimeCam(const char *name, const char *title) { fName = name ? name : "MCalibrationRelTimeCam"; fTitle = title ? title : "Container for Relative Time Calibration Information"; fPixels = new TClonesArray("MCalibrationRelTimePix",1); fAverageAreas = new TClonesArray("MCalibrationRelTimePix",1); fAverageSectors = new TClonesArray("MCalibrationRelTimePix",1); } // -------------------------------------------------------------------------- // // Print first the well fitted pixels // and then the ones which are not Valid // void MCalibrationRelTimeCam::Print(Option_t *o) const { *fLog << all << GetDescriptor() << ":" << endl; int id = 0; *fLog << all << "Calibrated pixels:" << endl; *fLog << all << endl; TIter Next(fPixels); MCalibrationRelTimePix *pix; while ((pix=(MCalibrationRelTimePix*)Next())) { if (!pix->IsExcluded()) { *fLog << all << Form("%s%4i%s%4.2f%s%4.2f%s%4.2f%s%4.2f","Pix ",pix->GetPixId(), ": Offset: ",pix->GetTimeOffset()," +- ",pix->GetTimeOffsetErr(), " Precision: ",pix->GetTimePrecision()," +- ",pix->GetTimePrecisionErr()) << endl; id++; } } *fLog << all << id << " pixels" << endl; id = 0; *fLog << all << endl; *fLog << all << "Excluded pixels:" << endl; *fLog << all << endl; id = 0; TIter Next4(fPixels); while ((pix=(MCalibrationRelTimePix*)Next4())) { if (pix->IsExcluded()) { *fLog << all << pix->GetPixId() << endl; id++; } } *fLog << all << id << " Excluded pixels " << endl; *fLog << endl; TIter Next5(fAverageAreas); while ((pix=(MCalibrationRelTimePix*)Next5())) { *fLog << all << Form("%s%4i%s%4.2f%s%4.2f%s%4.2f%s%4.2f","Average Area ",pix->GetPixId(), ": Offset: ",pix->GetTimeOffset()," +- ",pix->GetTimeOffsetErr(), " Precision: ",pix->GetTimePrecision()," +- ",pix->GetTimePrecisionErr()) << endl; } TIter Next6(fAverageSectors); while ((pix=(MCalibrationRelTimePix*)Next5())) { *fLog << all << Form("%s%4i%s%4.2f%s%4.2f%s%4.2f%s%4.2f","Average Sector ",pix->GetPixId(), ": Offset: ",pix->GetTimeOffset()," +- ",pix->GetTimeOffsetErr(), " Precision: ",pix->GetTimePrecision()," +- ",pix->GetTimePrecisionErr()) << endl; } } // -------------------------------------------------------------------------- // // The types are as follows: // // Fitted values: // ============== // // 0: Fitted RelTime // 1: Error of fitted RelTime // 2: Sigma of fitted RelTime // 3: Error of Sigma of fitted RelTime // // Useful variables derived from the fit results: // ============================================= // // 4: Returned probability of Gauss fit to RelTime distribution // Bool_t MCalibrationRelTimeCam::GetPixelContent(Double_t &val, Int_t idx, const MGeomCam &cam, Int_t type) const { if (idx > GetSize()) return kFALSE; Float_t area = cam[idx].GetA(); if (area == 0) return kFALSE; MCalibrationRelTimePix &pix = (MCalibrationRelTimePix&)(*this)[idx]; switch (type) { case 0: if (pix.IsExcluded()) return kFALSE; val = pix.GetMean(); break; case 1: if (pix.IsExcluded()) return kFALSE; val = pix.GetMeanErr(); break; case 2: if (pix.IsExcluded()) return kFALSE; val = pix.GetSigma(); break; case 3: if (pix.IsExcluded()) return kFALSE; val = pix.GetSigmaErr(); break; case 4: if (pix.IsExcluded()) return kFALSE; val = pix.GetProb(); break; default: return kFALSE; } return val!=-1.; } // -------------------------------------------------------------------------- // // Calls MCalibrationPix::DrawClone() // void MCalibrationRelTimeCam::DrawPixelContent(Int_t idx) const { (*this)[idx].DrawClone(); }