hyperray 0.0.1__py3-none-any.whl

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/environments/l2f/parameters/default.h

@@ -0,0 +1,209 @@
+#include "../../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_ENVIRONMENTS_L2F_PARAMETERS_DEFAULT_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_ENVIRONMENTS_L2F_PARAMETERS_DEFAULT_H
+
+#include "../multirotor.h"
+
+#include "dynamics/mrs.h"
+#include "init/default.h"
+#include "reward_functions/default.h"
+#include "termination/default.h"
+#include "registry.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rl::environments::l2f::parameters {
+    template <bool T_ENABLED = false>
+    struct DEFAULT_DOMAIN_RANDOMIZATION_OPTIONS{
+        static constexpr bool ENABLED = T_ENABLED;
+        static constexpr bool THRUST_TO_WEIGHT = ENABLED;
+        static constexpr bool MASS = ENABLED;
+        static constexpr bool TORQUE_TO_INERTIA = ENABLED;
+        static constexpr bool MASS_SIZE_DEVIATION = ENABLED;
+        static constexpr bool ROTOR_TORQUE_CONSTANT = ENABLED;
+        static constexpr bool DISTURBANCE_FORCE = ENABLED;
+        static constexpr bool ROTOR_TIME_CONSTANT = ENABLED;
+    };
+
+    template <typename T, typename TI, TI T_EPISODE_LENGTH_S = 5, typename DOMAIN_RANDOMIZATION_OPTIONS=DEFAULT_DOMAIN_RANDOMIZATION_OPTIONS<>>
+    struct DEFAULT_PARAMETERS_FACTORY{
+        static constexpr auto MODEL = dynamics::REGISTRY::crazyflie;
+        constexpr static auto MODEL_NAME = parameters::dynamics::registry_name<MODEL>;
+
+        using REWARD_FUNCTION = reward_functions::Squared<T>;
+        static constexpr REWARD_FUNCTION reward_function = {
+                false, // non_negative
+                01.00, // scale
+                00.50, // constant
+                -100.00, // termination_penalty
+                01.00, // position
+                00.00, // position_clip
+                00.10, // orientation
+                00.00, // linear_velocity
+                00.00, // angular_velocity
+                00.00, // linear_acceleration
+                00.00, // angular_acceleration
+                {00.00, 00.00, 00.00, 00.00}, // action
+                {01.00, 01.00, 01.00, 01.00}, // d_action
+                00.00, // position_error_integral
+        };
+        struct TRAJECTORY_OPTIONS{
+            static constexpr bool LANGEVIN = false;
+        };
+        static constexpr TI SIMULATION_FREQUENCY = 100;
+        static constexpr TI EPISODE_STEP_LIMIT_OUTER = T_EPISODE_LENGTH_S * SIMULATION_FREQUENCY;
+        static constexpr TI TRAJECTORY_LENGTH = EPISODE_STEP_LIMIT_OUTER;
+        static constexpr TI TRAJECTORY_DT = 1000000/SIMULATION_FREQUENCY; // in microseconds
+
+        using PARAMETERS_SPEC = ParametersBaseSpecification<T, TI, 4, EPISODE_STEP_LIMIT_OUTER, REWARD_FUNCTION>;
+        using PARAMETERS_TYPE = ParametersObservationDelay<ParametersObservationDelaySpecification<T, TI, ParametersTrajectory<ParametersTrajectorySpecification<T, TI, TRAJECTORY_LENGTH, TRAJECTORY_DT, ParametersDomainRandomization<ParametersDomainRandomizationSpecification<T, TI, DOMAIN_RANDOMIZATION_OPTIONS, ParametersDisturbances<ParametersSpecification<T, TI, ParametersIMU<ParametersSpecification<T, TI, ParametersBase<PARAMETERS_SPEC>>>>>>>>>>>;
+
+        static constexpr auto dynamics = l2f::parameters::dynamics::registry<MODEL, PARAMETERS_SPEC>;
+
+        static constexpr auto init = l2f::parameters::init::init_90_deg<PARAMETERS_SPEC>;
+        static constexpr typename PARAMETERS_TYPE::MDP::ActionNoise action_noise = {
+            0, // std of additive gaussian noise onto the normalized action (-1, 1)
+        };
+        static constexpr typename PARAMETERS_TYPE::MDP::Termination termination = {
+            true,  // enable
+            1,     // position
+            0,     // angle (0 = disabled)
+            2,     // linear velocity
+            35,    // angular velocity
+            10000, // position integral
+            50000, // orientation integral
+        };
+        static constexpr typename PARAMETERS_TYPE::MDP mdp = {
+            init,
+            reward_function,
+            { // observation_noise
+                0.00,// position
+                0.00, // orientation
+                0.00, // linear_velocity
+                0.00, // angular_velocity
+                0.00, // imu acceleration
+            },
+            action_noise,
+            termination
+        };
+        static constexpr typename PARAMETERS_TYPE::Integration integration = {
+            1.0/((T)SIMULATION_FREQUENCY) // integration dt
+        };
+        static constexpr typename PARAMETERS_TYPE::DomainRandomization domain_randomization = DOMAIN_RANDOMIZATION_OPTIONS::ENABLED ? typename PARAMETERS_TYPE::DomainRandomization{
+            1.5, // thrust_to_weight_min;
+            5.0, // thrust_to_weight_max;
+            0.001, // thrust_to_weight_by_torque_to_inertia_min;
+            0.100, // thrust_to_weight_by_torque_to_inertia_max;
+            0.02, // mass_min;
+            5.00, // mass_max;
+            0.1, // mass_size_deviation;
+            0.0, // motor_time_constant_rising_min;
+            0.0, // motor_time_constant_rising_max;
+            0.0, // motor_time_constant_falling_min;
+            0.0, // motor_time_constant_falling_max;
+            0.005, // rotor_torque_constant_min;
+            0.05, // rotor_torque_constant_max;
+            0.0, // orientation_offset_angle_max;
+            0.1  // disturbance_force_max;
+        } : typename PARAMETERS_TYPE::DomainRandomization{
+            0, // thrust_to_weight_min;
+            0, // thrust_to_weight_max;
+            0, // thrust_to_weight_by_torque_to_inertia_min;
+            0, // thrust_to_weight_by_torque_to_inertia_max;
+            0, // mass_min;
+            0, // mass_max;
+            0, // mass_size_deviation;
+            0, // motor_time_constant_rising_min;
+            0, // motor_time_constant_rising_max;
+            0, // motor_time_constant_falling_min;
+            0, // motor_time_constant_falling_max;
+            0, // rotor_torque_constant_min;
+            0, // rotor_torque_constant_max;
+            0, // orientation_offset_angle_max;
+            0  // disturbance_force_max;
+        };
+        static constexpr typename PARAMETERS_TYPE::Disturbances disturbances = {
+            typename PARAMETERS_TYPE::Disturbances::UnivariateGaussian{0, 0}, //{0, 0.027 * 9.81 / 3}, // random_force;
+            typename PARAMETERS_TYPE::Disturbances::UnivariateGaussian{0, 0} //{0, 0.027 * 9.81 / 10000} // random_torque;
+        };
+        static constexpr typename PARAMETERS_TYPE::IMU imu = {
+            {{ // accelerometer error
+                {0, 0}, // noise: mean, std
+                {0, 0, 0} // bias: init_max, tau, sigma
+            }},
+            {{ // gyro error
+                {0, 0}, // noise: mean, std
+                {0, 0, 0} // bias: init_max, tau, sigma
+            }}
+        };
+
+        static constexpr typename PARAMETERS_TYPE::Trajectory trajectory = {};
+        static constexpr typename PARAMETERS_TYPE::TrajectoryParameters trajectory_parameters = {
+            rl::environments::l2f::parameters::trajectories::Type::LISSAJOUS,
+            {
+                rl::environments::l2f::parameters::trajectories::lissajous::default_parameters<T>
+            }
+        };
+
+        static constexpr PARAMETERS_TYPE nominal_parameters = {
+            {
+                {
+                    {
+                        {
+                            {
+                                dynamics,
+                                integration,
+                                mdp
+                            }, // Base
+                            imu
+                        }, // IMU
+                        disturbances
+                    }, // Disturbances
+                    domain_randomization
+                }, // DomainRandomization
+                trajectory,
+                trajectory_parameters
+            },
+            {
+                0, // linear_velocity
+                0, // angular_velocity
+            }
+        }; // ObservationDelay
+
+        struct STATIC_PARAMETERS{
+            static constexpr auto ACTION_INTERFACE = ActionInterface::DIRECT_MOTOR;
+            static constexpr TI N_SUBSTEPS = 1;
+            static constexpr TI ACTION_HISTORY_LENGTH = 16;
+            static constexpr TI EPISODE_STEP_LIMIT = EPISODE_STEP_LIMIT_OUTER;
+            static constexpr TI CLOSED_FORM = false;
+            static constexpr TI ANGULAR_VELOCITY_DELAY = 0; // one step at 100hz = 10ms ~ delay from IMU to input to the policy: 1.3ms time constant of the IIR in the IMU (bw ~110Hz) + synchronization delay (2ms) + (negligible SPI transfer latency due to it being interrupt-based) + 1ms sensor.c RTOS loop @ 1khz + 2ms for the RLtools loop
+            static constexpr TI ANGULAR_VELOCITY_HISTORY = ANGULAR_VELOCITY_DELAY;
+            // using STATE_TYPE = StatePoseErrorIntegral<StateSpecification<T, TI, DefaultActionHistoryState<T, TI, ACTION_HISTORY_LENGTH, ANGULAR_VELOCITY_HISTORY>>>;
+            using STATE_TYPE = StateTrajectory<StateSpecification<T, TI, DefaultActionHistoryState<T, TI, ACTION_HISTORY_LENGTH, ANGULAR_VELOCITY_HISTORY>>>;
+            using OBSERVATION_TYPE_MARKOVIAN = DefaultActionHistoryObservation<T, TI, ACTION_HISTORY_LENGTH, ANGULAR_VELOCITY_DELAY,
+                observation::ParametersMotorPosition<observation::ParametersMotorPositionSpecification<T, TI, PARAMETERS_TYPE::N,
+                observation::ParametersThrustCurves<observation::ParametersThrustCurvesSpecification<T, TI, PARAMETERS_TYPE::N,
+                observation::ParametersMass<observation::ParametersMassSpecification<T, TI,
+                observation::ParametersInertia<observation::ParametersInertiaSpecification<T, TI
+                // observation::PoseIntegral<observation::PoseIntegralSpecification<T, TI
+            >>>>>>>>>;
+            using OBSERVATION_TYPE_PO = DefaultActionHistoryObservation<T, TI, ACTION_HISTORY_LENGTH, ANGULAR_VELOCITY_DELAY>;
+            using OBSERVATION_TYPE = OBSERVATION_TYPE_PO;
+            using OBSERVATION_TYPE_PRIVILEGED = OBSERVATION_TYPE;
+            static constexpr bool PRIVILEGED_OBSERVATION_NOISE = false;
+            using PARAMETERS = PARAMETERS_TYPE;
+            static constexpr PARAMETERS PARAMETER_VALUES = nominal_parameters;
+            static constexpr T STATE_LIMIT_POSITION_X = 100000;
+            static constexpr T STATE_LIMIT_POSITION_Y = 100000;
+            static constexpr T STATE_LIMIT_POSITION_Z = 100000;
+            static constexpr T STATE_LIMIT_VELOCITY_X = 100000;
+            static constexpr T STATE_LIMIT_VELOCITY_Y = 100000;
+            static constexpr T STATE_LIMIT_VELOCITY_Z = 100000;
+            static constexpr T STATE_LIMIT_ANGULAR_VELOCITY_X = 100000;
+            static constexpr T STATE_LIMIT_ANGULAR_VELOCITY_Y = 100000;
+            static constexpr T STATE_LIMIT_ANGULAR_VELOCITY_Z = 100000;
+        };
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/environments/l2f/parameters/dynamics/arpl.h

@@ -0,0 +1,112 @@
+#include "../../../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_ENVIRONMENTS_L2F_PARAMETERS_DYNAMICS_ARPL_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_ENVIRONMENTS_L2F_PARAMETERS_DYNAMICS_ARPL_H
+#include "../../multirotor.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rl::environments::l2f::parameters::dynamics{
+    template<typename T, typename TI>
+    constexpr Dynamics<T, TI, 4> arpl = {
+            // Rotor positions
+            {
+                    {
+                            0.0775,
+                            -0.0981,
+                            0
+
+                    },
+                    {
+                            -0.0775,
+                            0.0981,
+                            0
+
+                    },
+                    {
+                            0.0775,
+                            0.0981,
+                            0
+
+                    },
+                    {
+                            -0.0775,
+                            -0.0981,
+                            0
+
+                    },
+            },
+            // Rotor thrust directions
+            {
+                    {0, 0, 1},
+                    {0, 0, 1},
+                    {0, 0, 1},
+                    {0, 0, 1},
+            },
+            // Rotor torque directions
+            {
+                    {0, 0, -1},
+                    {0, 0, -1},
+                    {0, 0, +1},
+                    {0, 0, +1},
+            },
+            // thrust constants
+            {
+                    {-0.5300192490953086, 8.971435376396558, -0.8911788522090669},
+                    {-0.5300192490953086, 8.971435376396558, -0.8911788522090669},
+                    {-0.5300192490953086, 8.971435376396558, -0.8911788522090669},
+                    {-0.5300192490953086, 8.971435376396558, -0.8911788522090669}
+            },
+            // torque constant
+            {0.005964552, 0.005964552, 0.005964552, 0.005964552},
+            // T, RPM time constant
+            {0.033, 0.033, 0.033, 0.033},
+            {0.033, 0.033, 0.033, 0.033},
+            // mass vehicle
+            0.782,
+            // gravity
+            {0, 0, -9.81},
+            // J
+            {
+                    {
+                            1.7665e-3,
+                            0.0,
+                            0.0
+                    },
+                    {
+                            0.0,
+                            1.3766e-3,
+                            0.0
+                    },
+                    {
+                            0.0,
+                            0.0,
+                            (1.7665e-3 + 1.3766e-3)/2 * 1.879
+                    }
+            },
+            // J_inv
+            {
+                    {
+                            1/1.7665e-3,
+                            0.0,
+                            0.0
+                    },
+                    {
+                            0.0,
+                            1/1.3766e-3,
+                            0.0
+                    },
+                    {
+                            0.0,
+                            0.0,
+                            1/((1.7665e-3 + 1.3766e-3)/2 * 1.879)
+                    }
+            },
+            // hovering throttle (julia): sqrt((mass * 9.81/4 - thrust_curve[1])/thrust_curve[3]),
+            0.13095934350152208,
+            // action limit
+            {0.0, 1.0},
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/environments/l2f/parameters/dynamics/crazyflie.h

@@ -0,0 +1,127 @@
+#include "../../../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_ENVIRONMENTS_L2F_PARAMETERS_DYNAMICS_CRAZYFLIE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_ENVIRONMENTS_L2F_PARAMETERS_DYNAMICS_CRAZYFLIE_H
+#include "../../multirotor.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rl::environments::l2f::parameters::dynamics{
+    template<typename T, typename TI> // Crazyflie is a quadrotor
+    constexpr Dynamics<T, TI, 4> crazyflie = {
+            // Rotor positions
+            {
+                    {
+                            0.028,
+                            -0.028,
+                            0
+                    },
+                    {
+                            -0.028,
+                            -0.028,
+                            0
+                    },
+                    {
+                            -0.028,
+                            0.028,
+                            0
+                    },
+                    {
+                            0.028,
+                            0.028,
+                            0
+                    },
+            },
+            // Rotor thrust directions
+            {
+                    {0, 0, 1},
+                    {0, 0, 1},
+                    {0, 0, 1},
+                    {0, 0, 1},
+            },
+            // Rotor torque directions
+            {
+                    {0, 0, -1},
+                    {0, 0, +1},
+                    {0, 0, -1},
+                    {0, 0, +1},
+            },
+            // thrust constants
+            {
+                    // {0.0213, -0.0112, 0.1201},
+                    // {0.0213, -0.0112, 0.1201},
+                    // {0.0213, -0.0112, 0.1201},
+                    // {0.0213, -0.0112, 0.1201}
+                    // {0, 0, 0.1302},
+                    // {0, 0, 0.1302},
+                    // {0, 0, 0.1302},
+                    // {0, 0, 0.1302}
+                    {0.00352526, 0.01437313, 0.09223048},
+                    {0.00352526, 0.01437313, 0.09223048},
+                    {0.00352526, 0.01437313, 0.09223048},
+                    {0.00352526, 0.01437313, 0.09223048},
+            },
+            // torque constant
+            {4.665e-3, 4.665e-3, 4.665e-3, 4.665e-3},
+            // T, RPM time constant
+            { // rising: ~(0.040 - 0.080)s from manufacturer plot
+                    0.05545454545454546,
+                    0.05545454545454546,
+                    0.05545454545454546,
+                    0.05545454545454546
+            },
+            { // falling: ~0.398s from manufacturer plot
+                    0.24939393939393945,
+                    0.24939393939393945,
+                    0.24939393939393945,
+                    0.24939393939393945
+            },
+            // mass vehicle
+            0.027 + 0.0017 + 0.0003 + 0.0016, // take-off-weight, sd card deck, sd card, optical flow deck (v2)
+            // gravity
+            {0, 0, -9.81},
+            // J
+            {
+                    {
+                            9.416556729130406e-06,
+                            0.0,
+                            0.0
+                    },
+                    {
+                            0.0,
+                            9.644051701582312e-06,
+                            0.0
+                    },
+                    {
+                            0.0,
+                            0.0,
+                            1.745951732253285e-05
+                    }
+            },
+            // J_inv
+            {
+                    {
+                            106195.93007988465,
+                            0.0,
+                            0.0
+                    },
+                    {
+                            0.0,
+                            103690.85846314249,
+                            0.0
+                    },
+                    {
+                            0.0,
+                            0.0,
+                            57275.35197719487
+                    }
+            },
+            // hovering throttle (julia): sqrt((mass * 9.81/4 - thrust_curve[1])/thrust_curve[3]),
+//            "hovering_throttle": 14475.809152959684,
+            0.7261389721508553, // "hovering_throttle_relative"
+            // action limit
+            {0, 1},
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/environments/l2f/parameters/dynamics/crazyflie_openmv.h

@@ -0,0 +1,119 @@
+#include "../../../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_ENVIRONMENTS_L2F_PARAMETERS_DYNAMICS_CRAZYFLIE_OPENMV_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_ENVIRONMENTS_L2F_PARAMETERS_DYNAMICS_CRAZYFLIE_OPENMV_H
+#include "../../multirotor.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rl::environments::l2f::parameters::dynamics{
+    template<typename T, typename TI> // Crazyflie is a quadrotor
+    constexpr Dynamics<T, TI, 4> crazyflie_openmv = {
+            // Rotor positions
+            {
+                    {
+                            0.028,
+                            -0.028,
+                            0
+                    },
+                    {
+                            -0.028,
+                            -0.028,
+                            0
+                    },
+                    {
+                            -0.028,
+                            0.028,
+                            0
+                    },
+                    {
+                            0.028,
+                            0.028,
+                            0
+                    },
+            },
+            // Rotor thrust directions
+            {
+                    {0, 0, 1},
+                    {0, 0, 1},
+                    {0, 0, 1},
+                    {0, 0, 1},
+            },
+            // Rotor torque directions
+            {
+                    {0, 0, -1},
+                    {0, 0, +1},
+                    {0, 0, -1},
+                    {0, 0, +1},
+            },
+            // thrust constants
+            {
+                    {0.01244825, 0.05290432, 0.15135338},
+                    {0.01244825, 0.05290432, 0.15135338},
+                    {0.01244825, 0.05290432, 0.15135338},
+                    {0.01244825, 0.05290432, 0.15135338}
+            },
+            // torque constant
+            {4.665e-3, 4.665e-3, 4.665e-3, 4.665e-3},
+            // T, RPM time constant
+            { // rising
+                    0.061,
+                    0.061,
+                    0.061,
+                    0.061
+            },
+            { // falling
+                    0.061,
+                    0.061,
+                    0.061,
+                    0.061
+            },
+            // mass vehicle
+            0.0477,
+            // gravity
+            {0, 0, -9.81},
+            // J
+            {
+                    {
+                            1.543e-5,
+                            0.0,
+                            0.0
+                    },
+                    {
+                            0.0,
+                            1.946e-5,
+                            0.0
+                    },
+                    {
+                            0.0,
+                            0.0,
+                            3.1957e-5
+                    }
+            },
+            // J_inv
+            {
+                    {
+                            64808,
+                            0.0,
+                            0.0
+                    },
+                    {
+                            0.0,
+                            51387,
+                            0.0
+                    },
+                    {
+                            0.0,
+                            0.0,
+                            31292
+                    }
+            },
+            // hovering throttle (julia): sqrt((mass * 9.81/4 - thrust_curve[1])/thrust_curve[3]),
+//            "hovering_throttle": 14475.809152959684,
+            0.68, // "hovering_throttle_relative"
+            // action limit
+            {0, 1},
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/environments/l2f/parameters/dynamics/flightmare.h

@@ -0,0 +1,111 @@
+#include "../../../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_ENVIRONMENTS_L2F_PARAMETERS_DYNAMICS_FLIGHTMARE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_ENVIRONMENTS_L2F_PARAMETERS_DYNAMICS_FLIGHTMARE_H
+#include "../../multirotor.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rl::environments::l2f::parameters::dynamics{
+    template<typename T, typename TI>
+    constexpr Dynamics<T, TI, 4> flightmare = {
+            // Rotor positions
+            {
+                    {
+                            0.17 * 0.7071067811865475,
+                            -0.17 * 0.7071067811865475,
+                            0
+
+                    },
+                    {
+                            -0.17 * 0.7071067811865475,
+                            0.17 * 0.7071067811865475,
+                            0
+
+                    },
+                    {
+                            0.17 * 0.7071067811865475,
+                            0.17 * 0.7071067811865475,
+                            0
+
+                    },
+                    {
+                            -0.17 * 0.7071067811865475,
+                            -0.17 * 0.7071067811865475,
+                            0
+
+                    },
+            },
+            // Rotor thrust directions
+            {
+                    {0, 0, 1},
+                    {0, 0, 1},
+                    {0, 0, 1},
+                    {0, 0, 1},
+            },
+            // Rotor torque directions
+            {
+                    {0, 0, -1},
+                    {0, 0, -1},
+                    {0, 0, +1},
+                    {0, 0, +1},
+            },
+            // thrust constants
+            {
+                    {-1.7689986848125325, 11.50824315802381, 11.968428150335603}, // orig: [1.3298253500372892e-06, 0.0038360810526746033, -1.7689986848125325] (x^2, x, 1) => (1, x, x^2) => (1, 3000, 3000^2) (to normalize to 0-1)
+                    {-1.7689986848125325, 11.50824315802381, 11.968428150335603},
+                    {-1.7689986848125325, 11.50824315802381, 11.968428150335603},
+                    {-1.7689986848125325, 11.50824315802381, 11.968428150335603}
+            },
+            // torque constant
+            {0.016, 0.016, 0.016, 0.016},
+            // T, RPM time constant
+            {0.0200, 0.0200, 0.0200, 0.0200},
+            {0.0200, 0.0200, 0.0200, 0.0200},
+            // mass vehicle
+            0.73,
+            // gravity
+            {0, 0, -9.81},
+            // J
+            {
+                    {
+                            0.00791,
+                            0.0,
+                            0.0
+                    },
+                    {
+                            0.0,
+                            0.00791,
+                            0.0
+                    },
+                    {
+                            0.0,
+                            0.0,
+                            0.0123
+                    }
+            },
+            // J_inv
+            {
+                    {
+                            126.42225031605562,
+                            0.0,
+                            0.0
+                    },
+                    {
+                            0.0,
+                            126.42225031605562,
+                            0.0
+                    },
+                    {
+                            0.0,
+                            0.0,
+                            81.30081300813008
+                    }
+            },
+            0.5,
+            // action limit
+            {0, 1.0},
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif