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")