text:
// ****************************************************************************
// NOTICE
//
// This work was produced for the U.S. Government under Contract 693KA8-22-C-00001
// and is subject to Federal Aviation Administration Acquisition Management System
// Clause 3.5-13, Rights In Data-General, Alt. III and Alt. IV (Oct. 1996).
//
// The contents of this document reflect the views of the author and The MITRE
// Corporation and do not necessarily reflect the views of the Federal Aviation
// Administration (FAA) or the Department of Transportation (DOT). Neither the FAA
// nor the DOT makes any warranty or guarantee, expressed or implied, concerning
// the content or accuracy of these views.
//
// For further information, please contact The MITRE Corporation, Contracts Management
// Office, 7515 Colshire Drive, McLean, VA 22102-7539, (703) 983-6000.
//
// 2022 The MITRE Corporation. All Rights Reserved.
// ****************************************************************************

#include "gtest/gtest.h"
#include "imalgs/IMAlgorithmLoader.h"
#include "imalgs/IMTimeBasedAchieve.h"
#include "imalgs/IMUtils.h"

using namespace std;
using namespace aaesim::open_source;

namespace aaesim
{
   namespace test
   {
      namespace imalgo
      {

         class IMAchieveTest : public IMAchieve, public ::testing::Test
         {
            // A mock implementation that allows us to get at protected methods in IMAchieve
         protected:
            void SetAssignedSpacingGoal(const IMClearance &clearance) override
            {
               // Not needed for testing, only to build properly
            }

            void SetMaxSpeedDeviationPercentage(const double max_speed_deviation_factor) override
            {
               IMAlgorithm::SetMaxSpeedDeviationPercentage(max_speed_deviation_factor);
            }

         public:
            const double GetSpacingError() const override
            {
               // Not used for testing, only to build
               return 0;
            }
         };

         TEST(IMAlgorithmLoader, getAlgorithmType)
         {
            IMAlgorithmLoader imloader;
            IMUtils::IMAlgorithmTypes none = imloader.GetAlgorithmType("none");
            EXPECT_EQ(IMUtils::IMAlgorithmTypes::NONE, none);

            /* Tests removed: see AAES-1129
            IMUtils::IMAlgorithmTypes precalcAchieve = imloader.GetAlgorithmType("precalcAchieve");
            EXPECT_EQ(IMUtils::IMAlgorithmTypes::KINETICACHIEVE, precalcAchieve);

            IMUtils::IMAlgorithmTypes precalcTargetAchieve = imloader.GetAlgorithmType("precalcTargetAchieve");
            EXPECT_EQ(IMUtils::IMAlgorithmTypes::KINETICTARGETACHIEVE, precalcTargetAchieve);
             */

            IMUtils::IMAlgorithmTypes timeBasedAchieve = imloader.GetAlgorithmType("timeBasedAchieve");
            EXPECT_EQ(IMUtils::IMAlgorithmTypes::TIMEBASEDACHIEVE, timeBasedAchieve);

            IMUtils::IMAlgorithmTypes distBasedAchieve = imloader.GetAlgorithmType("distBasedAchieve");
            EXPECT_EQ(IMUtils::IMAlgorithmTypes::DISTANCEBASEDACHIEVE, distBasedAchieve);
         }

         TEST_F(IMAchieveTest, SetMaxSpeedDeviationPercentage)
         {
            SetMaxSpeedDeviationPercentage(25);
            const double nominal3(3);
            EXPECT_DOUBLE_EQ(HighLimit(nominal3), 3.75);
            EXPECT_DOUBLE_EQ(LowLimit(nominal3), 2.25);
         }

         TEST_F(IMAchieveTest, errorThreshold)
         {

            // Set the distance from ABP at which error threshold becomes constant
            m_error_distance = Units::NauticalMilesLength(0.0);

            // Set the constant term of the error threshold time
            m_time_threshold = Units::SecondsTime(0.0);

            // A negative slope would cause error threshold to increase as ownship approaches ABP
            Units::SecondsPerNauticalMileInvertedSpeed slope_value = m_slope;
            if (slope_value.value() < 0.0)
            {
               FAIL();
            }

            Units::SecondsTime test_time = GetErrorThreshold(Units::NauticalMilesLength(0.0));
            EXPECT_DOUBLE_EQ(test_time.value(), 0.0);

            test_time = GetErrorThreshold(Units::NauticalMilesLength(50.0));
            EXPECT_DOUBLE_EQ(test_time.value(), 12.5);

            test_time = GetErrorThreshold(Units::NauticalMilesLength(-10.0));
            Units::SecondsTime time_threshold = m_time_threshold;
            EXPECT_DOUBLE_EQ(test_time.value(), time_threshold.value());
         }

         TEST(IMUtils, projTargetPosition)
         {
            /*
             * Test the projection method using unit lengths. This geometry is
             * easily diagrammed on paper and then tested.
             */
            vector<HorizontalPath> ownship_horizontal_traj;
            HorizontalPath hp;
            hp.m_segment_type = HorizontalPath::SegmentType::STRAIGHT;
            hp.SetXYPositionMeters(0, 0);
            hp.m_path_length_cumulative_meters = 0;
            hp.m_path_course = 0;
            ownship_horizontal_traj.push_back(hp);
            hp.SetXYPositionMeters(1, 0);
            hp.m_path_length_cumulative_meters = 1;
            ownship_horizontal_traj.push_back(hp);

            // Define the geometry so that expected conditions are mathematically valid
            const Units::MetersLength target_dtg(0.5);
            const Units::Length target_x = Units::MetersLength(0.5);
            const Units::Length target_y = target_x;

            // Test expectations
            const Units::MetersLength tol(1e-10);
            const Units::MetersLength xExpect(0.5), yExpect(0.0), dtgExpect(0.5);

            // test
            Units::MetersLength xProjected, yProjected, dtgProjected;
            bool b1 = IMUtils::ProjectTargetPosition(target_x, target_y, ownship_horizontal_traj,
                                                     xProjected, yProjected, dtgProjected);
            EXPECT_TRUE(b1);
            EXPECT_NEAR(xExpect.value(), xProjected.value(), tol.value());
            EXPECT_NEAR(yExpect.value(), yProjected.value(), tol.value());
            EXPECT_NEAR(dtgExpect.value(), dtgProjected.value(), tol.value());

            /*
             * Check again with a very large cross track error (make target_y big). Note that cte
             * can't be larger than 2.5 NM according to AircraftCalculations algorithms.
             */
            const Units::Length target_y_large = target_x + Units::NauticalMilesLength(2.0);
            bool b2 = IMUtils::ProjectTargetPosition(target_x, target_y_large, ownship_horizontal_traj,
                                                     xProjected, yProjected, dtgProjected);
            EXPECT_TRUE(b2);
            EXPECT_NEAR(xExpect.value(), xProjected.value(), tol.value());
            EXPECT_NEAR(yExpect.value(), yProjected.value(), tol.value());
            EXPECT_NEAR(dtgExpect.value(), dtgProjected.value(), tol.value());

            /*
             * Check again with a state off the back of the route and with minor cross track error.
             */
            const Units::Length target_x_large = Units::MetersLength(hp.GetXPositionMeters()) + Units::NauticalMilesLength(2.0);
            bool b3 = IMUtils::ProjectTargetPosition(target_x_large, target_y, ownship_horizontal_traj,
                                                     xProjected, yProjected, dtgProjected);
            EXPECT_TRUE(b3);
            EXPECT_NEAR(Units::MetersLength(hp.GetXPositionMeters()).value(), xProjected.value(), tol.value());
            EXPECT_NEAR(Units::MetersLength(hp.GetYPositionMeters()).value(), yProjected.value(), tol.value());
            EXPECT_NEAR(Units::MetersLength(target_x_large).value(), dtgProjected.value(), tol.value());

            /*
             * Check again with a state off the back of the route and with significant cross track error.
             */
            const Units::Length large_cte = target_y + Units::NauticalMilesLength(3.0);
            bool b4 = IMUtils::ProjectTargetPosition(target_x_large, large_cte, ownship_horizontal_traj,
                                                     xProjected, yProjected, dtgProjected);
            EXPECT_FALSE(b4);
            EXPECT_LT(dtgProjected, Units::ZERO_LENGTH);
         }

         TEST(IMUtils, projTargetState_simple)
         {
            // Generate hpath
            //   const Units::MetersLength unity = Units::MetersLength(1);

            vector<HorizontalPath> ownship_horizontal_traj;
            HorizontalPath hp0, hp1, hp2;
            hp0.m_segment_type = HorizontalPath::SegmentType::STRAIGHT;
            hp0.SetXYPositionMeters(1, 1);
            hp0.m_path_length_cumulative_meters = 0;
            hp0.m_path_course = PI / 4;
            ownship_horizontal_traj.push_back(hp0);
            hp1.m_segment_type = HorizontalPath::SegmentType::STRAIGHT;
            hp1.SetXYPositionMeters(2, 2);
            hp1.m_path_length_cumulative_meters = hp0.m_path_length_cumulative_meters + sqrt(2);
            hp1.m_path_course = PI / 4;
            ownship_horizontal_traj.push_back(hp1);
            hp2.m_segment_type = HorizontalPath::SegmentType::STRAIGHT;
            hp2.SetXYPositionMeters(3, 3);
            hp2.m_path_length_cumulative_meters = hp1.m_path_length_cumulative_meters + sqrt(2);
            hp2.m_path_course = PI / 4;
            ownship_horizontal_traj.push_back(hp2);

            // Generate test state vector at constant gs that is
            // near the hpath, but not "on"
            const Units::Speed xd = Units::MetersPerSecondSpeed(-0.5), yd = Units::MetersPerSecondSpeed(-0.5);
            const Units::SecondsTime tstep(1);
            interval_management::AircraftState asv;
            asv.Create(
               1000,
               Units::zero(),
               EarthModel::LocalPositionEnu::Of(Units::MetersLength(hp1.GetXPositionMeters()), Units::MetersLength(hp1.GetYPositionMeters()), Units::zero()),
               Units::FeetPerSecondSpeed(xd),
               Units::FeetPerSecondSpeed(yd),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero()
            );

            Units::Length x, y, dtg;
            IMUtils::ProjectTargetPosition(asv.GetPositionX(),
                                           asv.GetPositionY(),
                                           ownship_horizontal_traj,
                                           x,
                                           y,
                                           dtg);

            EXPECT_NEAR(hp1.m_path_length_cumulative_meters, Units::MetersLength(dtg).value(), 0.1);
            EXPECT_NEAR(hp1.GetXPositionMeters(), Units::MetersLength(x).value(), 0.1);
            EXPECT_NEAR(hp1.GetYPositionMeters(), Units::MetersLength(y).value(), 0.1);
         }

