add dummy calculation endpoint

src/calculation_time_constrains/flows.py

@@ -1,11 +1,13 @@
+import numpy as np
 from sqlalchemy import Select, func, select
 from src.workorder.model import MasterWorkOrder
 from src.scope_equipment.model import ScopeEquipment
 from src.scope.model import Scope
 from src.database.core import DbSession
 from src.scope.service import get_all
-from .schema import CalculationTimeConstrainsParametersRead
-from .service import get_overhaul_cost_by_time_chart
+from .schema import CalculationTimeConstrainsParametersRead, CalculationTimeConstrainsCreate
+from .service import get_overhaul_cost_by_time_chart, get_corrective_cost_time_chart
+
 
 async def get_create_calculation_parameters(*, db_session: DbSession):
     stmt = (
@@ -40,27 +42,48 @@ async def get_create_calculation_parameters(*, db_session: DbSession):
     )
 
 
-async def create_calculation(*, db_session: DbSession):
-
+async def create_calculation(*, db_session: DbSession, calculation_time_constrains_in: CalculationTimeConstrainsCreate):
+    days = 365
     ##
+    overhaul_cost_points = get_overhaul_cost_by_time_chart(
+        calculation_time_constrains_in.overhaulCost, days)
+    corrective_cost_points, dailyNumberOfFailure = get_corrective_cost_time_chart(
+        calculation_time_constrains_in.costPerFailure, days)
+
+    total_cost = overhaul_cost_points + corrective_cost_points
 
+    optimumOH = np.argmin(total_cost)
+    numbersOfFailure = sum(dailyNumberOfFailure[:optimumOH])
+
+    # raise Exception(optimumOH)
+
+    points = []
+    for i in range(days):
+        points.append({
+            "day": int(i+1),
+            "overhaulCost": float(overhaul_cost_points[i]),
+            "correctiveCost": float(corrective_cost_points[i]),
+            "totalCost": float(overhaul_cost_points[i] + corrective_cost_points[i]),
+            # "dailyFailureRate": float(daily_failure_rate[i]),
+            # "cumulativeFailures": float(failure_counts[i])
+        })
 
     return {
         "id": "calc_123",
         "result": {
             "summary": {
-                "scope": "B",
-                "numberOfFailures": 59,
-                "optimumOHTime": 90,
-                "optimumTotalCost": 500000000
+                "scope": calculation_time_constrains_in.scopeOH,
+                "numberOfFailures": int(np.floor(numbersOfFailure)),
+                "optimumOHTime": int(optimumOH+1),
+                "optimumTotalCost": float(total_cost[optimumOH]),
             },
-            "chartData": {},
-            "comparisons": {
-                "vsLastCalculation": {
-                    "costDifference": -50000000,
-                    "timeChange": "+15 days"
-                }
-            }
+            "chartData": points,
+            # "comparisons": {
+            #     "vsLastCalculation": {
+            #         "costDifference": -50000000,
+            #         "timeChange": "+15 days"
+            #     }
+            # }
         },
         "simulationLimits": {
             "minInterval": 30,

src/calculation_time_constrains/router.py

@@ -24,7 +24,7 @@ async def get_calculation_parameters(db_session: DbSession):
 @router.post("", response_model=StandardResponse[CalculationTimeConstrainsRead])
 async def create_calculation_time_constrains(db_session: DbSession, calculation_time_constrains_in: CalculationTimeConstrainsCreate):
     """Calculate Here"""
-    calculation_result = await create_calculation(db_session=db_session)
+    calculation_result = await create_calculation(db_session=db_session, calculation_time_constrains_in=calculation_time_constrains_in)
 
     return StandardResponse(data=CalculationTimeConstrainsRead(
         id=calculation_result["id"],

src/calculation_time_constrains/service.py

@@ -2,5 +2,26 @@ import numpy as np
 
 
 def get_overhaul_cost_by_time_chart(overhaul_cost: float, days: int) -> list:
-    exponents = np.arange(1, days + 1)
-    return overhaul_cost / (2 ** exponents)
+    exponents = np.arange(0, days)
+    results = overhaul_cost / (2 ** exponents)
+    return results
+
+
+def get_corrective_cost_time_chart(cost_per_failure: float, days: int) -> list:
+    day_points = np.arange(0, days)    
+    
+    # Parameters for failure rate
+    base_rate = 1.2  # Base failure rate per day
+    acceleration = 7.2  # How quickly failure rate increases
+    grace_period = 50  # Days before failures start increasing significantly
+    
+    # Calculate daily failure rate using sigmoid function
+    daily_failure_rate = base_rate / (1 + np.exp(-acceleration * (day_points - grace_period)/days))
+    
+    # Calculate cumulative failures
+    failure_counts = np.cumsum(daily_failure_rate)
+    
+    # Calculate corrective costs based on cumulative failures and cost per failure
+    corrective_costs = failure_counts * cost_per_failure
+    
+    return corrective_costs, failure_counts