SEvent/Station.cc

Go to the documentation of this file.

#include <sevt/Station.h>
#include <sevt/SEvent.h>
#include <sevt/Scintillator.h>
#include <sevt/PMT.h>
#include <sevt/StationTriggerData.h>
#include <sevt/StationSimData.h>
#include <sevt/StationRecData.h>
#include <sevt/StationCalibData.h>
#include <sevt/StationGPSData.h>
#include <sevt/StationConstants.h>
#include <sevt/ScintillatorSimData.h>
#include <det/Detector.h>
#include <sdet/SDetector.h>
#include <sdet/Station.h>
#include <sdet/PMTConstants.h>
#include <sdet/Scintillator.h>
#include <utl/Particle.h>
#include <utl/ErrorLogger.h>
#include <utl/AugerException.h>

#include <cstddef>
#include <iostream>
#include <algorithm>

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


namespace sevt {

  Station::Station(const int id) :
    fId(id)
  {
    /* PMTs are generated based on the PMTs which exist in SDetector Station at
       the present time. */
    const auto& dStation = Detector::GetInstance().GetSDetector().GetStation(id);

    for (const auto& pmt : dStation.PMTsRange())
      fPMTs.push_back(new PMT(pmt.GetId(), id, pmt.GetType()));

    if (dStation.HasScintillator())
      fScintillator = new Scintillator(fId);

    if (dStation.HasSmallPMT())
      fSmallPMTData = new SmallPMTData();
  }


  Station::~Station()
  {
    for (const auto p : fPMTs)
      delete p;
  }


  Station&
  Station::operator=(const Station& station)
  {
    if (this == &station)
      return *this;

    fId = station.fId;

    for (const auto p : fPMTs)
      delete p;
    fPMTs.clear();
    for (const auto p : station.fPMTs)
      fPMTs.push_back(new PMT(*p));

    fSimData = station.fSimData;
    fRecData = station.fRecData;
    fCalibData = station.fCalibData;
    fTriggerData = station.fTriggerData;
    fGPSData = station.fGPSData;
    fTraceStartTime = station.fTraceStartTime;
    fTrace = station.fTrace;
    fReconstructionStatus = station.fReconstructionStatus;
    copy(begin(station.fSaturation), end(station.fSaturation), begin(fSaturation));
    fRejectionStatus = station.fRejectionStatus;
    fT2Life = station.fT2Life;
    fSignals = station.fSignals;
    fScintillator = station.fScintillator;
    fSmallPMTData = station.fSmallPMTData;

    return *this;
  }


  bool
  Station::HasPMT(const unsigned int pmtId)
    const
  {
    for (const auto p : fPMTs)
      if (p->GetId() == pmtId)
        return true;
    return false;
  }


  void
  Station::MakePMT(const unsigned int pmtId, const int stationId, const sdet::PMTConstants::PMTType type)
  {
    if (HasPMT(pmtId)) {
      std::ostringstream err;
      err << "PMT with id " << pmtId << "already exists!";
      ERROR(err);
      throw utl::InvalidConfigurationException(err.str());
    }
    fPMTs.push_back(new PMT(pmtId, stationId, type));
  }


  const PMT&
  Station::GetPMT(const unsigned int pmtId)
    const
  {
    for (const auto p : fPMTs)
      if (p->GetId() == pmtId)
        return *p;
    std::ostringstream err;
    err << "Invalid PMT id " << pmtId;
    ERROR(err);
    throw utl::NonExistentComponentException(err.str());
  }


  const PMT&
  Station::GetScintillatorPMT()
    const
  {
    // Check to ensure that there is only one PMT of the given type
    if (GetNPMTs(sdet::PMTConstants::eScintillator) > 1) {
      std::ostringstream err;
      err << "The station appears to contain more than one scintillator PMT"
             "which is neither expected nor allowed.";
      ERROR(err);
      throw utl::DoesNotComputeException(err.str());
    }
    // Find and return PMT of requested type
    for (const auto p : fPMTs)
      if (p->GetType() == sdet::PMTConstants::eScintillator)
        return *p;
    std::ostringstream err;
    err << "Scintillator PMT does not exist.";
    ERROR(err);
    throw utl::NonExistentComponentException(err.str());
  }


