1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

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

103

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

import numpy as num 

 

from matplotlib import pyplot as plt 

from matplotlib.ticker import FuncFormatter 

 

from pyrocko.plot import mpl_init, mpl_margins, mpl_papersize 

 

km = 1e3 

 

 

def draw( 

axes, 

dislocation, 

coordinates, 

xlims=[], 

ylims=[], 

zero_center=False, 

*args, 

**kwargs): 

''' 

Do scatterplot of dislocation array 

 

:param axes: container for figure elements, as plot, coordinate system etc. 

:type axes: :py:class:`matplotlib.axes` 

:param dislocation: Dislocation array [m] 

:type dislocation: :py:class:`numpy.ndarray`, ``(N,)`` 

:param xlims: x limits of the plot [m] 

:type xlims: optional, :py:class:`numpy.ndarray`, ``(2,)`` or list 

:param ylims: y limits of the plot [m] 

:type ylims: optional, :py:class:`numpy.ndarray`, ``(2,)`` or list 

:param zero_center: optional, bool 

:type zero_center: True, if colorscale for dislocations shall extend from 

-Max(Abs(dislocations)) to Max(Abs(dislocations)) 

 

:return: Scatter plot path collection 

:rtype: :py:class:`matplotlib.collections.PathCollection` 

''' 

 

if zero_center: 

vmax = num.max(num.abs([ 

num.min(dislocation), num.max(dislocation)])) 

vmin = -vmax 

else: 

vmin = num.min(dislocation) 

vmax = num.max(dislocation) 

 

scat = axes.scatter( 

coordinates[:, 1], 

coordinates[:, 0], 

c=dislocation, 

edgecolor='None', 

vmin=vmin, vmax=vmax, 

*args, **kwargs) 

 

if xlims and ylims: 

axes.set_xlim(xlims) 

axes.set_ylim(ylims) 

 

return scat 

 

 

def setup_axes(axes, title='', xlabeling=False, ylabeling=False): 

''' 

Create standard title, gridding and axis labels 

 

:param axes: container for figure elements, as plot, coordinate system etc. 

:type axes: :py:class:`matplotlib.axes` 

:param title: optional, str 

:type title: Title of the subplot 

:param xlabeling: optional, bool 

:type xlabeling: True, if x-label shall be printed 

:param ylabeling: optional, bool 

:type ylabeling: True, if y-label shall be printed 

''' 

 

axes.set_title(title) 

axes.grid(True) 

km_formatter = FuncFormatter(lambda x, v: x / km) 

axes.xaxis.set_major_formatter(km_formatter) 

axes.yaxis.set_major_formatter(km_formatter) 

if xlabeling: 

axes.set_xlabel('Easting [$km$]') 

if ylabeling: 

axes.set_ylabel('Northing [$km$]') 

 

 

def plot( 

dislocations, 

coordinates, 

filename='', 

dpi=100, 

fontsize=10., 

figsize=None, 

titles=None, 

*args, 

**kwargs): 

 

''' 

Create and displays/stores a scatter dislocation plot 

 

:param dislocations: Array containing dislocation in north, east and down 

direction and optionally also the dislocation vector length 

:type dislocations: :py:class:`numpy.ndarray`, ``(N, 3/4)`` 

:param coordinates: Coordinates [km] of observation points 

(northing, easting) 

:type coordinates: :py:class:`numpy.ndarray`, ``(N, 2)`` 

:param filename: If given, plot is stored at filename, else plot is 

displayed 

:type filename: optional, str 

:param dpi: Resolution of the plot [dpi] 

:type dpi: optional, int 

:param fontsize: Fontsize of the plot labels and titles [pt] 

:type fontsize: optional, int 

:param figsize: Tuple of the figure size [cm] 

:type figsize: optional, tuple 

:param titles: If new subplot titles are whished, give them here (needs to 

four titles!) 

:type titles: optional, list of str 

''' 

assert dislocations.shape[1] >= 3 

assert coordinates.shape[0] == dislocations.shape[0] 

 

mpl_init(fontsize=fontsize) 

 

if figsize is None: 

figsize = mpl_papersize('a4', 'landscape') 

 

fig = plt.figure(figsize=figsize) 

labelpos = mpl_margins( 

fig, 

left=7., right=5., top=5., bottom=6., nw=2, nh=2, 

wspace=6., hspace=5., units=fontsize) 

 

if not titles: 

titles = [ 

'Displacement North', 

'Displacement East', 

'Displacement Down', 

'||Displacement||'] 

 

assert len(titles) == 4 

 

data = dislocations[:, :3] 

data = num.hstack((data, num.linalg.norm(data, axis=1)[:, num.newaxis])) 

 

for iax in range(1, 5): 

axes = fig.add_subplot(2, 2, iax) 

labelpos(axes, 2., 2.5) 

 

setup_axes( 

axes=axes, 

title=titles[iax - 1], 

xlabeling=False if iax < 3 else True, 

ylabeling=False if iax in [2, 4] else True) 

 

scat = draw( 

axes=axes, 

dislocation=num.squeeze(data[:, iax - 1]), 

coordinates=coordinates, 

*args, 

**kwargs) 

 

cbar = fig.colorbar(scat) 

cbar.set_label('[$m$]') 

 

if filename: 

fig.savefig(filename, dpi=dpi) 

else: 

plt.show()