def method(ts,
time=None,
step=0,
show=True,
save=False,
latex=False,
**kwargs):
""" Plot at given timestep using matplotlib. """
info_cyan("Plotting at given time/step using Matplotlib.")
if time is not None:
step, time = get_step_and_info(ts, time)
if rank == 0:
for field in ts.fields:
if save:
save_fig_file = os.path.join(
ts.plots_folder, "{}_{:06d}.png".format(field, step))
else:
save_fig_file = None
plot_any_field(ts.nodes,
ts.elems,
ts[field, step],
save=save_fig_file,
show=show,
label=field,
latex=latex)
def method(ts, time=None, step=0, **kwargs):
""" Plot at given time/step using dolfin. """
info_cyan("Plotting at given timestep using Dolfin.")
step, time = get_step_and_info(ts, time)
f = ts.functions()
for field in ts.fields:
ts.update(f[field], field, step)
df.plot(f[field])
df.interactive()
def method(ts, time=None, step=0, **kwargs):
""" Plot at given time/step using dolfin. """
info_cyan("Plotting at given timestep using Dolfin.")
step, time = get_step_and_info(ts, time)
f = ts.functions()
for i, field in enumerate(ts.fields):
ts.update(f[field], field, step)
plt.figure(i)
df.plot(f[field], title=field)
plt.show()
def method(ts, time=None, step=0, show=False, save_fig=False, **kwargs):
""" Compare to analytic reference expression at given timestep.
This is done by importing the function "reference" in the problem module.
"""
info_cyan("Comparing to analytic reference at given time or step.")
step, time = get_step_and_info(ts, time, step)
parameters = ts.get_parameters(time=time)
problem = parameters.get("problem", "intrusion_bulk")
try:
module = importlib.import_module("problems.{}".format(problem))
reference = module.reference
except:
info_error("No analytic reference available.")
ref_exprs = reference(t=time, **parameters)
info("Comparing to analytic solution.")
info_split("Problem:", "{}".format(problem))
info_split("Time:", "{}".format(time))
f = ts.functions(ref_exprs.keys())
err = dict()
f_int = dict()
f_ref = dict()
for field in ref_exprs.keys():
el = f[field].function_space().ufl_element()
degree = el.degree()
if bool(el.value_size() != 1):
W = df.VectorFunctionSpace(ts.mesh, "CG", degree + 3)
else:
W = df.FunctionSpace(ts.mesh, "CG", degree + 3)
err[field] = df.Function(W)
f_int[field] = df.Function(W)
f_ref[field] = df.Function(W)
for field, ref_expr in ref_exprs.items():
ref_expr.t = time
# Update numerical solution f
ts.update(f[field], field, step)
# Interpolate f to higher space
f_int[field].assign(
df.interpolate(f[field], f_int[field].function_space()))
# Interpolate f_ref to higher space
f_ref[field].assign(
df.interpolate(ref_expr, f_ref[field].function_space()))
err[field].vector()[:] = (f_int[field].vector().get_local() -
f_ref[field].vector().get_local())
if show or save_fig:
# Interpolate the error to low order space for visualisation.
err_int = df.interpolate(err[field], f[field].function_space())
err_arr = ts.nodal_values(err_int)
label = "Error in " + field
if rank == 0:
save_fig_file = None
if save_fig:
save_fig_file = os.path.join(
ts.plots_folder,
"error_{}_time{}_analytic.png".format(field, time))
plot_any_field(ts.nodes,
ts.elems,
err_arr,
save=save_fig_file,
show=show,
label=label)
save_file = os.path.join(ts.analysis_folder,
"errornorms_time{}_analytic.dat".format(time))
compute_norms(err, save=save_file)
def main():
parser = argparse.ArgumentParser(description="Average various files")
parser.add_argument("-l",
"--list",
nargs="+",
help="List of folders",
required=True)
parser.add_argument("-f",
"--fields",
nargs="+",
default=None,
help="Sought fields")
parser.add_argument("-t", "--time", type=float, default=0, help="Time")
parser.add_argument("--show", action="store_true", help="Show")
parser.add_argument("-R",
"--radius",
type=float,
default=None,
help="Radial distance")
args = parser.parse_args()
tss = []
for folder in args.list:
ts = InterpolatedTimeSeries(folder, sought_fields=args.fields)
tss.append(ts)
Ntss = len(tss)
all_fields_ = []
for ts in tss:
all_fields_.append(set(ts.fields))
all_fields = list(set.intersection(*all_fields_))
if args.fields is None:
fields = all_fields
else:
fields = list(set.intersection(set(args.fields), set(all_fields)))
f_in = []
for ts in tss:
f_in.append(ts.functions())
# Using the first timeseries to define the spaces
# Could be redone to e.g. a finer, structured mesh.
# ref_mesh = tss[0].mesh
ref_spaces = dict([(field, f.function_space())
for field, f in f_in[0].items()])
if "psi" not in fields:
exit("No psi")
var_names = ["t", "s"]
index_names = ["tt", "st", "ss"]
index_numbers = [0, 1, 4]
dim_names = ["x", "y", "z"]
# Loading geometry
rad_t = []
rad_s = []
g_ab = []
gab = []
for ts in tss:
# Should compute these from the curvature tensor
rad_t.append(
df.interpolate(df.Expression("x[0]", degree=2), ts.function_space))
rad_s.append(
df.interpolate(df.Expression("x[1]", degree=2), ts.function_space))
# g_loc = [ts.function(name) for name in ["gtt", "gst", "gss"]]
# g_inv_loc = [ts.function(name) for name in ["g_tt", "g_st", "g_ss"]]
gab_loc = dict([(idx, ts.function("g{}".format(idx)))
for idx in index_names])
g_ab_loc = dict([(idx, ts.function("g_{}".format(idx)))
for idx in index_names])
for idx, ij in zip(index_names, index_numbers):
# for ij in range(3):
# ts.set_val(g_loc[ij], ts.g[:, ij])
# ts.set_val(g_inv_loc[ij], ts.g_inv[:, ij])
ts.set_val(g_ab_loc[idx], ts.g_ab[:, ij])
# Could compute the gab locally instead of loading
ts.set_val(gab_loc[idx], ts.gab[:, ij])
g_ab_loc["ts"] = g_ab_loc["st"]
gab_loc["ts"] = gab_loc["st"]
g_ab.append(g_ab_loc)
gab.append(gab_loc)
costheta = df.Function(ref_spaces["psi"], name="costheta")
for its, (ts, g_ab_loc, gab_loc) in enumerate(zip(tss, g_ab, gab)):
if args.time is not None:
step, time = get_step_and_info(ts, args.time)
g_ab_ = to_vector(g_ab_loc)
gab_ = to_vector(gab_loc)
ts.update(f_in[its]["psi"], "psi", step)
psi = f_in[its]["psi"]
psi_t = df.project(psi.dx(0), ts.function_space)
psi_s = df.project(psi.dx(1), ts.function_space)
gp_t = psi_t.vector().get_local()
gp_s = psi_s.vector().get_local()
# gtt, gst, gss = [g_ij.vector().get_local() for g_ij in g[its]]
# g_tt, g_st, g_ss = [g_ij.vector().get_local() for g_ij in g_inv[its]]
gtt = gab_["tt"]
gst = gab_["ts"]
gss = gab_["ss"]
g_tt = g_ab_["tt"]
g_st = g_ab_["ts"]
g_ss = g_ab_["ss"]
rht = rad_t[its].vector().get_local()
rhs = rad_s[its].vector().get_local()
rh_norm = np.sqrt(g_tt * rht**2 + g_ss * rhs**2 + 2 * g_st * rht * rhs)
gp_norm = np.sqrt(gtt * gp_t**2 + gss * gp_s**2 +
2 * gst * gp_t * gp_s)
costheta_loc = ts.function("costheta")
# abs(cos(theta)):
costheta_loc.vector()[:] = abs(
(rht * gp_t + rhs * gp_s) / (rh_norm * gp_norm + 1e-8))
# cos(theta)**2:
#costheta_loc.vector()[:] = ((rht*gp_t + rhs*gp_s)/(rh_norm*gp_norm+1e-8))**2
# sin(theta):
#costheta_loc.vector()[:] = np.sin(np.arccos((rht*gp_t + rhs*gp_s)/(rh_norm*gp_norm+1e-8)))
# sin(theta)**2:
# costheta_loc.vector()[:] = np.sin(np.arccos((rht*gp_t + rhs*gp_s)/(rh_norm*gp_norm+1e-8)))**2
# abs(theta):
#costheta_loc.vector()[:] = abs(np.arccos((rht*gp_t + rhs*gp_s)/(rh_norm*gp_norm+1e-8)))
costheta_intp = interpolate_nonmatching_mesh(costheta_loc,
ref_spaces["psi"])
costheta.vector()[:] += costheta_intp.vector().get_local() / Ntss
dump_xdmf(costheta)
if args.show:
JET = plt.get_cmap('jet')
RYB = plt.get_cmap('RdYlBu')
RYB_r = plt.get_cmap('RdYlBu_r')
mgm = plt.get_cmap('magma')
fig, ax = plt.subplots()
fig.set_size_inches(4.7, 4.7)
rc('text', usetex=True)
rc('font', **{'family': 'serif', 'serif': ['Palatino']})
# First, dump a hires PNG version of the data:
plot = df.plot(costheta, cmap=mgm)
plt.axis('off')
plt.savefig('anglogram_hires.png',
format="png",
bbox_inches='tight',
pad_inches=0,
dpi=500)
mainfs = 10 # Fontsize
titlefs = 12 # Fontsize
#plt.set_cmap('jet')
#cbar = fig.colorbar(plot, ticks=[0, 0.5, 1], orientation='vertical')
#cbar.ax.set_yticklabels(['Radial', 'Intermediate', 'Azimuthal'])
#cbar = fig.colorbar(plot, ticks=[0, 0.5, 0.95], orientation='horizontal', fraction=0.046, pad=0.04)
#cbar = fig.colorbar(plot, ticks=[0, 0.5, 0.995], orientation='horizontal', fraction=0.046, pad=0.04)
cbar = fig.colorbar(plot,
ticks=[0, 0.5, 0.9995],
orientation='horizontal',
fraction=0.046,
pad=0.04)
cbar.ax.set_xticklabels(['Radial', 'Intermediate', 'Azimuthal'])
#ax.set_title('Stripe orientation -- $\\cos^2(\\theta)$', fontsize=mainfs)
#ax.set_title(r'Stripe orientation -- $\cos^2(\theta)$')
plt.text(0.5,
1.05,
r'Stripe orientation -- $\left\vert\cos(\theta)\right\vert$',
fontsize=titlefs,
horizontalalignment='center',
transform=ax.transAxes)
#ax.set_title('Stripe orientation', fontsize=mainfs)
#plt.text(0.2, 0.2, '$\\textcolor{red}{\\mathbf{p}(u,w,\\xi)}=\\textcolor{blue}{\\tilde{\\mathbf{p}}(u,w)} + \\xi \\tilde{\\mathbf{n}}(u,w)$', fontsize=mainfs)
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
#plt.show()
plt.savefig('anglogram.pdf',
format="pdf",
bbox_inches='tight',
pad_inches=0)
#plt.axis('on')
#ax.get_xaxis().set_visible(True)
#ax.get_yaxis().set_visible(True)
#plt.colorbar(plot)
#plt.show()
if args.radius is not None and args.radius > 0:
Nr, Nphi = 256, 256
r_lin = np.linspace(0., args.radius, Nr)
phi_lin = np.linspace(0, 2 * np.pi, Nphi, endpoint=False)
R, Phi = np.meshgrid(r_lin, phi_lin)
r = R.reshape((Nr * Nphi, 1))
phi = Phi.reshape((Nr * Nphi, 1))
xy = np.hstack((r * np.cos(phi), r * np.sin(phi)))
pts = xy.flatten()
probes = Probes(pts, ref_spaces["psi"])
probes(costheta)
ct = probes.array()
CT = ct.reshape(R.shape)
g_r = CT.mean(axis=0)
g_phi = CT.mean(axis=1)
plt.figure()
plt.plot(r_lin, g_r)
plt.ylabel("g(r)")
plt.xlabel("r")
plt.figure()
plt.plot(phi_lin, g_phi)
plt.xlabel("phi")
plt.ylabel("g(phi)")
plt.show()