seg fault or something else. cant find it ...

[marvin-ad-martianum]

[DEBUG] [1751485547.946398150] [force_controller_node]: u_opt=0.00, rpm_ss=0.00, rpm_target=0.00, F_z=0.00, input_vec=0.00, output_vec=0.00
[DEBUG] [1751485547.956408303] [force_controller_node]: u_opt=0.00, rpm_ss=0.00, rpm_target=0.00, F_z=0.00, input_vec=0.00, output_vec=0.00
[DEBUG] [1751485547.976383275] [force_controller_node]: u_opt=0.00, rpm_ss=0.00, rpm_target=0.00, F_z=0.00, input_vec=0.00, output_vec=0.00
[DEBUG] [1751485547.996454968] [force_controller_node]: u_opt=0.00, rpm_ss=0.00, rpm_target=0.00, F_z=0.00, input_vec=0.00, output_vec=0.00
[DEBUG] [1751485548.016420120] [force_controller_node]: u_opt=0.00, rpm_ss=0.00, rpm_target=0.00, F_z=0.00, input_vec=0.00, output_vec=0.00
deepc initialized
target 0
apply
[apply] entry: is_initialized=1, T_ini=40, target_size=23, output_dims=1, input_dims=1
[apply] before check_dimensions(target)
[apply] target dims OK
[apply] concatenating target (vector length=23)...
[apply] target_.size()=23
[apply] offset empty -> zero vector of size 23
[apply] offset_.size()=23
[apply] u_ini.size()=40, y_ini.size()=40
[apply] getting history vectors...
[apply] u_hist.len=40, y_hist.len=40
[apply] concatenating history into x...
[apply] x.size()=80
[apply] computing w = M_u^TQ(target_-M_xx) + Roffset_...
[apply] w.size()=23
[apply] solving G u = w via LDLT...
[apply] u_star.size()=23
[apply] calling projected_gradient_method...
[ros2run]: Segmentation fault
marvin@marvin-P1-7:~$

[dominichofer]

https://stackoverflow.com/questions/17965/how-to-generate-a-core-dump-in-linux-on-a-segmentation-fault

[marvin-ad-martianum]

ja danke. das git leider nid me info...

I müsst das usserhalb ros2 versueche z'reproduziere. Leider schaffis nid de bug zfinde....

deepc initialized
target 0
apply
[apply] entry: is_initialized=1, T_ini=40, target_size=23, output_dims=1, input_dims=1
[apply] before check_dimensions(target)
[apply] target dims OK
[apply] concatenating target (vector length=23)...
[apply] target_.size()=23
[apply] offset empty -> zero vector of size 23
[apply] offset_.size()=23
[apply] u_ini.size()=40, y_ini.size()=40
[apply] getting history vectors...
[apply] u_hist.len=40, y_hist.len=40
[apply] concatenating history into x...
[apply] x.size()=80
[apply] computing w = M_u^T*Q*(target_-M_x*x) + R*offset_...
[apply] w.size()=23
[apply] solving G u = w via LDLT...
[apply] u_star.size()=23
[apply] calling projected_gradient_method...
[PGM] entry: max_iters=300, tol=0.01, dim=23
[PGM] step_size=27.6526
[proj] called, u.size=23, min=-30, max=60, u.data=0x55913c629100
[proj] returning, constrained_u.data=0x55913c62a950
[PGM] iter=0 grad.norm=4.05608
[ros2run]: Segmentation fault

Da passierts

VectorXd candidate = x - step * grad;

