Skip to content

DAIDALUSv2.0.1
Compare
Choose a tag to compare
@cesaramh cesaramh released this 13 Aug 16:11
· 1 commit to v2.0.1 since this release
DAIDALUSv2.0.1g
2ef80cd

Release DAIDALUS-v2.0.1:

  • January 11, 2021

    • Fixed comment related to SUM setting in Daidalus class
    • Added interface to raw resolutions

  • December 11, 2020

    • Fixed computation of TCPA hazard volume when TTHR*||v|| < DTHR and other volumes when relative velocity is zero (these fixes are only for display)

  • October 9, 2020

    • Added performance metrics methods to Daidalus class
    • Fixed bug in Daidalus class, where numberOfAircraft was used instead of lastTrafficIndex

  • September 29, 2020

    • Added documentation (automatically generated from code), updated README.

  • September 21, 2020
    Fixed error in DaidalusCore copy constructor (DaidalusCore.h and DaidalusCore.cpp). Thanks to V-ALICE

  • August 20, 2020
    Fixed memory leak in non _MSC_VER compiled branch (Util.cpp and util_string.cpp). Thanks to B. Shimanuki

  • August 12, 2020

    • Updated Makefile
    • Removed global variable j_step_ (using instead local parameters target_step and instantaneous) in integer bands and altitude bands
    • Removed parameters B2, T2 using instead 0,T.

  • August 4, 2020
    Implemented hazard zones (for display purposes only)

Pre-Release DAIDALUS-v2.0.g

June 8, 2020

  • DTA logic is fully implemented. When DTA lat,lon, radius, and height
    is provided, DAIDALUS automatically uses dta_alerter accordingly
    to either ownship or intruder centric alerting. When DTA is active,
    special bands are computed when an alert higher than corrective,
    i.e., warning, is issued. The behavior of the special bands is
    controlled by the dta_logic value. When the value is positive,
    vertical bands block the down side. When the value is negative,
    vertical bands block the down side and horizontal direction bands
    saturate. When the value of dta is zero, DTA logic is disabled.

  • DTA can be manually activated by setting the DTA alerter of the
    ownship, when ownship-centric alerting logic, or intruder, when
    intruder-centric alerting logic, to dta_alerter.

  • Winds in v2.0.g are sticky. Once they are set they remain set until
    explicitly set to a different value or the are disable using the
    method setNoWind() in the Daidalus class.

  • Conflict bands, the ones in front of an aircraft, are computed until
    lookahead time. In some encounter, this will provide wider bands.

  • When hysteresis is enabled, e.g., after the first alert of a given
    level, the subsequent alerts and maneuver guidance for the same
    alerting aircraft are computed using early alerting time instead of
    alerting time. Therefore, when ownship implements the resolutions
    bands are still accurate even if the conflict moved beyond the
    alerting time.

Pre-Release DAIDALUS-v2.0.f:

April 3, 2020

  • Fixed bug in DaidalusRealBands, where boolean check
    if (saturated) should have been if (recovery).
  • Fixed resolution and preferred direction persistence logic.

February 27, 2020

  • Implemented hysteresis logic (M of N and persistence) for maneuver
    guidance. Bands persistance was experimentally implemented in v2d.
    The implementation is v2f is different and more consistent with
    alerting persistence.

  • Setting configuration parameters in a Daidalus object resets hysteresis.

  • The method clean() in the class Daidalus resets hysteresis. In older
    versions of DAIDALUS, the method clean() was needed before adding the
    ownship. This is not needed anymore.

  • When SUM parameters are set to 0, the WCV_TAUMOD_SUM detector is
    equivalent to the WCV_TAUMOD detector. In previous versions, a 10% of
    value step error was always added to WCV_TAUMOD_SUM. However, if SUM
    is not required, it's recommended that the WCV_TAUMOD detector is
    used since WCV_TAUMOD_SUM will add a bit of computation overhead.

  • Eliminated CD3Table to avoid overhead.

  • In C++: Daidalus(Detection3D,double,double) constructor changed to
    Daidalus(Detection3D*,double,double) for efficiency reasons. This
    should only affect specialized users of DAIDALUS that use a
    programatic configuration.

  • In C++: The following static methods are now available

CDCylinder::CD3DCylinder()
WCV_TAUMOD::DO_365_DWC_Phase_I()

The return structures that are safe for referencing with & operator

Pre-Release DAIDALUS-v2.0.e:

February 15, 2020

  • Corrected bug in C++, where reserve was used instead of resize. This
    caused a segmentation fault in Visual Studio C++
  • Reorganized examples in directory outside src
  • Updated Makefile

