RdAirplaneTiming.cc

Go to the documentation of this file.

#include "RdAirplaneTiming.h"
#include "AirplaneUtil.h"
#include "Ads_bDataBase.h"
#include "Airplane.h"
#include "Flight.h"
#include "DataWriter.h"
#include "PulseInfoWriter.h"

using namespace evt;
using namespace revt;
using namespace std;
using namespace utl;
using namespace fwk;
using namespace RdAirplane;
using namespace boost;
namespace fs = filesystem;

RdAirplaneTiming::RdAirplaneTiming() :
  _maxAngleBetweenAirplaneAndEventInRadians_(0),
  _ads_bAntennaPosition_(),
  _ads_bDataBase_(NULL),
  _dataWriter_(NULL) {}

RdAirplaneTiming::~RdAirplaneTiming() {
  delete _dataWriter_;
}

VModule::ResultFlag RdAirplaneTiming::Init() {
  
  _globalCoordinateSystem_ = det::Detector::GetInstance().GetReferenceCoordinateSystem();
  string outputDirectory;
  // for debugging: true -> for every airplane some information is streamed to the console
  bool shouldPrintAirplaneInfo = false;
  
  CentralConfig* centralConfig = CentralConfig::GetInstance();
  Branch timingTopBranch =  centralConfig->GetTopBranch("RdAirplaneTiming");
  timingTopBranch.GetChild("OutputDirectoy").GetData(outputDirectory);
  timingTopBranch.GetChild("MaxAngleBetweenAirplaneAndEvent").GetData(_maxAngleBetweenAirplaneAndEventInRadians_);

  _maxAngleBetweenAirplaneAndEventInRadians_=_maxAngleBetweenAirplaneAndEventInRadians_*M_PI/degree/180;
  _dataWriter_ = new DataWriter(outputDirectory, _globalCoordinateSystem_);

  // Check the configuration of the RdWaveFitModule. This is necessary to have consistent coordinate system origins.
  // This way we know how to interpret eShowerAxisX, eShowerAxisY and eShowerAxisZ.
  string usedCorePositionForReconstruction;
  CentralConfig::GetInstance()->GetTopBranch("RdWaveFit").GetChild("UsedCorePosition").GetData(usedCorePositionForReconstruction);
  if(usedCorePositionForReconstruction!="RadioCoordinateOrigin") {
    ERROR("The parameter 'UsedCorePosition' of the 'RdWaveFit'-Module must be set to 'RadioCoordinateOrigin' to have consistent coordinate systems.");
    return eFailure;
  }

  INFO("The max. allowed angle between the reconstructed and the real airplane position in radians is "+ lexical_cast<string>(_maxAngleBetweenAirplaneAndEventInRadians_));

  // see diploma thesis by A. Lang
  _ads_bAntennaPosition_=UTMPoint(-35.108397*degree, -69.533337*degree, 1560.63*meter, ReferenceEllipsoid::eWGS84).GetPoint(_globalCoordinateSystem_);
  INFO(
      "The ADS-B antenna is at ("+
      lexical_cast<string>(_ads_bAntennaPosition_.GetX(_globalCoordinateSystem_))+", " +
      lexical_cast<string>(_ads_bAntennaPosition_.GetY(_globalCoordinateSystem_))+", " +
      lexical_cast<string>(_ads_bAntennaPosition_.GetZ(_globalCoordinateSystem_))+
      ") in the global coordinate system."
  );

  //reading the ADS-B data that is grouped by airplane and by flight over the AERA field
  _ads_bDataBase_ = Ads_bDataBase::getSharedDataBase();
  
  INFO("Assuming a time shift of the capture time of the ADS-B signal and the real position measurement on the airplane of " + lexical_cast<string>(_ads_bDataBase_->getTimeShift().GetInterval()/ms) + "ms.");

  if(shouldPrintAirplaneInfo)
    INFO(_ads_bDataBase_->getInformations());
  
  return eSuccess;
}


VModule::ResultFlag RdAirplaneTiming::Run(Event& event) {
  
  string eventIdAsString = event.GetHeader().GetId();
  INFO("Processing event " + eventIdAsString);
  
  if(!event.HasREvent())
    return eContinueLoop;

  REvent& rEvent = event.GetREvent();
  const det::Detector& detector = det::Detector::GetInstance();
  const rdet::RDetector& radioDetector = detector.GetRDetector();
  const TimeStamp& eventTime = event.GetHeader().GetTime();

  const ShowerRRecData& showerRRecData = event.GetRecShower().GetRRecShower();
  if(!(showerRRecData.HasParameter(eShowerAxisX) &&
       showerRRecData.HasParameter(eShowerAxisY) &&
       showerRRecData.HasParameter(eShowerAxisZ) &&
       showerRRecData.HasParameter(eCoreX) &&
       showerRRecData.HasParameter(eCoreY) &&
       showerRRecData.HasParameter(eCoreZ))) {
    
    INFO("Radio event was not successfully reconstructed.");
    return eContinueLoop;
  }
  
  CoordinateSystemPtr coreCoordinateSystem = LocalCoordinateSystem::Create(showerRRecData.GetCorePosition());

  Point reconstructedRadioEventOrigin(showerRRecData.GetParameter(eShowerAxisX),
                                      showerRRecData.GetParameter(eShowerAxisY),
                                      showerRRecData.GetParameter(eShowerAxisZ),
                                      coreCoordinateSystem);


  // find the airplanes near the event origin
  // the returned list is sorted by the distance to the reconstructed event source
  Ads_bDataBase::FlightsAndCoordinatesList flightCandidates = _ads_bDataBase_->getFlights(
      eventTime,
      reconstructedRadioEventOrigin,
      _maxAngleBetweenAirplaneAndEventInRadians_,
      coreCoordinateSystem);
  
  if(flightCandidates.empty()) {
    INFO("No airplane corresponds this event.");
    return eContinueLoop;
  }
  
  if(flightCandidates.size()>1) {
    WARNING("Multiple airplanes correspond this event. Using closest one to the reconstructed position.");
  }

  INFO("Association of an airplane with this event was successful.");

  const Flight& flight = *flightCandidates.begin()->getFlight();
  Point coreCoordinateSystemOrigin(0, 0, 0, coreCoordinateSystem);

  // memory is managed by the dataWriter
  PulseInfoWriter* pulseInfoWriter = _dataWriter_->registerEvent(
      event,
      flight,
      reconstructedRadioEventOrigin,
      coreCoordinateSystem);

  for(REvent::CandidateStationIterator stationsIter = rEvent.CandidateStationsBegin(); stationsIter != rEvent.CandidateStationsEnd(); ++stationsIter) {
    const Station& station = *stationsIter;

    if(!station.GetRecData().GetPulseFound() || station.GetRejectionStatus() != 0) {
      continue;
    }

    const rdet::Station& radioStation = radioDetector.GetStation(station);
    _dataWriter_->registerStationInfo(radioStation);
    pulseInfoWriter->writePulseInfo(station, radioStation);
  }
  return eSuccess;
}


VModule::ResultFlag RdAirplaneTiming::Finish() {
  if(!_dataWriter_->writeStationInfosToFile())
    return eFailure;
  return eSuccess;
}