VectorXd projected_gradient_method(
    const MatrixXd &M,
    const VectorXd &x0,
    const VectorXd &b,
    std::function<VectorXd(const VectorXd&)> proj,
    int max_iters,
    double tol) {
    std::cout << "[PGM] entry: max_iters=" << max_iters << ", tol=" << tol << ", dim=" << x0.size() << std::endl;
    double step = 1.0 / M.norm();
    std::cout << "[PGM] step_size=" << step << std::endl;
    VectorXd x = proj(x0);
    for (int k = 0; k < max_iters; ++k) {
        VectorXd grad = M * x - b;
        std::cout << "[PGM] iter=" << k << " grad.norm=" << grad.norm() << std::endl;
        // compute candidate before projection
        
        VectorXd candidate = x - step * grad;
        
        std::cout << "[PGM] iter=" << k
                  << " candidate.size=" << candidate.size()
                  << " candidate.data=" << static_cast<const void*>(candidate.data())
                  << std::endl;
        // apply projection
        VectorXd x_new = proj(candidate);
        std::cout << "[PGM] iter=" << k
                  << " x_new.size=" << x_new.size()
                  << " x_new.data=" << static_cast<const void*>(x_new.data())
                  << " x_new[0]=" << (x_new.size() ? x_new(0) : 0)
                  << std::endl;
        // convergence check
        double norm_diff = (x_new - x).norm();
        std::cout << "[PGM] iter=" << k << " diff.norm=" << norm_diff << std::endl;
        if (norm_diff < tol) {
            std::cout << "[PGM] converged at iter=" << k << std::endl;
            return x_new;
        }
        x.swap(x_new);
    }

[dominichofer]

What is static_cast<const void*> trying to achieve?

[marvin-ad-martianum]

ah it was just a way to print output to figure out when it crashes. (the 1d example is running).

The problem is very likely my external library. however, i canot figure out what it could be. What happens now is usually

[apply] computing w = M_u^TQ(target_-M_xx) + Roffset_...
[apply] w.size()=23
[apply] solving G u = w via LDLT...
[apply] u_star.size()=23
[apply] calling projected_gradient_method...
here it usually crashes
(x_new - x).norm(); 17.3404
[ros2run]: Segmentation fault

this line sometimes computes, sometimes not
(x_new - x).norm(); 17.3404

this is my external wrapper.

// deepc_controller_siso.cpp

#include "controllers/deepc_controller_siso.h"
#include "data_importer_and_resampler_extended.h"
#include "utilities.h"
#include <iostream>
#include "rclcpp/rclcpp.hpp"
#include <algorithm>
// --- Helper functions (static to this file) ---

static std::vector<Eigen::VectorXd> loadData(const YAML::Node &config, const std::string& key)
{
    auto params = config["data_importer_deepc_force"];
    if (!params) {
        throw std::runtime_error("Invalid or missing 'data_importer_deepc_force' in configuration.");
    }
    
    std::string path_to_csv_file = expandTilde(params["path_to_csv_file"].as<std::string>());

    dataImporterAndResampler importer(
        params["delta_T"].as<double>(),
        params["import_all_data"].as<bool>(),
        params["start_sample_index"].as<size_t>(),
        params["number_of_samples"].as<size_t>(),
        path_to_csv_file,
        params["layers_to_import"].as<std::vector<int>>()
    );
    
    std::cout << "Successfully loaded " << key << " data." << std::endl;
    return importer.getData({key});
}

static std::function<Eigen::VectorXd(const Eigen::VectorXd &)> createConstraintFunction(const YAML::Node &config)
{
    auto params = config["input_constraints_rpm"];
    if (!params) {
        throw std::runtime_error("input_constraints_rpm not found in the supplied YAML node");
    }
    
    double min_val = params["min"].as<double>();
    double max_val = params["max"].as<double>();

    return [min_val, max_val](const Eigen::VectorXd &u) -> Eigen::VectorXd {
        // FIX: Reverted to the self-contained implementation.
        // This creates a copy and clamps each element individually using the
        // standard library's std::clamp, which works on scalar values.
        Eigen::VectorXd constrained_u = u;
        for (int i = 0; i < u.size(); ++i) {
            constrained_u(i) = std::clamp(u(i), min_val, max_val);
        }
        return constrained_u;
    };
}

DeepCControllerSISO::DeepCControllerSISO(const YAML::Node &config)
  // The core Controller object is now initialized directly here, in the member initializer list.
  // This is the key change that fixes the memory error. It ensures the object is constructed
  // correctly before the constructor body is entered.
  : deepc_controller_(
        loadData(config, "rpm target"),
        loadData(config, "force"),
        config["T_ini"].as<int>(),
        config["target_size"].as<int>(),
        config["Q"].as<double>(),
        config["R"].as<double>(),
        createConstraintFunction(config),
        config["max_pgm_iterations"].as<int>(),
        config["pgm_tolerance"].as<double>()
    ),
    // Initialize other member variables
    target_size_(config["target_size"].as<int>())
{
    // The constructor body is now much cleaner.
    std::cout << "[DeepCControllerSISO] Controller constructed and initialized." << std::endl;
}

void DeepCControllerSISO::update(const Eigen::VectorXd &input_vector, const Eigen::VectorXd &output_vector)
{
    // Use member access operator '.' instead of pointer operator '->'
    deepc_controller_.update(input_vector, output_vector);
}

bool DeepCControllerSISO::isInitialized()
{
    return deepc_controller_.is_initialized();
}

Eigen::VectorXd DeepCControllerSISO::computeOptimalControlInput()
{
    if (!isInitialized()) {
        RCLCPP_WARN_ONCE(rclcpp::get_logger("DeepCControllerSISO"), "Controller not initialized, returning zero.");
        return Eigen::VectorXd::Zero(1);
    }

    // Create the target vector
    const std::vector<Eigen::VectorXd> target(target_size_, Eigen::VectorXd::Constant(1, force_target_));
    
    // Call apply() on the member object
    std::vector<Eigen::VectorXd> opt_control_input_sequence = deepc_controller_.apply(target);

    if (opt_control_input_sequence.empty()) {
        RCLCPP_ERROR_ONCE(rclcpp::get_logger("DeepCControllerSISO"), "DeePC solver failed, returning zero.");
        return Eigen::VectorXd::Zero(1);
    }

    return opt_control_input_sequence[0];
}

void DeepCControllerSISO::setForceTarget(double force_target)
{
    force_target_ = force_target;
}

somewhere here im probably doing something bad. no idea what.

[dominichofer]

https://stackoverflow.com/questions/3718998/fixing-segmentation-faults-in-c