CollisionAvoidance.cpp

Go to the documentation of this file.

#include "CollisionAvoidance.h"
 
#include <algorithm>
 
#include <SimoxUtility/math/convert/mat4f_to_quat.h>
#include <VirtualRobot/MathTools.h>
#include <VirtualRobot/Nodes/RobotNode.h>
#include <VirtualRobot/RobotNodeSet.h>
 
#include <simox/control/dynamics/RBDLModel.h>
#include <simox/control/robot/NodeInterface.h>
 
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
 
#include <RobotAPI/components/units/RobotUnit/ControlTargets/ControlTarget1DoFActuator.h>
#include <RobotAPI/components/units/RobotUnit/SensorValues/SensorValue1DoFActuator.h>
#include <RobotAPI/components/units/RobotUnit/util/ControlThreadOutputBuffer.h>
 
#include <armarx/control/common/utils.h>
 
namespace armarx::control::common::control_law
{
    void
    CollisionAvoidanceController::calculateCollisionTorque(
        CollisionData& collDataVec,
        const Config& c,
        RtStatusForSafetyStrategy& rts,
        const CollisionRobotIndices& collisionRobotIndices,
        const Eigen::VectorXf& qvelFiltered,
        Eigen::VectorXf& jointTorque,
        const float distanceThresholdRaw,
        const float distanceThreshold) const
    {
        // calculate jacobian
        {
            const auto* node = collisionRobotIndices.at(collDataVec.node1);
            auto localTransformation = Eigen::Isometry3d::Identity();
            localTransformation.translation() =
                node->getGlobalPose().inverse() * collDataVec.point1.cast<double>();
            const bool result = nodeSet_->computeJacobian(
                collDataVec.jacobian,
                *node,
                simox::control::robot::JacobianParams{
                    .mode = simox::control::utils::CartesianSelection::Position,
                    .localTransformation = localTransformation});
            ARMARX_CHECK_EXPRESSION(result);
        }
 
        float distThrSquare = distanceThresholdRaw * distanceThresholdRaw;
        float factor = c.maxRepulsiveForce / distThrSquare;
        float diff = collDataVec.minDistance - distanceThreshold;
        /// calculate common collision pair values
        collDataVec.repulsiveForce = factor * diff * diff;
        collDataVec.localStiffness = -2.0 * factor * diff;
        // minimum distance is always lower than the threshold distance
        // (local stiffness is always positive)
        collDataVec.repulsiveForce =
            std::clamp(collDataVec.repulsiveForce, 0.0f, c.maxRepulsiveForce);
        ARMARX_CHECK_NONNEGATIVE(collDataVec.repulsiveForce);
        ARMARX_CHECK_NONNEGATIVE(collDataVec.localStiffness);
 
        ARMARX_CHECK_EQUAL(3, collDataVec.direction.rows());
        // projected in direction of collision (1xn), is saved transposed (nx1)
        collDataVec.projectedJacT =
            (collDataVec.direction.transpose() * collDataVec.jacobian.cast<float>()).transpose();
        ARMARX_CHECK_EQUAL(1, collDataVec.projectedJacT.cols());
        ARMARX_CHECK_EQUAL(numNodes(), collDataVec.projectedJacT.rows());
        ARMARX_CHECK_EQUAL(numNodes(), qvelFiltered.rows());
 
        collDataVec.distanceVelocity = collDataVec.projectedJacT.transpose() * qvelFiltered;
 
        ARMARX_CHECK_EQUAL(numNodes(), rts.inertiaInverse.rows());
        ARMARX_CHECK_EQUAL(numNodes(), rts.inertiaInverse.cols());
 
        collDataVec.projectedMass = 1 / (collDataVec.projectedJacT.transpose() *
                                         rts.inertiaInverse * collDataVec.projectedJacT);
 
        ARMARX_CHECK_NONNEGATIVE(collDataVec.projectedMass);
 
        collDataVec.damping = 2 * std::sqrt(collDataVec.localStiffness) *
                              std::sqrt(collDataVec.projectedMass) * c.dampingFactor;
 
        if (rts.inRecoveryMode)
        {
            collDataVec.damping *= c.recoveryDampingFactor;
        }
 
        ARMARX_CHECK_NONNEGATIVE(collDataVec.damping);
 
        jointTorque +=
            collDataVec.projectedJacT *
            (collDataVec.repulsiveForce - collDataVec.damping * collDataVec.distanceVelocity);
    }
 
    CollisionAvoidanceController::CollisionAvoidanceController(
        const simox::control::robot::NodeSetInterface* nodeSet) :
        nodeSet_(nodeSet),
        identityMat(nodeSet ? Eigen::MatrixXf::Identity(nodeSet->getSize(), nodeSet->getSize())
                            : Eigen::MatrixXf())
    {
        ARMARX_CHECK_EXPRESSION(nodeSet);
        ARMARX_CHECK_GREATER(numNodes(), 0);
    }
 
    CollisionAvoidanceController::~CollisionAvoidanceController()
    {
 
        ARMARX_INFO << "Destruction of CollisionAvoidanceController";
    }
 
