ShowerRRecData.cc

Go to the documentation of this file.

// includes for LameShadowPtr dependencies first
#include <evt/ShowerScintillatorRecData.h>
#include <evt/ShowerMRecData.h>
#include <evt/ShowerUnivRecData.h>
#include <AugerEvent.h>
#include <cevt/CEvent.h>
#include <mevt/MEvent.h>
#include <revt/Header.h>
#include <revt/EventTrigger.h>
#include <revt/REvent.h>
#include <sevt/Meteo.h>
#include <sevt/EventTrigger.h>

#include <sevt/SEvent.h>
#include <evt/ShowerRRecData.h>

#include <evt/ShowerRecData.h>
#include <evt/ShowerSRecData.h>
#include <evt/ShowerFRecData.h>
#include <evt/ShowerSimData.h>
#include <evt/LaserData.h>
#include <evt/RadioSimulation.h>

#include <fevt/FEvent.h>
#include <fevt/FdComponentSelector.h>
#include <fevt/Eye.h>
#include <fevt/EyeRecData.h>

#include <utl/AugerException.h>
#include <utl/ErrorLogger.h>
#include <utl/TabulatedFunctionErrors.h>
#include <utl/Math.h>
#include <utl/AnalyticCoordinateTransformator.h>

#include <string>

#include <utl/LameShadowPtr_imp.h>
LAMESHADOWPTR_INST(evt::ShowerRRecData);

using namespace std;
using namespace utl;
using namespace evt;
using namespace revt;


double
ShowerRRecData::GetRadius()
  const
{
  if (HasParameter(eShowerAxisX) &&
      HasParameter(eShowerAxisY) &&
      HasParameter(eShowerAxisZ)) {
    return
      AnalyticCoordinateTransformator::GetRadiusFromCartesianCoordinates(
        GetParameter(eShowerAxisX),
        GetParameter(eShowerAxisY),
        GetParameter(eShowerAxisZ)
      );
  } else {
    WARNING("ShowerRRecData::GetRadius(): Parameter eShowerAxis was not set");
    return std::numeric_limits<double>::quiet_NaN();
  }
}


double
ShowerRRecData::GetRadiusError()
  const
{
  if (HasParameter(eShowerAxisX) &&
      HasParameter(eShowerAxisY) &&
      HasParameter(eShowerAxisZ) &&
      HasParameterCovariance(eShowerAxisX, eShowerAxisX) &&
      HasParameterCovariance(eShowerAxisY, eShowerAxisY) &&
      HasParameterCovariance(eShowerAxisZ, eShowerAxisZ) &&
      HasParameterCovariance(eShowerAxisX, eShowerAxisY) &&
      HasParameterCovariance(eShowerAxisX, eShowerAxisZ) &&
      HasParameterCovariance(eShowerAxisY, eShowerAxisZ)) {
    const double covarianceRR =
      AnalyticCoordinateTransformator::GetSphericalCovarianceFromCartesian(
        0,
        0,
        GetParameter(eShowerAxisX),
        GetParameter(eShowerAxisY),
        GetParameter(eShowerAxisZ),
        GetParameterCovariance(eShowerAxisX, eShowerAxisX),
        GetParameterCovariance(eShowerAxisY, eShowerAxisY),
        GetParameterCovariance(eShowerAxisZ, eShowerAxisZ),
        GetParameterCovariance(eShowerAxisX, eShowerAxisY),
        GetParameterCovariance(eShowerAxisX, eShowerAxisZ),
        GetParameterCovariance(eShowerAxisY, eShowerAxisZ)
      );
    return sqrt(covarianceRR);
  } else {
    WARNING("ShowerRRecData::GetRadiusError(): Parameter or Covariances of eShowerAxis was not set, returning NaN");
    return std::numeric_limits<double>::quiet_NaN();
  }
}


double
ShowerRRecData::GetAzimuth()
  const
{
  if (HasParameter(eShowerAxisX) && HasParameter(eShowerAxisY)) {
    return AnalyticCoordinateTransformator::GetAzimuthFromCartesianCoordinates(GetParameter(eShowerAxisX), GetParameter(eShowerAxisY));
  } else {
    WARNING("ShowerRRecData::GetAzimuth(): Parameter eShowerAxis was not set");
    return std::numeric_limits<double>::quiet_NaN();
  }
}


