gsharma007 / single_use_systems_simulation_modeling_and_optimization Goto Github PK

Why simulation terminates before adding the last set of values into the event calendar??

Yield Curve Function Should return the time values and yield values for the 3 cases in the curve, which will then be utilized to finalize the processing time and Ytilda value.

Correct the code to get the right values.

utilize the added event calendar to model the rework into the system

QM Policy 2 says that,

all the tests will be done in low fidelity initially. Then the result is checked. If the test fails, the high fidelity test is conducted on such samples.

Include this logic.

1. Add washing time if the machine is used before
2. Prefer not used machines over the used ones
3. Specify Machines as Single-use and Disposable. Then prefer the single-use ones always over the disposable ones.

Setup time is generated according to the number of machines and number of customers, and hence there is no change in the system by changing the number of operators which should not be the case since it is a shared resource.

aplha_low values make a bit sense, but certainly not the alpha_up values.

Considering the curve, it seems like the values for the aplha_up should be negative considering that the slope of the curve is negative.

Also, check the sanity of alpha_low values together

Rework should start from departure times when the test happens. And it should end at the passing of the sample.

Out of three times(t_low, t_normal, and t_up) calculated from the yield curve. We choose one of the t based on the patient mix policy and the selected time works as the processing time for that patient.

In this scenario, does the machine allocation logic makes any sense?

Let's say I have 5 machines. Any of the machines are chosen based on availability but the processing time for that machine is just one value.

Figuring out the graphs and finding the code to plot those.

https://github.com/gsharma007/Clinic_Simulation/blob/156d6657e78eb05420665f1a950bdefb208831ff/Bio_Mfg_V12.py#L173

• Generate the target value of yield for the individual customers and compare the same with the achieved yield after each step and plot the same instead of plotting box plot for all the customers

Is the test result value changing for each patient?? If not, how to assign the same to each patient in order to have the right rework trigger?

At any point in the system, if the test fails, there will a new request made for a new sample and the process will start from the beginning step, but since the patient is the same, the requests have to be made under the same patient ID.

Include this logic.

It has to do with the values considered during the logic of test results. We compare the patients_target_bc and yield from manufacturing. The way logic is defined, it looks like its biased towards selecting rejection.

https://github.com/gsharma007/Clinic_Simulation/blob/156d6657e78eb05420665f1a950bdefb208831ff/Bio_Mfg_V12.py#L23

• Generate the estimated yield of the overall process as well as for the individual steps.
• Overall yield can be generated using triangular distribution using lower and upper bound in the input as +-30%
• The individual step yield can be estimated by taking the percentage of overall yield, like
  Harvesting yield = 0.85*(overall yield)
  Cryo yield = 0.95*(harvesting yield)

Add the termination condition properly in order to generate all the relevant events for each patient. Currently, since the iteration is based on the indexed service time value, it stops after service time array stops.

Check the Queue_track_length

• The event calendar ends when the queue level becomes zero. Departures equal to the len(num_machines), remains.

Do we have to define everything similarly for the harvesting procedure as well, what we defined for MFG?
Specifically, the Yield curve characteristics.

Including a clock, updating the clock after each event. Am I following the same format or is it totally different?

https://github.com/gsharma007/Clinic_Simulation/blob/156d6657e78eb05420665f1a950bdefb208831ff/Bio_Mfg_V12.py#L165

• The yield of each step as well as of the whole process is supposed to be the cell counts required for the process
• But according to the yield model, it depends on factors whose values are in different units, how will the value of yield come in form of cell counts?

Service time generation is an array, generated according to the number of machines and for each customer. According to the chosen machine and the customer, the service time is populated. Is it correct?

https://github.com/gsharma007/Clinic_Simulation/blob/156d6657e78eb05420665f1a950bdefb208831ff/Bio_Mfg_V12.py#L21

• Replication should be done 50 times for each single condition
• The impact should be calculated on the overall process, as well as on the individual steps

