/[escript]/trunk/doc/user/faultsystem.tex
ViewVC logotype

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3329 - (show annotations)
Fri Oct 29 05:55:55 2010 UTC (8 years, 10 months ago) by caltinay
File MIME type: application/x-tex
File size: 15325 byte(s)
Faultsystems2d. not finished yet.

1
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 %
4 % Copyright (c) 2003-2010 by University of Queensland
5 % Earth Systems Science Computational Center (ESSCC)
6 % http://www.uq.edu.au/esscc
7 %
8 % Primary Business: Queensland, Australia
9 % Licensed under the Open Software License version 3.0
10 % http://www.opensource.org/licenses/osl-3.0.php
11 %
12 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13
14 \section{Fault System}
15 \label{Fault System}
16 The \class{FaultSystem} class provides an easy-to-use interface to handle 2D
17 and 3D fault systems\index{faults} as used for instance in simulating fault
18 ruptures. The main purpose of the class is to provide a parameterization of
19 an individual fault in the system of faults.
20 In case of a 2D fault the fault is parameterized by a single value $w_{0}$ and
21 in the case of a 3D fault two parameters $w_{0}$ and $w_{1}$ are used.
22 This parameterization can be used to impose data (e.g. a slip distribution)
23 onto the fault. It can also be a useful tool to visualize or analyze the
24 results on the fault if the fault is not straight.
25
26 \begin{figure}
27 \centering
28 \includegraphics{FaultSystem2D}
29 \caption{\label{FAULTSYSTEM2D}Two dimensional fault system with one fault
30 named `t` in the $(x_{0},x_{1})$ space and its parameterization in the
31 $w_{0}$ space. The fault has three segments.}
32 \end{figure}
33
34 A fault $t$ in the fault system is represented by a starting point $V^{t0}$
35 and series of directions, called strikes\index{strike}, and the lengths $(l^{ti})$.
36 The strike of segment $i$ is defined by the angle $\sigma^{ti}$ between the
37 $x_{0}$-axis and the direction of the fault, see Figure~\ref{FAULTSYSTEM2D}.
38 The length and strike defines the polyline $(V^{ti})$ of the fault by
39 \begin{equation}
40 V^{ti} = V^{t(i-1)} +
41 l^{ti} \cdot S^{ti}
42 \mbox{ with }
43 S^{ti} =
44 \left[
45 \begin{array}{c}
46 cos(\sigma^{ti}) \\
47 sin(\sigma^{ti}) \\
48 0
49 \end{array}
50 \right]
51 \label{eq:fault 00}
52 \end{equation}
53 In the 3D case each fault segment $i$ has an additional dip\index{dip}
54 $\theta^{ti}$ and at each vertex $i$ a depth $\delta^{ti}$ is given.
55 The fault segment normal $n^{ti}$ is given by
56 \begin{equation}
57 n^{ti} =
58 \left[
59 \begin{array}{c}
60 -sin(\theta^{ti}) \cdot S^{ti}_{1} \\
61 sin(\theta^{ti}) \cdot S^{ti}_{0} \\
62 cos(\theta^{ti})
63 \end{array}
64 \right]
65 \label{eq:fault 0}
66 \end{equation}
67 At each vertex we define a depth vector $d^{ti}$ defined as the intersect of
68 the fault planes of segment $(i-1)$ and $i$ where for the first segment and
69 last segment the vector orthogonal to strike vector $S^{ti}$\index{strike}
70 and the segment normal $n^{ti}$ is used. The direction $\tilde{d}^{ti}$ of the
71 depth vector is given as
72 \begin{equation}
73 \tilde{d}^{ti} = n^{ti} \times n^{t(i-1)}
74 \label{eq:fault b}
75 \end{equation}
76 If $\tilde{d}^{ti}$ is zero the strike vectors $L^{t(i-1)}$ and $L^{ti}$ are
77 collinear and we can set $\tilde{d}^{ti} = l^{ti} \times n^{ti}$.
78 If the two fault segments are almost orthogonal $\tilde{d}^{ti}$ is pointing
79 in the direction of $L^{t(i-1)}$ and $L^{ti}$. In this case no depth can be
80 defined. So we will reject a fault system if
81 \begin{equation}
82 min(\| \tilde{d}^{ti} \times L^{t(i-1)} \|,\| \tilde{d}^{ti} \times L^{ti} \|)
83 \le 0.1 \cdot \| \tilde{d}^{ti} |
84 \label{eq:fault c}
85 \end{equation}
86 which corresponds to an angle of less than $10^o$ between the depth vector and
87 the strike. We then set
88 \begin{equation}
89 d^{ti}=\delta^{ti} \cdot \frac{\tilde{d}^{ti}}{\|\tilde{d}^{ti}\|}
90 \label{eq:fault d}
91 \end{equation}
92 We can then define the polyline $(v^{ti})$ for the bottom of the fault as
93 \begin{equation}
94 v^{ti}= V^{ti}+d^{ti}
95 \label{eq:fault e}
96 \end{equation}
97 In order to simplify working on a fault $t$ in a fault system a
98 parameterization $P^t: (w_{0},w_{1}) \rightarrow (x_{0},x_{1},x_{2})$ over a
99 rectangular domain is introduced such that
100 \begin{equation}
101 0\le w_{0} \le w^t_{0 max} \mbox{ and } -w^t_{1max}\le w_{1} \le 0
102 \label{eq:fault 1}
103 \end{equation}
104 with positive numbers $w^t_{0 max}$ and $w^t_{1 max}$. Typically one chooses
105 $w^t_{0 max}$ to be the unrolled length of the fault and $w^t_{1 max}$ to be
106 the mean value of segment depth. Moreover we have
107 \begin{equation}
108 P^t(W^{ti})=V^{ti}\mbox{ and } P^t(w^{ti})=v^{ti}\
109 \label{eq:fault 2}
110 \end{equation}
111 where
112 \begin{equation}
113 W^{ti}=(\Omega^{ti},0) \mbox{ and } w^{ti}=(\Omega^{ti},-w^t_{1 max})
114 \label{eq:fault 3}
115 \end{equation}
116 and $\Omega^{ti}$ is the unrolled distance of $W^{ti}$ from $W^{t0}$, i.e.
117 $l^{ti}=\Omega^{t(i+1)}-\Omega^{ti}$. In the 2D case $w^t_{1 max}$ is set to
118 zero and therefore the second component is dropped, see Figure~\ref{FAULTSYSTEM2D}.
119
120 In the 2D case the parameterization $P^t$ is constructed as follows:
121 The line connecting $V^{t(i-1)}$ and $V^{ti}$ is given by
122 \begin{equation}
123 x=V^{ti} + s \cdot ( V^{t(i+1)}- V^{ti} )
124 \label{eq:2D line 1}
125 \end{equation}
126 where $s$ is between $0$ and $1$. The point $x$ is on $i$-th fault segment if
127 and only if such an $s$ exists. Assuming $x$ is on the fault it can be
128 calculated as
129 \begin{equation}
130 s = \frac{ (x- V^{ti})^t \cdot (V^{t(i+1)}- V^{ti}) }{ \|V^{t(i+1)}- V^{ti}\|^2}
131 \label{eq:2D line 1b}
132 \end{equation}
133 We then can set
134 \begin{equation}
135 w_{0}=\Omega^{ti}+s \cdot (\Omega^{ti}-\Omega^{t(i-1)})
136 \label{eq:2D line 2}
137 \end{equation}
138 to get $P^t(w_{0})=x$.
139 It remains the question if the given $x$ is actually on the segment $i$ of
140 fault $t$. To test this $s$ is restricted between $0$ and $1$ (so if $s<0$, $s$
141 is set to $0$ and if $s>1$, $s$ is set to $1$) and then we check the residual
142 of \eqn{eq:2D line 1}, i.e. $x$ has been accepted to be in the segment if
143 \begin{equation}
144 \|x-V^{ti} - s \cdot (V^{t(i+1)}- V^{ti}) \| \le tol \cdot
145 max(l^{ti}, \|x-V^{ti} \|)
146 \label{eq:2D line 3}
147 \end{equation}
148 where $tol$ is a given tolerance.
149
150 In the 3D case the situation is a bit more complicated: we split the fault
151 segment across the diagonal $V^{ti}$-$v^{t(i+1)}$ to produce two triangles.
152 In the upper triangle we use the parameterization
153 \begin{equation}
154 x= V^{ti} + s \cdot (V^{t(i+1)}-V^{ti}) + r \cdot (v^{t(i+1)}-V^{t(i+1)})
155 \mbox{ with } r \le s;
156 \label{eq:2D line 4}
157 \end{equation}
158 while in the lower triangle we use
159 \begin{equation}
160 x= V^{ti} + s \cdot (v^{t(i+1)}-v^{ti}) + r \cdot (v^{ti}-V^{ti})
161 \mbox{ with } s \le r;
162 \label{eq:2D line 4b}
163 \end{equation}
164 where $0\le s,r \le 1$. Both equations are solved in the least-squares sense
165 e.g. using the Moore–Penrose pseudo-inverse for the coefficient matrices.
166 The resulting $s$ and $r$ are then restricted to the unit square. Similar to
167 the 2D case (see \eqn{eq:2D line 3}) we identify $x$ to be in the upper
168 triangle of the segment if
169 \begin{equation}
170 \|x- V^{ti} - s \cdot (V^{t(i+1)}-V^{ti}) - r \cdot (v^{t(i+1)}-V^{t(i+1)}) \|
171 \le tol \cdot max(\|x-V^{ti} \|,\|v^{t(i+1)}-V^{t(i)})\|)
172 \label{eq:2D line 4c}
173 \end{equation}
174 and in the lower part
175 \begin{equation}
176 \|x-V^{ti} - s \cdot (v^{t(i+1)}-v^{ti}) - r \cdot (v^{ti}-V^{ti}) \|
177 \le tol \cdot max(\|x-V^{ti} \|,\|v^{t(i+1)}-V^{t(i)})\|)
178 \label{eq:2D line 4d}
179 \end{equation}
180 after the restriction of $(s,t)$ to the unit square.
181 Note that $\|v^{t(i+1)}-V^{t(i)})\|$ is the length of the diagonal of the
182 fault segment. For those $x$ which have been located in the $i$-th segment we
183 then set
184 \begin{equation}
185 w_{0}=\Omega^{ti}+s \cdot (\Omega^{ti}-\Omega^{t(i-1)})
186 \mbox{ and }
187 w_{1}=w^t_{1max} (r-1)
188 \label{eq:2D line 5}
189 \end{equation}
190
191 \subsection{Functions}
192
193 \begin{classdesc}{FaultSystem}{\optional{dim =3}}
194 creates a fault system in the \var{dim} dimensional space.
195 \end{classdesc}
196
197 \begin{methoddesc}[FaultSystem]{getMediumDepth}{tag}
198 returns the medium depth of fault \var{tag}.
199 \end{methoddesc}
200
201 \begin{methoddesc}[FaultSystem]{getTags}{}
202 returns a list of the tags used by the fault system.
203 \end{methoddesc}
204
205 \begin{methoddesc}[FaultSystem]{getStart}{tag}
206 returns the starting point of fault \var{tag} as a \numpyNDA object.
207 \end{methoddesc}
208
209 \begin{methoddesc}[FaultSystem]{getDim}{}
210 returns the spatial dimension.
211 \end{methoddesc}
212
213 \begin{methoddesc}[FaultSystem]{getDepths}{tag}
214 returns the list of the depths of the segments in fault \var{tag}.
215 \end{methoddesc}
216
217 \begin{methoddesc}[FaultSystem]{getTopPolyline}{tag}
218 returns the polyline used to describe the fault tagged by \var{tag}.
219 \end{methoddesc}
220
221 \begin{methoddesc}[FaultSystem]{getStrikes}{tag}
222 returns the list of strikes $\sigma^{ti}$ of the segments in fault
223 $t=$\var{tag}.
224 \end{methoddesc}
225
226 \begin{methoddesc}[FaultSystem]{getStrikeVectors}{tag}
227 returns the strike vectors $S^{ti}$ of fault $t=$\var{tag}.
228 \end{methoddesc}
229
230 \begin{methoddesc}[FaultSystem]{getLengths}{tag}
231 returns the lengths $l^{ti}$ of the segments in fault $t=$\var{tag}.
232 \end{methoddesc}
233
234 \begin{methoddesc}[FaultSystem]{getTotalLength}{tag}
235 returns the total unrolled length of fault \var{tag}.
236 \end{methoddesc}
237
238 \begin{methoddesc}[FaultSystem]{getDips}{tag}
239 returns the list of the dips of the segments in fault \var{tag}.
240 \end{methoddesc}
241
242 \begin{methoddesc}[FaultSystem]{getBottomPolyline}{tag}
243 returns the list of the vertices defining the bottom of the fault \var{tag}.
244 \end{methoddesc}
245
246 \begin{methoddesc}[FaultSystem]{getSegmentNormals}{tag}
247 returns the list of the normals of the segments in fault \var{tag}.
248 \end{methoddesc}
249
250 \begin{methoddesc}[FaultSystem]{getDepthVectors}{tag}
251 returns the list of the depth vectors $d^{ti}$ for fault $t=$\var{tag}.
252 \end{methoddesc}
253
254 \begin{methoddesc}[FaultSystem]{getDepths}{tag}
255 returns the list of the depths of the segments in fault \var{tag}.
256 \end{methoddesc}
257
258 \begin{methoddesc}[FaultSystem]{getW0Range}{tag}
259 returns the range of the parameterization in $w_{0}$.
260 For tag $t$ this is the pair $(\Omega^{t0},\Omega^{tn})$ where $n$ is the
261 number of segments in the fault.
262 In most cases one has $(\Omega^{t0},\Omega^{tn})=(0,w^t_{0 max})$.
263 \end{methoddesc}
264
265 \begin{methoddesc}[FaultSystem]{getW1Range}{tag}
266 returns the range of the parameterization in $w_{1}$.
267 For tag $t$ this is the pair $(-w^t_{1max},0)$.
268 \end{methoddesc}
269
270 \begin{methoddesc}[FaultSystem]{getW0Offsets}{tag}
271 returns the offsets for the parameterization of fault \var{tag}.
272 For tag \var{tag}=$t$ this is the list $[\Omega^{ti}]$.
273 \end{methoddesc}
274
275 \begin{methoddesc}[FaultSystem]{getCenterOnSurface}{}
276 returns the center point of the fault system at the surfaces.
277 In 3D the calculation of the center is considering the top edge of the faults
278 and projects the edge to the surface (the $x_{2}$ component is assumed to be
279 0). An \numpyNDA object is returned.
280 \end{methoddesc}
281
282 \begin{methoddesc}[FaultSystem]{getOrientationOnSurface}{}
283 returns the orientation of the fault system in RAD on the surface
284 ($x_{2}=0$ plane) around the fault system center.
285 \end{methoddesc}
286
287 \begin{methoddesc}[FaultSystem]{transform}{\optional{rot=0, \optional{shift=numpy.zeros((3,)}}}
288 applies a shift \var{shift} and a consecutive rotation in the $x_{2}=0$ plane.
289 \var{rot} is a float number and \var{shift} an \numpyNDA object.
290 \end{methoddesc}
291
292 \begin{methoddesc}[FaultSystem]{getMaxValue}{f\optional{, tol=1.e-8}}
293 returns the tag of the fault where \var{f} takes the maximum value and a
294 \class{Locator} object which can be used to collect values from \Data objects
295 at the location where the maximum is taken, e.g.
296 \begin{python}
297 fs=FaultSystem()
298 f=Scalar(..)
299 t, loc=fs.getMaxValue(f)
300 print "maximum value of f on the fault %s is %s at location."%(t,loc(f),loc.getX())
301 \end{python}
302 \var{f} must be a \Scalar. When the maximum is calculated only
303 \DataSamplePoints are considered which are on a fault in the fault system in
304 the sense of condition~\ref{eq:2D line 3} or \ref{eq:2D line 4d}, respectively.
305 In the case no \DataSamplePoints are found the returned tag is \var{None} and
306 the maximum value as well as the location of the maximum value are undefined.
307 \end{methoddesc}
308
309 \begin{methoddesc}[FaultSystem]{getMinValue}{f\optional{, tol=1.e-8}}
310 returns the tag of the fault where \var{f} takes the minimum value and a
311 \class{Locator} object which can be used to collect values from \Data objects
312 at the location where the minimum is taken, e.g.
313 \begin{python}
314 fs=FaultSystem()
315 f=Scalar(..)
316 t, loc=fs.getMinValue(f)
317 print "minimum value of f on the fault %s is %s at location."%(t,loc(f),loc.getX())
318 \end{python}
319 \var{f} must be a \Scalar. When the minimum is calculated only
320 \DataSamplePoints are considered which are on a fault in the fault system in
321 the sense of condition~\ref{eq:2D line 3} or \ref{eq:2D line 4d}, respectively.
322 In the case no \DataSamplePoints are found the returned tag is \var{None} and
323 the minimum value as well as the location of the minimum value are undefined.
324 \end{methoddesc}
325
326 \begin{methoddesc}[FaultSystem]{getParametrization}{x,tag \optional{\optional{, tol=1.e-8}, outsider=None}}
327 returns the argument $w$ of the parameterization $P^t$ for \var{tag}=$t$ to
328 provide \var{x} together with a mask indicating where the given location if on
329 a fault in the fault system by the value $1$ (otherwise the value is set to $0$).
330 \var{x} needs to be a \Vector or \numpyNDA object.
331 \var{tol} defines the tolerance to decide if given \DataSamplePoints are on
332 fault \var{tag}. The value \var{outside} is the value used as a replacement
333 value for $w$ where the corresponding value in \var{x} is not on a fault.
334 If \var{outside} is not present an appropriate value is used.
335 \end{methoddesc}
336
337 \begin{methoddesc}[FaultSystem]{getSideAndDistance}{x,tag}
338 returns the side and the distance at locations \var{x} from the fault \var{tag}.
339 \var{x} needs to be a \Vector or \numpyNDA object.
340 Positive values for side means that the corresponding location is to the right
341 of the fault, a negative value means that the corresponding location is
342 to the left of the fault. The value zero means that the side is undefined.
343 \end{methoddesc}
344
345 \begin{methoddesc}[FaultSystem]{getFaultSegments}{tag}
346 returns the polylines used to describe fault \var{tag}. For \var{tag}=$t$ this
347 is the list of the vertices $[V^{ti}]$ for the 2D and the pair of lists of the
348 top vertices $[V^{ti}]$ and the bottom vertices $[v^{ti}]$ in 3D.
349 Note that the coordinates are represented as \numpyNDA objects.
350 \end{methoddesc}
351
352 \begin{methoddesc}[FaultSystem]{addFault}{
353 strikes\optional{,
354 ls\optional{,
355 V0=[0.,0.,0.]\optional{,
356 tag=None\optional{,
357 dips=None\optional{,
358 depths= None\optional{,
359 w0_offsets=None\optional{,
360 w1_max=None}}}}}}}}
361 adds the fault \var{tag} to the fault system.
362 \var{V0} defines the start point of fault names $t=$\var{tag}. The polyline
363 defining the fault segments on the surface are set
364 by the strike angles \var{strikes} (=$\sigma^{ti}$, north = $\pi/2$, the orientation is counter clockwise.) and
365 the length \var{ls} (=$l^{ti}$). In the 3D one also needs to define the
366 dip angles \var{dips} (=$\delta^{ti}$, vertical=$0$, right-hand rule applies.) and
367 the depth \var{depths} for each segment.
368 \var{w1_max} defines the range of the $w_{1}$. If not present the mean value over the depth of
369 all segment edges in the fault is used.
370 \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
371 to explicitly specify the offsets in order to simplify the assignment of values.
372 \end{methoddesc}
373
374 \subsection{Example}
375 See section~\ref{Slip CHAP}
376
377
378
379
380
381
382

  ViewVC Help
Powered by ViewVC 1.1.26