rock-physics-open 0.3.2__py3-none-any.whl

rock_physics_open/t_matrix_models/t_matrix_parameter_optimisation_exp.py

@@ -0,0 +1,176 @@
+import numpy as np
+
+from rock_physics_open.equinor_utilities import gen_utilities
+from rock_physics_open.equinor_utilities.optimisation_utilities import (
+    gen_opt_routine,
+    opt_param_info,
+    save_opt_params,
+)
+
+from .curvefit_t_matrix_exp import curvefit_t_matrix_exp
+from .t_matrix_parameter_optimisation_min import DEF_VP_VS_RATIO
+
+
+def t_matrix_optimisation_exp(
+    k_fl: np.ndarray,
+    rho_fl: np.ndarray,
+    por: np.ndarray,
+    vsh: np.ndarray,
+    vp: np.ndarray,
+    vs: np.ndarray,
+    rhob: np.ndarray,
+    angle: float = 0.0,
+    k_r: float = 50.0,
+    eta_f: float = 1.0,
+    tau: float = 1.0e-7,
+    freq: float = 1.0e3,
+    file_out_str: str = "opt_params_exp.pkl",
+    display_results: bool = False,
+    well_name: str = "Unknown well",
+    **opt_kwargs,
+):
+    """T-Matrix optimisation adapted to an exploration setting, where detailed well information is generally not known.
+    Inclusion parameters are optimised for the whole well.
+
+    Parameters
+    ----------
+    por :
+        Inclusion porosity [ratio].
+    vsh :
+        Shale volume [ratio].
+    k_fl :
+        Fluid bulk modulus [Pa].
+    rho_fl :
+        Fluid density [kg/m^3].
+    vp :
+        Compressional velocity log [m/s].
+    vs :
+        Shear velocity log [m/s].
+    rhob :
+        Bulk density log [kg/m^3].
+    angle : float
+        Angle of symmetry plane [degrees]
+    k_r :
+        Permeability [mD].
+    eta_f :
+        Fluid viscosity [cP].
+    tau :
+        Relaxation time constant [s].
+    freq :
+        Signal frequency [Hz].
+    file_out_str :
+        Output file name (string) to store optimal parameters (pickle format).
+    display_results :
+        D isplay optimal parameters in a window after run.
+    well_name :
+        Name of well to be displayed in info box title.
+    opt_kwargs :
+        Additional keywords to be passed to optimisation function
+
+    Returns
+    -------
+    tuple
+        vp_mod, vs_mod - modelled logs, vp_res, vs_res - residual logs.
+    """
+    # 1. Preparation that is independent of search for minimum possible aspect ratio for second inclusion set
+
+    # Optimisation function for selected parameters
+    opt_fun = curvefit_t_matrix_exp
+    # rho_min = (rhob - por * rho_fl) / (1 - por)
+    # EXP adapted inputs: include fluid data and other params in x_data
+    # expand single value parameters to match logs length
+    por, angle, k_r, eta_f, tau, freq, def_vpvs = gen_utilities.dim_check_vector(
+        (por, angle, k_r, eta_f, tau, freq, DEF_VP_VS_RATIO)
+    )
+    x_data = np.stack(
+        (por, vsh, k_fl, rho_fl, angle, k_r, eta_f, tau, freq, def_vpvs), axis=1
+    )
+    # Set weight to vs to give vp and vs similar influence on optimisation
+    y_data = np.stack([vp, vs * DEF_VP_VS_RATIO], axis=1)
+
+    # 2. Search for minimum aspect ratio of inclusion set no. 2, given that inclusion set no. 1 will at least represent
+    # 50% of inclusions. Minimum aspect ratio is linked to the porosity, and the most conservative estimate is to use
+    # the maximum value. This is likely to deteriorate the optimisation results, so a search for a more appropriate
+    # value that still produces valid results is made
+    percentiles = [50, 75, 80, 85, 90, 95, 99, 100]
+    valid_result = False
+    vel_mod = None
+    vel_res = None
+    opt_params = None
+    scale_val = opt_param_info()[1]
+    while not valid_result and percentiles:
+        try:
+            # Make sure that parameters are not in conflict with T Matrix assumptions
+            min_v1 = 0.5
+            max_por = np.percentile(por, percentiles[0])
+            min_a2 = (1.0 - min_v1) * max_por
+            # Test with all parameters in the range 0.0 - 1.0
+            # Params:      f_ani f_con a1 a2 v1 k_carb mu_carb rho_carb k_sh mu_sh rho_sh
+            lower_bound = np.array(
+                [
+                    0.0,
+                    0.0,
+                    0.5,
+                    min_a2,
+                    min_v1,  # f_ani f_con a1 a2 v1
+                    35.0 / scale_val["k_carb"],
+                    30.0 / scale_val["mu_carb"],
+                    2650.0 / scale_val["rho_carb"],  # k_carb, mu_carb, rho_carb
+                    15.0 / scale_val["k_sh"],
+                    7.0 / scale_val["mu_sh"],
+                    2500.0 / scale_val["rho_sh"],
+                ],
+                dtype=float,
+            )  # k_sh, mu_sh, rho_sh
+            upper_bound = np.array(
+                [
+                    1.0,
+                    1.0,
+                    1.0,
+                    0.30,
+                    1.0,  # f_ani f_con a1 a2 v1
+                    1.0,
+                    1.0,
+                    1.0,  # k_carb, mu_carb, rho_carb
+                    1.0,
+                    1.0,
+                    1.0,
+                ],
+                dtype=float,
+            )  # k_sh, mu_sh, rho_sh
+            x0 = (upper_bound + lower_bound) / 2.0
+            # Optimisation step without fluid substitution
+            vel_mod, vel_res, opt_params = gen_opt_routine(
+                opt_fun, x_data, y_data, x0, lower_bound, upper_bound, **opt_kwargs
+            )
+            valid_result = True
+        except ValueError:
+            percentiles.pop(0)
+            valid_result = False
+
+    if not valid_result:
+        raise ValueError(
+            f"{__file__}: unable to find stable value for T Matrix optimisation, second inclusion"
+        )
+
+    # Reshape outputs and remove weight from vs
+    vp_mod, vs_mod = [arr.flatten() for arr in np.split(vel_mod, 2, axis=1)]
+    vp_res, vs_res = [arr.flatten() for arr in np.split(vel_res, 2, axis=1)]
+    vs_mod = vs_mod / DEF_VP_VS_RATIO
+    vs_res = vs_res / DEF_VP_VS_RATIO
+    vpvs_mod = vp_mod / vs_mod
+    # Calculate the modelled density
+    rhob_mod = (
+        (1.0 - vsh) * opt_params[7] * scale_val["rho_carb"]
+        + vsh * opt_params[10] * scale_val["rho_sh"]
+    ) * (1.0 - por) + por * rho_fl
+    ai_mod = vp_mod * rhob_mod
+    rhob_res = rhob_mod - rhob
+    # Save the optimal parameters
+    save_opt_params("exp", opt_params, file_out_str, well_name=well_name)
+    if display_results:
+        from .opt_subst_utilities import opt_param_to_ascii
+
+        opt_param_to_ascii(file_out_str, well_name=well_name)
+
+    return vp_mod, vs_mod, rhob_mod, ai_mod, vpvs_mod, vp_res, vs_res, rhob_res