https://github.com/gsharma007/Clinic_Simulation/blob/678612367525af338127a158b4c4663125f77e6e/PGA1.py#L31

It makes sense to relate set-up times to the operators rather than machines. But for each machine operator might have different set-time, hence which array to be generated for the set-up time.
Although it is sure, that operator's experience matters and set-up time will depend on that.

setup_times = np.random.exponential(scale=0.5, size=(NUM_MACHINES, NUM_CUSTOMERS))
or
setup_times = np.random.exponential(scale=0.5, size=(NUM_MACHINES, ))
or
setup_times = np.random.exponential(scale=0.5, size=(NUM_CUSTOMERS, NUM_Operators, NUM_MACHINES))

The count for Num_in_Service is not happening correctly. Debug the same.

The logic works better for the initial steps of the process but does not work when proceeding into the last steps and the time results for the overall process are showing irrelevant values, check the sanity of data as well the logic behind it to track down the issue.

When rework happens, there are multiple rows of results related to the same patient. Do all the rows contribute to the results or only the last one??

What to keep and What not to??
How does that affect the queue and utilization

Check/Find ways to represent the results for Bio-MAN

Not able to test the case where the operator is busy when the arrival happens. Every time arrival happens before the setup is done.

• Although as of now, the setup for the new customer starts if some machine is free despite both the operators are free, which is good.- Mandates the case that there can not be a difference between setup and service, if the setup is done, service should happen immediately after that.

Same Steps from Manufacturing

`def yield_curve_level(Yield_Curve_MFG,patients_target_bc):

if Yield_Curve_MFG == 1:

    #defining characteristics for yield curve 1 (Stressed System)
    #Relaxed alpha low, less delta t, and high alpha up

    alpha_low_mfg = 100000 
    alpha_up_mfg = 4000

    t_low_mfg = []
    for j in range(NUM_PATIENTS):
        t_low_mfg.append(j/alpha_low_mfg)

    delta_t_mfg = 5

    t_up_mfg = []
    for k in t_low_mfg:
        t_up_mfg.append(k+delta_t_mfg)
    #print("t_up : \n", t_up)

    low_level_factor_mfg = 0.90
    up_level_factor_mfg = 1.10


    t_low_new_mfg = []
    for t1 in t_low_mfg:
        t_low_new_mfg.append(t1*low_level_factor_mfg)
    #print("t_low_new : \n", t_low_new)

    t_up_new_mfg = []
    for t2 in t_up_mfg:
        t_up_new_mfg.append(t2*up_level_factor_mfg)
    #print("t_up_new : \n", t_up_new)

    t_normal_mfg = []
    for a in range(NUM_PATIENTS):
        t_normal_mfg.append((t_up_new_mfg[a]+t_low_new_mfg[a])/2)


else:

    #defining characteristics for yield curve 2 (relaxed system)
    #Sharp alpha low, more delta t, and relaxed alpha up

    alpha_low_mfg = 50000 
    alpha_up_mfg = 20000

    t_low_mfg = []
    for j in range(NUM_PATIENTS):
        t_low_mfg.append(j/alpha_low_mfg)

    delta_t_mfg = 15

    t_up_mfg = []
    for k in t_low_mfg:
        t_up_mfg.append(k+delta_t_mfg)
    #print("t_up : \n", t_up)

    low_level_factor_mfg = 0.90
    up_level_factor_mfg = 1.10


    t_low_new_mfg = []
    for t1 in t_low_mfg:
        t_low_new_mfg.append(t1*low_level_factor_mfg)
    #print("t_low_new : \n", t_low_new)

    t_up_new_mfg = []
    for t2 in t_up_mfg:
        t_up_new_mfg.append(t2*up_level_factor_mfg)
    #print("t_up_new : \n", t_up_new)

    t_normal_mfg = []
    for a in range(NUM_PATIENTS):
        t_normal_mfg.append((t_up_new_mfg[a]+t_low_new_mfg[a])/2)

time_level_patients_mfg = np.array((t_low_new_mfg, t_normal_mfg, t_up_new_mfg), dtype=float)
time_level_patients_mfg = np.transpose(time_level_patients_mfg)

y1_mfg = alpha_low_mfg * (time_level_patients_mfg[:,0])
y2_mfg = patients_target_bc
y3_mfg = patients_target_bc - alpha_up_mfg*(time_level_patients_mfg[:,2])

yield_mfg = np.array((y1_mfg,y2_mfg,y3_mfg))
yield_mfg = np.transpose(yield_mfg)

return time_level_patients_mfg, yield_mfg`

