source: trunk/MagicSoft/Mars/manalysis/MMcCalibrationUpdate.cc@ 2961

/* ======================================================================== *\
!
! *
! * 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): Abelardo Moralejo, 12/2003 <mailto:moralejo@pd.infn.it>
!
!   Copyright: MAGIC Software Development, 2000-2003
!
!
\* ======================================================================== */

/////////////////////////////////////////////////////////////////////////////
//
//  MMcCalibrationUpdate
//
//  This task looks for the ìnformation about FADC pedestals in
//  MMcFadcHeader and translates it to the pedestal mean and rms (in adc counts).
//  If not already existing in the parameter list, an MCalibrationCam object
//  is created, with the conversion factor between photons and ADC counts is 
//  set to 1 to allow the analysis to proceed.
//
//  Then it creates and fills also the MPedPhotCam object containing the pedestal
//  mean and rms in units of photons.
//
//  Input Containers:
//   MMcFadcHeader
//   MRawRunHeader
//  [MCalibrationCam] (if it existed previously)
//
//  Output Containers:
//   MPedPhotCam
//  [MCalibrationCam] (if it did not exist previously)
//
/////////////////////////////////////////////////////////////////////////////
#include "MMcCalibrationUpdate.h"

#include "MParList.h"

#include "MLog.h"
#include "MLogManip.h"

#include "MCalibrationPix.h"
#include "MCalibrationCam.h"
#include "MExtractedSignalCam.h"
#include "MExtractedSignalPix.h"
#include "MGeomCam.h"
#include "MPedPhotCam.h"
#include "MPedPhotPix.h"

#include "MRawRunHeader.h"
#include "MMcFadcHeader.hxx"

ClassImp(MMcCalibrationUpdate);

using namespace std;

MMcCalibrationUpdate::MMcCalibrationUpdate(const char *name, const char *title)
{
    fName  = name  ? name  : "MMcCalibrationUpdate";
    fTitle = title ? title : "Write MC pedestals and conversion factors into MCalibration Container";

    fADC2PhInner = 1.;
    fADC2PhOuter = 1.;

    fAmplitude = -1.;
    fAmplitudeOuter = -1.;
    fConversionHiLo = -1.;

    fFillCalibrationCam = kTRUE;

}

// --------------------------------------------------------------------------
//
// Check for the run type. Return kTRUE if it is a MC run or if there
// is no MC run header (old camera files) kFALSE in case of a different
// run type
//
Bool_t MMcCalibrationUpdate::CheckRunType(MParList *pList) const
{
    const MRawRunHeader *run = (MRawRunHeader*)pList->FindObject("MRawRunHeader");
    if (!run)
    {
        *fLog << warn << dbginf << "Warning - cannot check file type, MRawRunHeader not found." << endl;
        return kTRUE;
    }

    return  run->GetRunType() == kRTMonteCarlo;
}

// --------------------------------------------------------------------------
//
// Make sure, that there is an MCalibrationCam Object in the Parameter List.
//
Int_t MMcCalibrationUpdate::PreProcess(MParList *pList)
{
  //
  // If it is no MC file skip this function...
  //
  if (!CheckRunType(pList))
    return kTRUE;


  fCalCam = (MCalibrationCam*) pList->FindObject(AddSerialNumber("MCalibrationCam"));
  if ( !fCalCam )
    {
      *fLog << inf << dbginf << AddSerialNumber("MCalibrationCam") << " does not exist... Creating." << endl;

      fCalCam = (MCalibrationCam*) pList->FindCreateObj(AddSerialNumber("MCalibrationCam"));
      if ( !fCalCam )
        {
          *fLog << err << dbginf << "Cannot create " << AddSerialNumber("MCalibrationCam") << "... aborting." << endl;
          return kFALSE;
        }
    }
  else
    {
      fFillCalibrationCam = kFALSE;
      *fLog << inf << AddSerialNumber("MCalibrationCam") << " already exists... " << endl;
    }

  fPedPhotCam = (MPedPhotCam*) pList->FindCreateObj(AddSerialNumber("MPedPhotCam"));
  if ( ! fPedPhotCam)
    {
      *fLog << err << dbginf << "Cannot create " << AddSerialNumber("MPedPhotCam") << "... aborting." << endl;
      return kFALSE;
    }

  fSignalCam = (MExtractedSignalCam*) pList->FindObject(AddSerialNumber("MExtractedSignalCam"));
  if ( ! fSignalCam)
    {
      *fLog << err << dbginf << "Cannot find " << AddSerialNumber("MExtractedSignalCam") << "... aborting." << endl;
      return kFALSE;
    }

  return kTRUE;

}

