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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3295 - (hide annotations)
Fri Oct 22 01:56:02 2010 UTC (9 years ago) by jfenwick
File MIME type: application/x-tex
File size: 14938 byte(s)


1 gross 2647 \begin{figure}
2 caltinay 3279 \includegraphics[width=\textwidth]{FaultSystem2D}
3 jfenwick 3295 \caption{\label{FAULTSYSTEM2D}Two dimensional fault system with one fault named `t` in the $(x_{0},x_{1})$ and its parameterization in the
4     $w_{0}$ space. The fault has three segments.}
5 gross 2647 \end{figure}
6    
7     \section{Fault System}
8 gross 2654 \label{Fault System}
9 jfenwick 3295 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_{0}$ and in the case of a 3D fault two parameters $w_{0}$ and $w_{1}$ are used. This parameterization can be used
10 gross 2654 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 jfenwick 3295 The strike of segment $i$ is defined by the angle $\sigma^{ti}$ between the $x_{0}$-axis and the
15 gross 2663 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 jfenwick 3295 -sin(\theta^{ti}) \cdot S^{ti}_{1} \\
38     sin(\theta^{ti}) \cdot S^{ti}_{0} \\
39 gross 2663 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 jfenwick 3295 a fault $t$ in a fault system a parameterization $P^t: (w_{0},w_{1}) \rightarrow (x_{0},x_{1},x_{2})$ over a rectangular domain is introduced such that
74 gross 2663 \begin{equation}
75 jfenwick 3295 0\le w_{0} \le w^t_{0 max} \mbox{ and } -w^t_{1max}\le w_{1} \le 0
76 gross 2647 \label{eq:fault 1}
77     \end{equation}
78 jfenwick 3295 with positive if numbers $w^t_{0 max}$ and $w^t_{1 max}$. Typically one chooses
79     $w^t_{0 max}$ to be the unrolled length of the fault
80     $w^t_{1 max}$ to be the mean value of segment depth. Moreover we have
81 gross 2647 \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 jfenwick 3295 W^{ti}=(\Omega^{ti},0) \mbox{ and } w^{ti}=(\Omega^{ti},-w^t_{1 max})
88 gross 2647 \label{eq:fault 3}
89     \end{equation}
90 jfenwick 3295 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_{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 jfenwick 3295 w_{0}=\Omega^{ti}+s \cdot (\Omega^{ti}-\Omega^{t(i-1)})
107 gross 2647 \label{eq:2D line 2}
108     \end{equation}
109 jfenwick 3295 to get $P^t(w_{0})=x$.
110 gross 2647 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.
119    
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 jfenwick 3295 w_{0}=\Omega^{ti}+s \cdot (\Omega^{ti}-\Omega^{t(i-1)})
150 gross 2663 \mbox{ and }
151 jfenwick 3295 w_{1}=w^t_{1max} (r-1)
152 gross 2663 \label{eq:2D line 5}
153     \end{equation}
154 gross 2647
155 gross 2663
156 gross 2647 \subsection{Functions}
157    
158     \begin{classdesc}{FaultSystem}{
159     \optional{dim =3}}
160     Creates a fault system in the \var{dim} dimensional space.
161     \end{classdesc}
162    
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}
174    
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}
182    
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}
187    
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}
191    
192 gross 2663
193     \begin{methoddesc}[FaultSystem]{getStrikeVectors}{tag}
194     returns the strike vectors $S^{ti}$ of fault $t=$\var{tag}
195     \end{methoddesc}
196    
197    
198     \begin{methoddesc}[FaultSystem]{getLengths}{tag}
199     returns the lengths $l^{ti}$ of segments in fault $t=$\var{tag}
200     \end{methoddesc}
201    
202    
203     \begin{methoddesc}[FaultSystem]{getTotalLength}{tag}
204     returns the total unrolled length of fault \var{tag}
205     \end{methoddesc}
206    
207     \begin{methoddesc}[FaultSystem]{getDips}{tag}
208     returns the list of the dips of the segements in fault \var{tag}.
209     \end{methoddesc}
210    
211     \begin{methoddesc}[FaultSystem]{getBottomPolyline}{tag}
212     returns the list of the vertices defining the bottom of the fault \var{tag}.
213     \end{methoddesc}
214    
215     \begin{methoddesc}[FaultSystem]{getSegmentNormals}{tag}
216     returns the list of the normals of the segments in fault \var{tag}.
217     \end{methoddesc}
218    
219     \begin{methoddesc}[FaultSystem]{getDepthVectors}{tag}
220     returns the list of the depth vectors $d^{ti}$ for fault $t=$\var{tag}.
221     \end{methoddesc}
222    
223     \begin{methoddesc}[FaultSystem]{getDepths}{tag}
224     returns the list of the depths of the segements in fault \var{tag}.
225     \end{methoddesc}
226    
227 gross 2647 \begin{methoddesc}[FaultSystem]{getW0Range}{tag}
228 jfenwick 3295 returns the range of the parameterization in $w_{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 jfenwick 3295 In most cases one has $(\Omega^{t0},\Omega^{tn})=(0,w^t_{0 max})$.
231 gross 2647 \end{methoddesc}
232    
233     \begin{methoddesc}[FaultSystem]{getW1Range}{tag}
234 jfenwick 3295 returns the range of the parameterization in $w_{1}$.
235     For tag $t$ this is the pair $(-w^t_{1max},0)$.
236 gross 2647 \end{methoddesc}
237    
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}
242    
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 3295 considering the top edge of the faults and projects the edge to the surface (the $x_{2}$ component is assumed to be 0). An \numpyNDA object is returned.
246 gross 2647 \end{methoddesc}
247    
248     \begin{methoddesc}[FaultSystem]{getOrientationOnSurface}{}
249 jfenwick 3295 returns the orientation of the fault system in RAD on the surface ($x_{2}=0$ plane) around the fault system center.
250 gross 2647 \end{methoddesc}
251     \begin{methoddesc}[FaultSystem]{transform}{\optional{rot=0, \optional{shift=numpy.zeros((3,)}}}
252 jfenwick 3295 applies a shift \var{shift} and a consecutive rotation in the $x_{2}=0$ plane.
253 gross 2647 \var{rot} is a float number and \var{shift} an \numpyNDA object.
254     \end{methoddesc}
255    
256     \begin{methoddesc}[FaultSystem]{getMaxValue}{f\optional{, tol=1.e-8}}
257 gross 2676 returns the tag of the fault of where \var{f} takes the maximum value and a \class{Locator} object which can be used to collect values from \Data objects at the location where the maximum is taken, e.g.
258     \begin{python}
259     fs=FaultSystem()
260     f=Scalar(..)
261     t, loc=fs.getMaxValue(f)
262     print `maximum value of f on the fault %s is %s at location.'%(t,loc(f),loc.getX())
263     \end{python}
264     \var{f} must be a \Scalar. When the maximum is calculated only \DataSamplePoints are considered
265 gross 2690 which are on a fault in the fault system in the sense of condition~\ref{eq:2D line 3} or \ref{eq:2D line 4d}, respectively. In the case no \DataSamplePoints is found the returned tag is \var{None} and
266 gross 2647 the maximum value as well as the location of the maximum value are undefined.
267     \end{methoddesc}
268    
269 gross 2675 \begin{methoddesc}[FaultSystem]{getMinValue}{f\optional{, tol=1.e-8}}
270 gross 2676 returns the tag of the fault of where \var{f} takes the minimum value and a \class{Locator} object which can be used to collect values from \Data objects at the location where the minimum is taken, e.g.
271     \begin{python}
272     fs=FaultSystem()
273     f=Scalar(..)
274     t, loc=fs.getMinValue(f)
275     print `minimum value of f on the fault %s is %s at location.'%(t,loc(f),loc.getX())
276     \end{python}
277     \var{f} must be a \Scalar. When the minimum is calculated only \DataSamplePoints are considered
278 gross 2690 which are on a fault in the fault system in the sense of condition~\ref{eq:2D line 3} or \ref{eq:2D line 4d}, respectively. In the case no \DataSamplePoints is found the returned tag is \var{None} and
279 gross 2676 the minimum value as well as the location of the minimum value are undefined.
280 gross 2675 \end{methoddesc}
281    
282 gross 2647 \begin{methoddesc}[FaultSystem]{getParametrization}{x,tag \optional{\optional{, tol=1.e-8}, outsider=None}}
283 gross 2654 returns the argument $w$ of the parameterization $P^t$ for \var{tag}=$t$ to provide \var{x}
284 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
285     \var{outside} is the value used as a replacement value for $w$ where the corresponding value in \var{x} is not
286     on a fault. If not \var{outside} is not present an appropriate value is used.
287     \end{methoddesc}
288 gross 2663
289 gross 2654 \begin{methoddesc}[FaultSystem]{getSideAndDistance}{x,tag}
290 jfenwick 2656 returns the side and the distance at locations \var{x} from the fault \var{tag}.
291 gross 2654 \var{x} needs to be \Vector or \numpyNDA object. Positive values for side means that the corresponding location is
292     to the right of the fault, a negative value means that the corresponding location is
293     to the left of the fault. The value zero means that the side is undefined.
294     \end{methoddesc}
295    
296 gross 2663
297    
298    
299     \begin{methoddesc}[FaultSystem]{getFaultSegments}{tag}
300     returns the polylines used to describe fault \var{tag}. For \var{tag}=$t$ this is the list of the vertices
301     $[V^{ti}]$ for the 2D and the pair of lists of the top vertices $[V^{ti}]$ and the bottom vertices $[v^{ti}]$ in 3D.
302     Note that the coordinates are represented as \numpyNDA objects.
303     \end{methoddesc}
304    
305     \begin{methoddesc}[FaultSystem]{addFault}{
306     strikes\optional{,
307     ls\optional{,
308     V0=[0.,0.,0.]\optional{,
309     tag=None\optional{,
310     dips=None\optional{,
311     depths= None\optional{,
312     w0_offsets=None\optional{,
313     w1_max=None}}}}}}}}
314     adds the fault \var{tag} to the fault system.
315     \var{V0} defines the start point of fault names $t=$\var{tag}. The polyline
316     defining the fault segments on the surface are set
317     by the strike angles \var{strikes} (=$\sigma^{ti}$, north = $\pi/2$, the orientation is counter clockwise.) and
318     the length \var{ls} (=$l^{ti}$). In the 3D one also needs to define the
319     dip angles \var{dips} (=$\delta^{ti}$, vertical=$0$, right-hand rule applies.) and
320     the depth \var{depths} for each segment.
321 jfenwick 3295 \var{w1_max} defines the range of the $w_{1}$. If not present the mean value over the depth of
322 gross 2663 all segment edges in the fault is used.
323     \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
324     to explicitly specify the offsets in order to simplify the assignment of values.
325     \end{methoddesc}
326    
327 gross 2647 \subsection{Example}
328     See section~\ref{Slip CHAP}
329    
330    
331    
332    
333    
334    
335    

  ViewVC Help
Powered by ViewVC 1.1.26