ViewVC logotype

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

Parent Directory Parent Directory | Revision Log Revision Log

Revision 2675 - (hide annotations)
Mon Sep 21 02:32:17 2009 UTC (11 years, 1 month ago) by gross
File MIME type: application/x-tex
File size: 14791 byte(s)
getMinValue added to the fault system.
1 gross 2647 \begin{figure}
2     \includegraphics[width=\textwidth]{figures/FaultSystem2D}
3 gross 2654 \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 gross 2647 $w\hackscore{0}$ space. The fault has three segments.}
5     \end{figure}
7     \section{Fault System}
8 gross 2654 \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.
11 gross 2647
12 gross 2663 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 gross 2647 \begin{equation}
18 gross 2663 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 gross 2647 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 gross 2663 W^{ti}=(\Omega^{ti},0) \mbox{ and } w^{ti}=(\Omega^{ti},-w^t\hackscore{1 max})
88 gross 2647 \label{eq:fault 3}
89     \end{equation}
90 gross 2663 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}.
91 gross 2647
92 gross 2654 In the case of 2D the parameterization $P^t$ is constructed as follows:
93 gross 2647 The line connecting $V^{t(i-1)}$ and $V^{ti}$ is given by
94     \begin{equation}
95 gross 2663 x=V^{ti} + s \cdot ( V^{t(i+1)}- V^{ti} )
96 gross 2647 \label{eq:2D line 1}
97     \end{equation}
98 gross 2654 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 gross 2647 \begin{equation}
101 gross 2663 s = \frac{ (x- V^{ti})^t \cdot (V^{t(i+1)}- V^{ti}) }{ \|V^{t(i+1)}- V^{ti}\|^2}
102 gross 2647 \label{eq:2D line 1b}
103     \end{equation}
104     We then can set
105     \begin{equation}
106 gross 2663 w\hackscore{0}=\Omega^{ti}+s \cdot (\Omega^{ti}-\Omega^{t(i-1)})
107 gross 2647 \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 gross 2654 residual of equation~\ref{eq:2D line 1}, ie. $x$ is been accepted to be in the segment if
113 gross 2647 \begin{equation}
114 gross 2663 \|x-V^{ti} - s \cdot (V^{t(i+1)}- V^{ti}) \| \le tol \cdot
115     max(l^{ti}, \|x-V^{ti} \|)
116 gross 2647 \label{eq:2D line 3}
117     \end{equation}
118     where $tol$ is a given tolerance.
120 gross 2663 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}
154 gross 2647
155 gross 2663
156 gross 2647 \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 gross 2663 \begin{methoddesc}[FaultSystem]{getMediumDepth}{tag}
164     returns the medium depth of fault \var{tag}.
165     \end{methoddesc}
166 gross 2647
167 gross 2663 \begin{methoddesc}[FaultSystem]{getTags}{}
168     returns a list of the tags used by the fault system
169     \end{methoddesc}
170 gross 2647
171 gross 2663 \begin{methoddesc}[FaultSystem]{getStart}{tag}
172     returns the starting point of fault \var{tag} as a \numpyNDA object.
173     \end{methoddesc}
175 gross 2647 \begin{methoddesc}[FaultSystem]{getDim}{}
176     returns the spatial dimension
177     \end{methoddesc}
178 gross 2663
179     \begin{methoddesc}[FaultSystem]{getDepths}{tag}
180     returns the list of the depths of the segements in fault \var{tag}.
181 gross 2647 \end{methoddesc}
183 gross 2663
184     \begin{methoddesc}[FaultSystem]{getTopPolyline}{tag}
185     returns the polyline used to describe fault tagged by \var{tag}
186 gross 2647 \end{methoddesc}
188 gross 2663 \begin{methoddesc}[FaultSystem]{getStrikes}{tag}
189     returns the list of strikes $\sigma^{ti}$ of the segements in fault $t=$\var{tag}
190 gross 2647 \end{methoddesc}
192 gross 2663
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 gross 2647 \begin{methoddesc}[FaultSystem]{getW0Range}{tag}
228     returns the range of the parameterization in $w\hackscore{0}$.
229 gross 2663 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 gross 2647 \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 gross 2654 returns the offsets for the parameterization of fault \var{tag}.
240 gross 2663 For tag \var{tag}=$t$ this is the list $[\Omega^{ti}]$.
241 gross 2647 \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 jfenwick 2651 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 gross 2647 \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 gross 2654 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 jfenwick 2656 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 gross 2647 the maximum value as well as the location of the maximum value are undefined.
260     \end{methoddesc}
262 gross 2675 \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 gross 2647 \begin{methoddesc}[FaultSystem]{getParametrization}{x,tag \optional{\optional{, tol=1.e-8}, outsider=None}}
269 gross 2654 returns the argument $w$ of the parameterization $P^t$ for \var{tag}=$t$ to provide \var{x}
270 gross 2647 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}
274 gross 2663
275 gross 2654 \begin{methoddesc}[FaultSystem]{getSideAndDistance}{x,tag}
276 jfenwick 2656 returns the side and the distance at locations \var{x} from the fault \var{tag}.
277 gross 2654 \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}
282 gross 2663
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 gross 2647 \subsection{Example}
314     See section~\ref{Slip CHAP}

  ViewVC Help
Powered by ViewVC 1.1.26