Skip to content

numerical/model.py

WeatheringMediatedWeakness 

WeatheringMediatedWeakness()

Rock weathering & erosion modeling.

Used by:

Methods:

Source code in wmbe/numerical/model.py 
29
30
31
32
33
def __init__(self) -> None:
    """
    """
    self.fits = dict()
    self.fits2d = dict()

fit_weakness_vs_time_and_depth_model 

fit_weakness_vs_time_and_depth_model(data: DataFrame, select: str) -> None

Regress a 2d model against experimental data.

Parameters:

  • data

    (DataFrame) –

    which experimental dataset as key to pandas DataFrame

  • select

    (str) –

    which computation of weakness from rock strength

Attributes:

  • fdict[data_set] –

    model surface fit as meshgrid X=wet/dry \(N\), Y=confining pressure \(P\) and corresponding surface Z[X,Y] as list (X,Y,Z)

  • sdict[data_set] –

    model surface estimates at experimental values as meshgrid X=wet/dry \(N\), Y=confining pressure \(P\) and corresponding surface Z[X,Y] as list (X,Y,Z)

  • w_s2normed_means –

    mean values of model-normed weakness \(w\)

  • w_s2normed_stds –

    standard deviations of \(w\)

Source code in wmbe/numerical/model.py 
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
def fit_weakness_vs_time_and_depth_model(
        self, 
        data: DataFrame, 
        select: str
    ) -> None:
    """
    Regress a 2d model against experimental data.

    Args:
        data: which experimental dataset as key to pandas DataFrame
        select: which computation of weakness from rock strength

    Attributes:
        fdict[data_set]: model surface fit as
            meshgrid X=wet/dry $N$, Y=confining pressure $P$
            and corresponding surface Z[X,Y] as list (X,Y,Z)
        sdict[data_set]: model surface estimates at experimental values as
            meshgrid X=wet/dry $N$, Y=confining pressure $P$
            and corresponding surface Z[X,Y] as list (X,Y,Z)
        w_s2normed_means: 
            mean values of model-normed weakness $w$
        w_s2normed_stds: 
            standard deviations of $w$
    """        
    wdN_vec  = data.wetdryN
    P_vec    = data.P
    sig_vec  = data.sigmaC/180
    w_vec    = sig_vec**(-2)
    wdN_P_array = np.vstack((
        wdN_vec,
        P_vec,
    ))
    model_fit   = curve_fit(self.weakening_model, wdN_P_array, w_vec,)
    self.fits["default"] = model_fit

    n_pts = 30
    X = np.linspace(0, wdN_vec.max()*1.1, n_pts,)
    Y = np.linspace(0, P_vec.max()*1.1, n_pts,)
    X,Y = np.meshgrid(X, Y,)
    X_Y_array = np.vstack((
        X.reshape(n_pts**2), 
        Y.reshape(n_pts**2),
    ))
    Z = self.weakening_model(X_Y_array, *model_fit[0],).reshape(n_pts, n_pts,)
    self.fits[select+"_surface"] = (X, Y, Z,)

    P_vec = np.linspace(0,P_vec.max()*1.3)
    X,Y = np.meshgrid(np.unique(wdN_vec), P_vec)
    X_Y_array = np.vstack((
        X.reshape(X.shape[0]*Y.shape[1]), 
        Y.reshape(X.shape[0]*Y.shape[1]),
    ))
    self.fits2d["default"] = (
        X[0], 
        Y[:,0],
        self.weakening_model(
            X_Y_array, 
            *model_fit[0],
        ).reshape(X.shape[0], Y.shape[1],)
    )

    pd.options.mode.chained_assignment = None
    w_ref_vec = (self.fits2d["default"][2].T.copy())[:,0] - 1
    data["w_s2normed"] = 0.0
    for idx,wetdryN in enumerate(np.unique(data.wetdryN)):
        w = data.w_sigma2[data.wetdryN==wetdryN].copy()
        w_normed = (w-1)/w_ref_vec[idx]+1
        data.loc[(idx*3):(idx*3+3), "w_s2normed"] = w_normed

    self.w_s2normed_means \
        = data.groupby("P").mean()["w_s2normed"]
    self.w_s2normed_stds \
        = data.groupby("P").std()["w_s2normed"]

