def update(self, k, current_state, next_state):
""" updates the discounted total cost and health utility
:param k: simulation time step
:param current_state: current health state
:param next_state: next health state
"""
# update cost
cost = self._param.get_annual_state_cost(
current_state) * self._param.get_delta_t()
# update utility
utility = 0.5 * (self._param.get_annual_state_utility(current_state) +
self._param.get_annual_state_utility(next_state)
) * self._param.get_delta_t()
if current_state == P.HealthStats.CD4_200 and next_state != P.HealthStats.CD4_200:
cost = cost + 600 + (36.73 + 49.11)
if current_state == P.HealthStats.CD4_200to500:
cost += 32.68
# add the cost of treatment
# if HIV death will occur
if next_state in [P.HealthStats.DEATH]:
cost += 0.5 * self._param.get_annual_treatment_cost(
) * self._param.get_delta_t()
else:
cost += 1 * self._param.get_annual_treatment_cost(
) * self._param.get_delta_t()
# update total discounted cost and utility (corrected for the half-cycle effect)
self._totalDiscountedCost += \
EconCls.pv(cost, self._param.get_adj_discount_rate() / 2, 2*k + 1)
self._totalDiscountedUtility += \
EconCls.pv(utility, self._param.get_adj_discount_rate() / 2, 2*k + 1)
def simulate(self, sim_length):
""" simulate the patient over the specified simulation length """
# random number generator for this patient
self._rng = rndClasses.RNG(self._id)
k = 0 # current time step
# while the patient is alive and simulation length is not yet reached
while (self.healthstat != 3
or self.healthstat != 4) and k * delta_t < sim_length:
# find the transition probabilities of the future states
trans_probs = TRANS[self.THERAPY][self.healthstat]
# create an empirical distribution
empirical_dist = rndClasses.Empirical(trans_probs)
# sample from the empirical distribution to get a new state
# (returns an integer from {0, 1, 2, ...})
new_state_index = empirical_dist.sample(self._rng)
if self.healthstat == 1:
self.STROKE += 1
#caculate cost and utality
cost = TRANS_COST[self.THERAPY][self.healthstat] * delta_t
utility = TRANS_UTILITY[self.THERAPY][self.healthstat] * delta_t
# update total discounted cost and utility (corrected for the half-cycle effect)
self.totalDiscountCost += \
EconCls.pv(cost, Discount_Rate*delta_t, k + 1)
self.totalDiscountUtility += \
EconCls.pv(utility, Discount_Rate*delta_t, k + 1)
# update health state
self.healthstat = new_state_index[0]
# increment time step
k += 1
self.survival = k * delta_t
def update(self, k, current_state, next_state):
#update costs
cost = 0.5*(self._param.get_annual_state_cost(current_state)+(self._param.get_annual_state_cost(next_state))) \
* self._param.get_delta_t()
#update utility
utility = 0.5 * (self._param.get_annual_state_utility(current_state) +
(self._param.get_annual_state_utility(next_state))
) * self._param.get_delta_t()
#add the cost of treatment
# if stroke death will occur
if next_state in [P.HealthStats.DEATH, P.HealthStats.BACKGROUND_DEATH]:
cost += 0.5 * self._param.get_annual_treatment_cost(
) * self._param.get_delta_t()
else:
cost += 1 * self._param.get_annual_treatment_cost(
) * self._param.get_delta_t()
# update total discounted cost and utility (correct for the half-cycle effect)
self._totalDiscountedCost += EconCls.pv(
cost,
self._param.get_adj_discount_rate() / 2, 2 * k + 1)
self._totalDiscountedUtility += EconCls.pv(
utility,
self._param.get_adj_discount_rate() / 2, 2 * k + 1)
def update(self, k, current_state, next_state):
# update cost
cost = 0.5 * (self._parameters.get_annual_state_cost(current_state) +
self._parameters.get_annual_state_cost(next_state)
) * self._parameters.get_delta_t()
# update utility
utility = 0.5 * (
self._parameters.get_annual_state_utility(current_state) +
self._parameters.get_annual_state_utility(next_state)
) * self._parameters.get_delta_t()
# add cost of treatment
if next_state in [Parameters.HealthStates.DEAD]:
cost += 0.5 * self._parameters.get_annual_treatment_cost(
) * self._parameters.get_delta_t()
else:
cost += 1 * self._parameters.get_annual_treatment_cost(
) * self._parameters.get_delta_t()
# update total discounted cost and utility (corrected for half-cycle effect)
self._totalDiscountedCost += \
EconCls.pv(cost, self._parameters.get_adj_discount_rate() / 2, 2*k + 1)
self._totalDiscountedUtility += \
EconCls.pv(utility, self._parameters.get_adj_discount_rate() / 2, 2*k + 1)
def update(self, k, current_state, next_state):
# update cost
cost = 0
if next_state in [P.HealthStats.STROKE]:
cost += Data.COST_STROKE
# update cost of state
else:
cost += 0.5 * (self._param.get_annual_state_costs(current_state) +
self._param.get_annual_state_costs(next_state)
) * self._param.get_delta_t()
# add cost of drug treatment
if next_state in [P.HealthStats.POST_STROKE]:
cost += self._param.get_annual_drug_cost(
) * self._param.get_delta_t()
# update utility
utility = 0.5 * (self._param.get_annual_state_utilities(current_state)
+ self._param.get_annual_state_utilities(next_state)
) * self._param.get_delta_t()
# update total discounted cost and utility
self._totalDiscountedCost += \
EconCls.pv(cost, self._param.get_adj_discount_rate() / 2, 2*k + 1)
self._totalDiscountedUtil += \
EconCls.pv(utility, self._param.get_adj_discount_rate() / 2, 2*k + 1)
def update(self, k, current_state, next_state):
""" updates the discounted total cost and health utility
# :param k: simulation time step
# :param current_state: current health state
#:param next_state: next health state
#"""
# update cost
cost = 0.5 * (self._param.get_annual_state_cost(current_state) +
self._param.get_annual_state_cost(next_state)
) * self._param.get_delta_t()
# update utility
utility = 0.5 * (self._param.get_annual_state_utility(current_state) +
self._param.get_annual_state_utility(next_state)
) * self._param.get_delta_t()
# add the cost of treatment
# if HIV death will occur
if next_state in [P.HealthStats.STROKEDEATH]:
cost += 0.5 * self._param.get_annual_treatment_cost(
) * self._param.get_delta_t()
else:
cost += 1 * self._param.get_annual_treatment_cost(
) * self._param.get_delta_t()
# update total discounted cost and utility (corrected for the half-cycle effect)
self._totalDiscountedCost += \
EconCls.pv(cost, self._param.get_adj_discount_rate() / 2, 2*k + 1)
self._totalDiscountedUtility += \
EconCls.pv(utility, self._param.get_adj_discount_rate() / 2, 2*k + 1)
def update(self, k, current_state, next_state):
"""updates the discounted total cost and health utility
:param k: simulation time step
:param current_state: current health state
:param next_state: next health state
"""
# update cost
cost = 0.5 * (self._param.get_annual_state_cost(current_state) +
self._param.get_annual_state_cost(next_state)
) * self._param.get_delta_t()
# update utility
utility = 0.5 * (self._param.get_annual_state_utility(current_state) +
self._param.get_annual_state_utility(next_state)
) * self._param.get_delta_t()
# treatment cost (incurred only in post-stroke state)
if current_state is P.HealthStats.TREATMENT:
if next_state is [P.HealthStats.DEAD]:
cost += 0.5 * self._param.get_annual_treatment_cost(
) * self._param.get_delta_t()
else:
cost += 1 * self._param.get_annual_treatment_cost(
) * self._param.get_delta_t()
# update total discounted cost and utility (NOT corrected for the half-cycle effect)
self._totalDiscountedCost += \
EconCls.pv(cost,self._param.get_adj_discount_rate(), k)
self._totalDiscountedUtility += \
EconCls.pv(utility,self._param.get_adj_discount_rate(), k)
def update(self, k, current_state, next_state):
""" updates the discounted total cost and health utility
:param k: simulation time step
:param current_state: current health state
:param next_state: next health state
"""
# update cost
cost = 0.5 * (self._param.get_annual_state_cost(current_state) +
self._param.get_annual_state_cost(next_state)) * self._param.get_delta_t()
# update utility
utility = 0.5 * (self._param.get_annual_state_utility(current_state) +
self._param.get_annual_state_utility(next_state)) * self._param.get_delta_t()
# add the cost of treatment
# if DEATH will occur
if next_state in [HealthStats.STROKEDEATH] or next_state in [HealthStats.OTHERDEATH] and current_state in [HealthStats.POSTSTROKE]:
cost += 0.5 * self._param.get_annual_treatment_cost() * self._param.get_delta_t()
elif next_state in [HealthStats.STROKE] and (current_state in [HealthStats.POSTSTROKE] or current_state in [HealthStats.WELL]):
cost += 5000
elif current_state in [HealthStats.POSTSTROKE]:
cost += 1 * self._param.get_annual_treatment_cost() * self._param.get_delta_t()
# update total discounted cost and utility (removed the half-cycle effect)
self._totalDiscountedCost += \
Econ.pv(cost, self._param.get_adj_discount_rate() / 2, k + 1)
self._totalDiscountedUtility += \
Econ.pv(utility, self._param.get_adj_discount_rate() / 2, k + 1)
def update(self, k, current_state, next_state):
cost = (self._param.get_annual_state_cost(current_state)+(self._param.get_annual_state_cost(next_state))) \
* self._param.get_delta_t()
utility = (self._param.get_annual_state_utility(current_state) +
(self._param.get_annual_state_utility(next_state))) * self._param.get_delta_t()
if next_state in [P.HealthStats.DEAD, P.HealthStats.STROKE_DEAD]:
cost += self._param.get_annual_treatment_cost() * self._param.get_delta_t()
else:
cost += 1*self._param.get_annual_treatment_cost() * self._param.get_delta_t()
self._totalDiscountedCost += EconCls.pv(payment=cost, discount_rate=self._param.get_adj_discount_rate(), discount_period=k+1)
self._totalDiscountedUtility += EconCls.pv(payment=utility, discount_rate=self._param.get_adj_discount_rate(), discount_period=k+1)
def update(self, k, current_state, next_state):
cost = 0.5*(self._param.get_annual_state_cost(current_state)+(self._param.get_annual_state_cost(next_state))) \
* self._param.get_delta_t()
utility = 0.5 * (self._param.get_annual_state_utility(current_state) +
(self._param.get_annual_state_utility(next_state))) * self._param.get_delta_t()
if next_state is P.HealthStats.DEATH:
cost += 0.5*self._param.get_annual_treatment_cost() * self._param.get_delta_t()
else:
cost += 1*self._param.get_annual_treatment_cost() * self._param.get_delta_t()
self._totalDiscountedCost += EconCls.pv(cost, self._param.get_adj_discount_rate()/2, 2*k+1)
self._totalDiscountedUtility += EconCls.pv(utility, self._param.get_adj_discount_rate()/2, 2*k+1)
def update(self, k, current_state, next_state):
cost = self._param.get_annual_state_cost(
current_state) * self._param.get_delta_t()
utility = self._param.get_annual_state_utility(
current_state) * self._param.get_delta_t()
self._totalDiscountedCost += EconCls.pv(
cost,
self._param.get_adj_discount_rate() / 2, 2 * k + 1)
self._totalDiscountedUtility += EconCls.pv(
utility,
self._param.get_adj_discount_rate() / 2, 2 * k + 1)
def update(self, k, current_state, next_state):
# state cost and utility
cost = 0.5*(self._param.get_annual_state_cost(current_state)
+(self._param.get_annual_state_cost(next_state))) * self._param.get_delta_t()
utility = 0.5 * (self._param.get_annual_state_utility(current_state) +
(self._param.get_annual_state_utility(next_state))) * self._param.get_delta_t()
# treatment cost (incurred only in post-stroke state)
#if current_state is P.HealthStats.POST_STROKE:
# if next_state is P.HealthStats.DEATH:
# cost += 0.5*self._param.get_annual_treatment_cost() * self._param.get_delta_t()
# else:
# cost += 1*self._param.get_annual_treatment_cost() * self._param.get_delta_t()
self._totalDiscountedCost += EconCls.pv(cost, self._param.get_adj_discount_rate()/2, 2*k+1)
self._totalDiscountedUtility += EconCls.pv(utility, self._param.get_adj_discount_rate()/2, 2*k+1)
def update(self, k, current_state, next_state):
# update cost
cost = 0.5 * (self._param.get_annual_state_cost(current_state) +
(self._param.get_annual_state_cost(next_state))
) * self._param.get_delta_t()
# update utility
utility = 0.5 * (self._param.get_annual_state_utility(current_state) +
(self._param.get_annual_state_utility(next_state))
) * self._param.get_delta_t()
# treatment cost (incurred only in post-stroke state)
if current_state is P.HealthStats.POST_TIA:
if next_state is P.HealthStats.DEAD_OTHER or next_state is P.HealthStats.DEAD_STROKE:
cost += 0.5 * self._param.get_annual_treatment_cost(
) * self._param.get_delta_t()
else:
cost += 1 * self._param.get_annual_treatment_cost(
) * self._param.get_delta_t()
if current_state is P.HealthStats.POST_MILD_STROKE:
if next_state is P.HealthStats.DEAD_OTHER or next_state is P.HealthStats.DEAD_STROKE:
cost += 0.5 * self._param.get_annual_treatment_cost(
) * self._param.get_delta_t()
else:
cost += 1 * self._param.get_annual_treatment_cost(
) * self._param.get_delta_t()
if current_state is P.HealthStats.POST_MODERATE_SEVERE_STROKE:
if next_state is P.HealthStats.DEAD_OTHER or next_state is P.HealthStats.DEAD_STROKE:
cost += 0.5 * self._param.get_annual_treatment_cost(
) * self._param.get_delta_t()
else:
cost += 1 * self._param.get_annual_treatment_cost(
) * self._param.get_delta_t()
# update total discounted cost and utility
self._totalDiscountedCost += EconCls.pv(
cost, self._param.get_adj_discount_rate(), k)
self._totalDiscountedUtility += EconCls.pv(
utility, self._param.get_adj_discount_rate(), k)
def update(self, k, current_state, next_state):
# update cost
cost = 0.5 * (self._parameters.get_annual_state_cost(current_state) +
self._parameters.get_annual_state_cost(next_state)
) * self._parameters.get_delta_t()
# update utility
utility = 0.5 * (
self._parameters.get_annual_state_utility(current_state) +
self._parameters.get_annual_state_utility(next_state)
) * self._parameters.get_delta_t()
# add cost of screening
cost += self._parameters.get_screening_cost()
# update total discounted cost and utility (corrected for half-cycle effect)
self._totalDiscountedCost += \
EconCls.pv(cost, self._parameters.get_adj_discount_rate() / 2, 2*k + 1)
self._totalDiscountedUtility += \
EconCls.pv(utility, self._parameters.get_adj_discount_rate() / 2, 2*k + 1)
def update(self, k, current_state, next_state):
"""updates the discounted total cost and health utility
:param k: simulation time step
:param current_state: current health state
:param next_state: next health state
"""
# update cost
cost = 0.5 * (self._param.get_annual_state_cost(current_state) +
self._param.get_annual_state_cost(next_state)
) * self._param.get_delta_t()
# update utility
utility = 0.5 * (self._param.get_annual_state_utility(current_state) +
self._param.get_annual_state_utility(next_state)
) * self._param.get_delta_t()
# add the cost of treatment
# if DEAD will occur
if current_state is P.HealthStats.WELL:
cost += 0 * self._param.get_annual_treatment_cost(
) * self._param.get_delta_t()
elif current_state is P.HealthStats.BACKGROUND_DEATH:
cost += 0 * self._param.get_annual_treatment_cost(
) * self._param.get_delta_t()
elif current_state is P.HealthStats.STROKE_DEATH:
cost += 0 * self._param.get_annual_treatment_cost(
) * self._param.get_delta_t()
elif current_state is P.HealthStats.STROKE:
cost += 0 * self._param.get_annual_treatment_cost(
) * self._param.get_delta_t()
else:
cost += 1 * self._param.get_annual_treatment_cost(
) * self._param.get_delta_t()
# update total discounted cost and utility (NOT corrected for the half-cycle effect)
self._totalDiscountedCost += \
EconCls.pv(cost,self._param.get_adj_discount_rate(), k)
self._totalDiscountedUtility += \
EconCls.pv(utility,self._param.get_adj_discount_rate(), k)
def update(self, k, current_state, next_state):
""" updates the discounted total cost and health utility
:param k: simulation time step
:param current_state: current health state
:param next_state: next health state
"""
# update cost
cost = self._param.get_annual_state_cost(
current_state) * self._param.get_delta_t()
# update utility
utility = self._param.get_annual_state_utility(
current_state) * self._param.get_delta_t()
if next_state in [P.HealthStats.WELL]:
utility += 1 * (Data.SIM_LENGTH - k)
# update total discounted cost and utility (corrected for the half-cycle effect)
self._totalDiscountedCost += \
EconCls.pv(cost, self._param.get_adj_discount_rate() / 2, 2*k + 1)
self._totalDiscountedUtility += \
EconCls.pv(utility, self._param.get_adj_discount_rate() / 2, 2*k + 1)
def update(self, k, current_state, next_state):
""" updates the discounted total cost and health utility
:param k: simulation time step
:param current_state: current health state
:param next_state: next health state
"""
# update cost
cost = 0.5 * (self._param.get_annual_state_cost(current_state) +
self._param.get_annual_state_cost(next_state)) * self._param.get_delta_t()
# update utility
utility = 0.5 * (self._param.get_annual_state_utility(current_state) +
self._param.get_annual_state_utility(next_state)) * self._param.get_delta_t()
# add the cost of treatment
# if stroke will occur
if self._currentState == P.HealthStats.STROKE:
cost += self._param.get_onetime_Stroke_cost()
# update total discounted cost and utility (corrected for the half-cycle effect)
self._totalDiscountedCost += \
EconCls.pv(cost, self._param.get_adj_discount_rate(), k)
self._totalDiscountedUtility += \
EconCls.pv(utility, self._param.get_adj_discount_rate(), k)
def update(self, k, current_state, next_state):
""" updates the discounted total cost and health utility
:param k: simulation time step
:param current_state: current health state
:param next_state: next health state
"""
# update utility
utility = 0.5 * (self._param.get_annual_state_utility(current_state) +
self._param.get_annual_state_utility(next_state)
) * self._param.get_delta_t()
# update total discounted cost and utility (corrected for the half-cycle effect)
self._totalDiscountedUtility += \
EconCls.pv(utility, self._param.get_adj_discount_rate() / 2, 2*k + 1)
def simulate_fiveshort(self, sim_length_short):
""" simulate the patient over the specified simulation length """
# random number generator for this patient
self._rng = rndClasses.RNG(self._id)
if self.vaccine == 0:
k = 0
# while the patient is alive and simulation length is not yet reached
while (self.healthstat != 8) and k * ma.delta_t < sim_length_short:
# find the transition probabilities of the future states
trans_probs = ma.prob_matrix[0][self.healthstat]
# create an empirical distribution
empirical_dist = rndClasses.Empirical(trans_probs)
# sample from the empirical distribution to get a new state
# (returns an integer from {0, 1, 2, ...})
new_state_index = empirical_dist.sample(self._rng)
# caculate cost and utality
cost = ma.cost_matrix[
self.
healthstat] + ma.salary * ma.work_loss_day[self.healthstat]
utility = ma.utility_matrix[self.healthstat] * ma.delta_t
# update total discounted cost and utility (corrected for the half-cycle effect)
self.totalDiscountCost += \
EconCls.pv(cost, ma.discount_rate * ma.delta_t, k + 1)
self.totalDiscountUtility += \
EconCls.pv(utility, ma.discount_rate * ma.delta_t, k + 1)
# update diseases:
if self.healthstat == HealthStats.Pneumoniae.value:
self.pneumonaie += 1
if self.healthstat == HealthStats.Meningitis.value:
self.meningitis += 1
if self.healthstat == HealthStats.AOM_T.value or self.healthstat == HealthStats.AOM_NT.value:
self.aom += 1
# update disability number
if self.healthstat == HealthStats.Disability.value:
self._ndisability = 1
# update deafness number
if self.healthstat == HealthStats.Deaf.value:
self._ndeaf = 1
# update health state
self.healthstat = new_state_index[0]
#update number of deahts
if self.healthstat == HealthStats.DEATH.value:
self._ndeath = 1
# increment time step
k += 1
if self.vaccine == 1:
k = 0
while (self.healthstat != 8) and k * ma.delta_t < sim_length_short:
# find the transition probabilities of the future states
trans_probsv = ma.prob_matrix_vaccine[0][self.healthstat]
# create an empirical distribution
empirical_distv = rndClasses.Empirical(trans_probsv)
# sample from the empirical distribution to get a new state
# (returns an integer from {0, 1, 2, ...})
new_state_indexv = empirical_distv.sample(self._rng)
# caculate cost and utality
cost = ma.cost_matrix[
self.
healthstat] + ma.salary * ma.work_loss_day[self.healthstat]
utility = ma.utility_matrix[self.healthstat] * ma.delta_t
# update total discounted cost and utility (corrected for the half-cycle effect)
self.totalDiscountCost += \
EconCls.pv(cost, ma.discount_rate * ma.delta_t, k + 1)
self.totalDiscountUtility += \
EconCls.pv(utility, ma.discount_rate * ma.delta_t, k + 1)
# update diseases:
if self.healthstat == HealthStats.Pneumoniae.value:
self.pneumonaie += 1
if self.healthstat == HealthStats.Meningitis.value:
self.meningitis += 1
if self.healthstat == HealthStats.AOM_T.value or self.healthstat == HealthStats.AOM_NT.value:
self.aom += 1
# update disability number
if self.healthstat == HealthStats.Disability.value:
self._ndisability = 1
# update deafness number
if self.healthstat == HealthStats.Deaf.value:
self._ndeaf = 1
# update health state
self.healthstat = new_state_indexv[0]
#update number of deahts
if self.healthstat == HealthStats.DEATH.value:
self._ndeath = 1
if k == 3:
self.shot += 1
self.totalDiscountCost+= \
EconCls.pv(ma.vaccine_administration+ma.vaccine_cost, ma.discount_rate * ma.delta_t, k + 1)
if k == 5:
self.shot += 1
self.totalDiscountCost+= \
EconCls.pv(ma.vaccine_administration+ma.vaccine_cost, ma.discount_rate * ma.delta_t, k + 1)
if k == 11:
self.shot += 1
self.totalDiscountCost+= \
EconCls.pv(ma.vaccine_administration+ma.vaccine_cost, ma.discount_rate * ma.delta_t, k + 1)
# increment time step
k += 1
if self.healthstat == 3:
for i in (6, 16):
self.totalDiscountCost += EconCls.pv(2746, ma.discount_rate,
i + 1)