         TEST(IMUtils, getCrossingTime)
         {
            vector<HorizontalPath> traj;
            HorizontalPath hp;
            hp.m_segment_type = HorizontalPath::SegmentType::STRAIGHT;
            hp.SetXYPositionMeters(1000, 1000);
            hp.m_path_length_cumulative_meters = 0;
            traj.push_back(hp);
            hp.SetXYPositionMeters(1100, 1000);
            hp.m_path_length_cumulative_meters = 100;
            hp.m_path_course = atan2(3, 4);
            traj.push_back(hp);
            hp.SetXYPositionMeters(1200, 1075);
            hp.m_path_length_cumulative_meters = hp.m_path_length_cumulative_meters + sqrt(100 * 100 + 75 * 75);
            traj.push_back(hp);

            Units::SecondsTime crossingTime;
            bool valid;

            vector<interval_management::AircraftState> states;

            // test with empty states vector (invalid). Case E in the algorithm
            valid = IMUtils::GetCrossingTime(Units::MetersLength(150),
                                             states, traj, crossingTime);
            EXPECT_FALSE(valid);
            interval_management::AircraftState s0;
            s0.Create(
               0,
               Units::SecondsTime(55),
               EarthModel::LocalPositionEnu::Of(Units::MetersLength(1140), Units::MetersLength(1030), Units::zero()),
               Units::MetersPerSecondSpeed(10),
               Units::MetersPerSecondSpeed(7.5),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero()
            );
            states.push_back(s0);

            // Case D in the algorithm
            // test with single-element states vector (valid, will extrapolate, see AAES-633)
            valid = IMUtils::GetCrossingTime(Units::MetersLength(100),
                                             states, traj, crossingTime);
            EXPECT_TRUE(valid);
            EXPECT_NEAR(crossingTime.value(), 59, 0.01);
            interval_management::AircraftState s1;
            s1.Create(0,
               Units::SecondsTime(60.1),
               EarthModel::LocalPositionEnu::Of(Units::MetersLength(1099), Units::MetersLength(1000), Units::zero()),
               Units::MetersPerSecondSpeed(10),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero());
            states.push_back(s1);

            interval_management::AircraftState s2;
            s2.Create(
               0,
               Units::SecondsTime(65),
               EarthModel::LocalPositionEnu::Of(Units::MetersLength(1050), Units::MetersLength(1000), Units::zero()),
               Units::MetersPerSecondSpeed(10),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero()
            );
            states.push_back(s2);

            // Case A in the algorithm
            valid = IMUtils::GetCrossingTime(Units::MetersLength(hp.m_path_length_cumulative_meters),
                                             states, traj, crossingTime);
            EXPECT_TRUE(valid);
            EXPECT_NEAR(crossingTime.value(), 50, 1.0);

            // Case B in the algorithm
            valid = IMUtils::GetCrossingTime(Units::MetersLength(150),
                                             states, traj, crossingTime);
            EXPECT_TRUE(valid);
            EXPECT_NEAR(crossingTime.value(), 55, 0.01);

            // Case B in the algorithm
            valid = IMUtils::GetCrossingTime(Units::MetersLength(100),
                                             states, traj, crossingTime);
            EXPECT_TRUE(valid);
            EXPECT_NEAR(crossingTime.value(), 60, 0.01);

            // Case B in the algorithm
            valid = IMUtils::GetCrossingTime(Units::MetersLength(50),
                                             states, traj, crossingTime);
            EXPECT_TRUE(valid);
            EXPECT_NEAR(crossingTime.value(), 65, 0.01);

            // Case C in the algoirthm
            // 2 seconds after last state, should return true with an extrapolated crossing time
            valid = IMUtils::GetCrossingTime(Units::MetersLength(30),
                                             states, traj, crossingTime);
            EXPECT_TRUE(valid);
            EXPECT_DOUBLE_EQ(67, crossingTime.value());
         }

         TEST(IMUtils, calcTimeBasedExtrapolateForward)
         {
            vector<HorizontalPath> ownship_horizontal_traj;
            HorizontalPath hp;
            hp.m_segment_type = HorizontalPath::SegmentType::STRAIGHT;
            hp.SetXYPositionMeters(0, 0);
            hp.m_path_length_cumulative_meters = 0;
            ownship_horizontal_traj.push_back(hp);
            hp.SetXYPositionMeters(100, 0);
            hp.m_path_length_cumulative_meters = 100;
            ownship_horizontal_traj.push_back(hp);

            // Define the geometry so that expected conditions are mathematically valid
            const Units::Speed gs = Units::MetersPerSecondSpeed(50);
            const Units::MetersLength ownship_dtg(100.0);
            const Units::MetersLength target_dtg(150.0);
            const Units::SecondsTime expectedTime = (target_dtg - ownship_dtg) / gs;
            const Units::Length target_x =
                                    Units::MetersLength(hp.GetXPositionMeters()) + gs * expectedTime,
                                target_y = Units::ZERO_LENGTH;
            interval_management::AircraftState target_state;
            target_state.Create(
               0,
               Units::zero(),
               EarthModel::LocalPositionEnu::Of(target_x, target_y, Units::zero()),
               gs,
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero()
            );

            // test with single-element states vector (valid, will extrapolate, see AAES-633)
            const Units::SecondsTime tol(0.001);
            Units::Length x, y, dtg;
            Units::SecondsTime extrapTime;
            IMUtils::CalculateTimeBasedExtrapolate(ownship_dtg,
                                                   target_state,
                                                   ownship_horizontal_traj,
                                                   extrapTime, x, y, dtg);
            EXPECT_NEAR(expectedTime.value(), extrapTime.value(), tol.value());
         }

         TEST(IMUtils, getTimeBasedExtrapolateStateForward)
         {
            /*
             * Place the target behind the ownship and calculate when it will get to ownship's position and what that state will be.
             */

            vector<HorizontalPath> ownship_horizontal_traj;
            HorizontalPath hp;
            hp.m_segment_type = HorizontalPath::SegmentType::STRAIGHT;
            hp.SetXYPositionMeters(0, 0);
            hp.m_path_length_cumulative_meters = 0;
            ownship_horizontal_traj.push_back(hp);
            hp.SetXYPositionMeters(100, 0);
            hp.m_path_length_cumulative_meters = 100;
            ownship_horizontal_traj.push_back(hp);

            // Define the geometry so that expected conditions are mathematically valid
            interval_management::AircraftState ownship_state;
            ownship_state.Create(
               0,
               Units::zero(),
               EarthModel::LocalPositionEnu::Of(Units::MetersLength(hp.GetXPositionMeters()), Units::MetersLength(hp.GetYPositionMeters()), Units::zero()),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero()
            );

            const Units::Speed target_gs = Units::MetersPerSecondSpeed(50);
            const Units::MetersLength ownship_dtg(hp.m_path_length_cumulative_meters);
            const Units::SecondsTime timediff(-1.0); // make them this number of seconds apart, negative means target further away
            const Units::MetersLength target_dtg =
                ownship_dtg - Units::FeetPerSecondSpeed(target_gs) * timediff; // make target further away based on gs
            const Units::SecondsTime expectedTime = (target_dtg - ownship_dtg) / target_gs;
            const Units::Length target_x = Units::MetersLength(hp.GetXPositionMeters()) + (target_dtg - ownship_dtg), target_y = Units::ZERO_LENGTH;
            interval_management::AircraftState target_state;
            target_state.Create(
               0,
               Units::zero(),
               EarthModel::LocalPositionEnu::Of(target_x, target_y, Units::zero()),
               target_gs,
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero()
            );

            // get the estimated state
            Units::SecondsTime msi;
            interval_management::AircraftState actual;
            IMUtils::GetTimeBasedExtrapolateState(ownship_state,
                                                  target_state,
                                                  ownship_horizontal_traj,
                                                  ownship_horizontal_traj,
                                                  msi,
                                                  actual);

            // Asserts
            const Units::SecondsTime toltime(0.001);
            const Units::MetersLength tolxy(1e-5);
            const Units::MetersLength tolxyd(1e-5);
            EXPECT_NEAR(ownship_state.m_x, actual.m_x, tolxy.value());
            EXPECT_NEAR(ownship_state.m_y, actual.m_y, tolxy.value());
            EXPECT_NEAR(target_state.m_xd, actual.m_xd, tolxyd.value());
            EXPECT_NEAR(target_state.m_yd, actual.m_yd, tolxyd.value());
            EXPECT_NEAR(ownship_dtg.value(), actual.m_distance_to_go_meters, tolxy.value());
            EXPECT_NEAR(expectedTime.value(), actual.GetTimeStamp().value(), toltime.value());
            EXPECT_NEAR(timediff.value(), msi.value(), toltime.value());
         }

         TEST(IMUtils, calcTimeBasedExtrapolateBackward)
         {
            vector<HorizontalPath> ownship_horizontal_traj;
            HorizontalPath hp;
            hp.m_segment_type = HorizontalPath::SegmentType::STRAIGHT;
            hp.SetXYPositionMeters(0, 0);
            hp.m_path_length_cumulative_meters = 0;
            ownship_horizontal_traj.push_back(hp);
            hp.SetXYPositionMeters(100, 0);
            hp.m_path_length_cumulative_meters = 100;
            ownship_horizontal_traj.push_back(hp);

            // Define the geometry so that expected conditions are mathematically valid
            const Units::Speed target_gs = Units::MetersPerSecondSpeed(50);
            const Units::MetersLength ownship_dtg(100.0);
            const Units::MetersLength target_dtg(50.0);
            const Units::SecondsTime expectedTime = (target_dtg - ownship_dtg) / target_gs;
            const Units::Length target_x =
                                    Units::MetersLength(hp.GetXPositionMeters()) + target_gs * expectedTime,
                                target_y = Units::ZERO_LENGTH;
            interval_management::AircraftState target_state;
            target_state.Create(
               0,
               Units::zero(),
               EarthModel::LocalPositionEnu::Of(target_x, target_y, Units::zero()),
               target_gs,
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero()
            );

            // test with single-element states vector (valid, will extrapolate, see AAES-633)
            const Units::SecondsTime tol(0.001);
            Units::SecondsTime extrapTime;
            Units::Length x, y, dtg;
            IMUtils::CalculateTimeBasedExtrapolate(ownship_dtg,
                                                   target_state,
                                                   ownship_horizontal_traj,
                                                   extrapTime, x, y, dtg);
            EXPECT_NEAR(expectedTime.value(), extrapTime.value(), tol.value());
         }

         TEST(IMUtils, getMergePoint)
         {
            Units::MetersLength xAC0(0.0), yAC0(-18660.0), xFAP(0.0), yFAP(0.0), xAC1(5000), yAC1(-18660), xM(0), yM(0);
            Units::DegreesAngle courseAC1(120);
            IMUtils::CalculateMergePoint(xAC0, yAC0, xFAP, yFAP, xAC1, yAC1, xM, yM, courseAC1);
            EXPECT_NEAR((Units::MetersLength(xM)).value(), 0.0, 0.5);
            EXPECT_NEAR(yM.value(), -10000.0, 0.5);

            xAC0 = Units::MetersLength(13660);
            yAC0 = Units::MetersLength(5000);
            xFAP = Units::MetersLength(-5000);
            yFAP = Units::MetersLength(5000);
            xAC1 = Units::MetersLength(13660);
            yAC1 = Units::MetersLength(10000);
            courseAC1 = Units::DegreesAngle(210);
            IMUtils::CalculateMergePoint(xAC0, yAC0, xFAP, yFAP, xAC1, yAC1, xM, yM, courseAC1);
            EXPECT_NEAR(xM.value(), 5000.0, 0.5);
            EXPECT_NEAR(yM.value(), 5000.0, 0.5);
         }

