Update route_optimizer/green_route_optimizer.py

route_optimizer/green_route_optimizer.py

@@ -1,56 +1,71 @@
-# route_optimizer/green_route_optimizer.py
+# route_optimizer/green_route_optimizer.py (Updated to use weight)
 
 from geopy.geocoders import Nominatim
 import math
 
 class GreenRouteOptimizer:
-    """
-    GreenRouteOptimizer calculates optimized routes for rail, road, and ship.
-    Accepts place names (with optional country/short code) and returns distance and emission estimates.
-    """
-
     def __init__(self, user_agent="green_route_app"):
         self.geolocator = Nominatim(user_agent=user_agent)
-        # Emission factors in kg CO2 per km (example values)
+        # --- NOTE: These factors are now interpreted as kg CO₂ per tonne-km ---
         self.emission_factors = {
-            "road": 0.21,  # road transport
-            "rail": 0.041, # rail transport
-            "ship": 0.014  # shipping
+            "road": 0.21,
+            "rail": 0.041,
+            "ship": 0.014
         }
 
     def geocode(self, place_name):
-        """Returns (latitude, longitude) tuple for a given place name."""
-        location = self.geolocator.geocode(place_name)
-        if location is None:
-            raise ValueError(f"Could not geocode place: '{place_name}'")
-        return (location.latitude, location.longitude)
-
-    def optimize(self, start_coords, end_coords, mode="road"):
-        """Calculates Euclidean distance and estimated emissions."""
+        try:
+            location = self.geolocator.geocode(place_name, timeout=10)
+            if location is None:
+                return None
+            return (location.latitude, location.longitude)
+        except Exception:
+            return None
+
+    # --- CHANGE: Added 'weight_tonnes' as an argument ---
+    def optimize(self, start_coords, end_coords, mode, weight_tonnes):
         if mode not in self.emission_factors:
-            raise ValueError(f"Invalid mode '{mode}'. Choose from {list(self.emission_factors.keys())}.")
+            raise ValueError(f"Invalid mode '{mode}'.")
         
-        distance_km = math.dist(start_coords, end_coords) * 111  # approx km per degree
+        R = 6371
+        lat1, lon1 = start_coords
+        lat2, lon2 = end_coords
+        
+        dlat = math.radians(lat2 - lat1)
+        dlon = math.radians(lon2 - lon1)
+        a = math.sin(dlat / 2)**2 + math.cos(math.radians(lat1)) * math.cos(math.radians(lat2)) * math.sin(dlon / 2)**2
+        c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
+        distance_km = R * c
+
+        # --- CHANGE: Emission calculation now includes weight ---
+        estimated_emission = distance_km * self.emission_factors[mode] * weight_tonnes
+
         optimized_route = {
             "start": start_coords,
             "end": end_coords,
             "mode": mode,
             "optimized_distance_km": round(distance_km, 2),
-            "estimated_emission_kg": round(distance_km * self.emission_factors[mode], 3)
+            "estimated_emission_kg": round(estimated_emission, 3)
         }
         return optimized_route
 
-    def recommend_green_routes(self, start_place, end_place):
-        """
-        Returns optimized routes for all transport modes.
-        start_place and end_place can be:
-        - "City"
-        - "City, Country"
-        - "City, CountryCode" (short form)
-        """
+    # --- CHANGE: Added 'weight_tonnes' as an argument ---
+    def recommend_green_routes(self, start_place, end_place, weight_tonnes):
+        if not start_place or not start_place.strip():
+            return {"error": "Start place cannot be empty."}
+        if not end_place or not end_place.strip():
+            return {"error": "End place cannot be empty."}
+
         start_coords = self.geocode(start_place)
+        if start_coords is None:
+            return {"error": f"Could not find location: '{start_place}'"}
+
         end_coords = self.geocode(end_place)
+        if end_coords is None:
+            return {"error": f"Could not find location: '{end_place}'"}
+
         results = {}
         for mode in self.emission_factors:
-            results[mode] = self.optimize(start_coords, end_coords, mode)
-        return results
+            # --- CHANGE: Pass 'weight_tonnes' down to the optimize function ---
+            results[mode] = self.optimize(start_coords, end_coords, mode, weight_tonnes)
+        return results