May 19, 2019

  • Fixed issue with intervals of length 0 (i.e, only one point). These
    intervals are now removed from the computations.
  • Fixed issue with getTimeIn and getTimeOut, where in case of
    no-conflict, their return value is undefined. These methods are now guarded
    by conflit predicated. In case of no conflict they return infinite
    values.
  • Fixed issue in WCV_TAUMOD_SUM, where violationSUMAt and detectionSUM
    return inconsistent values when aircraft are at the border of the
    violation area.
  • Better use of cache information in DaidalusCore. Alerting doesn't
    trigger re-computation of banding core information.

Pre-Release DAIDALUS-v2.0.2d:

April 4, 2019

  • Added hysteresis and persistence times

  • Added preferred resolution persistence

  • Added bands persistence

  • Added alerting M of N

  • Changed max_delta_resolution_xxx to persistence_preferred_xxx. A
    preferred resolution persists while the difference between the the
    preferred resolution and the best resolution is less than this parameter.

  • Method setHorizontalSpeedUncertainty is now called
    setHorizontalVelocityUncertainty.

  • Method setVerticalVelocityZScore is now called
    setVerticalSpeedZScore.

  • Method alerting in Daidalus is now deprecated. It has been renamed
    alertLevel.

  • setAboveBelowHorizontalSpeed in DaidalusBands refactored as
    setAboveRelativeHorizontalSpeed and setBelowRelativeHorizontalSpeed.
    Similar changes for setRelativeVerticalSpeedBands and
    setRelativeAltitudeBands.

  • Added configurable parameters for relative bands.

  • Added UNKNOWN bands region in cases where relative bands are
    used.

  • Added hysteresis to alerting, preferred direction, and
    resolution. Configurable through new parameters.

Implemented ownship/intruder centric alerting logic. There is a new
boolean configuration parameter ownship_centric_alerting. By default,
ownship_centric_alerting is set to true.

Programmatically this parameter can be changed through the
methods:

  • setAlertingLogic(boolean ownship_centric)
  • setOwnshipCentricAlertingLogic()
  • setIntruderCentricAlertingLogic()
    The value of the parameter is obtained by the method
    isAlertingLogicOwnshipCentric().

When the logic is ownship centric, an alerter for all traffic
aircraft is set by using

  • setAlerterIndex(0,alerter_idx).

When the logic is intruder centric, individual alerters for each
traffic aircraft (ac_idx) is set by using

  • setAlerterIndex(ac_idx, alerter_idx)

The methods minHorizontalSeparationAtRecovery and
minVerticalSeparationAtRecovery in RecoveryInformation are now called
recoveryHorizontalDistance and recoveryVerticalDistance.

Pre-Release DAIDALUS-v2.0.2b:

October 15, 2018

daa.set_WC_SC_228_MOPS--> daa. set_WC_DO_365
daa.set_Buffered_WC_SC_228_MOPS --> daa. set_Buffered_WC_DO_365

Daidalus.getMultiKinematicBands() disappeared: The Daidalus object
implements all the functionality of MultiKinematicBands().

The field Daidalus.parameters is not longer available. Daidalus itself
implements all the methods available in DaidalusParameters. Therefore,
something like daa.parameters.getLookaheadTime() is now written
daa.getLookahaedTime();

VERY IMPORTANT List of alerters is now 1-indexed. 0 means none, 1 means first
alerter, 2 means second alerter, etc. More precisely:

  1. Alerters are 1-indexed, i.e., 1 is the index of first alerter
    (e.g., Phase I), 2 is the index of second alerter (e.g., Phase 2), 3 is the index of third alerter, etc.

  2. By default, Ownship is set to alerter 0 (meaning none)

  3. By default, Traffic aircraft is set to alerter 1

  4. If Onwship's alerter is set to 0, then the logic is "intruder-centric" and each aircraft's alerter is used for each aircraft. This is the default behavior.

  5. If Ownship's alerter is set to a value different from 0, then the logic is "ownship-centric" and this is the alerter that is used for every traffic aircraft.

Pre-Release DAIDALUS-v2.0.2a:

October 4, 2018

  • DADIALUS-2 supports multiple alerting structures that can be
    dynamically applied per traffic aircraft.

  • DAIDALUS-2 corrects several misnomers in DAIDALUS-1 (see below).

  • The class AlertLevels is now called Alerter. If daa is an object of
    the class Daidalus, a particular alerter for this aircraft
    can be set using the method:
    daa.setAlerter(ac_idx,arleter_idx);
    or equivalently,
    daa.setAlerter(ac_idx,alerter_id);

