arnica.utils package¶
The utils¶
These utils are helpers around CFD-related problems.
- showy is a matplotlib helper for using subplots with re-usable templates.
- show_mat is a matplotlib helper for fast matrix plotting with legend and axis naming.
- cloud2cloud is an inverse distance interpolator without connectivity.
- directed_projection is a projection of vectors clouds along their directions.
- vector_actions is a set of vector transformation helpers.
- plot_density_mesh is a mesh rendering tool using matplotlib hist2d.
- axi_shell is a 2D i-j structured mesh mapping axycylindrical splaine-based surfaces.
- nparray2xmf is a 1-2-3D i-j-k structured numpy datastructure dumping facility to XDMF format.
Untested - to be deleted :¶
- unstructured_adjacency unstested is the beginning of mesh handling using connectivity.
- mesh_tools unstested is a 2D mesh generation in numpy for solvers
- datadict2file was a dumping facility for dictionnary-like data. To be replaced by hdfdict or h5py-wrapper* packages.
- timer_decorator is a lightweight timer for functions. Better to use cProfile…
Submodules¶
arnica.utils.axipointcloud module¶
-
class
arnica.utils.axipointcloud.
AxiPointCloud
(xcoor, ycoor, zcoor, name='Unnamed', vars=None, theta_range=None)¶ Bases:
object
Handle Axysymmetric points clouds as 1D meshs with a dict of variables
-
dump
(filename)¶ Dump an XDMF file of the pointcloud
-
dupli_rotate
(repeat=1)¶ duplicate by rotation around x, in radians
Parameters: repeat – number or repetitions integer
-
rad
()¶ Return radius np array from Y and Z
-
recompute_theta_range_from_coords
()¶ recompute theta range
-
rotate
(shift_angle)¶ rotate around x
Parameters: shift_angle – angle in radians float
-
theta
()¶ Return theta np array (radians)
- range -pi/pi
- 0 on the y+ axis (z=0, y>0)
- spanning -pi to pi
0pi=0deg Y ^ | |
-0.5pi=-90deg o——>Z 0.5pi=90deg
-
vars_stack
()¶ Stacked version numpy of variables
shape: (n, k)
-
xyz
()¶ Stacked version numpy of coordinates
shape: (n, 3)
-
arnica.utils.axishell module¶
axishell module to create x-axisymmetric shells for scientific computations
-
class
arnica.utils.axishell.
AxiShell
(n_longi, n_azi)¶ Bases:
object
Base class for x-axisymmetric computationnal shells
___________ ___---- ----___ Cylindrical system \ / Example angle = 0 deg \ / \ / r - longi \ / ^ \ / | \ ___ / | \__--- ---__/ X-----> theta - azi x
Parameters: - n_longi (int) – Number of longitudinal cut points
- n_azi (int) – Number of azimuthal cut points
- shape (tuple of int(dim 2)) – Number of cut points n_longi and n_azi
- geom –
dict() containing the geometrical parameters :
- angle - float - Axi-symmetric angle range
- angle_min - float - Minimum axi-symmetric angle
- ctrl_pts_x - tuple of float - x-component of the spline control point
- ctrl_pts_r - tuple of float - r-component of the spline control point
- matrix –
dict() containing shell data :
- xyz - np.array of dim (n_azi,n_longi,3) - Array of x,y,z-components
- r - np.array of dim (n_azi,n_longi) - Array of r-component
- theta - np.array of dim (n_azi,n_longi) - Array of theta-component
- n_x - np.array of dim (n_azi,n_longi) - Array of normal x-component
- n_y - np.array of dim (n_azi,n_longi) - Array of normal y-component
- n_z - np.array of dim (n_azi,n_longi) - Array of normal z-component
- n_r - np.array of dim (n_azi,n_longi) - Array of normal r-component
- cake –
dict() containing 3D mesh from 2D shell extrusion :
- xyz - np.array of dim (n_azi, n_longi, n_layers, 3) - Array of x,y,z-components
- dz - np.array of dim (n_azi, n_longi, n_layers) - Array of width per layer
-
add_curviwidth
(label, points)¶ Add a 2D width matrix of shell shape extruded from points spline
Parameters: - label (str) – Label of the width matrix
- points – Tuple (dim n) of tuple (dim 2) of float coordinates
-
average_on_shell_over_dirs
(variable, directions, scale=True)¶ Performs an integration (averaging) over one or multiple directions
Parameters: - variable – A np.array to be averaged of dim (n_time, n_theta, n_r)
- directions – A list() of directions on which the average process is to be performed. Contains keywords from [‘time’,’theta’,’r’].
Returns: - averaged_variable - A np.array of averaged data on given directions.
-
bake_millefeuille
(width_matrix_label, n_layers, shift=0.0)¶ Create a millefeuille-like shell.
Extrude a 2D shell in the normal direction up pointwise height given by “width_matrix_label” matrix.
Parameters: - width_matrix_label (str) – Label of the width matrix
- n_layers (int) – Number of layer for extrusion
- shift (float) – Additional depth (optional)
Returns: cake - A dict() containing shell data :
- xyz - np.array of dim (n_longi, n_azi, n_layers, 3)
- dz - np.array of dim (n_longi, n_azi, n_layers)
“Bon appetit!”
-
build_shell
()¶ Build shell from geometric features
- Construct a spline used as base for extrusion from control points : tck
- Discretise the spline : shell_crest
- Compute normal vectors for the 1D shell_crest
- Compute r,n_x,n_r-components for 2D shell
- Compute theta-components for 2D shell
- Compute xyz,n_y,n_z-components for 2D shell
-
dump
()¶ Dump AxiShell geometric features in JavaScript Object Notation
-
init_mockup
()¶ Initialize with a mockup mesh
-
load
()¶ Load AxiShell geometric features in JavaScript Object Notation
-
set_mask_on_shell
(point_cloud, tol)¶ Create a mask on the shell from a point cloud
The mask value is 1 for shell points located near cloud points.
Parameters: - point_cloud (numpy array) – Array of dim (n,3) of coordinates of points.
- tol (int) – Tolerance of proximity
-
arnica.utils.axishell.
width_mockup
()¶ Create a mockup tuple of tuple for widths
arnica.utils.axishell_2 module¶
arnica.utils.cartshell_2 module¶
arnica.utils.cartshell_3 module¶
arnica.utils.cloud2cloud module¶
interpolate a cloud from an other cloud
-
arnica.utils.cloud2cloud.
cloud2cloud
(source_xyz, source_val, target_xyz, stencil=3, limitsource=None, power=1.0, tol=None)¶ Interpolate form a cloud to an other
source_xyz : numpy array shape (n_s, 3) either (1000, 3 ) or (10,10,10, 3) source_val : numpy array shape (n_s, k) of k variables target_xyz : numpy array shape (n_t, 3) stencil (int): nb of neigbors to compute (1 is closest point)
limitsource (int) : maximum nb of source points allowed (subsample beyond) power(float) : Description tol(float) : Description Returns : ———- target_val : numpy array shape (n_t, k)
arnica.utils.cloud2cloud2 module¶
interpolate a cloud from an other cloud
Alternate version with Rbf for testing purpose. NOT WORKING YET
-
arnica.utils.cloud2cloud2.
RbfWeights
(source, target, power, eps=1e-16)¶
-
arnica.utils.cloud2cloud2.
cloud2cloud2
(source_xyz, source_val, target_xyz, power=1.0)¶ Interpolate form a cloud to an other NOT WORKING YET
source_xyz : numpy array shape (:, 3) or (:,:, 3) or (:,:,:, 3) source_val : numpy array shape (:, 3) or (:,:, k) or (:,:,:, k) k variables , first dims equal to source mesh. target_xyz : numpy array shape (:, 3) or (:,:, 3) or (:,:,:, 3) stencil (int): nb of neigbors to compute (1 is closest point)
limitsource (int) : maximum nb of source points allowed (subsample beyond) power(float) : Description tol(float) : Description Returns : ———- target_val : numpy array shape (:, 3) or (:,:, 3) or (:,:,:, 3) , first dims equal to target mesh.
arnica.utils.curve_feat_extract module¶
Extract features from a curve
-
arnica.utils.curve_feat_extract.
amax_keepshape
(arr, axis)¶ expand “row” POS from axis AXIS of an array ARR everywhere else
- Args:
- arr (np.array): source array axis (int): index of axis to expand
- Returns:
- np.array: amax on the same shape
>>> a = np.array([[0, 1, 0, 0, 0], [0, 1, 1, 1, 1], [0, 1, 2, 3, 3]]) >>> amax_keepshape(a, axis=1, pos=3) array([[1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [3, 3, 3, 3, 3]])
-
arnica.utils.curve_feat_extract.
amin_keepshape
(arr, axis)¶ expand “row” POS from axis AXIS of an array ARR everywhere else
- Args:
- arr (np.array): source array axis (int): index of axis to expand
- Returns:
- np.array: amin on the same shape
>>> a = np.array([[0, 1, 0, 0, 0], [0, 1, -1, 1, 1], [1, 1, 2, 3, 4]]) >>> amin_keepshape(a, axis=1, pos=3) array([[0, 0, 0, 0, 0], [-1, -1, -1, -1, -1], [1, 1, 1, 1, 1]])
-
arnica.utils.curve_feat_extract.
mask_boundary_layer
(source, eps=0.1, gain=1.0, axis=0)¶ Identify the cells relative to a boundary layer in a numpy multi-d array. If no fluctuation detected, only the “wall” node is set to 1.
- Args:
- source (np.array): source array eps (float): ]0,1[ relative fluctuation thresold (0.1 is 10% of max curve amplitude) gain (float): >0 increase of decrease the width of the layer found axis (int): index of axis to search
- Returns:
- np.array: masked array equal to one on the fluctuation side.
>>> a = np.array( [[ 0, 1, 0, 0, 0] [ 0, 1, 1, 1, 1] [ 0, 3, 2, 3, 4] [ 0, 1, -2, 3, 4] [ 0, 0, 0, 0, 0] [ 0, 1, 2, 3, 4]] ) >>> mask_boundary_layer(ource, eps=0.1, axis=1) array( [[1, 1, 0, 0, 0], [1, 0, 0, 0, 0], [1, 1, 0, 0, 0], [1, 1, 1, 0, 0], [1, 0, 0, 0, 0], [1, 0, 0, 0, 0]] )
-
arnica.utils.curve_feat_extract.
reptile
(arr, axis, pos)¶ expand “row” POS from axis AXIS of an array ARR everywhere else
- Args:
- arr (np.array): source array axis (int): index of axis to expand pos (int): index of element to expand
- Returns:
- np.array: Expanded array
>>> a = np.array([[0, 1, 0, 0, 0], [0, 1, 1, 1, 1], [0, 1, 2, 3, 4]]) >>> reptile(a, axis=1, pos=3) array([[0, 0, 0, 0, 0], [1, 1, 1, 1, 1], [3, 3, 3, 3, 3]])
arnica.utils.datadict2file module¶
module to data array-like dictionnary to files for visulaisation or storage pupopses
-
arnica.utils.datadict2file.
dump_dico_0d
(filename, data_dict)¶ Write statistics to file
- filename : the file name to which array dictionnary are dumped
- possible extensions : - .xlsx (if pandas is found)
- .csv (default format)
data_dict : a dictionnary holding the data arrays
None
-
arnica.utils.datadict2file.
dump_dico_1d_nparrays
(filename, data_dict)¶ Write statistics to file
- filename : the file name to which array dictionnary are dumped
- possible extensions : - .xlsx (if pandas is found)
- .csv (default format)
data_dict : a dictionnary holding the data arrays
None
-
arnica.utils.datadict2file.
dump_dico_2d_nparrays
(data_dict, filename, x_coords, y_coords, z_coords, **kw_args)¶ - data_dict : dictionnary holding the 2d arrays, on the format
- data_dict[key] = array(n1, n2) where (n1, n_2) is a subset of (n_x, n_y, n_z)
filename : the xmf filename
- <x|y|z>_coords : 2d numpy arrays for coordiantes over each axis
- must be of shape (n_1, n_2)
- time : physical time corresponding to the array
- used in the xmf file as <Time Value=”time”….
- grid_name : the name of the grid to be used in the xmf file
- as <Grid Name=”grid_name”….
- domain_name : the name of the domain to be used in the xmf file
- as <Domain Name=domain_name….
None
-
arnica.utils.datadict2file.
dump_dico_2d_time_nparrays
(data_dict, root_path, prefix, x_coords, y_coords, z_coords, **kw_args)¶ - Dumps a dictionnary of time series 2d arrays
- to xmf files
- data_dict : dictionnary holding the times series 2d
arrays, on the format data_dict[key] = array(n_time, n1, n2) where:
- n_time is the number of time steps
- (n1, n_2) is a subset of (n_x, n_y, n_z)
prefix : the prefix to be used to generate xmf filenames
- <x|y|z>_coords : 2d numpy arrays for coordiantes over each axis
- must be of shape (n_1, n_2)
- steps : a list of integer time series steps
- that will be used to generate xmf files on the format : <prefix>_<step>.xmf if None steps will be generated as the range of time dimension of data arrays
- times : a list of float physical times that will
- be used in xmf files to describe the time of each step. if None will be generated as the range of time dimension of data arrays
-
arnica.utils.datadict2file.
dump_dict2xmdf
(filename, grid, data_dict)¶ Dump 2D matrices into hdf5 file
Parameters: - filename (str) – Name of the hdf file
- grid – Array of xyz-coordinates of shape (n_v, n_u, 3)
- data_dict – Dict of field arrays of shape (n_v, n_u)
-
arnica.utils.datadict2file.
plot_dict_data_as_file
(data_dict, filename, x_data, y_data, **kw_args)¶ Generates and write XY-plot to file
- filename : the file to which the plot is written it contains
- the extension that defines the format e.g: ‘plot_toto.png’ Supported formats/extensions : png, pdf, ps, eps and svg If not provided, by default “pdf” extension is used.
data_dict : a dictionnary holding the data arrays x_data : the key to the array holding the abscissa data y_data : the key to the array holding the y data
x_label : label of the x axis, by default x_data is used (supports latex) y_label : label of the y axis, by default y_data is used (supports latex)
arnica.utils.directed_projection module¶
Module to compute the directed projection of a point to a surface along a direction
___
x---->
OST : Seven nation Army (Westworld), R. Djawadi
-
arnica.utils.directed_projection.
compute_dists
(points, directions, points_surf, normals_surf, tol)¶ Compute cylindrical distances
For a i-number of points coordinates, compute the cylindrical distances between the i,p-number of nodes with the i-number of axis.
The array is then clipped according to the node normals and the direction of the drills.
Parameters: - points (np.array) – Array of dim (i,3) of drill float coordinates
- directions (np.array) – Array of dim (i,3) of drill float axis components
- points_surf (np.array) – Array of dim (i,p,3) of nodes float coordinates
- normals_surf (np.array) – Array of dim (i,p,3) of nodes float normal components
- params – Dict of parameter
Returns: - cyl_dists - Array of dim (i,p) of float cylindrical distances
-
arnica.utils.directed_projection.
intersect_plan_line
(xyz_line, vec_line, xyz_plan, nml_plan)¶ Compute intersection coordinates of a line and a plan
- Line defined by a point xyz_line and a vector vec_line
- Plan defined by a point xyz_plan and a normal nml_plan
Arrays dimensions must be consistent together.
- ::
- nml_plan xyz_line
- A x | / | / vec_line
___x______I________ xyz_plan
Intersection point
Parameters: - xyz_line – Array of coordinates of shape (3,) or (n, 3)
- vec_line – Array of components of shape (3,) or (n,3)
- xyz_plan – Array of coordinates of shape (3,) or (n,3)
- nml_plan – Array of complonents of shape (3,) or (n,3)
Returns: xyz_intersect - Array of coordinates of shape (3,) or (n,3)
-
arnica.utils.directed_projection.
project_points
(points_source, normals, points_target)¶ Compute the projected points, radial dists and axial dists
Compute projection from source points S of dim (k,) or (i,k),on a plan defined by normals N of dim (k,), (i,k), (p,k) or (i,p,k),and points T of dim (k,), (i,k), (p,k), (i,p,k). With :
- i : Number of points to project
- p : Number of points defining plans
- k : Dimension of the domain
S T1 T2 \ ⁄ ⁄ \ ⁄ ⁄ axi_d1 \ ⁄\ ⁄ rad_d1 ⁄ \ ⁄ ⁄ rad_d2 \ ⁄ \ ⁄ axi_d2 \ ⁄\ ⁄ \ ⁄ X proj_pt2 \ N
S : Points source N : Normal T : Points target axi_d : Axial distance of the point T projected on the axis Ax rad_d : Cylindrical or Radial distance between T and the axis Ax
——> ->axi_dist = (T - S) . N
————–> -> -> projected_point = S + N * axi_dist
-> ————–>rad_dist = norm(T - projected_point)
Parameters: - points_source (np.array) – Array of source points coordinates
- proj_axis (np.array) – Array of normal components defining projection plans
- points_target (np.array) – Array of points coordinates defining projection plans
Returns: - projected_points - Array of shape points_target.shape of float coordinates
- axi_dists - Array of shape points_target.shape[:-1] of float distances
- rad_dists - Array of shape points_target.shape[:-1] of float distances
-
arnica.utils.directed_projection.
projection_kdtree
(points, directions, point_surface, normal_surface, **kwargs)¶ Project the n points following the direction on the m suface.
Parameters: - points – Array of [p] points of shape (p,3)
- directions – Array of [p] direction vectors of shape (p,3)
- point_surface – Array of [n] surface nodes of shape (n,3)
- normal_surface – Array of [n] surface node normals of shape (n,3)
- neigbors (int) – Number [k] of neigbors to take into account
- tol (float) – Maximum distance beyond cyl dist with big set to BIG
- project (bool) – If True, first project points along normal.
Returns: - projected_pts - “t” nparray of shape (n,3), projected on the surface
- indexes - neigborhood of the points (n,k)
- cyl_dist - cylindrical distance of p with each neighbor (n,k)
< shp_dist > ______s___________t__________________ |' . A | ' .< cyl_dist > . v .< surface_dist> 4 . / . / . p V align : alignment (pscal of two unit vectors, in [-1,1])
- Algorithm :
- If project bool is True, first compute [p] projection from [p] points along the [p,1] spherical closest node’s normal. If False, projected_points = points.
- Reduce computation to the [p,k] spherical closest nodes of the [p] projected_points
- Compute the [p,k] cylindrical distances from the [p,k] closest nodes to the [p] lines defined by the [p] projected points and the [p] direction vectors.
arnica.utils.lay_and_temp_manager module¶
arnica.utils.mesh_tool module¶
This module contains function to create and modify meshes
-
arnica.utils.mesh_tool.
dilate_center
(x_coor, y_coor, perturbation=0.1)¶ perturb cartesian mesh dilatation in the center
x_coor : numpy array (n,m) , x_coordinates y_coor : numpy array (n,m) , y_coordinates perturbation : float, amplitude of the perturbation perturbation
with respect to the grid sizex_coor : numpy array (n,m) , x_coordinates shifted y_coor : numpy array (n,m) , y_coordinates shifted
-
arnica.utils.mesh_tool.
gen_cart_grid_2d
(gridrange, gridpoints)¶ Generate cartesian grid.
gridrange : tuple of floats, dimensions of the grid gridpoints : tuple of ints (n,m), sampling on the grid
x_coor, y_coor : numpy arrays (n,m) with coordinates
-
arnica.utils.mesh_tool.
gen_cyl_grid_2d
(r_min, r_max, r_points, theta_min, theta_max, theta_points)¶ Generate a cylindrical grid center on x = 0 and y = 0
r_min : inner radius r_max : outer radius theta_min : lower angle [0, 2 * pi] theta_max : upper angle [0, 2 * pi] r_points : number of points in the radial direction theta_points : number of points in the tangential direction
x_coor : x coordinates of the mesh y_coor : y coordinates of the mesh
-
arnica.utils.mesh_tool.
get_mesh
(params_mesh)¶ Call specific meshing functions from mesh parameters dict
params_mesh: dictionary containing mesh parameters
x_coor: x coordinates of the mesh y_coor: y coordinates of the mesh
arnica.utils.nparray2xmf module¶
module to create an ensight compatible file to visualize your data
-
class
arnica.utils.nparray2xmf.
NpArray2Xmf
(filename, domain_name=None, mesh_name=None, time=None, xmf_only=False)¶ Bases:
object
main class for data output in XDMF format
-
add_field
(nparray_field, variable_name)¶ add a field, assuming same shape as nparray of coordiantes
-
create_grid
(nparray_x, nparray_y, nparray_z)¶ create the grid according to numpy arrays x, y ,z if arrays are 1D, switch to cloud point if arrays are 2D, switch to quad connectivity if arrays are 3D, switch to hexaedrons connectivity
-
dump
()¶ dump the final file
-
xmf_dump
()¶ create XDMF descriptor file
-
-
arnica.utils.nparray2xmf.
create_time_collection_xmf
(collection_filenames, xmf_filename)¶ Creates xmf file holding time collection of xmf files
collection_filenames: a list of single time xmf filenames to collect xmf_filename : the name of the output file
None
arnica.utils.plot_ave_with_interval module¶
Plot graphs from 1D average array with or without its confidence interval. Rotate the graph from 90 deg.
-
arnica.utils.plot_ave_with_interval.
plot_ave_with_interval
(x_arr, average, profile='average-interval', upper=None, lower=None, **kw_args)¶ Plot average profile with or without confidence interval
Parameters: - x_arr (np.array) – Array of float of x-axis
- average (np.array) – Array of float of average curve
- profile (str) – Plot type (average-interval, average, integral)
- upper (np.array) – Array of float of upper interval values
- lower – Array of float of lower interval values
Optional Keyword Args:
Parameters: - x_label (str) – Label for x-axe
- y_label (str) – Label for y-axe
- style (str) – Style of the axes - plain or sci
Returns: - plt - Matplotlib.pyplot object
arnica.utils.plot_density_mesh module¶
Plot density mesh module
-
arnica.utils.plot_density_mesh.
heat_map_mesh
(x_crd, y_crd, z_crd, show=False, save=False, view_axes='xr')¶ heat map plot of skin
-
arnica.utils.plot_density_mesh.
scatter_plot_mesh
(x_crd, y_crd, z_crd, axisym=False, show=False)¶ scatter plot of skin
arnica.utils.plot_quad2tri module¶
Module to plot a field on cartesian mesh through a triangular mesh
-
arnica.utils.plot_quad2tri.
get_connectivity
(i, j, shape)¶ Generate connectivities
Parameters: - i (int) – Index of the cell on u-axis
- j (int) – Index of the cell on v-axis
- shape – Shape of the shell
Returns: - connectivity - Array of shape (t, 3) of triangle point indexes
-
arnica.utils.plot_quad2tri.
plot_quad2tri
(grid, title, field, shading=True)¶ Generate a plot of a field on a x,y shell cartesian grid
The cartesian grid is converted into a triangle grid with connectivities. The field is extended by interpolation on the new points created. The plot is generated from the points coordinates extended and the connectivity, using tripcolor of matplotlib.
If shading is True : using ‘gouraud’ from field value defined at nodes. If shading is False : using ‘flat’ from mean field value defined at the nodes or
field value defined at the cell.Parameters: - grid – Array of shape (n_u, n_v, 2) of cartesian coordinates
- title (str) – Title of the plot
- field – Array of shape (n_u, n_v) of field values
- shading (bool) – Define if plot is shaded of not
Returns: - plt - Matplotlib object containing the graph
- ::
- 1 quad 4 tri
O———O O———O | | | / | | | | / | | | | / | | | —> | O | | | | / | | | | / | | | | / | O———O O———O
-
arnica.utils.plot_quad2tri.
quad2tri
(grid, field)¶ Divide a cartesian grid into an extended triangular grid
Parameters: grid – Array of shape (n_u, n_v, 2) of cartesian coordinates :param field Array of shape (n_u, n_v) of field values
Returns: - triangulation - Matplotlib.tri.Triangulation object containing extended grid coordinates and connectivity array
- field_at_node - Array of extended field values stored at the node
arnica.utils.plotcsv module¶
arnica.utils.same_nob module¶
-
arnica.utils.same_nob.
h5_same
(source_file: str, target_file: str, **kwargs)¶ Main call function to test two h5 files.
Parameters: - source – Path to the source file to compare
- target – Path to the target file to compare
Returns: True if files are identical, False otherwise
-
arnica.utils.same_nob.
dict_same
(source_dict: dict, target_dict: dict, **kwargs)¶ Main call function to test two dictionaries.
Parameters: - source_dict – first dict to compare
- target_dict – second dict to compare
Returns: True if files are identical, raises an error otherwise
-
arnica.utils.same_nob.
h5dict_safe
(file: str) → dict¶ h5 files safe loader with hdfdict. :param file: str ou os.Path menant au h5 à lire
arnica.utils.sample_curve_from_cloud module¶
SORT AND SAMPLE POINTS FROM CURVE
-
arnica.utils.sample_curve_from_cloud.
get_neighbor
(kdtree, point, list_points)¶ Find the closiest neighbor that has not already been found
From the kdtree, find the two closiest points of ‘point’, the 1st being itself. If the second closiest point has already been found, then the number of researched points is increased until finding a point that has not already been found.
Parameters: - kdtree – KDTree of all points.
- point (np.array) – Array of dim (k,) of point float coordinates.
- list_points – List of integer indexes
Returns: - index - Index (int) of the unfound closiest point.
- dist - Distance (float) of the closiest point from point.
-
arnica.utils.sample_curve_from_cloud.
sample_arrays_by_dist_interval
(dists, samples_res, *args)¶ Sample data and optional args at each sample_res along data
From an array containing the distance between sorted points, and from a sample resolution defined by the distance betweentwo samples, the function picks up the indexes correspondingto a sample, and returns an array of sampled distances andarrays of sampled arguments from those indexes.
- ::
- ……………. .__.__.__.__.__.
… .. .__ ..
. . | . . ……………. ===> | .__.__.__.__.__. . . . .
. ………………. . .__.__.__.__.__.__. .. ..
- …………………. 9 .__.__.__.__.__.__.__.
- 9 321 3 2 1
Parameters: - dists (np.array) – Array of dim (n,) of floats
- samples_res (float) – Sample resolution for sampling
- args – Tuple de data of dim (n,)
-
arnica.utils.sample_curve_from_cloud.
sample_points_from_cloud
(points_coor, starting_pt, n_samples=None, samples_res=None)¶ Sort and sample unsorted curve
First the point coordinates are sorted by distances. Secondly compute sample resolution if not provided. Finally sample the ordered indexes points by distance. Returns the array of coordinates ordered and sampled.
Parameters: - points_coor – Array of dim (n,k) of points coordinates
- starting_pt (np.array) – Array of dim (k,) of starting point coordinates
- n_samples (int) – Number of samples to extract
- sample_res (float) – Resolution of the sampling
Returns: - skin_cyl - Array of dim (n_samples, 3) of coordinates
-
arnica.utils.sample_curve_from_cloud.
sort_points_by_dist
(points_coor, starting_pt)¶ Reorder a point cloud by distances
.From a starting fictive point, the first point 1 of the splineiget_neighbors found, as the closiest one. . From that point, the following points are obtained with get_neighbor() until having sorted all points.
- ::
- ……………. ……………. r/y
… 2 8 .. … .. ^
. . . . | x . ……………. ===> . ……………. o—–> . . . .
. ………………. . ………………. .. ..
- …………………. ………………….
- 1 3 X 8 321
- starting_pt
Parameters: - points_coor (np.array) – Array of dim (n,k) of points coordinates
- starting_pt (np.array) – Array of dim (k,) of starting pt coordinates
Returns: - ordered_indexes - Array of dim (n,) of indexes
- ordered_dists - Array of dim (n,) of floats
arnica.utils.shell module¶
arnica.utils.show_mat module¶
This script contains function to properly visualize matrices
-
arnica.utils.show_mat.
filter_stupid_characters
(string)¶ Delete and replace stupid characters to save the figure
string: title of the plot to be changed into the filename
cleaned string
-
arnica.utils.show_mat.
show_mat
(matrix, title, show=True, save=False)¶ Show and/or save a matrix visualization.
matrix: 2d matrix title: Title of the plot show: Boolean to show the plot or not save: Boolean to save the plot or nor (automatic name from title)
None
arnica.utils.showy module¶
-
arnica.utils.showy.
showy
(layout, data, data_c=None, show=True)¶
-
arnica.utils.showy.
display
(**kwargs)¶ Retro compatibility
arnica.utils.timer_decorator module¶
small timer function
-
arnica.utils.timer_decorator.
timing
(function)¶ lazy method to time my function
arnica.utils.unstructured_adjacency module¶
Efficient implementation of unstructured mesh operations
Created Feb 8th, 2018 by C. Lapeyre (lapeyre@cerfacs.fr)
-
class
arnica.utils.unstructured_adjacency.
UnstructuredAdjacency
(connectivity)¶ Bases:
object
Efficient scipy implementation of unstructured mesh adjacency ops
The connectivity is stored in a sparse adjencency matrix A of shape (nnode, ncell). The gather operation on vector X (nnode) yields the scattered vector Y (ncell), and the scatter operation yields the filtered vector X’ (nnode). This writes:
Y = 1/nvert . A . X X’ = 1/bincount . A^t . Ywhere ^t is the transpose operation.
The gatter-scatter operation resulting in filtering X can be performed efficiently by storing:
F = 1/bincount . A^t . 1/nvert . A X’ = F . X-
get_cell2node
()¶ Return the cell2node function
-
get_filter
(times=1)¶ Return the full gather + scatter filter operation
If you need to perform the operation N times, you can use the times attribute.
-
get_node2cell
()¶ Return the node2cell function
-
ncell
¶ Total number of cells
-
ncell_per_nvert
¶ Dictionary of {nvert: ncell}
For each type of element with nvert vertices, stores the nubmer of cells ncell
-
arnica.utils.vector_actions module¶
Module concerning some 3D vector manipulations in numpy
OST :Mercy in Darkness, by Two Steps From Hell
-
arnica.utils.vector_actions.
angle_btw_vects
(np_ar_vect1, np_ar_vect2, convert_to_degree=False)¶ compute the angle in deg btw two UNIT vectors
-
arnica.utils.vector_actions.
cart_to_cyl
(vects_xyz)¶ Transform vects from xyz-system to xrtheta-system
x -> x : x = x y -> r : r = sqrt(y^2 + z^2) z -> theta : theta = arctan2(z,y)
Parameters: vects_xyz (np.array) – Array of dim (n,3) of xyz components Returns: - vects_cyl - Array of dim (n,3) of xrtheta components
-
arnica.utils.vector_actions.
clip_by_bounds
(points_coord, bounds_dict, keep='in', return_mask=False)¶ Clip a cloud by keeping only or removing a bounded region
The dict to provide must be filled as follow : bounds_dict = {component_1 : (1_min, 1_max),
compoment_2 : (2_min, 2_max), …}component_1 = [“x”, “y”, “z”, “r”, “theta”]
The bounded region can either be :
- A 1D slice if only 1 component is provided ;
- A 2D box if 2 components are provided ;
- A 3D box if 3 components are provided.
If keep=”in”, returns the point coordinates inside the bounds. If keep=”out”, returns the point coordinates outside the bounds.
If returns=True, returns the coordinates clipped If returns=False, returns the mask of boolean than can be applied on other arrays
Parameters: - point_cloud (np.array) – Array of dim (n,k) of coordinates
- bounds_dict – Dict of MAX lengh k of tuple of floats
- keep (str) – Either keeps what is inside or outside
Returns: - points_coord_clipped - Array of dim (m,k) with m<=n
OR - mask - Array of dim (n,) of booleans
-
arnica.utils.vector_actions.
cyl_to_cart
(vects_cyl)¶ Transform vects from xrtheta-system to xyz-system
x -> x : x = x r -> y : y = r * cos(theta) theta -> z : z = r * sin(theta)
Parameters: vects_cyl (np.array) – Array of dim (n,3) of xrtheta components Returns: - vects_xyz - Array of dim (n,3) of xyz components
-
arnica.utils.vector_actions.
dilate_vect_around_x
(azimuth, np_ar_vect, angle_deg_init=None, angle_deg_targ=360)¶ - dilate vectors around axis x from a specified initial range angle
- to a target range angle.
np_ar_vect : numpy array of dim (n,3) angle_deg_targ : tuple or float
numpy array of dim (n,3)
-
arnica.utils.vector_actions.
make_radial_vect
(coord, vects)¶ Recalibrate vectors to make them radial.
The vectors are readjusted to cross x-axis. It is mainly done for nodes on the limit of the boundary for axi-cylindrical geometries.
Parameters: - coord (np.array) – Array of dim (n,3) of float coordinates
- vects (np.array) – Array of dim (n,3) of float components
Returns: - radial_vect - Array of dim (n,3) of float components
-
arnica.utils.vector_actions.
mask_cloud
(np_ar_xyz, axis, support)¶ mask a cloud of n 3D points in in xyz axis among x,y,z,theta,r support a 2 value tuple : (0,3), (-12,float(inf))
x and (0,3) reads as 0 <= x < 3 ( lower bound inclusive) z and (-12,float(inf)) reads as -12 <= z theta in degree, cyl. coordinate around x axis - range -180,180 - 0 on the y+ axis (z=0, y>0)
-
arnica.utils.vector_actions.
renormalize
(np_ar_vect)¶ renormalize a numpy array of vectors considering the last axis
-
arnica.utils.vector_actions.
rotate_vect_around_axis
(xyz, *tuples_rot)¶ Rotate vector around vector or series of vector
Parameters: - xyz – Array of xyz-coordinates of shape (n,3)
- tuples_rot – List of tuple with rotation data : Axis array of shape (3,) axis, Float angle in degree
Returns: Array of rotated xyz-coordinates of shape (n,3)
-
arnica.utils.vector_actions.
rotate_vect_around_x
(np_ar_vect, angle_deg)¶ rotate vector around axis x in degree
-
arnica.utils.vector_actions.
rtheta2yz
(rrr, theta)¶ - return yz fror rtheta ,
- theta in radians measure of ange in the yz plane, - range -pi/pi - 0 on the y+ axis (z=0, y>0) spanning -pi to pi
0pi=0deg Y ^ | | -0.5pi=-90deg o------>Z 0.5pi=90deg
-
arnica.utils.vector_actions.
vect_to_quat
(vect_targ, vect_source)¶ Generate a quaternion from two vectors
A quaternion is a rotation object. From two vectors, the rotation angle and the rotation axis are computed. The rotation vector generates then a quaternion for each serie of vectors.
Parameters: - vect_targ (np.array) – Array of dim (n,3) of vect components
- vect_source (np.array) – Array of dim (n,3) of vect components
Returns: - quat - Array of quaternion of dim (n,)
-
arnica.utils.vector_actions.
yz_to_theta
(np_ar_vect)¶ - return theta , a radians measure of ange in the yz plane,
- range -pi/pi
- 0 on the y+ axis (z=0, y>0)
- spanning -pi to pi
- 0pi=0deg
-0.5pi=-90deg o——>Z 0.5pi=90deg