double
ShowerRRecData::GetAzimuthError()
  const
{
  if (HasParameter(eShowerAxisX) &&
      HasParameter(eShowerAxisY) &&
      HasParameter(eShowerAxisZ) &&
      HasParameterCovariance(eShowerAxisX, eShowerAxisX) &&
      HasParameterCovariance(eShowerAxisY, eShowerAxisY) &&
      HasParameterCovariance(eShowerAxisZ, eShowerAxisZ) &&
      HasParameterCovariance(eShowerAxisX, eShowerAxisY) &&
      HasParameterCovariance(eShowerAxisX, eShowerAxisZ) &&
      HasParameterCovariance(eShowerAxisY, eShowerAxisZ)) {
    const double covariance22 =
      AnalyticCoordinateTransformator::GetSphericalCovarianceFromCartesian(
        2,
        2,
        GetParameter(eShowerAxisX),
        GetParameter(eShowerAxisY),
        GetParameter(eShowerAxisZ),
        GetParameterCovariance(eShowerAxisX, eShowerAxisX),
        GetParameterCovariance(eShowerAxisY, eShowerAxisY),
        GetParameterCovariance(eShowerAxisZ, eShowerAxisZ),
        GetParameterCovariance(eShowerAxisX, eShowerAxisY),
        GetParameterCovariance(eShowerAxisX, eShowerAxisZ),
        GetParameterCovariance(eShowerAxisY, eShowerAxisZ)
      );
    return sqrt(covariance22);
  } else {
    WARNING("ShowerRRecData::GetAzimuthError(): Parameter or Covariances of eShowerAxis was not set, returning NaN");
    return std::numeric_limits<double>::quiet_NaN();
  }
}


double
ShowerRRecData::GetZenith()
  const
{
  if (HasParameter(eShowerAxisX) && HasParameter(eShowerAxisY) && HasParameter(eShowerAxisZ)) {
    return
      AnalyticCoordinateTransformator::GetZenithFromCartesianCoordinates(
        GetParameter(eShowerAxisX),
        GetParameter(eShowerAxisY),
        GetParameter(eShowerAxisZ)
      );
  } else {
    WARNING("ShowerRRecData::GetZenith(): Parameter eShowerAxis was not set");
    return std::numeric_limits<double>::quiet_NaN();
  }
}


double
ShowerRRecData::GetZenithError()
  const
{
  if (HasParameter(eShowerAxisX) &&
      HasParameter(eShowerAxisY) &&
      HasParameter(eShowerAxisZ) &&
      HasParameterCovariance(eShowerAxisX, eShowerAxisX) &&
      HasParameterCovariance(eShowerAxisY, eShowerAxisY) &&
      HasParameterCovariance(eShowerAxisZ, eShowerAxisZ) &&
      HasParameterCovariance(eShowerAxisX, eShowerAxisY) &&
      HasParameterCovariance(eShowerAxisX, eShowerAxisZ) &&
      HasParameterCovariance(eShowerAxisY, eShowerAxisZ)) {
    const double covariance11 =
      AnalyticCoordinateTransformator::GetSphericalCovarianceFromCartesian(
        1,
        1,
        GetParameter(eShowerAxisX),
        GetParameter(eShowerAxisY),
        GetParameter(eShowerAxisZ),
        GetParameterCovariance(eShowerAxisX, eShowerAxisX),
        GetParameterCovariance(eShowerAxisY, eShowerAxisY),
        GetParameterCovariance(eShowerAxisZ, eShowerAxisZ),
        GetParameterCovariance(eShowerAxisX, eShowerAxisY),
        GetParameterCovariance(eShowerAxisX, eShowerAxisZ),
        GetParameterCovariance(eShowerAxisY, eShowerAxisZ)
      );
    return sqrt(covariance11);
  } else {
    WARNING("ShowerRRecData::GetZenithError(): Parameter or Covariances of eShowerAxis was not set, returning NaN");
    return std::numeric_limits<double>::quiet_NaN();
  }
}


double
ShowerRRecData::GetAzimuthPreFit()
  const
{
  if (HasParameter(ePreFitShowerAxisX) && HasParameter(ePreFitShowerAxisY)) {
    return
      AnalyticCoordinateTransformator::GetAzimuthFromCartesianCoordinates(GetParameter(ePreFitShowerAxisX), GetParameter(ePreFitShowerAxisY));
  } else {
    WARNING("ShowerRRecData::GetAzimuthPreFit(): Parameter ePreFitShowerAxis was not set");
    return std::numeric_limits<double>::quiet_NaN();
  }
}