    /// methods for self-collision and joint limit avoidance
    /// avoidance torque methods
    void
    CollisionAvoidanceController::calculateSelfCollisionTorque(
        const Config& c,
        RtStatusForSafetyStrategy& rts,
        RecoveryState& rState,
        const DistanceResults& collisionPairs,
        const CollisionRobotIndices& collisionRobotIndices,
        const Eigen::VectorXf& qvelFiltered,
        double deltaT) const
    {
        /// self-collision avoidance algorithm following the methods in Dietrich et al. (2012):
        ///
        /// A. Dietrich, T. Wimbock, A. Albu-Schaffer and G. Hirzinger, "Integration of Reactive,
        /// Torque-Based Self-Collision Avoidance Into a Task Hierarchy," in IEEE Transactions on
        /// Robotics, vol. 28, no. 6, pp. 1278-1293, Dec. 2012, doi: 10.1109/TRO.2012.2208667.
        ///
        /// see: https://ieeexplore.ieee.org/document/6255795
        ///
        /// method:
        ///
        /// computes the joint torques to avoid self-collisions -> collisionJointTorque
 
        ARMARX_CHECK_GREATER(collisionPairs.size(), 0);
 
        /// clear values before new cycle
        rts.selfCollisionJointTorque.setZero();
        rts.activeCollPairsNum = 0;
 
        for (auto& data : rts.collDataVec)
        {
            data.clearValues();
        }
 
        /// when collDistanceThresholdInit is smaller than recoveryDistanceElapseMeter
        /// (usually means it is zero), we need to initilize it to the smallest collision distance
        /// plus a recoveryDistanceElapseMeter.
        float& thresholdInit = rState.collDistanceThresholdInit;
        if (c.enableCollisionRecoveryOnStartup and (thresholdInit < c.recoveryDistanceElapseMeter))
        {
            thresholdInit = c.selfDistanceThreshold;
            for (const DistanceResult& collisionPair : collisionPairs)
            {
                float minDist = static_cast<float>(collisionPair.minDistance);
                if (minDist < thresholdInit)
                {
                    thresholdInit = std::max(minDist, 0.0f);
                }
            }
            thresholdInit =
                std::min(c.selfDistanceThreshold, thresholdInit + c.recoveryDistanceElapseMeter);
        }
 
        rState.update(c, rts, deltaT);
 
        /// check collision pairs, which have are below the prefilter distance
        for (const DistanceResult& collisionPair : collisionPairs)
        {
            //            if (static_cast<float>(collisionPair.minDistance) >= c.selfDistanceThreshold)
            if (static_cast<float>(collisionPair.minDistance) >= rState.collDistanceThreshold)
            {
                continue;
            }
 
            if (collisionRobotIndices.count(collisionPair.node1) == 0 and
                collisionRobotIndices.count(collisionPair.node2) == 0)
            {
                continue;
            }
 
            ARMARX_CHECK(collisionPair.hasPoints());
 
            auto& selfCollDataVec = rts.collDataVec[rts.activeCollPairsNum++];
 
            selfCollDataVec.minDistance = static_cast<float>(collisionPair.minDistance);
 
            bool flipped = false;
            if (collisionRobotIndices.count(collisionPair.node1) > 0)
            {
                // First node on nodeset
 
                if (collisionRobotIndices.count(collisionPair.node2) > 0)
                {
                    // Check that second node comes later (equals larger index)
                    ARMARX_CHECK_GREATER(collisionPair.node2, collisionPair.node1);
                }
 
                selfCollDataVec.node1 = collisionPair.node1;
                selfCollDataVec.node2 = collisionPair.node2;
                selfCollDataVec.point1 = collisionPair.point1->cast<float>();
                selfCollDataVec.point2 = collisionPair.point2->cast<float>();
            }
            else
            {
                // Second node on nodeset -> flip collision pair
 
                flipped = true;
                selfCollDataVec.node1 = collisionPair.node2;
                selfCollDataVec.node2 = collisionPair.node1;
                selfCollDataVec.point1 = collisionPair.point2->cast<float>();
                selfCollDataVec.point2 = collisionPair.point1->cast<float>();
            }
 
            // direction is pointing away from collision
            selfCollDataVec.direction = selfCollDataVec.point1 - selfCollDataVec.point2;
 
            if (selfCollDataVec.minDistance < 0.0f)
            {
                selfCollDataVec.minDistance = 0.0f;
 
                // check for overlapping spheres or capsules overlapping spheres
                // (returned points are exactly the same)
                if (selfCollDataVec.point1.isApprox(selfCollDataVec.point2, 1e-8) and
                    collisionPair.normalVec != std::nullopt)
                {
                    /// if the points are the same, normalVec comes with a value
 
                    // todo: how to make sure the normalVec is always pointing away from the
                    // collision, in normally the vector points out from the contact point within
                    // the sphere
                    // issue: if the arm is modeled with a sphere, it will point towards the collision
                    // No faulty behavior has been detected so far, however there is the possibility
                    // to get a direction vector pointing towards the collision
 
                    // solution: check if the node is a sphere, if the repulsive force is
                    // suppose to apply on the sphere, use the negative normal direction
                    selfCollDataVec.direction = collisionPair.normalVec->cast<float>();
                    if (flipped)
                    {
                        selfCollDataVec.direction *= -1.0f;
                    }
                }
                else
                {
                    selfCollDataVec.direction *= -1.0f;
                }
            }
 
            selfCollDataVec.direction.normalize();
 
            calculateCollisionTorque(selfCollDataVec,
                                     c,
                                     rts,
                                     collisionRobotIndices,
                                     qvelFiltered,
                                     rts.selfCollisionJointTorque,
                                     c.selfDistanceThreshold,
                                     rState.collDistanceThreshold);
        }
        rts.objectCollDataIndex = rts.activeCollPairsNum;
    }
 
    void
    CollisionAvoidanceController::calculateJointLimitTorque(
        const Config& c,
        RtStatusForSafetyStrategy& rts,
        const Eigen::VectorXf& qpos,
        const Eigen::VectorXf& qvelFiltered) const
    {
        /// method:
        ///
        /// computes the joint torques to avoid joint limits -> jointLimitJointTorque
 
        rts.jointLimitJointTorque.setZero();
        const size_t n = rts.jointLimitData.size();
        ARMARX_CHECK_EQUAL(numNodes(), rts.jointLimitJointTorque.rows());
 
        ARMARX_CHECK_EQUAL(numNodes(), n);
        ARMARX_CHECK_EQUAL(numNodes(), rts.inertia.cols());
        ARMARX_CHECK_EQUAL(numNodes(), rts.inertia.rows());
 
        /// iterate over all joints and check the joint positions for not limiteless joints
        for (int i = 0; i < n; ++i)
        {
            auto& joint = rts.jointLimitData[i];
            if (joint.isLimitless)
            {
                continue;
            }
 
            float diff = 0.0F;
            float sign = 1.0F;
            // 1. Determine penetration depth and direction
            if (qpos[i] < joint.qposThresholdLow)
            {
                diff = joint.qposThresholdLow - qpos[i];
                sign = 1.0F;
            }
            else if (qpos[i] > joint.qposThresholdHigh)
            {
                diff = qpos[i] - joint.qposThresholdHigh;
                sign = -1.0F;
            }
            else
            {
                continue; // Within safe limits
            }
 
            // 2. Pre-calculate common factors, done in the init process
            // maxRepulsiveJointVel = 1 / (thresholdRange * thresholdRange)
            // kRepulsive = c.maxRepulsiveJointVel * joint.invThresholdSq;
 
            // 3. Compute Repulsive Velocity (Quadratic)
            joint.repulsiveTorque =
                std::min(joint.kRepulsive * (diff * diff), c.maxRepulsiveTorque);
 
            // 4. Compute Damping
            // Stiffness is the derivative of the velocity profile
            const float localStiffness = 2.0F * joint.kRepulsive * diff;
            const float jointInertia = static_cast<float>(rts.inertia(i, i));
 
            // Critical Damping: 2 * sqrt(K * M) * zeta
            const float dampingGain =
                2.0F * std::sqrt(jointInertia * localStiffness) * c.dampingFactor;
 
            joint.totalDamping = dampingGain * qvelFiltered[i];
 
            // 5. Apply result
            // For Low limit:  pos_vel - damping
            // For High limit: -(pos_vel + damping) => -pos_vel - damping
            rts.jointLimitJointTorque(i) = (sign * joint.repulsiveTorque) - joint.totalDamping;
 
 
            // rts.jointInertia = rts.inertia(i, i);
            // if (qpos[i] < rts.jointLimitData[i].qposThresholdLow)
            // {
            //     joint.repulsiveTorque =
            //         c.maxRepulsiveTorque / std::pow(rts.jointLimitData[i].thresholdRange, 2) *
            //         std::pow(rts.jointLimitData[i].qposThresholdLow - qpos[i], 2);
            //     ARMARX_CHECK_NONNEGATIVE(joint.repulsiveTorque);
            //     joint.repulsiveTorque =
            //         std::clamp(joint.repulsiveTorque, 0.0f, c.maxRepulsiveTorque);
            //
            //     rts.localStiffnessJointLim = 2 * c.maxRepulsiveTorque /
            //                                  std::pow(rts.jointLimitData[i].thresholdRange, 2) *
            //                                  (rts.jointLimitData[i].qposThresholdLow - qpos[i]);
            //
            //     ARMARX_CHECK_NONNEGATIVE(rts.localStiffnessJointLim);
            //     rts.dampingJointLim = 2 * std::sqrt(rts.jointInertia) *
            //                           std::sqrt(rts.localStiffnessJointLim) * c.dampingFactor;
            //
            //     ARMARX_CHECK_NONNEGATIVE(rts.dampingJointLim);
            //     joint.totalDamping = rts.dampingJointLim * qvelFiltered[i];
            //     rts.jointLimitJointTorque(i) =
            //         joint.repulsiveTorque - rts.dampingJointLim * qvelFiltered[i];
            //
            //     ARMARX_TRACE_LITE;
            // }
            // else if (qpos[i] > rts.jointLimitData[i].qposThresholdHigh)
            // {
            //     joint.repulsiveTorque =
            //         c.maxRepulsiveTorque / std::pow(rts.jointLimitData[i].thresholdRange, 2) *
            //         std::pow(qpos[i] - rts.jointLimitData[i].qposThresholdHigh, 2);
            //
            //     ARMARX_CHECK_NONNEGATIVE(joint.repulsiveTorque);
            //     joint.repulsiveTorque =
            //         std::clamp(joint.repulsiveTorque, 0.0f, c.maxRepulsiveTorque);
            //
            //     rts.localStiffnessJointLim = 2 * c.maxRepulsiveTorque /
            //
            //                                  std::pow(rts.jointLimitData[i].thresholdRange, 2) *
            //                                  (qpos[i] - rts.jointLimitData[i].qposThresholdHigh);
            //     ARMARX_TRACE_LITE;
            //     ARMARX_CHECK_NONNEGATIVE(rts.localStiffnessJointLim);
            //     rts.dampingJointLim = 2 * std::sqrt(rts.jointInertia) *
            //                           std::sqrt(rts.localStiffnessJointLim) * c.dampingFactor;
            //     ARMARX_CHECK_NONNEGATIVE(rts.dampingJointLim);
            //     joint.totalDamping = rts.dampingJointLim * qvelFiltered[i];
            //     rts.jointLimitJointTorque(i) =
            //         -(joint.repulsiveTorque + rts.dampingJointLim * qvelFiltered[i]);
            // }
        }
    }
 
