File size: 5,402 Bytes
2379054 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 | """
Register your core engineering functions as DeepSeek Harness tools
"""
import sys
import os
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from typing import Dict, Any, Optional
import pandas as pd
from core.engineering import (
run_compliance_checks,
calculate_lift_value,
calculate_slue_value,
calculate_cant_value,
calculate_twist,
check_radius_for_speed,
TrackData,
NR_LIMITS,
compute_track_displacements,
)
from core.xml_parser import parse_station_base, parse_geometry_report, alignment_names
from core.standards_loader import get_limit, load_standards
calculate_lift = calculate_lift_value
calculate_slue = calculate_slue_value
calculate_cant = calculate_cant_value
def run_qa_checks(track_data, limits, track_category="C", design_speed=75.0, track_name=""):
track = TrackData(
track_no=1,
chainages=list(track_data.get("lift", {}).keys()),
lifts=track_data.get("lift", {}),
slues=track_data.get("slue", {}),
ex_cants=track_data.get("ex_cant", {}),
pr_cants=track_data.get("pr_cant", {}),
ex_levels=track_data.get("ex_low", {}),
pr_levels=track_data.get("pr_low", {}),
radii=track_data.get("pr_radius", {}),
)
return run_compliance_checks(track, limits, track_category, design_speed, track_name)
def get_standard_limit(parameter, default=None):
return get_limit(parameter, default)
def get_alignment_names(df):
return alignment_names(df)
def compute_displacements(track_data, track_no, chainages):
return compute_track_displacements(track_data, track_no, chainages).to_dict()
def get_nr_limits():
return NR_LIMITS
def register_engineering_tools(harness):
"""Register all engineering functions as Harness tools"""
@harness.tool(name="run_qa_checks", description="Run Network Rail QA compliance checks")
def tool_run_qa_checks(track_data: Dict, limits: Dict, track_category: str = "C", design_speed: float = 75.0, track_name: str = "") -> Dict:
track = TrackData(
track_no=1,
chainages=list(track_data.get("lift", {}).keys()),
lifts=track_data.get("lift", {}),
slues=track_data.get("slue", {}),
ex_cants=track_data.get("ex_cant", {}),
pr_cants=track_data.get("pr_cant", {}),
ex_levels=track_data.get("ex_low", {}),
pr_levels=track_data.get("pr_low", {}),
radii=track_data.get("pr_radius", {})
)
return run_compliance_checks(track, limits, track_category, design_speed, track_name)
@harness.tool(name="calculate_lift", description="Calculate lift/lower in mm")
def tool_calculate_lift(existing_level: float, proposed_level: float) -> Optional[float]:
return calculate_lift_value(existing_level, proposed_level)
@harness.tool(name="calculate_slue", description="Calculate slue/slew in mm")
def tool_calculate_slue(existing_offset: float, proposed_offset: float) -> Optional[float]:
return calculate_slue_value(existing_offset, proposed_offset)
@harness.tool(name="calculate_cant", description="Calculate cant in mm")
def tool_calculate_cant(left_level: float, right_level: float) -> Optional[float]:
return calculate_cant_value(left_level, right_level)
@harness.tool(name="calculate_twist", description="Calculate twist in mm/m")
def tool_calculate_twist(level1: float, level2: float, distance_m: float) -> Optional[float]:
return calculate_twist(level1, level2, distance_m)
@harness.tool(name="check_radius_for_speed", description="Check radius for speed")
def tool_check_radius_for_speed(radius_m: float, speed_mph: float, max_cant_def_mm: float = 110.0, applied_cant_mm: float = 0.0) -> tuple:
return check_radius_for_speed(radius_m, speed_mph, max_cant_def_mm, applied_cant_mm)
@harness.tool(name="get_standard_limit", description="Get limit from NR standards")
def tool_get_standard_limit(parameter: str, default: Optional[float] = None) -> Optional[float]:
return get_limit(parameter, default)
@harness.tool(name="load_standards", description="Load all NR standards")
def tool_load_standards() -> Dict:
return load_standards()
@harness.tool(name="parse_station_base", description="Parse Station Base XML")
def tool_parse_station_base(xml_bytes: bytes) -> pd.DataFrame:
return parse_station_base(xml_bytes)
@harness.tool(name="parse_geometry_report", description="Parse Geometry Report XML")
def tool_parse_geometry_report(xml_bytes: bytes) -> tuple:
return parse_geometry_report(xml_bytes)
@harness.tool(name="get_alignment_names", description="Get alignment names")
def tool_get_alignment_names(df: pd.DataFrame) -> list:
return alignment_names(df)
@harness.tool(name="compute_displacements", description="Compute track displacements")
def tool_compute_displacements(track_data: Dict, track_no: int, chainages: list) -> Dict:
result = compute_track_displacements(track_data, track_no, chainages)
return result.to_dict()
@harness.tool(name="get_nr_limits", description="Get default NR limits")
def tool_get_nr_limits() -> Dict:
return NR_LIMITS
print("Engineering tools registered")
|