fit_weakness_vs_time_linear_model 

fit_weakness_vs_time_linear_model(
    data: DataFrame, x_name: str, y_name: str, select: str | None = None
) -> None

Regress a 1d model against experimental data.

Perform a linear regression fit of a linear model to the given experimental data, such as modeling the degree of rock weakness as a linear function of the number of wetting and drying cycles.

Parameters:

  • data

    (DataFrame) –

    which experimental dataset as key to pandas DataFrame

  • x_name

    (str) –

    abscissa \(x\)

  • y_name

    (str) –

    ordinate \(y\)

  • select

    (str | None, default: None ) –

    which computation of weakness from rock strength

Attributes:

  • fdict[data_set] (or fdict[selection_name]) –

    model fit

  • w_s2_means (NDArray) –

    mean values of weakness \(w\)

  • w_s2_stds (NDArray) –

    standard deviations of weakness \(w\)

Source code in wmbe/numerical/model.py 
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
def fit_weakness_vs_time_linear_model(
        self, 
        data: DataFrame, 
        x_name: str, 
        y_name: str, 
        select: str|None=None,
    ) -> None:
    """
    Regress a 1d model against experimental data.

    Perform a linear regression fit of a linear model to the given
    experimental data, such as modeling the degree of rock weakness
    as a linear function of the number of wetting and drying cycles.

    Args:
        data: which experimental dataset as key to pandas DataFrame
        x_name: abscissa $x$
        y_name: ordinate $y$
        select: which computation of weakness from rock strength

    Attributes:
        fdict[data_set] or fdict[selection_name]: 
            model fit 
        w_s2_means (NDArray):
            mean values of weakness $w$
        w_s2_stds (NDArray):
            standard deviations of weakness $w$
    """
    if select is not None:
        for selection in np.unique(data[select]):
            selection_name = f"{select}_{selection}"
            x = data.loc[data[select]==selection][x_name]
            y = data.loc[data[select]==selection][y_name]
            self.fits[selection_name] = curve_fit(linear_model, x, y,)
    else:
        x = data[x_name]
        y = data[y_name]
        self.fits["default"] = curve_fit(linear_model, x, y,)

    self.w_s2_means \
        = data.groupby("wetdryN").mean()["w_sigma2"]
    self.w_s2_stds \
        = data.groupby("wetdryN").std()[ "w_sigma2"]

weakening_model staticmethod 

weakening_model(
    wetdryN_P: Sequence | NDArray, k: float, w0: float, tau0: float
) -> float

Shifted exponential decay weathering model: \(w = 1 + w_0(\tau+\tau_0)\exp(-k\chi)\).

Parameters:

  • wetdryN_P

    (Sequence | NDArray) –

    pair \((\tau,\chi)\)

  • k

    (float) –

    reciprocal e-folding scale \(k\)

  • w0

    (float) –

    magnitude \(w_0\)

  • tau0

    (float) –

    time offset \(\tau_0\)

Returns:

  • float –

    weakness \(w\)

Source code in wmbe/numerical/model.py 
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
@staticmethod
def weakening_model(
        wetdryN_P: Sequence|NDArray, 
        k: float, 
        w0: float, 
        tau0: float,
    ) -> float:
    """
    Shifted exponential decay weathering model: 
    $w = 1 + w_0(\\tau+\\tau_0)\\exp(-k\\chi)$.

    Args:
        wetdryN_P: pair $(\\tau,\\chi)$
        k: reciprocal e-folding scale $k$
        w0: magnitude $w_0$
        tau0: time offset $\\tau_0$

    Returns:
        weakness $w$
    """    
    tau = wetdryN_P[0]
    chi = wetdryN_P[1]
    return 1 + w0*(tau+tau0)*np.exp(-k*chi)