         TEST(IMUtils, GetMergePointAllQuadrants)
         {

            const Units::MetersLength tolerance(1e-5);

            // Quadrant 1
            Units::MetersLength xAC0(0.0), yAC0(0.0), xFAP(10.0), yFAP(10.0), xAC1(5.0), yAC1(0.0), xMerge(0), yMerge(0);
            Units::MetersLength expected_merge_x(5.0), expected_merge_y(5.0);
            Units::SignedDegreesAngle courseAC1(90.0);
            IMUtils::CalculateMergePoint(xAC0, yAC0, xFAP, yFAP, xAC1, yAC1, xMerge, yMerge, courseAC1);
            EXPECT_NEAR(expected_merge_x.value(), xMerge.value(), tolerance.value());
            EXPECT_NEAR(expected_merge_y.value(), yMerge.value(), tolerance.value());

            // Quadrant 2
            xAC0 = Units::MetersLength(0.0);
            yAC0 = Units::MetersLength(0.0);
            xFAP = Units::MetersLength(-10.0);
            yFAP = Units::MetersLength(10.0);
            xAC1 = Units::MetersLength(-5.0);
            yAC1 = Units::MetersLength(0.0);
            xMerge = Units::MetersLength(0);
            yMerge = Units::MetersLength(0);
            expected_merge_x = Units::MetersLength(-5.0);
            expected_merge_y = Units::MetersLength(5.0);
            courseAC1 = Units::SignedDegreesAngle(90.0);
            IMUtils::CalculateMergePoint(xAC0, yAC0, xFAP, yFAP, xAC1, yAC1, xMerge, yMerge, courseAC1);
            EXPECT_NEAR(expected_merge_x.value(), xMerge.value(), tolerance.value());
            EXPECT_NEAR(expected_merge_y.value(), yMerge.value(), tolerance.value());

            // Quadrant 3
            xAC0 = Units::MetersLength(0.0);
            yAC0 = Units::MetersLength(0.0);
            xFAP = Units::MetersLength(-10.0);
            yFAP = Units::MetersLength(-10.0);
            xAC1 = Units::MetersLength(-5.0);
            yAC1 = Units::MetersLength(0.0);
            xMerge = Units::MetersLength(0);
            yMerge = Units::MetersLength(0);
            expected_merge_x = Units::MetersLength(-5.0);
            expected_merge_y = Units::MetersLength(-5.0);
            courseAC1 = Units::SignedDegreesAngle(270.0);
            IMUtils::CalculateMergePoint(xAC0, yAC0, xFAP, yFAP, xAC1, yAC1, xMerge, yMerge, courseAC1);
            EXPECT_NEAR(expected_merge_x.value(), xMerge.value(), tolerance.value());
            EXPECT_NEAR(expected_merge_y.value(), yMerge.value(), tolerance.value());

            // Quadrant 4
            xAC0 = Units::MetersLength(0.0);
            yAC0 = Units::MetersLength(0.0);
            xFAP = Units::MetersLength(10.0);
            yFAP = Units::MetersLength(-10.0);
            xAC1 = Units::MetersLength(5.0);
            yAC1 = Units::MetersLength(0.0);
            xMerge = Units::MetersLength(0);
            yMerge = Units::MetersLength(0);
            expected_merge_x = Units::MetersLength(5.0);
            expected_merge_y = Units::MetersLength(-5.0);
            courseAC1 = Units::SignedDegreesAngle(270.0);
            IMUtils::CalculateMergePoint(xAC0, yAC0, xFAP, yFAP, xAC1, yAC1, xMerge, yMerge, courseAC1);
            EXPECT_NEAR(expected_merge_x.value(), xMerge.value(), tolerance.value());
            EXPECT_NEAR(expected_merge_y.value(), yMerge.value(), tolerance.value());
         }

         TEST(IMUtils, GetTargetState_aaes798)
         {
            // Generate hpath
            const Units::MetersLength basic_segment_length = -IMUtils::BEYOND_END_OF_ROUTE_TOL;
            vector<HorizontalPath> ownship_horizontal_traj;
            HorizontalPath hp0, hp1, hp2;
            hp0.m_segment_type = HorizontalPath::SegmentType::STRAIGHT;
            hp0.SetXYPositionMeters(0, 0);
            hp0.m_path_length_cumulative_meters = 0;
            hp0.m_path_course = PI / 4;
            ownship_horizontal_traj.push_back(hp0);
            hp1.m_segment_type = HorizontalPath::SegmentType::STRAIGHT;
            hp1.SetXYPositionMeters(basic_segment_length.value(), basic_segment_length.value());
            hp1.m_path_length_cumulative_meters = hp0.m_path_length_cumulative_meters + basic_segment_length.value() * sqrt(2);
            hp1.m_path_course = PI / 4;
            ownship_horizontal_traj.push_back(hp1);
            hp2.m_segment_type = HorizontalPath::SegmentType::STRAIGHT;
            hp2.SetXYPositionMeters(2 * basic_segment_length.value(), 2 * basic_segment_length.value());
            hp2.m_path_length_cumulative_meters = hp1.m_path_length_cumulative_meters + basic_segment_length.value() * sqrt(2);
            hp2.m_path_course = PI / 4;
            ownship_horizontal_traj.push_back(hp2);

            // Generate test state vector at constant gs that is
            // near the hpath, but not "on". The ground speed is chosen
            // to ensure the staes go "off" the path
            const Units::SecondsTime tstep(1);
            const Units::Speed xd = -0.75 * basic_segment_length / tstep, yd = -0.75 * basic_segment_length / tstep;
            vector<interval_management::AircraftState> asv(5);
            EarthModel::LocalPositionEnu enu_pos;
            enu_pos.x = Units::MetersLength(hp2.GetXPositionMeters()) - Units::FeetLength(0.1);
            enu_pos.y = Units::MetersLength(hp2.GetYPositionMeters()) - Units::FeetLength(0.2);
            enu_pos.z = Units::zero();
            asv[0].Create(
               5,
               Units::SecondsTime(1000),
               enu_pos,
               Units::FeetPerSecondSpeed(xd),
               Units::FeetPerSecondSpeed(yd),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero()
            );

            for (int i = 1; i < asv.size(); ++i)
            {
               enu_pos.x = asv[i - 1].GetPositionX() + Units::FeetLength(xd * tstep);
               enu_pos.y = asv[i - 1].GetPositionY() + Units::FeetLength(yd * tstep);
               enu_pos.z = Units::zero();
               asv[i].Create(
                  asv[i - 1].GetId(),
                  asv[i - 1].GetTimeStamp() + tstep,
                  enu_pos,
                  Units::FeetPerSecondSpeed(xd),
                  Units::FeetPerSecondSpeed(yd),
                  Units::zero(),
                  Units::zero(),
                  Units::zero(),
                  Units::zero(),
                  Units::zero(),
                  Units::zero(),
                  Units::zero(),
                  Units::zero()
               );
            }

            // Tests
            bool state_valid;
            // time valid, but no state on h_traj
            interval_management::AircraftState interp_result = IMUtils::GetProjectedTargetState(asv, ownship_horizontal_traj,
                                                                           Units::SecondsTime(asv.back().GetTimeStamp().value() - 0.2),
                                                                           Units::Angle(),
                                                                           state_valid); // interpolate
            EXPECT_FALSE(state_valid);

            interval_management::AircraftState extrap_result = IMUtils::GetProjectedTargetState(asv, ownship_horizontal_traj,
                                                                           Units::SecondsTime(asv.back().GetTimeStamp().value() + 0.2),
                                                                           Units::Angle(),
                                                                           state_valid); // extrapolate
            EXPECT_FALSE(state_valid);
         }

