Framework/Event/Event.cc

Go to the documentation of this file.

#include <utl/config.h>
#include <evt/Event.h>

#include <evt/Header.h>
#include <evt/ShowerRecData.h>
#include <evt/ShowerSimData.h>
#include <evt/VShowerGeometryProducer.h>

#include <fevt/FEvent.h>
#include <sevt/SEvent.h>

#include <revt/REvent.h>
#include <mevt/MEvent.h>
#include <cevt/CEvent.h>

#include <utl/AugerException.h>
#include <utl/ErrorLogger.h>

#include <AugerEvent.h>

using namespace fevt;
using namespace sevt;
using namespace revt;
using namespace mevt;
using namespace cevt;


namespace evt {

  ShowerSimData&
  Event::GetSimShower()
  {
    return *fSimShower;
  }


  const ShowerSimData&
  Event::GetSimShower()
    const
  {
    return *fSimShower;
  }


  void
  Event::MakeSimShower(const evt::VShowerGeometryProducer& p)
  {
    if (!fSimShower)
      fSimShower = new ShowerSimData(p);
    else
      ERROR("SimShower already exists - not replacing");
  }


  ShowerRecData&
  Event::GetRecShower()
  {
    return *fRecShower;
  }


  const ShowerRecData&
  Event::GetRecShower()
    const
  {
    return *fRecShower;
  }


  void
  Event::MakeRecShower()
  {
    if (!fRecShower)
      fRecShower = new ShowerRecData;
    else
      ERROR("RecShower already exists - not replacing");
  }


  SEvent&
  Event::GetSEvent()
  {
    return *fSEvent;
  }


  const SEvent&
  Event::GetSEvent()
    const
  {
    return *fSEvent;
  }


  void
  Event::MakeSEvent()
  {
    if (!fSEvent)
      fSEvent = new SEvent;
    else
      ERROR("SEvent already exists - not replacing");
  }


  FEvent&
  Event::GetFEvent()
  {
    return *fFEvent;
  }


  const FEvent&
  Event::GetFEvent()
    const
  {
    return *fFEvent;
  }


  void
  Event::MakeFEvent()
  {
    if (!fFEvent)
      fFEvent = new FEvent;
    else
      ERROR("FEvent already exists - not replacing");
  }


  REvent&
  Event::GetREvent()
  {
    return *fREvent;
  }


  const REvent&
  Event::GetREvent()
    const
  {
    return *fREvent;
  }


  void
  Event::MakeREvent()
  {
    if (!fREvent)
      fREvent = new REvent;
    else
      ERROR("REvent already exists - not replacing");
  }


  MEvent&
  Event::GetMEvent()
  {
    return *fMEvent;
  }


  const MEvent&
  Event::GetMEvent()
    const
  {
    return *fMEvent;
  }


  void
  Event::MakeMEvent()
  {
    // RFG I don't see why in the other MakeXEvent operator! is used,
    // programming the if the other way round.
    if (fMEvent)
      ERROR("MEvent already exists - not replacing");
    else
      fMEvent = new MEvent;
  }


  CEvent&
  Event::GetCEvent()
  {
    return *fCEvent;
  }


  const CEvent&
  Event::GetCEvent()
    const
  {
    return *fCEvent;
  }


  void
  Event::MakeCEvent()
  {
    if (!fCEvent)
      fCEvent = new CEvent;
    else
      ERROR("CEvent already exists - not replacing");
  }


  AugerEvent&
  Event::GetRawEvent()
  {
    return *fRawEvent;
  }


  const AugerEvent&
  Event::GetRawEvent()
    const
  {
    return *fRawEvent;
  }


  void
  Event::MakeRawEvent()
  {
    if (!fRawEvent)
      fRawEvent = new AugerEvent;
    else
      ERROR("RawEvent already exists - not replacing");
  }

}