    /// caclulate null spaces
    void
    CollisionAvoidanceController::calculateSelfCollisionNullspace(
        const common::control_law::arondto::CollisionAvoidanceConfig& c,
        RtStatusForSafetyStrategy& rtStatus) const
    {
        rtStatus.selfCollNullSpace.setIdentity();
 
        ARMARX_CHECK_EQUAL(numNodes(), rtStatus.selfCollNullSpace.rows());
        ARMARX_CHECK_EQUAL(numNodes(), rtStatus.selfCollNullSpace.cols());
 
        ARMARX_CHECK_EQUAL(4, rtStatus.selfCollisionNullSpaceWeights.rows());
        rtStatus.selfCollK1 = rtStatus.selfCollisionNullSpaceWeights(0);
        rtStatus.selfCollK2 = rtStatus.selfCollisionNullSpaceWeights(1);
        rtStatus.selfCollK3 = rtStatus.selfCollisionNullSpaceWeights(2);
        rtStatus.selfCollK4 = rtStatus.selfCollisionNullSpaceWeights(3);
 
        ARMARX_TRACE_LITE;
 
        for (unsigned int i = 0; i < rtStatus.objectCollDataIndex; i++)
        {
            auto& active = rtStatus.collDataVec[i];
 
            /// get desired null space value based on proximity to collision
            if (active.minDistance < c.selfCollActivatorZ1)
            {
                /// full locking in direction of collision
                rtStatus.desiredNullSpace = 0.0f;
            }
            else if (c.selfCollActivatorZ1 <= active.minDistance &&
                     active.minDistance <= c.selfCollActivatorZ2)
            {
                /// in transition state
                rtStatus.desiredNullSpace = rtStatus.selfCollK1 * std::pow(active.minDistance, 3) +
                                            rtStatus.selfCollK2 * std::pow(active.minDistance, 2) +
                                            rtStatus.selfCollK3 * active.minDistance +
                                            rtStatus.selfCollK4;
                if (rtStatus.desiredNullSpace > 1.0f)
                {
                    ARMARX_RT_LOGF_WARNING(
                        "desired null space value should not be higher than 1.0");
                    //                    ARMARX_WARNING
                    //                        << "desired null space value should not be higher than 1.0, was "
                    //                        << rtStatus.desiredNullSpace
                    //                        << ", in collision null space calulation, weights: " << rtStatus.selfCollK1
                    //                        << ", " << rtStatus.selfCollK2 << ", " << rtStatus.selfCollK3 << ", "
                    //                        << rtStatus.selfCollK4;
                }
            }
            else
            {
                /// unrestricted movement in direction of collision
                rtStatus.desiredNullSpace = 1.0f;
            }
 
 
            active.desiredNSColl = rtStatus.desiredNullSpace;
            rtStatus.desiredNullSpace = std::clamp(rtStatus.desiredNullSpace, 0.0f, 1.0f);
            ARMARX_CHECK_NONNEGATIVE(rtStatus.desiredNullSpace);
            /// normalize projected Jacobian
            rtStatus.selfCollNormalizedJacT = active.projectedJacT.normalized();
 
            ARMARX_CHECK_EQUAL(numNodes(), rtStatus.selfCollNormalizedJacT.rows());
 
            rtStatus.selfCollTempNullSpaceMatrix =
                identityMat -
                (rtStatus.selfCollNormalizedJacT * (1.0f - rtStatus.desiredNullSpace) *
                 rtStatus.selfCollNormalizedJacT.transpose());
 
            if (c.onlyLimitCollDirection)
            {
                /// check, whether impedance joint torque acts against the collision direction
                ARMARX_CHECK_EQUAL(active.projectedJacT.rows(),
                                   rtStatus.impedanceJointTorque.rows());
                for (int i = 0; i < rtStatus.impedanceJointTorque.rows(); ++i)
                {
                    if ((active.projectedJacT(i) < 0.0f and
                         rtStatus.impedanceJointTorque(i) < 0.0f) ||
                        (active.projectedJacT(i) > 0.0f and
                         rtStatus.impedanceJointTorque(i) > 0.0f))
                    {
                        // if both have the same sign (both negative or both positive), do not limit DoF
                        rtStatus.selfCollTempNullSpaceMatrix(i, i) = 1.0f;
                    }
                }
            }
 
            /// project desired null space in corresponding direction via the Norm-Jacobian
            rtStatus.selfCollNullSpace *= rtStatus.selfCollTempNullSpaceMatrix;
            // todo: clamp the diagonal values between 0 and 1
        }
    }
 
