Physics.hpp

Go to the documentation of this file.

// ----------------- BEGIN LICENSE BLOCK ---------------------------------
//
// Copyright (C) 2018-2021 Intel Corporation
//
// SPDX-License-Identifier: LGPL-2.1-only
//
// ----------------- END LICENSE BLOCK -----------------------------------
 
#pragma once
 
#include <vector>
#include "ad/physics/Acceleration.hpp"
#include "ad/physics/Angle.hpp"
#include "ad/physics/AngleRange.hpp"
#include "ad/physics/Distance.hpp"
#include "ad/physics/Duration.hpp"
#include "ad/physics/Speed.hpp"
 
namespace ad {
namespace rss {
namespace core {
 
bool calculateDistanceOffsetInAcceleratedMovement(physics::Speed const speed,
                                                  physics::Acceleration const acceleration,
                                                  physics::Duration const duration,
                                                  physics::Distance &distanceOffset);
 
bool calculateSpeedInAcceleratedMovement(physics::Speed const speed,
                                         physics::Acceleration const acceleration,
                                         physics::Duration const duration,
                                         physics::Speed &resultingSpeed);
 
bool calculateStoppingDistance(physics::Speed const currentSpeed,
                               physics::Acceleration const deceleration,
                               physics::Distance &stoppingDistance);
 
bool calculateAcceleratedLimitedMovement(physics::Speed const currentSpeed,
                                         physics::Speed const max_speed_on_acceleration,
                                         physics::Acceleration const acceleration,
                                         physics::Duration const duration,
                                         physics::Speed &resultingSpeed,
                                         physics::Distance &distanceOffset);
 
bool calculateTimeToCoverDistance(physics::Speed const currentSpeed,
                                  physics::Speed const max_speed_on_acceleration,
                                  physics::Duration const response_time,
                                  physics::Acceleration const aUntilResponseTime,
                                  physics::Acceleration const aAfterResponseTime,
                                  physics::Distance const distanceToCover,
                                  physics::Duration &requiredTime);
 
bool calculateSpeedAndDistanceOffset(physics::Duration const duration,
                                     physics::Speed const currentSpeed,
                                     physics::Duration const response_time,
                                     physics::Speed const max_speed_on_acceleration,
                                     physics::Acceleration const aUntilReponseTime,
                                     physics::Acceleration const aAfterResponseTime,
                                     physics::Speed &resultingSpeed,
                                     physics::Distance &distanceOffset);
 
bool calculateTimeToStop(physics::Speed const currentSpeed,
                         physics::Duration const response_time,
                         physics::Speed const max_speed_on_acceleration,
                         physics::Acceleration const aUntilResponseTime,
                         physics::Acceleration const aAfterResponseTime,
                         physics::Duration &stopDuration);
 
} // namespace core
} // namespace rss
} // namespace ad