I am trying to build an end-to-end supply chain simulator code that has all the logical operations; however, since I am using the Monte Carlo simulation approach, I am feeding random values for forecasted demand, real demand, and lead times. It is a two step process; the random values are being generated correctly, and if I fetch these values seperately using the same logic i used in my simulation, it works. However, when I run the entire code. it seems to affect 0 demand, in all instances leading to an error in the model as it is not considering the generated demand value. The error seems to be in the dictionary created. Can someone help me please?

Below is my code for reference
import pandas as pd
import simpy
import matplotlib.pyplot as plt
import numpy as np
import time

plt.switch_backend('Agg')

transcript = []

def load_data(file_path):
    print(f"Loading data from {file_path}")
    return pd.read_excel(file_path, sheet_name=None)

def load_demand_review(file_path):
    return pd.read_excel(file_path)

def load_random_demand_values(file_path):
    return pd.read_excel(file_path)

def load_random_supplier_lead_times(file_path):
    return pd.read_excel(file_path)

def load_random_transit_lead_times(file_path):
    return pd.read_excel(file_path)

def calculate_safety_stock(service_level, average_demand, demand_std, lead_time, lead_time_std):
    z_score = 1.65  # Z-score for 95% service level
    safety_stock = z_score * np.sqrt((lead_time * (demand_std ** 2)) + ((average_demand ** 2) * (lead_time_std ** 2)))
    return safety_stock

def get_timestamp():
    return time.strftime("%Y%m%d-%H%M%S")

def get_forecasted_demand_one_month_prior(forecasted_demand_dict, location, product, current_time):
    forecasted_time = current_time  # Ensure correct indexing
    key = (location, product)
    if key in forecasted_demand_dict:
        demand_array = forecasted_demand_dict[key]
        print(f"Checking forecasted demand for key {key} with length {len(demand_array)} at time {forecasted_time}")
        if forecasted_time < len(demand_array):
            print(f"Fetching forecasted demand for {location}, {product} at time {forecasted_time}: {demand_array[forecasted_time]}")
            return demand_array[forecasted_time]
        else:
            print(f"No forecasted demand for {location}, {product} at time {forecasted_time}, returning 0")
            return 0
    print(f"Key {key} not found in forecasted_demand_dict")
    return 0

ldc_data = load_data('E:\Python example database\LDC_workbook.xlsx')
gdc_data = load_data('E:\Python example database\GDC_workbook.xlsx')
manufacturing_data = load_data('E:\Python example database\Manufacturing_workbook.xlsx')
supplier_data = load_data('E:\Python example database\Supplier_workbook.xlsx')
demand_review_data = load_demand_review('E:\Python example database\Demand Review.xlsx')
transit_times_df = pd.read_excel('E:\Python example database\TransitTimes.xlsx')

random_demand_values = load_random_demand_values('E:\Python example database\generated_values\random_demand_values.xlsx')
random_supplier_lead_times = load_random_supplier_lead_times('E:\Python example database\generated_values\random_supplier_lead_times.xlsx')
random_transit_lead_times = load_random_transit_lead_times('E:\Python example database\generated_values\random_transit_lead_times.xlsx')

required_columns = ['Supplier', 'Sub_component', 'Lead_time', 'Order_quantity', 'Initial_Inventory']
missing_columns = [col for col in required_columns if col not in supplier_data['Suppliers'].columns]
if missing_columns:
    raise KeyError(f"Missing required columns in supplier_data: {missing_columns}")

def log(self, time, product_name, product_type, action, quantity, fulfilled, inventory_level):
    log_entry = {
        'Time': time,
        'Entity': self.name,
        'Product name': product_name,
        'product type': product_type,
        'Action': action,
        'Quantity': quantity,
        'Fulfilled': fulfilled,
        'Inventory_Level': inventory_level
    }
    self.ledger.append(log_entry)
    transcript.append(log_entry)

class Supplier:
    def __init__(self, name, sub_component, lead_time_distribution, order_quantity, initial_inventory):
        self.name = name
        self.sub_component = sub_component
        self.lead_time_distribution = lead_time_distribution
        self.order_quantity = order_quantity
        self.inventory = initial_inventory
        self.total_fulfilled_orders = 0
        self.total_unfulfilled_orders = 0
        self.fulfilled_orders = []
        self.monthly_data = []
        self.ledger = []  # Ledger for logging interactions

    def fulfill_order(self, env, quantity):
        lead_time = self.lead_time_distribution  # Directly using pre-loaded lead times
        yield env.timeout(lead_time)
        if self.inventory >= quantity:
            fulfilled = quantity
        else:
            fulfilled = self.inventory
        self.inventory -= fulfilled
        self.total_fulfilled_orders += fulfilled
        self.total_unfulfilled_orders += (quantity - fulfilled)
        self.fulfilled_orders.append((self.sub_component, fulfilled))
        self.monthly_data.append((env.now, fulfilled, quantity - fulfilled))
        self.log(env.now, self.sub_component, 'subcomponent', 'Fulfill Order', quantity, fulfilled, self.inventory)
        print(f"Supplier {self.name} - Fulfilled: {fulfilled}, Unfulfilled: {quantity - fulfilled}, Inventory left: {self.inventory}")
        return fulfilled

    def log(self, time, product_name, product_type, action, quantity, fulfilled, inventory_level):
        log_entry = {
            'Time': time,
            'Entity': self.name,
            'Product name': product_name,
            'product type': product_type,
            'Action': action,
            'Quantity': quantity,
            'Fulfilled': fulfilled,
            'Inventory_Level': inventory_level
        }
        self.ledger.append(log_entry)
        transcript.append(log_entry)

