Inheritance diagram for diffusion.Diffusion:

Public Member Functions
	__init__ (self, inputfile=None, box=True, r_Li=0, d_P=2.5, d_S=2, sign_var=-1, grid_size=22, axes=[0, 1], dim=3, simply_connected_top_bottom=False, swap_res_grid_and_balls=False, close_loops_with_boundary_conditions=False, z_axis_boundaries=True, simplify_grid_with_triangles=True, cut_paths_until_A_0=True, a=1, b=0.5, c=0.1, K_graph=1, MP=True, verbose=False)
	produce_fobidden_region (self, balls_centres_=None, balls_radii_=None, M_=None, m_=None)
	setup_triangulation (self, balls_centres_=None, balls_radii_=None, M_=None, m_=None)
	estimate_atoms_min_distances (self, n=10)
	produce_res_grid (self, balls_centres_=None, balls_radii_=None, M_=None, m_=None)
	setup_geodesics_and_boundaries (self)
	make_edges (self)
	make_cubic_to_res (self, cubic_grid)
	make_triangulation (self)
	make_N (self)
	sample_diffusion (self)
	preprocess_path (self, path)
	cut_until_A_0 (self, path)
	simplify_path_with_homology (self, path)
	equivalence (self, v_path)
	fill_loop (self, idxs_list, BOUNDARY_MAT=None, RED_MAT=None, V_MAT=None, find_chain=False, plot=False)
	cluster_deadlocks (self, PATHS)
	traslate_box (self, coords, v_=None)
	check_cluster (self, n_clus, n=5, plot=False)
	proj_lithium_paths (self, LIST, plot=True)
	reeb_graph (self, grid, axis=-1, D_=None)
	build_graph (self, E, emb, fun)
	plot_pts (self, pts)
	plot_voids (self)
	plot_balls (self)
	plot_triangulation (self, axis=-1)
	plot_path (self, path)
	plot_vector_field (self, axis=1)
	plot_paths_clustered (self, min_len=5, k=0, aggregate=True)
	plot_results (self, min_len=5, k=0, aggregate=False)
	network_plot_3D (self, G, fun)
	plot_triangulation_and_paths (self, LIST, axis=-1, k=0.1)
	check_lithium_ranges (self, plot=True)
	check_lithium_paths (self, n=5)
	reduce_boundary_mat (self)
	compute_vector_field_penalties (self, v_=np.array([0, 0, 1]))
	make_markov_chain_matrix (self, eps_=1)
	equivalence_wrapper (self, loop)
	run_A_0_to_A_1_diffusion (self, n_paths=200, save=False, folder_path='/Users/ye72al/Library/Mobile Documents/com~apple~CloudDocs/Glass_TDA/')
	random_simplification_wrapper_MP (self, LIST)
	random_simplification_wrapper (self, path, n=20, verbose=False)
	simplify_paths_with_homology (self, n=100, random=False)
	simplify_deadlocks_with_homology (self)
	cluster_paths (self, save=False)
	reeb_graph_voids (self, axis=-1, plot=True)
	reeb_graph_balls (self, axis=-1, plot=True)
	prova (self, paths, BOUNDARY_MAT=None, RED_MAT=None, V_MAT=None, verbose=False)
	make_boundary_matrix_from_paths (self, BOUNDARY_PATHS, add_top_bottom=False)
	make_overlapping_summary (self, paths, step=1, plot=True, plot_steps=False)
	fill_loop_on_slice (self, paths, z_l, z_u, plot=True, FIG=None)

Public Attributes
	inputfile = inputfile
	r_Li = r_Li
	d_P = d_P
	d_S = d_S
	sign_var = sign_var
	grid_size = grid_size
	axes = axes
	dim = dim
	MP = MP
	swap_res_grid_and_balls = swap_res_grid_and_balls
	close_loops_with_boundary_conditions = close_loops_with_boundary_conditions
