REvent/Station.cc

Go to the documentation of this file.

#include <revt/Station.h>

#include <revt/REvent.h>
#include <revt/Channel.h>
#include <revt/StationTriggerData.h>
#include <revt/StationSimData.h>
#include <revt/StationRecData.h>
#include <revt/StationGPSData.h>
#include <revt/StationHeader.h>

#include <det/Detector.h>
#include <rdet/RDetector.h>
#include <rdet/Station.h>

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

#include <cstddef>
#include <iostream>

using namespace std;
using namespace utl;
using namespace det;
using namespace revt;


Station::Station(const int sId) :
  fId(sId)
{
  const auto& dStation = det::Detector::GetInstance().GetRDetector().GetStation(sId);
  for (const auto cId : dStation.GetListOfChannelIds())
    fChannels.push_back(new Channel(sId, cId));
}


Station::Station(const Station& station) :
  fId(station.fId),
  fSimData(station.fSimData),
  fRecData(station.fRecData),
  fTriggerData(station.fTriggerData),
  fGPSData(station.fGPSData),
  fStationHeader(station.fStationHeader),
  fRawTraceStartTime(station.fRawTraceStartTime),
  fRawTraceStartTimeLocked(station.fRawTraceStartTimeLocked),
  fFFTDataContainer(station.fFFTDataContainer),
  fReconstructionStatus(station.fReconstructionStatus),
  fExcludedReason(station.fExcludedReason),
  fIsSaturated(station.fIsSaturated),
  fRejectedReason(station.fRejectedReason),
  fHWTemperature(station.fHWTemperature),
  fHWTemperatureInt(station.fHWTemperatureInt),
  fHWTemperatureExt(station.fHWTemperatureExt)
{
  for (const auto cp : station.fChannels)
    fChannels.push_back(new Channel(*cp));
}


Station::~Station()
{
  for (const auto cp : fChannels)
    delete cp;
}


Station&
Station::operator=(const Station& station)
{
  if (this != &station) {
    fId = station.fId;
    fSimData = station.fSimData;
    fRecData = station.fRecData;
    fTriggerData = station.fTriggerData;
    fGPSData = station.fGPSData;
    fStationHeader = station.fStationHeader;
    fRawTraceStartTime = station.fRawTraceStartTime;
    fRawTraceStartTimeLocked = station.fRawTraceStartTimeLocked;
    fFFTDataContainer = station.fFFTDataContainer;
    fReconstructionStatus = station.fReconstructionStatus;
    fExcludedReason = station.fExcludedReason;
    fIsSaturated = station.fIsSaturated;
    fRejectedReason = station.fRejectedReason;
    fHWTemperature = station.fHWTemperature;
    fHWTemperatureInt = station.fHWTemperatureInt;
    fHWTemperatureExt = station.fHWTemperatureExt;

    for (const auto cp : fChannels)
      delete cp;
    fChannels.clear();

    for (const auto& cp : station.ChannelsRange())
      fChannels.push_back(new Channel(cp));
  }

  return *this;
}


bool
Station::HasChannel(const int channelId)
  const
{
  const rdet::Station& dStation = det::Detector::GetInstance().GetRDetector().GetStation(fId);
  return dStation.HasChannel(channelId);
}


const Channel&
Station::GetChannel(const int channelId)
  const
{
  const rdet::Station& dStation = det::Detector::GetInstance().GetRDetector().GetStation(fId);

  if (!dStation.HasChannel(channelId)) {
    std::ostringstream err;
    err << "Invalid Channel id " << channelId;
    ERROR(err);
    throw utl::NonExistentComponentException(err.str());
  }

  return *fChannels[dStation.GetInternalChannelId(channelId)];
}


const StationSimData&
Station::GetSimData()
  const
{
  return *fSimData;
}


void
Station::MakeSimData()
{
  if (fSimData) {
    ERROR("SimData already exists - Not Replacing");
  }
  else
    fSimData = new StationSimData;
}


const StationRecData&
Station::GetRecData()
  const
{
  return *fRecData;
}


void
Station::MakeRecData()
{
  if (fRecData)
    ERROR("Rec Data already exists - Not Replacing");
  else
    fRecData = new StationRecData;
}


const StationTriggerData&
Station::GetTriggerData()
  const
{
  return *fTriggerData;
}


void
Station::MakeTriggerData()
{
  if (fTriggerData)
    ERROR("Trigger Data already exists - Not Replacing");
  else
    fTriggerData = new StationTriggerData;
}


const StationGPSData&
Station::GetGPSData()
  const
{
  return *fGPSData;
}


void
Station::MakeGPSData()
{
  if (fGPSData)
    ERROR("GPS Data already exists - Not Replacing");
  else
    fGPSData = new StationGPSData;
}


void
Station::MakeStationHeader()
{
  if (fStationHeader)
    ERROR("Station header already exists - Not replacing");
  else
    fStationHeader = new StationHeader;
}


const StationHeader&
Station::GetStationHeader()
  const
{
  return *fStationHeader;
}


void
Station::SetExcludedReason(const ExcludedReason reason)
{
  if (reason == revt::eNotExcluded) {
    ERROR("You are trying to manually set the station to eNotExcluded."
          "This is not allowed.");
  } else {
    fReconstructionStatus = revt::eExcluded;
    fExcludedReason = reason;
  }
}


void
Station::SetRejectedReason(const unsigned long long int reason)
{
  if (reason == revt::eNoRejection) {
    ERROR("You are trying to manually set the station to eNotRejected."
          "This is not allowed.");
  } else {
    fReconstructionStatus = revt::eRejected;
    fRejectedReason |= reason;
  }
}