mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-11-19 22:44:59 +01:00
141 lines
7.5 KiB
C++
141 lines
7.5 KiB
C++
#pragma once
|
|
|
|
#include <limits>
|
|
#include <string_view>
|
|
|
|
// the physical model of the coupling of two vehicles, used with couplerphysics set in eu07.ini (the legacy model of
|
|
// TMoverParameters::CouplerForce() otherwise). each vehicle end brings its buffers and its draw gear: progressive
|
|
// springs with friction hysteresis, pressed in series against those of the other end. the coupling has play (slack)
|
|
// in tension, or pulls the buffers in when its screw is tightened, and its steel link stretches for good past its
|
|
// yield force and breaks at its ultimate one, under a steady pull or the jerk of a run-out of the slack
|
|
namespace coupler_physics {
|
|
|
|
// force-deflection characteristic of the spring device of one vehicle end, its buffers or its draw gear:
|
|
// F(d) = F_end * ((1 - p) * u + p * u^3), u = d / travel, F_end = stiffness * travel
|
|
// p (the progression) 0 gives a linear spring; towards 1 it's soft at first and stiffens towards the end of the
|
|
// travel, as ring springs and elastomer pads do
|
|
struct spring_curve {
|
|
double stiffness{1.0}; // secant stiffness, up to the end of the travel [N/m]
|
|
double travel{0.1}; // [m]
|
|
double progression{0.0}; // 0 to 0.9
|
|
|
|
double end_force() const { return stiffness * travel; }
|
|
// force at the deflection [N], the deflection held within the travel
|
|
double force(double Deflection) const;
|
|
// deflection at the force [m]: the end of the travel at the end force and past it
|
|
double deflection(double Force) const;
|
|
// energy the device takes in along the curve up to the deflection [J]
|
|
double energy(double Deflection) const;
|
|
};
|
|
|
|
// the devices of both ends pressed against each other: they carry the same force, their deflections add up. past
|
|
// the end of the travel of one, the other one takes the rest. the result doesn't depend on the order of the two
|
|
struct series_split {
|
|
double force{0.0}; // [N]
|
|
double first{0.0}; // deflection of the first device [m]
|
|
double second{0.0}; // of the second one [m]
|
|
};
|
|
series_split series(spring_curve const &First, spring_curve const &Second, double Deflection);
|
|
|
|
// friction (Coulomb) hysteresis of a spring device: the force follows the loading curve while the deflection grows,
|
|
// drops to the unloading curve when it shrinks, and in between moves along a stiff transition line, as the friction
|
|
// of ring springs or of the wedges of a draw gear holds the device until the force changes enough
|
|
struct hysteresis {
|
|
double force{0.0}; // carried at the last update [N]
|
|
double deflection{0.0}; // at the last update [m]
|
|
|
|
// the force at the new deflection, given the force of the loading and of the unloading curve there, and the
|
|
// stiffness of the transition between them [N/m]
|
|
double update(double Deflection, double Loading, double Unloading, double Transition);
|
|
void reset();
|
|
};
|
|
|
|
// steel link of the coupling (the screw coupling and the hook, the knuckle of an automatic coupler): elastic up to
|
|
// the yield force, stretched for good past it (the hardening gives the force for each metre of it), broken at the
|
|
// ultimate force
|
|
struct link_strength {
|
|
double yield{std::numeric_limits<double>::max()}; // [N]
|
|
double ultimate{std::numeric_limits<double>::max()}; // [N]
|
|
double hardening{1.0}; // [N/m]
|
|
bool breakable{false}; // an articulated joint, or an end without a coupler set up, holds whatever
|
|
};
|
|
|
|
// the permanent elongation [m] the link has after carrying the force, given the one it had
|
|
double plastic_elongation(link_strength const &Link, double Force, double Elongation);
|
|
// peak force [N] of an elastic hit of two masses [kg] at the closing velocity [m/s] on a stop of the stiffness [N/m]:
|
|
// the kinetic energy of their relative motion all goes into the stop
|
|
double impact_force(double Velocity, double Stiffness, double Mass1, double Mass2);
|
|
// spread of the strength of the couplings as made: 1.0 to 1.2 of the rated force, fixed for the vehicle end, and the
|
|
// same on every compiler
|
|
double strength_scatter(std::string_view Name, int End);
|
|
|
|
// what the model takes of one vehicle end
|
|
struct end_parameters {
|
|
spring_curve buffers;
|
|
spring_curve draw_gear;
|
|
double slack{0.0}; // play of the coupling in tension [m], negative for the buffers pressed in by a tightened screw coupling
|
|
double buffers_unloading{0.5}; // force of the unloading curve to that of the loading one
|
|
double draw_gear_unloading{0.5};
|
|
double damping{0.0}; // viscous damping of the devices, while pressed [N s/m]
|
|
double link_stiffness{1.0}; // of the steel parts of the end, past the travel of the springs [N/m]
|
|
double crush_force{std::numeric_limits<double>::max()}; // a hit on the buffers past their travel with this force crushes them [N]
|
|
// coefficient of restitution of a hit on the springs gone solid: the steel of the housings and the underframe gives
|
|
// for good rather than springing back, so the vehicles share their momentum rather than pass it on
|
|
double solid_restitution{0.2};
|
|
link_strength link;
|
|
};
|
|
|
|
// the share of the energy of the relative motion a hit on the solid springs of the two ends takes, as the legacy
|
|
// collision (ComputeCollision()) takes it: 1 - e^2
|
|
double solid_hit_loss(end_parameters const &First, end_parameters const &Second);
|
|
|
|
// the weaker of the links of the two ends, which gives first; the same whichever end asks
|
|
link_strength weaker_link(end_parameters const &First, end_parameters const &Second);
|
|
|
|
// state of the coupling of two vehicle ends, which both vehicles keep alike: each updates its own copy with the same
|
|
// gap, so the copies stay the same
|
|
struct pair_state {
|
|
hysteresis draw_gear;
|
|
hysteresis buffers;
|
|
double elongation{0.0}; // permanent, of the link [m]; it adds to the slack until the vehicles are coupled again
|
|
double gap{0.0}; // at the last update [m]
|
|
int stop{0}; // at the last update: 1 the draw gear went solid, -1 the buffers did, 0 neither
|
|
double stop_force{0.0}; // the springs carried at the stop [N]
|
|
|
|
// a new coupling of the ends: the link adjusted (a screw coupling tightened anew), the draw gear released
|
|
void couple();
|
|
};
|
|
|
|
struct pair_input {
|
|
double gap{0.0}; // between the ends [m], negative with the buffers pressed in
|
|
double gap_rate{0.0}; // [m/s]
|
|
bool coupled{false};
|
|
bool adapter{false}; // an adapter on either end: the buffers don't meet, the coupler takes the push alone
|
|
bool damage{false}; // the link can stretch and break (crash damage on)
|
|
};
|
|
|
|
struct pair_result {
|
|
double force{0.0}; // between the ends, tension positive [N]
|
|
double tension{0.0}; // carried by the link [N]
|
|
double compression{0.0}; // carried by the buffers [N]
|
|
double buffers_deflection{0.0}; // of the buffers of the first end [m]
|
|
bool overloaded{false}; // the link was pulled past its yield force
|
|
bool broken{false}; // the link broke, it carries nothing now
|
|
};
|
|
|
|
// the force between the first end and the second one at the gap, updating the state of the pair
|
|
pair_result update_pair(end_parameters const &First, end_parameters const &Second, pair_state &State, pair_input const &Input);
|
|
|
|
// what a hit on the stop does to the ends
|
|
struct impact_result {
|
|
double force{0.0}; // peak force of the hit [N]
|
|
bool broken{false}; // the link broke under it
|
|
bool crushed{false}; // the buffers or the coupler of an end were crushed by it
|
|
};
|
|
|
|
// the hit on the stop the pair went solid against at the last update (State.stop), at the closing velocity [m/s], of
|
|
// the vehicles of the masses [kg]: stretches or breaks the link of a coupled pair, may crush the buffers
|
|
impact_result impact(end_parameters const &First, end_parameters const &Second, pair_state &State, double Velocity, double Mass1, double Mass2);
|
|
|
|
} // namespace coupler_physics
|