ShowerSRecData.cc

Go to the documentation of this file.

#include <fwk/LocalCoordinateSystem.h>
#include <evt/ShowerScintillatorRecData.h>
#include <utl/AugerException.h>
#include <utl/ErrorLogger.h>
#include <utl/TabulatedFunctionErrors.h>
#include <utl/Math.h>
#include <utl/Deprecator.h>
#include <utl/ParameterStorage.h>

#include <utl/LameShadowPtr_imp.h>
#include <evt/ShowerSRecData.h>


LAMESHADOWPTR_INST(evt::ShowerSRecData);


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


namespace evt {

  // static members

  const double ShowerSRecData::kBary                    = 0.5;
  const double ShowerSRecData::kPlaneFitLinear          = 1;
  const double ShowerSRecData::kPlaneFitLinear2         = 1.1;
  const double ShowerSRecData::kPlaneFit3d              = 1.2;
  const double ShowerSRecData::kLDFEstimate             = 2;
  const double ShowerSRecData::kLDFEstimateAndCurvature = 2.5;
  const double ShowerSRecData::kLDF                     = 3;
  const double ShowerSRecData::kLDFAndCurvature         = 3.5;
  const double ShowerSRecData::kLDFSilents              = 4;
  const double ShowerSRecData::kLDFSilentsAndCurvature  = 4.5;
  const double ShowerSRecData::kLDFGlobalFit            = 5;
  const double ShowerSRecData::kLDFBeta                 = 0.1;
  const double ShowerSRecData::kLDFGamma                = 0.01;
  const double ShowerSRecData::kLDFLowerLimit           = 0.001;


  Point
  ShowerSRecData::GetShowerCenter()
    const
  {
    if (fCurvature)
      return fCore + fAxis/fCurvature;
    else
      return fCore;
  }


  void
  ShowerSRecData::MakeLDF()
  {
    if (fLDF)
      ERROR("LDF exists. Not replacing");
    else
      fLDF = new TabulatedFunctionErrors;
  }


  void
  ShowerSRecData::MakeMPDHistogram(const int nBins, const double min, const double max)
  {
    fMPDHistogram = new Histogram<double>(nBins, min, max);
  }


  void
  ShowerSRecData::SetAngleErrors(const Vector::Triple& u_v_w,
                                 const Vector::Triple& sigma_u2_uv_v2)
  {
    PropagateAxisErrors(u_v_w, sigma_u2_uv_v2, fThetaError, fPhiError, fCorrelationThetaPhi);
  }


  const char*
  ShowerSRecData::GetShowerSizeLabel()
    const
  {
    switch (fShowerSizeType) {
    case eS1000: return "S1000";
    case eS450: return "S450";
    case eN19: return "N19";
    case eS300: return "S300";
    case eUndefined: return "Undefined";
    }

    // never arrive here
    return "";
  }


  void
  ShowerSRecData::MakeScintillatorRecShower()
  {
    if (!fShowerScintillatorRecData)
      fShowerScintillatorRecData = new ShowerScintillatorRecData();
    else
      ERROR("ScintillatorRecShower already exists - Not replacing");
  }


  const CoordinateSystemPtr&
  ShowerSRecData::GetBarycenterCoordinateSystem()
    const
  {
    if (!fBarycenterCoordinateSystem)
      fBarycenterCoordinateSystem = fwk::LocalCoordinateSystem::Create(fBarycenter);
    return fBarycenterCoordinateSystem;
  }


  const CoordinateSystemPtr&
  ShowerSRecData::GetCoreCoordinateSystem()
    const
  {
    if (!fCoreCoordinateSystem)
      fCoreCoordinateSystem = fwk::LocalCoordinateSystem::Create(fCore);
    return fCoreCoordinateSystem;
  }


  const CoordinateSystemPtr&
  ShowerSRecData::GetShowerCoordinateSystem()
    const
  {
    if (!fShowerCoordinateSystem) {
      const auto& coreCS = GetCoreCoordinateSystem();
      const double theta = GetAxis().GetTheta(coreCS);
      const double phi = GetAxis().GetPhi(coreCS);
      fShowerCoordinateSystem = CoordinateSystem::RotationY(theta, CoordinateSystem::RotationZ(phi, coreCS));
    }
    return fShowerCoordinateSystem;
  }

}