double
ShowerRRecData::GetAzimuthPreFitError()
  const
{
  if (HasParameter(ePreFitShowerAxisX) &&
      HasParameter(ePreFitShowerAxisY) &&
      HasParameter(ePreFitShowerAxisZ) &&
      HasParameterCovariance(ePreFitShowerAxisX, ePreFitShowerAxisX) &&
      HasParameterCovariance(ePreFitShowerAxisY, ePreFitShowerAxisY) &&
      HasParameterCovariance(ePreFitShowerAxisZ, ePreFitShowerAxisZ) &&
      HasParameterCovariance(ePreFitShowerAxisX, ePreFitShowerAxisY) &&
      HasParameterCovariance(ePreFitShowerAxisX, ePreFitShowerAxisZ) &&
      HasParameterCovariance(ePreFitShowerAxisY, ePreFitShowerAxisZ)) {
    const double covariance22 =
      AnalyticCoordinateTransformator::GetSphericalCovarianceFromCartesian(
        2,
        2,
        GetParameter(ePreFitShowerAxisX),
        GetParameter(ePreFitShowerAxisY),
        GetParameter(ePreFitShowerAxisZ),
        GetParameterCovariance(ePreFitShowerAxisX, ePreFitShowerAxisX),
        GetParameterCovariance(ePreFitShowerAxisY, ePreFitShowerAxisY),
        GetParameterCovariance(ePreFitShowerAxisZ, ePreFitShowerAxisZ),
        GetParameterCovariance(ePreFitShowerAxisX, ePreFitShowerAxisY),
        GetParameterCovariance(ePreFitShowerAxisX, ePreFitShowerAxisZ),
        GetParameterCovariance(ePreFitShowerAxisY, ePreFitShowerAxisZ)
      );
    return sqrt(covariance22);
  } else {
    WARNING("ShowerRRecData::GetAzimuthPreFitError(): Parameter or Covariances of ePreFitShowerAxis was not set, returning NaN");
    return std::numeric_limits<double>::quiet_NaN();
  }
}


double
ShowerRRecData::GetZenithPreFit()
  const
{
  if (HasParameter(ePreFitShowerAxisX) && HasParameter(ePreFitShowerAxisY) && HasParameter(ePreFitShowerAxisZ)) {
    return
      AnalyticCoordinateTransformator::GetZenithFromCartesianCoordinates(
        GetParameter(ePreFitShowerAxisX),
        GetParameter(ePreFitShowerAxisY),
        GetParameter(ePreFitShowerAxisZ)
      );
  } else {
    WARNING("ShowerRRecData::GetZenithPreFit(): Parameter ePreFitShowerAxis was not set");
    return std::numeric_limits<double>::quiet_NaN();
  }
}


double
ShowerRRecData::GetZenithPreFitError()
  const
{
  if (HasParameter(ePreFitShowerAxisX) &&
      HasParameter(ePreFitShowerAxisY) &&
      HasParameter(ePreFitShowerAxisZ) &&
      HasParameterCovariance(ePreFitShowerAxisX, ePreFitShowerAxisX) &&
      HasParameterCovariance(ePreFitShowerAxisY, ePreFitShowerAxisY) &&
      HasParameterCovariance(ePreFitShowerAxisZ, ePreFitShowerAxisZ) &&
      HasParameterCovariance(ePreFitShowerAxisX, ePreFitShowerAxisY) &&
      HasParameterCovariance(ePreFitShowerAxisX, ePreFitShowerAxisZ) &&
      HasParameterCovariance(ePreFitShowerAxisY, ePreFitShowerAxisZ)) {
    const double covariance11 =
      AnalyticCoordinateTransformator::GetSphericalCovarianceFromCartesian(
        1,
        1,
        GetParameter(ePreFitShowerAxisX),
        GetParameter(ePreFitShowerAxisY),
        GetParameter(ePreFitShowerAxisZ),
        GetParameterCovariance(ePreFitShowerAxisX, ePreFitShowerAxisX),
        GetParameterCovariance(ePreFitShowerAxisY, ePreFitShowerAxisY),
        GetParameterCovariance(ePreFitShowerAxisZ, ePreFitShowerAxisZ),
        GetParameterCovariance(ePreFitShowerAxisX, ePreFitShowerAxisY),
        GetParameterCovariance(ePreFitShowerAxisX, ePreFitShowerAxisZ),
        GetParameterCovariance(ePreFitShowerAxisY, ePreFitShowerAxisZ)
      );
    return sqrt(covariance11);
  } else {
    WARNING("ShowerRRecData::GetZenithPreFitError(): Parameter or Covariances of ePreFitShowerAxis was not set, returning NaN");
    return std::numeric_limits<double>::quiet_NaN();
  }
}


