Skip to content

Drillholes

Collar, survey and interval tables desurveyed by method: "minimum_curvature" (circular arcs), "tangential" (each survey's direction holds down to the next) or "balanced_tangential" (half of each segment along each end's direction). Survey angles are azimuth (clockwise from north) and either dip (degrees below horizontal) or inclination (degrees from vertical); holes without survey are vertical.

bounds property 

bounds

(min, max) corners of the desurveyed holes, None without stations.

column_names property 

column_names

Names of the interval columns.

coords property 

coords

(n, 3) interval midpoints.

interval_columns property 

interval_columns

Hole, from and to column names of the interval table, if one was given.

length_unit property 

length_unit

Unit of the coordinates and depths, such as m or ft; None when not declared.

x property 

x

x of each row's coordinates.

y property 

y

y of each row's coordinates.

z property 

z

z of each row's coordinates.

at method descriptor 

at(holes, depths)

(n, 3) positions at measured depths down holes, e.g. contacts.

composite method descriptor 

composite(
    length,
    grades,
    *,
    domain=None,
    intervals=None,
    residual="keep",
    min_fraction=0.5,
    categories=Ellipsis,
)

Length-weighted composites, never crossing a change of domain and located at their midpoints. Composites with none of the grades sampled are dropped. Each grade comes with its sampled length, <grade>_length, so the sum of grade × <grade>_length equals the input metal; length also counts unsampled ground. The hole column keeps its constructor name, followed by from, to and length.

Parameters:

Name Type Description Default
length (float, str or None)

Composite length in the length unit of the holes, or text such as "2 m"; None gives one composite per run of domain.

 required
grades sequence of str

Numeric columns, averaged over the length that carries a value.

 required
domain str

Column whose changes composites never cross.

 None
intervals table

Hole, from and to columns (named as in the constructor) of non-overlapping intervals to composite to instead of length, e.g. benches; ground outside them is left out.

 None
residual (keep, drop, merge)

What to do with the tail of a run shorter than min_fraction * length; merge adds it to the previous composite of the run, if there is one.

 "keep"
min_fraction float

Tail length, as a fraction of length, below which residual applies.

 0.5
categories sequence of str

Categorical columns, composited to the value covering the most length.

 Ellipsis

from_tables 

from_tables(tables, *, intervals='assays', **options)

Drillholes from a mapping with collars and surveys tables, plus the intervals table (None for none), as the datasets return them; options go to the constructor.

mesh_intervals method descriptor 

mesh_intervals(mesh, *, step=1.0, tolerance=0.01)

Splits each hole's path against a closed mesh, wherever it crosses the surface.

The path is sampled every step of depth and a crossing between two samples is bisected down to tolerance; a boundary crossed more than once within one step is missed. Every depth down every hole falls in exactly one row, so piping the result through merge_intervals splits assays exactly at the mesh instead of at a logged contact.

Parameters:

Name Type Description Default
mesh Mesh

A closed mesh.

 required
step float

Sampling step down each hole, in meters.

 1.0
tolerance float

Depth tolerance the crossing is refined to, in meters.

 0.01

Returns:

Type Description
Table

Hole (named as in the constructor), FROM, TO and INSIDE (whether the run is inside mesh), one row per run down each hole — matching merge_intervals's own column names.

paths method descriptor 

paths()

Desurveyed stations: hole (named as in the constructor), depth, x, y, z.

runs method descriptor 

runs(
    grade,
    *,
    cutoff=None,
    category=None,
    ore=Ellipsis,
    min_length=Ellipsis,
    max_dilution=Ellipsis,
    edge=Ellipsis,
)

Ore and waste runs down each hole: contiguous intervals above cutoff (or of an ore category), cleaned by mining rules. The runs of a hole partition its samples, so Σ grade × length equals the sample metal.

Rules apply in order: internal dilution, then edge dilution, then minimum length. Samples missing the grade are left out, as unsampled ground, and samples missing the category are waste; like composite(None, ...), gaps are skipped, not bridged.

Parameters:

Name Type Description Default
grade str or None

Numeric column; None with category for runs without grades.

 required
cutoff float

Samples at or above it are ore, unless category is given; also the grade a run must keep when it takes in internal dilution.

 None
category str

Column whose values in ore flag ore samples.

 None
ore sequence of str

Ore values of category.

 Ellipsis
min_length float

Runs spanning less, shortest first, take their neighbors' flag and merge with them.

 Ellipsis
max_dilution float

Waste runs between ore spanning at most this are taken into the ore when the grade of the three together stays at or above cutoff.

 Ellipsis
edge float

Waste taken into each ore run on each side where it meets waste.

 Ellipsis

Returns:

Type Description
Table

Hole (named as in the constructor), from, to, length (sampled length), the grade, and ore, one row per run down each hole.

samples method descriptor 

samples()

Interval midpoints with every interval column; intervals of holes without a collar are dropped.

used in