cmpFDEvent.cc

Go to the documentation of this file.

#include "cmpFDEvent.h"

#include <iostream>
#include <iomanip>
#include <sstream>
#include <string>
#include <map>

#include <TFile.h>
#include <TDirectory.h>

#include <adst/RecEventFile.h>
#include <adst/DetectorGeometry.h>
#include <adst/FileInfo.h>
#include <adst/RecEvent.h>
#include <adst/FDEvent.h>
#include <adst/FdRecPixel.h>
#include <adst/FdGenGeometry.h>
#include <adst/FdGenApertureLight.h>
#include <adst/FdRecStation.h>

#include "testlib.h"
#include "adstReading.h"

#define IS(x,prefix) is(test.x, ref.x, prefix"."#x)
#define ISDIAG(x,prefix) isDiag(test.x, ref.x, prefix"."#x)
#define ISEPSDIAG(x,eps,prefix) isEpsDiag(test.x, ref.x, eps, prefix"."#x)

using namespace std;

void
cmpFDEvent(const FDEvent& ref, const FDEvent& test)
{
  isDiag(test.GetEventClass(), ref.GetEventClass(), "FDEvent.GetEventClass");
  isDiag(test.GetEventId(), ref.GetEventId(), "FDEvent.GetEventId");
  isDiag(test.GetEventType(), ref.GetEventType(), "FDEvent.GetEventType");
  isDiag(test.GetEyeId(), ref.GetEyeId(), "FDEvent.GetEyeId");

  cmpFDRecAPLight(ref.GetFdRecApertureLight(), test.GetFdRecApertureLight());
  // GetFdRecApertureLightTel is below
  cmpFDRecGeometry(ref.GetFdRecGeometry(), test.GetFdRecGeometry());
  cmpFDRecPixel(ref.GetFdRecPixel(), test.GetFdRecPixel());
  cmpFDRecShower(ref.GetFdRecShower(), test.GetFdRecShower());
  cmpFDGenAPLight(ref.GetGenApertureLight(), test.GetGenApertureLight());
  // GetGenApertureLightTel is below
  cmpFDGenGeometry(ref.GetGenGeometry(), test.GetGenGeometry());
  cmpFDGenShower(ref.GetGenShower(), test.GetGenShower());

  ISDIAG(GetGPSNanoSecond(),"FDEvent");
  ISDIAG(GetGPSSecond(),"FDEvent");
  ISDIAG(GetHHMMSS(),"FDEvent");
  ISDIAG(GetHottestMirrorId(),"FDEvent");
  ISDIAG(GetMirrorsInEvent(),"FDEvent");
  ISDIAG(GetMirrorsInEye(),"FDEvent");
  // GetMirrorTimeOffset is below
  // GetMirrorTimeOffsets can be skipped
  ISDIAG(GetMoonCycle(),"FDEvent");
  ISDIAG(GetRecLevel(),"FDEvent");
  ISDIAG(GetRunId(),"FDEvent");
  // GetSdRecGeometry can be skipped
  // GetStation can be skipped
  ISDIAG(GetStationVector().size(),"FDEvent");
  for (unsigned int iStation=0;
       iStation < min(ref.GetStationVector().size(),test.GetStationVector().size());
       ++iStation)
    cmpFDRecStation(test.GetStationVector()[iStation], ref.GetStationVector()[iStation]);
  ISDIAG(GetT3Azimuth(),"FDEvent");
  ISDIAG(GetT3NPixels(),"FDEvent");
  ISDIAG(GetT3SDPTheta(),"FDEvent");
  ISDIAG(GetT3TimeAtGround(),"FDEvent");
  // GetTLTLabel is below
  ISDIAG(GetXmaxInFOVTelId(),"FDEvent");
  ISDIAG(GetXmaxPixel(),"FDEvent");
  ISDIAG(GetYYMMDD(),"FDEvent");
  // HasFdGenApertureLightTel is below
  // HasFdRecApertureLightTel is below
  IS(HasT3Reconstruction(),"FDEvent");
  IS(IsHybridEvent(),"FDEvent");
  // IsXmaxInTelFOV is below
  // MirrorIsInEvent is below

  // loop over telescopes
  for (unsigned int iTel = 0; iTel < 10; ++iTel) {
    ostringstream msg;
    msg << "(" << iTel << ")";

    if (ref.HasTelescopeData(iTel))
    {
      const FdTelescopeData& refT = ref.GetTelescopeData(iTel);
      if (ok(test.HasTelescopeData(iTel), string("FDEvent.HasTelescopeData")+msg.str()))
      {
        const FdTelescopeData& testT = test.GetTelescopeData(iTel);
        diag(string("Testing FdRecApertureLightTel")+msg.str());
        cmpFDRecAPLight(refT.GetRecApertureLight(), testT.GetRecApertureLight());
        is(test.IsXmaxInTelFOV(iTel),ref.IsXmaxInTelFOV(iTel),"FDEvent.IsXmaxInTelFOV"+msg.str());
        diag(string("Testing GenApertureLightTel")+msg.str());
        cmpFDGenAPLight(refT.GetGenApertureLight(), testT.GetGenApertureLight());
      }
    }

    if (ref.HasTLT(iTel))
    {
      if (ok(test.HasTLT(iTel), "FDEvent.HasTLT"+msg.str()))
      {
        isDiag(test.GetTLTLabel(iTel),ref.GetTLTLabel(iTel),"FDEvent.GetTLTLabel"+msg.str());
      }
    }

    if (ref.MirrorIsInEvent(iTel))
    {
      if (ok(test.MirrorIsInEvent(iTel), "FDEvent.MirrorIsInEvent"+msg.str()))
      {
        isDiag(test.GetMirrorTimeOffset(iTel),ref.GetMirrorTimeOffset(iTel),"FDEvent.GetMirrorTimeOffset"+msg.str());
      }
    }
  }
}