rock_physics_open/t_matrix_models/t_matrix_parameter_optimisation_min.py

@@ -0,0 +1,162 @@
+import numpy as np
+
+from rock_physics_open.equinor_utilities import gen_utilities
+from rock_physics_open.equinor_utilities.optimisation_utilities import (
+    gen_opt_routine,
+    save_opt_params,
+)
+
+from .curvefit_t_matrix_min import curve_fit_2_inclusion_sets
+
+# Trade-off between calcite, dolomite and quartz, vs is weighted by this in order to make it count as much as vp
+# in the optimisation
+DEF_VP_VS_RATIO = 1.8
+
+
+def t_matrix_optimisation_petec(
+    k_min: np.ndarray,
+    mu_min: np.ndarray,
+    rho_min: np.ndarray,
+    k_fl: np.ndarray,
+    rho_fl: np.ndarray,
+    por: np.ndarray,
+    vp: np.ndarray,
+    vs: np.ndarray,
+    rhob: np.ndarray,
+    angle: float = 0.0,
+    k_r: float = 50.0,
+    eta_f: float = 1.0,
+    tau: float = 1.0e-7,
+    freq: float = 1.0e3,
+    file_out_str: str = "opt_params_min.pkl",
+    display_results: bool = False,
+    well_name: str = "Unknown well",
+    **opt_kwargs,
+):
+    """T-Matrix optimisation adapted to a case with detailed information available, such as in a development or production
+    setting. Mineral and fluid composition should be known on a sample basis. Inclusion parameters are regarded as
+    unknown and they are optimised for.
+
+    Parameters
+    ----------
+    k_min :
+        Effective mineral bulk modulus [Pa].
+    mu_min :
+        Effective mineral shear modulus [Pa].
+    rho_min :
+        Effective mineral bulk density [kg/m^3].
+    k_fl :
+        Effective fluid bulk modulud [Pa].
+    rho_fl :
+        Effective fluid density [kg/m^3].
+    por :
+        Inclusion porosity [ratio].
+    vp :
+        Compressional velocity log [m/s].
+    vs :
+        Shear velocity log [m/s].
+    rhob :
+        Bulk density log [kg/m^3].
+    angle : float
+        Angle of symmetry plane [degrees]
+    k_r :
+        Permeability [mD].
+    eta_f :
+        Fluid viscosity [cP].
+    tau :
+        Relaxation time constant [s].
+    freq :
+        Signal frequency [Hz].
+    file_out_str :
+        Output file name (string) to store optimal parameters (pickle format).
+    display_results :
+        Display optimal parameters in a window after run.
+    well_name:
+        Name of well to be displayed in info box title.
+    opt_kwargs:
+        Additional keywords to be passed to optimisation function
+
+    Returns
+    -------
+    tuple
+        vp_mod, vs_mod, rho_mod, ai_mod, vpvs_mod - modelled logs, vp_res, vs_res, rho_res - residual logs.
+    """
+    # 1. Preparation that is independent of search for minimum possible aspect ratio for second inclusion set
+
+    # Optimisation function for selected parameters, with effective mineral properties known and 2 inclusion sets
+    opt_fun = curve_fit_2_inclusion_sets
+    rhob_mod = rho_min * (1 - por) + rho_fl * por
+    rhob_res = rhob - rhob_mod
+    # PETEC adapted inputs: include fluid data and other params in x_data
+    por, angle, k_r, eta_f, tau, freq, def_vp_vs_ratio = gen_utilities.dim_check_vector(
+        (por, angle, k_r, eta_f, tau, freq, DEF_VP_VS_RATIO)
+    )
+    x_data = np.stack(
+        (
+            por,
+            k_min,
+            mu_min,
+            rho_min,
+            k_fl,
+            rho_fl,
+            angle,
+            k_r,
+            eta_f,
+            tau,
+            freq,
+            def_vp_vs_ratio,
+        ),
+        axis=1,
+    )
+    # Set weight to vs to give vp and vs similar influence on optimisation
+    y_data = np.stack([vp, vs * DEF_VP_VS_RATIO], axis=1)
+
+    # 2. Search for minimum aspect ratio of inclusion set no. 2, given that inclusion set no. 1 will at least represent
+    # 50% of inclusions. Minimum aspect ratio is linked to the porosity, and the most conservative estimate is to use
+    # the maximum value. This is likely to deteriorate the optimisation results, so a search for a more appropriate
+    # value that still produces valid results is made
+    percentiles = [50, 75, 80, 85, 90, 95, 99, 100]
+    valid_result = False
+    vel_mod = None
+    vel_res = None
+    opt_params = None
+    while not valid_result and percentiles:
+        try:
+            # Make sure that parameters are not in conflict with T Matrix assumptions
+            min_v1 = 0.5
+            max_por = np.percentile(por, percentiles[0])
+            min_a2 = (1.0 - min_v1) * max_por
+            # Test with all parameters in the range 0.0 - 1.0 for best optimiser performance
+            # Params:               f_ani f_con a1   a2    v1
+            lower_bound = np.array([0.0, 0.0, 0.5, min_a2, min_v1], dtype=float)
+            upper_bound = np.array([1.0, 1.0, 1.0, 0.30, 1.0], dtype=float)
+            x0 = (upper_bound + lower_bound) / 2.0
+            # Optimisation step without fluid substitution
+            vel_mod, vel_res, opt_params = gen_opt_routine(
+                opt_fun, x_data, y_data, x0, lower_bound, upper_bound, **opt_kwargs
+            )
+            valid_result = True
+        except ValueError:
+            percentiles.pop(0)
+            valid_result = False
+
+    if not valid_result:
+        raise ValueError(
+            f"{__file__}: unable to find stable value for T Matrix optimisation, second inclusion"
+        )
+
+    # Reshape outputs and remove weight from vs
+    vp_mod, vs_mod = [arr.flatten() for arr in np.split(vel_mod, 2, axis=1)]
+    ai_mod = vp_mod * rhob_mod
+    vp_res, vs_res = [arr.flatten() for arr in np.split(vel_res, 2, axis=1)]
+    vs_mod = vs_mod / DEF_VP_VS_RATIO
+    vs_res = vs_res / DEF_VP_VS_RATIO
+    vpvs_mod = vp_mod / vs_mod
+    # Save the optimal parameters
+    save_opt_params("min", opt_params, file_out_str, well_name=well_name)
+    if display_results:
+        from .opt_subst_utilities import opt_param_to_ascii
+
+        opt_param_to_ascii(file_out_str, well_name=well_name)
+
+    return vp_mod, vs_mod, rhob_mod, ai_mod, vpvs_mod, vp_res, vs_res, rhob_res