bool	simply_connected_top_bottom = True
	z_axis_boundaries = z_axis_boundaries
	simplify_grid_with_triangles = simplify_grid_with_triangles
	cut_paths_until_A_0 = cut_paths_until_A_0
	a = a
	b = b
	K_graph = K_graph
	verbose = verbose
	Li
	P
	S
	N
	M_x
	M_y
	m_x
	m_y
	r_P = self.d_P + self.sign_var*np.var(np.linalg.norm(self.P-P_centres,axis=-1)[:,aux_P])
	r_S = self.d_S + self.sign_var*np.var(np.linalg.norm(self.S-S_centres,axis=-1)[:,aux_S])
	d_Li = bp['caps'][0].get_ydata()[0]
	nx
	ny
tuple	nz = (self.grid_size, self.grid_size, self.grid_size)
	x = np.linspace(self.m_x, self.M_x, self.nx+tmp)[:-1]
	y = np.linspace(self.m_y, self.M_y, self.ny+tmp)[:-1]
	z = np.linspace(self.m_z, self.M_z, self.nz+tmp)[:-1]
	d_x = self.x[1]-self.x[0]
	d_y = self.y[1]-self.y[0]
	d_z = self.z[1]-self.z[0]
	z_0 = self.z[0]+self.d_z*k
	z_1 = self.z[-1]-self.d_z*k
	grid = np.zeros((self.nxself.nyself.nz,self.dim))
float	r_graph = np.sqrt(np.max([self.d_x,self.d_y,self.d_z])*2)np.sqrt(2)1.001self.K_graph
	res_grid = np.array([p for i,p in enumerate(res_grid) if i in comp])
	D_force_graph = np.ones((self.N,self.N))
list	ITRIS
	idxs_to_edge
	idxs = np.array(idxs)
dict	grid_to_res_grid = {}
	balls = self.grid[np.array([i for i in np.arange(len(self.grid)) if i not in self.idxs])]
	D
	geod
	idxs_A_0 = np.array([t[0] for t in np.argwhere(self.res_grid[:,-1]<self.z_0)])
	A_0 = self.res_grid[self.idxs_A_0]
dict	A_0_to_res = {}
dict	res_to_A_0 = {}
	geod_A_0
	idxs_A_1 = np.array([t[0] for t in np.argwhere(self.res_grid[:,-1]>self.z_1)])
	A_1 = self.res_grid[self.idxs_A_1]
dict	A_1_to_res = {}
dict	res_to_A_1 = {}
	geod_A_1
dict	edge_idxs = {}
float	r_graph_aux = np.sqrt(self.d_x2 + self.d_y2+self.d_z*2)1.001*self.K_graph
	N_1 = aux
dict	cubic_to_res = {}
	N_2 = len(ITRIS)
	B = B[:self.N_2,:]
	A = A
int	REEB_GRAPH = -1*np.ones((grid.shape[0],values.shape[0])).astype(int)
int	n = len(emb)-1
list	CLUSTERS
	GF = galois.GF(2)
	V = Q[:,-B.shape[0]:]
	B_red = Q[:,:B.shape[1]]
	pivot_cols = np.where(np.sum(self.B_red==1,axis=0)==1)[0]
	rank = np.sum(np.max(self.B_red, axis=-1)>0)
	V_ = Q[:,-A_.shape[0]:]
	A_red = Q[:,:A_.shape[1]]
	rank_A = np.sum(np.max(self.A_red, axis=-1)>0)
	v = np.ones_like(self.res_grid)*v_
	grad_pen = np.array([grad_r2(pt, self.balls_centres, self.balls_radii) for pt in self.res_grid])
	direction = np.zeros_like(self.D)
	repulsion = np.zeros_like(self.D)
	eps = eps_
list	DEADLOCKS = []
list	PATHS = []

Static Public Attributes
	balls_radii = np.array([self.r_P for _ in P_centres] + [self.r_S for _ in S_centres]) + self.r_Li
	M
	m
	M_z
	m_z
	balls_centres = balls_centres_
	vtx = self.res_grid[tr,:]
	tri = Poly3DCollection([vtx], alpha=0.3)
	linewidth
	linestyle
	c
	aux = self.traslate_box(self.res_grid[p,:])
	e = self.idxs_to_edge[idx,:]
list	chain = []

Detailed Description

Diffusion Class

Constructor & Destructor Documentation

◆ init()

