def test_compute_gradient():
h5store = 'small_hexagonal.hf5'
datasets = load_datasets(h5store,
data_names=['face', 'vert', 'edge'])
specs = config.geometry.sheet_spec()
sheet = Sheet('emin', datasets, specs)
nondim_specs = config.dynamics.quasistatic_sheet_spec()
dim_model_specs = model.dimentionalize(nondim_specs)
sheet.update_specs(dim_model_specs)
geom.update_all(sheet)
isotropic_relax(sheet, nondim_specs)
nrj_norm_factor = sheet.specs['settings']['nrj_norm_factor']
(grad_t, grad_c,
grad_v_srce, grad_v_trgt) = model.compute_gradient(sheet,
components=True)
grad_t_norm = np.linalg.norm(grad_t, axis=0).sum() / nrj_norm_factor
assert_almost_equal(grad_t_norm, 0.4497370048, decimal=DECIMAL)
grad_c_norm = np.linalg.norm(grad_c, axis=0).sum() / nrj_norm_factor
assert_almost_equal(grad_c_norm, 0.49692791, decimal=DECIMAL)
grad_vs_norm = np.linalg.norm(grad_v_srce.dropna(),
axis=0).sum() / nrj_norm_factor
assert_almost_equal(grad_vs_norm, 0.3028136725, decimal=DECIMAL)
grad_vt_norm = np.linalg.norm(grad_v_trgt.dropna(),
axis=0).sum() / nrj_norm_factor
assert_almost_equal(grad_vt_norm, 0.277320351, decimal=DECIMAL)
def test_sort_eastwest():
datasets = {}
tri_verts = [[0, 0], [1, 0], [-0.5, 3**0.5 / 2], [-0.5, -(3**0.5) / 2]]
tri_edges = [
[0, 1, 0],
[1, 2, 0],
[2, 0, 0],
[0, 3, 1],
[3, 1, 1],
[1, 0, 1],
[0, 2, 2],
[2, 3, 2],
[3, 0, 2],
]
datasets["edge"] = pd.DataFrame(data=np.array(tri_edges),
columns=["srce", "trgt", "face"])
datasets["edge"].index.name = "edge"
datasets["face"] = pd.DataFrame(data=np.zeros((3, 2)), columns=["x", "y"])
datasets["face"].index.name = "face"
datasets["vert"] = pd.DataFrame(data=np.array(tri_verts),
columns=["x", "y"])
datasets["vert"].index.name = "vert"
specs = config.geometry.planar_spec()
eptm = Sheet("extra", datasets, specs, coords=["x", "y"])
PlanarGeometry.update_all(eptm)
eptm.edge_df["opposite"] = get_opposite(eptm.edge_df)
eptm.sort_edges_eastwest()
assert_array_equal(np.asarray(eptm.free_edges), [0, 1, 2])
assert_array_equal(np.asarray(eptm.east_edges), [3, 4, 5])
assert_array_equal(np.asarray(eptm.west_edges), [6, 7, 8])
def test_anchors():
datasets, specs = generation.three_faces_sheet()
sheet = Sheet("test_anchors", datasets, specs)
sheet.edge_df["opposite"] = get_opposite(sheet.edge_df)
expected_dict = {
18: [1, 13],
19: [2, 14],
20: [3, 15],
21: [4, 16],
22: [5, 17],
23: [6, 18],
24: [7, 19],
25: [8, 20],
26: [9, 21],
27: [10, 22],
28: [11, 23],
29: [12, 24],
}
expected_res = pd.DataFrame.from_dict(expected_dict, orient="index")
expected_res.columns = ["srce", "trgt"]
generation.create_anchors(sheet)
res_srce_trgt_anchors = sheet.edge_df.loc[18:, ["srce", "trgt"]]
assert res_srce_trgt_anchors.equals(expected_res)
def test_solver():
h5store = os.path.join(stores_dir, "small_hexagonal.hf5")
datasets = load_datasets(h5store, data_names=["face", "vert", "edge"])
specs = config.geometry.cylindrical_sheet()
sheet = Sheet("emin", datasets, specs)
nondim_specs = config.dynamics.quasistatic_sheet_spec()
dim_model_specs = model.dimensionalize(nondim_specs)
sheet.update_specs(dim_model_specs)
# sheet.vert_df.is_active = 1
# grad_err = solver.check_grad(sheet, geom, model)
# grad_err /= sheet.vert_df.size
# assert_almost_equal(grad_err, 0.0, DECIMAL)
settings = {
"minimize": {
"options": {
"disp": False,
"ftol": 1e-4,
"gtol": 1e-4
}
}
}
res = solver.find_energy_min(sheet, geom, model, **settings)
assert res["success"]
new_solver = QSSolver(with_collisions=True, with_t1=True, with_t3=True)
res = new_solver.find_energy_min(sheet, geom, model,
**settings["minimize"])
assert res["success"]
def test_solver():
h5store = 'small_hexagonal.hf5'
datasets = load_datasets(h5store, data_names=['face', 'vert', 'edge'])
specs = config.geometry.sheet_spec()
sheet = Sheet('emin', datasets, specs)
nondim_specs = config.dynamics.quasistatic_sheet_spec()
dim_model_specs = model.dimentionalize(nondim_specs)
sheet.update_specs(dim_model_specs)
isotropic_relax(sheet, nondim_specs)
# sheet.vert_df.is_active = 1
# grad_err = solver.check_grad(sheet, geom, model)
# grad_err /= sheet.vert_df.size
# assert_almost_equal(grad_err, 0.0, DECIMAL)
settings = {
'minimize': {
'options': {
'disp': False,
'ftol': 1e-4,
'gtol': 1e-4
},
}
}
res = solver.find_energy_min(sheet, geom, model, **settings)
assert res['success']
def leg_joint_view(sheet, coords=['z', 'x', 'y']):
x, y, z = coords
datasets = {}
datasets['face'] = sheet.face_df.sort_values(z)
datasets['vert'] = sheet.vert_df.sort_values(z)
edge_z = 0.5 * (sheet.upcast_srce(sheet.vert_df[z]) +
sheet.upcast_trgt(sheet.vert_df[z]))
datasets['edge'] = sheet.edge_df.copy()
datasets['edge'][z] = edge_z
datasets['edge'] = datasets['edge'].sort_values(z)
tmp_sheet = Sheet('tmp', datasets, sheet.specs)
tmp_sheet.reset_index()
cmap = plt.cm.get_cmap('viridis')
e_depth = (tmp_sheet.edge_df[z] -
tmp_sheet.edge_df[z].min()) / tmp_sheet.edge_df[z].ptp()
depth_cmap = cmap(e_depth)
draw_specs = {'vert': {'visible': False}, 'edge': {'color': depth_cmap}}
fig, ax = sheet_view(tmp_sheet, coords[:2], **draw_specs)
ax.set_xlim(-80, 80)
ax.set_ylim(-50, 50)
ax.set_axis_bgcolor('#404040')
ax.set_xticks([])
ax.set_yticks([])
fig.set_size_inches((16, 9))
fig.set_frameon(False)
fig.set_clip_box(ax.bbox)
return fig, ax
def single_sim(args):
l, g, dirname, nb_dir = args
print('Parsing' + dirname, nb_dir)
data_file = os.path.join(nb_dir, '../data/hf5/before_apoptosis.hf5')
datasets = hdf5.load_datasets(data_file)
with open(os.path.join(nb_dir, 'specs.json'), 'r') as sp_file:
specs = json.load(sp_file)
sheet2 = Sheet('fold', datasets, specs)
res = solver.find_energy_min(sheet2, geom, model, **min_settings)
print('starting {}'.format(dirname))
try:
os.mkdir(dirname)
except IOError:
pass
settings = {
'shrink_steps': 10,
'rad_tension': l,
'contractile_increase': g,
'contract_span': 3
}
apopto_cells = get_apopto_cells(sheet2)
sheet2.settings['apoptosis'] = settings
run_sim(sheet2, apopto_cells, geom, model, dirname)
print('{} done'.format(dirname))
print('~~~~~~~~~~~~~~~~~~~~~\n')
return args
def test_relax():
sheet = Sheet('emin', *three_faces_sheet())
sheet.face_df['contractility'] = 1.12
sheet.face_df['prefered_area'] = 1.
relax(sheet, 0, 2)
assert sheet.face_df.loc[0, 'contractility'] == 0.56
assert sheet.face_df.loc[0, 'prefered_area'] == 2.
def test_extract():
datasets, specs = generation.three_faces_sheet()
sheet = Sheet("test_sheet_extract_coordinate", datasets, specs)
sheet.face_df.loc[0, "is_alive"] = 0
subsheet = sheet.extract("is_alive")
assert subsheet.face_df["is_alive"].all()
assert subsheet.Nf == 2
def test_relax():
sheet = Sheet("emin", *three_faces_sheet())
sheet.face_df["contractility"] = 1.12
sheet.face_df["prefered_area"] = 1.0
relax(sheet, 0, 2)
assert sheet.face_df.loc[0, "contractility"] == 0.56
assert sheet.face_df.loc[0, "prefered_area"] == 2.0
def test_contract():
sheet = Sheet('emin', *three_faces_sheet())
sheet.face_df['contractility'] = 1.
contract(sheet, 0, 0.5, multiple=False)
assert sheet.face_df.loc[0, 'contractility'] == 1.5
contract(sheet, 1, 2., multiple=True)
assert sheet.face_df.loc[1, 'contractility'] == 2.
def test_contract():
sheet = Sheet("emin", *three_faces_sheet())
sheet.face_df["contractility"] = 1.0
contract(sheet, 0, 0.5, multiple=False)
assert sheet.face_df.loc[0, "contractility"] == 1.5
contract(sheet, 1, 2.0, multiple=True)
assert sheet.face_df.loc[1, "contractility"] == 2.0
def test_ab_pull():
sheet = Sheet("emin", *three_faces_sheet())
sheet.vert_df["radial_tension"] = 1.0
ab_pull(sheet, 0, 1.0, distributed=False)
np.testing.assert_array_equal(sheet.vert_df.loc[0:5, "radial_tension"],
np.ones(6) * 2.0)
ab_pull(sheet, 0, 3.0, distributed=True)
np.testing.assert_array_equal(sheet.vert_df.loc[0:5, "radial_tension"],
np.ones(6) * 2.5)
def test_ab_pull():
sheet = Sheet('emin', *three_faces_sheet())
sheet.vert_df['radial_tension'] = 1.
ab_pull(sheet, 0, 1., distributed=False)
np.testing.assert_array_equal(sheet.vert_df.loc[0:5, 'radial_tension'],
np.ones(6) * 2.)
ab_pull(sheet, 0, 3., distributed=True)
np.testing.assert_array_equal(sheet.vert_df.loc[0:5, 'radial_tension'],
np.ones(6) * 2.5)
def test_close_face():
sheet = Sheet("test", *three_faces_sheet())
e0 = sheet.edge_df.index[0]
face = sheet.edge_df.loc[e0, "face"]
Ne = sheet.Ne
sheet.edge_df = sheet.edge_df.loc[sheet.edge_df.index[1:]].copy()
close_face(sheet, face)
assert sheet.Ne == Ne
close_face(sheet, face)
assert sheet.Ne == Ne
def test_model():
h5store = os.path.join(stores_dir, "small_hexagonal.hf5")
datasets = load_datasets(h5store, data_names=["face", "vert", "edge"])
specs = config.geometry.cylindrical_sheet()
sheet = Sheet("emin", datasets, specs)
model_tester(sheet, model)
model_tester(sheet, PlanarModel)
flat = Sheet.planar_sheet_2d("flat", 5, 5, 1, 1)
flat.sanitize()
PlanarGeometry.update_all(flat)
model_tester(flat, PlanarModel)
def test_face_elimination():
sheet = Sheet('emin', *three_faces_sheet())
sheet.face_df['id'] = sheet.face_df.index
face_id = 0
manager = EventManager('face')
event = (face_elimination, {'face_id': face_id})
manager.current.append(event)
manager.execute(sheet)
manager.update()
assert sheet.Nf == 2
assert sheet.Nv == 8
assert sheet.Ne == 10
def test_face_elimination():
sheet = Sheet("emin", *three_faces_sheet())
sheet.face_df["id"] = sheet.face_df.index
face_id = 0
manager = EventManager("face")
event = (face_elimination, {"face_id": face_id})
manager.current.append(event)
manager.execute(sheet)
manager.update()
assert sheet.Nf == 2
assert sheet.Nv == 8
assert sheet.Ne == 10
def test_extra_indices():
datasets = {}
tri_verts = [[0, 0], [1, 0], [-0.5, 3**0.5 / 2], [-0.5, -(3**0.5) / 2]]
tri_edges = [
[0, 1, 0],
[1, 2, 0],
[2, 0, 0],
[0, 3, 1],
[3, 1, 1],
[1, 0, 1],
[0, 2, 2],
[2, 3, 2],
[3, 0, 2],
]
datasets["edge"] = pd.DataFrame(data=np.array(tri_edges),
columns=["srce", "trgt", "face"])
datasets["edge"].index.name = "edge"
datasets["face"] = pd.DataFrame(data=np.zeros((3, 2)), columns=["x", "y"])
datasets["face"].index.name = "face"
datasets["vert"] = pd.DataFrame(data=np.array(tri_verts),
columns=["x", "y"])
datasets["vert"].index.name = "vert"
specs = config.geometry.planar_spec()
eptm = Sheet("extra", datasets, specs, coords=["x", "y"])
PlanarGeometry.update_all(eptm)
eptm.edge_df["opposite"] = get_opposite(eptm.edge_df)
eptm.get_extra_indices()
assert (2 * eptm.Ni + eptm.No) == eptm.Ne
assert eptm.west_edges.size == eptm.Ni
assert eptm.Nd == 2 * eptm.Ni
for edge in eptm.free_edges:
opps = eptm.edge_df[eptm.edge_df["srce"] == eptm.edge_df.loc[
edge, "trgt"]]["trgt"]
assert eptm.edge_df.loc[edge, "srce"] not in opps
for edge in eptm.east_edges:
srce, trgt = eptm.edge_df.loc[edge, ["srce", "trgt"]]
opp = eptm.edge_df[(eptm.edge_df["srce"] == trgt)
& (eptm.edge_df["trgt"] == srce)].index
assert opp[0] in eptm.west_edges
for edge in eptm.west_edges:
srce, trgt = eptm.edge_df.loc[edge, ["srce", "trgt"]]
opp = eptm.edge_df[(eptm.edge_df["srce"] == trgt)
& (eptm.edge_df["trgt"] == srce)].index
assert opp[0] in eptm.east_edges
def test_sheet_extract_coordinate():
grid = hexa_grid2d(6, 4, 3, 3)
datasets = from_2d_voronoi(Voronoi(grid))
sheet = Sheet("test_extract_bounding_box", datasets)
subsheet = sheet.extract_bounding_box(
[sheet.face_df["x"].min(), sheet.face_df["x"].max() / 2],
[sheet.face_df["y"].min(), sheet.face_df["y"].max() / 2],
)
assert subsheet.face_df["x"].max() <= sheet.face_df["x"].max() / 2
assert subsheet.face_df["x"].min() >= sheet.face_df["x"].min()
assert subsheet.face_df["y"].max() <= sheet.face_df["y"].max() / 2
assert subsheet.face_df["y"].min() >= sheet.face_df["y"].min()
assert subsheet.face_df["z"].max() <= sheet.face_df["z"].max()
assert subsheet.face_df["z"].min() >= sheet.face_df["z"].min()
def test_increase_line_tension():
sheet = Sheet("emin", *three_faces_sheet())
sheet.edge_df["line_tension"] = 1
edges = sheet.edge_df[sheet.edge_df["face"] == 4]
for index, edge in edges.iterrows():
sheet.edge_df.loc[edge, "line_tension"] == 2
increase_linear_tension(sheet, 0, 4)
edges = sheet.edge_df[sheet.edge_df["face"] == 4]
for index, edge in edges.iterrows():
angle_ = np.arctan2(sheet.edge_df.dx, sheet.edge_df.dy)
if np.abs(angle_) < np.pi / 4:
assert sheet.edge_df.loc[edge, "line_tension"] == 8
def test_remove_face():
sheet = Sheet("emin", *three_faces_sheet())
type3(sheet, 0, geom)
assert sheet.Nf == 2
assert sheet.Nv == 8
assert sheet.Ne == 10
def test_3faces():
datasets, specs = three_faces_sheet()
sheet = Sheet("3faces_2D", datasets, specs)
sgeom.update_dcoords(sheet)
sgeom.update_length(sheet)
np.testing.assert_allclose(sheet.edge_df["length"], 1, rtol=1e-3)
sgeom.update_centroid(sheet)
np.testing.assert_array_almost_equal([0.5, -1.0, 0.5],
sheet.face_df["x"],
decimal=3)
sgeom.update_normals(sheet)
norms = np.linalg.norm(sheet.edge_df[["nx", "ny", "nz"]], axis=1)
np.testing.assert_allclose(norms, 0.866, rtol=1e-3)
sgeom.update_areas(sheet)
np.testing.assert_allclose(sheet.face_df["area"],
np.sqrt(3) * 1.5,
rtol=1e-3)
sgeom.update_all(sheet)
np.testing.assert_allclose(sheet.face_df["area"],
np.sqrt(3) * 1.5,
rtol=1e-3)
def test_3faces():
datasets, specs = three_faces_sheet()
sheet = Sheet('3faces_2D', datasets, specs)
sgeom.update_dcoords(sheet)
sgeom.update_length(sheet)
np.testing.assert_allclose(sheet.edge_df['length'], 1, rtol=1e-3)
sgeom.update_centroid(sheet)
np.testing.assert_array_almost_equal([0.5, -1., 0.5],
sheet.face_df['x'],
decimal=3)
sgeom.update_normals(sheet)
norms = np.linalg.norm(sheet.edge_df[['nx', 'ny', 'nz']], axis=1)
np.testing.assert_allclose(norms, 0.866, rtol=1e-3)
sgeom.update_areas(sheet)
np.testing.assert_allclose(sheet.face_df['area'],
np.sqrt(3) * 1.5,
rtol=1e-3)
sgeom.update_all(sheet)
np.testing.assert_allclose(sheet.face_df['area'],
np.sqrt(3) * 1.5,
rtol=1e-3)
def test_type1_at_shorter():
sheet = Sheet("emin", *three_faces_sheet())
sheet.vert_df.loc[0, "x"] += 0.5
geom.update_all(sheet)
type1_at_shorter(sheet, 0, geom)
np.all(sheet.face_df.num_sides.values == [5, 7, 5])
def test_subdivide():
datasets, specs = generation.three_faces_sheet()
sheet = Sheet("test", datasets, specs)
subdivided = subdivide_faces(sheet, [0])
assert subdivided["face"].shape[0] == 3
assert subdivided["edge"].shape[0] == 30
assert subdivided["vert"].shape[0] == 14
datasets_3d = extrude(datasets, method="translation")
sheet_3d = Sheet("test3d", datasets_3d, specs)
subdivided_3d = subdivide_faces(sheet_3d, [0])
assert subdivided_3d["face"].shape[0] == 24
assert subdivided_3d["edge"].shape[0] == 120
assert subdivided_3d["vert"].shape[0] == 27
assert subdivided_3d["cell"].shape[0] == 3
def test_merge_border_edges():
sheet = Sheet.planar_sheet_3d("sheet", 5, 6, 1, 1)
sheet.get_opposite()
sheet.sanitize(trim_borders=True)
assert (sheet.edge_df[sheet.edge_df["opposite"] < 0].groupby("face")
["opposite"].sum().min() == -1)
assert not set(sheet.vert_df.index).difference(sheet.edge_df.srce)
def test_execute_contraction():
sheet = Sheet('emin', *three_faces_sheet())
geom.update_all(sheet)
sheet.face_df['contractility'] = 1.12
sheet.face_df['id'] = sheet.face_df.index.values
manager = EventManager('face')
face_id = 1
event = (contraction, {
'face_id': face_id,
'contractile_increase': 0.2,
'critical_area': 1e-2
})
manager.current.append(event)
manager.execute(sheet)
manager.update()
assert sheet.face_df.loc[face_id, 'contractility'] == 1.32
def test_check_tri_faces():
h5store = os.path.join(stores_dir, "small_hexagonal.hf5")
datasets = load_datasets(h5store, data_names=["face", "vert", "edge"])
specs = config.geometry.cylindrical_sheet()
sheet = Sheet("emin", datasets, specs)
initial_nb_cells = len(sheet.face_df)
nb_tri_cells = len(sheet.face_df[(sheet.face_df["num_sides"] < 4)])
geom.update_all(sheet)
sheet.face_df["id"] = sheet.face_df.index.values
manager = EventManager("face")
manager.current.append((check_tri_faces, {}))
manager.execute(sheet)
manager.update()
manager.execute(sheet)
manager.update()
assert len(sheet.face_df) == initial_nb_cells - nb_tri_cells
def test_compute_gradient():
h5store = os.path.join(stores_dir, "small_hexagonal.hf5")
datasets = load_datasets(h5store, data_names=["face", "vert", "edge"])
specs = config.geometry.cylindrical_sheet()
sheet = Sheet("emin", datasets, specs)
nondim_specs = config.dynamics.quasistatic_sheet_spec()
dim_model_specs = model.dimensionalize(nondim_specs)
sheet.update_specs(dim_model_specs)
geom.update_all(sheet)
sheet.edge_df["is_active"] = sheet.upcast_srce("is_active") * sheet.upcast_face(
"is_alive"
)
nrj_norm_factor = sheet.specs["settings"]["nrj_norm_factor"]
print("Norm factor: ", nrj_norm_factor)
((grad_t, _), (grad_c, _), (grad_v_srce, grad_v_trgt)) = model.compute_gradient(
sheet, components=True
)
grad_t_norm = np.linalg.norm(grad_t, axis=0).sum() / nrj_norm_factor
assert_almost_equal(grad_t_norm, 0.22486850242320636, decimal=DECIMAL)
grad_c_norm = np.linalg.norm(grad_c, axis=0).sum() / nrj_norm_factor
assert_almost_equal(grad_c_norm, 0.49692791, decimal=DECIMAL)
grad_vs_norm = np.linalg.norm(grad_v_srce.dropna(), axis=0).sum() / nrj_norm_factor
assert_almost_equal(grad_vs_norm, 0.30281367249952407, decimal=DECIMAL)
grad_vt_norm = np.linalg.norm(grad_v_trgt.dropna(), axis=0).sum() / nrj_norm_factor
assert_almost_equal(grad_vt_norm, 0.27732035134768285, decimal=DECIMAL)