rock_physics_open/t_matrix_models/t_matrix_vector/__init__.py

@@ -0,0 +1,12 @@
+from .array_functions import array_inverse, array_matrix_mult
+from .calc_pressure import calc_pressure_vec
+from .pressure_input import pressure_input_utility
+from .t_matrix_vec import t_matrix_porosity_vectorised
+
+__all__ = [
+    "array_inverse",
+    "array_matrix_mult",
+    "calc_pressure_vec",
+    "pressure_input_utility",
+    "t_matrix_porosity_vectorised",
+]

rock_physics_open/t_matrix_models/t_matrix_vector/array_functions.py

@@ -0,0 +1,75 @@
+import numpy as np
+
+
+def array_inverse(a: np.ndarray) -> np.ndarray:
+    """Inverse of higher order array (3 dim) using linalg inv routine.
+
+    Parameters
+    ----------
+    a : np.ndarray
+        An nxmxm numpy array.
+
+    Returns
+    -------
+    np.ndarray
+        An nxmxm array where [i, :, :] contains the inverse of A[i, :, :].
+
+    Raises
+    ------
+    ValueError
+        If input of wrong shape.
+    """
+    if not (a.ndim == 3 and a.shape[1] == a.shape[2]):
+        raise ValueError(f"{__name__}: mismatch in inputs variables dimension/shape")
+
+    return np.array([np.linalg.inv(x) for x in a])
+
+
+def array_matrix_mult(*args: np.ndarray) -> np.ndarray:
+    """3-dim arrays are matrix multiplied args[j][i, :, :] @ args[j+1][i, :, :].
+    Input args should all be numpy arrays of shape nxmxm.
+
+    Returns
+    -------
+    np.ndarray
+        An nxmxm array with n args[i] @ args[i+1] @ ....
+
+    Raises
+    ------
+    ValueError
+        If input is not a list or tuple.
+    ValueError
+        If mismatch in input shape/dimension.
+    ValueError
+        If mismatch in input shape/dimension.
+    """
+    if not isinstance(args, (list, tuple)):
+        raise ValueError(f"{__name__}: inputs must be list or tuple")
+    if not len(args) > 1:
+        return args[0]
+
+    arg_shape = []
+    arg_type = []
+    for i in range(len(args)):
+        if not (
+            isinstance(args[i], np.ndarray)
+            and args[i].ndim == 3
+            and args[i].shape[1] == args[i].shape[2]
+        ):
+            raise ValueError(
+                f"{__name__}: mismatch in inputs variables dimension/shape"
+            )
+        arg_shape.append(args[i].shape)
+        arg_type.append(args[i].dtype)
+    arg_shape = np.array(arg_shape)
+    arg_type = np.array(arg_type)
+    if not np.all(arg_shape[:, 0] == arg_shape[0, 0]):
+        raise ValueError(f"{__name__}: mismatch in inputs variables dimension/shape")
+    out_type = "complex128" if np.any(arg_type == np.dtype("complex128")) else "float64"
+
+    x = args[0]
+
+    for i in range(1, len(args)):
+        x = np.einsum("...ij,...jk->...ik", x, args[i], dtype=out_type)
+
+    return x

