def draw_infection_curves_and_histograms(simOutputs_ANNUAL, simOutputs_SEMI):
""" draws the infection curves and the histograms of time until HIV deaths
:param simOutputs_mono: output of a cohort simulated under mono therapy
:param simOutputs_combo: output of a cohort simulated under combination therapy
"""
# histograms of infection times
set_of_infection_times = [
simOutputs_ANNUAL.get_infection_durations(),
simOutputs_SEMI.get_infection_durations()
]
# graph histograms
Figs.graph_histograms(data_sets=set_of_infection_times,
title='Histogram of Infection Duration',
x_label='Infection Duration (Year)',
y_label='Counts',
bin_width=1,
legend=['Annual Treatment', 'Semi-Annual Treatment'],
transparency=0.6)
#get infection curves of both treatments
infection_curves = [
simOutputs_ANNUAL.get_infection_curve(),
simOutputs_SEMI.get_infection_curve()
]
# graph infection curve
PathCls.graph_sample_paths(sample_paths=infection_curves,
title='infection curve',
x_label='Simulation time step (year)',
y_label='Number of infected patients',
legends=['ANNUAL', '6-month'])
def draw_survival_curves_and_histograms(simOutputs_warfarin,
simOutputs_Dabigitran150):
""" draws the survival curves and the histograms of time until stoke deaths
:param simOutputs_warfarin: output of a cohort simulated under warfarin therapy
:param simOutputs_Dabigitran150: output of a cohort simulated under dab150 therapy
"""
# get survival curves of both treatments
survival_curves = [
simOutputs_warfarin.get_survival_curve(),
simOutputs_Dabigitran150.get_survival_curve()
]
# graph survival curve
PathCls.graph_sample_paths(sample_paths=survival_curves,
title='Survival curve',
x_label='Simulation time step (year)',
y_label='Number of alive patients',
legends=['Warfarin', 'Dabigitran150 Therapy'])
# histograms of survival times
set_of_survival_times = [
simOutputs_warfarin.get_survival_times(),
simOutputs_Dabigitran150.get_survival_times()
]
# graph histograms
Figs.graph_histograms(data_sets=set_of_survival_times,
title='Histogram of patient survival time',
x_label='Survival time (year)',
y_label='Counts',
bin_width=1,
legend=['Warfarin Therapy', 'Dabigitran150 Therapy'],
transparency=0.6)
def draw_survival_curves_and_histograms(simOutputs_mono, simOutputs_combo):
""" draws the survival curves and the histograms of time until HIV deaths
:param simOutputs_mono: output of a cohort simulated under mono therapy
:param simOutputs_combo: output of a cohort simulated under combination therapy
"""
# get survival curves of both treatments
survival_curves = [
simOutputs_mono.get_survival_curve(),
simOutputs_combo.get_survival_curve()
]
# graph survival curve
PathCls.graph_sample_paths(sample_paths=survival_curves,
title='Exposure of antibiotics',
x_label='Simulation time step (day)',
y_label='Number of patients using antibiotics',
legends=['Standard treatment', 'PCT-guided'])
# histograms of survival times
set_of_survival_times = [
simOutputs_mono.get_survival_times(),
simOutputs_combo.get_survival_times()
]
# graph histograms
Figs.graph_histograms(data_sets=set_of_survival_times,
title='Histogram of exposure time to antibiotics',
x_label='Exposure time to antibiotics (day)',
y_label='Counts',
bin_width=1,
legend=['Standard care', 'PCT-guided'],
transparency=0.5)
def draw_survival_curves_and_histograms(simOutputs_mono, simOutputs_combo):
""" draws the survival curves and the histograms of time until HIV deaths
:param simOutputs_mono: output of a cohort simulated under mono therapy
:param simOutputs_combo: output of a cohort simulated under combination therapy
"""
# get survival curves of both treatments
survival_curves = [
simOutputs_mono.get_survival_curve(),
simOutputs_combo.get_survival_curve()
]
# graph survival curve
PathCls.graph_sample_paths(sample_paths=survival_curves,
title='Survival curve',
x_label='Simulation time step (year)',
y_label='Number of alive patients',
legends=['Mono Therapy', 'Combination Therapy'])
# histograms of survival times
set_of_survival_times = [
simOutputs_mono.get_survival_times(),
simOutputs_combo.get_survival_times()
]
# graph histograms
Figs.graph_histograms(data_sets=set_of_survival_times,
title='Histogram of patient survival time',
x_label='Survival time (year)',
y_label='Counts',
bin_width=1,
legend=['Mono Therapy', 'Combination Therapy'],
transparency=0.6)
def draw_survival_curves_and_histograms(simOutputs_standard,
simOutputs_population):
""" draws the survival curves and the histograms of time until cancer
:param simOutputs_standard: output of a cohort simulated under standard testing
:param simOutputs_population: output of a cohort simulated under population testing
"""
# get survival curves of both treatments
survival_curves = [
simOutputs_standard.get_survival_curve(),
simOutputs_population.get_survival_curve()
]
# graph survival curve
PathCls.graph_sample_paths(
sample_paths=survival_curves,
title='Survival curve',
x_label='Simulation time step (year)',
y_label='Number of alive patients',
legends=['Standard Testing', 'Population Testing'])
# histograms of survival times
set_of_survival_times = [
simOutputs_standard.get_survival_times(),
simOutputs_population.get_survival_times()
]
# graph histograms
Figs.graph_histograms(data_sets=set_of_survival_times,
title='Histogram of patient survival time',
x_label='Survival time (year)',
y_label='Counts',
bin_width=1,
legend=['Mono Therapy', 'Combination Therapy'],
transparency=0.6)
def draw_survival_curves_and_histograms(sim_output_no_drug,
sim_output_with_drug):
""" draws the survival curves and the histograms of survival time
:param sim_output_no_drug: output of a cohort simulated when drug is not available
:param sim_output_with_drug: output of a cohort simulated when drug is available
"""
# get survival curves of both treatments
survival_curves = [
sim_output_no_drug.get_survival_curve(),
sim_output_with_drug.get_survival_curve()
]
# graph survival curve
PathCls.graph_sample_paths(sample_paths=survival_curves,
title='Survival curve',
x_label='Simulation time step',
y_label='Number of alive patients',
legends=['No Drug', 'With Drug'])
# histograms of survival times
set_of_survival_times = [
sim_output_no_drug.get_survival_times(),
sim_output_with_drug.get_survival_times()
]
# graph histograms
Figs.graph_histograms(data_sets=set_of_survival_times,
title='Histogram of patient survival time',
x_label='Survival time',
y_label='Counts',
bin_width=1,
legend=['No Drug', 'With Drug'],
transparency=0.6)
def draw_survival_curves_and_histograms(simOutputs_none, simOutputs_anticoag):
""" draws the survival curves and the histograms of time until HIV deaths
:param simOutputs_none: output of a cohort simulated under the natural history of disease
:param simOutputs_anticoag: output of a cohort simulated under angicoagulation therapy recepit
"""
# get survival curves of both treatments
survival_curves = [
simOutputs_none.get_survival_curve(),
simOutputs_anticoag.get_survival_curve()
]
# graph survival curve
PathCls.graph_sample_paths(
sample_paths=survival_curves,
title='Survival curve',
x_label='Simulation time step (year)',
y_label='Number of alive patients',
legends=['No Therapy', 'Anticoagulation Therapy'])
# histograms of survival times
set_of_survival_times = [
simOutputs_none.get_survival_times(),
simOutputs_anticoag.get_survival_times()
]
# graph histograms
Figs.graph_histograms(data_sets=set_of_survival_times,
title='Histogram of patient survival time',
x_label='Survival time (year)',
y_label='Counts',
bin_width=1,
legend=['No Therapy', 'Anticoagulation Therapy'],
transparency=0.6)
# histograms of the number of strokes
set_of_stroke_counts = [
simOutputs_none.get_if_developed_stroke(),
simOutputs_anticoag.get_if_developed_stroke()
]
# graph histograms
Figs.graph_histograms(data_sets=set_of_stroke_counts,
title='Histogram of patient stroke counts',
x_label='Number of strokes',
y_label='Counts',
bin_width=1,
legend=['No Therapy', 'Anticoagulation Therapy'],
transparency=0.6)
def __init__(self, simulated_cohort):
self._survivalTimes = []
self._numberStrokes_cohort = []
# survival curve
self._survivalCurve = \
Path.SamplePathBatchUpdate('Population size over time', id, simulated_cohort.get_initial_pop_size())
# find patients' survival times
for patient in simulated_cohort.get_patients():
# get the patient survival time
survival_time = patient.get_survival_time()
if not (survival_time is None):
self._survivalTimes.append(survival_time)
self._survivalCurve.record(survival_time, -1)
# summary statistic
self._sumStat_survivalTime = Stat.SummaryStat('Patient survival time',
self._survivalTimes)
# find patients' number of strokes
for patient in simulated_cohort.get_patients():
self._numberStrokes_cohort.append(
patient.get_number_strokes_individual())
# summary statistic of strokes
self._sumStat_numberStrokes = Stat.SummaryStat(
'Patient number of strokes', self._numberStrokes_cohort)
def __init__(self, simulated_cohort):
""" extracts outputs from a simulated cohort
:param simulated_cohort: a cohort after being simulated
"""
self._survivalTimes = [] # patients' survival times
self._timeToSTROKE = [] # patients' stroke times
#we dont need costs or utilities here.
# survival curve
self._survivalCurve = \
PathCls.SamplePathBatchUpdate('Population size over time', id, simulated_cohort.get_initial_pop_size())
# find patients' survival times
for patient in simulated_cohort.get_patients():
# get the patient survival time
survival_time = patient.get_survival_time()
if not (survival_time is None):
self._survivalTimes.append(
survival_time) # store the survival time of this patient
self._survivalCurve.record(survival_time,
-1) # update the survival curve
# get the patient's time to AIDS
time_To_STROKE = patient.get_these_stroke_times()
if not (time_To_STROKE is None):
self._time_To_STROKE.append(stroke_times)
# summary statistics
self._sumStat_survivalTime = StatCls.SummaryStat(
'Patient survival time is... ', self._survivalTimes)
self._sumState_timeToSTROKE = StatCls.SummaryStat(
'Time until STROKE is...', self._timeToSTROKE)
def __init__(self, simulated_cohort):
""" extracts outputs from a simulated cohort
:param simulated_cohort: a cohort after being simulated
"""
self._eclampsiaTimes = [] # patients' eclampsia times
self._utilities = []
self._costs = []
# eclampsia curve
self._eclampsiaCurve = \
PathCls.SamplePathBatchUpdate('Population size over time', id, simulated_cohort.get_initial_pop_size())
# find patients' ec times
for patient in simulated_cohort.get_patients():
# get the patient EC time
eclampsia_time = patient.get_eclampsia_time()
if not (eclampsia_time is None):
self._eclampsiaTimes.append(
eclampsia_time) # store the EC time of this patient
self._eclampsiaCurve.record(eclampsia_time,
-1) # update the EC curve
self._costs.append(patient.get_total_discounted_cost())
self._utilities.append(patient.get_total_discounted_utility())
# summary statistics
self._sumStat_ECTime = StatCls.SummaryStat('Patient Eclampsia time',
self._eclampsiaTimes)
self._sumStat_cost = StatCls.SummaryStat('Patient discounted cost',
self._costs)
self._sumStat_utility = StatCls.SummaryStat(
'Patient discounted utility', self._utilities)
def __init__(self, simulated_cohort):
""" extracts outputs from a simulated cohort
:param simulated_cohort: a cohort after being simulated
"""
self._survivalTimes = [] # patients' survival times
self._strokes = []
# survival curve
self._survivalCurve = \
PathCls.SamplePathBatchUpdate('Population size over time', id, simulated_cohort.get_initial_pop_size())
# find patients' survival times
for patient in simulated_cohort.get_patients():
a = patient.get_numberofstroke()
self._strokes.append(a)
# get the patient survival time
survival_time = patient.get_survival_time()
if not (survival_time is None):
self._survivalTimes.append(
survival_time) # store the survival time of this patient
self._survivalCurve.record(survival_time,
-1) # update the survival curve
# summary statistics
self._sumStat_survivalTime = StatCls.SummaryStat(
'Patient survival time', self._survivalTimes)
def __init__(self, simulated_cohort):
""" extracts outputs from a simulated cohort
:param simulated_cohort: a cohort after being simulated
"""
self._survivalTimes = [] # patients' survival times
self._times_to_Stroke = [] # patients' times to have had a stroke
# survival curve
self._survivalCurve = \
PathCls.SamplePathBatchUpdate('Population size over time', id, simulated_cohort.get_initial_pop_size())
# find patients' survival times
for patient in simulated_cohort.get_patients():
# get the patient survival time
survival_time = patient.get_survival_time()
if not (survival_time is None):
self._survivalTimes.append(
survival_time) # store the survival time of this patient
self._survivalCurve.record(survival_time,
-1) # update the survival curve
# get the patient's time to post stroke
time_to_stroke = patient.get_time_to_Stroke()
if not (time_to_stroke is None):
self._times_to_Stroke.append(time_to_stroke)
# summary statistics
self._sumStat_survivalTime = StatCls.SummaryStat(
'Patient survival time', self._survivalTimes)
self._sumState_timeToStroke = StatCls.SummaryStat(
'Time until AIDS', self._times_to_Stroke)
def __init__(self, simulated_cohort):
""" extracts outputs from a simulated cohort
:param simulated_cohort: a cohort after being simulated
"""
self._survivalTimes = [] # patients' survival times
self._times_to_Stroke = [] # patients' times to stroke
self._count_strokes = []
self._utilities = []
self._costs = []
# survival curve
self._survivalCurve = \
PathCls.SamplePathBatchUpdate('Population size over time', id, simulated_cohort.get_initial_pop_size())
# find patients' survival times
for patient in simulated_cohort.get_patients():
# get the patient survival time
survival_time = patient.get_survival_time()
if not (survival_time is None):
self._survivalTimes.append(survival_time) # store the survival time of this patient
self._survivalCurve.record(survival_time, -1) # update the survival curve
count_strokes = patient.get_number_of_strokes()
self._count_strokes.append(count_strokes)
self._costs.append(patient.get_total_discounted_cost())
self._utilities.append(patient.get_total_discounted_utility())
# summary statistics
self._sumStat_survivalTime = StatCls.SummaryStat('Patient survival time', self._survivalTimes)
self._sumState_number_strokes = StatCls.SummaryStat('Time until stroke', self._count_strokes)
self._sumStat_cost = StatCls.SummaryStat('Patient discounted cost', self._costs)
self._sumStat_utility = StatCls.SummaryStat('Patient discounted utility', self._utilities)
def get_survival_curve(self):
""" returns the sample path for the number of living patients over time """
# find the initial population size
n_pop = 2000
# sample path (number of alive patients over time)
n_living_patients = PathCls.SamplePathBatchUpdate('# of living patients', 0, n_pop)
# record the times of deaths
for obs in self._simulatedCohort.get_survival_time():
n_living_patients.record(time=obs, increment=-1)
return n_living_patients
def draw_survival_curves_and_histograms(simOutputs_no_therapy, simOutputs_anticoagulation):
"""
:param simOutputs_no_therapy: no therapy
:param simOutputs_anticoagulation: anticoagulation
:return:
"""
# get survival curves of both treatments
survival_curves = [
simOutputs_no_therapy.get_survival_curve(),
simOutputs_anticoagulation.get_survival_curve()
]
# graph survival curve
PathCls.graph_sample_paths(
sample_paths=survival_curves,
title='Survival curve',
x_label='Simulation time step (year)',
y_label='Number of alive patients',
legends=['No Therapy', 'Anticoagulation Therapy']
)
# histograms of survival times
set_of_survival_times = [
simOutputs_no_therapy.get_survival_times(),
simOutputs_anticoagulation.get_survival_times()
]
# graph histograms
Figs.graph_histograms(
data_sets=set_of_survival_times,
title='Histogram of patient survival time',
x_label='Survival time (year)',
y_label='Counts',
bin_width=1,
legend=['No Therapy', 'Anticoagualtion Therapy'],
transparency=0.6
)
def draw_survival_curves_and_histograms(simOutputs_anti, simOutputs_none):
""" draws the survival curves and the histograms of time until STROKE deaths
:param simOutputs_anti: output of a cohort simulated under ANTI therapy
:param simOutputs_none: output of a cohort simulated under NONE therapy
"""
# get survival curves of both treatments
survival_curves = [
simOutputs_anti.get_survival_curve(),
simOutputs_none.get_survival_curve()
]
# graph survival curve
PathCls.graph_sample_paths(
sample_paths=survival_curves,
title='Survival curve',
x_label='Simulation time step (year)',
y_label='Number of alive patients',
legends=['Anticoagulant Therapy', 'None Therapy']
)
# histograms of survival times
set_of_survival_times = [
simOutputs_anti.get_survival_times(),
simOutputs_none.get_survival_times()
]
# graph histograms
Figs.graph_histograms(
data_sets=set_of_survival_times,
title='Histogram of patient survival time',
x_label='Survival time (year)',
y_label='Counts',
bin_width=1,
legend=['Anticoagulant Therapy', 'None Therapy'],
transparency=0.6
)
def draw_survival_curves_and_histograms(simOutputs_warfarin,
simOutputs_dabigatran_110,
simOutputs_dabigatran_150):
# draws the survival curves and the histograms of time until death
# get survival curves of all treatments
survival_curves = [
simOutputs_warfarin.get_survival_curve(),
simOutputs_dabigatran_110.get_survival_curve(),
simOutputs_dabigatran_150.get_survival_curve()
]
# graph survival curve
PathCls.graph_sample_paths(
sample_paths=survival_curves,
title='Survival curve',
x_label='Simulation time step (year)',
y_label='Number of alive patients',
legends=['Warfarin', 'Dabigatran 110', 'Dabigatran 150'])
# histograms of survival times
set_of_survival_times = [
simOutputs_warfarin.get_survival_times(),
simOutputs_dabigatran_110.get_survival_times(),
simOutputs_dabigatran_150.get_survival_times()
]
# graph histograms
Figs.graph_histograms(
data_sets=set_of_survival_times,
title='Histogram of patient survival time',
x_label='Survival time (year)',
y_label='Counts',
bin_width=0.5,
legend=['Warfarin', 'Dabigatran 110', 'Dabigatran 150'],
transparency=0.6)
def get_survival_curve(self):
""" returns the sample path for the number of living patients over time """
# find the initial population size
n_pop = self._simulatedCohort.get_initial_pop_size()
# sample path (number of alive patients over time)
n_living_patients = PathCls.SamplePathBatchUpdate('# of living patients', 5, n_pop)
# record the times of deaths
for obs in self._simulatedCohort.get_survival_times():
n_living_patients.record(time=obs, increment=-1)
return n_living_patients
after5 = n_living_patients / n_pop
print('Percentage of living patients after 5 years:', after5 )
def __init__(self, simulated_cohort):
self._survivalTimes = []
self._survivalCurve = PathClasses.SamplePathBatchUpdate(
'Population over time', id,
simulated_cohort.get_initial_pop_size())
for patient in simulated_cohort.get_patients():
survival_time = patient.get_survival_time()
if not (survival_time is None):
self._survivalTimes.append(survival_time)
self._survivalCurve.record(survival_time, -1)
self._sumStat_survivalTime = StatClasses.SummaryStat(
'Patient Survival Time', self._survivalTimes)
def __init__(self, simulated_cohort):
""" extracts outputs from a simulated cohort
:param simulated_cohort: a cohort after being simulated
"""
self._survivalTimes = [] # patients' survival times
self._times_to_CANCER = [] # patients' times to CANCER
self._costs = [] # patients' discounted total costs
self._utilities = [] # patients' discounted total utilities
# survival curve
self._survivalCurve = \
PathCls.SamplePathBatchUpdate('Population size over time', id, simulated_cohort.get_initial_pop_size())
# find patients' survival times
for patient in simulated_cohort.get_patients():
# get the patient survival time
survival_time = patient.get_survival_time()
if not (survival_time is None):
self._survivalTimes.append(
survival_time) # store the survival time of this patient
self._survivalCurve.record(survival_time,
-1) # update the survival curve
# get the patient's time to CANCER
time_to_CANCER = patient.get_time_to_CANCER()
if not (time_to_CANCER is None):
self._times_to_CANCER.append(time_to_CANCER)
# cost and utility
self._costs.append(patient.get_total_discounted_cost())
self._utilities.append(patient.get_total_discounted_utility())
# summary statistics
self._sumStat_survivalTime = StatCls.SummaryStat(
'Patient survival time', self._survivalTimes)
self._sumState_timeToCANCER = StatCls.SummaryStat(
'Time until Cancer', self._times_to_CANCER)
self._sumStat_cost = StatCls.SummaryStat('Patient discounted cost',
self._costs)
self._sumStat_utility = StatCls.SummaryStat(
'Patient discounted utility', self._utilities)
def __init__(self, simulated_cohort):
""" extracts outputs from a simulated cohort
:param simulated_cohort: a cohort after being simulated
"""
self._survivalTimes = [] # patients' survival times
self._times_to_POST_STROKE = [] # patients' times to POST_STROKE
self._strokeCount = []
# survival curve
self._survivalCurve = \
PathCls.SamplePathBatchUpdate('Population size over time', id, simulated_cohort.get_initial_pop_size())
# find patients' survival times
for patient in simulated_cohort.get_patients():
# get the patient survival time
survival_time = patient.get_survival_time()
if not (survival_time is None):
self._survivalTimes.append(
survival_time) # store the survival time of this patient
self._survivalCurve.record(survival_time,
-1) # update the survival curve
stroke_count = patient.get_stroke_count()
if not (stroke_count is None):
self._strokeCount.append(stroke_count)
# get the patient's time to POST_STROKE
time_to_POST_STROKE = patient.get_time_to_POST_STROKE()
if not (time_to_POST_STROKE is None):
self._times_to_POST_STROKE.append(time_to_POST_STROKE)
# summary statistics
self._sumStat_survivalTime = StatCls.SummaryStat(
'Patient survival time', self._survivalTimes)
self._sumState_timeToPOST_STROKE = StatCls.SummaryStat(
'Time until POST_STROKE', self._times_to_POST_STROKE)
self._sumStat_stroke = StatCls.SummaryStat('Number of strokes',
self._strokeCount)
def __init__(self, simulated_cohort):
""" extracts outputs from a simulated cohort
:param simulated_cohort: a cohort after being simulated
"""
self._infectionTimes = [] # patients' infection times
self._count_infections = []
self._utilities = []
self._costs = []
self._count_treated = []
#infection curve
self._infectionCurve = \
PathCls.SamplePathBatchUpdate('Population size over time', id, simulated_cohort.get_initial_pop_size())
# find patients' infection times
for patient in simulated_cohort.get_patients():
# get the patient infection time
infection_time = patient.get_infection_duration()
if not (infection_time is None):
self._infectionTimes.append(infection_time) # store the infection time of this patient
self._infectionCurve.record(infection_time, -1) # update the infection curve
count_infections = patient.get_number_of_infections()
count_treated = patient.get_number_of_infections()
self._count_infections.append(count_infections)
self._infectionTimes.append(infection_time)
self._costs.append(patient.get_total_discounted_cost())
self._utilities.append(patient.get_total_discounted_utility())
self._count_treated.append(count_treated)
# summary statistics
self._sumStat_infectionTime = StatCls.SummaryStat('Patient infection time', self._infectionTimes)
self._sumStat_number_infections = StatCls.SummaryStat('Time until infection', self._count_infections)
self._sumStat_cost = StatCls.SummaryStat('Patient discounted cost', self._costs)
self._sumStat_utility = StatCls.SummaryStat('Patient discounted utility', self._utilities)
self._sumStat_treated= StatCls.SummaryStat('Number of Infections Treated', self._count_treated)
def __init__(self, simulated_cohort):
""" extracts outputs from a simulated cohort
:param simulated_cohort: a cohort after being simulated
"""
self._survivalTimes = [] # patients' survival times
self._times_to_AIDS = [] # patients' times to AIDS
self._stroke_total_number = []
# survival curve
self._survivalCurve = \
PathCls.SamplePathBatchUpdate('Population size over time', id, simulated_cohort.get_initial_pop_size())
# find patients' survival times
for patient in simulated_cohort.get_patients():
self._stroke_total_number.append(
patient._stateMonitor.get_stroke_number())
# get the patient survival time
survival_time = patient.get_survival_time()
if not (survival_time is None):
self._survivalTimes.append(
survival_time) # store the survival time of this patient
self._survivalCurve.record(survival_time,
-1) # update the survival curve
# get the patient's time to AIDS
time_to_AIDS = patient.get_time_to_AIDS()
if not (time_to_AIDS is None):
self._times_to_AIDS.append(time_to_AIDS)
# summary statistics
self._sumStat_survivalTime = StatCls.SummaryStat(
'Patient survival time', self._survivalTimes)
self._sumState_timeToAIDS = StatCls.SummaryStat(
'Time until AIDS', self._times_to_AIDS)
self._sumStat_strokenumber = StatCls.SummaryStat(
"number of stroke", self.get_stroke_total())
[0, 0, 0, 0, 0, 0, 0] #OTHERDEATH
]
# Run
# create cohorts
standard = Cohort(id=1, therapy=Therapies.STANDARD)
population = Cohort(id=1, therapy=Therapies.POPULATION)
# simulate the cohorts
standardOutputs = standard.simulate()
populationOutputs = population.simulate()
# graph survival curve
PathCls.graph_sample_path(sample_path=standardOutputs.get_survival_curve(),
title='Survival curve for standard testing',
x_label='Simulation time step',
y_label='Number of alive patients')
# graph histogram of survival times
Figs.graph_histogram(data=standardOutputs.get_survival_times(),
title='Survival times of patients for standard testing',
x_label='Survival time (years)',
y_label='Counts',
bin_width=1)
# graph survival curve
PathCls.graph_sample_path(sample_path=populationOutputs.get_survival_curve(),
title='Survival curve for population testing',
x_label='Simulation time step',
y_label='Number of alive patients')
# graph histogram of survival times
import Q4_ParameterClasses as P
import Q4_MarkovModelClasses as MarkovCls
import Q4_SupportMarkovModel as SupportMarkov
import scr.SamplePathClasses as PathCls
import scr.FigureSupport as Figs
# create a cohort
cohort = MarkovCls.Cohort(id=1, therapy=P.Therapies.MONO)
# simulate the cohort
simOutputs = cohort.simulate()
# graph survival curve
PathCls.graph_sample_path(sample_path=simOutputs.get_survival_curve(),
title='Survival curve',
x_label='Simulation time step',
y_label='Number of alive patients')
# graph histogram of survival times
Figs.graph_histogram(
data=simOutputs.get_survival_times(),
title='Survival times of patients with atrial fibrillation',
x_label='Survival time (years)',
y_label='Counts',
bin_width=1)
# graph histogram of number of stroke
Figs.graph_histogram(
data=simOutputs.get_survival_times(),
title='Survival times of patients with atrial fibrillation',
x_label='Survival time (years)',
print(meansurvival, CI_of_Expected)
print(meansurvival_TWO, CI_of_Expected_TWO)
cohortOUT_ONE = CohortOutcomes(cohort_ONE)
cohortOUT_TWO = CohortOutcomes(cohort_TWO)
survival_curves = [
cohortOUT_ONE.get_survival_curve(),
cohortOUT_TWO.get_survival_curve()
]
PathCls.graph_sample_paths(sample_paths=survival_curves,
title='Survival curve',
x_label='Simulation time step',
y_label='Number of alive patients',
legends=['No Drug', 'With Drug'])
set_of_STROKE_times = [
cohort_ONE.get_STROKE_time(),
cohort_TWO.get_STROKE_time()
]
Figs.graph_histograms(data_sets=set_of_STROKE_times,
title='Histogram of patient STROKE time',
x_label='Survival time',
y_label='Counts',
bin_width=1,
legend=['No Drug', 'With Drug'],
transparency=0.6)
import MarkovModelClasses as MarkovCls
import ParameterClasses as ParameterCls
import SupportMarkovModel as SupportModel
import scr.SamplePathClasses as PathCls
import scr.FigureSupport as Figs
# create the cohorts
cohort_anticoagulant = MarkovCls.Cohort(
id=0, therapy=ParameterCls.Therapies.ANTICOAGULANT)
cohort_no_therapy = MarkovCls.Cohort(id=0,
therapy=ParameterCls.Therapies.NO_THERAPY)
# simulate the cohorts
simOutputs_anticoagulant = cohort_anticoagulant.simulate()
simOutputs_no_therapy = cohort_no_therapy.simulate()
# graph the survival curve for anticoagulant
PathCls.graph_sample_path(
sample_path=simOutputs_anticoagulant.get_survival_curve(),
title='Survival Curve for Treatment (anticoag)',
x_label='Time',
y_label='Number of people still alive')
# graph the survival curve for no therapy
PathCls.graph_sample_path(
sample_path=simOutputs_no_therapy.get_survival_curve(),
title='Survival Curve for Those Without Treatment',
x_label='Time',
y_label='Number of people still alive')
import MarkovModel as MarkovCls
import SupportMarkovModel as SupportMarkov
import scr.SamplePathClasses as PathCls
import scr.FigureSupport as Figs
# create and simulate cohort for warfarin
warfarin_cohort = MarkovCls.Cohort(
id=1,
therapy=P.Therapies.WARFARIN)
warfarin_simOutputs = warfarin_cohort.simulate()
# graph survival curve
PathCls.graph_sample_path(
sample_path=warfarin_simOutputs.get_survival_curve(),
title='Survival curve, Warfarin',
x_label='Simulation time step',
y_label='Number of alive patients'
)
# graph histogram of survival times
Figs.graph_histogram(
data=warfarin_simOutputs.get_survival_times(),
title='Survival times of patients with Stroke, Warfarin',
x_label='Survival time (years)',
y_label='Counts',
bin_width=0.5
)
# graph histogram of number of strokes
Figs.graph_histogram(
data=warfarin_simOutputs.get_if_developed_stroke(),
import MarkovcClasses as MarkovClasses
import Parameters as Parameters
import SupportMarkovModel as Support
import scr.SamplePathClasses as PathClasses
# no drug
cohort1 = MarkovClasses.Cohort(id=1, therapy=Parameters.Therapies.no_drug)
simOutputs1 = cohort1.simulate()
Support.print_outcomes(simOutputs1, "No drug")
# drug treatment
cohort2 = MarkovClasses.Cohort(id=1, therapy=Parameters.Therapies.tx_drug)
simOutputs2 = cohort2.simulate()
Support.print_outcomes(simOutputs2, "Drug Treatment")
# survival curves
PathClasses.graph_sample_path(sample_path=simOutputs1.get_survival_curve(),
title='Survival curve (no drug)',
x_label='Simulation time step',
y_label='Number of alive individuals')
PathClasses.graph_sample_path(sample_path=simOutputs2.get_survival_curve(),
title='Survival curve (drug treatment)',
x_label='Simulation time step',
y_label='Number of alive individuals')
import SupportMarkovModel as SupportMarkov
import scr.SamplePathClasses as PathCls
import scr.FigureSupport as Figs
# create a cohort
cohort_NONE = MarkovCls.Cohort(id=0, therapy=P.Therapies.NONE)
cohort_ANTICOAG = MarkovCls.Cohort(id=0, therapy=P.Therapies.ANTICOAG)
# simulate the cohort
simOutputs_NONE = cohort_NONE.simulate()
simOutputs_ANTICOAG = cohort_ANTICOAG.simulate()
# graph survival curve
PathCls.graph_sample_path(sample_path=simOutputs_NONE.get_survival_curve(),
title='Survival curve',
x_label='Simulation time step (no therapy)',
y_label='Number of alive patients')
PathCls.graph_sample_path(
sample_path=simOutputs_ANTICOAG.get_survival_curve(),
title='Survival curve',
x_label='Simulation time step (anticoagulation therapy)',
y_label='Number of alive patients')
# graph histogram of survival times
Figs.graph_histogram(
data=simOutputs_NONE.get_survival_times(),
title='Survival times of patients with Stroke (no therapy)',
x_label='Survival time (years)',
y_label='Counts',
bin_width=1)
