def di_dist_without_singletons(model, rs, cfg, ind):
completion_for_m = cfg.ind_ancestral_set - cfg.ind_cbg_p_i_vertex_sets[ind]
completion_for_p_ind = cfg.ind_cbg_p_i_vertex_sets[ind] - cfg.ind_ancestral_set
logger.info("Creating completion variables.")
hat_rs = define_matching_vars(model=model,
edge_set=general_allowable_set(completion_for_p_ind),
edge_conditions=general_conditional_set(completion_for_p_ind),
vertex_set=[],
vertex_conditions={x: False for x in completion_for_p_ind})
hat_ps = define_matching_vars(model=model,
edge_set=general_allowable_set(completion_for_m),
edge_conditions=general_conditional_set(completion_for_m),
vertex_set=[],
vertex_conditions={x: False for x in completion_for_m})
logger.info("Creating connectivity variables and constraints.")
bs, tilde_bs = create_connectivity_variables(model=model,
vertex_set=(cfg.ind_ancestral_set | cfg.ind_cbg_p_i_vertex_sets[ind]))
add_certain_connectivity_constraints(model=model,
edges=cfg.ind_cbg_p_i_edges[ind],
connect_vars=bs)
add_uncertain_connectivity_constraints(model=model,
edge_set=cfg.allowable_ancestral_edges,
connect_vars=bs,
edge_vars=rs,
biggest_const=cfg.biggest_const)
add_uncertain_connectivity_constraints(model=model,
edge_set=general_allowable_set(completion_for_m),
connect_vars=bs,
edge_vars=hat_ps,
biggest_const=cfg.biggest_const)
add_uncertain_connectivity_constraints(model=model,
edge_set=general_allowable_set(completion_for_p_ind),
connect_vars=bs,
edge_vars=hat_rs,
biggest_const=cfg.biggest_const)
logger.info("Creating telomeric variables and constraints.")
hat_bs = create_vars_count_odd_paths(model=model,
connect_vars=bs,
telomeric_vertices=cfg.ind_cbg_p_i_telomers[ind],
biggest_const=cfg.biggest_const)
return tilde_bs, hat_bs
def create_ilp_formulation_for_restricted_median(cfg):
try:
model = gurobipy.Model(cfg.name_model)
logger.info("START CREATING MODEL.")
dot_rs = model.addVars(
{x
for x, cond in cfg.allowable_telomers.items() if cond},
vtype=gurobipy.GRB.BINARY)
rs = define_matching_vars(model=model,
edge_set=cfg.allowable_ancestral_edges,
edge_conditions=cfg.connection_constrs,
vertex_set=dot_rs,
vertex_conditions=cfg.allowable_telomers,
name="rs")
tilde_bs, hat_bs = [], []
for i in range(cfg.number_of_genomes):
tilde_b, hat_b = di_dist_without_singletons(model=model,
rs=rs,
cfg=cfg,
ind=i)
tilde_bs.append(tilde_b)
hat_bs.append(hat_b)
logger.info("CREATING BIG CONSTRAINT")
model.addConstr(tilde_bs[0].sum('*') + tilde_bs[1].sum('*') -
dot_rs.sum('*') - hat_bs[0].sum('*') -
hat_bs[1].sum('*') == len(cfg.ind_ancestral_set) // 2 +
cfg.number_of_cycles + cfg.number_of_even_paths // 2)
logger.info("CREATING OBJECTIVE FUNCTION.")
model.setObjective(
tilde_bs[2].sum('*') - 0.5 * dot_rs.sum('*') - hat_bs[2].sum('*'),
gurobipy.GRB.MAXIMIZE)
logger.info("FINISH CREATE MODEL.")
model.params.logFile = cfg.log_file
model.params.MIPFocus = 2
model.params.timeLimit = cfg.time_limit
model.optimize()
logger.info("The number of cycles and paths is " +
str(int(model.objVal)))
answer = get_param_of_solution_for_restricted_median(model=model,
cfg=cfg,
rs=rs,
dot_rs=dot_rs)
return answer
except gurobipy.GurobiError as e:
logger.error(
"Some error has been raised. Please, report to github bug tracker. \n Text exception: {0}"
.format(e))
def create_ilp_formulation_for_halvings_without_singletons(cfg):
try:
model = gurobipy.Model(cfg.name_model)
logger.info("START CREATING MODEL.")
dot_rs = model.addVars(
{
x
for x, cond in cfg.allowable_ancestral_telomers.items() if cond
},
vtype=gurobipy.GRB.BINARY)
rs = define_matching_vars(
model=model,
edge_set=cfg.allowable_ancestral_edges,
edge_conditions=cfg.connection_ancestral_constrs,
vertex_set=dot_rs,
vertex_conditions=cfg.allowable_ancestral_telomers,
name="rs")
tilde_b, hat_b = di_dist_without_singletons(model=model,
rs=rs,
cfg=cfg,
ind=0)
tilde_a, hat_a = ddi_dist_without_singletons(model=model,
rs=rs,
cfg=cfg)
logger.info("CREATING OBJECTIVE FUNCTION.")
model.setObjective(
tilde_b.sum('*') + tilde_a.sum('*') - 1.5 * dot_rs.sum('*') -
hat_b.sum('*') - hat_a.sum('*'), gurobipy.GRB.MAXIMIZE)
logger.info("FINISH CREATE MODEL.")
model.params.logFile = cfg.log_file
model.params.MIPFocus = 2
model.params.timeLimit = cfg.time_limit
model.optimize()
logger.info("The number of cycles and paths is " +
str(int(model.objVal)))
answer = get_param_of_solution_for_halving_problem(model=model,
cfg=cfg,
rs=rs,
dot_rs=dot_rs)
return answer
except gurobipy.GurobiError as e:
logger.error(
"Some error has been raised. Please, report to github bug tracker. \n Text exception: {0}"
.format(e))
return None
def create_ilp_formulation_for_ddp(config):
try:
model = gurobipy.Model(config.name_model)
logger.info("Creating completion variables.")
hat_as = define_matching_vars(
model=model,
edge_set=general_allowable_set(config.ind_compl_for_A),
edge_conditions=general_conditional_set(config.ind_compl_for_A),
vertex_set=[],
vertex_conditions={x: False
for x in config.ind_compl_for_A},
name="hat_as")
hat_xs = define_matching_vars(
model=model,
edge_set=general_allowable_set(config.ind_compl_for_R),
edge_conditions=general_conditional_set(config.ind_compl_for_R),
vertex_set=[],
vertex_conditions={x: False
for x in config.ind_compl_for_R},
name="hat_bs")
logger.info("Defining genome X.")
xes, indexing_set = define_guided_matching_using_graph(
model=model,
edge_conditions={edge: False
for edge in config.ind_cbg_R_edges},
equiv_map=config.equiv_map,
edge_variables=[])
logger.info("Creating connectivity variables and constraints.")
aes, tilde_as = create_connectivity_variables(
model=model, vertex_set=config.bg_vertex2ind.values())
add_certain_connectivity_constraints(model=model,
edges=config.ind_bg_A_edges,
connect_vars=aes)
add_uncertain_connectivity_constraints(
model=model,
edge_set=indexing_set,
edge_vars=xes,
connect_vars=aes,
biggest_const=config.biggest_const)
add_uncertain_connectivity_constraints(
model=model,
edge_set=general_allowable_set(config.ind_compl_for_A),
edge_vars=hat_as,
connect_vars=aes,
biggest_const=config.biggest_const)
add_uncertain_connectivity_constraints(
model=model,
edge_set=general_allowable_set(config.ind_compl_for_R),
edge_vars=hat_xs,
connect_vars=aes,
biggest_const=config.biggest_const)
logger.info("Creating telomeric variables and constraints.")
dot_as = create_odd_path_variables(
model=model,
telomeric_vertices=config.ind_bg_A_telomers,
connect_vars=aes,
biggest_const=config.biggest_const)
logger.info("CREATING OBJECTIVE FUNCTION.")
model.setObjective(
tilde_as.sum('*') - dot_as.sum('*'), gurobipy.GRB.MAXIMIZE)
logger.info("FINISH CREATE MODEL.")
model.params.logFile = config.log_file
model.params.MIPFocus = 2
model.params.timeLimit = config.time_limit
model.optimize()
logger.info("The number of cycles and paths is " +
str(int(model.objVal)))
answer = get_param_of_solution_for_double_distance(
model=model,
multiplicity=config.multiplicity,
number_of_genes=len(config.s_all_genes),
number_of_R_telomers=len(config.ind_cbg_R_telomers))
return answer
except gurobipy.GurobiError as e:
logger.error(
"Some error has been raised. Please, report to github bug tracker. \n Text exception: {0}"
.format(e))
return None
def di_dist_with_singletons(model, rs, cfg, ind):
completion_for_m = cfg.ind_ancestral_set - cfg.ind_cbg_p_i_vertex_sets[ind]
completion_for_p_ind = cfg.ind_cbg_p_i_vertex_sets[ind] - cfg.ind_ancestral_set
logger.info("Creating variables and constraints for singletons.")
ss, tilde_ss = create_connectivity_variables(model=model, vertex_set=completion_for_m)
filtered_obverse_edges = {(u, v) for u, v in cfg.ind_cbg_obverse_edges
if u in completion_for_m and v in completion_for_m}
add_certain_connectivity_constraints(model=model,
edges=filtered_obverse_edges,
connect_vars=ss)
add_uncertain_connectivity_constraints(model=model,
edge_set=general_allowable_set(completion_for_m),
connect_vars=ss,
edge_vars=rs,
biggest_const=cfg.biggest_const)
dot_ss = create_varibles_vertex_in_component(model=model,
vertex_set=completion_for_m,
connect_vars=ss,
component_set=completion_for_m)
hat_ss = create_vars_vertices_in_singleton(model=model,
vertex_set=completion_for_m,
dot_vars=dot_ss)
add_constr_representative_neq_zero(model=model,
dot_vars=dot_ss,
component_set=completion_for_m,
tilde_vars=tilde_ss,
biggest_const=cfg.biggest_const)
add_constr_vertex_in_singleton_has_edge(model=model,
hat_vars=hat_ss,
genome_vars=rs,
vertex_set=completion_for_m)
logger.info("Creating completion variables.")
hat_rs = define_matching_vars(model=model,
edge_set=general_allowable_set(completion_for_p_ind),
edge_conditions=general_conditional_set(completion_for_p_ind),
vertex_set=[],
vertex_conditions={x: False for x in completion_for_p_ind})
hat_ps = define_matching_vars(model=model,
edge_set=general_allowable_set(completion_for_m),
edge_conditions=general_conditional_set(completion_for_m),
vertex_set=hat_ss,
vertex_conditions={x: True for x in completion_for_m})
logger.info("Creating connectivity variables and constraints.")
bs, tilde_bs = create_connectivity_variables(model=model,
vertex_set=(cfg.ind_ancestral_set | cfg.ind_cbg_p_i_vertex_sets[ind]))
add_certain_connectivity_constraints(model=model,
edges=cfg.ind_cbg_p_i_edges[ind],
connect_vars=bs)
add_uncertain_connectivity_constraints(model=model,
edge_set=cfg.allowable_ancestral_edges,
connect_vars=bs,
edge_vars=rs,
biggest_const=cfg.biggest_const)
add_uncertain_connectivity_constraints(model=model,
edge_set=general_allowable_set(completion_for_m),
connect_vars=bs,
edge_vars=hat_ps,
biggest_const=cfg.biggest_const)
add_uncertain_connectivity_constraints(model=model,
edge_set=general_allowable_set(completion_for_p_ind),
connect_vars=bs,
edge_vars=hat_rs,
biggest_const=cfg.biggest_const)
logger.info("Creating telomeric variables and constraints.")
hat_bs = create_vars_count_odd_paths(model=model,
connect_vars=bs,
telomeric_vertices=cfg.ind_cbg_p_i_telomers[ind],
biggest_const=cfg.biggest_const)
logger.info("Creating variables and constraints for avoiding singletons.")
dot_bs = create_varibles_vertex_in_component(model=model,
vertex_set=completion_for_m,
connect_vars=bs,
component_set=(cfg.ind_ancestral_set | cfg.ind_cbg_p_i_vertex_sets[ind]))
add_constr_vertices_in_comp_or(model=model,
vertex_set=completion_for_m,
dot_vars=dot_bs,
singleton_vars=hat_ss)
return tilde_bs, hat_bs, tilde_ss, hat_ss
def di_dist_with_singletons(model, rs, cfg, ind):
"""
Function constructs part of ILP formulation, which express DCJ-indel distance between
ordinary genomes M and P_ind.
:param model: ILP model that will be submitted to solver
:param rs: variables corresponding to median genome
:param cfg: config with all information about problem instance
:param ind: Integer
the index of ordinary genome for which constraints will be constructed
:return: return two types of variables required for objective function
"""
completion_for_m = cfg.ind_ancestral_set - cfg.ind_cbg_p_i_vertex_sets[ind]
completion_for_p_ind = cfg.ind_cbg_p_i_vertex_sets[
ind] - cfg.ind_ancestral_set
filtered_obverse_edges = {
(u, v)
for u, v in cfg.ind_cbg_obverse_edges
if u in completion_for_m and v in completion_for_m
}
logger.info("Creating variables and constraints for singletons.")
ss, tilde_ss = create_connectivity_variables(model=model,
vertex_set=completion_for_m,
suffix="ss")
add_certain_connectivity_constraints(model=model,
edges=filtered_obverse_edges,
connect_vars=ss)
add_uncertain_connectivity_constraints(
model=model,
edge_set=general_allowable_set(completion_for_m),
connect_vars=ss,
edge_vars=rs,
biggest_const=cfg.biggest_const)
dot_ss = create_representing_variables(model=model,
vertex_set=completion_for_m,
component_set=completion_for_m,
component_vars=ss,
name="dot_ss")
hat_ss = model.addVars(completion_for_m, vtype=gurobipy.GRB.BINARY)
add_ensuring_belonging_constraints(model=model,
vertex_set=completion_for_m,
representing_vars=dot_ss,
belonging_vars=hat_ss,
negotiation=False)
add_ensuring_non_zero_constraints(model=model,
dot_vars=dot_ss,
component_set=completion_for_m,
tilde_vars=tilde_ss,
biggest_const=cfg.biggest_const)
add_ensuring_edge_constraints(model=model,
hat_vars=hat_ss,
genome_vars=rs,
vertex_set=completion_for_m)
logger.info("Creating completion variables.")
hat_rs = define_matching_vars(
model=model,
edge_set=general_allowable_set(completion_for_p_ind),
edge_conditions=general_conditional_set(completion_for_p_ind),
vertex_set=[],
vertex_conditions={x: False
for x in completion_for_p_ind},
name="hat_rs")
hat_ps = define_matching_vars(
model=model,
edge_set=general_allowable_set(completion_for_m),
edge_conditions=general_conditional_set(completion_for_m),
vertex_set=hat_ss,
vertex_conditions={x: True
for x in completion_for_m},
name="hat_ps")
logger.info("Creating connectivity variables and constraints.")
bs, tilde_bs = create_connectivity_variables(
model=model,
vertex_set=(cfg.ind_ancestral_set | cfg.ind_cbg_p_i_vertex_sets[ind]),
suffix="ps")
add_certain_connectivity_constraints(model=model,
edges=cfg.ind_cbg_p_i_edges[ind],
connect_vars=bs)
add_uncertain_connectivity_constraints(
model=model,
edge_set=cfg.allowable_ancestral_edges,
connect_vars=bs,
edge_vars=rs,
biggest_const=cfg.biggest_const)
add_uncertain_connectivity_constraints(
model=model,
edge_set=general_allowable_set(completion_for_m),
connect_vars=bs,
edge_vars=hat_ps,
biggest_const=cfg.biggest_const)
add_uncertain_connectivity_constraints(
model=model,
edge_set=general_allowable_set(completion_for_p_ind),
connect_vars=bs,
edge_vars=hat_rs,
biggest_const=cfg.biggest_const)
logger.info("Creating telomeric variables and constraints.")
hat_bs = create_odd_path_variables(
model=model,
connect_vars=bs,
telomeric_vertices=cfg.ind_cbg_p_i_telomers[ind],
biggest_const=cfg.biggest_const)
logger.info("Creating variables and constraints for avoiding singletons.")
dot_bs = create_representing_variables(
model=model,
vertex_set=completion_for_m,
component_set=(cfg.ind_ancestral_set
| cfg.ind_cbg_p_i_vertex_sets[ind]),
component_vars=bs,
name="dot_ps")
add_ensuring_belonging_constraints(model=model,
vertex_set=completion_for_m,
representing_vars=dot_bs,
belonging_vars=hat_ss,
negotiation=True)
return tilde_bs, hat_bs, tilde_ss, hat_ss
def di_dist_without_singletons(model, rs, cfg, ind):
"""
Function constructs part of ILP formulation, which express DCJ distance between ordinary genomes
M and P_ind. Function assumption is no singletons in M wrt P_i.
:param model: ILP model that will be submitted to solver
:param rs: variables corresponding to median genome
:param cfg: config with all information about problem instance
:param ind: Integer
the index of ordinary genome for which constraints will be constructed
:return: return two types of variables required for objective function
"""
completion_for_m = cfg.ind_ancestral_set - cfg.ind_cbg_p_i_vertex_sets[ind]
completion_for_p_ind = cfg.ind_cbg_p_i_vertex_sets[
ind] - cfg.ind_ancestral_set
logger.info("Creating completion variables.")
hat_rs = define_matching_vars(
model=model,
edge_set=general_allowable_set(completion_for_p_ind),
edge_conditions=general_conditional_set(completion_for_p_ind),
vertex_set=[],
vertex_conditions={x: False
for x in completion_for_p_ind},
name='hat_rs')
hat_ps = define_matching_vars(
model=model,
edge_set=general_allowable_set(completion_for_m),
edge_conditions=general_conditional_set(completion_for_m),
vertex_set=[],
vertex_conditions={x: False
for x in completion_for_m},
name='hat_ps')
logger.info("Creating connectivity variables and constraints.")
bs, tilde_bs = create_connectivity_variables(
model=model,
vertex_set=(cfg.ind_ancestral_set | cfg.ind_cbg_p_i_vertex_sets[ind]),
suffix="ps")
add_certain_connectivity_constraints(model=model,
edges=cfg.ind_cbg_p_i_edges[ind],
connect_vars=bs)
add_uncertain_connectivity_constraints(
model=model,
edge_set=cfg.allowable_ancestral_edges,
connect_vars=bs,
edge_vars=rs,
biggest_const=cfg.biggest_const)
add_uncertain_connectivity_constraints(
model=model,
edge_set=general_allowable_set(completion_for_m),
connect_vars=bs,
edge_vars=hat_ps,
biggest_const=cfg.biggest_const)
add_uncertain_connectivity_constraints(
model=model,
edge_set=general_allowable_set(completion_for_p_ind),
connect_vars=bs,
edge_vars=hat_rs,
biggest_const=cfg.biggest_const)
logger.info("Creating telomeric variables and constraints.")
hat_bs = create_odd_path_variables(
model=model,
connect_vars=bs,
telomeric_vertices=cfg.ind_cbg_p_i_telomers[ind],
biggest_const=cfg.biggest_const)
return tilde_bs, hat_bs
def create_ilp_formulation_for_ddp(config, ilp_type='improved'):
try:
start_time = datetime.datetime.now()
model = gurobipy.Model(config.name_model)
logger.info("Creating completion variables.")
logger.info("Defining R completion.")
hat_rs = define_matching_vars(model=model,
edge_set=general_allowable_set(config.ind_cbg_compl_R),
edge_conditions=general_conditional_set(config.ind_cbg_compl_R),
vertex_set=[],
vertex_conditions={x: False for x in config.ind_cbg_compl_R})
logger.info("Defining genome X.")
xes, indexing_set = define_guided_matching_using_graph(model=model,
edge_conditions={**{edge: False for edge in
config.ind_cbg_R_edges},
**{pair: True for pair in
general_allowable_set(
config.ind_cbg_compl_R)}},
equiv_map=config.equiv_map,
edge_variables=hat_rs)
logger.info("Creating connectivity variables and constraints.")
aes, tilde_as = create_connectivity_variables(model=model, vertex_set=config.bg_vertex2ind.values())
add_certain_connectivity_constraints(model=model,
edges=config.ind_bg_A_edges,
connect_vars=aes)
if ilp_type == 'basic':
logger.info("Defining A completion.")
hat_as = define_matching_vars(model=model,
edge_set=general_allowable_set(config.ind_compl_A),
edge_conditions=general_conditional_set(config.ind_compl_A),
vertex_set=[],
vertex_conditions={x: False for x in config.ind_compl_A})
add_uncertain_connectivity_constraints(model=model,
edge_set=indexing_set,
edge_vars=xes,
connect_vars=aes,
biggest_const=config.biggest_const)
add_uncertain_connectivity_constraints(model=model,
edge_set=general_allowable_set(config.ind_compl_A),
edge_vars=hat_as,
connect_vars=aes,
biggest_const=config.biggest_const)
logger.info("Creating telomeric variables and constraints.")
dot_as = create_vars_count_odd_paths(model=model,
telomeric_vertices=config.ind_bg_A_telomers,
connect_vars=aes,
biggest_const=config.biggest_const)
logger.info("CREATING OBJECTIVE FUNCTION.")
model.setObjective(tilde_as.sum('*') - dot_as.sum('*'), gurobipy.GRB.MAXIMIZE)
elif ilp_type == 'improved':
set_pairs_for_paths = general_allowable_set(config.ind_forth_type_telomers) | \
product_set(config.ind_second_type_telomers,
config.ind_third_type_telomers) | \
product_set(config.ind_second_type_telomers,
config.ind_forth_type_telomers)
logger.info("Creating variables for counting paths.")
hat_cs = create_path_variables(model=model,
pairs_set=set_pairs_for_paths)
add_uncertain_connectivity_constraints_a(model=model,
edge_set=indexing_set,
edge_vars=xes,
connect_vars=aes,
biggest_const=config.biggest_const)
add_uncertain_connectivity_constraints_c(model=model,
edge_set=set_pairs_for_paths,
edge_vars=hat_cs,
connect_vars=aes,
biggest_const=config.biggest_const)
p44 = create_helping_path_variables(model=model,
connect_vars=hat_cs,
pair_set=general_allowable_set(config.ind_forth_type_telomers),
biggest_const=config.biggest_const)
p23 = create_helping_path_variables(model=model,
connect_vars=hat_cs,
pair_set=product_set(config.ind_second_type_telomers,
config.ind_third_type_telomers),
biggest_const=config.biggest_const)
p24 = create_helping_path_variables(model=model,
connect_vars=hat_cs,
pair_set=product_set(config.ind_second_type_telomers,
config.ind_forth_type_telomers),
biggest_const=config.biggest_const)
c1 = len(config.ind_first_type_telomers)
# create_objective
logger.info("CREATING OBJECTIVE FUNCTION.")
tmp = model.addVar(lb=-config.biggest_const, ub=config.biggest_const, vtype=gurobipy.GRB.INTEGER, name="tmp")
model.addConstr(tmp == p24 - c1 - p23)
abs_var = model.addVar(ub=config.biggest_const, vtype=gurobipy.GRB.INTEGER, name="abs_tmp")
model.addConstr(abs_var == gurobipy.abs_(tmp))
model.setObjective(tilde_as.sum('*') - p44 - 1 / 4 * (c1 + p23 + 3 * p24 + abs_var), gurobipy.GRB.MAXIMIZE)
else:
logger.error('Error: Unknown type. Use "basic" or "improved"')
return None
logger.info("FINISH CREATE MODEL.")
model.params.logFile = config.log_file
model.params.MIPFocus = 2
model.params.timeLimit = config.time_limit
model.optimize()
logger.info("The number of cycles and paths is " + str(int(model.objVal)))
print("The number of cycles and paths is " + str(int(model.objVal)))
answer = get_param_of_solution_for_double_distance(model=model,
multiplicity=config.multiplicity,
number_of_genes=len(config.s_all_genes),
number_of_R_telomers=len(config.ind_cbg_R_telomers),
working_time=datetime.datetime.now() - start_time)
return answer
except gurobipy.GurobiError as e:
logger.error(
"Some error has been raised. Please, report to github bug tracker. \n Text exception: {0}".format(e))
return None
def create_ilp_formulation_for_medians_with_singletons(cfg):
"""
:param cfg: Median configuration object with all information
about ILP formultaion, i.e., gene set, index sets, index constraints set.
For more details see file utils/medians.py
:return: ILP answer object that contains reconstructed genome, status of ILP solver, median score.
This function takes into account possibility of appearing singletons in median genome.
"""
try:
model = gurobipy.Model(cfg.name_model)
logger.info("START CREATING MODEL.")
dot_rs = model.addVars(
{
x
for x, cond in cfg.allowable_ancestral_telomers.items() if cond
},
vtype=gurobipy.GRB.BINARY,
name="dot_rs")
rs = define_matching_vars(
model=model,
edge_set=cfg.allowable_ancestral_edges,
edge_conditions=cfg.connection_ancestral_constrs,
vertex_set=dot_rs,
vertex_conditions=cfg.allowable_ancestral_telomers,
name="rs")
tilde_bs, hat_bs, tilde_ss, hat_ss = [], [], [], []
for i in range(cfg.number_of_genomes):
tilde_b, hat_b, tilde_s, hat_s = di_dist_with_singletons(
model=model, rs=rs, cfg=cfg, ind=i)
tilde_bs.append(tilde_b)
hat_bs.append(hat_b)
tilde_ss.append(tilde_s)
hat_ss.append(hat_s)
logger.info("CREATING OBJECTIVE FUNCTION.")
model.setObjective(
tilde_bs[0].sum('*') + tilde_bs[1].sum('*') +
tilde_bs[2].sum('*') - 1.5 * dot_rs.sum('*') - hat_bs[0].sum('*') -
hat_bs[1].sum('*') - hat_bs[2].sum('*') +
0.5 * hat_ss[0].sum('*') + 0.5 * hat_ss[2].sum('*') +
0.5 * hat_ss[2].sum('*') - tilde_ss[0].sum('*') -
tilde_ss[1].sum('*') - tilde_ss[2].sum('*'), gurobipy.GRB.MAXIMIZE)
logger.info("FINISH CREATE MODEL.")
model.params.logFile = cfg.log_file
model.params.MIPFocus = 2
model.params.timeLimit = cfg.time_limit
model.optimize()
logger.info("The number of cycles and paths is " +
str(int(model.objVal)))
answer = get_param_of_solution_for_median_problem(model=model,
cfg=cfg,
rs=rs,
dot_rs=dot_rs)
return answer
except gurobipy.GurobiError as e:
logger.error(
"Some error has been raised. Please, report to github bug tracker. \n Text exception: {0}"
.format(e))
return None