  const PMT&
  Station::GetSmallPMT()
    const
  {
    // Check to ensure that there is only one PMT of the given type
    if (GetNPMTs(sdet::PMTConstants::eWaterCherenkovSmall) > 1) {
      std::ostringstream err;
      err << "The station appears to contain more than one small PMT"
             "which is neither expected nor allowed.";
      ERROR(err);
      throw utl::DoesNotComputeException(err.str());
    }
    // Find and return PMT of requested type
    for (const auto p : fPMTs)
      if (p->GetType() == sdet::PMTConstants::eWaterCherenkovSmall)
        return *p;
    std::ostringstream err;
    err << "Small PMT does not exist.";
    ERROR(err);
    throw utl::NonExistentComponentException(err.str());
  }


  unsigned int
  Station::GetNPMTs(const sdet::PMTConstants::PMTType type)
    const
  {
    if (type == sdet::PMTConstants::eAnyType)
      return fPMTs.size();

    unsigned int n = 0;
    for (const auto p : fPMTs)
      if (p->GetType() == type)
        ++n;
    return n;
  }


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


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


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


  void
  Station::MakeCalibData()
  {
    if (fCalibData)
      ERROR("Calib Data already exists - Not Replacing");
    else
      fCalibData = new StationCalibData;
  }


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


  void
  Station::SetCandidate()
  {
    if (fReconstructionStatus != StationConstants::eCandidate)
      throw utl::DoesNotComputeException("Trying to change the status of the station from non-candidate to candidate!");
  }


  void
  Station::SetRejected(const int reason)
  {
    /*
     * fRejectionStatus is already set to 0 (eNoRejection) by default
     * in Station constructor. Attempts to manually set it to 0
     * are likely misguided.
     */
    if (reason == StationConstants::eNoRejection) {
      std::ostringstream err;
      err << "Attempting to set station as rejected with status of "
          << "not rejected (fRejectionStatus = " << reason << ").";
      throw utl::DoesNotComputeException(err.str());
    }
    fReconstructionStatus = StationConstants::eRejected;
    fRejectionStatus |= reason;
  }



  void
  Station::SetSilent()
  {
    if (fReconstructionStatus == StationConstants::eRejected)
      throw utl::DoesNotComputeException("Trying to change the status of the station from rejected to silent!");
    fReconstructionStatus = StationConstants::eSilent;
  }


  void
  Station::MakeVEMTrace(const StationConstants::SignalComponent source)
  {
    const auto& dStation = Detector::GetInstance().GetSDetector().GetStation(*this);
    fTrace.AddTrace(dStation.GetFADCTraceLength(), dStation.GetFADCBinSize(), source);
  }


  bool
  Station::IsUUB()
    const
  {
    return Detector::GetInstance().GetSDetector().GetStation(*this).IsUUB();
  }


  void
  Station::AddParticle(const utl::Particle& particle)
  {
    if (!HasSimData())
      MakeSimData();
    fSimData->AddParticle(particle);

    if (fScintillator && !fScintillator->HasSimData())
        fScintillator->MakeSimData();

    /*
     * Although particle is always added to StationSimData,
     * it is only added to the Station (that is, WCD) particle
     * counters (muons, electrons, etc.) if it's injection
     * trajectory intersects the WCD. It is only added to the
     * Scintillator particle counters if it's injection trajectory
     * intersects the Scintillator
     */

    // It's insane to do this for every particle... but the idea
    // of caching the sdet Station in the sevt Station also seems
    // insane. Regardless, we need a better solution.
    const auto& dStation = Detector::GetInstance().GetSDetector().GetStation(fId);
    if (dStation.IsHit(particle.GetPosition(), particle.GetDirection()))
      fSimData->CountParticle(particle);
    if (fScintillator && dStation.GetScintillator().IsHit(particle.GetPosition(), particle.GetDirection()))
      fScintillator->GetSimData().CountParticle(particle);
  }

}