utl::Point
ShowerRRecData::GetCoordinateOrigin()
  const
{
  const utl::CoordinateSystemPtr referenceCS = det::Detector::GetInstance().GetReferenceCoordinateSystem();
  if (HasParameter(revt::eCoordinateOriginX) &&
      HasParameter(revt::eCoordinateOriginY) &&
      HasParameter(revt::eCoordinateOriginZ)) {
    return utl::Point(GetParameter(revt::eCoordinateOriginX),
                      GetParameter(revt::eCoordinateOriginY),
                      GetParameter(revt::eCoordinateOriginZ),
                      referenceCS);
  } else {
    WARNING("ShowerRRecData::GetCoordinateOrigin(): Parameter eCoordinateOrigin was not set. Throwing exception...");
    throw utl::NonExistentComponentException("Tried to get an unset parameter (eCoordinateOriginX/Y/Z) from ParameterStorage.");
  }
}


bool
ShowerRRecData::HasCorePosition()
  const
{
  return (HasParameter(revt::eCoreX) &&
          HasParameter(revt::eCoreY) &&
          HasParameter(revt::eCoreZ));
}


utl::Point
ShowerRRecData::GetCorePosition()
  const
{
  const utl::CoordinateSystemPtr referenceCS = det::Detector::GetInstance().GetReferenceCoordinateSystem();
  if (HasCorePosition()) {
    return utl::Point(GetParameter(revt::eCoreX),
                      GetParameter(revt::eCoreY),
                      GetParameter(revt::eCoreZ),
                      referenceCS);
  } else {
    WARNING("ShowerRRecData::GetCorePosition(): Parameter eCore was not set. You might want to use GetReferenceCorePosition(). Throwing exception...");
    throw utl::NonExistentComponentException("Tried to get an unset parameter (eCoreX/Y/Z) from ParameterStorage.");
  }
}


utl::Vector
ShowerRRecData::GetCoreError()
  const
{
  const utl::CoordinateSystemPtr referenceCS = det::Detector::GetInstance().GetReferenceCoordinateSystem();
  if (HasParameterError(revt::eCoreX) &&
      HasParameterError(revt::eCoreY) &&
      HasParameterError(revt::eCoreZ)) {
    return utl::Vector(GetParameterError(revt::eCoreX),
                      GetParameterError(revt::eCoreY),
                      GetParameterError(revt::eCoreZ),
                      referenceCS);
  } else {
    WARNING("ShowerRRecData::GetCoreError(): Parameter eCore was not set. Throwing exception...");
    throw utl::NonExistentComponentException("Tried to get an unset parameter error (eCoreX/Y/Z) from ParameterStorage.");
  }
}


double
ShowerRRecData::GetCoreCorrelationXY()
  const
{
  const utl::CoordinateSystemPtr referenceCS = det::Detector::GetInstance().GetReferenceCoordinateSystem();
  if (HasParameterCovariance(revt::eCoreX, revt::eCoreY)) {
    return GetParameterCovariance(revt::eCoreX, revt::eCoreY);
  } else {
    WARNING("ShowerRRecData::GetCoreError(): Parameter eCore was not set. Throwing exception...");
    throw utl::NonExistentComponentException("Tried to get an unset parameter correlation (eCoreX/Y) from ParameterStorage.");
  }
}


bool
ShowerRRecData::HasAxis()
  const
{
  return (HasParameter(revt::eShowerAxisX) &&
          HasParameter(revt::eShowerAxisY) &&
          HasParameter(revt::eShowerAxisZ));
}


utl::Vector
ShowerRRecData::GetAxis()
  const
{
  const utl::CoordinateSystemPtr fgLocalCS = fwk::LocalCoordinateSystem::Create(GetCoordinateOrigin());
  if (HasAxis()) {
    return utl::Vector(GetParameter(revt::eShowerAxisX),
                       GetParameter(revt::eShowerAxisY),
                       GetParameter(revt::eShowerAxisZ),
                       fgLocalCS);
  } else {
    WARNING("ShowerRRecData::GetAxis(): Parameter eShowerAxis was not set. You might want to use GetReferenceAxis(). Throwing exception...");
    throw utl::NonExistentComponentException("Tried to get an unset parameter (eShowerAxisX/Y/Z) from ParameterStorage.");
  }
}


utl::Vector
ShowerRRecData::GetMagneticFieldVector()
  const
{
  const utl::CoordinateSystemPtr fgLocalCS = fwk::LocalCoordinateSystem::Create(GetCoordinateOrigin());
  if (HasParameter(revt::eMagneticFieldVectorX) &&
      HasParameter(revt::eMagneticFieldVectorY) &&
      HasParameter(revt::eMagneticFieldVectorZ)) {
    return utl::Vector(GetParameter(revt::eMagneticFieldVectorX),
                       GetParameter(revt::eMagneticFieldVectorY),
                       GetParameter(revt::eMagneticFieldVectorZ),
                       fgLocalCS);
  } else {
    WARNING("ShowerRRecData::GetMagneticFieldVector(): Parameter eMagneticFieldVector was not set. Throwing exception...");
    throw utl::NonExistentComponentException("Tried to get an unset parameter (eMagneticFieldVectorX/Y/Z) from ParameterStorage.");
  }
}


