def plotPathList(paths):
global ax
paths = list(paths)
print(paths)
fit_data = []
data_list = []
for index, file in enumerate(paths):
output_file = Path(str(file).replace("_result.txt", "_evaluated.csv"))
# load the data and the config
data = getData(file)
config = getConfig(file)
""" evaluating data"""
if not output_file.exists():
#refetchTimestamps(data, config)
getVelocity(data, config)
# take the mean of all values of each cell
data = data.groupby(['cell_id']).mean()
correctCenter(data, config)
data = filterCells(data, config)
# reset the indices
data.reset_index(drop=True, inplace=True)
getStressStrain(data, config)
#data = data[(data.stress < 50)]
data.reset_index(drop=True, inplace=True)
data["area"] = data.long_axis * data.short_axis * np.pi
data.to_csv(output_file, index=False)
data = pd.read_csv(output_file)
#data = data[(data.area > 0) * (data.area < 2000) * (data.stress < 250)]
#data.reset_index(drop=True, inplace=True)
data_list.append(data)
data = pd.concat(data_list)
data.reset_index(drop=True, inplace=True)
fitStiffness(data, config)
plotDensityScatter(data.stress, data.strain)
#plotStressStrainFit(data, config)
plotBinnedData(data.stress, data.strain,
[0, 10, 20, 30, 40, 50, 75, 100, 125, 150, 200, 250])
#plt.title(f'{config["fit"]["p"][0] * config["fit"]["p"][1]:.2f}')
fit_data.append(config["fit"]["p"][0] * config["fit"]["p"][1])
return fit_data
(v / (np.pi * 2 * config["imaging_pos_mm"])))**p[1])
return k
for i in range(3):
data, config = position_list[i]
plt.subplot(1, 3, 1 + i)
k = get_k(data, config)
#plotStressStrain(data, config)
plotDensityScatter(np.abs(data.rp), k, skip=1, y_factor=0.33)
plotBinnedData(np.abs(data.rp),
k,
np.arange(0, 90, 10),
bin_func=np.median,
error_func="quantiles")
plt.xlim(0, 100)
plt.ylim(0, 200)
#% start: automatic generated code from pylustrator
plt.figure(1).ax_dict = {ax.get_label(): ax for ax in plt.figure(1).axes}
import matplotlib as mpl
plt.figure(1).set_size_inches(16.250000 / 2.54, 5.000000 / 2.54, forward=True)
plt.figure(1).axes[0].set_position([0.124970, 0.226507, 0.245158, 0.648012])
plt.figure(1).axes[0].set_ylim(0.0, 220.0)
plt.figure(1).axes[0].set_yticklabels(["0", "50", "100", "150", "200"],
fontsize=10.0,
fontweight="normal",
datafile = getInputFile(filetype="csv file (*_evaluated_new.csv)", settings_name=settings_name, video=file)
print("evaluate file", datafile)
# load the data and the config
data, config = load_all_data_new(datafile)
plt.figure(0, (10, 8))
plt.subplot(2, 3, 1)
plt.cla()
plot_velocity_fit(data)
plt.text(0.9, 0.9, f"$\\eta_0$ {data.eta0[0]:.2f}\n$\\delta$ {data.delta[0]:.2f}\n$\\tau$ {data.tau[0]:.2f}", transform=plt.gca().transAxes, va="top", ha="right")
plt.subplot(2, 3, 2)
plt.cla()
plotDensityScatter(data.stress, data.epsilon)
plotBinnedData(data.stress, data.epsilon, bins=np.arange(0, 300, 10))
plt.xlabel("stress (Pa)")
plt.ylabel("strain")
plt.subplot(2, 3, 3)
plt.cla()
plotDensityScatter(data.rp, data.angle)
plotBinnedData(data.rp, data.angle, bins=np.arange(-300, 300, 10))
plt.xlabel("radial position (µm)")
plt.ylabel("angle (deg)")
plt.subplot(2, 3, 4)
plt.loglog(data.omega, data.Gp1, "o", alpha=0.25)
plt.loglog(data.omega, data.Gp2, "o", alpha=0.25)
plt.ylabel("G' / G''")
plt.xlabel("angular frequency")
def selected(self, name):
plt.clf()
if name.endswith(".tif"):
data, config = load_all_data_new(name.replace(
".tif", "_evaluated_new.csv"),
do_excude=False)
def get_mode_stats(x):
from scipy import stats
from deformationcytometer.evaluation.helper_functions import bootstrap_error
x = np.array(x)
print("a", x.shape)
if len(x.shape) == 1:
x = x[~np.isnan(x)]
print("b", x.shape)
def get_mode(x):
kde = stats.gaussian_kde(x)
print(x.shape)
print(np.argmax(kde(x)))
return x[..., np.argmax(kde(x))]
mode = get_mode(x)
# err = bootstrap_error(x, get_mode, repetitions=2)
return mode
from scipy.special import gamma
def fit(omega, k, alpha):
omega = np.array(omega)
G = k * (1j * omega)**alpha * gamma(1 - alpha)
return np.real(G), np.imag(G)
def cost(p):
Gp1, Gp2 = fit(data.omega_weissenberg, *p)
#return np.sum(np.abs(np.log10(data.w_Gp1) - np.log10(Gp1))) + np.sum(
# np.abs(np.log10(data.w_Gp2) - np.log10(Gp2)))
return np.sum(
(np.log10(data.w_Gp1) - np.log10(Gp1))**2) + np.sum(
(np.log10(data.w_Gp2) - np.log10(Gp2))**2)
from scipy.optimize import minimize
res = minimize(
cost,
[np.median(data.w_k_cell),
np.mean(data.w_alpha_cell)]) #, bounds=([0, np.inf], [0, 1]))
print(res)
pair_median_mean = [
np.median(data.w_k_cell),
np.mean(data.w_alpha_cell)
]
pair_fit = [res.x[0], res.x[1]]
pair_2dmode = get_mode_stats(
[np.log10(data.w_k_cell), data.w_alpha_cell])
pair_2dmode[0] = 10**pair_2dmode[0]
print("pair_median_mean", pair_median_mean)
print("pair_fit", pair_fit)
print("pair_2dmode", pair_2dmode)
plt.subplot(3, 3, 1)
plot_velocity_fit(data)
if "vel_fit_error" in data.iloc[0]:
plt.text(0.8,
0.8,
f'{data.iloc[0]["vel_fit_error"]:.0f}',
transform=plt.gca().transAxes)
plt.subplot(3, 3, 2)
plt.axline([0, 0], slope=1, color="k")
plt.plot(data.omega, data.omega_weissenberg, "o", ms=1)
plt.xlabel("omega")
plt.ylabel("omega weissenberg")
plt.subplot(3, 3, 3)
plotDensityScatter(data.stress, data.epsilon)
plotBinnedData(data.stress,
data.epsilon,
bins=np.arange(0, 300, 10))
plt.xlabel("stress (Pa)")
plt.ylabel("strain")
plt.subplot(3, 3, 4)
plt.loglog(data.omega_weissenberg,
data.w_Gp1,
"o",
alpha=0.25,
ms=1)
plt.loglog(data.omega_weissenberg,
data.w_Gp2,
"o",
alpha=0.25,
ms=1)
xx = [
10**np.floor(np.log10(np.min(data.w_Gp1))),
10**np.ceil(np.log10(np.max(data.w_Gp1)))
]
plt.plot(xx, fit(xx, *pair_fit)[0], "k-", lw=0.8)
plt.plot(xx, fit(xx, *pair_fit)[1], "k--", lw=0.8)
plt.plot(xx, fit(xx, *pair_median_mean)[0], "r-", lw=0.8)
plt.plot(xx, fit(xx, *pair_median_mean)[1], "r--", lw=0.8)
plt.plot(xx, fit(xx, *pair_2dmode)[0], "c-", lw=0.8)
plt.plot(xx, fit(xx, *pair_2dmode)[1], "c--", lw=0.8)
plt.ylabel("G' / G''")
plt.xlabel("angular frequency")
logk, a = get_mode_stats(
[np.log10(data.w_k_cell), data.w_alpha_cell])
plt.subplot(3, 3, 5)
plt.cla()
plt.xlim(0, 4)
plot_density_hist(np.log10(data.w_k_cell), color="C0")
plt.axvline(np.log10(pair_fit[0]), color="k")
plt.axvline(np.log10(pair_median_mean[0]), color="r")
plt.axvline(np.log10(pair_2dmode[0]), color="c")
plt.xlabel("log10(k)")
plt.ylabel("relative density")
plt.text(
0.9,
0.9,
f"mean(log10(k)) {np.mean(np.log10(data.w_k_cell)):.2f}\nstd(log10(k)) {np.std(np.log10(data.w_k_cell)):.2f}\nmean(k) {np.mean(data.k_cell):.2f}\nstd(k) {np.std(data.k_cell):.2f}\n",
transform=plt.gca().transAxes,
va="top",
ha="right")
plt.subplot(3, 3, 6)
plt.cla()
plt.xlim(0, 1)
plot_density_hist(data.w_alpha_cell, color="C1")
plt.xlabel("alpha")
plt.axvline(pair_fit[1], color="k")
plt.axvline(pair_median_mean[1], color="r")
plt.axvline(pair_2dmode[1], color="c")
plt.text(
0.9,
0.9,
f"mean($\\alpha$) {np.mean(data.w_alpha_cell):.2f}\nstd($\\alpha$) {np.std(data.w_alpha_cell):.2f}\n",
transform=plt.gca().transAxes,
va="top",
ha="right")
plt.subplot(3, 3, 7)
plt.cla()
plotDensityScatter(np.log10(data.w_k_cell), data.w_alpha_cell)
plt.axvline(np.log10(pair_fit[0]), color="k")
plt.axhline(pair_fit[1], color="k", label="fit")
plt.axvline(np.log10(pair_median_mean[0]), color="r")
plt.axhline(pair_median_mean[1], color="r", label="median")
plt.axvline(np.log10(pair_2dmode[0]), color="c")
plt.axhline(pair_2dmode[1], color="c", label="2dmode")
plt.legend()
print("doublemode",
get_mode_stats([np.log10(data.w_k_cell), data.w_alpha_cell]))
plt.xlim(1, 3)
plt.ylim(0, .5)
plt.tight_layout()
#plt.plot(data.rp, data.vel)
""""""
from deformationcytometer.includes.RoscoeCoreInclude import getRatio
from deformationcytometer.includes.fit_velocity import getFitXYDot
eta0 = data.iloc[0].eta0
alpha = data.iloc[0].delta
tau = data.iloc[0].tau
pressure = data.iloc[0].pressure
def func(x, a, b):
return x / 2 * 1 / (1 + a * x**b)
def getFitLine(pressure, p):
config = {
"channel_length_m": 5.8e-2,
"channel_width_m": 186e-6
}
x, y = getFitXYDot(config, np.mean(pressure), p)
return x, y
channel_pos, vel_grad = getFitLine(pressure, [eta0, alpha, tau])
vel_grad = -vel_grad
vel_grad = vel_grad[channel_pos > 0]
channel_pos = channel_pos[channel_pos > 0]
omega = func(np.abs(vel_grad), *[0.113, 0.45])
import scipy
k_cell, alpha_cell = pair_fit
mu1_ = k_cell * omega**alpha_cell * scipy.special.gamma(
1 - alpha_cell) * np.cos(np.pi / 2 * alpha_cell)
eta1_ = k_cell * omega**alpha_cell * scipy.special.gamma(
1 - alpha_cell) * np.sin(np.pi / 2 * alpha_cell) / omega
ratio, alpha1, alpha2, strain, stress, theta, ttfreq, eta, vdot = getRatio(
eta0, alpha, tau, vel_grad, mu1_, eta1_)
plt.subplot(3, 3, 3)
plt.plot(stress, strain, "-k")
k_cell, alpha_cell = pair_median_mean
mu1_ = k_cell * omega**alpha_cell * scipy.special.gamma(
1 - alpha_cell) * np.cos(np.pi / 2 * alpha_cell)
eta1_ = k_cell * omega**alpha_cell * scipy.special.gamma(
1 - alpha_cell) * np.sin(np.pi / 2 * alpha_cell) / omega
ratio, alpha1, alpha2, strain, stress, theta, ttfreq, eta, vdot = getRatio(
eta0, alpha, tau, vel_grad, mu1_, eta1_)
plt.subplot(3, 3, 3)
plt.plot(stress, strain, "-r")
k_cell, alpha_cell = pair_2dmode
mu1_ = k_cell * omega**alpha_cell * scipy.special.gamma(
1 - alpha_cell) * np.cos(np.pi / 2 * alpha_cell)
eta1_ = k_cell * omega**alpha_cell * scipy.special.gamma(
1 - alpha_cell) * np.sin(np.pi / 2 * alpha_cell) / omega
ratio, alpha1, alpha2, strain, stress, theta, ttfreq, eta, vdot = getRatio(
eta0, alpha, tau, vel_grad, mu1_, eta1_)
plt.subplot(3, 3, 3)
plt.plot(stress, strain, "-c")
self.canvas.draw()
position_list = []
for position in ["inlet", "middle", "outlet"]:
pressure = 3
data, config = load_all_data([
fr"\\131.188.117.96\biophysDS\emirzahossein\microfluidic cell rhemeter data\microscope4\2020_july\2020_07_29_aslginate2%_NIH_diff_x_position_2\{position}\[0-9]\*_result.txt",
fr"\\131.188.117.96\biophysDS\emirzahossein\microfluidic cell rhemeter data\microscope4\2020_july\2020_07_29_aslginate2%_NIH_diff_x_position_3\{position}\[0-9]\*_result.txt",
], pressure=pressure)
position_list.append([data, config])
for i in range(3):
data, config = position_list[i]
plt.subplot(2, 3, 1+i)
plt.title(["inlet", "middle", "outlet"][i])
plotDensityScatter(np.abs(data.rp), np.log10(data.k_cell), skip=1, y_factor=0.33)
plotBinnedData(np.abs(data.rp), np.log10(data.k_cell), np.arange(0, 90, 10), bin_func=np.median, error_func="quantiles")
plt.subplot(2, 3, 3+1+i)
plotDensityScatter(np.abs(data.rp), data.alpha_cell, skip=1, y_factor=0.33)
plotBinnedData(np.abs(data.rp), data.alpha_cell, np.arange(0, 90, 10), bin_func=np.median, error_func="quantiles")
#% start: automatic generated code from pylustrator
plt.figure(1).ax_dict = {ax.get_label(): ax for ax in plt.figure(1).axes}
import matplotlib as mpl
plt.figure(1).set_size_inches(16.250000/2.54, 8.000000/2.54, forward=True)
plt.figure(1).axes[0].set_xlim(-4.183295591939136, 88.04517013968203)
plt.figure(1).axes[0].set_ylim(1.0, 3.0)
plt.figure(1).axes[0].set_yticks([1.0, 2.0, 3.0])
plt.figure(1).axes[0].set_xticklabels([])
plt.figure(1).axes[0].set_yticklabels(["1.0", "2.0", "3.0"], fontsize=10.0, fontweight="normal", color="black", fontstyle="normal", fontname="Arial", horizontalalignment="right")
print("data0.beta.loc[i]", data0.beta)
xx = np.array([getTorque(data0.a.loc[i]/data0.r.loc[i], data0.b.loc[i]/data0.r.loc[i], data0.beta.loc[i]/180*np.pi) for i in data0.index])
individual_slope = -data0.freq / data0.grad
p, = plt.plot(x, individual_slope, "o", ms=2)
#plotBinnedData(x, individual_slope, np.arange(0, 1, 0.1), color=p.get_color())
plt.xlabel("$\\frac{b}{r_0}$")
plt.ylabel("slope $\\frac{f}{\dot \gamma}$")
plt.ylim(0, 0.1)
plt.xlim(0.6, 1)
xl.extend(x)
yl.extend(individual_slope)
xf, yf = plotBinnedData(xl, yl, np.arange(0, 1, 0.05))
index = ~np.isnan(xf) & ~np.isnan(yf)
xf = xf[index]
yf = yf[index]
def curve(x, a):
return 1/(np.pi*4) * x **a
import scipy.optimize
if 0:
p, popt = scipy.optimize.curve_fit(curve, xf, yf)
x = np.arange(0.5, 1, 0.01)
plt.plot(x, curve(x, *p), "-k")
plt.show()
"#d40000",
"#b00038",
]
for index, pressure in enumerate([1, 2, 3]):
ax = plt.subplot(2, 3, index+1)
data = data_list[index]
config = config_list[index]
plotDensityScatter(data.rp, data.strain)
ax = plt.subplot(2, 3, 3+index+1)
plotDensityScatter(data.stress, data.strain)
for i in range(3):
if i != index:
plotBinnedData(data_list[i].stress, data_list[i].strain, ranges[i], error_func="quantiles", alpha=0.5, mec="none", mfc=colors[i])
plotBinnedData(data.stress, data.strain, ranges[index], error_func="quantiles", mfc=colors[index])
numbers.append(len(data.rp))
print(config)
print("numbers", numbers)
#% start: automatic generated code from pylustrator
plt.figure(1).ax_dict = {ax.get_label(): ax for ax in plt.figure(1).axes}
import matplotlib as mpl
plt.figure(1).set_size_inches(16.260000/2.54, 10.890000/2.54, forward=True)
plt.figure(1).axes[0].set_xlim(-90.22751034357464, 89.45098813781398)
plt.figure(1).axes[0].set_ylim(-0.05093250462193348, 1.156151079632439)
plt.figure(1).axes[0].set_position([0.111408, 0.621312, 0.269192, 0.340314])
plt.figure(1).axes[0].spines['right'].set_visible(False)
plt.figure(1).axes[0].spines['top'].set_visible(False)