l_jP_background = []
l_gamma = []
l_gamma_0 = []
l_logP = []
for ll_signal in ll_signal_tot :
""" INITIALIZE AND RUN HMM """
l_var = [theta_var_coupled, amplitude_var, background_var]
hmm=HMM_SemiCoupled(l_var, ll_signal, sigma_em_circadian,
ll_val_phi = [], waveform = W , pi = pi,
crop = False )
(l_gamma_0_temp, l_gamma_temp ,l_logP_temp, ll_alpha, ll_beta, l_E,
ll_cnorm, ll_idx_phi_hmm_temp, ll_signal_hmm_temp,
ll_nan_circadian_factor_hmm_temp) = hmm.run_em()
ll_mat_TR = [np.array( [theta_var_coupled.TR_no_coupling \
for i in gamma_temp]) for gamma_temp in l_gamma_temp ]
""" PLOT TRACE EXAMPLE """
zp = zip(enumerate(ll_signal_hmm_temp),l_gamma_temp, l_logP_temp)
for (idx, signal), gamma, logP in zp:
plt_result = PlotResults(gamma, l_var, signal_model, signal,
waveform = W, logP = None,
temperature = temperature, cell = cell)
plt_result.plotEverythingEsperance(False, idx)
if idx==0:
break
def F_by_cell_cell_cycle_period(cell = 'NIH3T3', nb_traces = 10000,
size_block = 100, nb_iter = 15):
"""
Optimize and plot the coupling function and phase-space density at
different temperatures, but for a fixed distribution of cell-cycle periods.
Parameters
----------
cell : string
Cell condition.
nb_traces : int
How many traces to run the experiment on.
size_block : integer
Size of the traces chunks (to save memory).
nb_iter : int
Number of EM iterations.
"""
temperature = None
##################### LOAD COLORMAP ##################
c = mcolors.ColorConverter().to_rgb
bwr = make_colormap( [c('blue'), c('white'), 0.48, c('white'),
0.52,c('white'), c('red')])
##################### LOAD OPTIMIZED PARAMETERS ##################
path = '../Parameters/Real/opt_parameters_nodiv_'+str(temperature)\
+"_"+cell+'.p'
with open(path , 'rb') as f:
l_parameters = [dt, sigma_em_circadian, W, pi,
N_theta, std_theta, period_theta, l_boundaries_theta, w_theta,
N_phi, std_phi, period_phi, l_boundaries_phi, w_phi,
N_amplitude_theta, mu_amplitude_theta, std_amplitude_theta,
gamma_amplitude_theta, l_boundaries_amplitude_theta,
N_background_theta, mu_background_theta, std_background_theta,
gamma_background_theta, l_boundaries_background_theta,
F] = pickle.load(f)
##################### DISPLAY PARAMETERS ##################
display_parameters_from_file(path, show = False)
##################### LOAD TRACES ##################
dic_traces = {34:{}, 37:{}, 40:{}}
cell_cycle_space = list(range(12,40))
for T_cell_cycle in cell_cycle_space:
for temperature in [34,37,40]:
##################### LOAD DATA ##################
if cell == 'NIH3T3':
path = "../Data/NIH3T3.ALL.2017-04-04/ALL_TRACES_INFORMATION.p"
else:
path = "../Data/U2OS-2017-03-20/"\
+"ALL_TRACES_INFORMATION_march_2017.p"
dataClass=LoadData(path, nb_traces, temperature = temperature,
division = True, several_cell_cycles = False,
remove_odd_traces = True)
(ll_area_tot_flat, ll_signal_tot_flat,
ll_nan_circadian_factor_tot_flat, ll_obs_phi_tot_flat, ll_peak,
ll_idx_cell_cycle_start, T_theta, std_T_theta, T_phi, std_T_phi)\
= dataClass.load(period_phi = T_cell_cycle,
load_annotation = True,
force_temperature = True)
dic_traces[temperature][T_cell_cycle] = [ll_area_tot_flat,
ll_signal_tot_flat,
ll_nan_circadian_factor_tot_flat,
ll_obs_phi_tot_flat, ll_peak,
ll_idx_cell_cycle_start, T_theta,
std_T_theta, T_phi, std_T_phi]
#check that there is the same number of traces for a given temperature and
#given cell-cycle
for T_cell_cycle in cell_cycle_space:
max_nb = min(len(dic_traces[34][T_cell_cycle][0]),
len(dic_traces[37][T_cell_cycle][0]),
len(dic_traces[40][T_cell_cycle][0]))
dic_traces[34][T_cell_cycle] = [l[:max_nb] \
if type(l)==list else l for l in dic_traces[34][T_cell_cycle]]
dic_traces[37][T_cell_cycle] = [l[:max_nb] \
if type(l)==list else l for l in dic_traces[37][T_cell_cycle]]
dic_traces[40][T_cell_cycle] = [l[:max_nb] \
if type(l)==list else l for l in dic_traces[40][T_cell_cycle]]
print(len(dic_traces[34][T_cell_cycle][0]),
len(dic_traces[37][T_cell_cycle][0]),
len(dic_traces[40][T_cell_cycle][0]))
#merge all traces for a given temperature
for temperature in [34,37,40]:
print("Temperature : ", temperature)
(ll_area_tot_flat, ll_signal_tot_flat, ll_nan_circadian_factor_tot_flat,
ll_obs_phi_tot_flat, ll_peak, ll_idx_cell_cycle_start) \
= [], [], [], [], [], []
for T_cell_cycle in cell_cycle_space:
ll_area_tot_flat.extend(dic_traces[temperature][T_cell_cycle][0])
ll_signal_tot_flat.extend(dic_traces[temperature][T_cell_cycle][1])
ll_nan_circadian_factor_tot_flat.extend(
dic_traces[temperature][T_cell_cycle][2])
ll_obs_phi_tot_flat.extend(dic_traces[temperature][T_cell_cycle][3])
ll_peak.extend(dic_traces[temperature][T_cell_cycle][4])
ll_idx_cell_cycle_start.extend(
dic_traces[temperature][T_cell_cycle][5])
##################### SPECIFY F OPTIMIZATION CONDITIONS ##################
#makes algorithm go faster
only_F_and_pi = True
#we don't know the inital condiion when traces divide
pi = None
#we start with a random empty F
F = (np.random.rand( N_theta, N_phi)-0.5)*0.01
#regularization
lambda_parameter = 2*10e-6
lambda_2_parameter = 0.005
##################### CORRECT INFERENCE BIAS ##################
try:
F_no_coupling = pickle.load(open("../Parameters/Misc/F_no_coupling_"\
+str(37)+"_"+cell+'.p', "rb" ) )
for idx_theta in range(N_theta):
F_no_coupling[idx_theta,:] = np.mean(F_no_coupling[idx_theta,:])
except:
print("F_no_coupling not found, no bias correction applied")
F_no_coupling = None
##################### CORRECT PARAMETERS ACCORDINGLY ##################
l_parameters = [dt, sigma_em_circadian, W, pi,
N_theta, std_theta, period_theta, l_boundaries_theta, w_theta,
N_phi, std_phi, period_phi, l_boundaries_phi, w_phi,
N_amplitude_theta, mu_amplitude_theta, std_amplitude_theta,
gamma_amplitude_theta, l_boundaries_amplitude_theta,
N_background_theta, mu_background_theta, std_background_theta,
gamma_background_theta, l_boundaries_background_theta,
F]
##################### CREATE HIDDEN VARIABLES ##################
theta_var_coupled, amplitude_var, background_var = \
create_hidden_variables(l_parameters = l_parameters)
##################### CREATE BLOCK OF TRACES ##################
ll_area_tot = []
ll_signal_tot = []
ll_nan_circadian_factor_tot = []
ll_obs_phi_tot = []
first= True
zp = enumerate(zip(ll_area_tot_flat, ll_signal_tot_flat,
ll_nan_circadian_factor_tot_flat,
ll_obs_phi_tot_flat))
for index, (l_area, l_signal, l_nan_circadian_factor, l_obs_phi) in zp:
if index%size_block==0:
if not first:
ll_area_tot.append(ll_area)
ll_signal_tot.append(ll_signal)
ll_nan_circadian_factor_tot.append(ll_nan_circadian_factor)
ll_obs_phi_tot.append(ll_obs_phi)
else:
first = False
ll_area = [l_area]
ll_signal = [l_signal]
ll_nan_circadian_factor = [l_nan_circadian_factor]
ll_obs_phi = [l_obs_phi]
else:
ll_area.append(l_area)
ll_signal.append(l_signal)
ll_nan_circadian_factor.append(l_nan_circadian_factor)
ll_obs_phi.append(l_obs_phi)
#get remaining trace
ll_area_tot.append(ll_area)
ll_signal_tot.append(ll_signal)
ll_nan_circadian_factor_tot.append(ll_nan_circadian_factor)
ll_obs_phi_tot.append(ll_obs_phi)
##################### OPTIMIZATION ##################
def buildObsPhiFromIndex(ll_index):
ll_obs_phi = []
for l_index in ll_index:
l_obs_phi = []
for index in l_index:
if index==-1:
l_obs_phi.append(-1)
else:
l_obs_phi.append(index/N_theta*2*np.pi)
ll_obs_phi.append(l_obs_phi)
return ll_obs_phi
lP=0
l_lP=[]
l_idx_to_remove = []
for it in range(nb_iter):
print("Iteration :", it)
l_jP_phase = []
l_jP_amplitude = []
l_jP_background = []
l_gamma = []
l_gamma_0 = []
l_logP = []
ll_signal_hmm = []
ll_idx_phi_hmm = []
ll_nan_circadian_factor_hmm = []
### CLEAN TRACES AFTER FIRST ITERATION ###
if it==1:
ll_signal_tot_flat = ll_signal_hmm_clean
ll_idx_phi_tot_flat = ll_idx_phi_hmm_clean
ll_nan_circadian_factor_tot_flat = \
ll_nan_circadian_factor_hmm_clean
print("nb traces apres 1ere iteration : ",
len(ll_signal_tot_flat))
ll_signal_tot = []
ll_idx_phi_tot = []
ll_nan_circadian_factor_tot = []
ll_obs_phi_tot = []
first= True
zp = zip(enumerate(ll_signal_tot_flat),
ll_idx_phi_tot_flat,
ll_nan_circadian_factor_tot_flat)
for (index, l_signal), l_idx_phi, l_nan_circadian_factor in zp:
if index%size_block==0:
if not first:
ll_signal_tot.append(ll_signal)
ll_idx_phi_tot.append(ll_idx_phi)
ll_nan_circadian_factor_tot.append(
ll_nan_circadian_factor)
ll_obs_phi_tot.append(
buildObsPhiFromIndex(ll_idx_phi))
else:
first = False
ll_signal = [l_signal]
ll_idx_phi = [l_idx_phi]
ll_nan_circadian_factor = [l_nan_circadian_factor]
else:
ll_signal.append(l_signal)
ll_idx_phi.append(l_idx_phi)
ll_nan_circadian_factor.append(l_nan_circadian_factor)
#get remaining trace
ll_signal_tot.append(ll_signal)
ll_idx_phi_tot.append(ll_idx_phi)
ll_nan_circadian_factor_tot.append(ll_nan_circadian_factor)
ll_obs_phi_tot.append( buildObsPhiFromIndex(ll_idx_phi) )
zp = zip(ll_signal_tot, ll_obs_phi_tot, ll_nan_circadian_factor_tot)
for ll_signal, ll_obs_phi, ll_nan_circadian_factor in zp:
### INITIALIZE AND RUN HMM ###
l_var = [theta_var_coupled, amplitude_var, background_var]
hmm = HMM_SemiCoupled(l_var, ll_signal, sigma_em_circadian,
ll_val_phi = ll_obs_phi, waveform = W ,
ll_nan_factor = ll_nan_circadian_factor,
pi = pi, crop = True )
(l_gamma_0_temp, l_gamma_temp ,l_logP_temp, ll_alpha, ll_beta,
l_E, ll_cnorm, ll_idx_phi_hmm_temp, ll_signal_hmm_temp,
ll_nan_circadian_factor_hmm_temp) = hmm.run_em()
#crop and create ll_mat_TR
ll_signal_hmm_cropped_temp = [[s for s, idx in zip(l_s, l_idx) \
if idx>-1]\
for l_s, l_idx \
in zip(ll_signal_hmm_temp,
ll_idx_phi_hmm_temp)]
ll_idx_phi_hmm_cropped_temp = [[idx for idx in l_idx if idx>-1]\
for l_idx in ll_idx_phi_hmm_temp]
ll_mat_TR = [np.array( [theta_var_coupled.TR[:,idx_phi,:] \
for idx_phi in l_idx_obs_phi]) for l_idx_obs_phi \
in ll_idx_phi_hmm_cropped_temp]
l_jP_phase_temp, l_jP_amplitude_temp,l_jP_background_temp \
= EM.compute_jP_by_block(ll_alpha, l_E, ll_beta, ll_mat_TR,
amplitude_var.TR, background_var.TR,
N_theta, N_amplitude_theta,
N_background_theta, only_F_and_pi)
l_jP_phase.extend(l_jP_phase_temp)
l_jP_amplitude.extend(l_jP_amplitude_temp)
l_jP_background.extend(l_jP_background_temp)
l_gamma.extend(l_gamma_temp)
l_logP.extend(l_logP_temp)
l_gamma_0.extend(l_gamma_0_temp)
ll_signal_hmm.extend(ll_signal_hmm_temp)
ll_idx_phi_hmm.extend(ll_idx_phi_hmm_temp)
ll_nan_circadian_factor_hmm.extend(
ll_nan_circadian_factor_hmm_temp)
t_l_jP = (l_jP_phase, l_jP_amplitude,l_jP_background)
### REMOVE BAD TRACES IF FIRST ITERATION###
if it==0:
Plim = np.percentile(l_logP, 10)
#Plim = -10000
for idx_trace, P in enumerate(l_logP):
if P<=Plim:
l_idx_to_remove.append(idx_trace)
for index in sorted(l_idx_to_remove, reverse=True):
del t_l_jP[0][index]
del t_l_jP[1][index]
del t_l_jP[2][index]
del l_gamma[index]
del l_logP[index]
del l_gamma_0[index]
del ll_signal_hmm[index]
del ll_idx_phi_hmm[index]
del ll_nan_circadian_factor_hmm[index]
ll_signal_hmm_clean = copy.deepcopy(ll_signal_hmm)
ll_idx_phi_hmm_clean = copy.deepcopy(ll_idx_phi_hmm)
ll_nan_circadian_factor_hmm_clean \
= copy.deepcopy(ll_nan_circadian_factor_hmm)
### PARAMETERS UPDATE ###
[F_up, pi_up, std_theta_up, sigma_em_circadian_up, ll_coef,
std_amplitude_theta_up, std_background_theta_up, mu_amplitude_theta_up,
mu_background_theta_up, W_up] = EM.run_EM(l_gamma_0, l_gamma,
t_l_jP, theta_var_coupled, ll_idx_phi_hmm,
F, ll_signal_hmm, amplitude_var,
background_var, W,
ll_idx_coef = F_no_coupling,
only_F_and_pi = only_F_and_pi,
lambd_parameter = lambda_parameter,
lambd_2_parameter = lambda_2_parameter)
if np.mean(l_logP)-lP<10**-9:
print("diff:", np.mean(l_logP)-lP)
print(print("average lopP:", np.mean(l_logP)))
break
else:
lP = np.mean(l_logP)
print("average lopP:", lP)
l_lP.append(lP)
### CHOOSE NEW PARAMETERS ###
F = F_up
pi_up = pi
l_parameters = [dt, sigma_em_circadian, W, pi,
N_theta, std_theta, period_theta, l_boundaries_theta, w_theta,
N_phi, std_phi, period_phi, l_boundaries_phi, w_phi,
N_amplitude_theta, mu_amplitude_theta, std_amplitude_theta,
gamma_amplitude_theta, l_boundaries_amplitude_theta,
N_background_theta, mu_background_theta, std_background_theta,
gamma_background_theta, l_boundaries_background_theta,
F]
theta_var_coupled, amplitude_var, background_var = \
create_hidden_variables(l_parameters = l_parameters)
### PLOT COUPLING FUNCTION ###
plt.pcolormesh(theta_var_coupled.domain, theta_var_coupled.codomain,
F.T, cmap=bwr, vmin=-0.3, vmax=0.3)
plt.xlim([0, 2*np.pi])
plt.ylim([0, 2*np.pi])
plt.colorbar()
plt.xlabel("theta")
plt.ylabel("phi")
plt.show()
plt.close()
plt.plot(l_lP)
#plt.savefig("../Parameters/Real/opt_parameters_div_"+str(temperature)
#+"_"+cell+'_'+str(T_cell_cycle)+'.pdf')
plt.show()
plt.close()
##################### PLOT FINAL COUPLING ##################
def add_colorbar(im, aspect=20, pad_fraction=0.5, **kwargs):
###Add a vertical color bar to an image plot.###
divider = axes_grid1.make_axes_locatable(im.axes)
width = axes_grid1.axes_size.AxesY(im.axes, aspect=1./aspect)
pad = axes_grid1.axes_size.Fraction(pad_fraction, width)
current_ax = plt.gca()
cax = divider.append_axes("right", size=width, pad=pad)
plt.sca(current_ax)
return im.axes.figure.colorbar(im, cax=cax, **kwargs)
plt.figure(figsize=(5*1.2,5*1.2))
im = plt.imshow(F.T, cmap=bwr, vmin=-0.3, vmax=0.3,
interpolation='spline16', origin='lower',
extent=[0, 2*np.pi,0, 2*np.pi])
add_colorbar(im, label = r'Acceleration ($rad.h^{-1}$)')
plt.xlabel(r'Circadian phase $\theta$')
plt.ylabel(r'Cell-cycle phase $\phi$')
#plt.colorbar()
plt.xlabel(r'$\theta$')
plt.ylabel(r'$\phi$')
plt.title('T = ' + str(temperature))
plt.tight_layout()
plt.savefig("../Results/PhaseSpace/Coupling_"+str(temperature)\
+"_"+cell+'_demoind.pdf')
plt.close()
##################### PLOT PHASE SPACE DENSITY ##################
plot_phase_space_density(l_var, l_gamma, ll_idx_phi_tot_flat,
F_superimpose = None, save = True, cmap = bwr,
temperature = temperature, cell = cell,
period = T_cell_cycle,
folder = '../Results/PhaseSpace/' )
path = "../Results/PhaseSpace/Coupling_"+str(temperature)+"_"\
+cell+'_demoind.p'
with open(path, 'wb') as f:
pickle.dump(F, f)
def test_sigma_theta(cell='NIH3T3',
temperature=37,
nb_traces=500,
size_block=100):
"""
Compute how the diffusion coefficient (inferred) evolves with the phase.
Parameters
----------
cell : string
Cell condition.
temperature : integer
Temperature condition.
nb_traces : integer
How many traces to run the experiment on.
size_block : integer
Size of the traces chunks (to save memory).
"""
##################### LOAD OPTIMIZED PARAMETERS ##################
path = '../Parameters/Real/opt_parameters_div_'+str(temperature)+"_"\
+cell+'.p'
with open(path, 'rb') as f:
l_parameters = [
dt, sigma_em_circadian, W, pi, N_theta, std_theta, period_theta,
l_boundaries_theta, w_theta, N_phi, std_phi, period_phi,
l_boundaries_phi, w_phi, N_amplitude_theta, mu_amplitude_theta,
std_amplitude_theta, gamma_amplitude_theta,
l_boundaries_amplitude_theta, N_background_theta,
mu_background_theta, std_background_theta, gamma_background_theta,
l_boundaries_background_theta, F
] = pickle.load(f)
##################### DISPLAY PARAMETERS ##################
display_parameters_from_file(path, show=False)
##################### LOAD DATA ##################
if cell == 'NIH3T3':
path = "../Data/NIH3T3.ALL.2017-04-04/ALL_TRACES_INFORMATION.p"
else:
path = "../Data/U2OS-2017-03-20/ALL_TRACES_INFORMATION_march_2017.p"
dataClass = LoadData(path,
nb_traces,
temperature=None,
division=True,
several_cell_cycles=False,
remove_odd_traces=True)
(ll_area_tot_flat, ll_signal_tot_flat, ll_nan_circadian_factor_tot_flat,
ll_obs_phi_tot_flat, T_theta, T_phi) = dataClass.load()
print(len(ll_signal_tot_flat), " traces kept")
##################### SPECIFY F OPTIMIZATION CONDITIONS ##################
#makes algorithm go faster
only_F_and_pi = True
##################### CREATE HIDDEN VARIABLES ##################
theta_var_coupled, amplitude_var, background_var \
= create_hidden_variables(l_parameters = l_parameters)
##################### CREATE BLOCK OF TRACES ##################
ll_area_tot = []
ll_signal_tot = []
ll_nan_circadian_factor_tot = []
ll_obs_phi_tot = []
first = True
zp = enumerate(
zip(ll_area_tot_flat, ll_signal_tot_flat,
ll_nan_circadian_factor_tot_flat, ll_obs_phi_tot_flat))
for index, (l_area, l_signal, l_nan_circadian_factor, l_obs_phi) in zp:
if index % size_block == 0:
if not first:
ll_area_tot.append(ll_area)
ll_signal_tot.append(ll_signal)
ll_nan_circadian_factor_tot.append(ll_nan_circadian_factor)
ll_obs_phi_tot.append(ll_obs_phi)
else:
first = False
ll_area = [l_area]
ll_signal = [l_signal]
ll_nan_circadian_factor = [l_nan_circadian_factor]
ll_obs_phi = [l_obs_phi]
else:
ll_area.append(l_area)
ll_signal.append(l_signal)
ll_nan_circadian_factor.append(l_nan_circadian_factor)
ll_obs_phi.append(l_obs_phi)
#get remaining trace
ll_area_tot.append(ll_area)
ll_signal_tot.append(ll_signal)
ll_nan_circadian_factor_tot.append(ll_nan_circadian_factor)
ll_obs_phi_tot.append(ll_obs_phi)
##################### OPTIMIZATION ##################
l_jP_phase = []
l_jP_amplitude = []
l_jP_background = []
l_gamma = []
l_gamma_0 = []
l_logP = []
ll_signal_hmm = []
ll_idx_phi_hmm = []
ll_nan_circadian_factor_hmm = []
for ll_signal, ll_obs_phi, ll_nan_circadian_factor in zip(
ll_signal_tot, ll_obs_phi_tot, ll_nan_circadian_factor_tot):
### INITIALIZE AND RUN HMM ###
l_var = [theta_var_coupled, amplitude_var, background_var]
hmm = HMM_SemiCoupled(l_var,
ll_signal,
sigma_em_circadian,
ll_val_phi=ll_obs_phi,
waveform=W,
ll_nan_factor=ll_nan_circadian_factor,
pi=pi,
crop=True)
(l_gamma_0_temp, l_gamma_temp, l_logP_temp, ll_alpha, ll_beta, l_E,
ll_cnorm, ll_idx_phi_hmm_temp, ll_signal_hmm_temp,
ll_nan_circadian_factor_hmm_temp) = hmm.run_em()
#crop and create ll_mat_TR
ll_signal_hmm_cropped_temp =[[s for s, idx in zip(l_s, l_idx) if idx>-1]\
for l_s, l_idx in zip(ll_signal_hmm_temp ,ll_idx_phi_hmm_temp)]
ll_idx_phi_hmm_cropped_temp = [ [idx for idx in l_idx if idx>-1] \
for l_idx in ll_idx_phi_hmm_temp ]
ll_mat_TR = [np.array( [theta_var_coupled.TR[:,idx_phi,:] for idx_phi \
in l_idx_obs_phi]) for l_idx_obs_phi in ll_idx_phi_hmm_cropped_temp]
### PLOT TRACE EXAMPLE ###
zp = zip(enumerate(ll_signal_hmm_cropped_temp), l_gamma_temp,
l_logP_temp)
for (idx, signal), gamma, logP in zp:
plt_result = PlotResults(gamma,
l_var,
signal_model,
signal,
waveform=W,
logP=None,
temperature=temperature,
cell=cell)
plt_result.plotEverythingEsperance(False, idx)
if idx == 0:
break
l_jP_phase_temp, l_jP_amplitude_temp,l_jP_background_temp \
= EM.compute_jP_by_block(ll_alpha, l_E, ll_beta, ll_mat_TR,
amplitude_var.TR, background_var.TR,
N_theta, N_amplitude_theta,
N_background_theta, only_F_and_pi)
l_jP_phase.extend(l_jP_phase_temp)
l_jP_amplitude.extend(l_jP_amplitude_temp)
l_jP_background.extend(l_jP_background_temp)
l_gamma.extend(l_gamma_temp)
l_logP.extend(l_logP_temp)
l_gamma_0.extend(l_gamma_0_temp)
ll_signal_hmm.extend(ll_signal_hmm_temp)
ll_idx_phi_hmm.extend(ll_idx_phi_hmm_temp)
ll_nan_circadian_factor_hmm.extend(ll_nan_circadian_factor_hmm_temp)
##################### COMPUTE SIGMA(THETA) ##################
l_mean = []
l_std = []
dic_phase = {}
theta_domain = theta_var_coupled.domain
for idx_theta in range(N_theta):
dic_phase[idx_theta] = []
for jP, ll_idx_obs_phi_trace in zip(l_jP_phase, ll_idx_phi_hmm):
for t, jPt in enumerate(jP):
for idx_theta_i, theta_i in enumerate(theta_domain):
norm = np.sum(jPt[idx_theta_i])
if norm == 0:
continue
jPt_i_norm = jPt[idx_theta_i] / norm
theta_dest = theta_i + (
w_theta + F[idx_theta_i, ll_idx_obs_phi_trace[t]]) * dt
var = 0
for idx_theta_k, theta_k in enumerate(theta_domain):
var+= (min( abs( theta_dest - theta_k ),
abs( theta_dest - (theta_k+2*np.pi) ) ,
abs( theta_dest - (theta_k-2*np.pi) ) )**2) \
*jPt_i_norm[idx_theta_k]
dic_phase[idx_theta_i].append((var, norm))
for idx_theta in range(N_theta):
p_theta = np.sum([tupl[1] for tupl in dic_phase[idx_theta]])
sigma_theta = np.sum( [ (p_theta_t * sigma_theta_t)/p_theta \
for (p_theta_t, sigma_theta_t) in dic_phase[idx_theta] ])
var_sigma_theta = np.sum( [ (sigma_theta_t-sigma_theta)**2*p_theta_t \
/p_theta \
for (p_theta_t, sigma_theta_t) in dic_phase[idx_theta] ])
l_mean.append(sigma_theta)
l_std.append(var_sigma_theta**0.5)
plt.errorbar(theta_domain / (2 * np.pi), l_mean, yerr=l_std, fmt='o')
plt.xlabel(r"Circadian phase $\theta$")
plt.ylabel(r"Phase diffusion SD[$\theta$]")
plt.tight_layout()
plt.savefig('../Results/Correlation/Diffusion_'+cell+'_'\
+str(temperature)+'.pdf')
plt.show()
plt.close()