class ManufacturingPlant:
    def __init__(self, env, name, products, supplier, forecasted_demand):
        self.env = env
        self.name = name
        self.products = products  # Dictionary containing product-specific info
        self.supplier = supplier
        self.forecasted_demand = forecasted_demand
        self.ledger = []  # Ledger for logging interactions

        # Initialize production rates and inventory levels for each product
        self.production_rates = {product: self.sanitize_production_rate(info['production_rate']) for product, info in products.items()}
        self.inventory_levels = {product: info['finished_goods_inventory'] for product, info in products.items()}
        self.sub_component_inventories = {product: info['sub_component_inventory'] for product, info in products.items()}
        self.manufactured_units = {product: [] for product in products}
        self.fulfilled_orders = {product: [] for product in products}
        
        # Initialize safety stock for each product
        self.safety_stocks = {}
        for product, info in products.items():
            avg_demand = np.mean(list(info['sub_component_inventory'].values()))
            std_demand = np.std(list(info['sub_component_inventory'].values()))
            avg_lead_time = supplier.lead_time_distribution
            std_lead_time = 0  # Assuming zero lead time std for simplicity
            self.safety_stocks[product] = calculate_safety_stock(0.95, avg_demand, std_demand, avg_lead_time, std_lead_time)
        
        env.process(self.produce_goods())

    def sanitize_production_rate(self, production_rate):
        try:
            return float(production_rate)
        except ValueError:
            print(f"Invalid production rate '{production_rate}' for {self.name}. Setting to default value 1.0")
            return 1.0

    def produce_goods(self):
        while True:
            current_time = int(self.env.now)
            for product in self.products:
                forecasted_demand = get_forecasted_demand_one_month_prior(self.forecasted_demand, self.name, product, current_time)

                # Ensure forecasted_demand is a float
                forecasted_demand = float(forecasted_demand)

                print(f"Time {current_time}: Forecasted demand for {product} is {forecasted_demand}")

                # Adjust production rate based on forecasted demand
                if forecasted_demand > self.production_rates[product]:
                    self.adjust_production_rate(product, forecasted_demand)

                # Production logic for each product
                if self.inventory_levels[product] >= forecasted_demand:
                    self.inventory_levels[product] -= forecasted_demand
                    self.manufactured_units[product].append((current_time, forecasted_demand))
                    self.log(current_time, product, 'Finished good', 'Produce Goods', forecasted_demand, forecasted_demand, self.inventory_levels[product])
                    print(f"Manufacturing Plant {self.name} - Produced {forecasted_demand} units of {product}, Inventory left: {self.inventory_levels[product]}")
                else:
                    deficit = forecasted_demand - self.inventory_levels[product]
                    self.inventory_levels[product] = 0
                    self.safety_stocks[product] -= deficit

                # Sub-component check
                if all(self.sub_component_inventories[product].get(comp, 0) >= forecasted_demand for comp in self.products[product]['sub_components']):
                    for comp in self.products[product]['sub_components']:
                        self.sub_component_inventories[product][comp] -= forecasted_demand
                    self.inventory_levels[product] += self.production_rates[product]
                    self.manufactured_units[product].append((current_time, self.production_rates[product]))
                    self.log(current_time, product, 'Finished good', 'Produce Goods', self.production_rates[product], self.production_rates[product], self.inventory_levels[product])
                    print(f"Manufacturing Plant {self.name} - Produced {self.production_rates[product]} units of {product}, Inventory left: {self.inventory_levels[product]}")
                else:
                    for comp in self.products[product]['sub_components']:
                        if self.sub_component_inventories[product].get(comp, 0) < forecasted_demand:
                            quantity_needed = forecasted_demand - self.sub_component_inventories[product].get(comp, 0)
                            print(f"Manufacturing Plant {self.name} - Ordering {quantity_needed} units of {comp} from supplier")
                            yield self.env.process(self.supplier.fulfill_order(self.env, quantity_needed))
                            self.sub_component_inventories[product][comp] += quantity_needed
                            print(f"Manufacturing Plant {self.name} - Received {quantity_needed} units of {comp}, Inventory left: {self.sub_component_inventories[product][comp]}")

            yield self.env.timeout(1)

    def adjust_production_rate(self, product, total_demand):
        self.production_rates[product] = max(total_demand // 30, 1)
        self.log(self.env.now, product, 'Finished good', 'Adjust Production Rate', total_demand, total_demand, self.production_rates[product])

    def fulfill_order(self, env, product, quantity):
        if self.inventory_levels[product] >= quantity:
            fulfilled = quantity
        else:
            fulfilled = self.inventory_levels[product]
        self.inventory_levels[product] -= fulfilled
        self.manufactured_units[product].append((env.now, fulfilled))
        self.log(env.now, product, 'Finished good', 'Fulfill Order', quantity, fulfilled, self.inventory_levels[product])
        print(f"Manufacturing Plant {self.name} - Fulfilled order of {fulfilled} units of {product}, Inventory left: {self.inventory_levels[product]}")
        return fulfilled

    def receive_gdc_order(self, quantity, gdc):
        for product in self.products:
            fulfilled = yield self.env.process(self.fulfill_order(self.env, product, quantity))
            gdc.receive_goods(fulfilled)
            yield self.env.timeout(1)

    def place_order_to_supplier(self, component, quantity):
        yield self.env.process(self.supplier.fulfill_order(self.env, quantity))
        self.sub_component_inventories[component] += quantity
        self.log(self.env.now, component, 'subcomponent', 'Place Order to Supplier', quantity, quantity, self.sub_component_inventories[component])

    def receive_goods_from_supplier(self, component, quantity):
        self.sub_component_inventories[component] += quantity
        self.log(self.env.now, component, 'subcomponent', 'Receive Goods from Supplier', quantity, quantity, self.sub_component_inventories[component])

    def log(self, time, product_name, product_type, action, quantity, fulfilled, inventory_level):
        log_entry = {
            'Time': time,
            'Entity': self.name,
            'Product name': product_name,
            'product type': product_type,
            'Action': action,
            'Quantity': quantity,
            'Fulfilled': fulfilled,
            'Inventory_Level': inventory_level
        }
        self.ledger.append(log_entry)
        transcript.append(log_entry)

class GlobalDistributionCenter:
    def __init__(self, env, name, fg_name, inventory_level, manufacturing_plant, forecasted_demand):
        self.env = env
        self.name = name
        self.fg_name = fg_name
        self.inventory_level = inventory_level
        self.manufacturing_plant = manufacturing_plant
        self.total_fulfilled_orders = 0
        self.total_unfulfilled_orders = 0
        self.fulfilled_orders = []
        self.monthly_data = []
        self.ledger = []  # Ledger for logging interactions
        self.forecasted_demand = forecasted_demand
        
        # Calculate initial safety stock
        avg_demand = np.mean(forecasted_demand)  # Adjusted
        std_demand = np.std(forecasted_demand)  # Adjusted
        avg_lead_time = manufacturing_to_gdc_lead_times.get((self.manufacturing_plant.name, self.fg_name, self.name), 0)
        std_lead_time = 0  # Assuming a constant lead time for simplicity
        self.safety_stock = calculate_safety_stock(0.95, avg_demand, std_demand, avg_lead_time, std_lead_time)

    def fulfill_order(self, quantity):
        print(f"GDC {self.name} - Received order for {quantity} units")
        if self.inventory_level >= quantity + self.safety_stock:
            fulfilled = quantity
        else:
            fulfilled = self.inventory_level - self.safety_stock
            if fulfilled < 0:
                fulfilled = 0
        self.inventory_level -= fulfilled
        self.total_fulfilled_orders += fulfilled
        self.total_unfulfilled_orders += (quantity - fulfilled)
        self.fulfilled_orders.append((self.fg_name, fulfilled, quantity - fulfilled))
        self.monthly_data.append((self.env.now, fulfilled, quantity - fulfilled))
        self.log(self.env.now, self.fg_name, 'Finished good', 'Fulfill Order', quantity, fulfilled, self.inventory_level)
        print(f"GDC {self.name} - Fulfilled: {fulfilled}, Unfulfilled: {quantity - fulfilled}, Inventory left: {self.inventory_level}")
        return fulfilled, quantity - fulfilled

    def place_order(self, quantity):
        yield self.env.process(self.manufacturing_plant.receive_gdc_order(quantity, self))
        self.log(self.env.now, self.fg_name, 'Finished good', 'Place Order', quantity, 0, self.inventory_level)  # Adjusted
        yield self.env.timeout(0)

    def receive_goods(self, quantity):
        self.inventory_level += quantity
        self.log(self.env.now, self.fg_name, 'Finished good', 'Receive Goods', quantity, quantity, self.inventory_level)  # Adjusted
        print(f"GDC {self.name} - Goods received: {quantity}")

    def receive_order_from_ldc(self, ldc, quantity):
        fulfilled, unfulfilled = self.fulfill_order(quantity)
        if unfulfilled > 0:
            yield self.env.process(self.place_order(unfulfilled))
        ldc.receive_goods(fulfilled)
        yield self.env.timeout(1)

    def forecast_next_day_demand(self):
        next_day = int(self.env.now + 1)  # Ensure next_day is an integer
        next_day_demand = sum(ldc.forecasted_demand[next_day] if next_day < len(ldc.forecasted_demand) else 0 for ldc in ldcs if ldc.global_distribution_center == self)
        self.log(self.env.now, self.fg_name, 'Finished good', 'Forecast Next Day Demand', next_day_demand, 0, self.inventory_level)  # Adjusted
        return next_day_demand

    def adjust_orders(self):
        while True:
            current_time = int(self.env.now)
            forecasted_demand = get_forecasted_demand_one_month_prior(self.forecasted_demand, self.name, self.fg_name, current_time)
            next_day_demand = self.forecast_next_day_demand()
            print(f"GDC {self.name} - Next day demand: {next_day_demand}")
            if self.inventory_level < next_day_demand + self.safety_stock:
                deficit = next_day_demand - self.inventory_level + self.safety_stock
                yield self.env.process(self.place_order(deficit))
            yield self.env.timeout(1)

    def check_nearby_gdcs_or_ldcs(self, part_name, quantity_needed):
        if (self.name, part_name) not in transit_times:
            print(f"Error: No transit time found for ({self.name}, {part_name})")
            return None, None

        for nearby_name, transit_time in transit_times[(self.name, part_name)].items():
            if nearby_name in [gdc.name for gdc in gdcs]:
                nearby_gdc = next(gdc for gdc in gdcs if gdc.name == nearby_name)
                if nearby_gdc.fg_name == part_name and nearby_gdc.inventory_level >= quantity_needed:
                    return nearby_gdc, transit_time // 30
            elif nearby_name in [ldc.name for ldc in ldcs]:
                nearby_ldc = next(ldc for ldc in ldcs if ldc.name == nearby_name)
                if nearby_ldc.fg_name == part_name and nearby_ldc.inventory_level >= quantity_needed:
                    return nearby_ldc, transit_time // 30
        return None, None

    def log(self, time, product_name, product_type, action, quantity, fulfilled, inventory_level):  # Adjusted
        log_entry = {
            'Time': time,
            'Entity': self.name,
            'Product name': product_name,
            'product type': product_type,
            'Action': action,
            'Quantity': quantity,
            'Fulfilled': fulfilled,
            'Inventory_Level': inventory_level
        }
        self.ledger.append(log_entry)
        transcript.append(log_entry)

class LocalDistributionCenter:
    def __init__(self, env, name, fg_name, global_distribution_center, initial_inventory, forecasted_demand, real_demand):
        self.env = env
        self.name = name
        self.fg_name = fg_name
        self.inventory_level = initial_inventory
        self.global_distribution_center = global_distribution_center
        self.forecasted_demand = forecasted_demand
        self.real_demand = real_demand
        self.total_fulfilled_orders = 0
        self.total_unfulfilled_orders = 0
        self.fulfilled_orders = []
        self.monthly_data = []
        self.ledger = []  # Ledger for logging interactions
        
        # Calculate initial safety stock
        avg_demand = np.mean(real_demand)
        std_demand = np.std(real_demand)
        avg_lead_time = gdc_to_ldc_lead_times.get((self.global_distribution_center.name, self.fg_name, self.name), 0)
        std_lead_time = 0  # Assuming a constant lead time for simplicity
        self.safety_stock = calculate_safety_stock(0.95, avg_demand, std_demand, avg_lead_time, std_lead_time)

    def simulate_demand(self):
        month_limit = 3
        while self.env.now < month_limit:
            current_time = int(self.env.now)
            forecasted_demand = get_forecasted_demand_one_month_prior(self.forecasted_demand, self.name, self.fg_name, current_time)
            if current_time < len(self.real_demand):
                demand = self.real_demand[current_time]
            else:
                demand = 0
                print(f"LDC {self.name} - No demand data available for time {current_time}, defaulting demand to 0")

            print(f"LDC {self.name} - Current Inventory: {self.inventory_level}, Forecasted Demand: {forecasted_demand}, Real Demand: {demand}")

            fulfilled, unfulfilled = self.fulfill_order(demand)
            if unfulfilled > 0:
                print(f"LDC {self.name} - Unfulfilled demand: {unfulfilled}, placing order")
                yield self.env.process(self.place_order(unfulfilled))
                nearby_entity, transit_time = self.check_nearby_gdcs_or_ldcs(self.fg_name, unfulfilled)
                if nearby_entity:
                    print(f"LDC {self.name} is reaching out to nearby entity {nearby_entity.name} for {unfulfilled} units of {self.fg_name}")
                    yield self.env.timeout(transit_time)
                    fulfilled, not_fulfilled = nearby_entity.fulfill_order(unfulfilled)
                    self.inventory_level += fulfilled
            yield self.env.timeout(1)

    def fulfill_order(self, quantity):
        print(f"LDC {self.name} - Received order for {quantity} units")
        if self.inventory_level >= quantity + self.safety_stock:
            fulfilled = quantity
        else:
            fulfilled = self.inventory_level - self.safety_stock
            if fulfilled < 0:
                fulfilled = 0
        self.inventory_level -= fulfilled
        self.total_fulfilled_orders += fulfilled
        self.total_unfulfilled_orders += (quantity - fulfilled)
        self.fulfilled_orders.append((self.fg_name, fulfilled, quantity - fulfilled))
        self.monthly_data.append((self.env.now, fulfilled, quantity - fulfilled))
        self.log(self.env.now, self.fg_name, 'Finished good', 'Fulfill Order', quantity, fulfilled, self.inventory_level)
        print(f"LDC {self.name} - Fulfilled: {fulfilled}, Unfulfilled: {quantity - fulfilled}, Inventory left: {self.inventory_level}")
        return fulfilled, quantity - fulfilled

    def place_order(self, quantity):
        yield self.env.process(self.global_distribution_center.receive_order_from_ldc(self, quantity))
        yield self.env.timeout(1)

    def receive_goods(self, quantity):
        self.inventory_level += quantity
        self.log(self.env.now, self.fg_name, 'Finished good', 'Receive Goods', quantity, quantity, self.inventory_level)
        print(f"LDC {self.name} - Goods received: {quantity}")

    def log(self, time, product_name, product_type, action, quantity, fulfilled, inventory_level):
        log_entry = {
            'Time': time,
            'Entity': self.name,
            'Product name': product_name,
            'product type': product_type,
            'Action': action,
            'Quantity': quantity,
            'Fulfilled': fulfilled,
            'Inventory_Level': inventory_level
        }
        self.ledger.append(log_entry)
        transcript.append(log_entry)

remaining code is in comments