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

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

Parent Directory Parent Directory | Revision Log Revision Log


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

1 caltinay 3329
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 gross 2647 \begin{figure}
27 caltinay 3329 \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 jfenwick 3295 $w_{0}$ space. The fault has three segments.}
32 gross 2647 \end{figure}
33    
34 caltinay 3329 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 gross 2647 \begin{equation}
40 gross 2663 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 caltinay 3329 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 gross 2663 \begin{equation}
57     n^{ti} =
58     \left[
59     \begin{array}{c}
60 jfenwick 3295 -sin(\theta^{ti}) \cdot S^{ti}_{1} \\
61     sin(\theta^{ti}) \cdot S^{ti}_{0} \\
62 gross 2663 cos(\theta^{ti})
63     \end{array}
64     \right]
65     \label{eq:fault 0}
66     \end{equation}
67 caltinay 3329 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 gross 2663 \begin{equation}
73     \tilde{d}^{ti} = n^{ti} \times n^{t(i-1)}
74     \label{eq:fault b}
75     \end{equation}
76 caltinay 3329 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 gross 2663 \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 caltinay 3329 which corresponds to an angle of less than $10^o$ between the depth vector and
87     the strike. We then set
88 gross 2663 \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 caltinay 3329 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 gross 2663 \begin{equation}
101 jfenwick 3295 0\le w_{0} \le w^t_{0 max} \mbox{ and } -w^t_{1max}\le w_{1} \le 0
102 gross 2647 \label{eq:fault 1}
103     \end{equation}
104 caltinay 3329 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 gross 2647 \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 caltinay 3329 where
112 gross 2647 \begin{equation}
113 jfenwick 3295 W^{ti}=(\Omega^{ti},0) \mbox{ and } w^{ti}=(\Omega^{ti},-w^t_{1 max})
114 gross 2647 \label{eq:fault 3}
115     \end{equation}
116 caltinay 3329 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 gross 2647
120 caltinay 3329 In the 2D case the parameterization $P^t$ is constructed as follows:
121 gross 2647 The line connecting $V^{t(i-1)}$ and $V^{ti}$ is given by
122     \begin{equation}
123 gross 2663 x=V^{ti} + s \cdot ( V^{t(i+1)}- V^{ti} )
124 gross 2647 \label{eq:2D line 1}
125     \end{equation}
126 caltinay 3329 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 gross 2647 \begin{equation}
130 gross 2663 s = \frac{ (x- V^{ti})^t \cdot (V^{t(i+1)}- V^{ti}) }{ \|V^{t(i+1)}- V^{ti}\|^2}
131 gross 2647 \label{eq:2D line 1b}
132     \end{equation}
133     We then can set
134     \begin{equation}
135 jfenwick 3295 w_{0}=\Omega^{ti}+s \cdot (\Omega^{ti}-\Omega^{t(i-1)})
136 gross 2647 \label{eq:2D line 2}
137     \end{equation}
138 jfenwick 3295 to get $P^t(w_{0})=x$.
139 caltinay 3329 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 gross 2647 \begin{equation}
144 gross 2663 \|x-V^{ti} - s \cdot (V^{t(i+1)}- V^{ti}) \| \le tol \cdot
145     max(l^{ti}, \|x-V^{ti} \|)
146 gross 2647 \label{eq:2D line 3}
147     \end{equation}
148     where $tol$ is a given tolerance.
149    
150 caltinay 3329 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 gross 2663 \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 caltinay 3329 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 gross 2663 \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 caltinay 3329 and in the lower part
175 gross 2663 \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 caltinay 3329 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 gross 2663 \begin{equation}
185 jfenwick 3295 w_{0}=\Omega^{ti}+s \cdot (\Omega^{ti}-\Omega^{t(i-1)})
186 gross 2663 \mbox{ and }
187 jfenwick 3295 w_{1}=w^t_{1max} (r-1)
188 gross 2663 \label{eq:2D line 5}
189     \end{equation}
190 gross 2647
191     \subsection{Functions}
192    
193 caltinay 3329 \begin{classdesc}{FaultSystem}{\optional{dim =3}}
194     creates a fault system in the \var{dim} dimensional space.
195 gross 2647 \end{classdesc}
196    
197 gross 2663 \begin{methoddesc}[FaultSystem]{getMediumDepth}{tag}
198     returns the medium depth of fault \var{tag}.
199     \end{methoddesc}
200 gross 2647
201 gross 2663 \begin{methoddesc}[FaultSystem]{getTags}{}
202 caltinay 3329 returns a list of the tags used by the fault system.
203 gross 2663 \end{methoddesc}
204 gross 2647
205 gross 2663 \begin{methoddesc}[FaultSystem]{getStart}{tag}
206     returns the starting point of fault \var{tag} as a \numpyNDA object.
207     \end{methoddesc}
208    
209 gross 2647 \begin{methoddesc}[FaultSystem]{getDim}{}
210 caltinay 3329 returns the spatial dimension.
211 gross 2647 \end{methoddesc}
212 gross 2663
213     \begin{methoddesc}[FaultSystem]{getDepths}{tag}
214 caltinay 3329 returns the list of the depths of the segments in fault \var{tag}.
215 gross 2647 \end{methoddesc}
216    
217 gross 2663 \begin{methoddesc}[FaultSystem]{getTopPolyline}{tag}
218 caltinay 3329 returns the polyline used to describe the fault tagged by \var{tag}.
219 gross 2647 \end{methoddesc}
220    
221 gross 2663 \begin{methoddesc}[FaultSystem]{getStrikes}{tag}
222 caltinay 3329 returns the list of strikes $\sigma^{ti}$ of the segments in fault
223     $t=$\var{tag}.
224 gross 2647 \end{methoddesc}
225    
226 gross 2663 \begin{methoddesc}[FaultSystem]{getStrikeVectors}{tag}
227 caltinay 3329 returns the strike vectors $S^{ti}$ of fault $t=$\var{tag}.
228 gross 2663 \end{methoddesc}
229    
230     \begin{methoddesc}[FaultSystem]{getLengths}{tag}
231 caltinay 3329 returns the lengths $l^{ti}$ of the segments in fault $t=$\var{tag}.
232 gross 2663 \end{methoddesc}
233    
234     \begin{methoddesc}[FaultSystem]{getTotalLength}{tag}
235 caltinay 3329 returns the total unrolled length of fault \var{tag}.
236 gross 2663 \end{methoddesc}
237    
238     \begin{methoddesc}[FaultSystem]{getDips}{tag}
239 caltinay 3329 returns the list of the dips of the segments in fault \var{tag}.
240 gross 2663 \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 caltinay 3329 returns the list of the depths of the segments in fault \var{tag}.
256 gross 2663 \end{methoddesc}
257    
258 gross 2647 \begin{methoddesc}[FaultSystem]{getW0Range}{tag}
259 jfenwick 3295 returns the range of the parameterization in $w_{0}$.
260 caltinay 3329 For tag $t$ this is the pair $(\Omega^{t0},\Omega^{tn})$ where $n$ is the
261     number of segments in the fault.
262 jfenwick 3295 In most cases one has $(\Omega^{t0},\Omega^{tn})=(0,w^t_{0 max})$.
263 gross 2647 \end{methoddesc}
264    
265     \begin{methoddesc}[FaultSystem]{getW1Range}{tag}
266 jfenwick 3295 returns the range of the parameterization in $w_{1}$.
267     For tag $t$ this is the pair $(-w^t_{1max},0)$.
268 gross 2647 \end{methoddesc}
269    
270     \begin{methoddesc}[FaultSystem]{getW0Offsets}{tag}
271 gross 2654 returns the offsets for the parameterization of fault \var{tag}.
272 gross 2663 For tag \var{tag}=$t$ this is the list $[\Omega^{ti}]$.
273 gross 2647 \end{methoddesc}
274    
275     \begin{methoddesc}[FaultSystem]{getCenterOnSurface}{}
276 caltinay 3329 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 gross 2647 \end{methoddesc}
281    
282     \begin{methoddesc}[FaultSystem]{getOrientationOnSurface}{}
283 caltinay 3329 returns the orientation of the fault system in RAD on the surface
284     ($x_{2}=0$ plane) around the fault system center.
285 gross 2647 \end{methoddesc}
286 caltinay 3329
287 gross 2647 \begin{methoddesc}[FaultSystem]{transform}{\optional{rot=0, \optional{shift=numpy.zeros((3,)}}}
288 jfenwick 3295 applies a shift \var{shift} and a consecutive rotation in the $x_{2}=0$ plane.
289 gross 2647 \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 caltinay 3329 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 gross 2676 \begin{python}
297 caltinay 3329 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 gross 2676 \end{python}
302 caltinay 3329 \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 gross 2647 the maximum value as well as the location of the maximum value are undefined.
307     \end{methoddesc}
308    
309 gross 2675 \begin{methoddesc}[FaultSystem]{getMinValue}{f\optional{, tol=1.e-8}}
310 caltinay 3329 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 gross 2676 \begin{python}
314 caltinay 3329 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 gross 2676 \end{python}
319 caltinay 3329 \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 gross 2676 the minimum value as well as the location of the minimum value are undefined.
324 gross 2675 \end{methoddesc}
325    
326 gross 2647 \begin{methoddesc}[FaultSystem]{getParametrization}{x,tag \optional{\optional{, tol=1.e-8}, outsider=None}}
327 caltinay 3329 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 gross 2647 \end{methoddesc}
336 gross 2663
337 gross 2654 \begin{methoddesc}[FaultSystem]{getSideAndDistance}{x,tag}
338 jfenwick 2656 returns the side and the distance at locations \var{x} from the fault \var{tag}.
339 caltinay 3329 \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 gross 2654 to the left of the fault. The value zero means that the side is undefined.
343     \end{methoddesc}
344    
345 gross 2663 \begin{methoddesc}[FaultSystem]{getFaultSegments}{tag}
346 caltinay 3329 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 gross 2663 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 caltinay 3329 adds the fault \var{tag} to the fault system.
362 gross 2663 \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 jfenwick 3295 \var{w1_max} defines the range of the $w_{1}$. If not present the mean value over the depth of
369 gross 2663 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 gross 2647 \subsection{Example}
375     See section~\ref{Slip CHAP}
376    
377    
378    
379    
380    
381    
382    

  ViewVC Help
Powered by ViewVC 1.1.26