Ads_bEvent.cc

Go to the documentation of this file.

#include "Ads_bEvent.h"
#include "Ads_bDataBase.h"
#include "Airplane.h"
#include "Flight.h"

#include "det/Detector.h"

#include "atm/Atmosphere.h"
#include "atm/USStdADBProfileModel.h"
#include "utl/AugerUnits.h"

#include <stdlib.h>

//uncomment for debugging
//#include "utl/ErrorLogger.h"
//#include "boost/lexical_cast.hpp"


using namespace RdAirplane;
using namespace std;
using namespace utl;
using namespace det;
using namespace atm;
using namespace boost;

TimeInterval Ads_bEvent::MAX_TIME_SPAN_BETWEEN_ADS_B_EVENT_AND_DETECTOR_TIME = TimeInterval(60*60*s);

Ads_bEvent::Ads_bEvent(const TimeStamp& pCaptureTime,const utl::UTMPoint& pCoordinates, const string& pAds_bMessageAsHex, Flight* pFlight) :
  _captureTime_(pCaptureTime),
  _coordinatesFromAds_b_(pCoordinates),
  _pressureAltitude_(-1.0),
  _manuallyCorrectedPressureAltitude_(-1.0),
  _GDAScorrectedPressureAltitude_(-1.0),
  _gpsAltitude_(-1.0),
  _ads_bMessageBinary_(_binaryFromHexString(pAds_bMessageAsHex)),
  _tc_(0),
  _flight_(pFlight),
  _altitudeType_(ePressureAltitude) {
  _decodeAds_bMessage();
  const AirplaneOffset* offset = pFlight->getOffset();
  double altitudeOffset=0.0;
  if(offset!=NULL) {
    _captureTime_ += offset->getTimeOffset();
    altitudeOffset = offset->getAltitudeOffset();
  }
  if(HasGPSAltitude()) {
    _gpsAltitude_ = _coordinatesFromAds_b_.GetHeight();
    _altitudeType_ = eGPSAltitude;
  } else {
    _pressureAltitude_ = _coordinatesFromAds_b_.GetHeight();
    _manuallyCorrectedPressureAltitude_ = _pressureAltitude_+altitudeOffset;
    _altitudeType_ = ePressureAltitude;

    // correct altitude
    Detector& detector = Detector::GetInstance();
    //updating the detector every time would need years for the evaluation of all log files
    if(_captureTime_-detector.GetTime()>MAX_TIME_SPAN_BETWEEN_ADS_B_EVENT_AND_DETECTOR_TIME)
      detector.Update(_captureTime_);
    const Atmosphere& atmosphere = detector.GetAtmosphere();
    USStdADBProfileModel stdAtm;
    double pressure = stdAtm.EvaluatePressureVsHeight().Y(_pressureAltitude_);
    _GDAScorrectedPressureAltitude_ = _getAltitudeFromPressure(atmosphere.EvaluatePressureVsHeight(), pressure);
    if(_GDAScorrectedPressureAltitude_>1000.0*m)
      _altitudeType_ = eGDASCorrectedPressureAltitude;
  }
  tuple<double, double, double> geodeticCoordinates = _coordinatesFromAds_b_.GetGeodeticCoordinates();
  double latitude = geodeticCoordinates.get<0>();
  double longitude = geodeticCoordinates.get<1>();
  const ReferenceEllipsoid& ellipsoid = _coordinatesFromAds_b_.GetEllipsoid();
  _coordinatesPressureAltitude_ = new UTMPoint(latitude, longitude , _pressureAltitude_, ellipsoid);
  _coordinatesGDASCorrectedPressureAltitude_ = new UTMPoint(latitude, longitude , _GDAScorrectedPressureAltitude_, ellipsoid);
  _coordinatesManuallyCorrectedPressureAltitude_ = new UTMPoint(latitude, longitude , _manuallyCorrectedPressureAltitude_, ellipsoid);
  _coordinatesGPSAltitude_ = new UTMPoint(latitude, longitude , _gpsAltitude_, ellipsoid);
}

Ads_bEvent::~Ads_bEvent() {
  delete _coordinatesPressureAltitude_;
  delete _coordinatesGDASCorrectedPressureAltitude_;
  delete _coordinatesManuallyCorrectedPressureAltitude_;
  delete _coordinatesGPSAltitude_;
}

const UTMPoint& Ads_bEvent::getCoordinates() const {
  return getCoordinates(_altitudeType_);
}

const UTMPoint& Ads_bEvent::getCoordinates(AltitudeType pAltitudeType) const {
  switch(pAltitudeType) {
      case eGPSAltitude:
        return *_coordinatesGPSAltitude_;
      case eGDASCorrectedPressureAltitude:
        return *_coordinatesGDASCorrectedPressureAltitude_;
      case eManuallyCorrectedPressureAltitude:
              return *_coordinatesManuallyCorrectedPressureAltitude_;
      case ePressureAltitude:
        return *_coordinatesPressureAltitude_;
      default:
        throw runtime_error("Encountered an unknown altitude type.");
    }
}