bool
ShowerRRecData::HasReferenceCorePosition(const Event& event)
  const
{
  if (ShowerRRecData::fReferenceCoreFlag == ShowerRRecData::eUseSDReferenceCore) {
    if (!event.GetRecShower().HasSRecShower()) {
      ERROR("No SRecShower available but SD reference core specified in the settings.");
      throw utl::NonExistentComponentException();
    } else {
      return true; // There is no logic to ask SRecShower yet implemented...
    }
  } else if (ShowerRRecData::fReferenceCoreFlag == ShowerRRecData::eUseFDReferenceCore) {
    if (!event.HasFEvent()) {
      ERROR("No FEvent available but FD reference Core specified in the settings!");
      throw utl::NonExistentComponentException();
      } else {
        const fevt::FEvent& fdEvent = event.GetFEvent();
        for (fevt::FEvent::ConstEyeIterator eyeIter = fdEvent.EyesBegin(fevt::ComponentSelector::eHasData);
            eyeIter != fdEvent.EyesEnd(fevt::ComponentSelector::eHasData); ++eyeIter) {
          if (eyeIter->GetId() != fWhichEye)
            continue;  // continue until selected eye
          const fevt::Eye& eye = *eyeIter;
        if (!eye.HasRecData() || !eye.GetRecData().HasFRecShower()) {
          ERROR("Eye has no RecData or FRecShower but FD reference Core specified in the settings!");
          throw utl::NonExistentComponentException();
        } else {
          return true; // There is no logic to ask FRecShower yet implemented...
        }
      }
    }
  } else if (ShowerRRecData::fReferenceCoreFlag == ShowerRRecData::eUseMCReferenceCore) {
    if (!event.HasSimShower()) {
      ERROR("No SimShower available but MC reference core specified in the settings.");
      throw utl::NonExistentComponentException();
    } else {
      return event.GetSimShower().HasPosition();
    }
  } else if (ShowerRRecData::fReferenceCoreFlag == ShowerRRecData::eUseRDReferenceCore) {
    if (HasParameter(revt::eCoreX) &&
        HasParameter(revt::eCoreY) &&
        HasParameter(revt::eCoreZ)) {
      return true;
    } else {
      return false;
    }
  } else if (ShowerRRecData::fReferenceCoreFlag == ShowerRRecData::eUseRDCoordinateOrigin) {
    return true;  // is checked in getter function anyway
  } else if (ShowerRRecData::fReferenceCoreFlag == ShowerRRecData::eUseExternalReferenceCore) {
    if (HasParameter(revt::eExternalCoreX) &&
        HasParameter(revt::eExternalCoreY) &&
        HasParameter(revt::eExternalCoreZ)) {
      return true;
    } else {
      return false;
    }
  }
  ERROR("unknown reference core"); //this should never happen
  throw utl::NonExistentComponentException("invalid reference core specified");
}


bool
ShowerRRecData::HasReferenceAxis(const Event& event)
  const
{
  if (ShowerRRecData::fReferenceAxisFlag == ShowerRRecData::eUseSDReferenceAxis) {
    if (!event.GetRecShower().HasSRecShower()) {
      ERROR("No SRecShower available but SD reference core specified in the settings.");
      throw utl::NonExistentComponentException();
    } else {
      return true;  // There is no logic to ask SRecShower yet implemented...
    }
  } else if (ShowerRRecData::fReferenceAxisFlag == ShowerRRecData::eUseFDReferenceAxis) {
    if (!event.HasFEvent()) {
      ERROR("No FEvent available but FD reference Core specified in the settings!");
      throw utl::NonExistentComponentException();
      } else {
        const fevt::FEvent& fdEvent = event.GetFEvent();
        for (fevt::FEvent::ConstEyeIterator eyeIter = fdEvent.EyesBegin(fevt::ComponentSelector::eHasData);
            eyeIter != fdEvent.EyesEnd(fevt::ComponentSelector::eHasData); ++eyeIter) {
          if (eyeIter->GetId() != fWhichEye)
            continue;  // continue until selected eye
          const fevt::Eye& eye = *eyeIter;
        if (!eye.HasRecData() || !eye.GetRecData().HasFRecShower()) {
          ERROR("Eye has no RecData or FRecShower but FD reference Core specified in the settings!");
          throw utl::NonExistentComponentException();
        } else {
          return true;  // There is no logic to ask FRecShower yet implemented...
        }
      }
    }
  } else if (ShowerRRecData::fReferenceAxisFlag == ShowerRRecData::eUseMCReferenceAxis) {
    if (!event.HasSimShower()) {
      ERROR("No SimShower available but MC reference core specified in the settings.");
      throw utl::NonExistentComponentException();
    } else {
      return event.GetSimShower().HasDirection();
    }
  } else if (ShowerRRecData::fReferenceAxisFlag == ShowerRRecData::eUseRDReferenceAxis) {
    if (HasParameter(revt::eShowerAxisX) &&
        HasParameter(revt::eShowerAxisY) &&
        HasParameter(revt::eShowerAxisZ)) {
      return true;
    } else {
      return false;
    }
  } else if (ShowerRRecData::fReferenceAxisFlag == ShowerRRecData::eUseExternalReferenceAxis) {
    if (HasParameter(revt::eExternalShowerAxisX) &&
        HasParameter(revt::eExternalShowerAxisY) &&
        HasParameter(revt::eExternalShowerAxisZ)) {
      return true;
    } else {
      return false;
    }
  }
  ERROR("unknown reference direction"); //this should never happen
  throw utl::NonExistentComponentException("invalid reference direction specified");
}