    void
    CollisionAvoidanceController::calculateJointLimitNullspace(const Config& c,
                                                               RtStatusForSafetyStrategy& rts,
                                                               const Eigen::VectorXf& qpos) const
    {
        /// check fundamentals thesis BA Jan Fenker
        rts.jointLimNullSpace.setIdentity();
 
        ARMARX_CHECK_EQUAL(numNodes(), rts.jointLimNullSpace.rows());
        ARMARX_CHECK_EQUAL(numNodes(), rts.jointLimNullSpace.cols());
 
        ARMARX_CHECK_EQUAL(numNodes(), rts.jointLimitData.size());
 
        for (size_t i = 0; i < rts.jointLimitData.size(); ++i)
        {
            auto& joint = rts.jointLimitData[i];
            ARMARX_CHECK_EQUAL(4, joint.jointLimitNullSpaceWeightsLow.rows());
            ARMARX_CHECK_EQUAL(4, joint.jointLimitNullSpaceWeightsHigh.rows());
            rts.k1Lo = joint.jointLimitNullSpaceWeightsLow(0);
            rts.k2Lo = joint.jointLimitNullSpaceWeightsLow(1);
            rts.k3Lo = joint.jointLimitNullSpaceWeightsLow(2);
            rts.k4Lo = joint.jointLimitNullSpaceWeightsLow(3);
            rts.k1Hi = joint.jointLimitNullSpaceWeightsHigh(0);
            rts.k2Hi = joint.jointLimitNullSpaceWeightsHigh(1);
            rts.k3Hi = joint.jointLimitNullSpaceWeightsHigh(2);
            rts.k4Hi = joint.jointLimitNullSpaceWeightsHigh(3);
 
            ARMARX_TRACE_LITE;
 
            if (not joint.isLimitless)
            {
                /// get desired null space value based on proximity to joint boundaries
                if (qpos[i] < joint.qposZ1Low)
                {
                    /// full locking
                    rts.desiredNullSpace = 0.0f;
                }
                else if (joint.qposZ1Low <= qpos[i] && qpos[i] <= joint.qposZ2Low)
                {
                    /// in transition state
                    rts.desiredNullSpace = rts.k1Lo * std::pow(qpos[i], 3) +
                                           rts.k2Lo * std::pow(qpos[i], 2) + rts.k3Lo * qpos[i] +
                                           rts.k4Lo;
                    if (rts.desiredNullSpace > 1.0f)
                    {
                        ARMARX_RT_LOGF_WARNING(
                            "desired null space value should not be higher than 1.0, was %.2f, "
                            "approaching lower joint limit, weights: [%.2f, %.2f, %.2f, %.2f]",
                            rts.desiredNullSpace,
                            rts.k1Lo,
                            rts.k2Lo,
                            rts.k3Lo,
                            rts.k4Lo)
                            .deactivateSpam(2.0f);
                        //                        ARMARX_WARNING
                        //                            << "desired null space value should not be higher than 1.0, was "
                        //                            << rts.desiredNullSpace
                        //                            << ", approaching lower joint limit, weights: " << rts.k1Lo << ", "
                        //                            << rts.k2Lo << ", " << rts.k3Lo << ", " << rts.k4Lo;
                    }
                }
                else if (joint.qposZ2High <= qpos[i] && qpos[i] <= joint.qposZ1High)
                {
                    /// in transition state
                    rts.desiredNullSpace = rts.k1Hi * std::pow(qpos[i], 3) +
                                           rts.k2Hi * std::pow(qpos[i], 2) + rts.k3Hi * qpos[i] +
                                           rts.k4Hi;
                    if (rts.desiredNullSpace > 1.0f)
                    {
                        ARMARX_RT_LOGF_WARNING(
                            "desired null space value should not be higher than 1.0, was %.2f, "
                            "approaching lower joint limit, weights: [%.2f, %.2f, %.2f, %.2f]",
                            rts.desiredNullSpace,
                            rts.k1Hi,
                            rts.k2Hi,
                            rts.k3Hi,
                            rts.k4Hi)
                            .deactivateSpam(2.0f);
 
                        //                        ARMARX_WARNING
                        //                            << "desired null space value should not be higher than 1.0, was "
                        //                            << rts.desiredNullSpace
                        //                            << ", approaching upper joint limit, weights: " << rts.k1Hi << ", "
                        //                            << rts.k2Hi << ", " << rts.k3Hi << ", " << rts.k4Hi;
                    }
                }
                else if (joint.qposZ1High < qpos[i])
                {
                    /// full locking
                    rts.desiredNullSpace = 0.0f;
                }
                else
                {
                    /// unrestricted movement
                    rts.desiredNullSpace = 1.0f;
                }
 
 
                joint.desiredNSjointLim = rts.desiredNullSpace;
                rts.desiredNullSpace = std::clamp(rts.desiredNullSpace, 0.0f, 1.0f);
                ARMARX_CHECK_NONNEGATIVE(rts.desiredNullSpace);
 
                /// set desired null space value in null space matrix
                rts.jointLimNullSpace(i, i) = 1.0f - (1.0f - rts.desiredNullSpace);
            }
        }
    }
 
    /// --------------------------------- main rt-loop ------------------------------------------
 
