def SA_testing(values): # variables to alter and their values replace_var = ['TransmissionRateOnART', 'TransmissionRateOffART', 'HIVtestBgAcceptRate'] # replace_val = {} # multiply to attia attia_new = np.multiply(parameters['attia'], 1) replace_val['TransmissionRateOnART'] = np.multiply(np.reshape(attia_new, (8, 1)), np.ones((8, 6))) replace_val['TransmissionRateOffART'] = np.multiply(np.reshape(attia_new, (8, 1)), np.ones((8, 6))) for city in ['rio', 'salvador', 'manaus']: for k in values: # change background testing rate replace_val['HIVtestBgAcceptRate'] = k # replace values in .in file float_df = deepcopy(in_file[city]) # replace the variables for var in replace_var: float_df = t_op.replace_values(var, replace_val[var], float_df) # save float_df filename = os.path.join(filepath_new, city + '_Test accept rate_' + str(k) + '.in') link.write_cepac_in_file(filename, float_df) # parallelize files c_op.parallelize_input(filepath_new) return
def SA_tx_att_hrg(values): replace_var = ['TransmissionRateOnART', 'TransmissionRateOffART', 'DynamicTransmissionPropHRGAttrib'] replace_val = {} for city in ['rio', 'salvador', 'manaus']: for k in values:# this is to vary % on ART # multiply to attia attia_on_ART = np.multiply(parameters['attia on ART'], 1) attia_off_ART = np.multiply(parameters['attia off ART'], 1) replace_val['TransmissionRateOnART'] = np.multiply(np.reshape(attia_on_ART, (8, 1)), np.ones((8, 6))) replace_val['TransmissionRateOffART'] = np.multiply(np.reshape(attia_off_ART, (8, 1)), np.ones((8, 6))) # the percentage attributable to hrg replace_val['DynamicTransmissionPropHRGAttrib'] = k # replace values in .in file float_df = deepcopy(in_file[city]) # replace the variables for var in replace_var: float_df = t_op.replace_values(var, replace_val[var], float_df) # save float_df filename = os.path.join(filepath_new, city + '_att_to_hrg_' + str(k) + '.in') link.write_cepac_in_file(filename, float_df) # parallelize files c_op.parallelize_input(filepath_new) return
def create_in_files(self, parallel = 1): # get list of var to replace, value and base in file var_list = self.var_list val_map = self.val_map in_file = deepcopy(self.base_in_file) # loop over values we have for var for var in var_list: for val in val_map[var]: # this val can either be a float or array #if not (isinstance(val, (float, int))): # raise TypeError('The value of variable for OWSA must be np.array/float/int') # return # replace variable value valtype = int if var in ['HIVtestFreqInterval'] else float in_file = t_op.replace_values(var, val, in_file, position = self.var_pos[var], valtype = valtype) # TODO: search dependencies of current variable and change those values in_file = self.dep_data_object.replace_dep_value(var, val, self.dep_data_map, in_file)#, self.var_pos[var]) # save file try: x = ('%s=%.4f.in')%(var, val) except: x = ('%s=%.4f.in')%(var, val[0]) file_name = os.path.join(self.save_path, x) link.write_cepac_in_file(file_name, in_file) return
def SA_acute(values): # loop over scale down scenarios replace_var = ['TransmissionRateOnART', 'TransmissionRateOffART']#, 'TransmissionRateOnART', 'TransmissionRateOffART'] replace_val = {} for city in ['rio', 'salvador', 'manaus']: for k in values: # multiply to attia attia_new = parameters['attia'] attia_new[len(attia_new)-1] = k replace_val['TransmissionRateOnART'] = np.multiply(np.reshape(attia_new, (8, 1)), np.ones((8, 6))) replace_val['TransmissionRateOffART'] = np.multiply(np.reshape(attia_new, (8, 1)), np.ones((8, 6))) # replace values in .in file float_df = deepcopy(in_file[city]) # replace the variables for var in replace_var: float_df = t_op.replace_values(var, replace_val[var], float_df) # save float_df filename = os.path.join(filepath_new, city + '_Acute rate_' + str(k) + '.in') link.write_cepac_in_file(filename, float_df) # parallelize files c_op.parallelize_input(filepath_new)
def SA_testing_rate(values): replace_var = ['HIVtestBgAcceptRate'] replace_val = {} for city in ['rio', 'salvador', 'manaus']: for k in values:# this is to vary % on ART # dict of values replace_val['HIVtestBgAcceptRate'] = k # replace values in .in file float_df = deepcopy(in_file[city]) # replace the variables for var in replace_var: float_df = t_op.replace_values(var, replace_val[var], float_df) # save float_df filename = os.path.join(filepath_new, city + '_testing_rate_' + str(k) + '.in') link.write_cepac_in_file(filename, float_df) # parallelize files c_op.parallelize_input(filepath_new) return
def create_in_files(self, parallel = 1): # get variable list, value map and base in_file var_list = self.var_list var0, var1 = var_list[0], var_list[1] val_map = self.val_map in_file = deepcopy(self.base_in_file) # first start loop over var1 values for var0_val in val_map[var0]: # this val can either be a float or array if not (isinstance(var0_val, float) or isinstance(var0_val, int) or isinstance(var0_val, np.array)): raise TypeError('The value of variable for TWSA must be np.array/float/int') return # replace variable value in_file = t_op.replace_values(var0, var0_val, in_file, position = self.var_pos[var0]) # TODO: find and replace dependent variables of var0 in_file = self.dep_data_object.replace_dep_value(var0, var0_val, self.dep_data_map, in_file, self.var_pos) # now start loop over var2 for var1_val in val_map[var1]: # this val can either be a float or array if not (isinstance(var0_val, float) or isinstance(var0_val, int) or isinstance(var0_val, np.array)): raise TypeError('The value of variable for TWSA must be np.array/float/int') return # replace variable value in_file = t_op.replace_values(var1, var1_val, in_file, position = self.var_pos[var1]) # TODO: find and replace dependent variables of var1 in_file = self.dep_data_object.replace_dep_value(var1, var1_val, self.dep_data_map, in_file, self.var_pos) # save in file x = ('%s=%.4f_%s=%.4f.in')%(var0, var0_val, var1, var1_val) file_name = os.path.join(self.save_path, x) link.write_cepac_in_file(file_name, in_file) # parallelize c_op.parallelize_input(self.save_path, parallel) return
def SA_treatment(values): # loop over scale down scenarios replace_var = ['DynamicTransmissionNumTransmissionsHRG', 'TransmissionRiskMultiplier_T1', 'TransmissionRiskMultiplier_T2', 'TransmissionRiskMultiplier_T3', 'TransmissionRateOnART', 'TransmissionRateOffART'] replace_val = {} for city in ['rio', 'salvador', 'manaus']: for k in values:# this is to vary % on ART # multiply to attia attia_on_ART = np.multiply(parameters['attia on ART'], 1) attia_off_ART = np.multiply(parameters['attia off ART'], 1) replace_val['TransmissionRateOnART'] = np.multiply(np.reshape(attia_on_ART, (8, 1)), np.ones((8, 6))) replace_val['TransmissionRateOffART'] = np.multiply(np.reshape(attia_off_ART, (8, 1)), np.ones((8, 6))) # calculate community viral load distibution on_art = np.multiply(k, parameters['viral load distribution on ART']) off_art = np.multiply((1-k), parameters['viral load distribution off ART']) community_vl = np.add(on_art, off_art) # calculate average transmission rate tx_avg = np.sum(np.multiply(parameters['attia off ART'], community_vl)) replace_val['DynamicTransmissionNumTransmissionsHRG'] = tx_avg # calculate transmission rate calibrated to the incidence rate tx = np.multiply(parameters[city]['incidence'], np.divide(parameters[city]['index negative'], parameters[city]['index positive'])) # calculate multiplier tx_mul = np.divide(tx, tx_avg) replace_val['TransmissionRiskMultiplier_T1'] = tx_mul[0] replace_val['TransmissionRiskMultiplier_T2'] = tx_mul[0] replace_val['TransmissionRiskMultiplier_T3'] = tx_mul[1] # replace values in .in file float_df = deepcopy(in_file[city]) # replace the variables for var in replace_var: float_df = t_op.replace_values(var, replace_val[var], float_df) # save float_df filename = os.path.join(filepath_new, city + '_On treatment_' + str(k) + '.in') link.write_cepac_in_file(filename, float_df) # parallelize files c_op.parallelize_input(filepath_new)
def SA_attia(factors): # loop over scale down scenarios replace_var = ['DynamicTransmissionNumTransmissionsHRG', 'TransmissionRiskMultiplier_T1', 'TransmissionRiskMultiplier_T2', 'TransmissionRiskMultiplier_T3', 'TransmissionRateOnART', 'TransmissionRateOffART'] replace_val = {} for city in ['rio', 'salvador', 'manaus']: for k in factors:# this us scale down factor for Attia rates # multiply to attia attia_new = np.multiply(parameters['attia'], k) replace_val['TransmissionRateOnART'] = np.multiply(np.reshape(attia_new, (8, 1)), np.ones((8, 6))) replace_val['TransmissionRateOffART'] = np.multiply(np.reshape(attia_new, (8, 1)), np.ones((8, 6))) # calculate average transmission rate tx_avg = np.sum(np.multiply(attia_new, parameters[city]['viral load distribution'])) replace_val['DynamicTransmissionNumTransmissionsHRG'] = tx_avg # calculate transmission rate calibrated to the incidence rate tx = np.multiply(parameters[city]['incidence'], np.divide(parameters[city]['index negative'], parameters[city]['index positive'])) # calculate multiplier tx_mul = np.divide(tx, tx_avg) replace_val['TransmissionRiskMultiplier_T1'] = tx_mul[0] replace_val['TransmissionRiskMultiplier_T2'] = tx_mul[0] replace_val['TransmissionRiskMultiplier_T3'] = tx_mul[1] # replace values in .in file float_df = deepcopy(in_file[city]) # replace the variables for var in replace_var: float_df = t_op.replace_values(var, replace_val[var], float_df) # save float_df filename = os.path.join(filepath_new, city + '_Attia scale down_' + str(k) + '.in') link.write_cepac_in_file(filename, float_df) # parallelize files c_op.parallelize_input(filepath_new)
def create_in_files(self): # get list of var to replace, value and base in file var_list = self.var_list val_map = self.value_map in_file = deepcopy(self.base_in_file) for var in var_list: # var should be string if not isinstance(var, str): raise TypeError('The each key of value map should be string, string of CEPAC variable name') # replace variable value in_file = t_op.replace_values(var, val_map[var], in_file, position = self.var_pos[var]) # TODO: search dependencies of current variable and change those values # in_file = find and replace dependent variables # after we are done changing values for all variables, save .in file file_name = os.path.join(self.save_path, 'NewInputFile.in') link.write_cepac_in_file(file_name, in_file) return
# read respective .in file filepath = os.path.join(readpaths[var], file) + '.in' float_in = link.read_cepac_in_file(filepath) # replace few values r_val_map = {'UseHIVIncidReduction': 1, 'HIVIncidReductionStopTime': HORIZON, 'HIVIncidReductionCoefficient': coeff} for r_var in r_val_map: # if not r_var in position: position[r_var] = t_op.search_var(r_var, float_in) # replace value float_in = t_op.replace_values(r_var, r_val_map[r_var], float_in, position[r_var]) # write the file varval = file.split('=')[1] addstr = 'OWSA_final_run_var=%s_val=%s'%(var, varval) + '.in' if not os.path.exists(finalpaths[var]): os.makedirs(finalpaths[var]) savepath = os.path.join(finalpaths[var], addstr) link.write_cepac_in_file(savepath, float_in) # parallelize c_op.parallelize_input(finalpaths[var])
def write_final_runs(value_grid, path_dict, STOP_TIME = 60): # aux function for creating final run files def get_reduction_coeff(percentage_red, stop_time): # reduction coefficient will be as follows if ((0.01*percentage_red) < 1) and (percentage_red > 0): red_coeff = -1*stop_time/(np.log(1 - (0.01*percentage_red))) elif (percentage_red <= 0) or (percentage_red <= 0.0): red_coeff = 10000 else: # this says percentage reduction is >= 100% red_coeff = -1*stop_time/np.log(10**-100) return red_coeff # check if both inputs are dictionaries if not (isinstance(value_grid, dict) or isinstance(path_dict, dict)): raise TypeError("Input needs to be in dictionary format.") return # val_to_replace = value_grid del value_grid # import out files #out_path = os.path.join(path_dict['output']['intervention'], r'results') cepac_out = {} for k in path_dict['output']: cepac_out[k] = link.import_all_cepac_out_files(os.path.join(path_dict['output'][k], r'results'), module = "regression") # set stop time and PrEP duration #SQ_DF = link.import_all_cepac_in_files(path_dict['output']['status quo'])['SQ'] #STOP_TIME = int(t_op.read_values('HIVIncidReductionStopTime', SQ_DF)) #del SQ_DF # create sets of runs ABC out = {} name_map = {} for k in cepac_out['intervention']: if k == 'popstats': continue key_name = aux.get_digit_for_file_name(k, val_to_replace) if not key_name in out.keys(): out[key_name] = {} name_map[key_name] = k if "RunB" in k: out[key_name]['B'] = cepac_out['intervention'][k] elif "RunC" in k: out[key_name]['C'] = cepac_out['intervention'][k] else: continue # TODO: following value will change according to city, need to take care of this inp = {} for k in out: out[k]['A'] = cepac_out['status quo']['SQ']#['A'] inp[k] = {'PrEPCoverage': 0, 'prep_efficacy': 0.96, 'CohortSize': 10000000, 'PrEPDuration': 0, 'HIVmthIncidMale': 0.00357692085607886, 'prep_usage_at_initialization': 'n'} row_idx = 0 percentage_decline = [] for i in val_to_replace['PrEPCoverage']: for j in val_to_replace['PrEPDuration']: if i == 0.0: j_idx = np.where(val_to_replace['PrEPDuration'] == j)[0][0] out[j_idx] = {} out[j_idx]["A"] = cepac_out["status quo"]["SQ"] out[j_idx]["B"] = cepac_out["status quo"]["SQ"] out[j_idx]["C"] = cepac_out["status quo"]["SQ"] inp[j_idx] = inp[1] inp[row_idx]['PrEPCoverage'] = i inp[row_idx]['PrEPDuration'] = STOP_TIME #60 #600 percentage_decline.append(tx_algo.get_percentage_decline(out[row_idx], inp[row_idx])) row_idx += 1 # plot results plot_heatmap(val_to_replace, percentage_decline, path_dict) # write results to excel file export_abc_out_to_excel(cepac_out, out, val_to_replace, path_dict) # create directory to write the final run files if not os.path.exists(path_dict['output']['final runs']): os.makedirs(path_dict['output']['final runs']) final_path = path_dict['output']['final runs'] # read one .in file (B, as that is intervention file) and alter following values # 1. reduction coefficient # 2. disable dynamic transmission module # import base file for B base_int = link.import_all_cepac_in_files(path_dict['input']) base_int = base_int['B'] # first we'll find the indices of all the required variables idx = {} var_list = ["UseHIVIncidReduction", "HIVIncidReductionStopTime", "HIVIncidReductionCoefficient", "UseDynamicTransmission", "PrEPCoverage", "PrEPDuration"] for k in var_list: idx[k] = base_int.loc[base_int.loc[:, 0] == k, :].index.values # replace required values for run in name_map: # deepcopy float_int = deepcopy(base_int) # following value of stop time might not be correct float_int.loc[idx["HIVIncidReductionStopTime"], 1] = STOP_TIME #480#120 coeff = get_reduction_coeff(percentage_decline[run], float_int.loc[idx["HIVIncidReductionStopTime"], 1].values[0]) if coeff <= 0: # disable incidence reduction float_int.loc[idx["UseHIVIncidReduction"], 1] = 0 #float_int.loc[idx["HIVIncidReductionCoefficient"], 1] = coeff else: # enable incidence reduction float_int.loc[idx["UseHIVIncidReduction"], 1] = 1 float_int.loc[idx["HIVIncidReductionCoefficient"], 1] = coeff # disable dynamic transmission module # TODO: we need to take care that the values for risk multiplier are correct float_int.loc[idx["UseDynamicTransmission"], 1] = 1 # replace coverage and coverage time float_int.loc[idx["PrEPCoverage"], 1:2] = 0.01*(aux.get_coverage_level_from_file_name(name_map[run])) float_int.loc[idx["PrEPDuration"], 1:2] = aux.get_coverage_time_from_file_name(name_map[run]) # write the file save_path = os.path.join(final_path, name_map[run].split('_')[1]) + '.in' link.write_cepac_in_file(save_path, float_int)
def write_abc(value_map, path_dict): # check if both inputs are dictionaries if not (isinstance(value_map, dict) or isinstance(path_dict, dict)): raise TypeError("Input needs to be in dictionary format.") return # check keys in the input dictionary for k in value_map: if not k in ["PrEPCoverage", "PrEPDuration"]: raise ValueError("Keys of the input dictionary should only contain PrEPCoverage and PrEPDuration") return # Lazyness encounter: remaning input because rest of the code was written with different name var_to_replace = value_map del value_map # create mesh grid for values val_to_replace = {} val_to_replace['PrEPCoverage'], val_to_replace['PrEPDuration'] = np.meshgrid(var_to_replace['PrEPCoverage'], var_to_replace['PrEPDuration']) # import the base files cepac_in = link.import_all_cepac_in_files(path_dict['input']) # find indices of the required variables idx = {} for k in var_to_replace: idx[k] = cepac_in['B'].loc[cepac_in['B'].loc[:, 0] == k, :].index.values # replace all the indices with respective values float_b = cepac_in['B'] float_c = cepac_in['C'] for row in range(len(val_to_replace['PrEPCoverage'])): # for col in range(val_to_replace['PrEPCoverage'].shape[1]): # don't need to create files for zero coverage, just use SQ results if float(val_to_replace["PrEPCoverage"][(row, col)]) == 0: continue # for var in var_to_replace: float_b.loc[idx[var], 1:2] = val_to_replace[var][(row, col)] float_c.loc[idx[var], 1:2] = val_to_replace[var][(row, col)] # make new dir if not os.path.exists(path_dict['output']['intervention']): os.makedirs(path_dict['output']['intervention']) # name the input file path = path_dict['output']['intervention'] # B name = "RunB_Coverage=%d, Duration=%d"%(100 * val_to_replace["PrEPCoverage"][(row, col)], val_to_replace["PrEPDuration"][(row, col)]) + r".in" float_path = os.path.join(path, name) link.write_cepac_in_file(float_path, float_b) # C name = "RunC_Coverage=%d, Duration=%d"%(100 * val_to_replace["PrEPCoverage"][(row, col)], val_to_replace["PrEPDuration"][(row, col)]) + r".in" float_path = os.path.join(path, name) link.write_cepac_in_file(float_path, float_c) # create a folder for status quo if not os.path.exists(path_dict['output']['status quo']): os.makedirs(path_dict['output']['status quo']) # write a status quo .in file in the stsus quo folder link.write_cepac_in_file(os.path.join(path_dict['output']['status quo'], 'SQ.in'), cepac_in['SQ']) return
# replace value in the .in file float_df = t_op.replace_values(var, val, float_df) float_df = t_op.replace_values('PrepIncidMale', val_prep, float_df) del val, val_prep#, solution else: # print #print('This variable has been altered in .in file: %s'%(var)) # replace value in the .in file float_df = t_op.replace_values(var, samples[var][run], float_df) # save the file name = os.path.join(savepath_cepac, 'sample_' + str(run) + '.in') link.write_cepac_in_file(name, float_df) # featurizarion of the .in file feature_mat = h_fun1.featurize_in_file(samples, sample_bounds, run, SEQ_LEN) feature_tensor.append(feature_mat) # print print(run) # save condensed cepac input files CEPAC_input_condensed = CEPAC_input_condensed.to_dict() h_fun1.dump_json(CEPAC_input_condensed, os.path.join(savepath_rnn, 'CEPAC_input.json')) # parallelize input files c_op.parallelize_input(savepath_cepac, parallel = 5)
for var2 in replace_val["PrEPDuration"]: # replace coverage time run_b = find_and_replace(run_b, "PrEPDuration", var2) run_c = find_and_replace(run_c, "PrEPDuration", var2) # create directory dir_name = "Coverage time - %d"%(var2) if not os.path.exists(os.path.join(path_save, dir_name)): path_float = os.path.join(path_save, dir_name) os.makedirs(path_float) # save files path_b = os.path.join(path_float, "B.in") path_c = os.path.join(path_float, "C.in") link.write_cepac_in_file(path_b, run_b) link.write_cepac_in_file(path_c, run_c) # read output and write final files path = {"output": r"C:\Users\Vijeta\Documents\Projects\Brazil PrEP\Transmission runs\Input files\Runs asked by Ken"} dir_list = {"coverage": os.listdir(path["output"]), "coverage time": []} cepac_out = {} percentage_decline = {} for p_coverage in dir_list["coverage"]: # create dictionary cepac_out[p_coverage] = {} percentage_decline[p_coverage] = {} # get all the subfolders
pass # write all final run files abc_output.write_final_runs(var_to_replace, path_dict, HORIZON) # paralellize c_op.parallelize_input(path_dict['output']['final runs']) else: # write all abc run files abc_input.write_abc(var_to_replace, path_dict) # parallelize c_op.parallelize_input(path_dict['output']['intervention']) # compare New CEPAC with Old CEPAC """ # new_path = r'/Users/vijetadeshpande/Downloads/MPEC/Brazil/Rio/ART CHECK1/Compare different ART parameter setting1/2-way SA/Measurement of community benefit_R10/Status quo_R10/SQ.in' old_path = r'/Users/vijetadeshpande/Downloads/MPEC/Brazil/Rio/2-way SA_10 year/Measurement of community benefit_R10/Status quo_R10/SQ.in' new_sq = link.read_cepac_in_file(new_path) old_sq = link.read_cepac_in_file(old_path) # mismatch_idx, mismatch_idx1 = [], [] mismatch_data, mismatch_data1 = {}, {} sq = deepcopy(new_sq) for row in range(0, 1005): x = old_sq.iloc[row, :].dropna() y = new_sq.iloc[row, :].dropna() if (x != y).values.astype(int).sum() > 0: mismatch_idx.append(row)
def get_sensitivity_analysis_files(self, path): # create a new folder which can directly be uploaded on cluster run_folder_name = r'Runs prepared for sensitivity analysis' if not os.path.exists(os.path.join(path, run_folder_name)): os.makedirs(os.path.join(path, run_folder_name)) path = os.path.join(path, run_folder_name) else: path = os.path.join(path, run_folder_name) # define a number to replace na in df end_string = 'stop' # get input data i.e. cepac input for the intervention scenario for i in self.base_files: if 'intervention' in i: intervention = deepcopy(self.base_files[i]) break elif 'RunB' in i: intervention = deepcopy(self.base_files[i]) # variable perturbation perturbation = deepcopy(self.perturbation) perturbation['Variable names'] = perturbation['Variable names'].fillna(end_string) # create structured perturbation data row_index = -1 for var in perturbation['Variable names']['variable name']: # update row index row_index += 1 if var == perturbation['Variable names']['variable name'][0]: continue # break the loop when there's no variable left to do S.A. over if var == end_string: break # get the values of for S.A. for respective variable var_float = perturbation['Variable names']['float name'][row_index] var_sheet = perturbation[var_float].iloc[2:, :].reset_index(drop = True) var_sheet = var_sheet.iloc[var_sheet[1].first_valid_index():var_sheet[1].last_valid_index() + 1, :].dropna( axis=1) #%% if variable under consideration is efficacy or adherance, you # won't find in .in file ################################################################## # find index of current variable in the CEPAC input file replace_index = intervention.index[intervention[0] == var] #%% # check if there are multiple rows for current variable if len(replace_index) != 1: # select the specific dimension for S.A. # take dimension value from perturbation dim1 = perturbation['Variable names']['dim1'].loc[ perturbation['Variable names'].loc[:, 'variable name'] == var] # if that dimension is not availble in CEPAC_input the thre's # something wrong if dim1.values[0] not in intervention.loc[replace_index, 1].values[:]: print('Error') # if that specific value is available in CEPAC_input then see # if there's any dim2 mentioned in the perturbation file else: dim2 = perturbation['Variable names']['dim2'].loc[ perturbation['Variable names'].loc[:, 'variable name'] == var] # %% # if there's no second dimention mentioned then we'll # replace the entire array of inputs corresponding to dim1 if dim2.values[0] == end_string: # write the file self.write_files(dim1=dim1, intervention_file=intervention, index_of_current_var=replace_index, path=path, index_value_in_perturbation=row_index, variable_under_consideration=var, variable_values_sheet_perturbation=var_sheet) # %% # if there's a second dimension mentioned in the perturbation # file then we'll replace only one value in the array # of inputs corresponding to dim1 else: # if that dimension is not available in CEPAC_input the thre's # something wrong if dim2.values[0] not in intervention.loc[replace_index, 1].values[:]: # this section is not written correctly print('Error') # if that specific value is available in CEPAC_input then see # if there's any dim2 mentioned in the perturbation file else: # this section is not written correctly print('Error') # %% # if there's only one element in replace_index else: # write the file self.write_files(dim1=pd.DataFrame(), intervention_file=intervention, index_of_current_var=replace_index, path=path, index_value_in_perturbation=row_index, variable_under_consideration=var, variable_values_sheet_perturbation=var_sheet) # shift files for basecase and intervention to a folder data = self.basecase_intervention new_path = os.path.join(path, r'Basecase and Intervention') if not os.path.exists(new_path): os.makedirs(new_path) for file in data: link.write_cepac_in_file(os.path.join(new_path, file+r'.in'), data[file]) #os.remove(os.path.join(path, file+r'.in')) return True
def write_files(self, dim1, intervention_file, index_of_current_var, path, index_value_in_perturbation, variable_under_consideration, variable_values_sheet_perturbation): # in this case there will be an array of replace_index # and we have to find out which row to select for # replacing data if len(index_of_current_var) > 1: index_of_current_var = intervention_file.iloc[index_of_current_var, :].loc[ intervention_file[1] == dim1.values[0], :].index.values replace_col = intervention_file.iloc[index_of_current_var, :].dropna(axis=1).columns[ 2 - int(dim1.empty):].values # using var_sheet replace the row-col (replace_index-replace_col) # with values mentioned in the perturbation file, # one by one # create a folder with name of current var new_path = path + r'\/' + str(index_value_in_perturbation) + '. ' + variable_under_consideration if not os.path.exists(new_path): os.makedirs(new_path) # iterate over the values mentioned in perturbation file # for sensitivity analysis for i in variable_values_sheet_perturbation.index: # copy main intervention file intervention_float = deepcopy(intervention_file) # replace values with perturbation values intervention_float = self.check_dependancies_and_replace() #%% it'll be better we create a central function for replacing values. # whenever you have to changeany value in .in file, you have to call # that function. # Most importantly, function should take care of the dependancies # between different variables ################################################################## if variable_under_consideration in self.independant_var: val = {'x_cepac': {}, 'x_user_in': {}} val['x_user_in'][variable_under_consideration] = variable_values_sheet_perturbation.iloc[i,2:].values if variable_under_consideration == 'percenatge_reduction': intervention_float = link.calculations_for_depemdent_var(intervention_float, self.dependent_var_map[0], val) elif variable_under_consideration == 'prep_efficacy': print('\n\n================================================') val['x_user_in']['prep_adherence'] = input('\nPlease enter PrEP adherence value for basecase: \n') intervention_float = link.calculations_for_depemdent_var(intervention_float, self.dependent_var_map[1], val) elif variable_under_consideration == 'prep_adherence': print('\n\n================================================') val['x_user_in']['prep_eficacy'] = input('\nPlease enter PrEP efficacy value for basecase: \n') intervention_float = link.calculations_for_depemdent_var(intervention_float, self.dependent_var_map[1], val) else: intervention_float.iloc[index_of_current_var, replace_col] = variable_values_sheet_perturbation.iloc[i, 2:].values #%% # save the file save_path = new_path + r'\/' + str(variable_under_consideration) + r' value ' + str(i + 1) + r'.in' link.write_cepac_in_file(save_path, intervention_float)
float_df = find_and_replace(float_df, var, sample[var][row]) prep_incid = sample[var][row] * (1 - efficacy * adherence) float_df = find_and_replace(float_df, 'PrepIncidMale', prep_incid) else: float_df = find_and_replace(float_df, var, sample[var][row]) # write file if row % 10 == 0: name_extension = "CEPAC input set %d" % (row / 10) run_path = os.path.join(path["Input"], name_extension) if not os.path.exists(run_path): os.makedirs(run_path) name = 'cepac_run' + str(row) + r'.in' link.write_cepac_in_file(os.path.join(run_path, name), float_df) # stop timer stop = timeit.default_timer() print('Time: ', stop - start) #%% #def weib(t, shape): # coverage = 0.01 # duration = 120 # scale = -np.log(1 - coverage)/(duration**shape) # tp = 1 - np.exp(scale*(math.pow(t, shape) - math.pow(t+1, shape))) # return tp