utl::Point
ShowerRRecData::GetReferenceCorePosition(const Event& event)
  const
{
  // set reference core/direction
  if (ShowerRRecData::fReferenceCoreFlag == ShowerRRecData::eUseSDReferenceCore) {
    if (!event.GetRecShower().HasSRecShower()) {
      ERROR("No SRecShower available but SD reference core specified in the settings.");
      throw utl::NonExistentComponentException();
    } else {
      const ShowerSRecData& showersrec = event.GetRecShower().GetSRecShower();
      return showersrec.GetCorePosition();
    }
  } else if (ShowerRRecData::fReferenceCoreFlag == ShowerRRecData::eUseFDReferenceCore) {
    if (!event.HasFEvent()) {
      ERROR("No FEvent available but FD reference Core specified in the settings!");
      throw utl::NonExistentComponentException();
      } else {
        const fevt::FEvent& fdEvent = event.GetFEvent();
        for (fevt::FEvent::ConstEyeIterator eyeIter = fdEvent.EyesBegin(fevt::ComponentSelector::eHasData);
            eyeIter != fdEvent.EyesEnd(fevt::ComponentSelector::eHasData); ++eyeIter) {
          if (eyeIter->GetId() != fWhichEye)
            continue;  // continue until selected eye
          const fevt::Eye& eye = *eyeIter;
        if (!eye.HasRecData() || !eye.GetRecData().HasFRecShower()) {
          ERROR("Eye has no RecData or FRecShower but FD reference Core specified in the settings!");
          throw utl::NonExistentComponentException();
        } else {
          const ShowerFRecData& showerfrec = eye.GetRecData().GetFRecShower();
          return showerfrec.GetCorePosition();
        }
      }
    }
  } else if (ShowerRRecData::fReferenceCoreFlag == ShowerRRecData::eUseMCReferenceCore) {
    if (!event.HasSimShower()) {
      ERROR("No SimShower available but MC reference core specified in the settings.");
      throw utl::NonExistentComponentException();
    } else {
      return event.GetSimShower().GetPosition();
    }
  } else if (ShowerRRecData::fReferenceCoreFlag == ShowerRRecData::eUseRDReferenceCore) {
    const ShowerRRecData& showerrrec = event.GetRecShower().GetRRecShower();
    return showerrrec.GetCorePosition();
  } else if (ShowerRRecData::fReferenceCoreFlag == ShowerRRecData::eUseRDCoordinateOrigin) {
    const ShowerRRecData& showerrrec = event.GetRecShower().GetRRecShower();
    return showerrrec.GetCoordinateOrigin();
  } else if (ShowerRRecData::fReferenceCoreFlag == ShowerRRecData::eUseExternalReferenceCore) {
    const utl::CoordinateSystemPtr referenceCS = det::Detector::GetInstance().GetReferenceCoordinateSystem();
    if (HasParameter(revt::eExternalCoreX) &&
        HasParameter(revt::eExternalCoreY) &&
        HasParameter(revt::eExternalCoreZ)) {
      return utl::Point(GetParameter(revt::eExternalCoreX),
                        GetParameter(revt::eExternalCoreY),
                        GetParameter(revt::eExternalCoreZ),
                        referenceCS);
    } else {
      WARNING("ShowerRRecData::GetCorePosition(): Parameter eExternalCore was not set. Throwing exception...");
      throw utl::NonExistentComponentException("Tried to get an unset parameter (eExternalCoreX/Y/Z) from ParameterStorage.");
    }
  }
  ERROR("unknown reference core"); //this should never happen
  throw utl::NonExistentComponentException("invalid reference core specified");
}