         TEST(IMUtils, TargetState)
         {
            vector<HorizontalPath> ownship_horizontal_traj;
            HorizontalPath hp0, hp1, hp2;
            hp0.m_segment_type = HorizontalPath::SegmentType::STRAIGHT;
            hp0.SetXYPositionMeters(1, 1);
            hp0.m_path_length_cumulative_meters = 0;
            hp0.m_path_course = PI / 4;
            ownship_horizontal_traj.push_back(hp0);
            hp1.m_segment_type = HorizontalPath::SegmentType::STRAIGHT;
            hp1.SetXYPositionMeters(2, 2);
            hp1.m_path_length_cumulative_meters = hp0.m_path_length_cumulative_meters + sqrt(2);
            hp1.m_path_course = PI / 4;
            ownship_horizontal_traj.push_back(hp1);
            hp2.m_segment_type = HorizontalPath::SegmentType::STRAIGHT;
            hp2.SetXYPositionMeters(3, 3);
            hp2.m_path_length_cumulative_meters = hp1.m_path_length_cumulative_meters + sqrt(2);
            hp2.m_path_course = PI / 4;
            ownship_horizontal_traj.push_back(hp2);

            // Generate test state vector at constant gs that is
            // near the hpath, but not "on"
            const Units::Speed xd = Units::MetersPerSecondSpeed(-0.5), yd = Units::MetersPerSecondSpeed(-0.5);
            const Units::SecondsTime tstep(1);
            vector<interval_management::AircraftState> asv(5);
            EarthModel::LocalPositionEnu enu_pos;
            enu_pos.x = Units::MetersLength(hp2.GetXPositionMeters()) - Units::FeetLength(0.1);
            enu_pos.y = Units::MetersLength(hp2.GetYPositionMeters()) - Units::FeetLength(0.2);
            enu_pos.z = Units::zero();
            asv[0].Create(
               5,
               Units::zero(),
               enu_pos,
               Units::FeetPerSecondSpeed(xd),
               Units::FeetPerSecondSpeed(yd),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero()
            );

            for (int i = 1; i < asv.size(); ++i)
            {
               EarthModel::LocalPositionEnu enu_pos;
               enu_pos.x = asv[i - 1].GetPositionX() + Units::FeetLength(xd * tstep);
               enu_pos.y = asv[i - 1].GetPositionY() + Units::FeetLength(yd * tstep);
               enu_pos.z = Units::zero();
               asv[i].Create(
                  5,
                  asv[i - 1].GetTimeStamp() + tstep,
                  enu_pos,
                  Units::FeetPerSecondSpeed(xd),
                  Units::FeetPerSecondSpeed(yd),
                  Units::zero(),
                  Units::zero(),
                  Units::zero(),
                  Units::zero(),
                  Units::zero(),
                  Units::zero(),
                  Units::zero(),
                  Units::zero()
               );

            }

            // Tests
            bool built;
            interval_management::AircraftState current_ownship_state;
            current_ownship_state.Create(
               5,
               Units::zero(),
               enu_pos,
               xd,
               yd,
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero()
            );

            // time-too-early, hp2 extrapolated
            interval_management::AircraftState result = IMUtils::GetProjectedTargetState(
               asv,
               ownship_horizontal_traj,
               Units::SecondsTime(asv.front().GetTimeStamp().value() - 0.5),
               current_ownship_state.GetHeadingCcwFromEastRadians(),
               built);
            EXPECT_TRUE(built);
            EXPECT_DOUBLE_EQ(asv.front().GetTimeStamp().value() - 0.5, result.GetTimeStamp().value());
            const Units::FeetLength expectxbefore =
                Units::MetersLength(hp2.GetXPositionMeters()) - xd *
                                                                    cos(current_ownship_state.GetHeadingCcwFromEastRadians()) * Units::SecondsTime(0.5);
            const Units::FeetLength expectybefore =
                Units::MetersLength(hp2.GetYPositionMeters()) - yd *
                                                                    sin(current_ownship_state.GetHeadingCcwFromEastRadians()) * Units::SecondsTime(0.5);

            EXPECT_NEAR(expectxbefore.value(), Units::FeetLength(result.GetPositionX()).value(), 0.2);
            EXPECT_NEAR(expectybefore.value(), Units::FeetLength(result.GetPositionY()).value(), 0.2);

            // time at beginning, should be basically hp2
            result = IMUtils::GetProjectedTargetState(asv, ownship_horizontal_traj, asv.front().GetTimeStamp(),
                                                      Units::Angle(),
                                                      built);
            EXPECT_TRUE(built);
            EXPECT_DOUBLE_EQ(asv.front().GetTimeStamp().value(), result.GetTimeStamp().value());
            EXPECT_NEAR(Units::FeetLength(Units::MetersLength(hp2.GetXPositionMeters())).value(), Units::FeetLength(result.GetPositionX()).value(), 0.2);
            EXPECT_NEAR(Units::FeetLength(Units::MetersLength(hp2.GetYPositionMeters())).value(), Units::FeetLength(result.GetPositionY()).value(), 0.2);

            // time between elements 0 and 1
            const Units::SecondsTime test1_tstep(0.5);
            const Units::Length xboundupper = Units::FeetLength(asv[0].m_x), xboundlower = Units::FeetLength(asv[1].m_x);
            const Units::Length yboundupper = Units::FeetLength(asv[0].m_y), yboundlower = Units::FeetLength(asv[1].m_y);
            result = IMUtils::GetProjectedTargetState(asv, ownship_horizontal_traj, Units::SecondsTime(asv[0].GetTimeStamp().value() + .5),
                                                      Units::Angle(),
                                                      built);
            EXPECT_TRUE(built);
            EXPECT_DOUBLE_EQ(Units::SecondsTime(asv[0].GetTimeStamp().value() + .5).value(), result.GetTimeStamp().value());
            EXPECT_LT(Units::FeetLength(result.GetPositionX()).value(), Units::FeetLength(xboundupper).value());
            EXPECT_GT(Units::FeetLength(result.GetPositionX()).value(), Units::FeetLength(xboundlower).value());
            EXPECT_LT(Units::FeetLength(result.GetPositionY()).value(), Units::FeetLength(yboundupper).value());
            EXPECT_GT(Units::FeetLength(result.GetPositionY()).value(), Units::FeetLength(yboundlower).value());

            // time at element 2, should be basically hp1
            result = IMUtils::GetProjectedTargetState(asv, ownship_horizontal_traj, asv[2].GetTimeStamp(),
                                                      Units::Angle(), built);
            EXPECT_TRUE(built);
            EXPECT_DOUBLE_EQ(asv[2].GetTimeStamp().value(), result.GetTimeStamp().value());
            EXPECT_NEAR(Units::FeetLength(Units::MetersLength(hp1.GetXPositionMeters())).value(), Units::FeetLength(result.GetPositionX()).value(), 0.2);
            EXPECT_NEAR(Units::FeetLength(Units::MetersLength(hp1.GetYPositionMeters())).value(), Units::FeetLength(result.GetPositionY()).value(), 0.2);

            // time at last element, should be basically hp0
            result = IMUtils::GetProjectedTargetState(asv, ownship_horizontal_traj, asv.back().GetTimeStamp(),
                                                      Units::Angle(), built);
            EXPECT_TRUE(built);
            EXPECT_DOUBLE_EQ(asv.back().GetTimeStamp().value(), result.GetTimeStamp().value());
            EXPECT_NEAR(Units::FeetLength(Units::MetersLength(hp0.GetXPositionMeters())).value(), Units::FeetLength(result.GetPositionX()).value(), 0.2);
            EXPECT_NEAR(Units::FeetLength(Units::MetersLength(hp0.GetYPositionMeters())).value(), Units::FeetLength(result.GetPositionY()).value(), 0.2);

            // time after last element, hp0 extrapolated
            result = IMUtils::GetProjectedTargetState(asv, ownship_horizontal_traj, Units::SecondsTime(asv.back().GetTimeStamp().value() + 0.5),
                                                      Units::Angle(), built);
            EXPECT_FALSE(built);
            EXPECT_DOUBLE_EQ(asv.back().GetTimeStamp().value() + 0.5, result.GetTimeStamp().value());
            const Units::FeetLength expectx = Units::MetersLength(hp0.GetXPositionMeters()) + xd * Units::SecondsTime(0.5);
            const Units::FeetLength expecty = Units::MetersLength(hp0.GetYPositionMeters()) + yd * Units::SecondsTime(0.5);
            EXPECT_NEAR(expectx.value(), Units::FeetLength(result.GetPositionX()).value(), 0.2);
            EXPECT_NEAR(expecty.value(), Units::FeetLength(result.GetPositionY()).value(), 0.2);
         }

         TEST(IMUtils, GetTargetStateAtGivenDtgOnOwnshipsPath)
         {

            // Generate straight-line path in one dimension
            vector<HorizontalPath> ownship_horizontal_traj;
            HorizontalPath hp0, hp1; //, hp2;
            hp0.m_segment_type = HorizontalPath::SegmentType::STRAIGHT;
            hp0.SetXYPositionMeters(0, 0);
            hp0.m_path_length_cumulative_meters = 0;
            hp0.m_path_course = 0;
            ownship_horizontal_traj.push_back(hp0);
            hp1.m_segment_type = HorizontalPath::SegmentType::STRAIGHT;
            hp1.SetXYPositionMeters(1, 0);
            hp1.m_path_length_cumulative_meters = 1;
            hp1.m_path_course = 0;
            ownship_horizontal_traj.push_back(hp1);

            // Generate test state vector at constant gs that is
            // near the hpath, but not "on"
            const Units::Speed xd = Units::MetersPerSecondSpeed(-0.2);
            const Units::SecondsTime time_step(1);

            std::vector<interval_management::AircraftState> aircraft_state_history(6);
            EarthModel::LocalPositionEnu enu_pos;
            enu_pos.x = Units::MetersLength(hp1.GetXPositionMeters());
            enu_pos.y = Units::FeetLength(0.5);
            enu_pos.z = Units::zero();
            aircraft_state_history[0].Create(
               5,
               Units::zero(),
               enu_pos,
               Units::FeetPerSecondSpeed(xd),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero()
            );
            aircraft_state_history[0].m_distance_to_go_meters = Units::MetersLength(hp1.GetXPositionMeters()).value();

            for (int i = 1; i < aircraft_state_history.size(); ++i)
            {
               enu_pos.x = aircraft_state_history[i - 1].GetPositionX() + Units::FeetLength(xd * time_step);
               enu_pos.y = Units::FeetLength(0.5);
               enu_pos.z = Units::zero();
               aircraft_state_history[i].Create(
                  aircraft_state_history[i - 1].GetId(),
                  aircraft_state_history[i - 1].GetTimeStamp() + time_step,
                  enu_pos,
                  Units::FeetPerSecondSpeed(xd),
                  Units::zero(),
                  Units::zero(),
                  Units::zero(),
                  Units::zero(),
                  Units::zero(),
                  Units::zero(),
                  Units::zero(),
                  Units::zero(),
                  Units::zero()
               );
               aircraft_state_history[i].m_distance_to_go_meters =
                   Units::MetersLength(aircraft_state_history[i].GetPositionX()).value();

            }

            interval_management::AircraftState result;

            // the y component of the ownship route is zero, so we expect all y values to get projected to 0.
            Units::Length expected_y_value = Units::ZERO_LENGTH;

            interval_management::AircraftState current_state;
            current_state.m_x = Units::FeetLength(Units::MetersLength(ownship_horizontal_traj.back().GetXPositionMeters())).value();
            current_state.m_y = 0;
            current_state.m_xd = Units::FeetPerSecondSpeed(xd).value();
            current_state.m_yd = 0;

            // target distance beyond beginning of ownship route
            Units::MetersLength distance_before_beginning_of_route(1.5);
            result = IMUtils::GetTargetStateOnOwnshipPathForDtg(aircraft_state_history, ownship_horizontal_traj,
                                                                distance_before_beginning_of_route,
                                                                current_state.GetHeadingCcwFromEastRadians());

            Units::Length target_x =
                distance_before_beginning_of_route -
                Units::MetersLength(ownship_horizontal_traj.back().m_path_length_cumulative_meters);
            EXPECT_DOUBLE_EQ(Units::FeetLength(target_x).value(), Units::FeetLength(result.m_x).value());
            EXPECT_NEAR(Units::MetersLength(hp1.GetYPositionMeters()).value(),
                        Units::MetersLength(Units::FeetLength(result.m_y)).value(), 0.0001);

            // distance between elements 0 and 1
            const Units::Length xboundupper = Units::MetersLength(aircraft_state_history[0].m_distance_to_go_meters);
            const Units::Length xboundlower = Units::MetersLength(aircraft_state_history[1].m_distance_to_go_meters);
            result = IMUtils::GetTargetStateOnOwnshipPathForDtg(aircraft_state_history, ownship_horizontal_traj,
                                                                Units::MetersLength(
                                                                    aircraft_state_history[0].m_distance_to_go_meters - 0.1),
                                                                Units::Angle());
            EXPECT_DOUBLE_EQ(Units::SecondsTime(aircraft_state_history[0].GetTimeStamp().value() + 0.5).value(), result.GetTimeStamp().value());
            EXPECT_LT(result.m_x, Units::FeetLength(xboundupper).value());
            EXPECT_GT(result.m_x, Units::FeetLength(xboundlower).value());
            EXPECT_DOUBLE_EQ(Units::FeetLength(expected_y_value).value(), Units::FeetLength(result.m_y).value());

            // distance at element 2
            result = IMUtils::GetTargetStateOnOwnshipPathForDtg(aircraft_state_history, ownship_horizontal_traj,
                                                                Units::MetersLength(aircraft_state_history[2].m_distance_to_go_meters),
                                                                Units::Angle());
            EXPECT_DOUBLE_EQ(aircraft_state_history[2].GetTimeStamp().value(), result.GetTimeStamp().value());
            EXPECT_NEAR(Units::FeetLength(aircraft_state_history[2].m_x).value(), Units::FeetLength(result.m_x).value(), 1e-10);
            EXPECT_DOUBLE_EQ(Units::FeetLength(expected_y_value).value(), Units::FeetLength(result.m_y).value());

            // target at end of route
            result = IMUtils::GetTargetStateOnOwnshipPathForDtg(aircraft_state_history, ownship_horizontal_traj,
                                                                Units::ZERO_LENGTH, Units::Angle());
            EXPECT_DOUBLE_EQ(aircraft_state_history.back().GetTimeStamp().value(), result.GetTimeStamp().value());
            EXPECT_NEAR(Units::FeetLength(aircraft_state_history.back().m_x).value(), Units::FeetLength(result.m_x).value(), 1e-10);
            EXPECT_DOUBLE_EQ(Units::FeetLength(expected_y_value).value(), Units::FeetLength(result.m_y).value());

            // target distance past end of ownship route
            Units::MetersLength distance_beyond_end_of_route(-0.5);
            result = IMUtils::GetTargetStateOnOwnshipPathForDtg(aircraft_state_history, ownship_horizontal_traj,
                                                                distance_beyond_end_of_route, Units::Angle());

            EXPECT_DOUBLE_EQ(Units::FeetLength(distance_beyond_end_of_route).value(), Units::FeetLength(result.m_x).value());
            EXPECT_DOUBLE_EQ(0, Units::FeetLength(result.m_y).value());
         }