void
cmpFDRecShower(const FdRecShower& ref, const FdRecShower& test)
{
  isDiag(test.GetAngTrackObs(), ref.GetAngTrackObs(), "FdRecShower.GetAngTrackObs");
  isDiag(test.GetAngularVelocity(), ref.GetAngularVelocity(), "FdRecShower.GetAngularVelocity");
  isEpsDiag(test.GetCherenkovFraction(), ref.GetCherenkovFraction(), 1.e-8, "FdRecShower.GetCherenkovFraction");

//test.GetCombineddEdXProfile()

  isEpsDiag(test.GetCoreXmaxDist(), ref.GetCoreXmaxDist(), 1.e-6, "FdRecShower.GetCoreXmaxDist");
  isEpsDiag(test.GetCoreEastingError(), ref.GetCoreEastingError(), 1.e-6, "FdRecShower.GetCoreEastingError");
  isEpsDiag(test.GetCoreNorthingEastingCorrelation(), ref.GetCoreNorthingEastingCorrelation(), 1.e-6, "FdRecShower.GetCoreNorthingEastingCorrelation");
  isEpsDiag(test.GetCoreNorthingError(), ref.GetCoreNorthingError(), 1.e-5, "FdRecShower.GetCoreNorthingError");
  isEpsDiag(test.GetCosZenithError(), ref.GetCosZenithError(), 1.e-8, "FdRecShower.GetCosZenithError");
  isEpsDiag(test.GetCoreSiteCS(), ref.GetCoreSiteCS(), 1e-7, "FdRecShower.GetCoreSiteCS");
  isDiag(test.GetCoreTimeNanoSecond(), ref.GetCoreTimeNanoSecond(), "FdRecShower.GetCoreTimeNanoSecond");
  isDiag(test.GetCoreTimeSecond(), ref.GetCoreTimeSecond(), "FdRecShower.GetCoreTimeSecond");
  isEpsDiag(test.GetCoreUTMCS(), ref.GetCoreUTMCS(), 1e-7, "FdRecShower.GetCoreUTMCS");
  isEpsDiag(test.GetCosZenith(), ref.GetCosZenith(), 1.e-9, "FdRecShower.GetCosZenith");

  isRelEpsDiag(test.GetDepth(), ref.GetDepth(), 1.e-7, "FdRecShower.GetDepth");
  isRelEpsDiag(test.GetDepthError(), ref.GetDepthError(), 1.e-7, "FdRecShower.GetDepthError");
  isRelEpsDiag(test.GetElectrons(), ref.GetElectrons(), 1.e-6, "FdRecShower.GetElectrons");
  isRelEpsDiag(test.GetElectronsError(), ref.GetElectronsError(), 1.e-8, "FdRecShower.GetElectronsError");
  isRelEpsDiag(test.GetEnergyDeposit(), ref.GetEnergyDeposit(), 1.e-7, "FdRecShower.GetEnergyDeposit");
  isRelEpsDiag(test.GetEnergyDepositError(), ref.GetEnergyDepositError(), 1.e-7, "FdRecShower.GetEnergyDepositError");

  isDiag(test.GetDepthVelocity(), ref.GetDepthVelocity(), "FdRecShower.GetDepthVelocity");
  isEpsDiag(test.GetDistXmax(), ref.GetDistXmax(), 1.e-6, "FdRecShower.GetDistXmax");

  // GH fit
  isRelEpsDiag(test.GetGHChi2(), ref.GetGHChi2(), 1.e-7, "FdRecShower.GetGHChi2");
  isDiag(test.GetGHNdf(), ref.GetGHNdf(), "FdRecShower.GetGHNdf");
  isRelEpsDiag(test.GetX0(), ref.GetX0(), 1.e-7, "FdRecShower.GetX0");
  isRelEpsDiag(test.GetX0Error(), ref.GetX0Error(), 1.e-7, "FdRecShower.GetX0Error");
  isRelEpsDiag(test.GetXmax(), ref.GetXmax(), 1.e-7, "FdRecShower.GetXmax");
  isRelEpsDiag(test.GetXmaxError(), ref.GetXmaxError(), 1.e-7, "FdRecShower.GetXmaxError");
  isRelEpsDiag(test.GetXmaxChi(), ref.GetXmaxChi(), 1.e-7, "FdRecShower.GetXmaxChi");
  isRelEpsDiag(test.GetXmaxChiError(), ref.GetXmaxChiError(), 1.e-7, "FdRecShower.GetXmaxChiError");
  isRelEpsDiag(test.GetLambda(), ref.GetLambda(), 1.e-7, "FdRecShower.GetLambda");
  isRelEpsDiag(test.GetLambdaError(), ref.GetLambdaError(), 1.e-7, "FdRecShower.GetLambdaError");
  isRelEpsDiag(test.GetdEdXmax(), ref.GetdEdXmax(), 1.e-7, "FdRecShower.GetdEdXmax");
  isRelEpsDiag(test.GetdEdXmaxError(), ref.GetdEdXmaxError(), 1.e-7, "FdRecShower.GetdEdXmaxError");

  isRelEpsDiag(test.GetHeight(), ref.GetHeight(), 1.e-7, "FdRecShower.GetHeight");
  isRelEpsDiag(test.GetHeightXmax(), ref.GetHeightXmax(), 1.e-7, "FdRecShower.GetHeightXmax");

  isDiag(test.GetMaxAngle(), ref.GetMaxAngle(), "FdRecShower.GetMaxAngle");
  isDiag(test.GetMeanAngle(), ref.GetMeanAngle(), "FdRecShower.GetMeanAngle");
  isDiag(test.GetMinAngle(), ref.GetMinAngle(), "FdRecShower.GetMinAngle");
  isEpsDiag(test.GetMinViewingAngles(), ref.GetMinViewingAngles(), 1.e-12, "FdRecShower.GetMinViewingAngles");

  isEpsDiag(test.GetMieAttXmax(), ref.GetMieAttXmax(), 1.e-9, "FdRecShower.GetMieAttXmax");
  isEpsDiag(test.GetAttXmax(), ref.GetAttXmax(), 1.e-9, "FdRecShower.GetAttXmax");
  isEpsDiag(test.GetMieCorrection(), ref.GetMieCorrection(), 1.e-9, "FdRecShower.GetMieCorrection");
  isEpsDiag(test.GetRayleighAttXmax(), ref.GetRayleighAttXmax(), 1.e-9, "FdRecShower.GetRayleighAttXmax");
  isEpsDiag(test.GetRayleighCorrection(), ref.GetRayleighCorrection(), 1.e-9, "FdRecShower.GetRayleighCorrection");
  isDiag(test.GetShowerAge(), ref.GetShowerAge(), "FdRecShower.GetShowerAge");
  isDiag(test.GetTimTrackObs(), ref.GetTimTrackObs(), "FdRecShower.GetTimTrackObs");
  isRelEpsDiag(test.GetTrackLength(), ref.GetTrackLength(), 1e-7, "FdRecShower.GetTrackLength");
  isRelEpsDiag(test.GetTrackLengthFOV(), ref.GetTrackLengthFOV(), 1.e-9, "FdRecShower.GetTrackLengthFOV");
  isRelEpsDiag(test.GetX1(), ref.GetX1(), 1e-7, "FdRecShower.GetX1");
  isRelEpsDiag(test.GetX1Chi(), ref.GetX1Chi(), 1e-7, "FdRecShower.GetX1Chi");
  isRelEpsDiag(test.GetX1ChiError(), ref.GetX1ChiError(), 1e-7, "FdRecShower.GetX1ChiError");
  isRelEpsDiag(test.GetX1Error(), ref.GetX1Error(), 1e-7, "FdRecShower.GetX1Error");

  isRelEpsDiag(test.GetXFOVMax(), ref.GetXFOVMax(), 1.e-7, "FdRecShower.GetXFOVMax");
  isRelEpsDiag(test.GetXFOVMin(), ref.GetXFOVMin(), 1.e-7, "FdRecShower.GetXFOVMin");
  isRelEpsDiag(test.GetXTrackMax(), ref.GetXTrackMax(), 1.e-7, "FdRecShower.GetXTrackMax");
  isRelEpsDiag(test.GetXTrackMin(), ref.GetXTrackMin(), 1.e-7, "FdRecShower.GetXTrackMin");
  isRelEpsDiag(test.GetXTrackMinChi(), ref.GetXTrackMinChi(), 1.e-7, "FdRecShower.GetXTrackMinChi");
  isRelEpsDiag(test.GetZVector(), ref.GetZVector(), 1.e-7, "FdRecShower.GetZVector");
  isRelEpsDiag(test.GetZXmax(), ref.GetZXmax(), 1.e-7, "FdRecShower.GetZXmax");

  isEpsDiag(test.GetAxisCoreCS(), ref.GetAxisCoreCS(), 1.e-7, "FdRecShower.GetAxisCoreCS");
  isEpsDiag(test.GetAxisSiteCS(), ref.GetAxisSiteCS(), 1.e-7, "FdRecShower.GetAxisSiteCS");
  isRelEpsDiag(test.GetAzimuth(), ref.GetAzimuth(), 1.e-9, "FdRecShower.GetAzimuth");
  isRelEpsDiag(test.GetAzimuthError(), ref.GetAzimuthError(), 1.e-9, "FdRecShower.GetAzimuthError");
  isRelEpsDiag(test.GetZenith(), ref.GetZenith(), 1.e-9, "FdRecShower.GetZenith");
  isRelEpsDiag(test.GetZenithError(), ref.GetZenithError(), 1.e-9, "FdRecShower.GetZenithError");
  isRelEpsDiag(test.GetZenithAzimuthCorrelation(), ref.GetZenithAzimuthCorrelation(), 1.e-9, "FdRecShower.GetZenithAzimuthCorrelation");

  isRelEpsDiag(test.GetGalacticLatitudeError(), ref.GetGalacticLatitudeError(), 1.e-7, "FdRecShower.GetGalacticLatitudeError");
  isRelEpsDiag(test.GetGalacticLatitude(), ref.GetGalacticLatitude(), 1.e-7, "FdRecShower.GetGalacticLatitude");
  isRelEpsDiag(test.GetGalacticLongitude(), ref.GetGalacticLongitude(), 1.e-7, "FdRecShower.GetGalacticLongitude");
  isRelEpsDiag(test.GetGalacticLongitudeError(), ref.GetGalacticLongitudeError(), 1.e-7, "FdRecShower.GetGalacticLongitudeError");
  isRelEpsDiag(test.GetLongLatCorrelation(), ref.GetLongLatCorrelation(), 1.e-7, "FdRecShower.GetLongLatCorrelation");
  isRelEpsDiag(test.GetDeclinationError(), ref.GetDeclinationError(), 1.e-7, "FdRecShower.GetDeclinationError");
  isRelEpsDiag(test.GetDeclination(), ref.GetDeclination(), 1.e-7, "FdRecShower.GetDeclination");
  isRelEpsDiag(test.GetRDCorrelation(), ref.GetRDCorrelation(), 1.e-7, "FdRecShower.GetRDCorrelation");
  isRelEpsDiag(test.GetRightAscension(), ref.GetRightAscension(), 1.e-7, "FdRecShower.GetRightAscension");
  isRelEpsDiag(test.GetRightAscensionError(), ref.GetRightAscensionError(), 1.e-7, "FdRecShower.GetRightAscensionError");

  isRelEpsDiag(test.GetLinearProfileFitChi2(), ref.GetLinearProfileFitChi2(), 1.e-7, "FdRecShower.GetLinearProfileFitChi2");

  isRelEpsDiag(test.GetCalorimetricEnergy(), ref.GetCalorimetricEnergy(), 1.e-7, "FdRecShower.GetCalorimetricEnergy");
  isRelEpsDiag(test.GetCalorimetricEnergyError(), ref.GetCalorimetricEnergyError(), 1.e-7, "FdRecShower.GetCalorimetricEnergyError");
  isRelEpsDiag(test.GetEnergyAtmError(), ref.GetEnergyAtmError(), 1.e-7, "FdRecShower.GetEnergyAtmError");
  isRelEpsDiag(test.GetEnergyError(), ref.GetEnergyError(), 1.e-7, "FdRecShower.GetEnergyError");
  isRelEpsDiag(test.GetEnergy(), ref.GetEnergy(), 1.e-7, "FdRecShower.GetEnergy");
}

