LoopStructural.interpolators.DiscreteFoldInterpolator

class LoopStructural.interpolators.DiscreteFoldInterpolator(support, fold: FoldEvent | None = None)

Bases: P1Interpolator

A piecewise linear interpolator that can also use fold constraints defined in Laurent et al., 2016

Parameters:

• support – discrete support with nodes and elements etc

• FoldEvent (fold) – a fold event with a valid geometry

__init__(support, fold: FoldEvent | None = None)

A piecewise linear interpolator that can also use fold constraints defined in Laurent et al., 2016

Parameters:

• support – discrete support with nodes and elements etc

• FoldEvent (fold) – a fold event with a valid geometry

Methods

__init__(support[, fold])	A piecewise linear interpolator that can also use fold constraints defined in Laurent et al., 2016
add_constraints_to_least_squares(A, B, idc)	Adds constraints to the least squares system.
add_equality_constraints(node_idx, values[, ...])	Adds hard constraints to the least squares system.
add_fold_constraints([fold_orientation, ...])	param fold_orientation: weight for the fold direction/orientation in the least squares system
add_gradient_constraints([w])
add_gradient_orthogonal_constraints(points, ...)	constraints scalar field to be orthogonal to a given vector
add_interface_constraints([w])
add_norm_constraints([w])
add_tangent_constraints([w])	Adds the constraints \(f(X)\cdotT=0\)
add_value_constraints([w])
build_matrix([square, damp, ie])	Assemble constraints into interpolation matrix.
calculate_residual_for_constraints()	Calculates Ax-B for all constraints added to the interpolator This could be a proxy to identify which constraints are controlling the model
check_array(array)
clean()	Removes all of the data from an interpolator
debug()	Helper function for debugging when the interpolator isn't working
evaluate_gradient(locations)	Evaluate the gradient of the scalar field at the evaluation points :param evaluation_points: xyz locations to evaluate the gradient :type evaluation_points: np.array
evaluate_value(locations)	Evaluate the value of the interpolator at location
get_data_locations()	Get the location of all data points
get_gradient_constraints()	returns: numpy array
get_inequality_constraints()
get_interface_constraints()	Get the location of interface constraints
get_norm_constraints()	returns: numpy array
get_tangent_constraints()	returns: numpy array
get_value_constraints()	returns: numpy array
minimise_edge_jumps([w, vector_func, ...])
remove_constraints_from_least_squares([...])	Remove constraints from the least squares system using the constraint ids which corresponds to the rows in the interpolation matrix.
reset()	Reset the interpolation constraints
set_gradient_constraints(points)	param points: array containing the value constraints usually 7-8 columns.
set_inequality_pairs_constraints(pointsa, ...)
set_interface_constraints(points)
set_interpolation_weights(weights)	Set the interpolation weights dictionary
set_normal_constraints(points)	param points: array containing the value constraints usually 7-8 columns.
set_region([region])	Set the region of the support the interpolator is working on
set_tangent_constraints(points)	param points: array containing the value constraints usually 7-8 columns.
set_value_constraints(points)	param points: array containing the value constraints usually 4-5 columns.
set_value_inequality_constraints(points)
setup(**kwargs)	Runs all of the required setting up stuff
setup_interpolator(**kwargs)	Searches through kwargs for any interpolation weights and updates the dictionary.
solve_system([solver])	Main entry point to run the solver and update the node value attribute for the discreteinterpolator class
to_dict()
to_json()	Returns a json representation of the geological interpolator
update()	Check if the solver is up to date, if not rerun interpolation using the previously used solver.
update_fold(fold)	param fold: a fold that contrains the geometry we are trying to add

Attributes

data
nx	Number of degrees of freedom for the interpolator
region	The active region of the interpolator.
region_map

add_constraints_to_least_squares(A, B, idc, w=1.0, name='undefined')

Adds constraints to the least squares system. Automatically works out the row index given the shape of the input arrays

Parameters:

• A (numpy array / list) – RxC numpy array of constraints where C is number of columns,R rows

• B (numpy array /list) – B values array length R

• idc (numpy array/list) – RxC column index

Returns:

list of constraint ids

add_equality_constraints(node_idx, values, name='undefined')

Adds hard constraints to the least squares system. For now this just sets the node values to be fixed using a lagrangian.

Parameters:

• node_idx (numpy array/list) – int array of node indexes

• values (numpy array/list) – array of node values

add_fold_constraints(fold_orientation=10.0, fold_axis_w=10.0, fold_regularisation=[0.1, 0.01, 0.01], fold_normalisation=1.0, fold_norm=1.0, step=2)

Parameters:

• fold_orientation (double) – weight for the fold direction/orientation in the least squares system

• fold_axis_w (double) – weight for the fold axis in the least squares system

