def run_generation_no_events(self, path_to_sim, plot_it=True):
"""
See documentation for run_generation() function.
This essentially does the same thing, save for the mutation event on the genome.
Allows to check for noise in transcription profiles.
"""
print("\n\n----\n")
self.evs.append('no')
self.write_sim_files(path_to_sim)
# update gen counter
self.generation += 1
print("Now at generation", self.generation)
# run simulation
sim.start_transcribing('../sim_files/current/params.ini', "../sim_files/future")
fit, fut = self.fitness("../sim_files/future/save_tr_nbr.csv")
# keep or not
# if new fitness is inferior to old fit.
self.fit_bygeneration.append(fit)
self.gene_expr_history(fit, fut, 'NoE', 'NA')
# plot fitness
if not self.NO_PLOT:
if plot_it :
self.plot_sim()
plt.pause(0.001)
def create_genome(self):
#create a linear genome
genome = ['i' for i in range(self.size)]
self.genes_list = list()
self.genes_TU = {}
for i in range(1, len(self.genes)):
start = int(self.genes["Start"][i])
end = int(self.genes["End"][i])
gene_name = self.genes["Attribute"][i].split('=')[-1]
self.genes_list.append(gene_name)
self.genes_TU[gene_name] = i - 1
genome[start:end + 1] = [gene_name] * (end - start + 1)
#add barriers
for b in self.barrier['prot_pos']:
genome[b] = 'b'
#defines the current genome
self.gen_ancetre = np.array(list(genome))
self.gen = np.array(self.gen_ancetre)
self.update_files(self.genes)
self.dataframes_to_text()
if self.nb_pol == None:
sim.start_transcribing(
os.path.join(self.pathToFiles, 'paramsInitOce.ini'),
os.path.join(self.pathToFiles, 'testRes'))
else:
sim.start_transcribing(os.path.join(self.pathToFiles,
'paramsOce.ini'),
os.path.join(self.pathToFiles, 'testRes'),
nb_pol=int(self.nb_pol))
self.fitness = self.compute_fitness()
#self.fitness = 1
self.fitnesses.append(self.fitness)
self.tmp_genes = self.genes.copy()
return self.gen_ancetre
def __init__(self, Size, path_init, path_output="../sim_files/output", NO_PLOT=False,
sec_dist=60, indel_var=0, p_inv=.1, T0=0.001, nb_pol = 7):
self.Size = Size
self.sec_dist = sec_dist
self.indel_var = indel_var
self.p_inv = p_inv
self.change_RNAPS(nb_pol, sec_dist) # change number of PRNA and the security distance in params.ini
self.generation = 0 # generation counter
self.evs = [None] # events occurred by generation
TSS = pd.read_table(path_init+'/TSS.dat', header=0)
TTS = pd.read_table(path_init+'/TTS.dat', header=0)
self.gene_info = TSS.merge(TTS)
self.prot = pd.read_table(path_init+'/prot.dat', header=0)
self.env = pd.read_table(path_init+'/environment.dat', header=None)
self.path_init = path_init
self.path_output = path_output
self.gene_out = self.path_output+'/gene_expr.csv'
if not os.path.exists(self.path_output):
os.makedirs(self.path_output)
self.NO_PLOT = NO_PLOT
self.fit_bygeneration = []
self.T0 = T0
copy2(self.path_init+'/params.ini','../sim_files/current/params.ini')
self.write_sim_files("../sim_files/current")
# Reset the simulation data file if it exists.
try:
os.remove(self.gene_out)
except OSError:
pass
open(self.gene_out, 'w').close()
self.gene_expr_history("fit",
["g0","g1","g2", "g3", "g4","g5", "g6", "g7", "g8", "g9"],
"event", "keep", g="gen")
## Run simulation 0
sim.start_transcribing('../sim_files/current/params.ini', "../sim_files/future")
fit, fut = self.fitness("../sim_files/future/save_tr_nbr.csv")
self.fit_bygeneration.append(fit)
self.gene_expr_history(fit, fut, "NoE", "NA")
# Keep track of best genome
self.best = [self.gene_info, self.prot]
self.best_fit = fit
if not NO_PLOT:
# Plot the genome using our draw_genome.py
self.plot_current_genome()
def run_generation(self, path_to_sim, plot_it=True, plot_gen=10):
"""
Takes the path to simulation folder and plot boolean arguments.
Runs one generation. One generation implies :
- Do one of the 3 events according to their probability
- Write new genome to simulation files
- Run the simulation
- Check output and compute fitness
- Decide if new genome is kept or not.
"""
print("\n\n----\n")
#keep old info in case mutation is BAAAAAD.
old_gene_info = cp.deepcopy(self.gene_info)
old_prot = cp.deepcopy(self.prot)
#choose event
event = np.random.choice(['inv', 'ins', 'del'], p=[self.p_inv, (1-self.p_inv)/2, (1-self.p_inv)/2])
#do event
if 'inv' == event:
self.inversion()
print("Did an inversion.")
elif 'ins' == event :
self.insertion()
print("Did an insertion.")
elif 'del' == event:
self.deletion()
print("Did a deletion.")
self.evs.append(event)
self.write_sim_files(path_to_sim)
# update gen counter
self.generation += 1
print("Now at generation", self.generation)
# run simulation
sim.start_transcribing('../sim_files/current/params.ini', "../sim_files/future")
fit, fut = self.fitness("../sim_files/future/save_tr_nbr.csv")
# keep or not
# if new fitness is inferior to old fit.
self.fit_bygeneration.append(fit)
keep = True
deltaU = self.fit_bygeneration[self.generation-1] - fit
if deltaU > 0:
p = np.exp(-deltaU/self.T0)
# with proba p, keep it. So if rd>p, reset
if np.random.random() > p :
self.gene_info = cp.deepcopy(old_gene_info)
self.prot = cp.deepcopy(old_prot)
self.fit_bygeneration[self.generation] = self.fit_bygeneration[self.generation-1]
keep = False
self.gene_expr_history(fit, fut, event, keep)
# update best fitness
if fit > self.best_fit :
self.best = [self.gene_info, self.prot]
self.best_fit = fit
# plot fitness
if not self.NO_PLOT:
if plot_it :
self.plot_sim()
plt.pause(0.001)
# plot genome
if (self.generation % plot_gen) == 0:
self.plot_current_genome()
def evolution_step(self, t):
#mutation du genome suivant la probabilite relative
r = rd.random()
inv_size = 0
if (self.indelInvRatio):
if r < self.f:
if rd.random() < 0.5:
event = 'insertion'
self.insertion()
else:
self.deletion()
event = 'deletion'
else:
inv_size = self.inversion()
event = 'inversion'
else:
if r < self.f:
inv_size = self.inversion()
event = 'inversion'
else:
if rd.random() < 0.5:
event = 'insertion'
self.insertion()
else:
self.deletion()
event = 'deletion'
#evaluation de la fitness du nouveau genome par simulation
self.update_files(self.tmp_genes)
self.dataframes_to_text()
try:
keep = False
if self.nb_pol == None:
sim.start_transcribing(
os.path.join(self.pathToFiles, 'paramsOce.ini'),
os.path.join(self.pathToFiles, 'testRes'))
else:
sim.start_transcribing(os.path.join(self.pathToFiles,
'paramsOce.ini'),
os.path.join(self.pathToFiles,
'testRes'),
nb_pol=int(self.nb_pol))
new_fitness = self.compute_fitness()
#new_fitness = 1
#garder le nouveau genome?
if new_fitness > self.fitness:
keep = True
else:
#on tire la probabilite dans une loi exponentielle
proba = self.T0 * math.exp(-self.T0 * t)
if rd.random() < proba:
keep = True
#print("old fit : ", self.fitness, " new fi : ", new_fitness, " keep = ", keep)
if event == 'inversion':
self.delta_fitness[event].append(
(self.fitness - new_fitness, inv_size))
else:
self.delta_fitness[event].append(self.fitness - new_fitness)
if keep:
#print("keep = ", keep)
#mise a jour des attributs en consequent
self.genes = self.tmp_genes.copy()
self.gen_ancetre = np.array(self.gen)
self.fitness = new_fitness
self.events.append((t, event))
self.fitnesses.append(self.fitness)
except ValueError:
print('Genes cotes a cotes dans simulation....')
except KeyError:
print('keyerror')