         TEST(AircraftState, Create) {
            auto actual_id = 100;
            auto actual_x = Units::MetersLength(10);
            auto actual_y = Units::FeetLength(20);
            auto actual_z = Units::NauticalMilesLength(1);
            auto actual_position = EarthModel::LocalPositionEnu::Of(actual_x, actual_y, actual_z);
            auto actual_xd = Units::MetersPerSecondSpeed(10);
            auto actual_yd = Units::FeetPerSecondSpeed(20);
            auto actual_zd = Units::KnotsSpeed(1);
            auto actual_gamma = Units::DegreesAngle(2);
            auto actual_time = Units::MinutesTime(1);

            interval_management::AircraftState* test_state = new interval_management::AircraftState();
            test_state->Create(
               actual_id,
               actual_time,
               actual_position,
               actual_xd,
               actual_yd,
               actual_zd,
               actual_gamma,
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero(),
               Units::zero()
            );

            EXPECT_EQ(actual_id, test_state->GetId());
            EXPECT_DOUBLE_EQ(Units::SecondsTime(actual_time).value(), test_state->GetTimeStamp().value());
            EXPECT_DOUBLE_EQ(Units::MetersLength(actual_x).value(), Units::MetersLength(test_state->GetPositionX()).value());
            EXPECT_DOUBLE_EQ(Units::MetersLength(actual_y).value(), Units::MetersLength(test_state->GetPositionY()).value());
            EXPECT_DOUBLE_EQ(Units::MetersLength(actual_z).value(), Units::MetersLength(test_state->GetPositionZ()).value());
            EXPECT_DOUBLE_EQ(Units::MetersPerSecondSpeed(actual_xd).value(), Units::MetersPerSecondSpeed(test_state->GetSpeedXd()).value());
            EXPECT_DOUBLE_EQ(Units::MetersPerSecondSpeed(actual_yd).value(), Units::MetersPerSecondSpeed(test_state->GetSpeedYd()).value());
            EXPECT_DOUBLE_EQ(Units::MetersPerSecondSpeed(actual_zd).value(), Units::MetersPerSecondSpeed(test_state->GetSpeedZd()).value());
            EXPECT_DOUBLE_EQ(Units::RadiansAngle(actual_gamma).value(), Units::RadiansAngle(test_state->GetGamma()).value());
         }

         TEST(IMUtils, ConvertAircraftStates){
            auto actual_id = 100;
            auto actual_x = Units::MetersLength(10);
            auto actual_y = Units::FeetLength(20);
            auto actual_z = Units::NauticalMilesLength(1);
            auto actual_position = EarthModel::LocalPositionEnu::Of(actual_x, actual_y, actual_z);
            auto actual_xd = Units::MetersPerSecondSpeed(10);
            auto actual_yd = Units::FeetPerSecondSpeed(20);
            auto actual_zd = Units::KnotsSpeed(1);
            auto actual_gamma = Units::DegreesAngle(2);
            auto actual_time = Units::MinutesTime(1);
            auto actual_psi = Units::SignedRadiansAngle(Units::arctan2(actual_xd.value(), actual_yd.value()));
            auto actual_sensed_veast = Units::MetersPerSecondSpeed(10);
            auto actual_sensed_vnorth = Units::MetersPerSecondSpeed(5);
            auto actual_sensed_wind_parallel = Units::MetersPerSecondSpeed(3);
            auto actual_sensed_wind_perpendicular = Units::MetersPerSecondSpeed(1);
            auto actual_sensed_temperature = Units::CelsiusTemperature(22);
            interval_management::AircraftState* test_state = new interval_management::AircraftState();
            test_state->Create(
               actual_id,
               actual_time,
               actual_position,
               actual_xd,
               actual_yd,
               actual_zd,
               actual_gamma,
               actual_sensed_veast,
               actual_sensed_vnorth,
               actual_sensed_wind_parallel,
               actual_sensed_wind_perpendicular,
               actual_sensed_temperature,
               actual_psi
            );

            // This is the tested method
            // convert to aaesim::open_source::AircraftState
            const aaesim::open_source::AircraftState converted_state_1 = IMUtils::ConvertToAaesimAircraftState(*test_state);

            // assert data transferred
            EXPECT_EQ(actual_id, converted_state_1.m_id);
            EXPECT_DOUBLE_EQ(Units::SecondsTime(actual_time).value(), converted_state_1.m_time);
            EXPECT_DOUBLE_EQ(Units::MetersLength(actual_x).value(), Units::MetersLength(converted_state_1.GetPositionX()).value());
            EXPECT_DOUBLE_EQ(Units::MetersLength(actual_y).value(), Units::MetersLength(converted_state_1.GetPositionY()).value());
            EXPECT_DOUBLE_EQ(Units::MetersLength(actual_z).value(), Units::MetersLength(converted_state_1.GetPositionZ()).value());
            EXPECT_DOUBLE_EQ(Units::MetersPerSecondSpeed(actual_xd).value(), Units::MetersPerSecondSpeed(converted_state_1.GetSpeedXd()).value());
            EXPECT_DOUBLE_EQ(Units::MetersPerSecondSpeed(actual_yd).value(), Units::MetersPerSecondSpeed(converted_state_1.GetSpeedYd()).value());
            EXPECT_DOUBLE_EQ(Units::MetersPerSecondSpeed(actual_zd).value(), Units::MetersPerSecondSpeed(converted_state_1.GetSpeedZd()).value());
            EXPECT_DOUBLE_EQ(Units::RadiansAngle(actual_gamma).value(), converted_state_1.m_gamma);
            EXPECT_DOUBLE_EQ(Units::RadiansAngle(actual_psi).value(), Units::RadiansAngle(converted_state_1.m_psi).value());
            EXPECT_DOUBLE_EQ(Units::CelsiusTemperature(actual_sensed_temperature).value(), Units::CelsiusTemperature(converted_state_1.m_sensed_temperature).value());
            EXPECT_DOUBLE_EQ(Units::MetersPerSecondSpeed(actual_sensed_veast).value(), converted_state_1.m_Vwx);
            EXPECT_DOUBLE_EQ(Units::MetersPerSecondSpeed(actual_sensed_vnorth).value(), converted_state_1.m_Vwy);
            EXPECT_DOUBLE_EQ(Units::MetersPerSecondSpeed(actual_sensed_wind_parallel).value(), converted_state_1.m_Vw_para);
            EXPECT_DOUBLE_EQ(Units::MetersPerSecondSpeed(actual_sensed_wind_perpendicular).value(), converted_state_1.m_Vw_perp);

            // This is the tested method
            // convert to interval_management::AircraftState
            const interval_management::AircraftState converted_state_2 = IMUtils::ConvertToIntervalManagementAircraftState(converted_state_1);

            // assert data transferred
            EXPECT_EQ(actual_id, converted_state_2.GetId());
            EXPECT_DOUBLE_EQ(Units::SecondsTime(actual_time).value(), converted_state_2.GetTimeStamp().value());
            EXPECT_DOUBLE_EQ(Units::MetersLength(actual_x).value(), Units::MetersLength(converted_state_2.GetPositionX()).value());
            EXPECT_DOUBLE_EQ(Units::MetersLength(actual_y).value(), Units::MetersLength(converted_state_2.GetPositionY()).value());
            EXPECT_DOUBLE_EQ(Units::MetersLength(actual_z).value(), Units::MetersLength(converted_state_2.GetPositionZ()).value());
            EXPECT_DOUBLE_EQ(Units::MetersPerSecondSpeed(actual_xd).value(), Units::MetersPerSecondSpeed(converted_state_2.GetSpeedXd()).value());
            EXPECT_DOUBLE_EQ(Units::MetersPerSecondSpeed(actual_yd).value(), Units::MetersPerSecondSpeed(converted_state_2.GetSpeedYd()).value());
            EXPECT_DOUBLE_EQ(Units::MetersPerSecondSpeed(actual_zd).value(), Units::MetersPerSecondSpeed(converted_state_2.GetSpeedZd()).value());
            EXPECT_DOUBLE_EQ(Units::RadiansAngle(actual_gamma).value(), Units::RadiansAngle(converted_state_2.GetGamma()).value());
            EXPECT_DOUBLE_EQ(Units::RadiansAngle(actual_psi).value(), Units::RadiansAngle(converted_state_2.GetPsi()).value());
            EXPECT_DOUBLE_EQ(Units::CelsiusTemperature(actual_sensed_temperature).value(), Units::CelsiusTemperature(converted_state_2.GetSensedTemperature()).value());
            EXPECT_DOUBLE_EQ(Units::MetersPerSecondSpeed(actual_sensed_veast).value(), Units::MetersPerSecondSpeed(converted_state_2.GetSensedWindEastComponent()).value());
            EXPECT_DOUBLE_EQ(Units::MetersPerSecondSpeed(actual_sensed_vnorth).value(), Units::MetersPerSecondSpeed(converted_state_2.GetSensedWindNorthComponent()).value());
            EXPECT_DOUBLE_EQ(Units::MetersPerSecondSpeed(actual_sensed_wind_parallel).value(), Units::MetersPerSecondSpeed(converted_state_2.GetSensedWindParallelComponent()).value());
            EXPECT_DOUBLE_EQ(Units::MetersPerSecondSpeed(actual_sensed_wind_perpendicular).value(), Units::MetersPerSecondSpeed(converted_state_2.GetSensedWindPerpendicularComponent()).value());
         }
      }
   }
}

redpajama_set_name: RedPajamaGithub


A volume, containing the conference papers and discussions, was published on 25 August 2015.
The theme of the Reserve Bank of Australia's conference in 2015 was 'Small Business Conditions and Finance'. The conference brought together senior central bankers, finance providers, small business representatives and leading academics to discuss the unique challenges faced by small business.
The discussions focused on a wide range of topics, including the challenges of obtaining small business finance, the diversity of Australian small business, the role of small businesses in driving the overall Australian economy, and the future of small business in Australia.
SME Access to Intermediated Credit: What Do We Know and What Don't We Know?
Does Innovation Make (SME) Firms More Productive?
Panel Discussion: What is the Future for Small Business?


Image Title: Amazon Com Wine Racks America Ponderosa Pine 4 Column 10 Row Inside Plans 2. Post Title: Wine Racks America. Filename: amazon-com-wine-racks-america-ponderosa-pine-4-column-10-row-inside-plans-2.jpg. Image Dimension: 461 x 879 pixels. Images Format: jpg/jpeg. Publisher/Author: msdathletics. Uploaded Date: Sunday - January 27th. 2019 15:47:06 PM. Category: Architecture. Image Source: archdaily.com. Wine Racks America Customizing Storage One Cellar At A Time In Design 12. Wine Racks America Inc Furniture Stores 360 N 700th W North With Regard To Ideas 13. Wine Racks America Small Decorative Cellar Arch Time For WINE Idea 8. Wine Racks America Customer Testimonials Regarding Remodel 10. Amazon Com Wine Racks America Redwood 36 Bottle Stackable 13 For Plan 9. Amazon Com Wine Racks America Redwood 18 Bottle Mini Scallop 13 Throughout Plans 14. Amazon Com Wine Racks America Redwood 48 Bottle Table Top 13 Within Remodel 5. Amazon Com Wine Racks America Redwood 1 Column 8 Row Display Top Inside Plan 11. DIY Wine Cellar Kits InstaCellar By Racks America With Plan 16. Amazon Com Wine Racks America Ponderosa Pine 4 Column 10 Row Inside Plans 2.