diffusion.Diffusion.__init__	(	self,
		inputfile = None,
		box = True,
		r_Li = 0,
		d_P = 2.5,
		d_S = 2,
		sign_var = -1,
		grid_size = 22,
		axes = [0,1],
		dim = 3,
		simply_connected_top_bottom = False,
		swap_res_grid_and_balls = False,
		close_loops_with_boundary_conditions = False,
		z_axis_boundaries = True,
		simplify_grid_with_triangles = True,
		cut_paths_until_A_0 = True,
		a = 1,
		b = 0.5,
		c = 0.1,
		K_graph = 1,
		MP = True,
		verbose = False )

LEGEND

simply_connected_top_bottom -> consider A_0 and A_1 as simply connected, ignoring the forbidden region in such sets.
swap_res_grid_and_balls -> swap forbidden region and residual grid.
close_loops_with_boundary_conditions -> consider all possible combinations for closing loops, 
                                        as made available by boundary conditions. 
                                        Requires A_0 and A_1 simply connected and geodesically convex.
z_axis_boundaries -> consider periodicity also on the z-axis to setup the forbidden region.
simplify_grid_with_triangles -> make sure that every edge is in a triangle. 
cut_paths_until_A_0 -> when simplifying a path, cuts the part of the path which is in A_0, but for the latest point.
homological_simplification -> when simplifying a path, uses homology to shorten it.
K_graph -> coefficient for building a graph on the grid when check path connected comp. Keep it equal to 1. 
MP -> using multiprocessing when checking if to paths are homologous.

Member Function Documentation

◆ build_graph()

diffusion.Diffusion.build_graph	(	self,
		E,
		emb,
		fun )

◆ check_cluster()

diffusion.Diffusion.check_cluster	(	self,
		n_clus,
		n = 5,
		plot = False )

◆ check_lithium_paths()

diffusion.Diffusion.check_lithium_paths	(		self,
			n = 5 )

◆ check_lithium_ranges()

diffusion.Diffusion.check_lithium_ranges	(		self,
			plot = True )

◆ cluster_deadlocks()

diffusion.Diffusion.cluster_deadlocks	(		self,
			PATHS )

◆ cluster_paths()

diffusion.Diffusion.cluster_paths	(		self,
			save = False )

◆ compute_vector_field_penalties()

diffusion.Diffusion.compute_vector_field_penalties	(		self,
			v_ = np.array([0,0,1]) )

◆ cut_until_A_0()

diffusion.Diffusion.cut_until_A_0	(		self,
			path )

◆ equivalence()

diffusion.Diffusion.equivalence	(		self,
			v_path )

◆ equivalence_wrapper()

diffusion.Diffusion.equivalence_wrapper	(		self,
			loop )

◆ estimate_atoms_min_distances()

diffusion.Diffusion.estimate_atoms_min_distances	(		self,
			n = 10 )

◆ fill_loop()

diffusion.Diffusion.fill_loop	(	self,
		idxs_list,
		BOUNDARY_MAT = None,
		RED_MAT = None,
		V_MAT = None,
		find_chain = False,
		plot = False )

Finds the 2-chain which fills the loop in p,q are homologous. Se é "None" prendo A_0 e A_1.
BOUNDARY_MAT -> la matrice A, che genera il sottospazio di bord
RED_MAT -> la matrice A_red cioé la versione row-reduced di A[rank(B):,:]
V_MAT -> la matrice che porta A[rank(B):,:] in forma A_red

◆ fill_loop_on_slice()

diffusion.Diffusion.fill_loop_on_slice	(	self,
		paths,
		z_l,
		z_u,
		plot = True,
		FIG = None )

◆ make_boundary_matrix_from_paths()

diffusion.Diffusion.make_boundary_matrix_from_paths	(	self,
		BOUNDARY_PATHS,
		add_top_bottom = False )

◆ make_cubic_to_res()

diffusion.Diffusion.make_cubic_to_res	(		self,
			cubic_grid )

◆ make_edges()

diffusion.Diffusion.make_edges ( self )

◆ make_markov_chain_matrix()

diffusion.Diffusion.make_markov_chain_matrix	(		self,
			eps_ = 1 )

◆ make_N()

diffusion.Diffusion.make_N ( self )

◆ make_overlapping_summary()