void
cmpFDRecGeometry(const FdRecGeometry& ref, const FdRecGeometry& test)
{
  // SDP
  isDiag(test.GetSDPChi2(), ref.GetSDPChi2(), "FdRecGeo.GetSDPChi2");
  isDiag(test.GetSDPNdF(), ref.GetSDPNdF(), "FdRecGeo.GetSDPNdF");
  isDiag(test.GetSDPPhiError(), ref.GetSDPPhiError(), "FdRecGeo.GetSDPPhiError");
  isDiag(test.GetSDPPhi(), ref.GetSDPPhi(), "FdRecGeo.GetSDPPhi");
  isDiag(test.GetSDPTheta(), ref.GetSDPTheta(), "FdRecGeo.GetSDPTheta");
  isDiag(test.GetSDPThetaError(), ref.GetSDPThetaError(), "FdRecGeo.GetSDPThetaError");
  isDiag(test.GetSDPThetaPhiCorrelation(), ref.GetSDPThetaPhiCorrelation(), "FdRecGeo.GetSDPThetaPhiCorrelation");
  is(test.GetSDP(), ref.GetSDP(), "FdRecGeo.GetSDP");

  isDiag(test.GetChi0(), ref.GetChi0(), "FdRecGeo.GetChi0");
  isDiag(test.GetChi0Error(), ref.GetChi0Error(), "FdRecGeo.GetChi0Error");
  isDiag(test.GetRp(), ref.GetRp(), "FdRecGeo.GetRp");
  isDiag(test.GetRpError(), ref.GetRpError(), "FdRecGeo.GetRpError");
  isDiag(test.GetT0Error(), ref.GetT0Error(), "FdRecGeo.GetT0Error");
  isDiag(test.GetT0(), ref.GetT0(), "FdRecGeo.GetT0");
  isDiag(test.GetRpT0Correlation(), ref.GetRpT0Correlation(), "FdRecGeo.GetRpT0Correlation");
  isDiag(test.GetChi0RpCorrelation(), ref.GetChi0RpCorrelation(), "FdRecGeo.GetChi0RpCorrelation");
  isDiag(test.GetChi0T0Correlation(), ref.GetChi0T0Correlation(), "FdRecGeo.GetChi0T0Correlation");
  isRelEpsDiag(test.GetTimeFitChi2(), ref.GetTimeFitChi2(), 1.e-7, "FdRecGeo.GetTimeFitChi2");
  isEpsDiag(test.GetTimeFitFDChi2(), ref.GetTimeFitFDChi2(), 1.e-6, "FdRecGeo.GetTimeFitFDChi2");
  isDiag(test.GetTimeFitNdof(), ref.GetTimeFitNdof(), "FdRecGeo.GetTimeFitNdof");

  isRelEpsDiag(test.GetCoreEyeDistanceError(), ref.GetCoreEyeDistanceError(), 1.e-7, "FdRecGeo.GetCoreEyeDistanceError");
  isRelEpsDiag(test.GetCoreEyeDistance(), ref.GetCoreEyeDistance(), 1.e-7, "FdRecGeo.GetCoreEyeDistance");

  isDiag(test.GetHottestStation(), ref.GetHottestStation(), "FdRecGeo.GetHottestStation");
  isDiag(test.GetNHybridStations(), ref.GetNHybridStations(), "FdRecGeo.GetNHybridStations");
  isRelEpsDiag(test.GetSDFDTimeOffset(), ref.GetSDFDTimeOffset(), 1.e-7, "FdRecGeo.GetSDFDTimeOffset");
  isRelEpsDiag(test.GetStationAxisDistance(), ref.GetStationAxisDistance(), 1.e-7, "FdRecGeo.GetStationAxisDistance");
  isRelEpsDiag(test.GetStationSDPDistance(), ref.GetStationSDPDistance(), 1.e-7, "FdRecGeo.GetStationSDPDistance");

  isRelEpsDiag(test.GetLinearTimeFitChi2(), ref.GetLinearTimeFitChi2(), 1.e-7, "FdRecGeo.GetLinearTimeFitChi2");
}

