def planar_daylight(strike,dip,to_plot=True,facecolor='none',edgecolor='b',segments=100):
"""
Draws the planar daylight envelope (cone) with respect to a
slope face with a given strike and dip.
Parameters
----------
strike : number or sequence of numbers
The strike of the plane(s) in degrees, with dip direction indicated by
the azimuth (e.g. 315 vs. 135) specified following the "right hand
rule".
dip : number or sequence of numbers
The dip of the plane(s) in degrees.
Returns
-------
pde_plunge, pde_bearing, pde_angle: arrays
Arrays of plunges, bearings, and angles of the planar daylight envelopes (cones).
"""
strikes, dips = np.atleast_1d(strike, dip)
# calculating plunge and bearing of pole to plane
p_plunge, p_bearing=st.pole2plunge_bearing(strikes, dips)
# calculating plunge, bearing, and angle of planar daylight envelope (cone)
pde_plunge=45+p_plunge/2.
pde_bearing=p_bearing
pde_angle=45-p_plunge/2.-10**-9
# plotting daylight envelope
if to_plot:
ax=plt.gca()
ax.cone(pde_plunge,pde_bearing, pde_angle,facecolor=facecolor,edgecolor=edgecolor)#,label='pDE')
return pde_plunge,pde_bearing,pde_angle
def test_sd_input(self):
for strike in range(0, 100, 10):
for dip in range(0, 370, 10):
dips = dip + np.array([-10, -5, 0, 5, 10])
strikes = strike + np.array([0, 0, 0, 0, 0])
plu, azi, vals = mplstereonet.eigenvectors(strikes, dips)
plunge, bearing = mplstereonet.pole2plunge_bearing(strike, dip)
self.compare_plungebearing(plunge, bearing, plu[0], azi[0])
assert np.allclose(vals, [1.09433342, 1.67776947e-02, 0])
def test_sd_input(self):
for strike in range(0, 100, 10):
for dip in range(0, 370, 10):
dips = dip + np.array([-10, -5, 0, 5, 10])
strikes = strike + np.array([0, 0, 0, 0, 0])
plu, azi, vals = mplstereonet.eigenvectors(strikes, dips)
plunge, bearing = mplstereonet.pole2plunge_bearing(strike, dip)
self.compare_plungebearing(plunge, bearing, plu[0], azi[0])
assert np.allclose(vals, [1.09433342, 1.67776947e-02, 0])
def fitfold(self):
strike, dip = self.get_strike_dip()
# discards the old graph
self.ax.hold(True)
fit_strike,fit_dip = mplstereonet.fit_girdle(strike,dip)
lon, lat = mplstereonet.pole(fit_strike, fit_dip)
(plunge,), (bearing,) = mplstereonet.pole2plunge_bearing(fit_strike, fit_dip)
template = u'Plunge / Direction of Fold Axis\n{:02.0f}\u00b0/{:03.0f}\u00b0'
self.ax.annotate(template.format(plunge, bearing), ha='center', va='bottom',
xy=(lon, lat), xytext=(-50, 20), textcoords='offset points',
arrowprops=dict(arrowstyle='-|>', facecolor='black'))
self.ax.plane(fit_strike, fit_dip, color='red', lw=2)
self.ax.pole(fit_strike, fit_dip, marker='o', color='red', markersize=14)
self.canvas.draw()
def fisher_fit(strike, dip):
"""
fit (strike, dip) dataset using fisher distribution
:param strike: array
:param dip: array
:return:
kappa: float
-fisher constant
resultant_orien: (float, float)
-resultant orientation
"""
plunge, bearing = mplstereonet.pole2plunge_bearing(strike, dip)
resultant_v, (r_value, theta_confi,
kappa) = mplstereonet.find_fisher_stats(plunge, bearing)
resultant_orien = mplstereonet.plunge_bearing2pole(resultant_v[0],
resultant_v[1])
return kappa, resultant_orien
def fitfold(self):
strike = []
dip = []
for f in self.layer.selectedFeatures():
dip.append(f['dip']) #self.dip_combo.currentText()])
strike.append(f['strike'])#self.strike_combo.currentText()])
# discards the old graph
self.ax.hold(True)
fit_strike,fit_dip = mplstereonet.fit_girdle(strike,dip)
lon, lat = mplstereonet.pole(fit_strike, fit_dip)
(plunge,), (bearing,) = mplstereonet.pole2plunge_bearing(fit_strike, fit_dip)
template = u'P/B of Fold Axis\n{:02.0f}\u00b0/{:03.0f}\u00b0'
self.ax.annotate(template.format(plunge, bearing), ha='center', va='bottom',
xy=(lon, lat), xytext=(-50, 20), textcoords='offset points',
arrowprops=dict(arrowstyle='-|>', facecolor='black'))
print fit_strike, fit_dip
self.ax.plane(fit_strike, fit_dip, color='red', lw=2)
self.ax.pole(fit_strike, fit_dip, marker='o', color='red', markersize=14)
self.canvas.draw()
def plot_bedding_stereonets(orientations_clean,geology,c_l,display):
import mplstereonet
import matplotlib.pyplot as plt
orientations = gpd.sjoin(orientations_clean, geology, how="left", op="within")
groups=geology[c_l['g']].unique()
codes=geology[c_l['c']].unique()
print("All observations n=",len(orientations_clean))
print('groups',groups,'\ncodes',codes)
if(display):
fig, ax = mplstereonet.subplots(figsize=(7,7))
if(c_l['otype']=='dip direction'):
strikes = orientations[c_l['dd']].values -90
else:
strikes = orientations[c_l['dd']].values
dips = orientations[c_l['d']].values
if(display):
cax = ax.density_contourf(strikes, dips, measurement='poles')
ax.pole(strikes, dips, markersize=5, color='w')
ax.grid(True)
text = ax.text(2.2, 1.37, "All data", color='b')
plt.show()
group_girdle={}
for gp in groups:
all_orientations=orientations[orientations[c_l['g']]==gp]
if(len(all_orientations)==1):
print("----------------------------------------------------------------------------------------------------------------------")
print(gp,"observations has 1 observation")
group_girdle[gp]=(-999,-999,1)
elif(len(all_orientations)>0):
print("----------------------------------------------------------------------------------------------------------------------")
print(gp,"observations n=",len(all_orientations))
if(display):
fig, ax = mplstereonet.subplots(figsize=(5,5))
if(c_l['otype']=='dip direction'):
strikes = all_orientations[c_l['dd']].values -90
else:
strikes = all_orientations[c_l['dd']].values
dips = all_orientations[c_l['d']].values
if(display):
cax = ax.density_contourf(strikes, dips, measurement='poles')
ax.pole(strikes, dips, markersize=5, color='w')
ax.grid(True)
text = ax.text(2.2, 1.37,gp, color='b')
plt.show()
fit_strike, fit_dip = mplstereonet.fit_girdle(strikes, dips)
(plunge,), (bearing,) = mplstereonet.pole2plunge_bearing(fit_strike, fit_dip)
group_girdle[gp]=(plunge, bearing,len(all_orientations))
print('strike/dip of girdle',fit_strike, '/', fit_dip)
else:
print("----------------------------------------------------------------------------------------------------------------------")
print(gp,"observations has no observations")
group_girdle[gp]=(-999,-999,0)
if(False):
for gp in groups:
print("----------------------------------------------------------------------------------------------------------------------")
print(gp)
#display(all_sorts2)
ind=0
orientations2=orientations[orientations[c_l['g']]==gp]
for code in codes:
orientations3=orientations2[orientations2[c_l['c']]==code]
ind2=int(fmod(ind,3))
if(len(orientations3)>0):
print(code,"observations n=",len(orientations3))
#display(orientations2)
if(len(orientations3)>0):
if(ind2==0):
fig, ax = mplstereonet.subplots(1,3,figsize=(15,15))
if(c_l['otype']=='dip direction'):
strikes = orientations3[c_l['dd']].values -90
else:
strikes = orientations3[c_l['dd']].values
dips = orientations3[c_l['d']].values
cax = ax[ind2].density_contourf(strikes, dips, measurement='poles')
ax[ind2].pole(strikes, dips, markersize=5, color='w')
ax[ind2].grid(True)
#fig.colorbar(cax)
text = ax[ind2].text(2.2, 1.37, code, color='b')
# Fit a plane to the girdle of the distribution and display it.
fit_strike, fit_dip = mplstereonet.fit_girdle(strikes, dips)
print('strike/dip of girdle',fit_strike, '/', fit_dip)
if(ind2==2):
plt.show()
ind=ind+1
if(ind>0 and not ind2==2):
plt.show()
return(group_girdle)
s, d = mplstereonet.plunge_bearing2pole(real_plunge, real_bearing)
lon, lat = mplstereonet.plane(s, d, segments=num_points)
lon += np.random.normal(0, np.radians(15), lon.shape)
lat += np.random.normal(0, np.radians(15), lat.shape)
strike, dip = mplstereonet.geographic2pole(lon, lat)
# Plot the raw data and contour it:
fig, ax = mplstereonet.subplots()
ax.density_contourf(strike, dip, cmap='gist_earth')
ax.density_contour(strike, dip, colors='black')
ax.pole(strike, dip, marker='.', color='black')
# Fit a plane to the girdle of the distribution and display it.
fit_strike, fit_dip = mplstereonet.fit_girdle(strike, dip)
ax.plane(fit_strike, fit_dip, color='red', lw=2)
ax.pole(fit_strike, fit_dip, marker='o', color='red', markersize=14)
# Add some annotation of the result
lon, lat = mplstereonet.pole(fit_strike, fit_dip)
(plunge, ), (bearing, ) = mplstereonet.pole2plunge_bearing(fit_strike, fit_dip)
template = u'P/B of Fold Axis\n{:02.0f}\u00b0/{:03.0f}\u00b0'
ax.annotate(template.format(plunge, bearing),
ha='center',
va='bottom',
xy=(lon, lat),
xytext=(-50, 20),
textcoords='offset points',
arrowprops=dict(arrowstyle='-|>', facecolor='black'))
plt.show()
def planarFailure(sstr, sdip, jfriction, jstr, jdip, to_plot=False):
"""
Evaluates planar failure of joints vis-a-vis a slope face
with a given strike and dip, such that a joint's pole plots 1) within the
planar daylight envelope, and 2) outside the planar friction envelope
Parameters
----------
sstr : int or float
The strike of the slope face in degrees, with dip direction indicated by
the azimuth (e.g. 315 vs. 135) specified following the "right hand
rule".
sdip : int or float
The dip of the slope face in degrees.
jfriction : int, float, or array of int or float
The friction angle of the joint plane in degrees.
jstr : int, float, or array of int or float
The strike of the joint plane in degrees, with dip direction indicated by
the azimuth (e.g. 315 vs. 135) specified following the "right hand
rule".
jdip : int, float, or array of int or float
The dip of the joint plane in degrees.
Returns
-------
planarFail: boolean array of size = len(np.atleast_1d(jstr))
Indicates if corresponding joints will allow planar failure.
"""
# ensure jstr, jdip, and jfriction are 1-d arrays
jstr, jdip = np.atleast_1d(jstr, jdip)
try:
len(jfriction)
uniformFriction = False
except:
jfriction = jfriction * (np.ones(len(jstr)))
uniformFriction = True
# determinde daylight and friction envelopes
pde_plunge, pde_bearing, pde_angle = env.planar_daylight(sstr, sdip, False)
pfe_plunge, pfe_bearing, pfe_angle = env.planar_friction(jfriction, False)
# convert joint plane (strike-dip) to pole (plunge-bearing)
jplunge, jbearing = st.pole2plunge_bearing(jstr, jdip)
# evaluate if joint poles are contained within daylight and friction envelopes (cones)
inDaylight = np.empty(len(jstr))
outFriction = np.empty(len(jstr))
for a in range(len(jstr)):
inDaylight[a] = line_in_cone(pde_plunge, pde_bearing, pde_angle,
jplunge[a], jbearing[a])
outFriction[a] = ~line_in_cone(pfe_plunge[a], pfe_bearing[a],
pfe_angle[a], jplunge[a], jbearing[a])
planarFail = (inDaylight == True) & (outFriction == True)
# plotting results
if uniformFriction and to_plot:
env.setup_axes(sstr,
sdip,
jfriction[0],
failure='planar',
to_plot=True)
plt.gca().pole(jstr[~planarFail],
jdip[~planarFail],
color='0.5',
marker='.')
plt.gca().pole(jstr[planarFail],
jdip[planarFail],
color='r',
marker='.')
return planarFail
def topplingFailure(sstr, sdip, jfriction, jstr, jdip, to_plot=False):
"""
Evaluates toppling failure of joints vis-a-vis a slope face
with a given strike and dip, such that a joint's pole plots 1) within the
toppling slip limits, and 2) on the convex side of the toppling friction
envelope
Parameters
----------
sstr : int or float
The strike of the slope face in degrees, with dip direction indicated by
the azimuth (e.g. 315 vs. 135) specified following the "right hand
rule".
sdip : int or float
The dip of the slope face in degrees.
jfriction : int, float, or array of int or float
The friction angle of the joint plane in degrees.
jstr : int, float, or array of int or float
The strike of the joint plane in degrees, with dip direction indicated by
the azimuth (e.g. 315 vs. 135) specified following the "right hand
rule".
jdip : int, float, or array of int or float
The dip of the joint plane in degrees.
Returns
-------
topplingFail: boolean array of size = len(np.atleast_1d(jstr))
Indicates if corresponding joints will allow toppling failure.
"""
# ensure jstr, jdip, and jfriction are 1-d arrays
jstr, jdip = np.atleast_1d(jstr, jdip)
try:
len(jfriction)
uniformFriction = False
except:
jfriction = jfriction * (np.ones(len(jstr)))
uniformFriction = True
# determine daylight and friction envelopes
tsl_plunge, tsl_bearing, tsl_angle = env.toppling_slipLimits(
sstr, sdip, False)
tfe_strike, tfe_dip = env.toppling_friction(sstr, sdip, jfriction, False)
# convert joint plane (strike-dip) to pole (plunge-bearing)
jplunge, jbearing = st.pole2plunge_bearing(jstr, jdip)
# evaluate if joint poles are contained within slip limits (cones) and friction envelope (great circles)
inSlipLimit1 = np.empty(len(jstr))
inSlipLimit2 = np.empty(len(jstr))
convexFriction = np.empty(len(jstr))
for a in range(len(jstr)):
inSlipLimit1[a] = ~line_in_cone(tsl_plunge, tsl_bearing, tsl_angle,
jplunge[a], jbearing[a])
inSlipLimit2[a] = ~line_in_cone(tsl_plunge, tsl_bearing + 180,
tsl_angle, jplunge[a], jbearing[a])
convexFriction[a] = line_above_plane(tfe_strike[0], tfe_dip[a],
jplunge[a], jbearing[a])
topplingFail = ((inSlipLimit1 == True) & (inSlipLimit2 == True) &
(convexFriction == True))
# plotting results
if uniformFriction and to_plot:
env.setup_axes(sstr,
sdip,
jfriction[a],
failure='toppling',
to_plot=True)
plt.gca().pole(jstr[~topplingFail],
jdip[~topplingFail],
color='0.5',
marker='.')
plt.gca().pole(jstr[topplingFail],
jdip[topplingFail],
color='r',
marker='.')
return topplingFail
# In the end, we'll have strikes and dips as measured from bedding in the fold.
# *strike* and *dip* below would normally be your input.
num_points = 200
real_bearing, real_plunge = 300, 5
s, d = mplstereonet.plunge_bearing2pole(real_plunge, real_bearing)
lon, lat = mplstereonet.plane(s, d, segments=num_points)
lon += np.random.normal(0, np.radians(15), lon.shape)
lat += np.random.normal(0, np.radians(15), lat.shape)
strike, dip = mplstereonet.geographic2pole(lon, lat)
# Plot the raw data and contour it:
fig, ax = mplstereonet.subplots()
ax.density_contourf(strike, dip, cmap='gist_earth')
ax.density_contour(strike, dip, colors='black')
ax.pole(strike, dip, marker='.', color='black')
# Fit a plane to the girdle of the distribution and display it.
fit_strike, fit_dip = mplstereonet.fit_girdle(strike, dip)
ax.plane(fit_strike, fit_dip, color='red', lw=2)
ax.pole(fit_strike, fit_dip, marker='o', color='red', markersize=14)
# Add some annotation of the result
lon, lat = mplstereonet.pole(fit_strike, fit_dip)
(plunge,), (bearing,) = mplstereonet.pole2plunge_bearing(fit_strike, fit_dip)
template = u'P/B of Fold Axis\n{:02.0f}\u00b0/{:03.0f}\u00b0'
ax.annotate(template.format(plunge, bearing), ha='center', va='bottom',
xy=(lon, lat), xytext=(-50, 20), textcoords='offset points',
arrowprops=dict(arrowstyle='-|>', facecolor='black'))
plt.show()