diffusion.Diffusion.make_overlapping_summary	(	self,
		paths,
		step = 1,
		plot = True,
		plot_steps = False )

◆ make_triangulation()

diffusion.Diffusion.make_triangulation ( self )

◆ network_plot_3D()

diffusion.Diffusion.network_plot_3D	(	self,
		G,
		fun )

◆ plot_balls()

diffusion.Diffusion.plot_balls ( self )

◆ plot_path()

diffusion.Diffusion.plot_path	(		self,
			path )

◆ plot_paths_clustered()

diffusion.Diffusion.plot_paths_clustered	(	self,
		min_len = 5,
		k = 0,
		aggregate = True )

◆ plot_pts()

diffusion.Diffusion.plot_pts	(		self,
			pts )

◆ plot_results()

diffusion.Diffusion.plot_results	(	self,
		min_len = 5,
		k = 0,
		aggregate = False )

◆ plot_triangulation()

diffusion.Diffusion.plot_triangulation	(		self,
			axis = -1 )

◆ plot_triangulation_and_paths()

diffusion.Diffusion.plot_triangulation_and_paths	(	self,
		LIST,
		axis = -1,
		k = 0.1 )

◆ plot_vector_field()

diffusion.Diffusion.plot_vector_field	(		self,
			axis = 1 )

◆ plot_voids()

diffusion.Diffusion.plot_voids ( self )

◆ preprocess_path()

diffusion.Diffusion.preprocess_path	(		self,
			path )

◆ produce_fobidden_region()

diffusion.Diffusion.produce_fobidden_region	(	self,
		balls_centres_ = None,
		balls_radii_ = None,
		M_ = None,
		m_ = None )

◆ produce_res_grid()

diffusion.Diffusion.produce_res_grid	(	self,
		balls_centres_ = None,
		balls_radii_ = None,
		M_ = None,
		m_ = None )

◆ proj_lithium_paths()

diffusion.Diffusion.proj_lithium_paths	(	self,
		LIST,
		plot = True )

◆ prova()

diffusion.Diffusion.prova	(	self,
		paths,
		BOUNDARY_MAT = None,
		RED_MAT = None,
		V_MAT = None,
		verbose = False )

Check se una lista di paths paths sono riempibili con una 2-chain a meno di un sottospazio generato 
da una BOUNDARY_MAT. Si sovrappone con fill_loop.
BOUNDARY_MAT -> la matrice A, che genera il sottospazio di bordo. Se é "None" prendo A_0 e A_1.
RED_MAT -> la matrice A_red cioé la versione row-reduced di A[rank(B):,:]
V_MAT -> la matrice che porta A[rank(B):,:] in forma A_red

◆ random_simplification_wrapper()

diffusion.Diffusion.random_simplification_wrapper	(	self,
		path,
		n = 20,
		verbose = False )

◆ random_simplification_wrapper_MP()

diffusion.Diffusion.random_simplification_wrapper_MP	(		self,
			LIST )

◆ reduce_boundary_mat()

diffusion.Diffusion.reduce_boundary_mat ( self )

◆ reeb_graph()

diffusion.Diffusion.reeb_graph	(	self,
		grid,
		axis = -1,
		D_ = None )

◆ reeb_graph_balls()

diffusion.Diffusion.reeb_graph_balls	(	self,
		axis = -1,
		plot = True )

◆ reeb_graph_voids()

diffusion.Diffusion.reeb_graph_voids	(	self,
		axis = -1,
		plot = True )

◆ run_A_0_to_A_1_diffusion()

diffusion.Diffusion.run_A_0_to_A_1_diffusion	(	self,
		n_paths = 200,
		save = False,
		folder_path = '/Users/ye72al/Library/Mobile Documents/com~apple~CloudDocs/Glass_TDA/' )

◆ sample_diffusion()

diffusion.Diffusion.sample_diffusion ( self )

◆ setup_geodesics_and_boundaries()

diffusion.Diffusion.setup_geodesics_and_boundaries ( self )

◆ setup_triangulation()

diffusion.Diffusion.setup_triangulation	(	self,
		balls_centres_ = None,
		balls_radii_ = None,
		M_ = None,
		m_ = None )

◆ simplify_deadlocks_with_homology()

