def test_close_already_closed(caplog): dsets = hdf5.load_datasets(Path(stores_dir) / "with_4sided_cell.hf5") mono = Monolayer("4", dsets) cell = mono.cell_df.query("num_faces != 4").index[0] close_cell(mono, cell) assert caplog.record_tuples[-1][2] == "cell %s is already closed" % cell
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)
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_execute_constriction(): 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) geom.update_all(sheet) sheet.settings["constriction"] = { "contractile_increase": 5, "critical_area": 5, "max_traction": 10, } sheet.face_df["id"] = sheet.face_df.index.values init_nb_cells = len(sheet.face_df) sheet.face_df["is_mesoderm"] = 0 sheet.vert_df["radial_tension"] = 0 manager = EventManager("face") face_id = 17 sheet.face_df.loc[face_id, "is_mesoderm"] = 1 sheet.settings["constriction"].update({"face_id": face_id}) initial_cell_event = (constriction, sheet.settings["constriction"]) manager.current.append(initial_cell_event) manager.execute(sheet) manager.update() assert len(manager.current) > 0 for i in range(20): manager.execute(sheet) manager.update() if len(sheet.face_df) == init_nb_cells: assert len(manager.current) > 0
def test_execute_constriction(): 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) geom.update_all(sheet) sheet.settings['constriction'] = { 'contractile_increase': 5, 'critical_area': 5, 'max_traction': 10 } sheet.face_df['id'] = sheet.face_df.index.values init_nb_cells = len(sheet.face_df) sheet.face_df['is_mesoderm'] = 0 sheet.vert_df['radial_tension'] = 0 manager = EventManager('face') face_id = 17 sheet.face_df.loc[face_id, 'is_mesoderm'] = 1 sheet.settings['constriction'].update({'face_id': face_id}) initial_cell_event = (constriction, sheet.settings['constriction']) manager.current.append(initial_cell_event) manager.execute(sheet) manager.update() assert len(manager.current) > 0 for i in range(20): manager.execute(sheet) manager.update() if len(sheet.face_df) == init_nb_cells: assert len(manager.current) > 0
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_close_cell(): dsets = hdf5.load_datasets(Path(stores_dir) / "with_4sided_cell.hf5") mono = Monolayer("4", dsets) cell = mono.cell_df.query("num_faces != 4").index[0] Nfi = mono.cell_df.loc[cell, "num_faces"] Nei = mono.Ne edges = mono.edge_df.query(f"cell == {cell}") face = edges["face"].iloc[0] face_edges = edges.query(f"face == {face}").index Nsi = len(face_edges) mono.face_df.drop(face, axis=0, inplace=True) mono.edge_df.drop(face_edges, axis=0, inplace=True) mono.reset_index() mono.reset_topo() assert mono.cell_df.loc[cell, "num_faces"] == Nfi - 1 assert mono.Ne == Nei - Nsi res = close_cell(mono, cell) MonolayerGeometry.update_all(mono) mono.reset_index() mono.reset_topo() assert not res assert mono.validate() assert mono.cell_df.loc[cell, "num_faces"] == Nfi assert mono.Ne == Nei
def initiate_ellipsoid(dataset_path, json_path): """ Create ellipsoid tissue as a sheet with mesodermal cells dataset_path: initial hf45 file json_path: json spec file """ dsets = hdf5.load_datasets(dataset_path, data_names=['vert', 'edge', 'face']) with open(json_path, 'r+') as fp: specs = json.load(fp) sheet = Sheet('ellipse', dsets, specs) # Modify some initial value sheet.settings['threshold_length'] = 1e-3 sheet.settings['vitelline_space'] = 0.2 sheet.vert_df['radial_tension'] = 0. sheet.settings['lumen_prefered_vol'] = 4539601.384437251 sheet.settings['lumen_vol_elasticity'] = 3.e-6 sheet.edge_df.cell = np.nan # Define mesoderm and relaxating cells define_mesoderm(sheet, 145, 40) define_relaxation_cells(sheet, 140, 33, 145, 40) return sheet
def test_rod_update_height(): pth = os.path.join(stores_dir, "rod_sheet.hf5") datasets = load_datasets(pth) specs = config.geometry.rod_sheet() sheet = Sheet("rod", datasets, specs) SheetGeometry.update_all(sheet) assert (sheet.vert_df.rho.mean() - 0.96074585429756632)**2 < TOLERANCE
def test_rod_update_height(): pth = os.path.join(CURRENT_DIR, '../../stores/rod_sheet.hf5') datasets = load_datasets(pth) specs = config.geometry.rod_sheet() sheet = Sheet('rod', datasets, specs) SheetGeometry.update_all(sheet) assert (sheet.vert_df.rho.mean() - 0.7895479495559642)**2 < TOLERANCE
def test_t1_transition(): h5store = os.path.join(stores_dir, "small_hexagonal.hf5") datasets = load_datasets(h5store, data_names=["face", "vert", "edge"]) specs = cylindrical_sheet() sheet = Sheet("emin", datasets, specs) geom.update_all(sheet) face = sheet.edge_df.loc[84, "face"] type1_transition(sheet, 84) assert sheet.edge_df.loc[84, "face"] != face
def main(): # --------- Chargement d'un fichier HDF5 --------- # dsets = hdf5.load_datasets("data/with_collisions.hf5", data_names=["vert", "edge", "face"]) specs = config.geometry.cylindrical_sheet() sheet = Sheet("ellipse", dsets, specs) SheetGeometry.update_all(sheet) list_intersected_facesolve_intersection(sheet)
def test_fix_pinch(): dsets = hdf5.load_datasets(Path(stores_dir) / "with_pinch.hf5") pinched = Monolayer("pinched", dsets) assert not pinched.validate() fix_pinch(pinched) assert pinched.validate() edf = pinched.edge_df[["srce", "trgt", "face", "cell"]].copy() # Nothing happens here fix_pinch(pinched) assert pinched.validate() assert np.all(pinched.edge_df[["srce", "trgt", "face", "cell"]] == edf)
def test_execute_apoptosis(): 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) geom.update_all(sheet) sheet.settings["apoptosis"] = { "contractile_increase": 2.0, "critical_area": 0.1 } sheet.face_df["id"] = sheet.face_df.index.values init_nb_faces = len(sheet.face_df) manager = EventManager("face") face_id = 17 face_area = sheet.face_df.loc[face_id, "area"] initial_nbsides = sheet.face_df.loc[face_id, "num_sides"] sheet.settings["apoptosis"].update({"face_id": face_id}) initial_cell_event = (apoptosis, sheet.settings["apoptosis"]) manager.current.append(initial_cell_event) manager.execute(sheet) manager.update() assert len(manager.current) > 0 manager.execute(sheet) manager.update() sheet.settings["apoptosis"] = { "contractile_increase": 2.0, "critical_area": 2 * face_area, } manager.current.clear() sheet.settings["apoptosis"].update({"face_id": face_id}) modified_cell_event = (apoptosis, sheet.settings["apoptosis"]) manager.current.append(modified_cell_event) manager.execute(sheet) manager.update() next_nbsides = sheet.face_df.loc[sheet.idx_lookup(face_id, "face"), "num_sides"] i = 1 while next_nbsides > 4: assert next_nbsides == initial_nbsides - i assert len(manager.current) > 0 i = i + 1 manager.execute(sheet) manager.update() next_nbsides = sheet.face_df.loc[sheet.idx_lookup(face_id, "face"), "num_sides"] if i > 20: raise RecursionError manager.execute(sheet) manager.update() assert len(sheet.face_df) < init_nb_faces
def test_get_phis(): pth = os.path.join(stores_dir, "rod_sheet.hf5") datasets = load_datasets(pth) specs = config.geometry.rod_sheet() sheet = Sheet("rod", datasets, specs) SheetGeometry.update_all(sheet) sheet.edge_df["sphi"] = SheetGeometry.get_phis(sheet) assert np.all( sheet.edge_df.sort_values(["face", "sphi"]).groupby("face").apply( lambda df: np.roll(df["trgt"], 1) == df["srce"]))
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_detection(): sheet = Sheet("crossed", hdf5.load_datasets(Path(stores_dir) / "sheet6x5.hf5")) sheet.vert_df.z = 5 * sheet.vert_df.x**2 # sheet.vert_df[sheet.coords] += np.random.normal(scale=0.001, size=(sheet.Nv, 3)) SheetGeometry.update_all(sheet) sheet.vert_df.x -= 35 * (sheet.vert_df.x / 2)**3 SheetGeometry.update_all(sheet) colliding_edges = set(collisions.self_intersections(sheet).flatten()) expected = {32, 1, 34, 9, 35} assert colliding_edges == expected
def get_ventral_patch(fname): sim_dsets = hdf5.load_datasets(fname) sheet = Sheet('morph', sim_dsets, config.geometry.flat_sheet()) to_crop = sheet.cut_out( [[-300, 300], [sheet.vert_df.y.max() - 22, sheet.vert_df.y.max() + 1], [-300, 300]], ) sheet.remove(to_crop) sheet.vert_df[['x', 'y', 'z']] = sheet.vert_df[['x', 'z', 'y']] SheetGeometry.update_all(sheet) return sheet
def test_execute_apoptosis(): 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) geom.update_all(sheet) sheet.settings['apoptosis'] = { 'contractile_increase': 2.0, 'critical_area': 0.1 } sheet.face_df['id'] = sheet.face_df.index.values init_nb_faces = len(sheet.face_df) manager = EventManager('face') face_id = 17 face_area = sheet.face_df.loc[face_id, 'area'] initial_nbsides = sheet.face_df.loc[face_id, 'num_sides'] sheet.settings['apoptosis'].update({'face_id': face_id}) initial_cell_event = (apoptosis, sheet.settings['apoptosis']) manager.current.append(initial_cell_event) manager.execute(sheet) manager.update() assert len(manager.current) > 0 manager.execute(sheet) manager.update() sheet.settings['apoptosis'] = { 'contractile_increase': 2.0, 'critical_area': 2 * face_area } manager.current.clear() sheet.settings['apoptosis'].update({'face_id': face_id}) modified_cell_event = (apoptosis, sheet.settings['apoptosis']) manager.current.append(modified_cell_event) manager.execute(sheet) manager.update() next_nbsides = sheet.face_df.loc[sheet.idx_lookup(face_id, 'face'), 'num_sides'] i = 1 while next_nbsides > 4: assert next_nbsides == initial_nbsides - i assert len(manager.current) > 0 i = i + 1 manager.execute(sheet) manager.update() next_nbsides = sheet.face_df.loc[sheet.idx_lookup(face_id, 'face'), 'num_sides'] manager.execute(sheet) manager.update() assert len(sheet.face_df) < init_nb_faces
def test_face_rotation(): 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) sgeom.update_all(sheet) face = 17 normal = sheet.edge_df[sheet.edge_df["face"] == face][sheet.ncoords].mean() rot = sgeom.face_rotation(sheet, face, 0) rotated = np.dot(rot, normal) np.testing.assert_allclose(rotated[:2], np.zeros(2), atol=1e-7)
def test_close_two_holes(): dsets = hdf5.load_datasets(Path(stores_dir) / "small_ellipsoid.hf5") mono = Monolayer("4", dsets) cell = mono.cell_df.query("num_faces != 4").index[0] edges = mono.edge_df.query(f"cell == {cell}") faces = edges["face"].iloc[[0, 8]] face_edges = edges[edges["face"].isin(faces)].index mono.face_df.drop(faces, axis=0, inplace=True) mono.edge_df.drop(face_edges, axis=0, inplace=True) mono.reset_index() mono.reset_topo() with pytest.raises(ValueError): close_cell(mono, cell)
def test_remove_cell(): dsets = hdf5.load_datasets(Path(stores_dir) / "with_4sided_cell.hf5") mono = Monolayer("4", dsets) Nci = mono.Nc cell = mono.cell_df.query("num_faces == 4").index[0] res = remove_cell(mono, cell) MonolayerGeometry.update_all(mono) assert not res assert mono.validate() assert mono.Nc == Nci - 1 with pytest.warns(UserWarning): cell = mono.cell_df.query("num_faces != 4").index[0] res = remove_cell(mono, cell) assert mono.validate()
def test_extra_indices_hexabug(): # GH #192 with pytest.raises(AssertionError): h5store = os.path.join(stores_dir, "small_hexagonal_snaped.hf5") datasets = load_datasets(h5store) specs = config.geometry.cylindrical_sheet() sheet = Sheet("emin", datasets, specs) SheetGeometry.update_all(sheet) sheet.sanitize() sheet.get_extra_indices() h5store = os.path.join(stores_dir, "small_hexagonal.hf5") datasets = load_datasets(h5store) specs = config.geometry.cylindrical_sheet() sheet = Sheet("emin", datasets, specs) SheetGeometry.update_all(sheet) sheet.sanitize() sheet.get_extra_indices()
def test_solving(): sheet = Sheet("crossed", hdf5.load_datasets(Path(stores_dir) / "sheet6x5.hf5")) sheet.vert_df.z = 5 * sheet.vert_df.x**2 SheetGeometry.update_all(sheet) positions_buffer = sheet.vert_df[sheet.coords].copy() sheet.vert_df.x -= 35 * (sheet.vert_df.x / 2)**3 SheetGeometry.update_all(sheet) colliding_edges = collisions.self_intersections(sheet) boxes = solvers.CollidingBoxes(sheet, positions_buffer, colliding_edges) boxes.solve_collisions(shyness=0.01) assert collisions.self_intersections(sheet).size == 0 assert sheet.vert_df.loc[[22, 12], "x"].diff().loc[12] == 0.01
def init_tissue(hf5_filename='superegg_final.hf5', json_filename='superegg_final.json'): """ Initialisation of the superegg tissue """ dsets = hdf5.load_datasets('../examples/' + hf5_filename, data_names=['vert', 'edge', 'face']) with open('../examples/' + json_filename, 'r+') as fp: specs = json.load(fp) sheet = Sheet('spherical', dsets, specs) modify_some_initial_settings(sheet) return sheet
def test_division(): h5store = os.path.join(stores_dir, "small_hexagonal.hf5") datasets = load_datasets(h5store, data_names=["face", "vert", "edge"]) specs = cylindrical_sheet() sheet = Sheet("emin", datasets, specs) geom.update_all(sheet) Nf, Ne, Nv = sheet.Nf, sheet.Ne, sheet.Nv cell_division(sheet, 17, geom) assert sheet.Nf - Nf == 1 assert sheet.Nv - Nv == 2 assert sheet.Ne - Ne == 6
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_iso_solver(): pth = os.path.join(stores_dir, "rod_sheet.hf5") datasets = load_datasets(pth) specs = config.geometry.rod_sheet() sheet = Sheet("rod", datasets, specs) geom.reset_scafold(sheet) geom.update_all(sheet) dyn_specs = config.dynamics.quasistatic_sheet_spec() dyn_specs["vert"]["basal_shift"] = 0.0 dyn_specs["face"]["prefered_vol"] = 1.0 sheet.update_specs(dyn_specs, reset=True) geom.update_all(sheet) res = bruteforce_isotropic_relax(sheet, geom, model) assert_almost_equal(res["x"], 1.6001116383)
def test_x_and_y_boundary_celldiv(): dsets = hdf5.load_datasets( Path(stores.stores_dir) / "planar_periodic8x8.hf5") specs = config.geometry.planar_sheet() specs["settings"]["boundaries"] = {"x": [-0.1, 8.1], "y": [-0.1, 8.1]} sheet = Sheet("periodic", dsets, specs) coords = ["x", "y"] draw_specs = config.draw.sheet_spec() PlanarGeometry.update_all(sheet) Nf = sheet.Nf # arbitrarily choose a cells on x_boundary and y_boundary to divide div_cell = sheet.face_df.index[(sheet.face_df["at_x_boundary"] == True) & (sheet.face_df["at_y_boundary"] == True)][0] daughter = cell_division(sheet, div_cell, PlanarGeometry, angle=0.6) assert sheet.validate() assert sheet.Nf == Nf + 1
def test_already(): # GH111 sheet = Sheet("crossed", hdf5.load_datasets(Path(stores_dir) / "sheet6x5.hf5")) sheet.vert_df.z = 5 * sheet.vert_df.x**2 SheetGeometry.update_all(sheet) sheet.vert_df.x -= 35 * (sheet.vert_df.x / 2)**3 SheetGeometry.update_all(sheet) positions_buffer = sheet.vert_df[sheet.coords].copy() sheet.vert_df.x -= 0.1 * (sheet.vert_df.x / 2)**3 SheetGeometry.update_all(sheet) colliding_edges = collisions.self_intersections(sheet) boxes = solvers.CollidingBoxes(sheet, positions_buffer, colliding_edges) res = boxes.solve_collisions(shyness=0.01) colliding_edges = collisions.self_intersections(sheet) assert len(colliding_edges) == 0