hybrid_friction.hpp

Go to the documentation of this file.

// sbl/dsp/pm/hybrid_friction.hpp — The table's curve, its force scaled by the rosin's warmth (Physical modeling — primitive)
//
// Woodhouse 2003 §5: a friction curve whose whole force–velocity relation,
// limit included, scales with μ(T). The TableFriction finds the force at the
// weight warm rosin leaves it; the ThermalFriction keeps the temperature from
// that force and the sliding speed. The scaling is applied when the weight is
// set — once a block, by the bow that owns this — not every sample
// (physical-modeling.md §5.5). Parked since the first calibration (AP-040:
// permanent stick at C4 bare), kept as the third law so the choice stays a
// type, not a branch.
 
#ifndef SBL_DSP_PM_HYBRID_FRICTION_HPP_
#define SBL_DSP_PM_HYBRID_FRICTION_HPP_
 
#include <cmath>
#include <cstdint>
 
#include <sbl/dsp/diagram/graph.hpp>
#include <sbl/dsp/pm/contracts.hpp>
#include <sbl/dsp/pm/table_friction.hpp>
#include <sbl/dsp/pm/thermal_friction.hpp>
 
namespace sbl::dsp::pm {
 
class HybridFriction {
public:
    /// @note All public methods are ISR-safe — bounded computation, no I/O.
 
    /// The table read, and the cold limits the rosin warms.
    void set_bow(const BowTable& bow) {
        table_.set_bow(bow);
        rosin_.set_limits(bow.limits, bow.slices);
    }
 
    /// Bow force across the family [0, 1]; the table sees it scaled by the
    /// rosin's warmth as of now. Set once a block.
    void set_force_su(float su) {
        force_su_ = su < 0.0f ? 0.0f : (su > 1.0f ? 1.0f : su);
        rosin_.set_force_su(force_su_);
        table_.set_force_su(force_su_ * rosin_.mu_rel());
    }
 
    /// The rosin, for its parameters (ThermalFriction::set_rosin, set_fast_cooling).
    ThermalFriction& rosin() { return rosin_; }
    const ThermalFriction& rosin() const { return rosin_; }
 
    /// One sample: relative velocity in, force out (wave units).
    float process(float dv_free) {
        const float force = table_.process(dv_free);
        const float a = std::fabs(dv_free);
        const float fa = std::fabs(force);
        rosin_.advance(force, table_.sticking() ? 0.0f : a - fa);
        return force;
    }
 
    bool sticking() const { return table_.sticking(); }
    float limit() const { return table_.limit(); }
    float temperature() const { return rosin_.temperature(); }
 
    void reset() {
        table_.reset();
        rosin_.reset();
    }
 
    diagram::Ports describe(diagram::Graph& g, uint8_t group, const char* name = "friction (hybrid)") const {
        return table_.describe(g, group, name);
    }
 
private:
    TableFriction table_;
    ThermalFriction rosin_;
    float force_su_ = 1.0f;
};
 
static_assert(is_friction_law_v<HybridFriction>, "HybridFriction is a friction law (physical-modeling.md §4.5)");
 
} // namespace sbl::dsp::pm
 
#endif // SBL_DSP_PM_HYBRID_FRICTION_HPP_