diffusion.Diffusion.simplify_deadlocks_with_homology ( self )

◆ simplify_path_with_homology()

diffusion.Diffusion.simplify_path_with_homology	(		self,
			path )

◆ simplify_paths_with_homology()

diffusion.Diffusion.simplify_paths_with_homology	(	self,
		n = 100,
		random = False )

◆ traslate_box()

diffusion.Diffusion.traslate_box	(	self,
		coords,
		v_ = None )

Member Data Documentation

◆ A

diffusion.Diffusion.A = A

◆ a

diffusion.Diffusion.a = a

◆ A_0

diffusion.Diffusion.A_0 = self.res_grid[self.idxs_A_0]

◆ A_0_to_res

dict diffusion.Diffusion.A_0_to_res = {}

◆ A_1

diffusion.Diffusion.A_1 = self.res_grid[self.idxs_A_1]

◆ A_1_to_res

dict diffusion.Diffusion.A_1_to_res = {}

◆ A_red

diffusion.Diffusion.A_red = Q[:,:A_.shape[1]]

◆ aux

diffusion.Diffusion.aux = self.traslate_box(self.res_grid[p,:])

static

◆ axes

diffusion.Diffusion.axes = axes

◆ B

diffusion.Diffusion.B = B[:self.N_2,:]

◆ b

diffusion.Diffusion.b = b

◆ B_red

diffusion.Diffusion.B_red = Q[:,:B.shape[1]]

◆ balls

diffusion.Diffusion.balls = self.grid[np.array([i for i in np.arange(len(self.grid)) if i not in self.idxs])]

◆ balls_centres

diffusion.Diffusion.balls_centres = balls_centres_

static

◆ balls_radii

diffusion.Diffusion.balls_radii = np.array([self.r_P for _ in P_centres] + [self.r_S for _ in S_centres]) + self.r_Li

static

◆ c

diffusion.Diffusion.c

static

◆ chain

list diffusion.Diffusion.chain = []

static

◆ close_loops_with_boundary_conditions

diffusion.Diffusion.close_loops_with_boundary_conditions = close_loops_with_boundary_conditions

◆ CLUSTERS

diffusion.Diffusion.CLUSTERS

◆ cubic_to_res

dict diffusion.Diffusion.cubic_to_res = {}

◆ cut_paths_until_A_0

diffusion.Diffusion.cut_paths_until_A_0 = cut_paths_until_A_0

◆ D

diffusion.Diffusion.D

◆ D_force_graph

diffusion.Diffusion.D_force_graph = np.ones((self.N,self.N))

◆ d_Li

diffusion.Diffusion.d_Li = bp['caps'][0].get_ydata()[0]

◆ d_P

diffusion.Diffusion.d_P = d_P

◆ d_S

diffusion.Diffusion.d_S = d_S

◆ d_x

diffusion.Diffusion.d_x = self.x[1]-self.x[0]

◆ d_y

diffusion.Diffusion.d_y = self.y[1]-self.y[0]

◆ d_z

diffusion.Diffusion.d_z = self.z[1]-self.z[0]

◆ DEADLOCKS

diffusion.Diffusion.DEADLOCKS = []

◆ dim

diffusion.Diffusion.dim = dim

◆ direction

diffusion.Diffusion.direction = np.zeros_like(self.D)

◆ e

diffusion.Diffusion.e = self.idxs_to_edge[idx,:]

static

◆ edge_idxs

dict diffusion.Diffusion.edge_idxs = {}

◆ eps

diffusion.Diffusion.eps = eps_

◆ geod

diffusion.Diffusion.geod

Initial value:

=  make_geodesics(self.res_grid, self.r_graph, self.M, self.m, self.axes, 
                                           self.dim, 
                                           D_force_graph_ = self.D_force_graph)

◆ geod_A_0

diffusion.Diffusion.geod_A_0

Initial value:

=  make_geodesics(self.A_0,self.r_graph, self.M, self.m, self.axes, 
                                          self.dim, 
                                          D_force_graph_ = self.D_force_graph[self.idxs_A_0,:][:,self.idxs_A_0])

◆ geod_A_1

diffusion.Diffusion.geod_A_1

Initial value:

=  make_geodesics(self.A_1,self.r_graph, self.M, self.m, self.axes, 
                                          self.dim, 
                                          D_force_graph_ = self.D_force_graph[self.idxs_A_1,:][:,self.idxs_A_1])

◆ GF

diffusion.Diffusion.GF = galois.GF(2)

◆ grad_pen

diffusion.Diffusion.grad_pen = np.array([grad_r2(pt, self.balls_centres, self.balls_radii) for pt in self.res_grid])

◆ grid

diffusion.Diffusion.grid = np.zeros((self.nx*self.ny*self.nz,self.dim))

◆ grid_size

diffusion.Diffusion.grid_size = grid_size

◆ grid_to_res_grid

dict diffusion.Diffusion.grid_to_res_grid = {}

◆ idxs

diffusion.Diffusion.idxs = np.array(idxs)

◆ idxs_A_0

diffusion.Diffusion.idxs_A_0 = np.array([t[0] for t in np.argwhere(self.res_grid[:,-1]<self.z_0)])

◆ idxs_A_1

diffusion.Diffusion.idxs_A_1 = np.array([t[0] for t in np.argwhere(self.res_grid[:,-1]>self.z_1)])

◆ idxs_to_edge

diffusion.Diffusion.idxs_to_edge

◆ inputfile

diffusion.Diffusion.inputfile = inputfile

◆ ITRIS

list diffusion.Diffusion.ITRIS

◆ K_graph

diffusion.Diffusion.K_graph = K_graph

◆ Li

diffusion.Diffusion.Li

◆ linestyle

diffusion.Diffusion.linestyle

static

◆ linewidth

diffusion.Diffusion.linewidth

static

◆ M

diffusion.Diffusion.M

static

◆ m

diffusion.Diffusion.m

static

◆ M_x

diffusion.Diffusion.M_x

◆ m_x

diffusion.Diffusion.m_x

◆ M_y

diffusion.Diffusion.M_y

◆ m_y

diffusion.Diffusion.m_y

◆ M_z

diffusion.Diffusion.M_z

static

◆ m_z

diffusion.Diffusion.m_z

static

◆ MP

diffusion.Diffusion.MP = MP

◆ N

diffusion.Diffusion.N

◆ n

int diffusion.Diffusion.n = len(emb)-1

◆ N_1

diffusion.Diffusion.N_1 = aux

◆ N_2

diffusion.Diffusion.N_2 = len(ITRIS)

◆ nx

diffusion.Diffusion.nx

◆ ny

diffusion.Diffusion.ny

◆ nz

diffusion.Diffusion.nz = (self.grid_size, self.grid_size, self.grid_size)

◆ P

diffusion.Diffusion.P

◆ PATHS

diffusion.Diffusion.PATHS = []

◆ pivot_cols

diffusion.Diffusion.pivot_cols = np.where(np.sum(self.B_red==1,axis=0)==1)[0]

◆ r_graph

float diffusion.Diffusion.r_graph = np.sqrt(np.max([self.d_x,self.d_y,self.d_z])**2)*np.sqrt(2)*1.001*self.K_graph

◆ r_graph_aux

float diffusion.Diffusion.r_graph_aux = np.sqrt(self.d_x**2 + self.d_y**2+self.d_z**2)*1.001*self.K_graph

◆ r_Li

diffusion.Diffusion.r_Li = r_Li

◆ r_P

diffusion.Diffusion.r_P = self.d_P + self.sign_var*np.var(np.linalg.norm(self.P-P_centres,axis=-1)[:,aux_P])

◆ r_S

diffusion.Diffusion.r_S = self.d_S + self.sign_var*np.var(np.linalg.norm(self.S-S_centres,axis=-1)[:,aux_S])

◆ rank

diffusion.Diffusion.rank = np.sum(np.max(self.B_red, axis=-1)>0)

◆ rank_A

diffusion.Diffusion.rank_A = np.sum(np.max(self.A_red, axis=-1)>0)

◆ REEB_GRAPH

int diffusion.Diffusion.REEB_GRAPH = -1*np.ones((grid.shape[0],values.shape[0])).astype(int)

◆ repulsion

diffusion.Diffusion.repulsion = np.zeros_like(self.D)

◆ res_grid