    void
    CollisionAvoidanceController::run(const Config& c,
                                      RtStatusForSafetyStrategy& rtStatus,
                                      RecoveryState& rStateSelfColl,
                                      const DistanceResults& collisionPairs,
                                      const CollisionRobotIndices& collisionRobotIndices,
                                      DynamicsModel& dynamicsModel,
                                      const Eigen::VectorXf& qpos,
                                      const Eigen::VectorXf& qvelFiltered,
                                      float torqueLimit,
                                      double deltaT)
    {
        /// run in rt thread
        /// ----------------------------- inertia calculations --------------------------------------------------
        dynamicsModel.getInertiaMatrix(qpos.cast<double>(), rtStatus.inertia);
 
        // rtStatus.inertiaInverse = rtStatus.inertia.cast<float>().inverse();
        // inertia is positive definite matrix
        rtStatus.inertiaInverse = rtStatus.inertia.cast<float>().llt().solve(identityMat);
 
        /// ----------------------------- safety constraints --------------------------------------------------
        if (c.enableSelfCollisionAvoidance)
        {
            // calculation of self-collision avoidance torque
            const double timeMeasure = IceUtil::Time::now().toMicroSecondsDouble();
            calculateSelfCollisionTorque(c,
                                         rtStatus,
                                         rStateSelfColl,
                                         collisionPairs,
                                         collisionRobotIndices,
                                         qvelFiltered,
                                         deltaT);
            rtStatus.collisionTorqueTime =
                IceUtil::Time::now().toMicroSecondsDouble() - timeMeasure;
        }
        if (c.enableJointLimitAvoidance)
        {
            // calculation of joint limit avoidance torque
            const double timeMeasure = IceUtil::Time::now().toMicroSecondsDouble();
            calculateJointLimitTorque(c, rtStatus, qpos, qvelFiltered);
            rtStatus.jointLimitTorqueTime =
                IceUtil::Time::now().toMicroSecondsDouble() - timeMeasure;
        }
        if (!c.samePriority)
        {
            if (c.enableSelfCollisionAvoidance)
            {
                // calculation of null space matrix for self-collision avoidance
                const double timeMeasure = IceUtil::Time::now().toMicroSecondsDouble();
                calculateSelfCollisionNullspace(c, rtStatus);
                rtStatus.selfCollNullspaceTime =
                    IceUtil::Time::now().toMicroSecondsDouble() - timeMeasure;
            }
            if (c.enableJointLimitAvoidance)
            {
                // calculation of null space matrix for joint limit avoidance
                const double timeMeasure = IceUtil::Time::now().toMicroSecondsDouble();
                calculateJointLimitNullspace(c, rtStatus, qpos);
                rtStatus.jointLimitNullspaceTime =
                    IceUtil::Time::now().toMicroSecondsDouble() - timeMeasure;
            }
        }
        ARMARX_TRACE_LITE;
 
        /// --------------------------- apply EMA low pass filter  -----------------------------------------------
        if (c.filterSafetyValues)
        {
            float coeff = rtStatus.inRecoveryMode ? 0.8 * c.safetyValFilter : c.safetyValFilter;
            /// filter safety constraint values using EMA low pass filter
            for (int i = 0; i < rtStatus.selfCollisionJointTorque.size(); ++i)
            {
                rtStatus.selfCollisionTorqueFiltered(i) =
                    (1 - coeff) * rtStatus.selfCollisionTorqueFiltered(i) +
                    coeff * rtStatus.selfCollisionJointTorque(i);
            }
            for (int i = 0; i < rtStatus.jointLimitJointTorque.size(); ++i)
            {
                rtStatus.jointLimitTorqueFiltered(i) =
                    (1 - coeff) * rtStatus.jointLimitTorqueFiltered(i) +
                    coeff * rtStatus.jointLimitJointTorque(i);
            }
 
            for (int i = 0; i < rtStatus.selfCollNullSpace.diagonalSize(); ++i)
            {
                // the computed values are only on the diagonal, so only these need to be filtered
                rtStatus.selfCollNullSpaceFiltered(i, i) =
                    (1 - coeff) * rtStatus.selfCollNullSpaceFiltered(i, i) +
                    coeff * rtStatus.selfCollNullSpace(i, i);
            }
            for (int i = 0; i < rtStatus.jointLimNullSpace.diagonalSize(); ++i)
            {
                // the computed values are only on the diagonal, so only these need to be filtered
                rtStatus.jointLimNullSpaceFiltered(i, i) =
                    (1 - coeff) * rtStatus.jointLimNullSpaceFiltered(i, i) +
                    coeff * rtStatus.jointLimNullSpace(i, i);
            }
            /// assign filtered values
            rtStatus.selfCollisionJointTorque = rtStatus.selfCollisionTorqueFiltered;
            rtStatus.jointLimitJointTorque = rtStatus.jointLimitTorqueFiltered;
            rtStatus.selfCollNullSpace = rtStatus.selfCollNullSpaceFiltered;
            rtStatus.jointLimNullSpace = rtStatus.jointLimNullSpaceFiltered;
        }
 
        ARMARX_TRACE_LITE;
        /// ----------------------------- hierarchical control  --------------------------------------------------
        /// The following control hierarchies are considered:
        ///
        /// three tasks in hierarchy: "enableSelfCollisionAvoidance": true, "enableJointLimitAvoidance": true
        ///
        /// flag: "samePriority": true
        /// same priority: torque_coll + torque_jl + torque_imp
        ///
        /// flag: "topPrioritySelfCollisionAvoidance": true, "samePriority": false
        /// self-coll avoidance on top: torque_coll -> torque_jl -> torque_imp
        ///
        /// flag: "topPriorityJointLimitAvoidance": true, "samePriority": false
        /// joint limit avoidance on top: torque_jl -> torque_coll -> torque_imp
        ///
        /// flag: "topPrioritySelfCollisionAvoidance": false, "topPriorityJointLimitAvoidance": false,
        /// "samePriority": false
        /// (torque_coll + torque_jl) -> torque_imp
        /// self-coll and joint limit avoidance on same priority level:
        ///
        /// two tasks in hierarchy:
        ///
        /// "enableSelfCollisionAvoidance": true, "enableJointLimitAvoidance": false
        /// self-coll avoidance on top: torque_coll -> torque_imp
        ///
        /// "enableSelfCollisionAvoidance": false, "enableJointLimitAvoidance": true
        /// joint limit avoidance on top: torque_jl -> torque_imp
        ///
        /// one task in hierarchy (impedance control):
        ///
        /// "enableSelfCollisionAvoidance": false, "enableJointLimitAvoidance": false
        /// only impedance control: torque_imp
 
        //        ARMARX_INFO << VAROUT(c.samePriority);
        if (c.samePriority)
        {
            ARMARX_CHECK_EQUAL(numNodes(), rtStatus.selfCollisionJointTorque.rows());
            ARMARX_CHECK_EQUAL(numNodes(), rtStatus.jointLimitJointTorque.rows());
            ARMARX_CHECK_EQUAL(numNodes(), rtStatus.impedanceJointTorque.rows());
            rtStatus.desiredJointTorques =
                rtStatus.selfCollisionJointTorque + rtStatus.jointLimitJointTorque +
                rtStatus.impedanceJointTorque + rtStatus.kdImpedanceTorque;
            ARMARX_TRACE_LITE;
        }
        else if (c.enableSelfCollisionAvoidance and c.enableJointLimitAvoidance)
        {
            /// three tasks in hierarchy considered
 
            if (c.topPrioritySelfCollisionAvoidance)
            {
 
                ARMARX_CHECK_EQUAL(numNodes(), rtStatus.selfCollNullSpace.rows());
                ARMARX_CHECK_EQUAL(numNodes(), rtStatus.selfCollNullSpace.cols());
                ARMARX_CHECK_EQUAL(rtStatus.impedanceJointTorque.rows(),
                                   rtStatus.selfCollNullSpace.cols());
                ARMARX_CHECK_EQUAL(numNodes(), rtStatus.jointLimNullSpace.rows());
                ARMARX_CHECK_EQUAL(numNodes(), rtStatus.jointLimNullSpace.cols());
                ARMARX_CHECK_EQUAL(rtStatus.jointLimitJointTorque.rows(),
                                   rtStatus.selfCollNullSpace.cols());
 
                rtStatus.desiredJointTorques =
                    rtStatus.selfCollisionJointTorque +
                    rtStatus.selfCollNullSpace *
                        (rtStatus.jointLimitJointTorque +
                         rtStatus.jointLimNullSpace * rtStatus.impedanceJointTorque) +
                    rtStatus.kdImpedanceTorque;
 
                // debug values
                rtStatus.projJointLimJointTorque =
                    rtStatus.selfCollNullSpace * rtStatus.jointLimitJointTorque;
                rtStatus.projImpedanceJointTorque =
                    rtStatus.selfCollNullSpace *
                    (rtStatus.jointLimNullSpace * rtStatus.impedanceJointTorque);
            }
            else if (c.topPriorityJointLimitAvoidance)
            {
                ARMARX_CHECK_EQUAL(numNodes(), rtStatus.selfCollNullSpace.rows());
                ARMARX_CHECK_EQUAL(numNodes(), rtStatus.selfCollNullSpace.cols());
                ARMARX_CHECK_EQUAL(rtStatus.impedanceJointTorque.rows(),
                                   rtStatus.selfCollNullSpace.cols());
                ARMARX_CHECK_EQUAL(numNodes(), rtStatus.jointLimNullSpace.rows());
                ARMARX_CHECK_EQUAL(numNodes(), rtStatus.jointLimNullSpace.cols());
                ARMARX_CHECK_EQUAL(rtStatus.selfCollisionJointTorque.rows(),
                                   rtStatus.jointLimNullSpace.cols());
 
                rtStatus.desiredJointTorques =
                    rtStatus.jointLimitJointTorque +
                    rtStatus.jointLimNullSpace *
                        (rtStatus.selfCollisionJointTorque +
                         rtStatus.selfCollNullSpace * rtStatus.impedanceJointTorque) +
                    rtStatus.kdImpedanceTorque;
 
                // debug values
                rtStatus.projCollJointTorque =
                    rtStatus.jointLimNullSpace * rtStatus.selfCollisionJointTorque;
                rtStatus.projImpedanceJointTorque =
                    rtStatus.jointLimNullSpace *
                    (rtStatus.selfCollNullSpace * rtStatus.impedanceJointTorque);
            }
            else
            {
                ARMARX_CHECK_EQUAL(numNodes(), rtStatus.selfCollNullSpace.rows());
                ARMARX_CHECK_EQUAL(numNodes(), rtStatus.selfCollNullSpace.cols());
                ARMARX_CHECK_EQUAL(rtStatus.impedanceJointTorque.rows(),
                                   rtStatus.selfCollNullSpace.cols());
                ARMARX_CHECK_EQUAL(numNodes(), rtStatus.jointLimNullSpace.rows());
                ARMARX_CHECK_EQUAL(numNodes(), rtStatus.jointLimNullSpace.cols());
                ARMARX_CHECK_EQUAL(rtStatus.selfCollisionJointTorque.rows(),
                                   rtStatus.jointLimNullSpace.cols());
                rtStatus.desiredJointTorques =
                    rtStatus.jointLimitJointTorque + rtStatus.selfCollisionJointTorque +
                    (rtStatus.jointLimNullSpace * rtStatus.selfCollNullSpace) *
                        rtStatus.impedanceJointTorque +
                    rtStatus.kdImpedanceTorque;
 
                // debug values
                rtStatus.projImpedanceJointTorque =
                    (rtStatus.jointLimNullSpace * rtStatus.selfCollNullSpace) *
                    rtStatus.impedanceJointTorque;
            }
        }
        else if (c.enableSelfCollisionAvoidance)
        {
            /// impedance control and self-collision avoidance
 
            ARMARX_CHECK_EQUAL(numNodes(), rtStatus.selfCollNullSpace.rows());
            ARMARX_CHECK_EQUAL(numNodes(), rtStatus.selfCollNullSpace.cols());
            ARMARX_CHECK_EQUAL(rtStatus.impedanceJointTorque.rows(),
                               rtStatus.selfCollNullSpace.cols());
 
            rtStatus.desiredJointTorques =
                rtStatus.selfCollisionJointTorque +
                rtStatus.selfCollNullSpace * rtStatus.impedanceJointTorque +
                rtStatus.kdImpedanceTorque;
 
            // debugging
            rtStatus.projImpedanceJointTorque =
                rtStatus.selfCollNullSpace * rtStatus.impedanceJointTorque;
        }
        else if (c.enableJointLimitAvoidance)
        {
            /// impedance control and joint limit avoidance
 
            ARMARX_CHECK_EQUAL(numNodes(), rtStatus.jointLimNullSpace.rows());
            ARMARX_CHECK_EQUAL(numNodes(), rtStatus.jointLimNullSpace.cols());
            ARMARX_CHECK_EQUAL(rtStatus.impedanceJointTorque.rows(),
                               rtStatus.jointLimNullSpace.cols());
 
            rtStatus.desiredJointTorques =
                rtStatus.jointLimitJointTorque +
                rtStatus.jointLimNullSpace * rtStatus.impedanceJointTorque +
                rtStatus.kdImpedanceTorque;
 
            // debugging
            rtStatus.projImpedanceJointTorque =
                rtStatus.jointLimNullSpace * rtStatus.impedanceJointTorque;
        }
        else
        {
            /// plain impedance control
            rtStatus.desiredJointTorques =
                rtStatus.impedanceJointTorque + rtStatus.kdImpedanceTorque;
        }
 
        //        rtStatus.desiredJointTorques += rtStatus.jointDampingTorque;
 
        ARMARX_TRACE_LITE;
 
        /// ------------------------- write impedance forces to buffer  -----------------------------------------
        // this section is purely for visualization purposes in the viewer
        //        rtStatus.dirErrorImp = rtStatus.poseErrorImp.head<3>().normalized();
        //        rtStatus.totalForceImpedance = rtStatus.forceImpedance.head<3>().norm();
        //        rtStatus.projForceImpedance = rtStatus.jtpinv * rtStatus.projImpedanceJointTorque;
        //        rtStatus.projTotalForceImpedance = rtStatus.projForceImpedance.head<3>().norm();
        //        rtStatus.impForceRatio = rtStatus.projTotalForceImpedance / rtStatus.totalForceImpedance;
        //        rtStatus.impTorqueRatio =
        //            rtStatus.projImpedanceJointTorque.norm() / rtStatus.impedanceJointTorque.norm();
 
 
        /// ----------------------------- write torque target  --------------------------------------------------
        for (int i = 0; i < rtStatus.desiredJointTorques.rows(); ++i)
        {
            rtStatus.desiredJointTorques(i) =
                std::clamp(rtStatus.desiredJointTorques(i), -torqueLimit, torqueLimit);
        }
    }
 