text:
Cheap flights from Minot to Los Angeles (MOT - LAX)
Home North America USA California Los Angeles Cheap flights from Minot to Los Angeles
Minot (MOT) to Los Angeles (LAX)
MOT - LAX
68 - 89.6 °F
From Minot to Los Angeles
One-way flight from Minot to Los Angeles
What is the cheapest day to fly round-trip from Minot to Los Angeles?
How far in advance should I book a flight from Minot to Los Angeles?
Travelers have found it's best to book a flight 17 days in advance to save up to 20% compared to booking the same week of travel. As your travel date approaches, the cost of this flight route may potentially increase. While opting to book 17 days out may not be an option for all, there are still additional ways to secure a deal in the near future. You might find a flight from Minot to Los Angeles 1-2 weeks in advance for as low as $75, or $95 for flights within the next 24 hours.
What is the cheapest month to fly from Minot to Los Angeles?
The best pricing can be found in the month of April. Prices to Los Angeles from Minot average $86. You can even find prices in April for less than $86, as users have found deals to Los Angeles from as low as $43. The month of December appears to be one of the more expensive times to travel to Los Angeles from Minot. Flying in the targeted month can save you up to 23%.
When is the cheapest time to fly from Minot to Los Angeles (MOT - LAX)?
A simple way to save on the total cost of your ticket is to fly from Minot to Los Angeles in the evening. If you're flexible enough to do this you can expect to save up to 22% on your trip compared to booking a flight in the morning.
Cheap flights from Minot to Los Angeles in January, February 2021
The best prices found for MOT to LAX flights for January, February
Minot to Los Angeles 2021 flight deals
Cheap flights to Los Angeles from Minot found for this year
One-way flights to Los Angeles from Minot
The cheapest one-way flights from Minot to Los Angeles
Useful info, stats and facts about Minot to Los Angeles flights.
Are flight prices decreasing from Minot to Los Angeles due to COVID-19 (coronavirus)?
At this time, Cheapflights has noticed price decreases for many domestic flights due to COVID-19. Travel is not necessarily recommended at this time, and flights may be prone to cancellation: please check with local authorities in both Minot and Los Angeles for travel alerts, and be sure to review the airline's cancellation policy and travel advisories before booking. For more information, please view our post on what to know about COVID-19 (coronavirus) and travel.
What safety measures are being taken by airlines flying from Minot to Los Angeles to control the spread of COVID-19?
Airlines globally have implemented additional safety measures to accommodate you. Delta is one of them. Airline carriers are regularly disinfecting and sanitizing their aircraft. Masks are provided and are mandatory while on board. Pre-flight testing for symptoms and antibodies, alongside socially distanced seating (for a limited time) will work towards keeping travelers safer while flying from Minot to Los Angeles. Policies will vary by airline.
Which airlines flying from Minot to Los Angeles have flexible cancellations due to COVID-19?
Some of our airline partners flying from Minot to Los Angeles have new flexible policies in place due to COVID-19. United Airlines and Delta are some of the carriers where you may find flexible cancellation policies. You can use our site to filter for airlines like United Airlines with this kind of flexibility.
Can I find flights from Minot to Los Angeles for under $400 on Cheapflights?
Yes, there are multiple flights from Minot to Los Angeles for under $400. The cheapest flight booked recently is on Delta for just $319, but on average you can expect to pay $461.
Are there nonstop flights from Minot to Los Angeles for under $300 on Cheapflights?
There are no nonstop flights from Minot to Los Angeles, but Cheapflights can provide you with all the information you need to find the fastest route with the fewest stops.
Does it rain more in Minot or Los Angeles?
Minot will have greater rainfall in 0 compared to Los Angeles over the next 1 days.
Is Minot weather warmer or cooler than Los Angeles?
You can imagine temperatures to be in the 90 °F range in August. The weather in Los Angeles is generally hotter than Minot's. As flight availability is subject to become more limited as peak season approaches it is ideal to book in a timely manner.
How long is the flight from Minot to Los Angeles?
A quick flight from Minot to Los Angeles can take about 6h 22m. Delta provides one of the quickest options available for as low as $708. This flight may include one or multiple stops.
What are the cheapest airlines flying from Minot to Los Angeles round-trip?
Our cheapest airline available from Minot to Los Angeles is Delta. Our recent data shows that you can find tickets from as low as $319 on this airline. An additional option worth looking into is United Airlines, starting at $335. Delta is 26% cheaper than the average price of flights available within the next 90 days to this destination.
What are the cheapest airlines to fly from Minot to Los Angeles one-way?
To fly one-way, consider booking your trip with United Airlines, which is currently one of the cheapest options available, starting at $256. United Airlines is not the only option available. At the moment, Delta is another option, for $259.
Flights to Los Angeles from Minot
Flights to Minot Flights to Los Angeles Flights from Minot Flights from Los Angeles
Car Rentals in Los Angeles Car Rentals in California Car Rentals at Los Angeles International
Alternative routes for Minot to Los Angeles
Grand Forks to Los Angeles from $319 pp
Jamestown to Los Angeles from $326 pp
Fargo to Bakersfield from $945 pp
Bismarck to Bakersfield from $1,282 pp
Destination information for Los Angeles
Things to know before you go. Useful info for your trip from Minot to Los Angeles
Average temperature for January in Los Angeles
Avg rainfall for January in Los Angeles
Airports servicing Minot
Minot (MOT)
Airports servicing Los Angeles
Flights to Reagan National
Flights from Miami to Cancun
Flights from Los Angeles to Melbourne
Flights from Kansas City to Denver
Flights from Fort Lauderdale to Boston
Flights to Delaware
Flights from New York to New Orleans
Flights from Minot to Lubbock

redpajama_set_name: RedPajamaCommonCrawl


Quality First,and Customer Supreme is our guideline to provide the best service to our customers.Nowadays, we are trying our best to become one of the best exporters in our field to meet customers more need for High Quality Water Pistol , high quality water pistol , Small Water Pistol , We sincerely welcome friends from all over the world to cooperate with us on the basis of long-term mutual benefits.
"Good quality comes 1st; assistance is foremost; business enterprise is cooperation"" is our business enterprise philosophy which is regularly observed and pursued by our company for High Quality Water Pistol , high quality water pistol , Small Water Pistol , Wide selection and fast delivery to suit your needs! Our philosophy: Good quality great service keep improving. We are looking forward that more and more oversea friends join in our family for further development near the future!


Flat Plastic Miniatures - Weird Wars Rome is a 64-piece pack of tabletop miniatures for the Weird Wars Rome campaign setting by Pinnacle Entertainment Group. "Join the forces of Rome and battle through the ages against her enemies. Discover the terrible secrets left out of the history books. Save your shieldmates. Save the Empire."
Includes centurions, legionaries, auxilia, nobles, praetorians, civilians, Britons, Druids, Dacian, Germans, Nubians, Hoplites, and more.
Includes 8 round bases. ©Pinnacle Entertainment Group.
Interested in more Weird Wars Rome? Check out our WWR Horde Packs.


This is a published formula originally designed for use with x-ray materials and is now recognized as an excellent developer for aero films and plates when high contrast is desired. D-19 Film Developer is a high-contrast developer used primarily for scientific applications with spectroscopic films and plates, high resolution plates and films like Tech Pan and high speed Infrared. D-19 provides higher than normal contrast and speed, higher than average graininess, high capacity, clean working and fast acting.
I like using D-19 on infra-red film to get the big popcorn grain, and also on regular films for edgy high-contrast.
Easy to follow instructions, every item clearly labelled. Highly recommended developer for super 8 and 16mm reversal black and white film.


text:
Click A Button Above to Choose a Stream
Kool Hits 1057 Staff
Jim Forrest
Jim is a 1973 graduate of Fairview High School, in Ashland, and a Graduate of Morehead State University. He is also pastor of Danleyton Missionary Baptist Church, in Flatwoods, Ky. In his free time Jim enjoys spending time with his wife Dreama and watching sports and history programs.
The Professor & Stefanie
Originally from Bluefield, WV, Prof relocated to the
Tri-State in 2010. In 2012, he began his radio career
as a board operator in Huntington, then was
promoted to co-host of the "Woody & Professor
Show." Once the mic is off, he is organist of Fifth
Avenue Baptist Church, a pilot-in-training, the proud owner of a 1926 Model T Ford, and long-suffering dog parent of two greyhounds—Sven and Lizzie.
Originally from St. Albans, WV, Stefanie Kerr came to the Tri-State to attend Marshall University. After graduating with a degree in Broadcasting, she worked many jobs in radio in Huntington. When not on the air, she enjoys reading, cooking and hanging out with her husband Nathan.
MJ McKay
M.J. McKay is the son of former Tri-State radio personality "The Mole". M.J. has always been fascinated with the inner workings of the radio business. He started his radio career in May of 2003 and has been at WLGC ever since. He has a degree in Electronic Media from Ohio University and has also worked behind the scenes at WSAZ-TV.
Ernie G. Anderson
2 - 6pm
Originally fron Brooklyn, New York, Ernie moved to Logan, West Virginia at an early age and begain his radio career at WLOG Radio, in Logan. He later went on to host the popular radio request show "The Top 10 at 10" and the high school quiz show "High Q". Ernie lives in Milton, WV with his dog, Bark Twain.
Dwayne Elliot
6pm - 10pm
A graduate of Ashland Paul Blazer High School, Dwayne has been in the radio business for over 25 years. He loves listening to out of town radio stations and keeping up to date on what's going on in the news.
Derek Levine
10pm - 2am
Derek has been in radio since 2004 and is a Graduate of West Virginla State College with a degree in communications. In His spare time he enjoys spending time with family and hist best friend Arnold, his awesome bulldog. Derek also enjoys exercising, drumming, listening to music and ranibows.
Other Kool Hits Staff
GENERAL MANAGER SPORTS ANNOUNCERS STUDIO PRODUCERS
Jim Forrest James Collier Kent Robinson Dee Luster
Jim Forrest Greg Preston
SALES STAFF Dicky Tiller Chauncey Griffith
Dicky Tiller Charlie Dunlap Jason Blanton
Merle Kidwell Jack Hanks Rick Barker Hager Easterling
Site créé avec openElement


text:
Q: Excluding some properties when doing JsonConvert.DeserializeObject on request basis I have the following 2 classes inside my asp.net mvc web application :-
public class Details4
{
    public Details4()
    {

        this.RESOURCECUSTOMFIELD = new List<RESOURCECUSTOMFIELD>();
    }
    [HiddenInput(DisplayValue = false)]
    public string RESOURCENAME { set; get; }
    [Display(Name = "Account Name")]
    [Required]
    public string ACCOUNTNAME { set; get; }

    [Display(Name = "Resource type")]
    [Required]
    public string RESOURCETYPE { set; get; }

    public List<RESOURCECUSTOMFIELD> RESOURCECUSTOMFIELD { set; get; }
}
public class RESOURCECUSTOMFIELD
{
    public string CUSTOMLABEL { set; get; }
    public string CUSTOMVALUE { set; get; }
}

now i am doing the following deserialization , as follow:-
resourceAccountListInfo = JsonConvert.DeserializeObject<Details4>(json);