diffusion.Diffusion.res_grid = np.array([p for i,p in enumerate(res_grid) if i in comp])

◆ res_to_A_0

dict diffusion.Diffusion.res_to_A_0 = {}

◆ res_to_A_1

dict diffusion.Diffusion.res_to_A_1 = {}

◆ S

diffusion.Diffusion.S

◆ sign_var

diffusion.Diffusion.sign_var = sign_var

◆ simplify_grid_with_triangles

diffusion.Diffusion.simplify_grid_with_triangles = simplify_grid_with_triangles

◆ simply_connected_top_bottom

bool diffusion.Diffusion.simply_connected_top_bottom = True

◆ swap_res_grid_and_balls

diffusion.Diffusion.swap_res_grid_and_balls = swap_res_grid_and_balls

◆ tri

diffusion.Diffusion.tri = Poly3DCollection([vtx], alpha=0.3)

static

◆ V

diffusion.Diffusion.V = Q[:,-B.shape[0]:]

◆ v

diffusion.Diffusion.v = np.ones_like(self.res_grid)*v_

◆ V_

diffusion.Diffusion.V_ = Q[:,-A_.shape[0]:]

◆ verbose

diffusion.Diffusion.verbose = verbose

◆ vtx

diffusion.Diffusion.vtx = self.res_grid[tr,:]

static

◆ x

diffusion.Diffusion.x = np.linspace(self.m_x, self.M_x, self.nx+tmp)[:-1]

◆ y

diffusion.Diffusion.y = np.linspace(self.m_y, self.M_y, self.ny+tmp)[:-1]

◆ z

diffusion.Diffusion.z = np.linspace(self.m_z, self.M_z, self.nz+tmp)[:-1]

◆ z_0

diffusion.Diffusion.z_0 = self.z[0]+self.d_z*k

◆ z_1

diffusion.Diffusion.z_1 = self.z[-1]-self.d_z*k

◆ z_axis_boundaries

diffusion.Diffusion.z_axis_boundaries = z_axis_boundaries

The documentation for this class was generated from the following file:

src/diffusion.py

Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ build_graph()

◆ check_cluster()

◆ check_lithium_paths()

◆ check_lithium_ranges()

◆ cluster_deadlocks()

◆ cluster_paths()

◆ compute_vector_field_penalties()

◆ cut_until_A_0()

◆ equivalence()

◆ equivalence_wrapper()

◆ estimate_atoms_min_distances()

◆ fill_loop()

◆ fill_loop_on_slice()

◆ make_boundary_matrix_from_paths()

◆ make_cubic_to_res()

◆ make_edges()

◆ make_markov_chain_matrix()

◆ make_N()

◆ make_overlapping_summary()

◆ make_triangulation()

◆ network_plot_3D()

◆ plot_balls()

◆ plot_path()

◆ plot_paths_clustered()

◆ plot_pts()

◆ plot_results()

◆ plot_triangulation()

◆ plot_triangulation_and_paths()

◆ plot_vector_field()

◆ plot_voids()

◆ preprocess_path()

◆ produce_fobidden_region()

◆ produce_res_grid()

◆ proj_lithium_paths()

◆ prova()

◆ random_simplification_wrapper()

◆ random_simplification_wrapper_MP()

◆ reduce_boundary_mat()

◆ reeb_graph()

◆ reeb_graph_balls()

◆ reeb_graph_voids()

◆ run_A_0_to_A_1_diffusion()

◆ sample_diffusion()

◆ setup_geodesics_and_boundaries()

◆ setup_triangulation()

◆ simplify_deadlocks_with_homology()

◆ simplify_path_with_homology()

◆ simplify_paths_with_homology()

◆ traslate_box()

Member Data Documentation

◆ A

◆ a

◆ A_0

◆ A_0_to_res

◆ A_1

◆ A_1_to_res

◆ A_red

◆ aux

◆ axes

◆ B

◆ b

◆ B_red

◆ balls

◆ balls_centres

◆ balls_radii

◆ c

◆ chain

◆ close_loops_with_boundary_conditions

◆ CLUSTERS

◆ cubic_to_res

◆ cut_paths_until_A_0

◆ D

◆ D_force_graph

◆ init()