cevtStation_ROOT.cc

Go to the documentation of this file.

#include <utl/TimeStamp.h>

#include <io/cevtStation_ROOT.h>
#include <io/cevtStationSimData_ROOT.h>
#include <io/cevtStationRecData_ROOT.h>

using utl::TimeStamp;

using namespace io;


ClassImp(cevtStation_ROOT)


cevtStation_ROOT::~cevtStation_ROOT()
{
  delete fSimData;
  delete fRecData;
  delete fHits;
}


cevtStation_ROOT&
cevtStation_ROOT::operator=(const cevtStation_ROOT& s)
{
  if (this != &s) {
    fId = s.fId;
    fPads = s.fPads;
    DeepCopy(fSimData, s.fSimData);
    DeepCopy(fRecData, s.fRecData);
    fHitsStartSecond = s.fHitsStartSecond;
    fHitsStartNanosecond = s.fHitsStartNanosecond;
    DeepCopy(fHits, s.fHits);
    fReconstructionStatus = s.fReconstructionStatus;
    fRejectionStatus = s.fRejectionStatus;
    //fGridType = s.fGridType
  }
  return *this;
}


cevtStation_ROOT::cevtStation_ROOT(const cevt::Station& s) :
  fId(s.GetId()),
  fPads(s.PadsBegin(), s.PadsEnd()),
  fRejectionStatus(s.GetRejectionStatus())
{
  if (s.HasSimData())
    ConvertCopy(fSimData, s.GetSimData());

  if (s.HasRecData())
    ConvertCopy(fRecData, s.GetRecData());

  fHitsStartSecond = s.GetHitsStartTime().GetGPSSecond();
  fHitsStartNanosecond = static_cast<int>(s.GetHitsStartTime().GetGPSNanoSecond());

  if (s.HasHits())
    fHits = new MultiTimeDistributionI_ROOT(s.HitsBegin(), s.HitsEnd());

  if (s.IsSilent())
    fReconstructionStatus = cevt::StationConstants::eSilent;
  else if (s.IsRejected())
    fReconstructionStatus = cevt::StationConstants::eRejected;
  else if (s.IsCandidate())
    fReconstructionStatus = cevt::StationConstants::eCandidate;
}


void
cevtStation_ROOT::operator>>(cevt::Station& s)
  const
{
  if (fId != s.GetId())
    throw utl::IOFailureException("Station id in source and destination are not equal!");

  for (int i = 0, n = fPads.size(); i < n; ++i)
  {
     const cevtPad_ROOT rPad = fPads[i];

     const int pId = rPad.fId; 
     s.MakePad(pId);

     rPad >> s.GetPad(pId);
  }

  if (fSimData) {
    if (!s.HasSimData())
      s.MakeSimData();
    *fSimData >> s.GetSimData();
  }
  if (fRecData) {
    if (!s.HasRecData())
      s.MakeRecData();
    *fRecData >> s.GetRecData();
  }

  s.SetHitsStartTime(TimeStamp(fHitsStartSecond, fHitsStartNanosecond));

  if (fHits) {
    for (const auto& st : fHits->fTimeDistributions) {
      //utl::TimeDistributionI t(st.second.fSlotSize);
      //st.second >> t;

      const cevt::StationConstants::SignalComponent source = 
        static_cast<cevt::StationConstants::SignalComponent>(st.first);

      if (!s.HasHits(source))
         s.MakeHits(source);
      st.second >> s.GetHits(source);
    }
  }
  
  if (fReconstructionStatus == cevt::StationConstants::eSilent)
    s.SetSilent();
  else if (fReconstructionStatus == cevt::StationConstants::eRejected)
    s.SetRejected(fRejectionStatus);
  else if (fReconstructionStatus == cevt::StationConstants::eCandidate)
    s.SetCandidate();
}