Variography

plot_semivariogram(variograms, model=None, model_angles=None, display_npairs=False, method=<VariographyMethod.SEMIVARIOGRAM: 'SEMIVARIOGRAM'>, save_file=None)

Semivariogram plot.

Parameters:

Name	Type	Description	Default
variograms	List	A pandas DataFrame with at least "vario" column in it.	required
model	Optional[geolime.geostats.models.covariance.Covariance]	Covariance model to be applied. Defaults to None.	None
model_angles	Optional[List[Dict[str, float]]]	Display variogram model along other orientations. {azi: float, dip: float, pitch: float, label: str}. Defaults to None.	None
display_npairs	Optional[bool]	Display barplot with number of pairs if True. Defaults to False.	False
method	VariographyMethod	"COVARIOGRAM" or "SEMIVARIOGRAM". Defaults to "SEMIVARIOGRAM".	<VariographyMethod.SEMIVARIOGRAM: 'SEMIVARIOGRAM'>
save_file	str	Filename of saved figure. Defaults to None.	None

Returns:

Type	Description
None	1D plot of variograms and models.

Source code in geolime/plotting/vario_plot.py

def plot_semivariogram(
    variograms: List,
    model: Optional[Covariance] = None,
    model_angles: Optional[List[Dict[str, float]]] = None,
    display_npairs: Optional[bool] = False,
    method: VariographyMethod = VariographyMethod.SEMIVARIOGRAM,
    save_file: str = None
) -> None:
    """
    Semivariogram plot.

    Args:
        variograms:
            A pandas DataFrame with at least "vario" column in it.
        model:
            Covariance model to be applied. Defaults to None.
        model_angles:
            Display variogram model along other orientations.
            {azi: float, dip: float, pitch: float, label: str}. Defaults to None.
        display_npairs:
            Display barplot with number of pairs if True. Defaults to False.
        method:
            "COVARIOGRAM" or "SEMIVARIOGRAM". Defaults to "SEMIVARIOGRAM".
        save_file:
            Filename of saved figure. Defaults to None.

    Returns:
        1D plot of variograms and models.

    """
    fig, ax = plt.subplots()

    colors = plt.cm.jet(np.linspace(0, 1, len(variograms)))

    svmax = 0

    for i, v in enumerate(variograms):
        legend_str = strip_extra_ws(f"""
            A: {v.attrs["geographic_azimuth"]},
            D: {v.attrs["dip"]},
            P: {v.attrs["pitch"]}
        """)
        ax.plot(v["avgdist"], v["vario"], color=colors[i], marker="o", label=legend_str)
        ax.set_ylabel("Semivariance")
        ax.set_xlabel("Average distance")
        ax.yaxis.tick_left()

        # retrieve max value for setting y limit later on
        if svmax < v["vario"].max():
            svmax = v["vario"].max()

        if display_npairs:
            # add variogram value to points
            for j, value in enumerate(v["npairs"]):
                ax.annotate(value, (v["lag"][j], v["vario"][j] + v["vario"][j] * 0.05))

    ax.legend(loc="upper left", bbox_to_anchor=(1.05, 1))
    ax.set_ylim(bottom=0, top=svmax + 0.15 * svmax)
    ax.set_xlim(left=0)

    if model:

        # Compute max_lag to strip model
        max_lag = np.max([vario["lag"].max() for vario in variograms])

        # store default vdir
        if model_angles:
            original_vdir = v.attrs["directional_vector"]
            for angle in model_angles:
                vdir, _, _ = directional_vector(
                    angle["azi"],
                    angle["dip"],
                    angle["pitch"]
                )
                vdir = vdir[:v.attrs["dim"]]
                v.attrs["directional_vector"] = vdir
                distance, results = model._compute_model(
                    angles=[angle["azi"], angle["dip"], angle["pitch"]],
                    method=method
                )
                bool_array = distance <= max_lag
                distance = distance[bool_array]
                results = results[bool_array]
                legend_str = strip_extra_ws(f"""
                    A: {angle["azi"]},
                    D: {angle["dip"]},
                    P: {angle["pitch"]}
                """)
                ax.plot(distance, results, label=legend_str)

            v.attrs["directional_vector"] = original_vdir
        else:
            distance, results = model._compute_model([0., 0., 0.], method, max_lag)
            bool_array = distance <= max_lag
            distance = distance[bool_array]
            results = results[bool_array]
            ax.plot(distance, results, label="A: 0, D:0, P:0")

    ax.legend(loc="upper left", bbox_to_anchor=(1.05, 1))

    if save_file is not None:
        fig.savefig(save_file, bbox_inches='tight')
        plt.close()
    else:
        plt.show()

