def test_multiple_rakes(self):
strike, dip, rake = np.array(self.data).T
lon, lat = smath.rake(strike, dip, rake)
plunge, bearing = smath.geographic2plunge_bearing(lon, lat)
newrake = smath.project_onto_plane(strike, dip, plunge, bearing)
assert np.allclose(rake, newrake)
def test_multiple_rakes(self):
strike, dip, rake = np.array(self.data).T
lon, lat = smath.rake(strike, dip, rake)
plunge, bearing = smath.geographic2plunge_bearing(lon, lat)
newrake = smath.project_onto_plane(strike, dip, plunge, bearing)
assert np.allclose(rake, newrake)
def test_offset_back_to_rake(self):
for strike, dip, rake in self.data:
# Displace the line perpendicular to the plane...
line = smath.sph2cart(*smath.rake(strike, dip, rake))
norm = smath.sph2cart(*smath.pole(strike, dip))
line = np.array(line) + 0.5 * np.array(norm)
# Project the "displaced" line back onto the plane...
lon, lat = smath.cart2sph(*line)
plunge, bearing = smath.geographic2plunge_bearing(lon, lat)
newrake = smath.project_onto_plane(strike, dip, plunge, bearing)
assert np.allclose(rake, newrake)
def test_offset_back_to_rake(self):
for strike, dip, rake in self.data:
# Displace the line perpendicular to the plane...
line = smath.sph2cart(*smath.rake(strike, dip, rake))
norm = smath.sph2cart(*smath.pole(strike, dip))
line = np.array(line) + 0.5 * np.array(norm)
# Project the "displaced" line back onto the plane...
lon, lat = smath.cart2sph(*line)
plunge, bearing = smath.geographic2plunge_bearing(lon, lat)
newrake = smath.project_onto_plane(strike, dip, plunge, bearing)
assert np.allclose(rake, newrake)
def test_wedge_sliding(self):
wedge_analysis = kinematic.WedgeSliding(0, 75)
line1 = smath.geographic2plunge_bearing(np.radians(55), np.radians(40))
data = [
# plunge, bearing main, sec
[(75, 90), (True, False)], # just daylights
[(35, 60), (True, False)], # just at friction cone
[(45, 120), (True, False)],
[line1, (False, True)], # just at "friction plane"
[(30, 150), (False, True)],
[(30, 30), (False, True)],
[(80, 90), (False, False)],
[(0, 90), (False, False)],
[(20, 280), (False, False)],
]
for plunge_bearing, correct in data:
p, b = plunge_bearing
results = wedge_analysis.check_failure(b, p)
assert results == correct
def test_geographic2plunge_bearing(self):
for (bearing, plunge) in self.strike_dip:
lon, lat = smath.line(plunge, bearing)
assert np.allclose(smath.geographic2plunge_bearing(lon, lat),
[[plunge], [bearing]])
def test_rake_back_to_rakes(self):
for strike, dip, rake in self.data:
lon, lat = smath.rake(strike, dip, rake)
plunge, bearing = smath.geographic2plunge_bearing(lon, lat)
newrake = smath.project_onto_plane(strike, dip, plunge, bearing)
assert np.allclose(rake, newrake)
def test_geographic2plunge_bearing(self):
for (bearing, plunge) in self.strike_dip:
lon, lat = smath.line(plunge, bearing)
assert np.allclose(smath.geographic2plunge_bearing(lon, lat),
[[plunge], [bearing]])
def test_rake_back_to_rakes(self):
for strike, dip, rake in self.data:
lon, lat = smath.rake(strike, dip, rake)
plunge, bearing = smath.geographic2plunge_bearing(lon, lat)
newrake = smath.project_onto_plane(strike, dip, plunge, bearing)
assert np.allclose(rake, newrake)
def proyAnEllipse2LongLat(x, y, axis2rot, angles2rot):
'''Pojects just an ellipse from the :math:`\\mathbb{R}^2` coordinates of
the :math:`\\mathscr{P}-` plane that contains it to the real position on
the stereographic projection through some rotations from an initial
position at the nadir of the semi-sphere.
Parameters:
x (`numpy.ndarray` or `list`): Abscises of just one ellipse's boundary
on the :math:`\\mathscr{P}-` plane. It is obtained from the
``confRegions2PPlanes`` function.
y (`numpy.ndarray` or `list`): Ordinates of just one ellipse's
boundary on the :math:`\\mathscr{P}-` plane. It is obtained from
the ``confRegions2PPlanes`` function.
axis2rot (`list`): Strings with the axis-names of the **NED** system
around which will be done the rotatios to project the confidence
ellipse. It is obtained from the ``rotateaxis2proyectellipses``
function.
angles2rot (`list`): List of the angles in degrees for rotating a
ellipse once it is placed orthogonal to the nadir. It is obtained
from the ``rotateaxis2proyectellipses`` function.
Returns:
Two elements are returned; they are described below.
- **ellipLong** (`numpy.ndarray`): Longitudes of the ellipse's\
boundary after being rotated to its right position in the\
stereographic projection.
- **ellipLat** (`numpy.ndarray`): Latitudes of the ellipse's\
boundary after being rotated to its right position in the\
stereographic projection.
Examples:
>>> from numpy import array
>>> from jelinekstat.tools import confRegions2PPlanes
>>> majorAxis = array([ 0.66888885, 0.66949335, 0.13745895])
>>> minorAxis = array([ 0.09950548, 0.09615434, 0.04640122])
>>> theta = array([-0.01949436, -1.51693959, -0.81162812])
>>> x, y = confRegions2PPlanes(majorAxis, minorAxis, theta, False,
>>> 0.95)
>>> ellipLong, ellipLat = proyAnEllipse2LongLat(
>>> x[0], y[0], ['E', 'D', 'N', 'D'], [-180, 116.37, 70.93, 77.98])
'''
import numpy as np
from mplstereonet.stereonet_math import geographic2plunge_bearing, line
from mplstereonet.stereonet_math import _rotate as rot
# transform NED to xyz-mplstereonet axes notation
for i in range(len(axis2rot)):
if axis2rot[i] == 'N':
axis2rot[i] = 'z'
elif axis2rot[i] == 'E':
axis2rot[i] = 'y'
elif axis2rot[i] == 'D':
axis2rot[i] = 'x'
vectOnes = np.ones(len(x))
ellipNED = np.array([y, x, vectOnes]).T
ellipPlgTrd = np.array(list(map(vector2plungetrend, ellipNED)))
ellipPlg = ellipPlgTrd[:, 0]
ellipTrd = ellipPlgTrd[:, 1]
ellipLong, ellipLat = line(ellipPlg, ellipTrd)
for i in range(len(angles2rot)):
ellipLong, ellipLat = rot(np.degrees(ellipLong),
np.degrees(ellipLat),
angles2rot[i],
axis=axis2rot[i])
ellipPlg, ellipTrd = geographic2plunge_bearing(ellipLong, ellipLat)
ellipLong, ellipLat = line(ellipPlg, ellipTrd)
return ellipLong, ellipLat
def rotateaxis2proyectellipses(axisN, axisE, axisD):
'''Since it is easier, the projection of an ellpise (confidence region) on
the stereogrpahic net is thought as a serie of rotations from the bottom of
the semi-sphere, *i.e.*, the *nadir*.
This function determines the axes names around which is necesary to rotate
a confidence ellipse once it is placed at nadir of a semi-sphere to poject
her from the nadir to the real position on the semi-sphere. Besides, it
determines the angles to rotate at each axis name.
The ``mplstereonet`` reference system has the :math:`x, y` and :math:`z`
vectors as its base, and they correspond to the *nadir*, *east* and *north*
vectors in the **NED** reference system of the semi-spherical space of the
Stereographic Projection.
It is implicit that the three input vectors are orthogonal to each other
due to they correspond to the principal vectors of :math:`\\boldsymbol{k}`.
Parameters:
axisN (`numpy.ndarray`): Array with the coordinates :math:`x, y, z`
of the eigenvector that will point to the north-axis once the
ellipse is placed at nadir of the semi-sphere, *i.e.*, its
othogonal eigenvector associated points downward.
axisE (`numpy.ndarray`): Array with the coordinates :math:`x, y, z`
of the eigenvector that will point to the east-axis once the
ellipse is placed at nadir of the semi-sphere, *i.e.*, its
othogonal eigenvector associated points downward.
axisD (`numpy.ndarray`): Array with the coordinates :math:`x, y, z`
of the eigenvector that is othogonal to the ellipse.
Returns:
Two elements are returned; they are described below.
- **axis2rot** (`list`): Strings with the axis-names of the\
**NED** system around which will be done the rotatios to\
project the confidence ellipse.
- **angles2rot** (`list`): List of the angles in degrees for\
rotating a ellipse once it is placed orthogonal to the nadir.
Examples:
>>> from numpy import array
>>> from jelinekstat.tools import rotateaxis2proyectellipses
>>> axis2rot, angles2rot = rotateaxis2proyectellipses(
>>> array([2, 2, 1]), array([-2, 1, 2]), array([1, -2, 2]))
>>> axis2rot
['E', 'D', 'N', 'D']
>>> angles2rot
[-180, 26.565051177077976, 48.189685104221404, 206.56505117707798]
'''
import numpy as np
from mplstereonet.stereonet_math import geographic2plunge_bearing, line
from mplstereonet.stereonet_math import _rotate as rot
# Nadir axis
axisDplg, axisDtrd = vector2plungetrend(axisD)
axisDlong, axisDlat = line(axisDplg, axisDtrd)
# East axis
axisEplg, axisEtrd = vector2plungetrend(axisE)
axisElong, axisElat = line(axisEplg, axisEtrd)
# North axis
axisNplg, axisNtrd = vector2plungetrend(axisN)
axisNlong, axisNlat = line(axisNplg, axisNtrd)
# rotation around the nadir axis to put axisD on the E-W line
angle1 = 90 - axisDtrd
rot1long, rot1lat = rot(np.degrees([axisNlong, axisElong, axisDlong]),
np.degrees([axisNlat, axisElat, axisDlat]),
angle1,
axis='x')
rot1plg, rot1trd = geographic2plunge_bearing(rot1long, rot1lat)
# rotation around the north axis to put axisD on the nadir axis
angle2 = np.degrees(rot1long[2][0])
if rot1long[2] > 0:
angle2 *= -1
rot2long, rot2lat = rot(np.degrees(rot1long),
np.degrees(rot1lat),
angle2,
axis='z')
rot2plg, rot2trd = geographic2plunge_bearing(rot2long, rot2lat)
# rotation around the nadir axis to put axisE on the east axis
angle3 = 90 - rot2trd[1][0]
rot3long, rot3lat = rot(np.degrees(rot2long),
np.degrees(rot2lat),
angle3,
axis='x')
rot3plg, rot3trd = geographic2plunge_bearing(rot3long, rot3lat)
# rotation around the east axis to put axisN on the north axis
if rot3lat[0] < 0:
angle4 = 180
else:
angle4 = 0
rot4long, rot4lat = rot(np.degrees(rot3long),
np.degrees(rot3lat),
angle4,
axis='y')
rot4plg, rot4trd = geographic2plunge_bearing(rot4long, rot4lat)
axis2rot = ['E', 'D', 'N', 'D'] # ['y', 'x', 'z', 'x'] sensu mplstereonet
angles2rot = [-angle4, -angle3, -angle2, -angle1]
return axis2rot, angles2rot