rock_physics_open/t_matrix_models/t_matrix_vector/calc_c_eff.py

@@ -0,0 +1,163 @@
+import numpy as np
+
+from .array_functions import array_inverse, array_matrix_mult
+from .calc_t import calc_t_vec
+from .calc_theta import calc_theta_vec
+from .calc_z import calc_z_vec
+
+
+def calc_c_eff_vec(c0, c1, gd, t, t_bar, v, frac_aniso):
+    """
+    Equation  4 (page 222) Jakobsen et al. 2003 (The acoustic signature of fluid flow in complex
+    porous media).
+    Returns the effective stiffness tensor C* (nx6x6 matrix) calculated from the t-matrices t(r) (Eq. 1).
+
+    Parameters
+    ----------
+    c0 : np.ndarray
+        Stiffness tensor of the host of the inclusion (nx6x6 matrix).
+    c1 : np.ndarray
+        Sum of the concentration and t-matrices (nx6x6 matrix).
+    gd : np.ndarray
+        Correlation function (nx6x6 matrix).
+    t : np.ndarray
+        t-matrices of the different inclusions (nx6x6xr matrix) (anisotropic).
+    t_bar: np.ndarray
+        t-matrices of the different inclusions (nx6x6xr matrix) (isotropic).
+    v : np.ndarray
+        Concentration of the inclusions (nxr vector).
+    frac_aniso: np.ndarray
+        Fraction of anisotropic.
+
+    Returns
+    -------
+    tuple
+        c_eff: np.ndarray.
+        c_eff: effective stiffness tensor C.
+    """
+    if not (
+        c0.ndim == 3
+        and c1.ndim == 3
+        and gd.ndim == 3
+        and t.ndim == 4
+        and t_bar.ndim == 4
+        and v.ndim == 2
+        and np.all(
+            np.array(
+                [
+                    c0.shape[1:2],
+                    c1.shape[1:2],
+                    gd.shape[1:2],
+                    t.shape[1:2],
+                    t_bar.shape[1:2],
+                ]
+            )
+            == c0.shape[1]
+        )
+        and np.all(
+            np.array(
+                [
+                    c0.shape[0],
+                    c1.shape[0],
+                    gd.shape[0],
+                    t.shape[0],
+                    t_bar.shape[0],
+                    v.shape[0],
+                ]
+            )
+            == c0.shape[0]
+        )
+    ):
+        raise ValueError("calc_c_eff_vec: inconsistencies in input shapes")
+
+    log_length = c0.shape[0]
+    alpha_len = v.shape[1]
+    v = v.reshape((log_length, 1, 1, alpha_len))
+    i4 = np.eye(6)
+
+    c1 = c1 + np.sum(frac_aniso * v * t + (1.0 - frac_aniso) * v * t_bar, axis=3)
+
+    return c0 + array_matrix_mult(c1, array_inverse(i4 + array_matrix_mult(gd, c1)))
+
+
+def calc_c_eff_visco_vec(
+    vs,
+    k_r,
+    eta_f,
+    v,
+    gamma,
+    tau,
+    kd_uuvv,
+    kappa,
+    kappa_f,
+    c0,
+    s0,
+    c1,
+    td,
+    td_bar,
+    x,
+    x_bar,
+    gd,
+    frequency,
+    frac_ani,
+):
+    """
+    Returns the effective stiffness tensor C* for a visco-elastic system (6x6xnumber of frequencies).
+
+    Parameters
+    ----------
+    vs : np.ndarray
+        The velocity used to calculate the wave number.
+    k_r : np.ndarray
+        Klinkenberg permability.
+    eta_f : np.ndarray
+        Viscosity (P).
+    v : np.ndarray
+        Concentration of the inclusions which are connected with respect to fluid flow.
+    gamma : np.ndarray
+        Gamma factor for each inclusion (1x(number of connected inclusions) vector).
+    tau : float or np.ndarray
+        Relaxation time constant.
+    kd_uuvv : np.ndarray
+        Kd_uuvv for each connected inclusion (1x(number of connected inclusions) vector.
+    kappa : np.ndarray
+        Bulk modulus of host material.
+    kappa_f : np.ndarray
+        Bulk modulus of the fluid.
+    c0 : np.ndarray
+        The stiffness tensor of host material (6x6 matrix).
+    s0 : np.ndarray
+        Inverse of C0.
+    c1 : np.ndarray
+        First order correction matrix(6x6 matrix). If there are isolated inclusions, C1 is sum of concentration and
+        t-matrices of the isolated part of the porosity.
+    td : np.ndarray
+        t-matrix tensors.
+    td_bar : np.ndarray
+        t-matrices of the connected inclusions(6x6x(numbers of inclusions) matrix).
+    x : np.ndarray
+        X-tensor.
+    x_bar : np.ndarray
+        X-tensor of the connected inclusions (6x6x(numbers of inclusions) matrix).
+    gd : np.ndarray
+        Correlation function (6x6 matrix).
+    frequency : float
+        Frequency under consideration.
+    frac_ani : np.ndarray
+        Fraction of anisotropic inclusions.
+
+    Returns
+    -------
+    np.ndarray
+        Effective stiffness tensor.
+    """
+    dr = k_r / eta_f
+
+    omega = 2 * np.pi * frequency
+    k = omega / vs
+    theta = calc_theta_vec(v, omega, gamma, tau, kd_uuvv, dr, k, kappa, kappa_f)
+    z, z_bar = calc_z_vec(s0, td, td_bar, omega, gamma, v * frac_ani, tau)
+    t = calc_t_vec(td, theta, x, z, omega, gamma, tau, kappa_f)
+    t_bar = calc_t_vec(td_bar, theta, x_bar, z_bar, omega, gamma, tau, kappa_f)
+
+    return calc_c_eff_vec(c0, c1, gd, t, t_bar, v, frac_ani)