vario_azimuth(object, attribute, region, lags, tol, n_az, atol)

Compute VarioContour as Pie Chart. Angle of slice equals angular tolerance and slice radius equals lag distance.

Parameters:

Name	Type	Description	Default
object	GeoRefObject	Geo-ref Object.	required
attribute	str	Object attribute to compute variography on.	required
region	Optional[str]	Object region to select data from.	required
lags	List[float]	List of lags, in meters.	required
tol	float	Lag tolerance, in percent.	required
n_az	int	Number of azimuth to compute variogram.	required
atol	float	Angular tolerance for variogram computation.	required

Returns:

Type	Description
Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]	Computed values of azimuthal variomap.

Source code in geolime/plotting/vario_plot.py

def vario_azimuth(
    object: GeoRefObject,
    attribute: str,
    region: Optional[str],
    lags: List[float],
    tol: float,
    n_az: int,
    atol: float,
) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
    """
    Compute VarioContour as Pie Chart. Angle of slice equals angular tolerance
    and slice radius equals lag distance.

    Args:
        object:
            Geo-ref Object.
        attribute:
            Object attribute to compute variography on.
        region:
            Object region to select data from.
        lags:
            List of lags, in meters.
        tol:
            Lag tolerance, in percent.
        n_az:
            Number of azimuth to compute variogram.
        atol:
            Angular tolerance for variogram computation.

    Returns:
        Computed values of azimuthal variomap.

    """
    # Convert number of azimuth to even number
    n_az = ceil(n_az / 2) * 2

    # Compute azimuth list in degrees and radians
    # Degree list is for computing : only needs half of the circle
    azm_deg = np.linspace(0, 180 * ((n_az - 2) / n_az), n_az // 2)

    # Radian list is for plotting : needs all the circle
    azm_rad = np.linspace(0, 2 * np.pi * ((n_az - 1) / n_az), n_az)

    # Pcontourf and pcolomesh use nodes values : needs to close circle
    azm_rad = np.append(azm_rad, 2 * np.pi)

    r, th = np.meshgrid(lags, azm_rad)
    z = np.ones_like(r, dtype=np.float64)

    # Compute value for halph circle and apply it to symmetric
    for j, az in enumerate(azm_deg):
        t = variogram(
            object=object,
            attribute=attribute,
            region=region,
            geographic_azimuth=az,
            dip=0,
            pitch=0,
            lags=lags,
            tol=tol,
            atol=atol
        )['vario']
        z[j, :] = np.concatenate((t.values, np.zeros(z.shape[1] - t.values.shape[0])))

        z[j + n_az // 2, :] = np.concatenate((t.values, np.zeros(z.shape[1] - t.values.shape[0])))

    # Last value is first value : 0 degrees value == 360 degrees value
    z[-1, :] = z[0, :]

    return r, th, z

vario_contour(object, attribute, region, lags, tol, n_az, atol, user_azimuth=None, c_step=None, save_file=None)

Plot Azimuth VarioContour as Pie Chart. Angle of slice equals angular tolerance and slice radius equals lag distance.

Parameters:

Name	Type	Description	Default
object	GeoRefObject	Geo-ref Object.	required
attribute	str	Object attribute to compute variography on.	required
region	Optional[str]	Object region to select data from.	required
lags	List[float]	List of lags, in meters.	required
tol	float	Lag tolerance, in percent.	required
n_az	int	Number of azimuth to compute variogram.	required
atol	float	Angular tolerance for variogram computation.	required
user_azimuth	Optional[float]	Azimuth value to be displayed. Defaults to None.	None
c_step	Optional[int]	Number of discretization steps of iso-values. Defaults to None.	None
save_file	str	Filename of saved figure. Defaults to None.	None

Returns:

Type	Description
None	Plot Azimuth variocontour.

Source code in geolime/plotting/vario_plot.py

def vario_contour(
    object: GeoRefObject,
    attribute: str,
    region: Optional[str],
    lags: List[float],
    tol: float,
    n_az: int,
    atol: float,
    user_azimuth: Optional[float] = None,
    c_step: Optional[int] = None,
    save_file: str = None
) -> None:
    """
    Plot Azimuth VarioContour as Pie Chart.
    Angle of slice equals angular tolerance and slice radius equals lag distance.

    Args:
        object:
            Geo-ref Object.
        attribute:
            Object attribute to compute variography on.
        region:
            Object region to select data from.
        lags:
            List of lags, in meters.
        tol:
            Lag tolerance, in percent.
        n_az:
            Number of azimuth to compute variogram.
        atol:
            Angular tolerance for variogram computation.
        user_azimuth:
            Azimuth value to be displayed. Defaults to None.
        c_step:
            Number of discretization steps of iso-values. Defaults to None.
        save_file:
            Filename of saved figure. Defaults to None.

    Returns:
        Plot Azimuth variocontour.

    """
    r, th, z = vario_azimuth(
        object,
        attribute,
        region,
        lags,
        tol,
        n_az,
        atol
    )

    # O means no data, misleading in plot
    z = np.where(z == 0, np.nan, z)

    # Plotting
    fig = plt.figure()
    ax = fig.add_subplot(111, projection="polar")
    ax.set_theta_zero_location("N")
    ax.set_theta_direction(-1)
    my_cmap = plt.cm.get_cmap("viridis")
    ax.contourf(th, r, z, cmap=my_cmap, levels=c_step)
    ax.grid()
    sm = ScalarMappable(cmap=my_cmap, norm=plt.Normalize(np.nanmin(z), np.nanmax(z)))
    sm.set_array([])
    cbar = fig.colorbar(sm)
    cbar.set_label("Semivariance", rotation=270, labelpad=25)
    if user_azimuth is not None:
        R1 = np.linspace(0, np.nanmax(r), 100)
        theta = np.ones(100) * user_azimuth * (np.pi / 180.0)
        ax.plot(theta, R1, lw=2.5)
    if save_file is not None:
        fig.savefig(save_file, bbox_inches='tight')
        plt.close()
    else:
        plt.show()

vario_contour_dip(object, attribute, region, lags, tol, azimuth, n_dip, atol, user_dip=None, c_step=None, save_file=None)

Plot VarioContour for a given azimuth as a semi Pie Chart. Angle of slice equals angular tolerance and slice radius equals lag distance.

Parameters:

Name	Type	Description	Default
object	GeoRefObject	Geo-ref Object.	required
attribute	str	Object attribute to compute variography on.	required
region	Optional[str]	Object region to select data from.	required
lags	List[float]	List of lags, in meters.	required
tol	float	Lag tolerance, in percent.	required
azimuth	float	Azimuth value along which dip is searched.	required
n_dip	int	Number of dip to compute variogram.	required
atol	float	Angular tolerance for variogram computation.	required
user_dip	Optional[float]	Dip value to be displayed. Defaults to None.	None
c_step	Optional[int]	Number of discretization steps of iso-values. Defaults to None.	None
save_file	str	Filename of saved figure. Defaults to None.	None

Returns:

Type	Description
None	2D plot of dip variomap along a given azimuth.

Source code in geolime/plotting/vario_plot.py

def vario_contour_dip(
    object: GeoRefObject,
    attribute: str,
    region: Optional[str],
    lags: List[float],
    tol: float,
    azimuth: float,
    n_dip: int,
    atol: float,
    user_dip: Optional[float] = None,
    c_step: Optional[int] = None,
    save_file: str = None
) -> None:
    """
    Plot VarioContour for a given azimuth as a semi Pie Chart.
    Angle of slice equals angular tolerance and slice radius equals lag distance.

    Args:
        object:
            Geo-ref Object.
        attribute:
            Object attribute to compute variography on.
        region:
            Object region to select data from.
        lags:
            List of lags, in meters.
        tol:
            Lag tolerance, in percent.
        azimuth:
            Azimuth value along which dip is searched.
        n_dip:
            Number of dip to compute variogram.
        atol:
            Angular tolerance for variogram computation.
        user_dip:
            Dip value to be displayed. Defaults to None.
        c_step:
            Number of discretization steps of iso-values. Defaults to None.
        save_file:
            Filename of saved figure. Defaults to None.

    Returns:
        2D plot of dip variomap along a given azimuth.

    """
    r, th, z = vario_dip(
        object,
        attribute,
        region,
        lags,
        tol,
        azimuth,
        n_dip,
        atol
    )

    # O means no data, misleading in plot
    z = np.where(z == 0, np.nan, z)

    # Plotting
    fig = plt.figure()
    ax = fig.add_subplot(111, projection="polar")
    ax.set_theta_zero_location("E")
    ax.set_theta_direction(-1)
    ax.set_thetalim(-np.pi / 2, 3 * np.pi / 2)
    my_cmap = plt.cm.get_cmap("viridis")
    ax.contourf(th, r, z, cmap=my_cmap, levels=c_step)
    ax.grid()
    sm = ScalarMappable(cmap=my_cmap, norm=plt.Normalize(np.nanmin(z), np.nanmax(z)))
    sm.set_array([])
    cbar = fig.colorbar(sm)
    cbar.set_label("Semivariance", rotation=270, labelpad=25)
    if user_dip is not None:
        R1 = np.linspace(0, np.nanmax(r), 100)
        theta = np.ones(100) * user_dip * (np.pi / 180.0)
        ax.plot(theta, R1, lw=2.5)
    if save_file is not None:
        fig.savefig(save_file, bbox_inches='tight')
        plt.close()
    else:
        plt.show()

vario_contour_pitch(object, attribute, region, lags, tol, azimuth, dip, n_pitch, atol, user_pitch=None, c_step=None, save_file=None)

Plot VarioContour for given azimuth and pitch as a semi Pie Chart. Angle of slice equals angular tolerance and slice radius equals lag distance.

Parameters:

Name	Type	Description	Default
object	GeoRefObject	Geo-ref Object.	required
attribute	str	Object attribute to compute variography on.	required
region	Optional[str]	Object region to select data from.	required
lags	List[float]	List of lags, in meters.	required
tol	float	Lag tolerance, in percent.	required
azimuth	float	Azimuth along which pitch is searched.	required
dip	float	Dip along which pitch is searched.	required
n_pitch	int	Number of dip to compute variogram.	required
atol	float	Angular tolerance for variogram computation.	required
user_pitch	Optional[float]	Pitch value to be displayed. Defaults to None.	None
c_step	Optional[int]	Number of discretization steps of iso-values. Defaults to None.	None
save_file	str	Filename of saved figure. Defaults to None.	None

Returns:

Type	Description
None	2D plot of pitch variomap along given azimuth and dip.

Source code in geolime/plotting/vario_plot.py

def vario_contour_pitch(
    object: GeoRefObject,
    attribute: str,
    region: Optional[str],
    lags: List[float],
    tol: float,
    azimuth: float,
    dip: float,
    n_pitch: int,
    atol: float,
    user_pitch: Optional[float] = None,
    c_step: Optional[int] = None,
    save_file: str = None
) -> None:
    """
    Plot VarioContour for given azimuth and pitch as a semi Pie Chart.
    Angle of slice equals angular tolerance and slice radius equals lag distance.

    Args:
        object:
            Geo-ref Object.
        attribute:
            Object attribute to compute variography on.
        region:
            Object region to select data from.
        lags:
            List of lags, in meters.
        tol:
            Lag tolerance, in percent.
        azimuth:
            Azimuth along which pitch is searched.
        dip:
            Dip along which pitch is searched.
        n_pitch:
            Number of dip to compute variogram.
        atol:
            Angular tolerance for variogram computation.
        user_pitch:
            Pitch value to be displayed. Defaults to None.
        c_step:
            Number of discretization steps of iso-values. Defaults to None.
        save_file:
            Filename of saved figure. Defaults to None.

    Returns:
        2D plot of pitch variomap along given azimuth and dip.

    """
    r, th, z = vario_pitch(
        object,
        attribute,
        region,
        lags,
        tol,
        azimuth,
        dip,
        n_pitch,
        atol
    )

    # O means no data, misleading in plot
    z = np.where(z == 0, np.nan, z)

    # Plotting
    fig = plt.figure()
    ax = fig.add_subplot(111, projection="polar")
    ax.set_theta_zero_location("N")
    ax.set_theta_direction(-1)
    ax.set_thetalim(-np.pi / 2, 3 * np.pi / 2)
    my_cmap = plt.cm.get_cmap("viridis")
    ax.contourf(th, r, z, cmap=my_cmap, levels=c_step)
    ax.grid()
    sm = ScalarMappable(cmap=my_cmap, norm=plt.Normalize(np.nanmin(z), np.nanmax(z)))
    sm.set_array([])
    cbar = fig.colorbar(sm)
    cbar.set_label("Semivariance", rotation=270, labelpad=25)
    if user_pitch is not None:
        R1 = np.linspace(0, np.nanmax(r), 100)
        theta = np.ones(100) * user_pitch * (np.pi / 180.0)
        ax.plot(theta, R1, lw=2.5)
    if save_file is not None:
        fig.savefig(save_file, bbox_inches='tight')
        plt.close()
    else:
        plt.show()

vario_dip(object, attribute, region, lags, tol, azimuth, n_dip, atol)

Compute VarioContour for a given azimuth as a semi Pie Chart. Angle of slice equals angular tolerance and slice radius equals lag distance.

Parameters:

Name	Type	Description	Default
object	GeoRefObject	Geo-ref Object.	required
attribute	str	Object attribute to compute variography on.	required
region	Optional[str]	Object region to select data from.	required
lags	List[float]	List of lags, in meters.	required
tol	float	Lag tolerance, in percent.	required
azimuth	float	Azimuth value along which dip is searched.	required
n_dip	int	Number of dip to compute variogram.	required
atol	float	Angular tolerance for variogram computation.	required

Returns:

Type	Description
Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]	Computed values of dip variomap along a given azimuth.

Source code in geolime/plotting/vario_plot.py

def vario_dip(
    object: GeoRefObject,
    attribute: str,
    region: Optional[str],
    lags: List[float],
    tol: float,
    azimuth: float,
    n_dip: int,
    atol: float
) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
    """
    Compute VarioContour for a given azimuth as a semi Pie Chart.
    Angle of slice equals angular tolerance and slice radius equals lag distance.

    Args:
        object:
            Geo-ref Object.
        attribute:
            Object attribute to compute variography on.
        region:
            Object region to select data from.
        lags:
            List of lags, in meters.
        tol:
            Lag tolerance, in percent.
        azimuth:
            Azimuth value along which dip is searched.
        n_dip:
            Number of dip to compute variogram.
        atol:
            Angular tolerance for variogram computation.

    Returns:
        Computed values of dip variomap along a given azimuth.

    """
    # Convert number of dip to even number
    n_dip = ceil(n_dip / 2) * 2

    # Compute dip list in degrees and radians
    # Degree list is for computing : only needs half of the circle
    dip_deg = np.linspace(-90, 90 * ((n_dip - 2) / n_dip), n_dip // 2)

    # Radian list is for plotting : needs half circle
    dip_rad = np.linspace(-np.pi / 2, 3 * np.pi / 2 * ((n_dip - 1) / n_dip), n_dip)

    # Pcontourf and pcolomesh use nodes values : needs to close circle
    dip_rad = np.append(dip_rad, 3 * np.pi / 2)

    r, th = np.meshgrid(lags, dip_rad)
    z = np.ones_like(r, dtype=np.float64)

    for j, dip in enumerate(dip_deg):
        if dip < 0:
            dip = - dip
            azimuth = azimuth + 180 if azimuth <= 180 else azimuth - 180

        t = variogram(
            object=object,
            attribute=attribute,
            region=region,
            geographic_azimuth=azimuth,
            dip=dip,
            pitch=90,
            lags=lags,
            tol=tol,
            atol=atol
        )["vario"]
        z[j, :] = np.concatenate((t.values, np.zeros(z.shape[1] - t.values.shape[0])))
        z[j + n_dip // 2, :] = np.concatenate((t.values, np.zeros(z.shape[1] - t.values.shape[0])))

    # Last value is first value : 0 degrees value == 360 degrees value
    z[-1, :] = z[0, :]

    return r, th, z

vario_map(object, attribute, region, lags, tol, n_az, atol, user_azimuth=None, save_file=None)

Plot Azimuth VarioMap as Pie Chart. Angle of slice equals angular tolerance and slice radius equals lag distance.

Parameters:

Name	Type	Description	Default
object	GeoRefObject	Geo-ref Object.	required
attribute	str	Object attribute to compute variography on.	required
region	Optional[str]	Object region to select data from.	required
lags	List[float]	List of lags, in meters.	required
tol	float	Lag tolerance, in percent.	required
n_az	int	Number of azimuth to compute variogram.	required
atol	float	Angular tolerance for variogram computation.	required
user_azimuth	Optional[float]	Azimuth value to be displayed. Defaults to None.	None
save_file	str	Filename of saved figure. Defaults to None.	None

Returns:

Type	Description
None	Plot Azimuth variomap.

Source code in geolime/plotting/vario_plot.py

def vario_map(
    object: GeoRefObject,
    attribute: str,
    region: Optional[str],
    lags: List[float],
    tol: float,
    n_az: int,
    atol: float,
    user_azimuth: Optional[float] = None,
    save_file: str = None
) -> None:
    """
    Plot Azimuth VarioMap as Pie Chart.
    Angle of slice equals angular tolerance and slice radius equals lag distance.

    Args:
        object:
            Geo-ref Object.
        attribute:
            Object attribute to compute variography on.
        region:
            Object region to select data from.
        lags:
            List of lags, in meters.
        tol:
            Lag tolerance, in percent.
        n_az:
            Number of azimuth to compute variogram.
        atol:
            Angular tolerance for variogram computation.
        user_azimuth:
            Azimuth value to be displayed. Defaults to None.
        save_file:
            Filename of saved figure. Defaults to None.

    Returns:
        Plot Azimuth variomap.

    """
    # Convert number of azimuth to even number
    n_az = ceil(n_az / 2) * 2

    # Compute azimuth list in degrees and radians
    # Degree list is for computing : only needs half of the circle
    azm_deg = np.arange(0, 180, 180 / (n_az // 2))

    # Radian list is for plotting : needs all the circle
    azm_rad = np.arange(0, 2 * np.pi, 2 * np.pi / n_az)
    r, th = np.meshgrid(lags, azm_rad)
    z = np.ones_like(r, dtype=np.float64)

    # Compute value for halph circle and apply it to symmetric
    for j, az in enumerate(azm_deg):
        t = variogram(
            object=object,
            attribute=attribute,
            region=region,
            geographic_azimuth=az,
            dip=0,
            pitch=0,
            lags=lags,
            tol=tol,
            atol=atol
        )["vario"]

        z[j, :] = np.concatenate((t.values, np.zeros(z.shape[1] - t.values.shape[0])))

        z[j + n_az // 2, :] = np.concatenate((t.values, np.zeros(z.shape[1] - t.values.shape[0])))

    # O means no data, misleading in plot
    z = np.where(z == 0, np.nan, z)

    # Plotting
    fig = plt.figure()
    ax = fig.add_subplot(111, projection="polar")
    ax.set_theta_zero_location("N")
    ax.set_theta_direction(-1)
    my_cmap = plt.cm.get_cmap("viridis")
    for j in range(len(azm_rad)):
        ax.bar(
            np.ones(len(lags)) * azm_rad[j],
            lags,
            width=np.ones(len(lags)) * np.deg2rad(360 / n_az),
            color=[plt.cm.viridis(z[j, i] / np.nanmax(z)) for i in range(z.shape[1])],
            bottom=shift(lags, 1, cval=0)
        )

    ax.grid()
    ax.set_ylim(0, lags[-1])
    sm = ScalarMappable(cmap=my_cmap, norm=plt.Normalize(np.nanmin(z), np.nanmax(z)))

    sm.set_array([])
    cbar = fig.colorbar(sm)
    cbar.set_label("Semivariance", rotation=270, labelpad=25)
    if user_azimuth is not None:
        R1 = np.linspace(0, np.nanmax(z), 100)
        theta = np.ones(100) * user_azimuth * (np.pi / 180.0)
        ax.plot(theta, R1, lw=2.5)
    if save_file is not None:
        fig.savefig(save_file, bbox_inches='tight')
        plt.close()
    else:
        plt.show()

vario_map_summary(object, attribute, region, lags, tol, azimuth, dip, pitch, n_step, atol, c_step=None, save_file=None)

Plot VarioContour for a given azimuth, dip and pitch as Pie Charts. Angle of slice equals angular tolerance and slice radius equals lag distance.

Parameters:

Name	Type	Description	Default
object	GeoRefObject	Geo-ref Object.	required
attribute	str	Object attribute to compute variography on.	required
region	Optional[str]	Object region to select data from.	required
lags	List[float]	List of lags, in meters.	required
tol	float	Lag tolerance, in percent.	required
azimuth	float	Azimuth value along which dip is searched.	required
dip	float	Dip value along which dip is searched.	required
pitch	float	Pitch value along which dip is searched.	required
n_step	int	Number of step to compute variogram.	required
atol	float	Angular tolerance for variogram computation.	required
c_step	Optional[int]	Number of discretization steps of iso-values. Defaults to None.	None
save_file	str	Filename of saved figure. Defaults to None.	None

Returns:

Type	Description
None	Summary of 3 2D subplots variomaps of azimuth, dip and pitch.

Source code in geolime/plotting/vario_plot.py

def vario_map_summary(
    object: GeoRefObject,
    attribute: str,
    region: Optional[str],
    lags: List[float],
    tol: float,
    azimuth: float,
    dip: float,
    pitch: float,
    n_step: int,
    atol: float,
    c_step: Optional[int] = None,
    save_file: str = None
) -> None:
    """
    Plot VarioContour for a given azimuth, dip and pitch as Pie Charts.
    Angle of slice equals angular tolerance and slice radius equals lag distance.

    Args:
        object:
            Geo-ref Object.
        attribute:
            Object attribute to compute variography on.
        region:
            Object region to select data from.
        lags:
            List of lags, in meters.
        tol:
            Lag tolerance, in percent.
        azimuth:
            Azimuth value along which dip is searched.
        dip:
            Dip value along which dip is searched.
        pitch:
            Pitch value along which dip is searched.
        n_step:
            Number of step to compute variogram.
        atol:
            Angular tolerance for variogram computation.
        c_step:
            Number of discretization steps of iso-values. Defaults to None.
        save_file:
            Filename of saved figure. Defaults to None.

    Returns:
        Summary of 3 2D subplots variomaps of azimuth, dip and pitch.

    """
    r_az, th_az, z_az = vario_azimuth(
        object,
        attribute,
        region,
        lags,
        tol,
        n_step,
        atol
    )

    # O means no data, misleading in plot
    z_az = np.where(z_az == 0, np.nan, z_az)

    r_dip, th_dip, z_dip = vario_dip(
        object,
        attribute,
        region,
        lags,
        tol,
        azimuth,
        n_step,
        atol
    )
    # O means no data, misleading in plot
    z_dip = np.where(z_dip == 0, np.nan, z_dip)

    r_pitch, th_pitch, z_pitch = vario_pitch(
        object,
        attribute,
        region,
        lags,
        tol,
        azimuth,
        dip,
        n_step,
        atol
    )

    # O means no data, misleading in plot
    z_pitch = np.where(z_pitch == 0, np.nan, z_pitch)

    # Figure Creation
    fig, (ax0, ax1, ax2) = plt.subplots(ncols=3, subplot_kw=dict(projection="polar"))
    cmap = 'viridis'

    # Plot Azimuth VarioContour
    azi_plot = ax0.contourf(th_az, r_az, z_az, cmap=cmap, levels=c_step)
    R1 = np.linspace(0, np.nanmax(r_az), 100)
    theta = np.ones(100) * azimuth * (np.pi / 180.0)
    ax0.plot(theta, R1, lw=2.5)
    ax0.set_theta_zero_location("N")
    ax0.set_theta_direction(-1)
    fig.colorbar(azi_plot, ax=ax0, fraction=0.046, pad=0.04, label="Semivariance")
    ax0.set_title("Azimuth Vario Map")

    # Plot Dip VarioContour
    dip_plot = ax1.contourf(th_dip, r_dip, z_dip, cmap=cmap, levels=c_step)
    R2 = np.linspace(0, np.nanmax(r_dip), 100)
    theta2 = np.ones(100) * dip * (np.pi / 180.0)
    ax1.plot(theta2, R2, lw=2.5)
    ax1.set_theta_zero_location("E")
    ax1.set_theta_direction(-1)
    ax1.set_thetalim(-np.pi / 2, 3 * np.pi / 2)
    fig.colorbar(dip_plot, ax=ax1, fraction=0.046, pad=0.04, label="Semivariance")
    ax1.set_title(f"Dip Vario Map with Azimuth = {azimuth}")

    # Plot pitch VarioContour
    pitch_plot = ax2.contourf(th_pitch, r_pitch, z_pitch, cmap=cmap, levels=c_step)
    R3 = np.linspace(0, np.nanmax(r_pitch), 100)
    theta3 = np.ones(100) * pitch * (np.pi / 180.0)
    ax2.plot(theta3, R3, lw=2.5)
    ax2.set_theta_zero_location("N")
    ax2.set_theta_direction(-1)
    ax2.set_thetalim(-np.pi / 2, 3 * np.pi / 2)
    fig.colorbar(pitch_plot, ax=ax2, fraction=0.046, pad=0.04, label="Semivariance")
    ax2.set_title(f"Pitch Vario Map with Azimuth = {azimuth} and Dip = {dip}")

    if save_file is not None:
        fig.savefig(save_file, bbox_inches='tight')
        plt.close()
    else:
        plt.show()

vario_pitch(object, attribute, region, lags, tol, azimuth, dip, n_pitch, atol)

Compute VarioContour for given azimuth and pitch as a semi Pie Chart. Angle of slice equals angular tolerance and slice radius equals lag distance.

Parameters:

Name	Type	Description	Default
object	GeoRefObject	Geo-ref Object.	required
attribute	str	Object attribute to compute variography on.	required
region	Optional[str]	Object region to select data from.	required
lags	List[float]	List of lags, in meters.	required
tol	float	Lag tolerance, in percent.	required
azimuth	float	Azimuth along which pitch is searched.	required
dip	float	Dip along which pitch is searched.	required
n_pitch	int	Number of dip to compute variogram.	required
atol	float	Angular tolerance for variogram computation.	required

Returns:

Type	Description
Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]	Computed values of pitch variomap along given azimuth and dip.

Source code in geolime/plotting/vario_plot.py

def vario_pitch(
    object: GeoRefObject,
    attribute: str,
    region: Optional[str],
    lags: List[float],
    tol: float,
    azimuth: float,
    dip: float,
    n_pitch: int,
    atol: float
) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
    """
    Compute VarioContour for given azimuth and pitch as a semi Pie Chart.
    Angle of slice equals angular tolerance and slice radius equals lag distance.

    Args:
        object:
            Geo-ref Object.
        attribute:
            Object attribute to compute variography on.
        region:
            Object region to select data from.
        lags:
            List of lags, in meters.
        tol:
            Lag tolerance, in percent.
        azimuth:
            Azimuth along which pitch is searched.
        dip:
            Dip along which pitch is searched.
        n_pitch:
            Number of dip to compute variogram.
        atol:
            Angular tolerance for variogram computation.

    Returns:
        Computed values of pitch variomap along given azimuth and dip.

    """
    # Convert number of pitch to even number
    n_pitch = ceil(n_pitch / 2) * 2

    # Compute pitch list in degrees and radians
    # Degree list is for computing : only needs half of the circle
    pitch_deg = np.linspace(-90, 90 * ((n_pitch - 2) / n_pitch), n_pitch // 2)

    # Radian list is for plotting : needs half circle
    pitch_rad = np.linspace(-np.pi / 2, 3 * np.pi / 2 * ((n_pitch - 1) / n_pitch), n_pitch)

    # Pcontourf and pcolomesh use nodes values : needs to close circle
    pitch_rad = np.append(pitch_rad, 3 * np.pi / 2)

    r, th = np.meshgrid(lags, pitch_rad)
    z = np.ones_like(r, dtype=np.float64)

    for j, pitch in enumerate(pitch_deg):
        t = variogram(
            object=object,
            attribute=attribute,
            region=region,
            geographic_azimuth=azimuth,
            dip=dip,
            pitch=pitch,
            lags=lags,
            tol=tol,
            atol=atol
        )["vario"]
        z[j, :] = np.concatenate((t.values, np.zeros(z.shape[1] - t.values.shape[0])))
        z[j + n_pitch // 2, :] = np.concatenate(
            (t.values, np.zeros(z.shape[1] - t.values.shape[0]))
        )

    # Last value is first value : 0 degrees value == 360 degrees value
    z[-1, :] = z[0, :]

    return r, th, z