feat(tracks): speed check of the paths against the speed their geometry allows: radius and cant, cant ramps, curves without transitions, switch branches

editor/editorSpeed.hpp

@@ -0,0 +1,80 @@
+/*
+This Source Code Form is subject to the
+terms of the Mozilla Public License, v.
+2.0. If a copy of the MPL was not
+distributed with this file, You can
+obtain one at
+http://mozilla.org/MPL/2.0/.
+*/
+
+#pragma once
+
+#include <string>
+#include <vector>
+#include <glm/glm.hpp>
+
+#include "editor/editorAlignment.hpp"
+
+class TTrack;
+
+// speed the geometry of the paths allows, set against the speed limits written in them
+namespace speed_check
+{
+
+enum class cause
+{
+	none,
+	radius, // unbalanced acceleration in the curve
+	cant_rate, // cant changes too fast for the passengers
+	cant_ramp, // the cant ramp is too steep for the wheels
+	jerk, // the unbalanced acceleration changes too fast, curves without the transitions
+	branch // diverging track of a switch, without cant
+};
+char const *describe(cause const Cause);
+
+struct options
+{
+	alignment::limits norms;
+	double branch_unbalanced{0.65}; // m/s2, for the diverging tracks of the switches
+	double reference_length{20.0}; // m, over which an abrupt change of the curvature or of the cant is felt
+	double step{2.0}; // m, between the checked points
+	double top{300.0}; // km/h, nothing above is looked into
+};
+
+struct verdict
+{
+	TTrack *track{nullptr};
+	int path{0};
+	double set{-1.0}; // km/h, -1: no limit of its own
+	double safe{0.0}; // km/h, Options.top when the geometry allows any speed
+	cause why{cause::none};
+	glm::dvec3 position{0.0}; // where the geometry is the tightest
+	double radius{0.0}; // m, there
+	double cant{0.0}; // mm, there
+	// over the reference length around the point: the radius and the cant at its ends, 0 m for a straight.
+	// negative where the curve turns the other way than at the point
+	double radius_from{0.0}, radius_to{0.0};
+	double cant_from{0.0}, cant_to{0.0}; // mm
+	double cant_slope{0.0}; // mm per m
+	// km/h, the safe speed without the limit of the switch branches, which is only a warning
+	double hard{0.0};
+	cause hard_why{cause::none};
+	// true when the speed set is above the safe one, or isn't set over a tight geometry; the switch branches not counted
+	bool violated(options const &Options) const;
+	// true when only the limit of a switch branch is exceeded
+	bool warned(options const &Options) const;
+};
+// what limits the speed, with the numbers which do
+std::string explain(verdict const &Verdict, options const &Options);
+
+verdict check(TTrack &Track, int const Path, options const &Options);
+// the safe speed rounded down to the usual steps of the speed limits
+double suggested(double const Safe);
+// speed limit in force on the path, -1 for none. a switch keeps one for both its tracks: positive applies to both,
+// -2 and below only to the diverging one, its main track having no limit then
+double path_velocity(TTrack const &Track, int const Path);
+// velocity of a switch which keeps its tracks to the limits given, -1 for none. one written value can't hold
+// a limit on each track, the main one gets the diverging one's limit too when that's lower
+double switch_velocity(double const Main, double const Diverging);
+
+} // namespace speed_check