creating the app.py file that runs the entire program

This file contains the source code for the program. This is the file that runs on huggingface.

app.py

@@ -0,0 +1,939 @@
+# -*- coding: utf-8 -*-
+"""
+Created on 26 January 2025 14:57 (HSC DPhil students Room, Oxford)
+
+@author: varad
+"""
+#all libraries that I will be using in the simulation
+
+import numpy as np
+import simpy 
+import gradio as gr
+import pandas as pd
+import random
+import csv
+import matplotlib
+import plotly.graph_objects as go
+import matplotlib.pyplot as plt
+import simpy.resources
+import os
+import plotly.subplots as sp
+
+#Non Modifiable variables
+class parameters (object):
+    '''
+    This class contains all the constant non-modifiable parameters that will go into the model
+    These mostly include service times and the time for which the simulation is supposed to run and halt etc
+    '''
+
+    experiment_no = 0 #incremented every time the main function is called
+    number_of_runs = 3 #Total number of times the simulation will run for 1 experiment
+
+    pt_per_day = 10 #Number of patients that visit the Gynae OPD every day (derived from AIIMS Bhopal Annual Report)(This could also be capped for a day if there are limited spots)
+    pt_interarrival_time = 50 #Number of minutes in a working day / number of total patients expected during the day
+    #modifiable factors, will be defined again in the relevant class
+    #resources 
+    #Staff
+    #Since these are modifiable parameters, they are not implemented but only defined here, they are implemented to be inputted from the gradio app
+    gynae_resident = None #Gynaecological residents that perform history and examination and pap smear collection in the routine OPDs in AIIMS Bhopal
+    gynae_consulant = None #Gynaecological consultants that perform procedures such as LEEP (LEETZ) or hysterectomy etc
+    pathologists = None #No of pathologists that interpret the pathology findings
+    cytotechnicians = None #No of cytotechnicians that process the sample generated
+
+
+    #Stuff
+    num_pap_kits = 50 #number of kits that the hospital has to perform a pap smear (ayre's spatula, glass slide, preservative and box)
+    num_pathology_consumables = 50 #consumables required for processing the pathological specimen
+    num_colposcopy_consumables = 50 #consumables required for conducting colposcopy
+    num_thermal_consumables = 50 #consumables required for LEEP
+    num_ot_consumables = 50 #consumables required for hysterectomy
+
+
+    #rooms (scheduled resource)
+    num_colposcopy_rooms = 3 #number of colposcopy rooms
+    num_ot_rooms = 3 #number of OT rooms
+
+    #service times
+    history_exam_time = 25 #time taken to complete history and examination per patient (Imp thing to remember here would be that this might change as the system adapts
+                            #to an excess load)
+    path_processing_time = 30 #time it takes from the sample is generated to the sample is prepared by cytotechnicians and ready for interpretation
+    path_reporting_time = 30 # time taken by pathologists to report the results of a processed sample
+    colposcopy_time = 25 #time taken to perform 1 colposcopy
+    thermal_time = 25 #time taken for 1 Loop Electrosurgical Excision procedure
+    hysterectomy_time = 50 #time taken for 1 hysterectomy
+
+    #Epidemiological parameters
+    screen_positivity_rate = 0.02 #% of positive samples (True positive + false positive / total samples)
+    biopsy_rate = 0.4 # % of all colposcopies that undergo a biopsy
+    biopsy_cin_rate = 0.6 # % of biopsies that are CIN
+    biopsy_cacx_rate = 0.02 # % of biopsies that are CaCx
+    follow_up_rate = 0.65 # % of women who follow up after a positive screen result (My own meta analysis + local data)
+
+    run_time = 100000 #Time for which the entire simulation will run (in minutes)
+class scheduled_resource(simpy.Resource):
+    '''
+    Extends the simpy.Resource object to include a resource that is only available during certain time of day and day of week
+    '''
+    def __init__(self, env, schedule, capacity):
+        super().__init__(env, capacity)
+        self.schedule = schedule # and integer list [0-6] for days of the week
+        self.env = env
+
+    def is_availeble (self):
+        '''
+        checks time of day and day of week and returns a boolean based on whether the resource is available at that time or not
+        '''
+        current_time = self.env.now
+        week_minutes = 24 * 7 * 60 #minutes in a week
+        day_minutes = 24 * 60 # minutes in a day
+
+        current_day = int((current_time % week_minutes)/day_minutes) #first checks the number of minutes left in th  week then checks number of day of the week
+        return current_day in self.schedule # returns a boolean whether the int current day is in schedule
+
+    def request (self, *args, **kwargs):
+        if self.is_availeble == False:
+            self.env.process(self.wait_for_availability(*args, **kwargs))
+        return super().request(*args, **kwargs)
+    
+    def wait_for_availability(self, *args, **kwargs):
+        '''
+        Creates a waiting process that waits for the resource to be available and then executes the request function
+        '''
+        while not self.is_availeble():
+            #sees how much time is left for new day
+            current_minutes = self.env.now
+            day_minutes = 24 * 60
+            minutes_till_next_day = day_minutes - (current_minutes/day_minutes)
+            #wait for that much time
+            yield self.env.timeout(minutes_till_next_day)
+        #when it's the right time, execute the request
+        request = super().request(*args, **kwargs)
+
+        yield request
+        return request
+
+
+class ca_cx_patient (object):
+    '''
+    This class creates patients and declares their individual parameters that explains how they spent their time at the hospital
+    These individual parameters will then be combined with others in the simulation to get overall estimates
+    '''
+    def __init__(self, pt_id):
+        '''
+        defines a patient and declares patient level variables to be recorded and written in a dataframe
+        '''
+        self.id = pt_id
+        
+        #declaring the variables to be recorded
+        #putting them as zero to try an 
+        self.time_at_entered = 0 #time when the patient entered into the OPD room
+        self.time_at_screen_result = 0 #time when the patient first received the screening result
+        self.time_at_colposcopy = 0 #time when the patient attended the colposcopy clinic
+        self.time_at_treatment = 0 #time when patient got the treatment, either admission or surgery or LEEP or thermal/cryo
+        self.time_at_exit = 0 #time when patient exits the system
+        #need these values to calculate resource utilisation percentage
+        self.history_examination_service_time = 0
+        self.colposcopy_service_time = 0
+        self.treatment_service_time = 0
+        self.screen_sample_processing_time = 0
+        self.screen_sample_reporting_time = 0
+        self.biopsy_sample_processing_time = 0
+        self.biopsy_sample_reporting_time = 0
+
+
+        #need these values to calculate queue lengths 
+        self.colposcopy_q_length =0
+        self.treatment_q_length = 0
+        self.screen_processing_q_length = 0
+        self.screen_reporting_q_length = 0
+        
+        self.biopsy_processing_q_length = 0
+        self.biopsy_reporting_q_length = 0
+
+
+class Ca_Cx_pathway (object):
+    '''
+    This is the fake hospital. Defines all the processes that the patients will go through. Will record statistics for 1 simulation that will be later analyzed and clubbed with 
+    results from 100 simulations
+    '''
+    def __init__(self, run_number, num_gynae_residents, num_gynae_consultants, num_pathologists, num_cytotechnicians, num_colposcopy_room = 3, num_ot_rooms = 2):
+        self.env = simpy.Environment()
+
+        #declaring number of modifiable resource capacity, non modifiable resources to be imported from the parameters class
+        self.num_gynae_residents = num_gynae_residents
+        self.num_gynae_consultants = num_gynae_consultants
+        self.num_pathologists = num_pathologists
+        self.num_cytotechnicians = num_cytotechnicians
+        self.num_colposcopy_rooms = num_colposcopy_room
+        self.num_ot_rooms = num_ot_rooms
+        self.run_number = run_number
+
+        self.colposcopy_schedule = [0,2,4] #list of integers form 0-6 for each day of the week that resource is available
+        self.ot_schedule = [0,2,4]  #list of integers from 0-6 for each day of the week that resource is available
+        
+        self.pt_counter = 0 #acts as the UHID of the 0th patient
+        self.run_number = self.run_number + 1
+        #declaring resources
+        #staff
+        self.gynae_residents = simpy.Resource(self.env, capacity=num_gynae_residents)
+        self.gynae_consultants = simpy.Resource(self.env, capacity=num_gynae_consultants)
+        self.pathologist = simpy.Resource(self.env, capacity=num_pathologists)
+        self.cytotechnician = simpy.Resource(self.env, capacity=num_cytotechnicians)
+
+        #stuff
+        self.pap_kit = simpy.Resource(self.env, capacity=parameters.num_pap_kits)
+        self.pathology_consumables = simpy.Resource(self.env, capacity=parameters.num_pathology_consumables)
+        self.colposcopy_consumables = simpy.Resource(self.env, capacity=parameters.num_colposcopy_consumables)
+        self.thermal_consumables = simpy.Resource(self.env, capacity=parameters.num_thermal_consumables)
+        self.ot_consumables = simpy.Resource(self.env, capacity=parameters.num_ot_consumables)
+
+        #rooms (scheduled resource)
+        self.colposcopy_room = scheduled_resource(self.env, self.colposcopy_schedule, capacity=parameters.num_colposcopy_rooms, )
+        self.ot_room = scheduled_resource(self.env, self.ot_schedule, capacity = parameters.num_ot_rooms)
+        
+        #declaring a patient level dataframe to record patient KPIs - This is recorded at the individual level
+        self.individual_results = pd.DataFrame({
+            "UHID" : [],
+            "Time_Entered_in System":[],
+            "Screen_Processing_Q_Length" : [],
+            "Screen_reporting_Q_Length" : [],
+            "Time_at_screening_result":[],
+            "Colposcopy_Q_Length" :[],
+            "Time_at_colposcopy" : [],
+            "Biopsy_Processing_Q_Length" : [],
+            "Biopsy_Reporting_Q_Length" : [],
+            "Treatment_Q_length" :[],
+            "Time_at_treatment" : [],
+            "History_and_Examination_time": [], #also recording service times as they will ultimately be added up to calculate resource utilisation percentage
+            "Screen_processing_time":[],
+            "Screen_reporting_time":[],
+            "Biopsy_processing_time":[],
+            "Biopsy_reporting_time":[],
+            "Colposcopy_time":[],
+            "Treatment_time":[],
+            "Exit_time":[]
+        })
+
+        #Declaring individual results processing variables
+        #time intervals between important points
+        self.time_to_screen_result = 0 #during analysis, need to only consider those patients who actually did undergo these procedures
+        self.time_to_colposcopy = 0    #as not all patients will undergo all the processes. might include some drop na function, but shouldn't be too much of a problem
+        self.time_to_treatment = 0
+        self.total_time_in_system = 0
+        
+
+        
+        #declaring system KPIs to be measured at the run level.
+        #Queue lengths for different processes
+        self.max_q_len_screen_processing = 0
+        self.max_q_len_screen_reporting = 0
+        self.max_q_len_colposcopy = 0
+        self.max_q_len_biopsy_processing = 0
+        self.max_q_len_biopsy_reporting = 0
+        self.max_q_len_treatment = 0
+
+        #Resource utilization percentages
+        self.gynae_residents_utilisation = 0 #by adding service times of all the processes where these resources are required. 
+        self.gynae_consultants_utlisation = 0
+        self.cytotechnician_utilisation = 0
+        self.pathologist_utilisation = 0
+
+        
+
+    def is_within_working_hours(self):
+        '''
+        checks whether the current simulation time is within working hours and returns a boolean
+        '''
+        current_sim_mins = self.env.now
+        day_mins = 24*60
+        current_sim_hour = int((current_sim_mins%day_mins)/60)
+        return 8 < current_sim_hour < 17
+
+
+    
+    def gen_patient_arrival(self):
+        '''
+        Generates a fictional patient according to a distribution, they undergo and OPD, this generates a sample which undergoes processing, after results are
+        conveyed, if positive, patient only then moves on to the next step i.e. colposcopy.
+        '''
+        while True:
+        #check time of day, 
+            #if self.is_within_working_hours:
+        #if time of day is appropriate then generate the patient
+                
+            self.pt_counter += 1
+            screening_patient = ca_cx_patient(self.pt_counter)
+                
+                
+                #print("Patient generates", self.patient.pt_id)
+                #here we will need to generate all the samples for the patient, even if they don't get created later on
+                #reason for that is it's okay if the reading is 0 or NaN, the code just won't work if there is no object to begin with
+
+        #record necessary timepoints
+            screening_patient.time_at_entered = self.env.now
+        #patient moves to the OPD
+            self.env.process(self.history_examination(screening_patient))
+        #time for next patient arrival
+            wait_time_for_next_pt = random.expovariate(1/parameters.pt_interarrival_time)
+            yield self.env.timeout(wait_time_for_next_pt)
+
+    def history_examination(self, patient):
+        '''
+        Patient undergoes history and examination and in the process also generates the screening sample
+        '''
+        #request for a resident and consumables for sample collection and wait for them to be available
+        with self.gynae_residents.request() as gynae_res, self.pap_kit.request() as pap, self.pathology_consumables.request() as path_consum :
+            yield gynae_res and pap and path_consum
+        
+        #patient undergoes history, examination and sample collection
+            history_examination_time = random.triangular(parameters.history_exam_time/2, parameters.history_exam_time, parameters.history_exam_time *2 )
+            patient.history_examination_service_time = history_examination_time
+            yield self.env.timeout(history_examination_time)
+
+            #New implementation different than the previous one
+            #The sample goes to processing and reporting function which generates a boolean which decides whether the patient moves on or not
+            screening_sample_gen = self.env.process(self.screening(patient))
+            
+            screen_result = yield screening_sample_gen
+            
+            
+            if screen_result:
+                self.env.process(self.call_for_follow_up(patient))
+            else:
+                #patient exits the system
+                patient.time_at_exit = self.env.now
+                self.add_to_individual_results(( patient))
+            
+            #generate a screening sample
+            #self.pt_screening_sample = screen_sample(self.patient.pt_id) #screen sample id is the same as the patient id
+            #print("Screen Sample generated", self.pt_screening_sample.screen_sample_id)
+            #here we will need to generate all the samples for the patient, even if they don't get created later on
+            #reason for that is it's okay if the reading is 0 or NaN, the code just won't work if there is no object to begin with
+            #self.pt_biopsy_sample = biopsy_sample(self.patient.pt_id) #generate a biopsy sample that will go for processing  
+            #print("biopsy sample generated", self.pt_biopsy_sample.biopsy_sample_id)
+        
+            #sample goes on for processing
+            #self.env.process(self.screen_sample_processing())
+
+    def screening (self, patient):
+        '''
+        This function simulation the processing and reporting of screen samples and returns a boolean whether the result is positive or negative
+        '''
+        patient.screen_processing_q_length = len(self.cytotechnician.queue)
+        
+        with self.cytotechnician.request() as cytotec, self.pathology_consumables.request() as scr_proc_consum:
+            yield cytotec and scr_proc_consum
+
+            screen_sample_processing_time = random.triangular(parameters.path_processing_time/2, parameters.path_processing_time, parameters.path_processing_time *2)
+            patient.screen_sample_processing_time = screen_sample_processing_time
+            yield self.env.timeout(screen_sample_processing_time)
+            
+            
+            patient.screen_reporting_q_length = len(self.pathologist.queue)
+            with self.pathologist.request() as path:
+                yield path
+                screen_sample_reporting_time = random.triangular(parameters.path_reporting_time/2, parameters.path_reporting_time, parameters.path_reporting_time * 2)
+                patient.screen_sample_reporting_time = screen_sample_reporting_time #record this for resource utilisation %
+                yield self.env.timeout(screen_sample_reporting_time)
+                
+                patient.time_at_screen_result = self.env.now
+
+                if random.random() < parameters.screen_positivity_rate:
+                    return True #if sample is positive
+                else: 
+                    return False # if sample is negative
+
+    def screen_sample_processing(self):
+        '''
+        Sample undergoes processing
+        '''
+        #queue length for processing
+        self.pt_screening_sample.screen_processing_q_length = len(self.cytotechnician.queue)
+        #request resources and wait for them to be available
+        with self.cytotechnician.request() as cytotec, self.pathology_consumables.request() as scr_proc_consum:
+            yield cytotec and scr_proc_consum
+        
+        #sample undergoes processing
+            screen_sample_processing_time = random.triangular(parameters.path_processing_time/2, parameters.path_processing_time, parameters.path_processing_time *2)
+            self.pt_screening_sample.screen_sample_processing_time = screen_sample_processing_time
+            yield self.env.timeout(screen_sample_processing_time)
+        #sample goes for reporting
+            self.env.process(self.screen_sample_reporting())
+
+    def screen_sample_reporting(self):
+        '''
+        Processed sample is interpreted and reported by pathologist
+        '''
+        #measure queue length for every patient that comes (max of this column will be the max queue length)
+        self.pt_screening_sample.screen_reporting_q_length = len(self.pathologist.queue)
+        #request for a pathologist and wait until 
+        with self.pathologist.request() as path:
+            yield path
+
+        #record the current time as an important milestone
+            self.patient.time_at_screen_result = self.env.now
+        
+        #sample undergoes reporting
+            screen_sample_reporting_time = random.triangular(parameters.path_reporting_time/2, parameters.path_reporting_time, parameters.path_reporting_time * 2)
+            self.pt_screening_sample.screen_sample_reporting_time = screen_sample_reporting_time #record this for resource utilisation %
+            yield self.env.timeout(screen_sample_reporting_time)
+
+        #if sample is positive, move on to follow up, otherwise terminate
+            if random.random() < parameters.screen_positivity_rate:
+                self.env.process(self.call_for_follow_up())
+            else:
+                #patient exits the system
+                self.patient.time_at_exit = self.env.now
+                #add data to the df
+                Ca_Cx_pathway.add_to_individual_results(self)
+
+    def call_for_follow_up (self, patient):
+        '''
+        Gynaecology residents 
+        '''
+        #no waiting time for this as it is quite instant.
+        #request a gynae_res (later on could modify to include a receptionist or another health cadre)
+        with self.gynae_residents.request() as gynae_res:
+            yield gynae_res
+        
+        # whether the patient returns or not
+            if random.random() < parameters.follow_up_rate:
+            #patient goes on for colposcopy
+                self.env.process(self.colposcopy(patient))
+        #instantaneous process so no timeout really and also not a service
+            else:
+                #patient exits the system
+                patient.time_at_exit = self.env.now
+                #add to df
+                self.add_to_individual_results(patient)
+            
+    def colposcopy(self, patient):
+        '''
+        Patient that was generated undergoes colposcopy
+        '''
+        #here, the entity requests two different resources, it's waiting time or queue length will be decided by whatever is less available. 
+        # 1 small caveat here is that service times for different resources are different, so a larger queue doesn't necessarily mean a longer waiting time
+        # we're not measuring waiting time but only time between events as that is a much more relevant indicator for implementation decisions.
+        colpo_q_len_list = [len(self.gynae_consultants.queue), len(self.colposcopy_room.queue) ]
+        patient.colposcopy_q_length = max(colpo_q_len_list)
+        
+        #requests for a consultant, consumables and a room
+        with self.gynae_consultants.request() as gynae_consul, self.colposcopy_consumables.request() as gynae_consumables, self.colposcopy_room.request() as colpo_room:
+            yield gynae_consul and gynae_consumables and colpo_room
+
+        #Record time at colposcopy
+            patient.time_at_colposcopy = self.env.now
+
+        #patient undergoes colposcopy
+            colposcopy_service_time = random.triangular(parameters.colposcopy_time/2, parameters.colposcopy_time, parameters.colposcopy_time *2)
+            patient.colposcopy_service_time = colposcopy_service_time
+            yield self.env.timeout(colposcopy_service_time)
+
+            
+
+            biopsy_sample_gen = self.env.process(self.biopsy(patient))
+
+            biopsy_result = yield biopsy_sample_gen
+
+            if biopsy_result == 1:
+                self.env.process(self.thermal_ablation(patient))
+            elif biopsy_result == 2:
+                self.env.process(self.hysterectomy(patient))
+            else:
+                patient.time_at_exit = self.env.now
+                self.add_to_individual_results((patient))
+
+    def biopsy(self, patient):
+        '''
+        implementation is very similar to the screening function
+        '''
+        patient.biopsy_processing_q_length = len(self.cytotechnician.queue)
+        with self.cytotechnician.request() as cytotec, self.pathology_consumables.request() as path_consum:
+            yield cytotec and path_consum
+
+            biopsy_sample_processing_time = random.triangular(parameters.path_processing_time/2, parameters.path_processing_time, parameters.path_processing_time * 2)    
+            patient.biopsy_sample_processing_time = biopsy_sample_processing_time
+            yield self.env.timeout(biopsy_sample_processing_time)
+
+            patient.biopsy_reporting_q_length = len(self.pathologist.queue)
+            with self.pathologist.request() as path:
+                yield path
+
+                biopsy_sample_reporting_time = random.triangular(parameters.path_reporting_time/2, parameters.path_reporting_time, parameters.path_reporting_time *2)
+                patient.biopsy_sample_reporting_time = biopsy_sample_reporting_time
+                yield self.env.timeout(biopsy_sample_reporting_time)
+
+                if random.random() < parameters.biopsy_cin_rate:
+                    return 1
+                elif parameters.biopsy_cin_rate < random.random() < parameters.biopsy_cacx_rate:
+                    return 2
+                else:
+                    return 3
+                    
+    def biopsy_sample_processing(self):
+        '''
+        Biopsy sample if prepared undergoes processing
+        '''
+        #queue length for processing
+        self.pt_biopsy_sample.biopsy_processing_q_length = len(self.cytotechnician.queue)
+        #requests a cytotechnicians and consumables
+        with self.cytotechnician.request() as cytotec, self.pathology_consumables.request() as path_consum:
+            yield cytotec and path_consum
+
+            #biopsy sample undergoes processing
+            biopsy_sample_processing_time = random.triangular(parameters.path_processing_time/2, parameters.path_processing_time, parameters.path_processing_time * 2)    
+            self.pt_biopsy_sample.biopsy_sample_processing_time = biopsy_sample_processing_time
+            yield self.env.timeout(biopsy_sample_processing_time)
+
+            #biopsy sample goes for reporting
+            self.env.process(self.biopsy_sample_reporting())
+
+    def biopsy_sample_reporting(self):
+        '''
+        Biopsy sample if taken undergoes reporting after processing
+        '''
+        #queue length for reporting
+        self.pt_biopsy_sample.biopsy_reporting_q_length = len(self.pathologist.queue)
+        #requests a pathologist
+        with self.pathologist.request() as path:
+            yield path
+
+            #biopsy sample undergoes reporting
+            biopsy_sample_reporting_time = random.triangular(parameters.path_reporting_time/2, parameters.path_reporting_time, parameters.path_reporting_time *2)
+            self.pt_biopsy_sample.biopsy_sample_reporting_time = biopsy_sample_reporting_time
+            yield self.env.timeout(biopsy_sample_reporting_time)
+
+            #depending on the diagnosis, patient either goes for thermal ablation or hysterectomy (currently, only making 2 options available, have the option of adding more on later)
+            biopsy_result = random.random()
+            if biopsy_result < parameters.biopsy_cin_rate:
+                self.env.process(self.thermal_ablation()) #diagnosed with CIN
+            
+            elif parameters.biopsy_cin_rate < biopsy_result < parameters.biopsy_cacx_rate:
+                self.env.process(self.hysterectomy()) #diagnosed with cervical cancer
+            
+            else:
+                self.patient.time_at_exit = self.env.now #patient exits the system
+                #add data to the df
+                Ca_Cx_pathway.add_to_individual_results(self)
+
+    def thermal_ablation(self, patient):
+        '''
+        If indicated, pt undergoes thermal ablation
+        '''
+        thermal_q_len_list = [len(self.gynae_consultants.queue), len(self.colposcopy_room.queue) ]
+        patient.treatment_q_length = max(thermal_q_len_list)
+        
+        #requests resources required for thermal ablation
+        with self.gynae_consultants.request() as gynae_consul, self.thermal_consumables.request() as thermal_consum, self.colposcopy_room.request() as colpo_room:
+            yield gynae_consul and thermal_consum and colpo_room
+
+            patient.time_at_treatment = self.env.now
+        #patient undergoes thermal ablation
+            thermal_ablation_time = random.triangular(parameters.thermal_time/2, parameters.thermal_time, parameters.thermal_time *2)
+            patient.treatment_service_time = thermal_ablation_time
+            yield self.env.timeout(thermal_ablation_time)
+
+        #patient exits the system
+            
+            patient.time_at_exit = self.env.now
+            #add to df
+            self.add_to_individual_results(patient)
+
+    def leep (self):
+        '''
+        if indicated, patient undergoes LEEP
+        '''
+        #Not being implemented in this first version of the model
+        pass 
+    def hysterectomy (self, patient):
+        '''
+        if indicated, patient undergoes hysterectomy
+        '''
+        hyst_q_len_list = [len(self.gynae_consultants.queue), len(self.ot_room.queue)]
+        patient.treatment_q_length = max(hyst_q_len_list)
+        
+        #request for a ot room and other equipment
+        with self.gynae_consultants.request() as gynae_consul, self.ot_consumables.request() as ot_consum, self.ot_room as ot_room:
+            yield gynae_consul and ot_consum and ot_room
+
+            self.patient.time_at_treatment = self.env.now    
+            #patient undergoes surgery
+            hysterectomy_time = random.triangular(parameters.hysterectomy_time/2, parameters.hysterectomy_time, parameters.hysterectomy_time *2)
+            self.patient.treatment_service_time = hysterectomy_time
+            yield self.env.timeout(hysterectomy_time)
+
+            #patient exits the system
+            
+            patient.time_at_exit = self.env.now
+            #adding everything to the dataframe
+            self.add_to_individual_results(patient)
+
+    
+    def add_to_individual_results (self, patient):
+        '''
+        To add a row to a df, we need to pass an argument that adds in all 10-12 columns together even if we want to add just one cell
+        Hence to make my job easier, writing a function that does this in every function without having to write too much.
+        '''
+        df_to_add = pd.DataFrame({
+            "UHID" : [patient.id],
+            "Time_Entered_in System":[patient.time_at_entered],
+            "Screen_Processing_Q_Length" : [patient.screen_processing_q_length],
+            "Screen_reporting_Q_Length" : [patient.screen_reporting_q_length],
+            "Time_at_screening_result":[patient.time_at_screen_result],
+            "Colposcopy_Q_Length":[patient.colposcopy_q_length],
+            "Time_at_colposcopy" : [patient.time_at_colposcopy],
+            "Biopsy_Processing_Q_Length" : [patient.biopsy_processing_q_length],
+            "Biopsy_Reporting_Q_Length" : [patient.biopsy_reporting_q_length],
+            "Treatment_Q_length":[patient.treatment_q_length],
+            "Time_at_treatment" : [patient.time_at_treatment],
+            "History_and_Examination_time": [patient.history_examination_service_time], #also recording service times as they will ultimately be added up to calculate resource utilisation percentage
+            "Screen_processing_time":[patient.screen_sample_processing_time],
+            "Screen_reporting_time":[patient.screen_sample_reporting_time],
+            "Biopsy_processing_time":[patient.biopsy_sample_processing_time],
+            "Biopsy_reporting_time":[patient.biopsy_sample_reporting_time],
+            "Colposcopy_time":[patient.colposcopy_service_time],
+            "Treatment_time":[patient.treatment_service_time],
+            "Exit_time":[patient.time_at_exit]
+            
+        })
+        df_to_add.set_index('UHID', inplace= True)
+        self.individual_results = pd.concat([self.individual_results, df_to_add]) #throws syntax error that I should not use the _ sign, we'll see
+    
+
+    def individual_results_processor(self):
+        '''
+        Processes the individual results dataframe by adding columns from which KPI's can be calculated
+        '''
+        #Calculating time between important events
+        self.individual_results['Time_to_screen_results'] = self.individual_results['Time_at_screening_result'] - self.individual_results['Time_Entered_in System']
+        self.individual_results['Time_to_Colposcopy'] = self.individual_results['Time_at_colposcopy'] - self.individual_results['Time_Entered_in System']
+        self.individual_results['Time_to_Treatment'] = self.individual_results['Time_at_treatment'] - self.individual_results['Time_Entered_in System']
+        self.individual_results['Total_time_in_system'] = self.individual_results['Exit_time'] - self.individual_results['Time_Entered_in System']
+        
+        #Calculating service times for different resources
+        
+        self.individual_results['Gynae_res_busy_time'] = self.individual_results['History_and_Examination_time']
+        self.individual_results['Cytotech_busy_time'] = self.individual_results['Screen_processing_time'] + self.individual_results['Biopsy_processing_time']
+        self.individual_results['Pathologist_busy_time'] = self.individual_results['Screen_reporting_time'] + self.individual_results['Biopsy_reporting_time']
+        self.individual_results['Gynae_consul_busy_time'] = self.individual_results['Colposcopy_time'] + self.individual_results['Treatment_time']
+
+    
+            
+    def KPI_calculator(self):
+        '''
+        Function that calculates the various KPIs from an individual run from the different columns of the individual results dataframe
+        These are KPIs for a signle run
+        '''
+        #max q lengths
+        self.max_q_len_screen_processing = self.individual_results['Screen_Processing_Q_Length'].max()
+        self.max_q_len_screen_reporting = self.individual_results['Screen_reporting_Q_Length'].max()
+        self.max_q_len_colposcopy = self.individual_results['Colposcopy_Q_Length'].max()
+        self.max_q_len_biopsy_processing = self.individual_results['Biopsy_Processing_Q_Length'].max()
+        self.max_q_len_biopsy_reporting = self.individual_results['Biopsy_Reporting_Q_Length'].max()
+        self.max_q_len_treatment = self.individual_results['Treatment_Q_length'].max()
+        
+        #resource utilisation percentages
+        self.gynae_residents_utilisation = self.individual_results['Gynae_res_busy_time'].sum()/(parameters.run_time * self.num_gynae_residents)
+        self.cytotechnician_utilisation = self.individual_results['Cytotech_busy_time'].sum()/(parameters.run_time * self.num_cytotechnicians)
+        self.gynae_consultants_utlisation = self.individual_results['Gynae_consul_busy_time'].sum() / (parameters.run_time * self.num_gynae_consultants)
+        self.pathologist_utilisation = self.individual_results['Pathologist_busy_time'].sum() / (parameters.run_time * self.num_pathologists)
+
+        #median time to important events
+        #creating temp df and dropping rows with negative values for specific columns
+        temp_colpo_time_df = self.individual_results['Time_to_Colposcopy'][self.individual_results['Time_to_Colposcopy'] >0]
+        temp_treatmet_time_df = self.individual_results['Time_to_Treatment'][self.individual_results['Time_to_Treatment'] >0]
+        #now putting the median method onto that limited dataset
+        self.med_time_to_scr_res = self.individual_results['Time_to_screen_results'].median()
+        self.med_time_to_colpo = temp_colpo_time_df.median()
+        self.med_time_to_treatment = temp_treatmet_time_df.median()
+        self.med_tot_time_in_system = self.individual_results['Total_time_in_system'].median()
+
+
+    def export_row_to_csv(self):
+        '''
+        Creates a new dataframe with trial results and exports a single row to that dataframe after each run
+        '''
+        with open ('kpi_trial_results.csv', 'a')as f:
+            writer = csv.writer(f, delimiter= ',')
+            row_to_add = [
+                self.run_number,
+                self.max_q_len_screen_processing,
+                self.max_q_len_screen_reporting,
+                self.max_q_len_colposcopy,
+                self.max_q_len_biopsy_processing,
+                self.max_q_len_biopsy_reporting,
+                self.max_q_len_treatment,
+
+                self.gynae_residents_utilisation,
+                self.gynae_consultants_utlisation,
+                self.pathologist_utilisation,
+                self.cytotechnician_utilisation,
+
+                self.med_time_to_scr_res,
+                self.med_time_to_colpo,
+                self.med_time_to_treatment,
+                self.med_tot_time_in_system
+            ]
+            writer.writerow(row_to_add)
+
+    def run(self):
+        '''
+        Runs the simulation and calls the generator function.
+        '''
+        self.env.process(self.gen_patient_arrival())
+        self.env.run(until= parameters.run_time)
+        #print(self.individual_results)
+        self.individual_results_processor()
+        self.individual_results.to_csv('individual_results.csv')
+        self.KPI_calculator()
+        self.export_row_to_csv()
+
+
+class summary_statistics(object):
+    '''
+    This class will define methods that will calculate aggregate statistics from 100 simulations and append the results onto a new spreadsheet which will be used to append results
+    from 100 simulations for different number of independent variables (such as patients)
+    '''
+    def __init__(self):
+        pass
+    
+    
+          
+    def gen_final_summary_table (self):
+        '''
+        Generates a table, essentially a row of summary statistics for 100 runs with a particular initial setting.
+        '''
+        with open ('final_summary_table.csv', 'w') as f:
+            writer = csv.writer(f, delimiter= ',')
+            column_headers = [
+                "Experiment_No" ,
+                "Max_Scr_Proc_Q_len" ,
+                'Max_Scr_Rep_Q_len' ,
+                'Max_Colpo_Q_len' ,
+                "Max_Biop_Proc_Q_Len" ,
+                "Max_Biop_Rep_Q_Len" ,
+                "Max_T/t_Q_len" ,
+
+                #resource utilisation %
+                'Gynae_Res_%_util',
+                'Gynae_consul_%_util',
+                'Path_%_util',
+                'Cytotec_%_util',
+
+                #Time between important events
+                'Time_to_screening_results',
+                'Time_to_colposcopy',
+                'Time_to_treatment',
+                'Total_time_in_system' ]
+            
+            writer.writerow(column_headers)
+        
+    def calculate_summary_statistics(self):
+        '''
+        Calculates summary statistic from 100 runs (or whatever the number of runs is specified) from the kpi_trial_results table which will then later on be added
+        onto the final_summary_table csv
+        '''
+        filepath = 'kpi_trial_results.csv'
+        df_to_read = pd.read_csv(filepath)
+        self.max_scr_proc_q_len = df_to_read['Max_Scr_Proc_Q_len'].median()
+        self.max_scr_rep_q_len = df_to_read['Max_Scr_Rep_Q_len'].median()
+        self.max_colpo_q_len = df_to_read['Max_Colpo_Q_len'].median()
+        self.max_biop_proc_q_len = df_to_read['Max_Biop_Proc_Q_Len'].median()
+        self.max_biop_rep_q_len = df_to_read['Max_Biop_Rep_Q_Len'].median()
+        self.max_treatment_q_len = df_to_read['Max_T/t_Q_len'].median()
+
+        self.med_gynae_res_util = df_to_read['Gynae_Res_%_util'].median()
+        self.med_gynae_consul_util = df_to_read['Gynae_consul_%_util'].median()
+        self.med_path_util = df_to_read['Path_%_util']
+        self.med_cytotec_util = df_to_read['Cytotec_%_util']
+
+        self.med_time_to_scr = df_to_read['Time_to_screening_results'].median()
+        self.med_time_to_colpo = df_to_read['Time_to_colposcopy'].median()
+        self.med_time_to_tt = df_to_read['Time_to_treatment'].median()
+        self.med_tot_time_in_sys = df_to_read['Total_time_in_system'].median()
+
+
+
+    def populate_final_summary_table(self):
+        '''
+        Updates the final summary table one row whenever it is called. 
+        '''
+        with open ('final_summary_table.csv', 'a') as f:
+            writer = csv.writer(f, delimiter= ',')
+            row_to_add = [parameters.experiment_no,
+            self.max_scr_proc_q_len,
+            self.max_scr_rep_q_len,
+            self.max_colpo_q_len,
+            self.max_biop_proc_q_len,
+            self.max_biop_rep_q_len,
+            self.max_treatment_q_len,
+
+            self.med_gynae_res_util,
+            self.med_gynae_consul_util,
+            self.med_path_util,
+            self.med_cytotec_util,
+
+            self.med_time_to_scr,
+            self.med_time_to_colpo,
+            self.med_time_to_tt,
+            self.med_tot_time_in_sys
+
+            ]
+            writer.writerow(row_to_add)
+    
+def clear_csv_file():
+    '''f
+    Erases all the contents of a csv file. Used in the refresh button of the gradio app to start fresh
+    '''
+    
+    parameters.experiment_no = 0
+    with open ('final_summary_table.csv', 'w') as f:
+        pass
+    open_final_table = summary_statistics()
+    open_final_table.gen_final_summary_table()
+
+
+def plotly_plotter():
+    filepath = 'final_summary_table.csv'
+    df_to_plot = pd.read_csv(filepath)
+    fig = sp.make_subplots(rows = 1, cols= 3, subplot_titles= ("Max Queue Length for Different Processes", 
+        'Percent Utilisation for different Professionals','Time to important events'))
+
+    fig.add_trace(go.Scatter(x = df_to_plot['Experiment_No'], y = df_to_plot['Max_Scr_Proc_Q_len'], name = "Q len for Screen Processing"), row = 1, col = 1)
+    fig.add_trace(go.Scatter(x = df_to_plot['Experiment_No'], y = df_to_plot['Max_Scr_Rep_Q_len'], name = "Q len for Screen Reporting"),row = 1, col = 1)
+    fig.add_trace(go.Scatter(x = df_to_plot['Experiment_No'], y = df_to_plot['Max_Colpo_Q_len'], name = "Q len for Colposcopy"),row = 1, col = 1)        
+    fig.add_trace(go.Scatter(x = df_to_plot['Experiment_No'], y = df_to_plot['Max_Biop_Proc_Q_Len'], name = "Q len for Biopsy Processing"),row = 1, col = 1)
+    fig.add_trace(go.Scatter(x = df_to_plot['Experiment_No'], y = df_to_plot['Max_Biop_Rep_Q_Len'], name = "Q len for Biopsy Reporting"),row = 1, col = 1)
+    fig.add_trace(go.Scatter(x = df_to_plot['Experiment_No'], y = df_to_plot['Max_T/t_Q_len'], name = "Q len for Treatment"),row = 1, col = 1)
+        
+        
+    fig.add_trace(go.Scatter(x = df_to_plot['Experiment_No'], y = df_to_plot['Gynae_Res_%_util'], name = "% Utilisation for Gynae Residents"),row = 1, col = 2)
+    fig.add_trace(go.Scatter(x = df_to_plot['Experiment_No'], y = df_to_plot['Gynae_consul_%_util'], name = "% Utilisation for Gynae Consultants"),row = 1, col = 2)
+    fig.add_trace(go.Scatter(x = df_to_plot['Experiment_No'], y = df_to_plot['Path_%_util'], name = "% Utilisation for Pathologists"),row = 1, col = 2)
+    fig.add_trace(go.Scatter(x = df_to_plot['Experiment_No'], y = df_to_plot['Cytotec_%_util'], name = "% Utilisation for Cytotechnicians"),row = 1, col = 2)
+
+    fig.add_trace(go.Scatter(x = df_to_plot['Experiment_No'], y = df_to_plot['Time_to_screening_results'], name = "Time to screening results"),row = 1, col = 3)
+    fig.add_trace(go.Scatter(x = df_to_plot['Experiment_No'], y = df_to_plot['Time_to_colposcopy'], name = "Time to Colposcopy"),row = 1, col = 3)
+    fig.add_trace(go.Scatter(x = df_to_plot['Experiment_No'], y = df_to_plot['Time_to_treatment'], name = "Time to Treatment"),row = 1, col = 3)
+    fig.add_trace(go.Scatter(x = df_to_plot['Experiment_No'], y = df_to_plot['Total_time_in_system'], name = "Total Time in the System"),row = 1, col = 3)
+
+    return fig
+
+
+def gen_kpi_table():
+        #defining the KPI Results Table for one run, the export to row function in the cacx pathway class
+        #  will add one row at a time
+    with open('kpi_trial_results.csv', 'w') as f:
+        writer = csv.writer(f, delimiter= ',')
+        column_headers = [
+                "Run_Number" ,
+                "Max_Scr_Proc_Q_len" ,
+                'Max_Scr_Rep_Q_len' ,
+                'Max_Colpo_Q_len' ,
+                "Max_Biop_Proc_Q_Len" ,
+                "Max_Biop_Rep_Q_Len" ,
+                "Max_T/t_Q_len" ,
+
+                #resource utilisation %
+                'Gynae_Res_%_util',
+                'Gynae_consul_%_util',
+                'Path_%_util',
+                'Cytotec_%_util',
+
+                #Time between important events
+                'Time_to_screening_results',
+                'Time_to_colposcopy',
+                'Time_to_treatment',
+                'Total_time_in_system' ]
+
+        writer.writerow(column_headers)
+
+open_final_table = summary_statistics()
+open_final_table.gen_final_summary_table()
+
+def main(pt_per_day, num_gynae_res, num_gynae_consul, num_cytotec, num_path):
+    '''
+    This function will run the simulation for different independent variables that we need.
+    '''
+    parameters.experiment_no += 1
+    print (f'Experiment Number: {parameters.experiment_no}')
+    #print('For this experiment, Pt interarrival time = 480/patients per day = 480/{pt_per_day}')
+    parameters.pt_per_day = pt_per_day
+    sum_stats = summary_statistics()
+    
+    gen_kpi_table()
+    for run in range (parameters.number_of_runs):
+        print(f'Run {run+1} in {parameters.number_of_runs}')
+        my_sim_model = Ca_Cx_pathway(run, num_gynae_res, num_gynae_consul, num_cytotec, num_path)
+        my_sim_model.run()
+    sum_stats.calculate_summary_statistics()
+    sum_stats.populate_final_summary_table()
+    return plotly_plotter()
+
+
+
+with gr.Blocks() as app:
+    gr.HTML(
+                '''
+                <h1>Cervical Cancer DES App</h1>
+                '''
+            )
+    
+    with gr.Row(equal_height= True):            
+                
+        with gr.Column(scale = 1):
+            gr.HTML(
+                        '''
+                        <h2>List of Assumptions</h2>
+                        Discrete Event Simulation Models take in a lot of assumptions into consideration. Here is a list of assumptions made
+                        while building this model
+                        <ul>
+                            <li> 50 Patients for cervical cancer screening arrive every day, making pt interrarrival time 480/50, but can be modified
+                            <li> One working day is from 9 am to 5 pm so total 480 minutes in a day
+                            <li> Procedure rooms such as Colposcopy and OT rooms are only available on Monday, Wednenday and Friday (3 days a week)
+                            <li> Cytotechnicians and Pathologists process and report both Screening and Biopsy specimens
+                            <li> Screening only happens through conventional pap smear
+                            <li> Gynae residents and Gynae consultants essentially mean two different levels of health cadres, with Consultants being more 
+                            experienced than residents. Doesn't necessarily mean professionals with specialised training in Obstetrics and Gynaecology
+                            <li> In the demo app, one run is for 1000 minutes i.e. 3 days
+                            <li> Medians are calculated from 100 iterations of the simulation
+                        </ul>
+                        '''
+                    )
+        with gr.Column(scale=1):
+            gr.HTML('''
+            <h2>AIIMS Bhopal Cervical Cancer Pathway</h2>
+            ''')
+            gr.Image('AIIMS_Bhopal_baseline_process_map.png')
+
+
+    with gr.Row():
+            gr.HTML(
+                        '''
+                        <h2>Modifiable Parameters</h2>
+                        Limited to different HR and Procedure rooms for this implementation
+                        '''
+                        #num_gynae_residents, num_gynae_consultants, num_pathologists, num_cytotechnicians, num_colposcopy_room, num_ot_rooms
+                    )
+            pt_per_day = gr.Slider(minimum=  1, maximum = 100, label= 'Patients Visiting per day', value= 50, step = int)
+            num_gynae_res = gr.Slider(minimum=  1, maximum = 10, label= 'No of Gynae Residents', value= 1, step = int)
+            num_gynae_consul = gr.Slider(minimum=  1, maximum = 10, label= 'No of Gynae Consultants', value= 1, step = int)
+            num_cytotec = gr.Slider(minimum=  1, maximum = 10, label= 'No of Cytotechnicians', value= 1, step = int)
+            num_path = gr.Slider(minimum=  1, maximum = 10, label= 'No of Pathologists', value= 1, step = int)
+    
+    with gr.Row():
+        btn = gr.Button(value= "Run the Simulation")
+            
+    with gr.Row(equal_height=True):
+        output = gr.Plot(label= 'Simulation Results')
+        btn.click(main, [pt_per_day, num_gynae_res, num_gynae_consul, num_cytotec, num_path], output)
+
+    with gr.Row():
+        btn_ref = gr.Button(value = "Refresh the plots")
+        btn_ref.click (clear_csv_file)
+
+app.launch(share = True)
+
+
+
+