rock_physics_open/t_matrix_models/t_matrix_vector/calc_isolated.py

@@ -0,0 +1,95 @@
+import numpy as np
+
+from .array_functions import array_inverse, array_matrix_mult
+from .g_tensor import g_tensor_vec
+from .iso_av import iso_av_vec
+
+
+def calc_isolated_part_vec(c0, s_0, kappa_f, alpha, v, case_iso, frac_ani):
+    """
+    Returns the first order correction tensor: sum of the concentrations and
+    t-matrices of the isolated porosity (6x6 matrix).
+    case_iso = 0 : 100% isotropic,
+    case_iso = 1 : mixed isotropic and anisotropic porosity,
+    case_iso = 2 : 100% anisotropic porosity.
+
+    Parameters
+    ----------
+    c0 : np.ndarray
+        Stiffness tensor of the host material (6x6xn).
+    s_0 :  np.ndarray
+        Inverse of stiffness tensor.
+    kappa_f : np.ndarray
+        Bulk modulus of the fluid (n length vector).
+    alpha : np.ndarray
+        Aspect ratios of all the inclusions (1xnumber of inclusions) vector).
+    v : np.ndarray
+        Concentration of all the inclusions (1xnumber of inclusions) vector).
+    case_iso : int
+        Control parameter.
+    frac_ani : float
+        Fraction of anisotropic inclusions.
+
+    Returns
+    -------
+    np.ndarray
+        c1: correction tensor.
+
+    Notes
+    -----
+    29.10.2020 HFLE: Simplification: alpha for isotropic and anisotropic part are the same. This has been default in
+    Remy's code, but this function had assumption that half of the inclusions could have different aspect ratio
+    13.11.2020 HFLE: In case of zero porosity, this routine returns a zero tensor, whereas the correct should have
+    been to return the host material tensor - corrected.
+
+    """
+    if not (c0.ndim == 3 and s_0.ndim == 3):
+        raise ValueError(f"{__name__}: mismatch in inputs variables dimension/shape")
+
+    log_length = c0.shape[0]
+    if v.ndim != 2:
+        v = np.tile(v.reshape(1, v.shape[0]), (log_length, 1))
+
+    if alpha.ndim == 1 and alpha.shape[0] != c0.shape[0]:
+        alpha = np.tile(alpha.reshape(1, alpha.shape[0]), (log_length, 1))
+    alpha_len = alpha.shape[1]
+
+    cn = np.zeros_like(c0)
+    cn[:, 0:3, 0:3] = np.tile(kappa_f.reshape((log_length, 1, 1)), (1, 3, 3))
+    cn_d = cn - c0
+    i4 = np.tile(np.eye(6).reshape(1, 6, 6), (log_length, 1, 1))
+    c1 = np.zeros_like(c0)
+
+    # Will need G tensor for each alpha
+    g_arr = []
+    for i in range(alpha_len):
+        g_arr.append(g_tensor_vec(c0, s_0, alpha[:, i]))
+
+    if case_iso != 1:
+        # if there is only isotropic or anisotropic inclusions
+        for j in range(alpha_len):
+            t = array_matrix_mult(
+                cn_d, array_inverse(i4 - array_matrix_mult(g_arr[j], cn_d))
+            )
+            if case_iso != 2:
+                t = iso_av_vec(t)
+            c1 = c1 + v[:, j].reshape(log_length, 1, 1) * t
+    else:
+        # Isotropic and anisotropic part
+        for j in range(alpha_len):
+            t = array_matrix_mult(
+                cn_d, array_inverse(i4 - array_matrix_mult(g_arr[j], cn_d))
+            )
+            t = iso_av_vec(t)
+            c1 = c1 + ((1 - frac_ani) * v[:, j]).reshape(log_length, 1, 1) * t
+        for j in range(alpha_len):
+            t = array_matrix_mult(
+                cn_d, array_inverse(i4 - array_matrix_mult(g_arr[j], cn_d))
+            )
+            c1 = c1 + (frac_ani * v[:, j]).reshape(log_length, 1, 1) * t
+
+    idx_zero = np.sum(v, axis=1) == 0.0
+    if np.any(idx_zero):
+        c1[idx_zero] = c0[idx_zero]
+
+    return c1