Format the code in form of handling the arrival and departure event functions.

handle_arrival_event()
handle_departure_event()

Complete the following tasks to address the above requirement:

1. Make a new ERG representing the current system.
2. Check if the event calendar is made after the generation for tracking the events only or it is used in the logic itself to check or do the assignment.
3. The event calendar will be of the following form:
   [Entity/Patient Number, Event time, Event Type]

• The event types include Arrival, Start, Departure.

4. Changes in the current model:
   a) Generating setup time on going
   b) use offline processing time
   c) Add data structure to include an event calendar, Queue level, Server Availability
   d) Closing the simulation at the right point, i.e. values for each patient are generated
   d) Fix the logic to get correct values
   e) Test the values

Enhancement:
f) Make graphs for b(t) and Q(t)

• Rejected in which type of test
• Rejected in which policy

https://github.com/gsharma007/Clinic_Simulation/blob/678612367525af338127a158b4c4663125f77e6e/PGA1.py#L16

The used parameters generate the results in hours while because of the nature of the problem, it is good to track the time in minutes. Hence think of a way, where the generated numbers directly resemble realistic minute times.

Calculating utilization?? How??

Clarify the logic for this.

https://github.com/gsharma007/Clinic_Simulation/blob/678612367525af338127a158b4c4663125f77e6e/PGA1.py#L16

num_machines = 4
num_customers = 50

service_time = array of 4, choosing a value from those 4 only vs
service_time = array of 50, choosing specific service time generated for the individual

Generate random values from an exponential distribution between a certain range

• Generate 50 random values from an exponential distribution between 5 and 8.

Event type can be, Arrival, Service Start, Departure.

• When a person departs, and if the queue >0 then two types(Departure and Service Start), will happen at the same time, how to show this kind of event in the event calendar?

[Event time, Departure_Ci & Service_Start_Cj ]
Is this representation correct?

Pblm a: Two Fresh arrivals at the same time.
Pblm b: Two Departures at the same time.

Both of the cases are not fulfilled in some of the runs.

https://github.com/gsharma007/Clinic_Simulation/blob/156d6657e78eb05420665f1a950bdefb208831ff/Bio_Mfg_V12.py#L55

https://github.com/gsharma007/Clinic_Simulation/blob/678612367525af338127a158b4c4663125f77e6e/PGA1.py#L17

As the arrival time starts from zero, and we limit the length till the num_patients, the arrival time of the last customer is not stored in the generated 1-D array

#Factor 2- Patient Component- Two Levels
#Level 1 shows a mix of patients with 80% Average response, 10 % Good and 10% Bad response
#Level 2 shows a mix of patients with 50% Average response, 25 % Good and 25% Bad response

1. Adding Column for tracking the contamination within the sample
2. Contamination happens only when we move forward in the process
3. Like QM Policy 3, with a 30% probability, we do not take the test. Although, in this case, we are passing the sample in some scenarios where the sample does not meet expectations in most of the scenarios, by not conducting the test, we are avoiding the contamination.
4. If we conduct the test, we are inducing the contamination in the sample with some probability Yha.
5. Logic
   Generate U(0,1)
   If U <= Yha
   Sample is contaminated
   else
   The sample is not contaminated

Few of the time values are too low which are inducing outliers in the data for y_tilda values.