void
cmpFDRecAPLight(const FdRecApertureLight& ref, const FdRecApertureLight& test)
{
  isDiag(test.GetCherLightCollEfficiency(), ref.GetCherLightCollEfficiency(), "FdRecApertureLight.GetCherLightCollEfficiency");
  isDiag(test.GetCherLightCollEfficiencyErrors(), ref.GetCherLightCollEfficiencyErrors(), "FdRecApertureLight.GetCherLightCollEfficiencyErrors");
  isDiag(test.GetFluorLightCollEfficiency(), ref.GetFluorLightCollEfficiency(), "FdRecApertureLight.GetFluorLightCollEfficiency");
  isDiag(test.GetFluorLightCollEfficiencyErrors(), ref.GetFluorLightCollEfficiencyErrors(), "FdRecApertureLight.GetFluorLightCollEfficiencyErrors");
  isDiag(test.GetMieCherLightCollEfficiency(), ref.GetMieCherLightCollEfficiency(), "FdRecApertureLight.GetMieCherLightCollEfficiency");
  isDiag(test.GetMieCherLightCollEfficiencyErrors(), ref.GetMieCherLightCollEfficiencyErrors(), "FdRecApertureLight.GetMieCherLightCollEfficiencyErrors");
  isDiag(test.GetRayCherLightCollEfficiency(), ref.GetRayCherLightCollEfficiency(), "FdRecApertureLight.GetRayCherLightCollEfficiency");
  isDiag(test.GetRayCherLightCollEfficiencyErrors(), ref.GetRayCherLightCollEfficiencyErrors(), "FdRecApertureLight.GetRayCherLightCollEfficiencyErrors");
  isDiag(test.GetTimeError(), ref.GetTimeError(), "FdRecApertureLight.GetTimeError");
  isDiag(test.GetTotalLightAtApertureError(), ref.GetTotalLightAtApertureError(), "FdRecApertureLight.GetTotalLightAtApertureError");
  isDiag(test.GetTotalLightIntegral(), ref.GetTotalLightIntegral(), "FdRecApertureLight.GetTotalLightIntegral");
  isDiag(test.GetTotalLightIntegralError(), ref.GetTotalLightIntegralError(), "FdRecApertureLight.GetTotalLightIntegralError");
  isDiag(test.GetZeta(), ref.GetZeta(), "FdRecApertureLight.GetZeta");
  isEpsDiag(test.GetCherLightAtAperture(), ref.GetCherLightAtAperture(), 1.e-5, "FdRecApertureLight.GetCherLightAtAperture");
  isEpsDiag(test.GetFluorLightAtAperture(), ref.GetFluorLightAtAperture(), 1.e-5, "FdRecApertureLight.GetFluorLightAtAperture");
  isEpsDiag(test.GetMieCherLightAtAperture(), ref.GetMieCherLightAtAperture(), 1.e-5, "FdRecApertureLight.GetMieCherLightAtAperture");
  isEpsDiag(test.GetMultScatCherLightAtAperture(), ref.GetMultScatCherLightAtAperture(), 1.e-5, "FdRecApertureLight.GetMultScatCherLightAtAperture");
  isEpsDiag(test.GetMultScatFluorLightAtAperture(), ref.GetMultScatFluorLightAtAperture(), 1.e-5, "FdRecApertureLight.GetMultScatFluorLightAtAperture");
  isDiag(test.GetNumberTimePoints(), ref.GetNumberTimePoints(), "FdRecApertureLight.GetNumberTimePoints");
  isEpsDiag(test.GetRayCherLightAtAperture(), ref.GetRayCherLightAtAperture(), 1.e-6, "FdRecApertureLight.GetRayCherLightAtAperture");
  isDiag(test.GetTotalLightAtAperture(), ref.GetTotalLightAtAperture(), "FdRecApertureLight.GetTotalLightAtAperture");
  isDiag(test.GetTime(), ref.GetTime(), "FdRecApertureLight.GetTime");
}

