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)