    void
    CollisionAvoidanceController::AdmittanceInterface::run(Eigen::VectorXf& jointTorque,
                                                           float jointVelLimit,
                                                           const TSCtrlRtStatus& rts)
    {
        float k_d = 0.5F;
        ARMARX_CHECK_EQUAL(rts.nDoFVelocity, nDoFVel);
        for (size_t i = 0; i < nDoFVel; ++i)
        {
            size_t idx = rts.jointIDVelocityMode[i];
            qTemp(i) = jointTorque(idx) - k_d * (qdVel(i) - rts.qvelFiltered(idx));
            /* - k_p * (rtStatus.qdPos(i) - rtStatus.jointPosition(idx))*/
        }
        qdAcc = rts.inertiaInvVelCtrlJoints * qTemp;
        qdVel = 0.5 * (rts.deltaT * qdAcc + qdVel);
        jointVel.setZero();
        for (size_t i = 0; i < nDoFVel; ++i)
        {
            jointVel(rts.jointIDVelocityMode[i]) =
                std::clamp(qdVel(i), -jointVelLimit, jointVelLimit);
        }
    }
 
    void
    CollisionAvoidanceController::AdmittanceInterface::reset(size_t nDoFNodeSet,
                                                             size_t nDoFVelocity)
    {
        nDoFVel = nDoFVelocity;
        jointVel.setZero(static_cast<int64_t>(nDoFNodeSet));
        qdVel.setZero(static_cast<int64_t>(nDoFVel));
        qdAcc.setZero(static_cast<int64_t>(nDoFVel));
        qTemp.setZero(static_cast<int64_t>(nDoFVel));
        // TODO: the interface should be activated when at least one joint is velocity controlled
        // However, due to incomplete hierarchy design, the activation is only used for full velocity control mode
        //        active = nDoFVel > 0;
        active = nDoFVel == nDoFNodeSet;
    }
 
