ViewVC logotype

Contents of /trunk/doc/user/faultsystem.tex

Parent Directory Parent Directory | Revision Log Revision Log

Revision 2675 - (show annotations)
Mon Sep 21 02:32:17 2009 UTC (12 years ago) by gross
File MIME type: application/x-tex
File size: 14791 byte(s)
getMinValue added to the fault system.
1 \begin{figure}
2 \includegraphics[width=\textwidth]{figures/FaultSystem2D}
3 \caption{\label{FAULTSYSTEM2D}Two dimensional fault system with one fault named `t` in the $(x\hackscore{0},x\hackscore{1})$ and its parameterization in the
4 $w\hackscore{0}$ space. The fault has three segments.}
5 \end{figure}
7 \section{Fault System}
8 \label{Fault System}
9 The \class{FaultSystem} is an easy to use interface to handle 2D and 3D fault systems \index{faults} as used for instance in simulating fault ruptures. The main purpose of the class is to provide a parameterization of an individual fault in the system of fault. In case of a 2D fault the fault is parameterized by a single value $w\hackscore{0}$ and in the case of a 3D fault two parameters $w\hackscore{0}$ and $w\hackscore{1}$ are used. This parameterization can be used
10 to impose data (e.g. a slip distribution) onto the fault. It can also be a useful tool to visualize or analyze the results on the fault if the fault is not straight.
12 A fault $t$ in the fault system is represented by a staring point $V^{t0}$ and series of
13 direction, called strikes~\index{strike}, and the lengths $(l^{ti})$.
14 The strike of segment $i$ is defined by the angle $\sigma^{ti}$ between the $x\hackscore{0}$-axis and the
15 direction of the fault, see Figure~\ref{FAULTSYSTEM2D}. The length and strike defines the
16 polyline $(V^{ti})$ of the fault by
17 \begin{equation}
18 V^{ti} = V^{t(i-1)} +
19 l^{ti} \cdot S^{ti}
20 \mbox{ with }
21 S^{ti} =
22 \left[
23 \begin{array}{c}
24 cos(\sigma^{ti}) \\
25 sin(\sigma^{ti}) \\
26 0
27 \end{array}
28 \right]
29 \label{eq:fault 00}
30 \end{equation}
31 In the 3D case each fault segment $i$ has an additional dip \index{dip} $\theta^{ti}$ and
32 and at each vertex $i$ a depth $\delta^{ti}$ is given. The fault segment normal $n^{ti}$ is given by
33 \begin{equation}
34 n^{ti} =
35 \left[
36 \begin{array}{c}
37 -sin(\theta^{ti}) \cdot S^{ti}\hackscore{1} \\
38 sin(\theta^{ti}) \cdot S^{ti}\hackscore{0} \\
39 cos(\theta^{ti})
40 \end{array}
41 \right]
42 \label{eq:fault 0}
43 \end{equation}
44 At each vertex we define a depth vector $d^{ti}$ defined as the
45 intersect of the fault planes of segment $(i-1)$ and $i$ where
46 for the first segment and last segment the vector orthogonal to strike vector $S^{ti}$\index{strike}
47 and the segment normal $n^{ti}$ is used. The direction $\tilde{d}^{ti}$ of the depth vector is
48 given as
49 \begin{equation}
50 \tilde{d}^{ti} = n^{ti} \times n^{t(i-1)}
51 \label{eq:fault b}
52 \end{equation}
53 If $\tilde{d}^{ti}$ is zero the strike vectors $L^{t(i-1)}$ and $L^{ti}$ are collinear and
54 we can set $\tilde{d}^{ti} = l^{ti} \times n^{ti}$. If the two fault segments are almost
55 orthogonal $\tilde{d}^{ti}$ is pointing in the direction of $L^{t(i-1)}$ and $L^{ti}$. In this case no
56 depth can be defined. So we will reject a fault system if
57 \begin{equation}
58 min(\| \tilde{d}^{ti} \times L^{t(i-1)} \|,\| \tilde{d}^{ti} \times L^{ti} \|)
59 \le 0.1 \cdot \| \tilde{d}^{ti} |
60 \label{eq:fault c}
61 \end{equation}
62 which corresponds to an angle of less then $10^o$ between the depth vector and the strike. We then set
63 \begin{equation}
64 d^{ti}=\delta^{ti} \cdot \frac{\tilde{d}^{ti}}{\|\tilde{d}^{ti}\|}
65 \label{eq:fault d}
66 \end{equation}
67 We can then define the polyline $(v^{ti})$ for the bottom of the fault as
68 \begin{equation}
69 v^{ti}= V^{ti}+d^{ti}
70 \label{eq:fault e}
71 \end{equation}
72 In order to simplify working on
73 a fault $t$ in a fault system a parameterization $P^t: (w\hackscore{0},w\hackscore{1}) \rightarrow (x\hackscore{0},x\hackscore{1},x\hackscore{2})$ over a rectangular domain is introduced such that
74 \begin{equation}
75 0\le w\hackscore{0} \le w^t\hackscore{0 max} \mbox{ and } -w^t\hackscore{1max}\le w\hackscore{1} \le 0
76 \label{eq:fault 1}
77 \end{equation}
78 with positive if numbers $w^t\hackscore{0 max}$ and $w^t\hackscore{1 max}$. Typically one chooses
79 $w^t\hackscore{0 max}$ to be the unrolled length of the fault
80 $w^t\hackscore{1 max}$ to be the mean value of segment depth. Moreover we have
81 \begin{equation}
82 P^t(W^{ti})=V^{ti}\mbox{ and } P^t(w^{ti})=v^{ti}\
83 \label{eq:fault 2}
84 \end{equation}
85 where
86 \begin{equation}
87 W^{ti}=(\Omega^{ti},0) \mbox{ and } w^{ti}=(\Omega^{ti},-w^t\hackscore{1 max})
88 \label{eq:fault 3}
89 \end{equation}
90 and $\Omega^{ti}$ is the unrolled distance of $W^{ti}$ from $W^{t0}$, ie $l^{ti}=\Omega^{t(i+1)}-\Omega^{ti}$. In the 2D case $w^t\hackscore{1 max}$ is set to zero and therefore the second component is dropped, see Figure~\ref{FAULTSYSTEM2D}.
92 In the case of 2D the parameterization $P^t$ is constructed as follows:
93 The line connecting $V^{t(i-1)}$ and $V^{ti}$ is given by
94 \begin{equation}
95 x=V^{ti} + s \cdot ( V^{t(i+1)}- V^{ti} )
96 \label{eq:2D line 1}
97 \end{equation}
98 where $s$ is between $0$ and $1$. The point $x$ is on $i$-th fault segment if and only if
99 such an $s$ exists. If assume $x$ is on the fault one can calculate $s$ as
100 \begin{equation}
101 s = \frac{ (x- V^{ti})^t \cdot (V^{t(i+1)}- V^{ti}) }{ \|V^{t(i+1)}- V^{ti}\|^2}
102 \label{eq:2D line 1b}
103 \end{equation}
104 We then can set
105 \begin{equation}
106 w\hackscore{0}=\Omega^{ti}+s \cdot (\Omega^{ti}-\Omega^{t(i-1)})
107 \label{eq:2D line 2}
108 \end{equation}
109 to get $P^t(w\hackscore{0})=x$.
110 It remains the question if the given $x$ is actual on the segment $i$ of fault $t$. To test this $s$ is restricted
111 between $0$ and $1$ (so if $s<0$ $s$ is set to $0$ and if $s>1$ $s$ is set to $1$) and the we check the
112 residual of equation~\ref{eq:2D line 1}, ie. $x$ is been accepted to be in the segment if
113 \begin{equation}
114 \|x-V^{ti} - s \cdot (V^{t(i+1)}- V^{ti}) \| \le tol \cdot
115 max(l^{ti}, \|x-V^{ti} \|)
116 \label{eq:2D line 3}
117 \end{equation}
118 where $tol$ is a given tolerance.
120 In the 3D case the situation is a bit more complicated: we split the fault segment across
121 the diagonal $V^{ti}$-$v^{t(i+1)}$ to produce two triangles. In the upper triangle we use the
122 parameterization
123 \begin{equation}
124 x= V^{ti} + s \cdot (V^{t(i+1)}-V^{ti}) + r \cdot (v^{t(i+1)}-V^{t(i+1)})
125 \mbox{ with } r \le s;
126 \label{eq:2D line 4}
127 \end{equation}
128 while in the lower triangle we use
129 \begin{equation}
130 x= V^{ti} + s \cdot (v^{t(i+1)}-v^{ti}) + r \cdot (v^{ti}-V^{ti})
131 \mbox{ with } s \le r;
132 \label{eq:2D line 4b}
133 \end{equation}
134 where $0\le s,r \le 1$. Both equations are solved in the least-squares sense e.g. using the Moore–Penrose pseudo-inverse for the coefficient matrices. The resulting $s$ and $r$ are then restricted to the unit square. Similar to the 2D case (see equation~\ref{eq:2D line 3}) we identify $x$ to be in the upper triangle of the segment if
135 \begin{equation}
136 \|x- V^{ti} - s \cdot (V^{t(i+1)}-V^{ti}) - r \cdot (v^{t(i+1)}-V^{t(i+1)}) \|
137 \le tol \cdot max(\|x-V^{ti} \|,\|v^{t(i+1)}-V^{t(i)})\|)
138 \label{eq:2D line 4c}
139 \end{equation}
140 and in the lower part
141 \begin{equation}
142 \|x-V^{ti} - s \cdot (v^{t(i+1)}-v^{ti}) - r \cdot (v^{ti}-V^{ti}) \|
143 \le tol \cdot max(\|x-V^{ti} \|,\|v^{t(i+1)}-V^{t(i)})\|)
144 \label{eq:2D line 4d}
145 \end{equation}
146 after the restriction of $(s,t)$ to the unit square. Note that $\|v^{t(i+1)}-V^{t(i)})\|$ is length of the
147 diagonal of the fault segment. For those $x$ which have been located in the $i$-th segment we then set
148 \begin{equation}
149 w\hackscore{0}=\Omega^{ti}+s \cdot (\Omega^{ti}-\Omega^{t(i-1)})
150 \mbox{ and }
151 w\hackscore{1}=w^t\hackscore{1max} (r-1)
152 \label{eq:2D line 5}
153 \end{equation}
156 \subsection{Functions}
158 \begin{classdesc}{FaultSystem}{
159 \optional{dim =3}}
160 Creates a fault system in the \var{dim} dimensional space.
161 \end{classdesc}
163 \begin{methoddesc}[FaultSystem]{getMediumDepth}{tag}
164 returns the medium depth of fault \var{tag}.
165 \end{methoddesc}
167 \begin{methoddesc}[FaultSystem]{getTags}{}
168 returns a list of the tags used by the fault system
169 \end{methoddesc}
171 \begin{methoddesc}[FaultSystem]{getStart}{tag}
172 returns the starting point of fault \var{tag} as a \numpyNDA object.
173 \end{methoddesc}
175 \begin{methoddesc}[FaultSystem]{getDim}{}
176 returns the spatial dimension
177 \end{methoddesc}
179 \begin{methoddesc}[FaultSystem]{getDepths}{tag}
180 returns the list of the depths of the segements in fault \var{tag}.
181 \end{methoddesc}
184 \begin{methoddesc}[FaultSystem]{getTopPolyline}{tag}
185 returns the polyline used to describe fault tagged by \var{tag}
186 \end{methoddesc}
188 \begin{methoddesc}[FaultSystem]{getStrikes}{tag}
189 returns the list of strikes $\sigma^{ti}$ of the segements in fault $t=$\var{tag}
190 \end{methoddesc}
193 \begin{methoddesc}[FaultSystem]{getStrikeVectors}{tag}
194 returns the strike vectors $S^{ti}$ of fault $t=$\var{tag}
195 \end{methoddesc}
198 \begin{methoddesc}[FaultSystem]{getLengths}{tag}
199 returns the lengths $l^{ti}$ of segments in fault $t=$\var{tag}
200 \end{methoddesc}
203 \begin{methoddesc}[FaultSystem]{getTotalLength}{tag}
204 returns the total unrolled length of fault \var{tag}
205 \end{methoddesc}
207 \begin{methoddesc}[FaultSystem]{getDips}{tag}
208 returns the list of the dips of the segements in fault \var{tag}.
209 \end{methoddesc}
211 \begin{methoddesc}[FaultSystem]{getBottomPolyline}{tag}
212 returns the list of the vertices defining the bottom of the fault \var{tag}.
213 \end{methoddesc}
215 \begin{methoddesc}[FaultSystem]{getSegmentNormals}{tag}
216 returns the list of the normals of the segments in fault \var{tag}.
217 \end{methoddesc}
219 \begin{methoddesc}[FaultSystem]{getDepthVectors}{tag}
220 returns the list of the depth vectors $d^{ti}$ for fault $t=$\var{tag}.
221 \end{methoddesc}
223 \begin{methoddesc}[FaultSystem]{getDepths}{tag}
224 returns the list of the depths of the segements in fault \var{tag}.
225 \end{methoddesc}
227 \begin{methoddesc}[FaultSystem]{getW0Range}{tag}
228 returns the range of the parameterization in $w\hackscore{0}$.
229 For tag $t$ this is the pair $(\Omega^{t0},\Omega^{tn})$ where $n$ is the number of segments in the fault.
230 In most cases one has $(\Omega^{t0},\Omega^{tn})=(0,w^t\hackscore{0 max})$.
231 \end{methoddesc}
233 \begin{methoddesc}[FaultSystem]{getW1Range}{tag}
234 returns the range of the parameterization in $w\hackscore{1}$.
235 For tag $t$ this is the pair $(-w^t\hackscore{1max},0)$.
236 \end{methoddesc}
238 \begin{methoddesc}[FaultSystem]{getW0Offsets}{tag}
239 returns the offsets for the parameterization of fault \var{tag}.
240 For tag \var{tag}=$t$ this is the list $[\Omega^{ti}]$.
241 \end{methoddesc}
243 \begin{methoddesc}[FaultSystem]{getCenterOnSurface}{}
244 returns the center point of the fault system at the surfaces. In 3D the calculation of the center is
245 considering the top edge of the faults and projects the edge to the surface (the $x\hackscore{2}$ component is assumed to be 0). An \numpyNDA object is returned.
246 \end{methoddesc}
248 \begin{methoddesc}[FaultSystem]{getOrientationOnSurface}{}
249 returns the orientation of the fault system in RAD on the surface ($x\hackscore{2}=0$ plane) around the fault system center.
250 \end{methoddesc}
251 \begin{methoddesc}[FaultSystem]{transform}{\optional{rot=0, \optional{shift=numpy.zeros((3,)}}}
252 applies a shift \var{shift} and a consecutive rotation in the $x\hackscore{2}=0$ plane.
253 \var{rot} is a float number and \var{shift} an \numpyNDA object.
254 \end{methoddesc}
256 \begin{methoddesc}[FaultSystem]{getMaxValue}{f\optional{, tol=1.e-8}}
257 returns the maximum value of \var{f}, the fault where the maximum is found and the location on the fault in fault coordinates. \var{f} must be a \Scalar. When the maximum is calculated only \DataSamplePoints are considered
258 which are on a fault in the fault system in the sense of condition~\ref{eq:2D line 3} or \ref{eq:3D line 3}, respectively. In the case no \DataSamplePoints is found the returned tag is \var{None} and
259 the maximum value as well as the location of the maximum value are undefined.
260 \end{methoddesc}
262 \begin{methoddesc}[FaultSystem]{getMinValue}{f\optional{, tol=1.e-8}}
263 returns the minimum value of \var{f}, the fault where the minimum is found and the location on the fault in fault coordinates. \var{f} must be a \Scalar. When the minimum is calculated only \DataSamplePoints are considered
264 which are on a fault in the fault system in the sense of condition~\ref{eq:2D line 3} or \ref{eq:3D line 3}, respectively. In the case no \DataSamplePoints is found the returned tag is \var{None} and
265 the minimum value as well as the location of the mimimum value are undefined.
266 \end{methoddesc}
268 \begin{methoddesc}[FaultSystem]{getParametrization}{x,tag \optional{\optional{, tol=1.e-8}, outsider=None}}
269 returns the argument $w$ of the parameterization $P^t$ for \var{tag}=$t$ to provide \var{x}
270 together with a mask indicating where the given location if on a fault in the fault system by the value $1$ (otherwise the value is set to $0$). \var{x} needs to be \Vector or \numpyNDA object. \var{tol} defines the tolerance to decide if a given \DataSamplePoints is on fault \var{tag}. The value
271 \var{outside} is the value used as a replacement value for $w$ where the corresponding value in \var{x} is not
272 on a fault. If not \var{outside} is not present an appropriate value is used.
273 \end{methoddesc}
275 \begin{methoddesc}[FaultSystem]{getSideAndDistance}{x,tag}
276 returns the side and the distance at locations \var{x} from the fault \var{tag}.
277 \var{x} needs to be \Vector or \numpyNDA object. Positive values for side means that the corresponding location is
278 to the right of the fault, a negative value means that the corresponding location is
279 to the left of the fault. The value zero means that the side is undefined.
280 \end{methoddesc}
285 \begin{methoddesc}[FaultSystem]{getFaultSegments}{tag}
286 returns the polylines used to describe fault \var{tag}. For \var{tag}=$t$ this is the list of the vertices
287 $[V^{ti}]$ for the 2D and the pair of lists of the top vertices $[V^{ti}]$ and the bottom vertices $[v^{ti}]$ in 3D.
288 Note that the coordinates are represented as \numpyNDA objects.
289 \end{methoddesc}
291 \begin{methoddesc}[FaultSystem]{addFault}{
292 strikes\optional{,
293 ls\optional{,
294 V0=[0.,0.,0.]\optional{,
295 tag=None\optional{,
296 dips=None\optional{,
297 depths= None\optional{,
298 w0_offsets=None\optional{,
299 w1_max=None}}}}}}}}
300 adds the fault \var{tag} to the fault system.
301 \var{V0} defines the start point of fault names $t=$\var{tag}. The polyline
302 defining the fault segments on the surface are set
303 by the strike angles \var{strikes} (=$\sigma^{ti}$, north = $\pi/2$, the orientation is counter clockwise.) and
304 the length \var{ls} (=$l^{ti}$). In the 3D one also needs to define the
305 dip angles \var{dips} (=$\delta^{ti}$, vertical=$0$, right-hand rule applies.) and
306 the depth \var{depths} for each segment.
307 \var{w1_max} defines the range of the $w\hackscore{1}$. If not present the mean value over the depth of
308 all segment edges in the fault is used.
309 \var{w0_offsets} sets the offsets $\Omega^{ti}$. If not present it i chosen such that $\Omega^{ti}-\Omega^{t(i-1)}$ is the length of the $i$-th segment. In some cases, eg. when kinks in the fault are relevant, it can be useful
310 to explicitly specify the offsets in order to simplify the assignment of values.
311 \end{methoddesc}
313 \subsection{Example}
314 See section~\ref{Slip CHAP}

  ViewVC Help
Powered by ViewVC 1.1.26