/* ======================================================================== *\ ! ! * ! * 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 ! ! \* ======================================================================== */ ///////////////////////////////////////////////////////////////////////////// // // MCalibrationCam // // Base class for Camera Calibration results. // // Contains TOrdCollections for the following objects: // - fPixels: Array of classes derived from MCalibrationPix, one entry // per pixel. Has to be created // - fAverageAreas: Array of classes derived from MCalibrationPix, one entry // per pixel AREA. Has to be created // - fAverageSectors: Array of classes derived from MCalibrationPix, one entry // per camera SECTOR. Has to be created // // - fAverageBadAreas: Array of classes derived from MBadPixelsPix, one entry // per pixel AREA. Is created automatically. // - fAverageBadSectors: Array of classes derived from MBadPixelsPix, one entry // per camera SECTOR. Is created automatically. // // Previous Class Versions haven't been commented by the author! // // Class Version 6: // ---------------- // + added fRunNumber // // All TOrdCollections have to enlarged by the corresponding calls to (e.g. in MGeomApply): // - InitSize() // - InitAverageAreas() // - InitAverageSectors() // ///////////////////////////////////////////////////////////////////////////// #include "MCalibrationCam.h" #include #include "MGeomCam.h" #include "MGeomPix.h" #include "MBadPixelsCam.h" #include "MBadPixelsPix.h" #include "MCalibrationPix.h" #include "MLog.h" #include "MLogManip.h" ClassImp(MCalibrationCam); using namespace std; const Int_t MCalibrationCam::gkNumPulserColors = 4; // -------------------------------------------------------------------------- // // Default constructor. // // Set the following pointer to NULL: // - fPixels // - fAverageAreas // - fAverageSectors // // Initializes: // - fPulserColor to kNONE // - fNumHiGainFADCSlices to 0. // - fNumLoGainFADCSlices to 0. // // Creates a TOrdCollection of MBadPixelsPix containers for the TOrdCollection's: // - fAverageBadAreas // - fAverageBadSectors // all initialized to 1 entry // // Later, a call to InitAverageAreas() and InitAverageSectors() (or Init()) // has to be performed in order to get the dimension correctly. // MCalibrationCam::MCalibrationCam(const char *name, const char *title) : fRunNumber(-1), fPulserColor(kNONE) { fPixels = new TOrdCollection; fPixels->SetOwner(); fAverageAreas = new TOrdCollection; fAverageAreas->SetOwner(); fAverageSectors = new TOrdCollection; fAverageSectors->SetOwner(); fAverageBadAreas = new TOrdCollection; fAverageBadAreas->SetOwner(); fAverageBadSectors = new TOrdCollection; fAverageBadSectors->SetOwner(); fNumHiGainFADCSlices.Set(1); fNumLoGainFADCSlices.Set(1); } // -------------------------------------------------------------------------- // // Deletes the following TOrdCollection's of MCalibrationPix containers (if exist): // - fPixels // - fAverageAreas // - fAverageSectors // // Deletes the following TOrdCollection's of MBadPixelsPix containers (if exist): // - fAverageBadAreas // - fAverageBadSectors // MCalibrationCam::~MCalibrationCam() { // // delete fPixels should delete all Objects stored inside // if (fPixels) delete fPixels; if (fAverageAreas) delete fAverageAreas; if (fAverageSectors) delete fAverageSectors; if (fAverageBadAreas) delete fAverageBadAreas; if (fAverageBadSectors) delete fAverageBadSectors; } // -------------------------------------- // // Calls the ForEach macro for the TOrdCollection fPixels with the argument Clear() // // Loops over the fAverageAreas, calling the function Clear() for // every entry in: // - fAverageAreas // - fAverageBadAreas // // Loops over the fAverageSectors, calling the function Clear() for // every entry in: // - fAverageSectors // - fAverageBadSectors // void MCalibrationCam::Clear(Option_t *o) { { fPixels ->R__FOR_EACH(TObject, Clear)(); } { fAverageAreas ->R__FOR_EACH(TObject, Clear)(); } { fAverageSectors->R__FOR_EACH(TObject, Clear)(); } } // -------------------------------------------------------------------------- // // Copy 'constructor' // void MCalibrationCam::Copy(TObject& object) const { MCalibrationCam &calib = (MCalibrationCam&)object; MParContainer::Copy(calib); calib.fPulserColor = fPulserColor; const Int_t n = GetSize(); if (n != 0) { calib.InitSize(n); for (int i=0; isave) Add(save,i); } void MCalibrationCam::Add(const UInt_t a, const UInt_t b) { for (UInt_t i=a; iAddAt(new MCalibrationPix,i); } void MCalibrationCam::AddArea(const UInt_t a, const UInt_t b) { for (UInt_t i=a; iAddAt(new MCalibrationPix,i); } void MCalibrationCam::AddSector(const UInt_t a, const UInt_t b) { for (UInt_t i=a; iAddAt(new MCalibrationPix,i); } // ------------------------------------------------------------------- // // Initialize the objects inside the TOrdCollections // - fAverageAreas // - fAverageBadAreas // using the virtual function Add(). // // InitSize can only increase the size, but not shrink. // // It can be called more than one time. New Containers are // added only from the current size to the argument i. // void MCalibrationCam::InitAverageAreas(const UInt_t i) { const UInt_t save = GetAverageAreas(); if (i==save) return; fNumUnsuitable.Set(i); fNumUnreliable.Set(i); fNumHiGainFADCSlices.Set(i); fNumLoGainFADCSlices.Set(i); if (i < save) return; for (UInt_t j=save; jAddAt(new MBadPixelsPix,j); AddArea(save,i); for (UInt_t j=save; jAddAt(new MBadPixelsPix,j); AddSector(save,i); for (UInt_t j=save; j fNumUnsuitable.GetSize() ? -1 : fNumUnsuitable[aidx]; } // -------------------------------------------------------------------------- // // Returns the number of un-reliable pixels per area index and -1 if // the area index exceeds the initialized array. // const Int_t MCalibrationCam::GetNumUnreliable( const Int_t aidx ) const { if (aidx < 0) { Int_t num = 0; for (Int_t i=0;i fNumUnreliable.GetSize() ? -1 : fNumUnreliable[aidx]; } // -------------------------------------------------------------------------- // // Returns the mean number of High-Gain FADC slices per area index and -1 if // the area index exceeds the initialized array. // const Float_t MCalibrationCam::GetNumHiGainFADCSlices( const Int_t aidx ) const { if (aidx < 0) return -1; return aidx > fNumHiGainFADCSlices.GetSize() ? -1 : fNumHiGainFADCSlices[aidx]; } // -------------------------------------------------------------------------- // // Returns the mean number of Low-Gain FADC slices per area index and -1 if // the area index exceeds the initialized array. // const Float_t MCalibrationCam::GetNumLoGainFADCSlices( const Int_t aidx ) const { if (aidx < 0) return -1; return aidx > fNumLoGainFADCSlices.GetSize() ? -1 : fNumLoGainFADCSlices[aidx]; } // -------------------------------------------------------------------------- // // Returns the current size of the TOrdCollection fAverageAreas // independently if the MCalibrationPix is filled with values or not. // const Int_t MCalibrationCam::GetAverageAreas() const { return fAverageAreas->GetSize(); } // -------------------------------------------------------------------------- // // Returns the current size of the TOrdCollection fAverageSectors // independently if the MCalibrationPix is filled with values or not. // const Int_t MCalibrationCam::GetAverageSectors() const { return fAverageSectors->GetSize(); } // -------------------------------------------------------------------------- // // Get i-th pixel (pixel number) // MCalibrationPix &MCalibrationCam::operator[](UInt_t i) { return *static_cast(fPixels->At(i)); } // -------------------------------------------------------------------------- // // Get i-th pixel (pixel number) // const MCalibrationPix &MCalibrationCam::operator[](UInt_t i) const { return *static_cast(fPixels->At(i)); } // -------------------------------------------------------------------------- // // Returns the current size of the TOrdCollection fPixels // independently if the MCalibrationPix is filled with values or not. // const Int_t MCalibrationCam::GetSize() const { return fPixels->GetSize(); } // -------------------------------------------------------------------------- // // Get i-th average pixel (area number) // MCalibrationPix &MCalibrationCam::GetAverageArea(const UInt_t i) { return *static_cast(fAverageAreas->At(i)); } // -------------------------------------------------------------------------- // // Get i-th average pixel (area number) // const MCalibrationPix &MCalibrationCam::GetAverageArea(const UInt_t i) const { return *static_cast(fAverageAreas->At(i)); } // -------------------------------------------------------------------------- // // Get i-th average pixel (sector number) // MCalibrationPix &MCalibrationCam::GetAverageSector(const UInt_t i) { return *static_cast(fAverageSectors->At(i)); } // -------------------------------------------------------------------------- // // Get i-th average pixel (sector number) // const MCalibrationPix &MCalibrationCam::GetAverageSector(const UInt_t i) const { return *static_cast(fAverageSectors->At(i)); } // -------------------------------------------------------------------------- // // Get i-th average pixel (area number) // MBadPixelsPix &MCalibrationCam::GetAverageBadArea(const UInt_t i) { return *static_cast(fAverageBadAreas->At(i)); } // -------------------------------------------------------------------------- // // Get i-th average pixel (area number) // const MBadPixelsPix &MCalibrationCam::GetAverageBadArea(const UInt_t i) const { return *static_cast(fAverageBadAreas->At(i)); } // -------------------------------------------------------------------------- // // Get i-th average pixel (sector number) // MBadPixelsPix &MCalibrationCam::GetAverageBadSector(const UInt_t i) { return *static_cast(fAverageBadSectors->At(i)); } // -------------------------------------------------------------------------- // // Get i-th average pixel (sector number) // const MBadPixelsPix &MCalibrationCam::GetAverageBadSector(const UInt_t i) const { return *static_cast(fAverageBadSectors->At(i)); } // -------------------------------------------------------------------------- // // Dummy needed for compilation with MCamEvent // Bool_t MCalibrationCam::GetPixelContent(Double_t &val, Int_t idx, const MGeomCam &cam, Int_t type) const { return kTRUE; } // -------------------------------------------------------------------------- // // Calls MCalibrationPix::DrawClone() // void MCalibrationCam::DrawPixelContent(Int_t idx) const { (*this)[idx].DrawClone(); } void MCalibrationCam::SetNumHiGainFADCSlices( const Float_t i, const Int_t aidx) { if (aidx < 0) return; if (aidx < fNumHiGainFADCSlices.GetSize()) fNumHiGainFADCSlices[aidx] = i; } void MCalibrationCam::SetNumLoGainFADCSlices( const Float_t i, const Int_t aidx) { if (aidx < 0) return; if (aidx < fNumLoGainFADCSlices.GetSize()) fNumLoGainFADCSlices[aidx] = i; } void MCalibrationCam::SetNumUnsuitable( const UInt_t i, const Int_t aidx) { if (aidx < 0) return; if (aidx < fNumUnsuitable.GetSize()) fNumUnsuitable[aidx] = i; } void MCalibrationCam::SetNumUnreliable( const UInt_t i, const Int_t aidx) { if (aidx < 0) return; if (aidx < fNumUnreliable.GetSize()) fNumUnreliable[aidx] = i; } TString MCalibrationCam::GetPulserColorStr(PulserColor_t col) { TString str; switch (col) { case kCT1: str += "CT1"; break; case kGREEN: str += "Green"; break; case kBLUE: str += "Blue"; break; case kUV: str += "UV"; break; case kNONE: str += "None"; break; default: str += "Unknown"; break; } str += " ("; str += (int)col; str += ")"; return str; }