utl::Vector
ShowerRRecData::GetReferenceCoreError(const Event& event)
  const
{
  // set reference core/direction
  if (ShowerRRecData::fReferenceCoreFlag == ShowerRRecData::eUseSDReferenceCore) {
    if (!event.GetRecShower().HasSRecShower()) {
      ERROR("No SRecShower available but SD reference core specified in the settings.");
      throw utl::NonExistentComponentException();
    } else {
      const ShowerSRecData& showersrec = event.GetRecShower().GetSRecShower();
      return showersrec.GetCoreError();
    }
  } else if (ShowerRRecData::fReferenceCoreFlag == ShowerRRecData::eUseFDReferenceCore) {
    if (!event.HasFEvent()) {
      ERROR("No FEvent available but FD reference Core specified in the settings!");
      throw utl::NonExistentComponentException();
    } else {
      const fevt::FEvent& fdEvent = event.GetFEvent();
      for (fevt::FEvent::ConstEyeIterator eyeIter = fdEvent.EyesBegin(fevt::ComponentSelector::eHasData);
          eyeIter != fdEvent.EyesEnd(fevt::ComponentSelector::eHasData); ++eyeIter) {
          if (eyeIter->GetId() != fWhichEye)
            continue;  // continue until selected eye
          const fevt::Eye& eye = *eyeIter;
          if (!eye.HasRecData() || !eye.GetRecData().HasFRecShower()) {
            ERROR("Eye has no RecData or FRecShower but FD reference Core specified in the settings!");
            throw utl::NonExistentComponentException();
          } else {
            const ShowerFRecData& showerfrec = eye.GetRecData().GetFRecShower();
            return showerfrec.GetCoreError();
          }
        }
      }
    } else if (ShowerRRecData::fReferenceCoreFlag == ShowerRRecData::eUseMCReferenceCore) {
    if (!event.HasSimShower()) {
      ERROR("No SimShower available but MC reference core specified in the settings.");
      throw utl::NonExistentComponentException();
    } else {
      ERROR("MC is specified as reference core position, no error for this setting.");
      return utl::Vector();
    }
  } else if (ShowerRRecData::fReferenceCoreFlag == ShowerRRecData::eUseRDReferenceCore) {
    ERROR("RD is specified as reference core position, no error for this setting.");
    return utl::Vector(); // No CoreError
  } else if (ShowerRRecData::fReferenceCoreFlag == ShowerRRecData::eUseRDCoordinateOrigin) {
    ERROR("RDCoordinateOrigin is specified as reference core position, no error for this setting.");
    return utl::Vector(); // No CoreError
  } else if (ShowerRRecData::fReferenceCoreFlag == ShowerRRecData::eUseExternalReferenceCore) {
    WARNING("External is specified as reference core position, no error for this setting.");
    return utl::Vector(); // No CoreError
  }
  ERROR("unknown reference core"); //this should never happen
  throw utl::NonExistentComponentException("invalid reference core specified");
}

double
ShowerRRecData::GetReferenceCoreErrorCorrelationXY(const Event& event)
const
{
  if (ShowerRRecData::fReferenceCoreFlag == ShowerRRecData::eUseSDReferenceCore) {
    if (!event.GetRecShower().HasSRecShower()) {
      ERROR("No SRecShower available but SD reference core specified in the settings.");
      throw utl::NonExistentComponentException();
    } else {
      const ShowerSRecData& showersrec = event.GetRecShower().GetSRecShower();
      return showersrec.GetCorrelationXY();
    }
  } else if (ShowerRRecData::fReferenceCoreFlag == ShowerRRecData::eUseFDReferenceCore) {
    if (!event.HasFEvent()) {
      ERROR("No FEvent available but FD reference Core specified in the settings!");
      throw utl::NonExistentComponentException();
      } else {
        const fevt::FEvent& fdEvent = event.GetFEvent();
      for (fevt::FEvent::ConstEyeIterator eyeIter = fdEvent.EyesBegin(fevt::ComponentSelector::eHasData);
          eyeIter != fdEvent.EyesEnd(fevt::ComponentSelector::eHasData); ++eyeIter) {
        if (eyeIter->GetId() != fWhichEye)
          continue;  // continue until selected eye
        const fevt::Eye& eye = *eyeIter;
        if (!eye.HasRecData() || !eye.GetRecData().HasFRecShower()) {
          ERROR("Eye has no RecData or FRecShower but FD reference Core specified in the settings!");
          throw utl::NonExistentComponentException();
        } else {
          const ShowerFRecData& showerfrec = eye.GetRecData().GetFRecShower();
          return showerfrec.GetCorrelationXY();
        }
      }
    }
  } else if (ShowerRRecData::fReferenceCoreFlag == ShowerRRecData::eUseMCReferenceCore) {
    if (!event.HasSimShower()) {
      ERROR("No SimShower available but MC reference core specified in the settings.");
      throw utl::NonExistentComponentException();
    } else {
      ERROR("MC is specified as reference core position, no ReferenceCoreErrorCorrelationXY for this setting.");
      return 0;
    }
  } else if (ShowerRRecData::fReferenceCoreFlag == ShowerRRecData::eUseRDReferenceCore) {
    ERROR("RD is specified as reference core position, no ReferenceCoreErrorCorrelationXY for this setting.");
    return 0;
  } else if (ShowerRRecData::fReferenceCoreFlag == ShowerRRecData::eUseRDCoordinateOrigin) {
    ERROR("RDCoordinateOrigin is specified as reference core position, no ReferenceCoreErrorCorrelationXY for this setting.");
    return 0;
  } else if (ShowerRRecData::fReferenceCoreFlag == ShowerRRecData::eUseExternalReferenceCore) {
    WARNING("External is specified as reference core position, no ReferenceCoreErrorCorrelationXY for this setting.");
    return 0;
  }
  ERROR("unknown reference core"); //this should never happen
  throw utl::NonExistentComponentException("invalid reference core specified");
}