    void
    CollisionAvoidanceController::RtStatusForSafetyStrategy::reset(
        const Config& c,
        const unsigned int nDoF,
        const unsigned int maxCollisionPairs,
        VirtualRobot::RobotNodeSetPtr& rns,
        const std::vector<size_t>& velCtrlIndex)
    {
        /// targets
        desiredJointTorques.setZero(nDoF);
        desiredJointVel.setZero(nDoF);
 
        ///
        trackingError = 0.0;
        dirErrorImp.setZero();
        totalForceImpedance = 0.0;
        projForceImpedance.setZero();
        projTotalForceImpedance = 0.0;
 
        /// intermediate torque results
        impedanceJointTorque.setZero(nDoF);
        kdImpedanceTorque.setZero(nDoF); // TODO remove this
        selfCollisionJointTorque.setZero(nDoF);
        objectCollisionJointTorque.setZero(nDoF);
        jointLimitJointTorque.setZero(nDoF);
 
        selfCollisionTorqueFiltered.setZero(nDoF);
        objectCollisionTorqueFiltered.setZero(nDoF);
        jointLimitTorqueFiltered.setZero(nDoF);
 
        /// for admittance interface
        selfCollisionJointVel.setZero(nDoF);
        objectCollisionJointVel.setZero(nDoF);
        jointLimitJointVel.setZero(nDoF);
 
        /// intermediate projected torques via null space matrices
        projImpedanceJointTorque.setZero(nDoF);
        projCollJointTorque.setZero(nDoF);
        projJointLimJointTorque.setZero(nDoF);
 
        impForceRatio = 0.0f;
        impTorqueRatio = 0.0f;
 
        /// intermediate null space matrices (collision and joint limit avoidance)
        selfCollNullSpace.resize(nDoF, nDoF);
        selfCollNullSpace.setZero();
        jointLimNullSpace.resize(nDoF, nDoF);
        jointLimNullSpace.setZero();
        objectCollNullSpace.resize(nDoF, nDoF);
        objectCollNullSpace.setZero();
        impedanceNullSpace.resize(nDoF, nDoF);
        impedanceNullSpace.setIdentity();
        desiredNullSpace = 0.0;
 
        selfCollNullSpaceFiltered.resize(nDoF, nDoF);
        selfCollNullSpaceFiltered.setZero();
        objectCollNullSpaceFiltered.resize(nDoF, nDoF);
        objectCollNullSpaceFiltered.setZero();
        jointLimNullSpaceFiltered.resize(nDoF, nDoF);
        jointLimNullSpaceFiltered.setZero();
 
        /// self-collision avoidance initialization parameters
        /// calculate weights for self-collision nullspace transition function
        /// range between z1 and z2
        /// z1: below this distance [m] the collision direction is fully locked
        /// z2: above this distance collision direction is unrestricted
        //        collisionNullSpaceWeights.setZero();
        selfCollisionNullSpaceWeights =
            helper::calculateTransitionWeights(c.selfCollActivatorZ1, c.selfCollActivatorZ2);
 
        /// distance results
        Eigen::Vector3d point1(0.0, 0.0, 0.0);
        Eigen::Vector3d point2(0.0, 0.0, 0.0);
        Eigen::Vector3d norm(0.0, 0.0, 0.0);
 
        collDataVec.resize(maxCollisionPairs, CollisionAvoidanceController::CollisionData(nDoF));
 
        /// self-collision avoidance null space intermediate results
        selfCollK1 = 0.0;
        selfCollK2 = 0.0;
        selfCollK3 = 0.0;
        selfCollK4 = 0.0;
        selfCollNormalizedJacT.setZero(nDoF);
        selfCollTempNullSpaceMatrix.resize(nDoF, nDoF);
        selfCollTempNullSpaceMatrix.setZero();
 
        /// object-collision avoidance null space intermediate results
        objectCollK1 = 0.0;
        objectCollK2 = 0.0;
        objectCollK3 = 0.0;
        objectCollK4 = 0.0;
        objectCollNormalizedJacT.setZero(nDoF);
        objectCollTempNullSpaceMatrix.resize(nDoF, nDoF);
        objectCollTempNullSpaceMatrix.setZero();
 
        /// joint limit avoidance initialization parameters
        CollisionAvoidanceController::RtStatusForSafetyStrategy::initJointLimtDataVec(c, nDoF, rns);
 
        /// others
        inertia.resize(nDoF, nDoF);
        inertia.setZero();
        inertiaInverse.resize(nDoF, nDoF);
        inertiaInverse.setZero();
 
        /// time status
        collisionPairTime = 0.0;
        preFilterTime = 0.0;
        collisionTorqueTime = 0.0;
        jointLimitTorqueTime = 0.0;
        selfCollNullspaceTime = 0.0;
        jointLimitNullspaceTime = 0.0;
 
        /// collision pair info
        collisionPairsNum = 0;
        activeCollPairsNum = 0;
 
        /// priority accumulators
        nullSpaceAcc.resize(nDoF, nDoF);
        nullSpaceAcc.setIdentity();
        torqueAcc.resize(nDoF);
        torqueAcc.setZero();
        finalTorque.resize(nDoF);
        finalTorque.setZero();
 
        /// admittance interface for vel controlled joints
        velCtrlIdx = velCtrlIndex;
        size_t nDoFVel = velCtrlIdx.size();
        selfColAdmInterface.reset(nDoF, nDoFVel);
        objColAdmInterface.reset(nDoF, nDoFVel);
        jointLimAdmInterface.reset(nDoF, nDoFVel);
    }
 
    void
    CollisionAvoidanceController::RtStatusForSafetyStrategy::rtPreActivate(const Config& c)
    {
        timeSinceStart = 0.0;
        inRecoveryMode = c.enableCollisionRecoveryOnStartup;
    }
 