double Ads_bEvent::getAltitude(AltitudeType pAltitudeType) const {
  switch(pAltitudeType) {
    case eGPSAltitude:
      if(_altitudeType_!=eGPSAltitude)
        throw runtime_error("Tried to read the gps altitude from ADS-B data that does not contain gps informations.");
      return _gpsAltitude_;
    case eGDASCorrectedPressureAltitude:
      if(_altitudeType_!=eGDASCorrectedPressureAltitude)
            throw runtime_error("Tried to read the corrected pressure altitude from ADS-B data for which the altitude was either from gps or could not be corrected.");
      return _GDAScorrectedPressureAltitude_;
    case ePressureAltitude:
        if(_altitudeType_!=eGDASCorrectedPressureAltitude && _altitudeType_!=ePressureAltitude)
              throw runtime_error("Tried to read the pressure altitude from ADS-B data only holding the gps altitude.");
        return _pressureAltitude_;
    case eManuallyCorrectedPressureAltitude:
            if(_altitudeType_!=eGDASCorrectedPressureAltitude && _altitudeType_!=ePressureAltitude)
                  throw runtime_error("Tried to read the pressure altitude from ADS-B data only holding the gps altitude.");
            return _manuallyCorrectedPressureAltitude_;
    default:
      throw runtime_error("Encountered an unknown altitude type.");
  }
}


double Ads_bEvent::_getAltitudeFromPressure(const atm::ProfileResult& pProfileResult, double pPressure, double pLowerAltitude, double pUpperAltitude, double pPressureTreshold, unsigned int pRecursionDepth, unsigned int pMaxRecursionDepth) {
  if(pRecursionDepth>=pMaxRecursionDepth)
    return -1.0;
  double middleAltitude = (pLowerAltitude+pUpperAltitude)/2;
  double middlePressure = pProfileResult.Y(middleAltitude);
  if(abs(middlePressure-pPressure)<pPressureTreshold)
    return middleAltitude;
  if(middlePressure >= pPressure)
    return _getAltitudeFromPressure(pProfileResult, pPressure, middleAltitude, pUpperAltitude, pPressureTreshold, ++pRecursionDepth, pMaxRecursionDepth);
  else
    return _getAltitudeFromPressure(pProfileResult, pPressure, pLowerAltitude, middleAltitude, pPressureTreshold, ++pRecursionDepth, pMaxRecursionDepth);
}

double Ads_bEvent::_getAltitudeFromPressure(const atm::ProfileResult& pProfileResult, double pPressure) {
  static double lowestAltitude = 7000*m;
  static double highestAltitude = 13000*m;
  static double pressureThreshold = 1*milli*bar;
  static unsigned int maxRecursionDepth = 100;
  return _getAltitudeFromPressure(pProfileResult, pPressure, lowestAltitude, highestAltitude, pressureThreshold, 0, maxRecursionDepth);
}

vector<bool> Ads_bEvent::_binaryFromHexChar(const char& pHexChar) {
  static bool alphabet[16][4] = {
    {0, 0, 0, 0},
    {0, 0, 0, 1},
    {0, 0, 1, 0},
    {0, 0, 1, 1},
    {0, 1, 0, 0},
    {0, 1, 0, 1},
    {0, 1, 1, 0},
    {0, 1, 1, 1},
    {1, 0, 0, 0},
    {1, 0, 0, 1},
    {1, 0, 1, 0},
    {1, 0, 1, 1},
    {1, 1, 0, 0},
    {1, 1, 0, 1},
    {1, 1, 1, 0},
    {1, 1, 1, 1}
  };
  int index = 0;
  switch(toupper(pHexChar)) {
      case '0': index = 0; break;
      case '1': index = 1; break;
      case '2': index = 2; break;
      case '3': index = 3; break;
      case '4': index = 4; break;
      case '5': index = 5; break;
      case '6': index = 6; break;
      case '7': index = 7; break;
      case '8': index = 8; break;
      case '9': index = 9; break;
      case 'A': index = 10; break;
      case 'B': index = 11; break;
      case 'C': index = 12; break;
      case 'D': index = 13; break;
      case 'E': index = 14; break;
      case 'F': index = 15; break;
      default:
        throw runtime_error("Encountered invalid hex character " + pHexChar);
        break;
  }
  bool* res = alphabet[index];
  return vector<bool>(res, res+4);
}

vector<bool> Ads_bEvent::_binaryFromHexString(const string& pHexString) {
  vector<bool> res;
  for(size_t i = 0; i<pHexString.length();++i) {
    const vector<bool>& charToBinary = _binaryFromHexChar(pHexString[i]);
    for(vector<bool>::const_iterator iter = charToBinary.begin(); iter!=charToBinary.end(); ++iter)
      res.push_back(*iter);
  }
  return res;
}

bool Ads_bEvent::ShouldBeFilteredOut() const {
  return false;
}

bool Ads_bEvent::_decodeAds_bMessage() {
  bool res = _decodeTC();
  return res;
}

int Ads_bEvent::_intFromBoolVector(const vector<bool>& pVector) {
    int res = 0;
    unsigned short i = pVector.size()-1;
    for(vector<bool>::const_iterator it = pVector.begin(); it != pVector.end(); ++it,--i){
        int bit = int(*it);
        res |= bit<<i;
    }
    return res;
}

bool Ads_bEvent::_decodeTC() {
  vector<bool>::const_iterator first = _ads_bMessageBinary_.begin() + ADS_B_DATA_BIT_OFFSET;
  vector<bool>::const_iterator last = _ads_bMessageBinary_.begin() + ADS_B_DATA_BIT_OFFSET + 5;
  vector<bool> tc(first, last);
  _tc_ = _intFromBoolVector(tc);
  return true;
}

bool Ads_bEvent::HasGPSAltitude() const {
  return _tc_ == 15 || _tc_ == 16;
}