utl::Vector
ShowerRRecData::GetReferenceAxis(const Event& event)
  const
{
  if (ShowerRRecData::fReferenceAxisFlag == ShowerRRecData::eUseSDReferenceAxis) {
    if (!event.GetRecShower().HasSRecShower()) {
      ERROR("No SRecShower available but SD reference direction specified in the settings.");
      throw utl::NonExistentComponentException();
    } else {
      const ShowerSRecData& showersrec = event.GetRecShower().GetSRecShower();
      return showersrec.GetAxis();
    }
  } else if (ShowerRRecData::fReferenceAxisFlag == ShowerRRecData::eUseFDReferenceAxis) {
    if (!event.HasFEvent()) {
      ERROR("No FEvent available but FD reference direction specified in the settings!");
      throw utl::NonExistentComponentException();
    } else {
      const fevt::FEvent& fdEvent = event.GetFEvent();
      for (fevt::FEvent::ConstEyeIterator eyeIter = fdEvent.EyesBegin(fevt::ComponentSelector::eHasData);
          eyeIter != fdEvent.EyesEnd(fevt::ComponentSelector::eHasData); ++eyeIter) {
        if (eyeIter->GetId() != fWhichEye)
          continue;  // continue until selected eye
        const fevt::Eye& eye = *eyeIter;
        if (!eye.HasRecData() || !eye.GetRecData().HasFRecShower()) {
          ERROR("Eye has no RecData or FRecShower but FD reference direction specified in the settings!");
          throw utl::NonExistentComponentException();
        } else {
          const ShowerFRecData& showerfrec = eye.GetRecData().GetFRecShower();
          return showerfrec.GetAxis();
        }
      }
    }
  } else if (ShowerRRecData::fReferenceAxisFlag == ShowerRRecData::eUseMCReferenceAxis) {
    if (!event.HasSimShower()) {
      ERROR("No SimShower available but MC reference direction specified in the settings.");
      throw utl::NonExistentComponentException();
    } else {
      return -1 * event.GetSimShower().GetDirection();  // MC direction is defined as velocity direction of the particles
    }
  } else if (ShowerRRecData::fReferenceAxisFlag == ShowerRRecData::eUseRDReferenceAxis) {
    const ShowerRRecData& showerrrec = event.GetRecShower().GetRRecShower();
    return showerrrec.GetAxis();
  } else if (ShowerRRecData::fReferenceAxisFlag == ShowerRRecData::eUseExternalReferenceAxis) {
    const utl::CoordinateSystemPtr fgLocalCS = fwk::LocalCoordinateSystem::Create(GetCoordinateOrigin());
    if (HasParameter(revt::eExternalShowerAxisX) &&
        HasParameter(revt::eExternalShowerAxisY) &&
        HasParameter(revt::eExternalShowerAxisZ)) {
      return utl::Vector(GetParameter(revt::eExternalShowerAxisX),
                         GetParameter(revt::eExternalShowerAxisY),
                         GetParameter(revt::eExternalShowerAxisZ),
                         fgLocalCS);
    } else {
      WARNING("ShowerRRecData::GetReferenceAxis(): Parameter eExternalShowerAxis was not set. Throwing exception...");
      throw utl::NonExistentComponentException("Tried to get an unset parameter (eExternalShowerAxisX/Y/Z) from ParameterStorage.");
    }
  }
  ERROR("unknown reference direction"); //this should never happen
  throw utl::NonExistentComponentException("invalid reference direction specified");
}