In these calls, ac_idx is the index of the aircraft in the traffic
list. The index 0 represents the ownship and the last index is the one
in daa.lastTrafficIndex(). Alerters are collected in a list indexed
from 0 (default alerter) to daa.parameters.numberOfAlerters()-1.

Configuration by File

To configure alerters using a file (same as in DAIDALUS-1):
daa.loadFromFile("configuration_file.txt");

DAIDALUS-2 correctly reads DAIDALUS-1 configuration
files. In this case, only 1 alerter is configured. The configuration
file for multiple alerters is done by configuring a list of alerter identifiers, e.g.,

alerters = Buffered_DWC_Phase_I,DWC_Phase_I

The order in this list is important, the index 0 corresponds to
Buffered_DWC_Phase_I and the index 1 corresponds to DWC_Phase_I. The
definition of these alerters is provided in the lines that follows
this line in the configuration file. Each one is similar to the
configuration of alert_levels in DAIDALUS-1.

The field conflict_level is replaced by a field corrective_region and
it takes a conflict region, e.g., FAR, MID, NEAR, instead of a
number. The reason for this change is that different alerters may
configure the corrective volume at a different alerting level.

Programatic Configuration

It works as follows.

daa.parameters.clearAlerters(); // Remove all alerters
daa.parameters.addAlerter(Alerter. DWC_Phase_I()); // This put DWC_Phase_I alerter at the index 0
Alerter alerter1 = new Alerter(...);
... configuration of alerter 1 ...
daa.parameters.addAlerter(alerter1);
Aleter alertere2 = new Alerter(...);
... configuration of alerter 2...
daa.parameters.addAlerter(alerter2);
...

Misnomers

  • In the configuration file, the prefix, postfix trk is now hdir
    and gs is now hs. Furthermore, all of them are postfix, e.g.,
    trk_step is now step_hdir. However, DAIDALUS-2 still recognizes
    the field names used in DAIDALUS-1.

  • In the names of methods the prefix/postfix Track and GroundSpeed
    have been replaced by HorizontalDirection and HorizontalSpeed,
    respectively. The reason for this change is that these methods may
    represent ground- or air- based values depending on whether a wind
    vector was configured.

  • The method daa.setWindField(...) is now called
    daa.setWindVelocityTo(...). This clarifies that the "wind field" is
    just a vector and that the direction of the wind is "to". The method
    daa.setWindVelocityFrom(...) can be sued in case the wind vector is
    specified in the "from" direction.

Other Changes

  • The class KinematicMultiBands is now DaidalusBands
  • The class KinematicBands disappeared as its functionality is fully integrated
    into DaidalusBands.
  • The class KinematicBandsCore is now DaidalusBandsCore
  • The class KinematicBandsParameters is now DaidalusParameters

In DaidalusBands (former KinematicMultiBands)

  • track() -> HorizontalDirectionAt()
  • groundSpeed() -> HorizontalSpeedAt()
  • verticalSpeed() -> VerticalSpeedAt()
  • altitude() -> altitudeAt()
  • directionRangeOf -> indexOfHorizontalDirection
  • trackLength -> horizontalDirectionBandsLength
  • groundSpeedLength -> horizontalSpeedBandsLength
  • verticalSpeedLength -> verticalSpeedBandsLength
  • altitudeLength -> altitudeBandsLength
  • timeIntervalOfViolation()-> timeIntervalOfRegionViolation()
  • horizontalSpeed-> horizontalSpeedIntervalAt
  • horizontalSpeedRegion -> horizontalSpeedRegionAt
  • horizontalSpeedRangeOf -> indexOfHorizontalSpeed
  • peripheralDirectionAircraft(level): list<AircraftStates> ->
    peripheralHorizontalDirectionAircraft(region):list<string>
  • peripheralHorizontalSpeedAircraft(level): list<AircraftStates> ->
    peripheralHorizontalSpeedBandsAircraft(region):list<string>
  • peripheralVerticalSpeedAircraft(level): list<AircraftStates> ->
    peripheralVerticalSpeedBandsAircraft(region):list<string>
  • peripheralAltitudeAircraft(level): list<AircraftStates> ->
    peripheralAltitudeBandsAircraft(region):list<string>

In Daidalus:

  • getAircraftState -> getAircraftStateAt
  • timeToViolation -> timeToCorrectiveVolume

Gotchas:

  • Spread bands will now compute UNKNOWN bands, for ranges outside
    min/max values.
  • Check usage of method getUnits from DaidalusParameters as field
    names have changed, e.g., trk_step is now step_hs.
Assets 2
Loading