// --------------------------------------------------------------------------
//
// Check for the runtype.
// Search for MGeomCam and MMcFadcHeader.
// Fill the MCalibrationCam object.
//
Bool_t MMcCalibrationUpdate::ReInit(MParList *pList)
{
    //
    // If it is no MC file skip this function...
    //
    if (!CheckRunType(pList))
        return kTRUE;

    //
    // Now check the existence of all necessary containers.
    //

    fGeom = (MGeomCam*) pList->FindObject(AddSerialNumber("MGeomCam"));
    if ( ! fGeom )
      {
        *fLog << err << dbginf << "Cannot find " << AddSerialNumber("MGeomCam") << "... aborting." << endl;
        return kFALSE;
      }

    fHeaderFadc = (MMcFadcHeader*)pList->FindObject(AddSerialNumber("MMcFadcHeader"));
    if (!fHeaderFadc)
    {
      *fLog << err << dbginf << AddSerialNumber("MMcFadcHeader") << " not found... aborting." << endl;
        return kFALSE;
    }

    //
    // Initialize Fadc simulation parameters:
    //
    if ( fAmplitude < 0. )
      {
        fAmplitude = fHeaderFadc->GetAmplitud();
        fAmplitudeOuter = fHeaderFadc->GetAmplitudOuter();
        fConversionHiLo = fHeaderFadc->GetLow2HighGain();
      }
    else   // Check that following files have all the same FADC parameters
      {
        if ( fabs(fHeaderFadc->GetAmplitud()-fAmplitude) > 1.e-6  ||
             fabs(fHeaderFadc->GetAmplitudOuter()-fAmplitudeOuter) > 1.e-6  ||
             fabs(fConversionHiLo-fHeaderFadc->GetLow2HighGain()) > 1.e-6 )
          {
            *fLog << err << endl << endl << dbginf << "Parameters of MMcFadcHeader are not the same for all the read files. Aborting..." << endl << endl;
            return kFALSE;
          }
      }

    //
    // If MCalibrationCam already existed in the parameter list before
    // MMcCalibrationUpdate::PreProcess was executed (from a 
    // previous calibration loop) we must not fill it, hence nothing
    // else has to be done in ReInit:
    //
    if ( !fFillCalibrationCam )
      return kTRUE;

    //
    // Set the ADC to photons conversion factor for outer pixels:
    //
    fADC2PhOuter = fADC2PhInner * (fAmplitude / fAmplitudeOuter);

    const int num = fCalCam->GetSize();

    fCalCam->SetBlindPixelMethodValid(kTRUE);

    for (int i=0; i<num; i++)
    {
        MCalibrationPix &calpix = (*fCalCam)[i];

        calpix.SetBlindPixelMethodValid();
        calpix.SetFitValid();

        calpix.SetConversionHiLo(fConversionHiLo);
        calpix.SetConversionHiLoError(0.);         // FIXME ?

        //
        // Write conversion factor ADC to photons (different for inner
        // and outer pixels).
        //

        Float_t adc2phot = (fGeom->GetPixRatio(i) < fGeom->GetPixRatio(0))?
          fADC2PhOuter : fADC2PhInner;

        calpix.SetConversionBlindPixelMethod(adc2phot, 0., 0.);
    }


    return kTRUE;
}


// --------------------------------------------------------------------------
//
// Fill the MCerPhotPed object
//
Int_t MMcCalibrationUpdate::Process()
{
    const int num = fCalCam->GetSize();

    for (int i=0; i<num; i++)
    {
        MExtractedSignalPix &sigpix = (*fSignalCam)[i];

        //
        // ped mean and rms per pixel, in ADC counts, according to signal 
        // calculation (hi or low gain and number of integrated slices):
        //
        const Float_t pedestmean = sigpix.IsLoGainUsed()? 
          fSignalCam->GetNumUsedLoGainFADCSlices()*fHeaderFadc->GetPedestal(i) : 
          fSignalCam->GetNumUsedHiGainFADCSlices()*fHeaderFadc->GetPedestal(i);

        //
        // In some cases, depending on the camera simulation parameters, one can
        // have very little or no noise in the FADC. In the case the rms of  
        // pedestal is zero, the pixel will be cleaned out later in the image
        // cleaning. To avoid this problem,we set a default value of 0.01 ADC
        // counts for the RMS per slice:
        //

        const Float_t pedestrms  = sigpix.IsLoGainUsed()? 
          sqrt((Double_t)(fSignalCam->GetNumUsedLoGainFADCSlices())) * 
          (fHeaderFadc->GetPedestalRmsLow(i)>0.? fHeaderFadc->GetPedestalRmsLow(i): 0.01)
          : 
          sqrt((Double_t)(fSignalCam->GetNumUsedHiGainFADCSlices())) * 
          (fHeaderFadc->GetPedestalRmsHigh(i)>0.? fHeaderFadc->GetPedestalRmsHigh(i) : 0.01);

        //
        // Write mean pedestal and pedestal rms per pixel
        // in number of photons:
        //
        MPedPhotPix &pedpix = (*fPedPhotCam)[i];

        MCalibrationPix &calpix = (*fCalCam)[i];
        Float_t adc2phot = calpix.GetMeanConversionBlindPixelMethod();
        Float_t hi2lo    = calpix.GetConversionHiLo();

        if (sigpix.IsLoGainUsed())
          pedpix.Set(adc2phot*hi2lo*pedestmean, 
                     adc2phot*hi2lo*pedestrms);
        else
          pedpix.Set(adc2phot*pedestmean, adc2phot*pedestrms);

    }

    return kTRUE;
}