• fold_regularisation (list) – weight for the fold regularisation in the least squares system

• fold_normalisation (double) – weight for the fold norm constraint in the least squares system

• fold_norm – length of the interpolation norm in the least squares system

• step (int) – array step for adding constraints

Notes

For more information about the fold weights see EPSL paper by Gautier Laurent 2016

add_gradient_orthogonal_constraints(points: ndarray, vector: ndarray, w: float = 1.0, B: float = 0, name='undefined gradient orthogonal constraint')

constraints scalar field to be orthogonal to a given vector

Parameters:

• points (np.darray) – location to add gradient orthogonal constraint

• vector (np.darray) – vector to be orthogonal to, should be the same shape as points

• w (double) –

• B (np.array) –

add_tangent_constraints(w=1.0)

Adds the constraints \(f(X)\cdotT=0\)

Parameters:

w (double) –

build_matrix(square=True, damp=0.0, ie=False)

Assemble constraints into interpolation matrix. Adds equaltiy constraints using lagrange modifiers if necessary

Parameters:

damp (bool) – Flag whether damping should be added to the diagonal of the matrix

Returns:

Interpolation matrix and B

calculate_residual_for_constraints()

Calculates Ax-B for all constraints added to the interpolator This could be a proxy to identify which constraints are controlling the model

Returns:

np.ndarray – vector of Ax-B

clean()

Removes all of the data from an interpolator

debug()

Helper function for debugging when the interpolator isn’t working

evaluate_gradient(locations: ndarray) → ndarray

Evaluate the gradient of the scalar field at the evaluation points :param evaluation_points: xyz locations to evaluate the gradient :type evaluation_points: np.array

evaluate_value(locations: ndarray) → ndarray

Evaluate the value of the interpolator at location

Parameters:

evaluation_points (np.ndarray) – location to evaluate the interpolator

Returns:

np.ndarray – value of the interpolator

get_data_locations()

Get the location of all data points

Returns:

numpy array – Nx3 - X,Y,Z location of all data points

get_gradient_constraints()

Returns:

numpy array

get_interface_constraints()

Get the location of interface constraints

Returns:

numpy array – Nx4 - X,Y,Z,id location of all interface constraints

get_norm_constraints()

Returns:

numpy array

get_tangent_constraints()

Returns:

numpy array

get_value_constraints()

Returns:

numpy array

property nx: int

Number of degrees of freedom for the interpolator

Returns:

int – number of degrees of freedom, positve

property region: ndarray

The active region of the interpolator. A boolean mask for all elements that are interpolated

Returns:

np.ndarray

remove_constraints_from_least_squares(name='undefined', constraint_ids=None)

Remove constraints from the least squares system using the constraint ids which corresponds to the rows in the interpolation matrix.

Parameters:

constraint_ids (np.array(dtype=int)) – id of constraints to remove

reset()

Reset the interpolation constraints

set_gradient_constraints(points: ndarray)

Parameters:

points (np.ndarray) – array containing the value constraints usually 7-8 columns. X,Y,Z,gx,gy,gz,weight

set_interpolation_weights(weights)

Set the interpolation weights dictionary

Parameters:

dictionary (weights -) – Entry of new weights to assign to self.interpolation_weights

set_normal_constraints(points: ndarray)

Parameters:

points (np.ndarray) – array containing the value constraints usually 7-8 columns. X,Y,Z,nx,ny,nz,weight

set_region(region=None)

Set the region of the support the interpolator is working on

Parameters:

function(position) (region -) – return true when in region, false when out

set_tangent_constraints(points: ndarray)

Parameters:

points (np.ndarray) – array containing the value constraints usually 7-8 columns. X,Y,Z,nx,ny,nz,weight

set_value_constraints(points: ndarray)

Parameters:

points (np.ndarray) – array containing the value constraints usually 4-5 columns. X,Y,Z,val,weight

setup(**kwargs)

Runs all of the required setting up stuff

setup_interpolator(**kwargs)

Searches through kwargs for any interpolation weights and updates the dictionary. Then adds the constraints to the linear system using the interpolation weights values :param kwargs -: interpolation weights

solve_system(solver='cg', **kwargs)

Main entry point to run the solver and update the node value attribute for the discreteinterpolator class

Parameters:

• solver (string) – solver e.g. cg, lu, chol, custom

• kwargs – kwargs for solver e.g. maxiter, preconditioner etc, damping for

Returns:

bool – True if the interpolation is run

to_json()

Returns a json representation of the geological interpolator

Returns:

json (dict) – json representation of the geological interpolator

update()

Check if the solver is up to date, if not rerun interpolation using the previously used solver. If the interpolation has not been run before it will return False

Returns:

bool

update_fold(fold)

Parameters:

fold (FoldEvent) – a fold that contrains the geometry we are trying to add