    void
    CollisionAvoidanceController::RtStatusForSafetyStrategy::initJointLimtDataVec(
        const Config& c,
        const unsigned int nDoF,
        VirtualRobot::RobotNodeSetPtr& rns)
    {
        jointVel = 0.0;
        jointInertia = 0.0;
 
        localStiffnessJointLim = 0.0;
        dampingJointLim = 0.0;
 
        k1Lo = 0.0;
        k2Lo = 0.0;
        k3Lo = 0.0;
        k4Lo = 0.0;
        k1Hi = 0.0;
        k2Hi = 0.0;
        k3Hi = 0.0;
        k4Hi = 0.0;
 
        jointLimitData.resize(nDoF);
 
        /// obtain joint information (limits, limitless) from VirtualRobot
        for (size_t i = 0; i < nDoF; ++i)
        {
            jointLimitData[i].jointName = rns->getNode(i)->getName();
            jointLimitData[i].isLimitless = rns->getNode(i)->isLimitless();
 
            if (not jointLimitData[i].isLimitless)
            {
                jointLimitData[i].qLimLow = rns->getNode(i)->getJointLimitLow();
                jointLimitData[i].qLimHigh = rns->getNode(i)->getJointLimitHigh();
            }
        }
 
        //        std::vector<std::string> jointInfo;
        for (auto& joint : jointLimitData)
        {
            if (not joint.isLimitless)
            {
                /// set joint limit avoidance threshold parameters for not limiteless joints
                float qRange = joint.qLimHigh - joint.qLimLow;
                joint.thresholdRange = c.jointRangeBufferZone * qRange;
                joint.invThresholdSq = 1.0F / (joint.thresholdRange * joint.thresholdRange);
                joint.kRepulsive = c.maxRepulsiveTorque * joint.invThresholdSq;
                joint.qposThresholdLow = joint.qLimLow + joint.thresholdRange;
                joint.qposThresholdHigh = joint.qLimHigh - joint.thresholdRange;
                float qposZ1 = c.jointRangeBufferZoneZ1 * qRange;
                float qposZ2 = c.jointRangeBufferZoneZ2 * qRange;
                joint.qposZ1Low = joint.qLimLow + qposZ1;
                joint.qposZ2Low = joint.qLimLow + qposZ2;
                joint.qposZ1High = joint.qLimHigh - qposZ1;
                joint.qposZ2High = joint.qLimHigh - qposZ2;
                joint.jointLimitNullSpaceWeightsLow =
                    helper::calculateTransitionWeights(joint.qposZ1Low, joint.qposZ2Low);
                joint.jointLimitNullSpaceWeightsHigh =
                    helper::calculateTransitionWeights(joint.qposZ1High, joint.qposZ2High);
 
                /// from here: only the parameter output information is prepared
                //                std::vector<float> params = {joint.qLimLow,
                //                                             joint.qLimHigh,
                //                                             joint.qposThresholdLow,
                //                                             joint.qposThresholdHigh,
                //                                             joint.qposZ1Low,
                //                                             joint.qposZ2Low,
                //                                             joint.qposZ1High,
                //                                             joint.qposZ2High,
                //                                             joint.jointLimitNullSpaceWeightsLow(0),
                //                                             joint.jointLimitNullSpaceWeightsLow(1),
                //                                             joint.jointLimitNullSpaceWeightsLow(2),
                //                                             joint.jointLimitNullSpaceWeightsLow(3),
                //                                             joint.jointLimitNullSpaceWeightsHigh(0),
                //                                             joint.jointLimitNullSpaceWeightsHigh(1),
                //                                             joint.jointLimitNullSpaceWeightsHigh(2),
                //                                             joint.jointLimitNullSpaceWeightsHigh(3)};
                //                std::vector<std::string> stringParams;
                //                // convert float values to string rounded to two digits
                //                for (auto& param : params)
                //                {
                //                    std::stringstream ss;
                //                    ss << std::fixed << std::setprecision(2) << param;
                //                    stringParams.push_back(ss.str());
                //                }
                //                std::string info = joint.jointName + ": LimLo: " + stringParams[0] +
                //                                   " - LimHi: " + stringParams[1] + " - q0L: " + stringParams[2] +
                //                                   " - q0H: " + stringParams[3] + " - z1L: " + stringParams[4] +
                //                                   " z2L: " + stringParams[5] + " z1H: " + stringParams[6] +
                //                                   " z2H: " + stringParams[7] + " k1L: " + stringParams[8] +
                //                                   " k2L: " + stringParams[9] + " k3L: " + stringParams[10] +
                //                                   " k4L: " + stringParams[11] + " k1H: " + stringParams[12] +
                //                                   " k2H: " + stringParams[13] + " k3H: " + stringParams[14] +
                //                                   " k4H: " + stringParams[15];
                //                jointInfo.push_back(info);
            }
        }
 
        //        std::ostringstream oss;
        //        for (const auto& str : jointInfo)
        //        {
        //            oss << str << "\n";
        //        }
        //        std::string initMessage = oss.str();
        //        ARMARX_INFO << "joint limit avoidance parameters initialized for: \n" << initMessage;
    }
 
    void
    collision::validateConfigData(const arondto::CollisionAvoidanceConfig& cfg)
    {
        /// collision config parameters
        ARMARX_CHECK_GREATER(cfg.dampingFactor, 0.0); // damping can't be exactly zero
        ARMARX_CHECK_LESS_EQUAL(cfg.dampingFactor, 1.0); // for scaling of the damping
        ARMARX_CHECK_GREATER(cfg.maxRepulsiveForce, 0.0);
        ARMARX_CHECK_NONNEGATIVE(cfg.maxRepulsiveForce);
        ARMARX_CHECK_NONNEGATIVE(cfg.selfDistanceThreshold);
        ARMARX_CHECK_NONNEGATIVE(cfg.selfCollActivatorZ1);
        ARMARX_CHECK_NONNEGATIVE(cfg.selfCollActivatorZ2);
        ARMARX_CHECK_GREATER(cfg.selfCollActivatorZ2, cfg.selfCollActivatorZ1);
 
        /// joint limit avoidance config parameters
        ARMARX_CHECK_NONNEGATIVE(cfg.maxRepulsiveTorque);
        ARMARX_CHECK_NONNEGATIVE(cfg.jointRangeBufferZone);
        ARMARX_CHECK_LESS_EQUAL(cfg.jointRangeBufferZone, 1.0); // percentage value
        ARMARX_CHECK_NONNEGATIVE(cfg.jointRangeBufferZoneZ1);
        ARMARX_CHECK_LESS_EQUAL(cfg.jointRangeBufferZoneZ1, 1.0); // percentage value
        ARMARX_CHECK_NONNEGATIVE(cfg.jointRangeBufferZoneZ2);
        ARMARX_CHECK_GREATER(cfg.jointRangeBufferZoneZ2, cfg.jointRangeBufferZoneZ1);
        ARMARX_CHECK_LESS_EQUAL(cfg.jointRangeBufferZoneZ2, 1.0); // percentage value
        ARMARX_CHECK_NONNEGATIVE(cfg.safetyValFilter);
        ARMARX_CHECK_LESS_EQUAL(cfg.safetyValFilter, 1.0);
 
        /// check hierarchy flags for valid config
        if (cfg.topPrioritySelfCollisionAvoidance)
        {
            ARMARX_CHECK_EXPRESSION(cfg.enableSelfCollisionAvoidance);
            ARMARX_CHECK_EXPRESSION(
                (cfg.topPrioritySelfCollisionAvoidance == !cfg.topPriorityJointLimitAvoidance));
        }
        if (cfg.topPriorityJointLimitAvoidance)
        {
            ARMARX_CHECK_EXPRESSION(cfg.enableJointLimitAvoidance);
            ARMARX_CHECK_EXPRESSION(
                (cfg.topPrioritySelfCollisionAvoidance == !cfg.topPriorityJointLimitAvoidance));
        }
    }
 
    void
    CollisionAvoidanceController::RecoveryState::update(const Config& c,
                                                        RtStatusForSafetyStrategy& rtStatus,
                                                        double deltaT)
    {
        if (not c.enableCollisionRecoveryOnStartup or not rtStatus.inRecoveryMode)
        {
            collDistanceThreshold = c.selfDistanceThreshold;
            return;
        }
 
        /// 1. determine current time since start
        rtStatus.timeSinceStart += deltaT;
        if (rtStatus.timeSinceStart > c.recoveryDurationSec)
        {
            rtStatus.inRecoveryMode = false;
        }
 
        /// 2. update threshold
        collDistanceThreshold =
            std::min(c.selfDistanceThreshold,
                     collDistanceThresholdInit +
                         (c.selfDistanceThreshold - collDistanceThresholdInit) *
                             static_cast<float>(rtStatus.timeSinceStart) / c.recoveryDurationSec);
    }
 
    void
    CollisionAvoidanceController::RecoveryState::reset()
    {
        collDistanceThreshold = 0.0;
        collDistanceThresholdInit = 0.0;
    }
 
} // namespace armarx::control::common::control_law