void
cmpFDGenAPLight(const FdGenApertureLight& ref, const FdGenApertureLight& test)
{
  ISDIAG(GetCherLightAtAperture(), "FdGenAperture");
  ISDIAG(GetFluorLightAtAperture(), "FdGenAperture");
  // GetLightFluxSum can be skipped
  // GetLightFluxSumVector can be skipped
  ISEPSDIAG(GetLightFraction(FdApertureLight::eUnknown), 1.e-8, "FdGenAperture");
  ISEPSDIAG(GetLightFraction(FdApertureLight::eTotalCherenkov), 1.e-8, "FdGenAperture");
  ISEPSDIAG(GetLightFraction(FdApertureLight::eDirect), 1.e-8, "FdGenAperture");
  ISEPSDIAG(GetLightFraction(FdApertureLight::eMie), 1.e-8, "FdGenAperture");
  ISEPSDIAG(GetLightFraction(FdApertureLight::eRayleigh), 1.e-8, "FdGenAperture");
  ISEPSDIAG(GetLightFraction(FdApertureLight::eScattered), 1.e-8, "FdGenAperture");
  ISEPSDIAG(GetLightFraction(FdApertureLight::eFluorescence), 1.e-8, "FdGenAperture");
  ISDIAG(GetMieCherLightAtAperture(), "FdGenAperture");
  ISDIAG(GetMultScatCherLightAtAperture(), "FdGenAperture");
  ISDIAG(GetMultScatFluorLightAtAperture(), "FdGenAperture");
  ISDIAG(GetNumberTimePoints(),"FdGenAperture");
  ISDIAG(GetRayCherLightAtAperture(),"FdGenAperture");
  ISDIAG(GetTime(),"FdGenAperture");
  ISDIAG(GetTotalLightAtAperture(),"FdGenAperture");
  IS(HasMultipleScatteredLight(),"FdGenAperture");
}