but in some scenarios i am not interested to deserialize the whole RESOURCECUSTOMFIELD list. while on other i need to deserizlize the RESOURCECUSTOMFIELD list. so is there a way to exclude some properties from the Deserialization process ? i know i can use [JsonIgnore] at the class level , but this will always exclude the related component,, while i am trying to find a way to do this on some methods only ,,, so is there a way to exclude some properties inside this line of code ??:-
resourceAccountListInfo = JsonConvert.DeserializeObject<Details4>(json);

A: What you are looking for is conditionally serializing object members.
Json.NET has this feature . You have to define a public method named ShouldSerialize{MemberName} returning a boolean value.
   public bool ShouldSerializeINSERT_YOUR_PROPERTY_NAME_HERE() {return true; // you can use some condition here}

redpajama_set_name: RedPajamaStackExchange


text:
'use strict'
import React from 'react'
import PropTypes from 'prop-types'
import InputField from '@essappstate/canopy-react-inputfield'

const AuthKeyForm = ({host, update, save}) => {
  if (!host) {
    return

  }
  return (

    <InputField value={host.authkey} change={update} placeholder="Paste in authkey received from host."/>
    <button className="btn btn-primary" onClick={save}>Save</button>

)
}

AuthKeyForm.propTypes = {
  host: PropTypes.object,
  update: PropTypes.func,
  save: PropTypes.func,
}

export default AuthKeyForm


KFC wants to help you escape the Internet for only $10,000.
The fast food chain's latest viral marketing strategy involves a $10,000 "Internet Escape Pod" that apparently forms an impenetrable wall against the Internet and a return to a much simpler time.
If you need one, you can visit KFC's Limited E-Store.


When it will come to residing in distinct residences, you have moved around a couple of occasions. You have lived in the dorm, an condominium, a townhouse and even a duplex. Despite the fact that most of these lodging have been good, they experienced previously been lived in by somebody other than by yourself. They actually did not feel like house. Besides, given that you never owned your personal house, you by no means obtained to make decorating alterations that would make it your own.
But, that is all going to modify. Parc Esta Singapore have ultimately determined to shift into your own house. You want it to be nice, cozy and model new. You have picked the design of home that you want. You have even picked out which area of town that you want to reside in. Even so, the a single factor that you are stumped about considerations the house builder. You never know the slightest factor about what to look for in a builder. This is the initial time that you have at any time bought a residence. Most importantly, this is the 1st time that you are receiving a residence developed to your specs.
Is he willing to perform with you? Locate a house builder that does not have a issue with creating your desire house based mostly on your requirements. When you are seeking for the perfect builder, don't forget that you want a house that is created in accordance to the items that you want and not what the builder is making an attempt to offload to his consumers. Is the builder inclined to customize your residence in accordance to your tastes? Several times builders are willing to develop properties based mostly upon what the property owner desires. Pick the colours for your kitchen area counter tops and cupboards. Select the carpet color for your residing room. Maybe you do not want carpet at all. You would desire hardwood rather. Do not get stuck with what you builder desires. Right after all, you may be paying out the home loan. Pick a residence builder that will allow you make alternatives that will personalize your residence just for you.
Are you into the atmosphere and want your property to mirror this? There are some house builders that will only develop homes with components that are environmentally correct. Does the builder offer you vitality efficient homes? Check out into other residences that he has built in the earlier. Were they created with materials that are bio-degradable? If you are a particular person who is dedicated to residing a eco-friendly life style, these are the types of items that are really essential to you? Why live in a home that does not symbolize the man or woman that you have grow to be?
Does your residence builder have the exact same eyesight that you do? Do you like his residence designs. Locate a property builder who builders classic styled houses, if that is what you have your heart established on. Do not settle for a builder who only builds homes with a modern slant.


Water is the obvious one, but green tea is also another great one. Green tea, and other drinks that contain caffeine, can act as diuretics which make you urinate more often, which is crucial if you are wanting to pass a drug test. Drinking too much water will definitely flush out the majority of the toxins, but it also makes it somewhat obvious that the samples are being diluted intentionally.


College football's top kicking award, the Lou Groza Collegiate Place-Kicker Award sponsored by the Palm Beach County Sports Commission recognizes three of the top kickers each week from FBS division teams as the "Stars of the Week." This week the performances of three of the twenty semi-finalists are highlighted.
Senior kicker Randy Bullock broke the Texas A&M career scoring record when he kicked three field goals and tacked on five extra points in the Aggies' 53-50 overtime loss to Kansas State in Manhattan on Saturday night. The Klein, Texas native connected from 42, 20 and 17 yards. He now has 103 points on the season, second-most in the nation amongst kickers, and became the Aggies' all-time career scoring leader with 326 points. Bullock has made 20 of his 24 field goal attempts this season and is tied for the national lead in field goals made.
Florida State junior Dustin Hopkins moved into a tie for fourth place in the nation in field goals made when he connected from 38, 37 and 21 yards in the Seminoles' 23-19 victory over the Miami Hurricanes in Tallahassee on Saturday. The Houston, Texas native is 18-of-21 on the season and his 85.7 percentage puts him in the top ten nationally. He added two PATs and has not missed any of his 40 extra point tries this season. His 94 points lead the Seminoles in scoring and with 310 career points, he is fifth all-time at Florida State, just behind two-time Lou Groza Award winner Sebastian Janikowski.
Quinn Sharp added twelve points to his national lead in kick-scoring with a 37-yard field goal and nine extra points in Oklahoma State's lopsided 66-6 victory over Texas Tech in Lubbock on Saturday. The junior from Mansfield, Texas has 113 points on the season, having made 16 of his 18 field goal tries and 65 of 66 extra point attempts. His 88.9 field goal percentage is fourth in the nation and his 65 extra points rank second. He is second in scoring for a Cowboys' offense that averages better than 51 points per game.
The presentation of the Lou Groza Award will be featured on The Home Depot College Football Awards live on Thursday, Dec. 8, at 9 p.m. ET on ESPN. The show, hosted by ESPN's Chris Fowler, Lee Corso, Kirk Herbstreit and Desmond Howard will feature the live presentation of nine player awards, along with the recipients of Disney's Spirit Award; The Home Depot Coach of the Year Award, the NCFAA (National College Football Awards Association) Contributions to College Football Award; and student-athletes selected to the Walter Camp All-America Team. Fans can visit the show's dedicated Web site at www.espncollegefootballawards.com to find the latest college football awards news, including show details, previous winners, fan voting, a photo gallery and video highlights.


Youssef started working in restaurants at a young age while continuing his education at the same time. Since then he has achieved some significant milestones in the local hospitality scene. Building his way up the career ladder, he worked in the kitchen of some prominent hotels in the country such as InterContinental hotel and Starwood chain Hotels. Still wanting to improve his skills, he got out of his way to attend the training of Michelin-starred Alain Ducasse. He then went on to take up the position of Chef in charge of La Posta Beirut, establishing a solid reputation in Italian cuisine, all the while hosting a live cooking show. Combining his love of travel with his passion for cooking and eager to learn and be challenged, Youssef headed off to France seeking to master the culinary art at the renowned L'Atelier of Joël Robuchon in Paris, as well as with the acclaimed Nicolas Le Bec in Lyon. After several culinary excursions abroad, including specialization in Gluten and Lactose free pastry from the "Ecole Nationale Superieure De La Patisserie" and "Cuisson Sous-vide a juste temperature" with Bruno Goussault and Joel Robuchon ... Youssef went on to hold the reins of the kitchen brigade in Burgundy Beirut, creating "culinary magic" on a daily basis. His appointment as Executive Chef in Burgundy, in addition to becoming a member of Les Toques Blanches du Monde, a managing partner in Oh Bakehouse, a gluten and lactose-free bakery and pastry, and a managing partner in Paname restaurant are the latest chapters in a rewarding and dynamic career. Always keen to learn and be inspired, Youssef travels all around Europe aspiring to polish his craft by working with well-known chefs such as Chef Jacob Jan Boerma of three Michelin-starred restaurant De Leest in Netherlands, and Chef Bart De Pooter of two Michelin-starred restaurant Pastorale in Belgium.


text:
San Bernardino County Has Paid Nearly $63M to Settle Lawsuits Since 2008
Of the county's 96 settled lawsuits during the period of August 2008 through January 2014, over one-fifth of the civil lawsuits named the San Bernardino County Sheriff's Department as a defendant. Plaintiffs were awarded $13.9 million in damages.
The Arrowhead Regional Medical Center racked up nearly 17% of the cases alone, accounting for $7.2 million worth of payments to plaintiffs.
According to the San Bernardino Sun:
"County spokesman David Wert said the high percentages can be attributed to the fact that the Sheriff's Department and county hospital are among the largest public agencies in the county, with the largest exposure to the public each day and the most vulnerable to liability."
The Sheriff's Department and the county hospital routinely deal with "people who are bleeding, who are in trouble, who or are sick, or who are crime victims or perpetrators," stated Wert. "That's always going to account for your highest level of liability."
It should be noted that these numbers are not unreasonable: in neighboring Riverside County, 35% of the county's settled civil lawsuits named the Sheriff's Department as defendants, and in San Diego County, the Sheriff's Department accounts for a whopping 46% of litigation.
San Bernardino's payouts largely concerned the issue of excessive force, including the death of 400 lb. man who was tased by deputies during a traffic stop at Lake Arrowhead.
For more details on the other settlements—including cases of wrongful termination and high-speed chases—read the full story at the San Bernardino Sun.
PublicCEO2014-03-24T07:07:16-07:00March 24, 2014|Cities|


RAMOS, Ana, COUTINHO, Patrícia, SILVA, Pedro, DAVIDS, Keith, GUIMARÃES, Eduardo and MESQUITA, Isabel (2017). Entropy measures reveal collective tactical behaviours in volleyball teams: how variability and regularity in game actions influence competitive rankings and match status. International Journal of Performance Analysis in Sport, 17 (6), 848-862.
This study analysed and compared the influence of match status and final team rankings on variability of tactical performance behaviours within side-out phase, in female volleyball teams of different competitive levels. Performance data were analysed from matches (n = 8 for each level) in the 2012 Olympic women's volleyball competition (elite level) and the Portuguese women's league (national level) in the 2014–2015 season, with a total of 1496 rallies observed. Variability of setting conditions, attack zone, attack tempo and block opposition were assessed using Shannon entropy measures. Magnitude-based inferences were used to analyse and compare values of selected variables. Results showed that current match status had no influence on tactical performance of elite teams showing that they adapted their collective organisation without losing their game patterns. Analysis of final team rankings showed that, at national level, the highest ranked teams revealed greater unpredictability in all tactical performance measures (mainly in attack tempo and block opposition), emphasising the importance of the setter to differentiate performance of national teams. These findings may guide coaches in designing practice contexts for developing specific game patterns (setting conditions) and in seeking greater variability in other game actions (in attack), regardless of competitive level of performance.


In April 1998, American photographer John S Callahan organised the first surfing project in the Andamans, starting from Phuket in Thailand with the assistance of Southeast Asia Liveaboards, a UK owned dive charter company.With a crew of international professional surfers, they crossed the Andaman Sea on the yacht Crescent and cleared formalities in Port Blair. The group proceeded to Little Andaman Island, where they spent ten days surfing several spots for the first time, including Jarawa Point near Hut Bay and the long right reef point at the southwest tip of the island, named Kumari Point. The resulting article in Surfer Magazine, "Quest for Fire" by journalist Sam George, put the Andaman Islands on the surfing map for the first time.Footage of the waves of the Andaman Islands also appeared in the film Thicker than Water, shot by documentary filmmaker Jack Johnson, who later achieved worldwide fame as a popular musician.Callahan went on to make several more surfing projects in the Andamans, including a trip to the Nicobar Islands in 1999.
It's been over a decade since this beach has been crowned as 'Asia's Best Beach' by TIME magazine, however, it's charm hasn't dropped one bit. Famed for the white sand, breathtaking sunset and turquoise blue waters, Radhanagar beach is amongst the most beautiful places to visit in Andaman and one of the best places in India to visit before you turn 30 . Surely, you'll end up clicking thousands of selfies as the landscape is just picture-perfect!
Trekking is another awesome thing to do in Andaman especially if you're travelling with friends. And if you are trekking buff, then you're going to love this 16 kilometre trek from Mount Harriet to Madhuban. It's a gorgeous route where you can witness exotic flora and fauna of the land amidst spectacular sceneries. Elephant safari is also an option to explore the forest of Mount Harriet.
A museum tour is a great way of getting to know the history and culture of a place. And since these islands are soaked in history you'd find the museums to be few of the greatest places to visit in Andaman. Take a tour down the Anthropological Museum giving insights into the lives of the indigenous tribes of the place and the Samudrika Naval Marine Museum in Port Blair that offers glimpse into the biodiversity of the marine life.
In the North Bay Beach you can walk under the sea and finally visit 'Octopus's Garden'! Colourful school of fishes, coral reefs and various other marine life forms you've never seen before would be swimming right by you. After all, North Bay Beach is the finest place for sea walking in Asia.Also, you don't have to know anything about swimming for this activity! You can normally breathe under the glass helmet. In fact, this is a convenient location for this activity as it is safe and there is no air pressure that bothers.
On 26 December 2004, the coast of the Andaman Islands was devastated by a 10-metre high tsunami following the 2004 Indian Ocean earthquake, which is the longest recorded earthquake, lasting for between 500 and 600 seconds.Strong oral traditions in the area warned of the importance of moving inland after a quake and is credited with saving many lives. In the aftermath, more than 2,000 people were confirmed dead and more than 4,000 children were orphaned or had lost one parent. At least 40,000 residents were rendered homeless and were moved to relief camps.On 11 August 2009, a magnitude 7 earthquake struck near the Andaman Islands, causing a tsunami warning to go into effect. On 30 March 2010, a magnitude 6.9 earthquake struck near the Andaman Islands.
The islands are prominently featured in Arthur Conan Doyle's Sherlock Holmes mystery, The Sign of the Four, as well as in M. M. Kaye's Death in the Andamans. The magistrate in Lady Gregory's play Spreading the News had formerly served in the islands. Marianne Wiggins' novel, John Dollar , is set on one of the islands; the characters begin an expedition from Burma to celebrate King George's birthday and after an earthquake and tsunami it becomes a grim survival story. A principal character in the book Six Suspects by Vikas Swarup is from the Andaman Islands. Kaalapani and Sirai Chaalai, a 1996 Indian film by Priyadarshan, depicts the Indian freedom struggle and the lives of prisoners in the Cellular Jail in Port Blair. Island's End is a 2011 novel by Padma Venkatraman about the training of an indigenous shaman.
The only commercial airport in the islands is Veer Savarkar International Airport in Port Blair, which has scheduled services to Kolkata, Chennai, New Delhi, Bangalore, Visakhapatnam and Bhubaneswar. The airport is under the control of the Indian Navy. Previously, only daylight operations were allowed, but since the beginning of 2016 night flights have also operated.A small airstrip of approximately 1000 metres is located near the Eastern shore of North Andaman near Diglipur.Due to the length of the routes and the small number of airlines flying to the islands, fares have traditionally been relatively expensive, although cheaper for locals than visitors. Fares are high during the peak seasons of spring and winter, although fares have decreased over time due to the expansion of the civil aviation industry in India.


text:
POETRY March 6, 2015
The Beginning and the Beginning Again
Eric Paul
by Eric Paul
I stand in the bathroom doorway, gripping my Virginia Is For Lovers mug while the morning sickness rushes through her like consumers through a box store on Black Friday. I'm doing all the wrong things. I watch as she pukes up a bowling ball. Why the bowling ball? I ask. You're an asshole! she snaps. How can you forget? Our first date was at Lang's Bowlarama. I apologize, understanding that her insides are very outside of her these days. She crawls back into bed. I wait until she falls asleep before heading into the bathroom. I grab the bowling ball out of the toilet and think, This is going to be hard to swallow. Tomorrow, she will throw up a bouquet of flowers. That will go down more easily.
Eric Paul is a writer and musician from Providence, Rhode Island. He has been the lyricist and vocalist for the bands Arab On Radar and The Chinese Stars as well as his current band, Doomsday Student. In 2009 a collection of Eric's lyrics and poetry was released by Heartworm Press titled I Offered Myself As The Sea. Since then, he has released two chapbook and two spoken word releases. Eric holds a BFA in Philosophy from Rhode Island College and an MFA in Creative Writing from Fairleigh Dickinson University. His work has also appeared in Ninth Letter, Word Riot, Spork, Lunch Ticket, The Literary Review, and others.
Eric Paul is a writer and musician from Providence, Rhode Island. He has been the lyricist and vocalist for the bands Arab On Radar and The Chinese Stars as well as his current band, Doomsday Student. In 2009 a collection of Eric's lyrics and poetry was released by Heartworm Press titled I Offered Myself As The Sea. Since then, he has released two chapbook and two spoken word releases. Eric holds a BFA in Philosophy from Rhode Island College and an MFA in Creative Writing from Fairleigh Dickinson University. His work has also appeared in Ninth Letter, Word Riot, Spork, Lunch Ticket, The Literary Review, and others.


Choose your color and we can easily match that color in our store.
We provide all products capable of getting the job done right the first time. Browse through the catalog and see what's in our store for you. Visit any of our three locations to browse through a wide selection our paint and paint supplies.
Custom Paint tinting is a simple process that we provide here at the paint place. Let's walk through this process together. If there is a special color that you are unable to find, you can bring a small sample of the color or material, we can then examine them, color reference our charts and recreate a color with a custom name for your future reference.
In-House Consultation is a stress relieving service here at the Paint Place. A time for you to unwind and for us to dive deep into our customers thoughts. If a customer has a project at hand, we will sit with the client and talk about their ideas and visions while collaborating on their specific venture. Our purpose is to assist and bring those ideas and visions to life, but also making sure they last for a very long time. Teaching our clients about paint, understanding colors and the elements effect on colors is always a pleasure.
With numerous features to help your shopping experience.
The Paint Place has been offering quality products at affordable prices for more than 20 years! We are the sole distributor of Benjamin Moore and Ricahrds Paints in the Bahamas and we offer a variety of brands of, varnishes, wood treatments, paint brushes and sundries as well as industrial coatings. The Maura family has been a reliable source for contractors dating back more than 50 years. Michael Maura has kept the family name in the business relevant over the years, maintaining the same tradition of quality products at affordable prices.
We note considerately the market desire for competitive pricing, quality products and availability. We have three locations; Marsh Harbour, Abaco, Sandyport and Bilney Lane Nassau. Additionally, we have two warehouses fully stocked with inventory as well as our ability to have paint shipments within a ten to fourteen day turnaround.
In addition to offering premium products at affordable prices, we deliver outstanding customer service! We also offer group training for maintenance staff and updates on product application catered specifically to your company's needs. In partnership with our Benjamin Moore International representative we will schedule and respond to your request as needed.
When purchasing on a larger scale, your needs may involve consigning paint to you outside of the Bahamas for shipment under the duty free status the project may enjoy. We can consign shipments, delivered to the port of your choice in Florida. Standard architectural products tinted in a specified color will be available in 50 to 240 gallon quantities in pails only. Larger quantities will require lead time of 7-12 days. Drop ship specials require 100 gallon minimum for pre-paid shipping.
Thank you for the opportunity and please contact us for all of your painting needs.
Simply provide a color and we will do our best to match it.


text:
Der Kranevo Point (englisch; ) ist eine felsige Landspitze im Nordwesten von Tower Island im Palmer-Archipel vor der Westküste der Antarktischen Halbinsel. Sie bildet die südliche Begrenzung der Einfahrt zur Mindya Cove und liegt 2,4 km südwestlich des Kap Leguillou, 3,5 km nördlich des Ustina Point und 5,8 km nordnordwestlich des Peña Point.

Die bulgarische Kommission für Antarktische Geographische Namen benannte sie 2009 nach der Ortschaft Kranewo im Nordosten Bulgariens.

Weblinks
 Kranevo Point im Composite Gazetteer of Antarctica (englisch)

Kap (Antarktika)
Tower Island

redpajama_set_name: RedPajamaWikipedia


text:
Cassian Andor Star Wars series starts shooting, Obi-Wan Kenobi to follow in January
December 5, 2020 by Gary Collinson
FacebookTwitterFlipboardRedditPinterestWhatsApp
With the second season of The Mandalorian currently delighting fans on Disney+, Lucasfilm is preparing to expand the small screen side of the galaxy far, far away with several new series, beginning with the Rogue One: A Star Wars Story spinoff Cassian Andor and followed by Obi-Wan Kenobi.
During an appearance on Jimmy Kimmel Live, Rogue One star Diego Luna has confirmed that production is now underway on the as-yet-untitled Cassian show, which is described as a "rousing spy thriller featuring tales filled with espionage and daring missions to restore hope to a galaxy in the grip of a ruthless Empire."
"It's basically everything you have to know to understand Rogue One," said Luna. "The story of the character before. I can spoil the ending I guess. It's nice to go into a story you already know the ending. Now you can take the nuances and the layers. I think it's fun to do something that isn't just about getting to the end. It's about delaying that."
Meanwhile, although Ewan McGregor has previously said that the hotly-anticipated Obi-Wan Kenobi series will starting filming in March, a production listing from the Film & Television Industry Alliance has suggested that the shoot will actually begin on January 4th. If that proves to be the case, then we should hopefully get some official news about the show and the supporting cast very soon indeed.
The Cassian Andor series features returning Rogue One stars Diego Luna (Cassian Andor), Alan Tudyk (K-2SO) and Genevieve O'Reilly (Mon Mothma), while Star Wars newcomers include Adria Arjona (6 Underground), Stellan Skarsgard (Chernobyl), Denise Gough (The Kid Who Would Be King) and Kyle Soller (101 Dalmatian Street).
Filed Under: Gary Collinson, News, Television Tagged With: Cassian Andor, Disney, Obi-Wan Kenobi, Star Wars
The Most Obscure and Underrated Slashers of the 1980s
Giveaway – Win Inner Sanctum Mysteries: The Complete Film Series
British military action thriller 400 Bullets gets a trailer and poster
Frank Grillo confirms Crossbones return in Marvel's What If…?
Apple TV+'s For All Mankind season 2 trailer has landed
Comic Book Preview – Rorschach #4
LEGO celebrates 10 years of Ninjago with Ninjago City Gardens set
New Batwoman star Javicia Leslie on differentiating her character from Ruby Rose's Kate Kane
WandaVision featurettes delves into the story of the new Marvel series
Comic Book Preview – Maestro: War and Pax #1


Set the water on fire with the Fuego rods from Daiwa! Powerful lightweight graphite construction. This rod features aluminum oxide ring guides with anodized stainless steel hooded reel seat and EVA and cork full length handles. Convenient hook keeper. Two-piece spin or casting rods.