void
cmpFDRecPixel(const FdRecPixel& ref, const FdRecPixel& test)
{
  // GetCalibrationConstant is below
  // GetCharge(i) can be skipped
  ISDIAG(GetCharge(),"FdRecPixel");
  // GetChi(i) can be skipped
  ISDIAG(GetChi(),"FdRecPixel");
  // GetID(i) can be skipped
  ISDIAG(GetID(),"FdRecPixel");
  ISDIAG(GetMeanADCRMS(),"FdRecPixel");
  ISDIAG(GetMeanPixelRMS(),"FdRecPixel");
  ISDIAG(GetMeanThreshold(),"FdRecPixel");
  // GetNumberOfPixels is below
  ISDIAG(GetNumberOfPulsedPixels(),"FdRecPixel");
  ISDIAG(GetNumberOfSDPFitPixels(),"FdRecPixel");
  ISDIAG(GetNumberOfSpotTracePixels(),"FdRecPixel");
  ISDIAG(GetNumberOfTimeFitPixels(),"FdRecPixel");
  ISDIAG(GetNumberOfTracePixels(),"FdRecPixel");
  ISDIAG(GetNumberOfTriggeredPixels(),"FdRecPixel");
  // GetPixelId is below
  // GetPulseStart is below
  // GetPulseStop is below
  // GetRMS is below
  // GetSimTrace is below
  // GetSimTraceOffset is below
  // GetSpotRecTrace is below
  // GetSpotRecTraceMax can be skipped
  // GetSpotRecTraceSum can be skipped
  // GetStatus(i) can be skipped
  ISDIAG(GetStatus(),"FdRecPixel");
  // GetTelescopeId is below
  // GetThreshold is below
  // GetTime(i) can be skipped
  ISDIAG(GetTime(),"FdRecPixel");
  // GetTimeErr(i) can be skipped
  ISDIAG(GetTimeErr(),"FdRecPixel");
  // GetTrace is below
  // GetTraceMax can be skipped
  // GetTraces can be skipped
  // GetTraceSum can be skipped
  // HasADCTrace is below
  ISDIAG(HasHighGainSaturatedPixels(),"FdRecPixel");
  ISDIAG(HasLowGainSaturatedPixels(),"FdRecPixel");
  ISDIAG(HasSaturationRecoveredPixels(),"FdRecPixel");
  // HasSimTrace is below
  // HasSpotRecADCTrace is below

  ISDIAG(GetNumberOfPixels(),"FdRecPixel");
  unsigned int size = min(ref.GetNumberOfPixels(),test.GetNumberOfPixels());
  for (unsigned int i=0;i<size;++i)
  {
    ISDIAG(GetCalibrationConstant(i),"FdRecPixel");
    ISDIAG(GetPixelId(i),"FdRecPixel");
    ISDIAG(GetTelescopeId(i),"FdRecPixel");
    ISDIAG(GetThreshold(i),"FdRecPixel");
    ISDIAG(GetPulseStart(i),"FdRecPixel");
    ISDIAG(GetPulseStop(i),"FdRecPixel");
    ISDIAG(GetRMS(i),"FdRecPixel");

    if (ref.HasSimTrace(i,FdApertureLight::eUnknown))
      if (ok(test.HasSimTrace(i,FdApertureLight::eUnknown)),"FdRecPixel.HasSimTrace(eUnknown)")
        ISDIAG(GetSimTrace(i,FdApertureLight::eUnknown),"FdRecPixel");
    if (ref.HasSimTrace(i,FdApertureLight::eTotalCherenkov))
      if (ok(test.HasSimTrace(i,FdApertureLight::eTotalCherenkov)),"FdRecPixel.HasSimTrace(eTotalCherenkov)")
        ISDIAG(GetSimTrace(i,FdApertureLight::eTotalCherenkov),"FdRecPixel");
    if (ref.HasSimTrace(i,FdApertureLight::eDirect))
      if (ok(test.HasSimTrace(i,FdApertureLight::eDirect)),"FdRecPixel.HasSimTrace(eDirect)")
        ISDIAG(GetSimTrace(i,FdApertureLight::eDirect),"FdRecPixel");
    if (ref.HasSimTrace(i,FdApertureLight::eMie))
      if (ok(test.HasSimTrace(i,FdApertureLight::eMie)),"FdRecPixel.HasSimTrace(eMie)")
        ISDIAG(GetSimTrace(i,FdApertureLight::eMie),"FdRecPixel");
    if (ref.HasSimTrace(i,FdApertureLight::eRayleigh))
      if (ok(test.HasSimTrace(i,FdApertureLight::eRayleigh)),"FdRecPixel.HasSimTrace(eRayleigh)")
        ISDIAG(GetSimTrace(i,FdApertureLight::eRayleigh),"FdRecPixel");
    if (ref.HasSimTrace(i,FdApertureLight::eScattered))
      if (ok(test.HasSimTrace(i,FdApertureLight::eScattered)),"FdRecPixel.HasSimTrace(eScattered)")
        ISDIAG(GetSimTrace(i,FdApertureLight::eScattered),"FdRecPixel");
    if (ref.HasSimTrace(i,FdApertureLight::eFluorescence))
      if (ok(test.HasSimTrace(i,FdApertureLight::eFluorescence)),"FdRecPixel.HasSimTrace(eFluorescence)")
        ISDIAG(GetSimTrace(i,FdApertureLight::eFluorescence),"FdRecPixel");

    if (ref.HasADCTrace(i) && ok(test.HasADCTrace(i),"FdRecPixel.HasADCTrace"))
    {
      ISDIAG(GetTrace(i),"FdRecPixel");
      ISDIAG(IsHighGainSaturated(i),"FdRecPixel");
      ISDIAG(IsLowGainSaturated(i),"FdRecPixel");
      ISDIAG(IsSaturationRecovered(i),"FdRecPixel");
    }
    else {
      ok(!test.HasADCTrace(i), "!FdRecPixel.HasADCTrace (reference doesn't have one)");
    }

    if (ref.HasSpotRecADCTrace(i) && ok(test.HasSpotRecADCTrace(i),"FdRecPixel.HasSpotRecADCTrace"))
    {
      ISDIAG(GetSpotRecTrace(i),"FdRecPixel");
    }
    else {
      ok(!test.HasSpotRecADCTrace(i), "!FdRecPixel.HasSpotRecADCTrace (reference doesn't have one)");
    }

    ISDIAG(GetSimTraceOffset(i),"FdRecPixel");
    ISDIAG(GetStatus(i),"FdRecPixel");
  }
}

void
cmpFDGenGeometry(const FdGenGeometry& ref, const FdGenGeometry& test)
{
}

void
cmpFDGenShower(const FdGenShower& ref, const FdGenShower& test)
{
}

void
cmpFDRecStation(const FdRecStation& ref, const FdRecStation& test)
{
}