 # Diff of /trunk/doc/user/faultsystem.tex

revision 3295 by jfenwick, Fri Oct 22 01:56:02 2010 UTC revision 3329 by caltinay, Fri Oct 29 05:55:55 2010 UTC
# Line 1  Line 1
1  \begin{figure}
2  \includegraphics[width=\textwidth]{FaultSystem2D}  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3  \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.}  % Copyright (c) 2003-2010 by University of Queensland
5  \end{figure}  % Earth Systems Science Computational Center (ESSCC)
6    % http://www.uq.edu.au/esscc
7    %
8    % Primary Business: Queensland, Australia
11    %
12    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13
14  \section{Fault System}  \section{Fault System}
15  \label{Fault System}  \label{Fault System}
16  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  The \class{FaultSystem} class provides an easy-to-use interface to handle 2D
17  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.  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  A fault $t$ in the fault system is represented by a staring point $V^{t0}$ and series of  \begin{figure}
27  direction, called strikes~\index{strike}, and the lengths $(l^{ti})$.  \centering
28  The strike of segment $i$ is defined by the angle $\sigma^{ti}$ between the $x_{0}$-axis and the  \includegraphics{FaultSystem2D}
29  direction of the fault, see Figure~\ref{FAULTSYSTEM2D}. The length and strike defines the    \caption{\label{FAULTSYSTEM2D}Two dimensional fault system with one fault
30  polyline $(V^{ti})$ of the fault by  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}  \begin{equation}
40  V^{ti} = V^{t(i-1)} +  V^{ti} = V^{t(i-1)} +
41  l^{ti} \cdot  S^{ti}  l^{ti} \cdot  S^{ti}
# Line 28  S^{ti} = Line 50  S^{ti} =
50  \right]  \right]
51  \label{eq:fault 00}  \label{eq:fault 00}
52  \end{equation}  \end{equation}
53  In the 3D case each fault segment $i$ has an additional dip \index{dip} $\theta^{ti}$ and  In the 3D case each fault segment $i$ has an additional dip\index{dip}
54  and at each vertex $i$ a depth $\delta^{ti}$ is given. The fault segment normal $n^{ti}$ is given by  $\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}  \begin{equation}
57  n^{ti} =  n^{ti} =
58  \left[  \left[
# Line 41  n^{ti} = Line 64  n^{ti} =
64  \right]  \right]
65  \label{eq:fault 0}  \label{eq:fault 0}
66  \end{equation}  \end{equation}
67  At each vertex we define a depth vector $d^{ti}$ defined as the  At each vertex we define a depth vector $d^{ti}$ defined as the intersect of
68  intersect of the fault planes of segment $(i-1)$ and $i$ where  the fault planes of segment $(i-1)$ and $i$ where for the first segment and
69  for the first segment and last segment the vector orthogonal to strike vector $S^{ti}$\index{strike}  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 depth vector is  and the segment normal $n^{ti}$ is used. The direction $\tilde{d}^{ti}$ of the
71  given as  depth vector is given as
72  \begin{equation}  \begin{equation}
73  \tilde{d}^{ti} = n^{ti} \times n^{t(i-1)}  \tilde{d}^{ti} = n^{ti} \times n^{t(i-1)}
74  \label{eq:fault b}  \label{eq:fault b}
75  \end{equation}  \end{equation}
76  If $\tilde{d}^{ti}$ is zero the strike vectors $L^{t(i-1)}$ and $L^{ti}$ are collinear and  If $\tilde{d}^{ti}$ is zero the strike vectors $L^{t(i-1)}$ and $L^{ti}$ are
77  we can set $\tilde{d}^{ti} = l^{ti} \times n^{ti}$. If the two fault segments are almost  collinear and we can set $\tilde{d}^{ti} = l^{ti} \times n^{ti}$.
78  orthogonal $\tilde{d}^{ti}$ is pointing in the direction of $L^{t(i-1)}$ and $L^{ti}$. In this case no  If the two fault segments are almost orthogonal $\tilde{d}^{ti}$ is pointing
79  depth can be defined. So we will reject a fault system if  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}  \begin{equation}
82  min(\| \tilde{d}^{ti}  \times  L^{t(i-1)} \|,\| \tilde{d}^{ti}  \times  L^{ti} \|)  min(\| \tilde{d}^{ti}  \times  L^{t(i-1)} \|,\| \tilde{d}^{ti}  \times  L^{ti} \|)
83  \le 0.1 \cdot \| \tilde{d}^{ti} |  \le 0.1 \cdot \| \tilde{d}^{ti} |
84  \label{eq:fault c}  \label{eq:fault c}
85  \end{equation}  \end{equation}
86  which corresponds to an angle of less then $10^o$ between the depth vector and the strike. We then set  which corresponds to an angle of less than $10^o$ between the depth vector and
87    the strike. We then set
88  \begin{equation}  \begin{equation}
89  d^{ti}=\delta^{ti} \cdot \frac{\tilde{d}^{ti}}{\|\tilde{d}^{ti}\|}  d^{ti}=\delta^{ti} \cdot \frac{\tilde{d}^{ti}}{\|\tilde{d}^{ti}\|}
90  \label{eq:fault d}  \label{eq:fault d}
# Line 69  We can then define the polyline $(v^{ti} Line 94 We can then define the polyline$(v^{ti}
94  v^{ti}= V^{ti}+d^{ti}  v^{ti}= V^{ti}+d^{ti}
95  \label{eq:fault e}  \label{eq:fault e}
96  \end{equation}  \end{equation}
97  In order to simplify working on  In order to simplify working on a fault $t$ in a fault system a
98  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  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}  \begin{equation}
101  0\le w_{0} \le w^t_{0 max} \mbox{ and }  -w^t_{1max}\le w_{1} \le 0  0\le w_{0} \le w^t_{0 max} \mbox{ and }  -w^t_{1max}\le w_{1} \le 0
102  \label{eq:fault 1}  \label{eq:fault 1}
103  \end{equation}  \end{equation}
104  with positive if numbers $w^t_{0 max}$ and $w^t_{1 max}$. Typically one chooses  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  $w^t_{0 max}$ to be the unrolled length of the fault and $w^t_{1 max}$ to be
106  $w^t_{1 max}$ to be the mean value of segment depth. Moreover we have  the mean value of segment depth. Moreover we have
107  \begin{equation}  \begin{equation}
108  P^t(W^{ti})=V^{ti}\mbox{ and } P^t(w^{ti})=v^{ti}\  P^t(W^{ti})=V^{ti}\mbox{ and } P^t(w^{ti})=v^{ti}\
109  \label{eq:fault 2}  \label{eq:fault 2}
110  \end{equation}  \end{equation}
111  where  where
112  \begin{equation}  \begin{equation}
113  W^{ti}=(\Omega^{ti},0) \mbox{ and } w^{ti}=(\Omega^{ti},-w^t_{1 max})  W^{ti}=(\Omega^{ti},0) \mbox{ and } w^{ti}=(\Omega^{ti},-w^t_{1 max})
114  \label{eq:fault 3}  \label{eq:fault 3}
115  \end{equation}  \end{equation}
116  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}.  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 case of 2D the parameterization $P^t$ is constructed as follows:  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  The line connecting $V^{t(i-1)}$ and $V^{ti}$ is given by
122  \begin{equation}  \begin{equation}
123  x=V^{ti} + s  \cdot  ( V^{t(i+1)}- V^{ti} )  x=V^{ti} + s  \cdot  ( V^{t(i+1)}- V^{ti} )
124  \label{eq:2D line 1}  \label{eq:2D line 1}
125  \end{equation}  \end{equation}
126  where $s$ is between $0$ and $1$. The point $x$ is on $i$-th fault segment if and only if  where $s$ is between $0$ and $1$. The point $x$ is on $i$-th fault segment if
127  such an $s$ exists. If assume $x$ is on the fault one can calculate $s$ as  and only if such an $s$ exists. Assuming $x$ is on the fault it can be
128    calculated as
129  \begin{equation}  \begin{equation}
130  s = \frac{ (x- V^{ti})^t \cdot (V^{t(i+1)}- V^{ti}) }{ \|V^{t(i+1)}- V^{ti}\|^2}  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}  \label{eq:2D line 1b}
# Line 107  w_{0}=\Omega^{ti}+s \cdot (\Omega^{ti}-\ Line 136  w_{0}=\Omega^{ti}+s \cdot (\Omega^{ti}-\
136  \label{eq:2D line 2}  \label{eq:2D line 2}
137  \end{equation}  \end{equation}
138  to get $P^t(w_{0})=x$.  to get $P^t(w_{0})=x$.
139  It remains the question if the given $x$ is actual on the segment $i$ of fault $t$. To test this $s$ is restricted  It remains the question if the given $x$ is actually on the segment $i$ of
140  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  fault $t$. To test this $s$ is restricted between $0$ and $1$ (so if $s<0$, $s$
141  residual of equation~\ref{eq:2D line 1}, ie. $x$ is been accepted to be in the segment if  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}  \begin{equation}
144  \|x-V^{ti} - s \cdot (V^{t(i+1)}- V^{ti}) \| \le tol \cdot    \|x-V^{ti} - s \cdot (V^{t(i+1)}- V^{ti}) \| \le tol \cdot
145  max(l^{ti}, \|x-V^{ti} \|)  max(l^{ti}, \|x-V^{ti} \|)
# Line 117  max(l^{ti}, \|x-V^{ti} \|) Line 147  max(l^{ti}, \|x-V^{ti} \|)
147  \end{equation}  \end{equation}
148  where $tol$ is a given tolerance.  where $tol$ is a given tolerance.
149
150  In the 3D case the situation is a bit more complicated: we split the fault segment across  In the 3D case the situation is a bit more complicated: we split the fault
151  the diagonal $V^{ti}$-$v^{t(i+1)}$ to produce two triangles. In the upper triangle we use the  segment across the diagonal $V^{ti}$-$v^{t(i+1)}$ to produce two triangles.
152  parameterization  In the upper triangle we use the parameterization
153  \begin{equation}  \begin{equation}
154  x= V^{ti} + s \cdot (V^{t(i+1)}-V^{ti})  + r \cdot (v^{t(i+1)}-V^{t(i+1)})  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;  \mbox{ with } r \le s;
# Line 131  x= V^{ti} +  s \cdot (v^{t(i+1)}-v^{ti}) Line 161  x= V^{ti} +  s \cdot (v^{t(i+1)}-v^{ti})
161  \mbox{ with } s \le r;  \mbox{ with } s \le r;
162  \label{eq:2D line 4b}  \label{eq:2D line 4b}
163  \end{equation}  \end{equation}
164  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  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}  \begin{equation}
170  \|x- V^{ti} - s \cdot (V^{t(i+1)}-V^{ti})  - r \cdot (v^{t(i+1)}-V^{t(i+1)}) \|  \|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)})\|)  \le tol \cdot  max(\|x-V^{ti} \|,\|v^{t(i+1)}-V^{t(i)})\|)
172  \label{eq:2D line 4c}  \label{eq:2D line 4c}
173  \end{equation}  \end{equation}
174  and in the lower part  and in the lower part
175  \begin{equation}  \begin{equation}
176  \|x-V^{ti} -  s \cdot (v^{t(i+1)}-v^{ti}) - r \cdot (v^{ti}-V^{ti}) \|  \|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)})\|)    \le tol \cdot  max(\|x-V^{ti} \|,\|v^{t(i+1)}-V^{t(i)})\|)
178  \label{eq:2D line 4d}  \label{eq:2D line 4d}
179  \end{equation}  \end{equation}
180  after the restriction of $(s,t)$ to the unit square. Note that $\|v^{t(i+1)}-V^{t(i)})\|$ is length of the  after the restriction of $(s,t)$ to the unit square.
181  diagonal of the fault segment. For those $x$ which have been located in the $i$-th segment  we then set  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}  \begin{equation}
185  w_{0}=\Omega^{ti}+s \cdot (\Omega^{ti}-\Omega^{t(i-1)})  w_{0}=\Omega^{ti}+s \cdot (\Omega^{ti}-\Omega^{t(i-1)})
186  \mbox{ and }  \mbox{ and }
# Line 152  w_{1}=w^t_{1max} (r-1) Line 188  w_{1}=w^t_{1max} (r-1)
188  \label{eq:2D line 5}  \label{eq:2D line 5}
189  \end{equation}  \end{equation}
190

191  \subsection{Functions}  \subsection{Functions}
192
193  \begin{classdesc}{FaultSystem}{  \begin{classdesc}{FaultSystem}{\optional{dim =3}}
194  \optional{dim =3}}  creates a fault system in the \var{dim} dimensional space.
Creates a fault system in the \var{dim} dimensional space.
195  \end{classdesc}  \end{classdesc}
196
197  \begin{methoddesc}[FaultSystem]{getMediumDepth}{tag}  \begin{methoddesc}[FaultSystem]{getMediumDepth}{tag}
# Line 165  returns the medium depth of fault \var{t Line 199  returns the medium depth of fault \var{t
199  \end{methoddesc}  \end{methoddesc}
200
201  \begin{methoddesc}[FaultSystem]{getTags}{}  \begin{methoddesc}[FaultSystem]{getTags}{}
202  returns a list of the tags used by the fault system  returns a list of the tags used by the fault system.
203  \end{methoddesc}  \end{methoddesc}
204
205  \begin{methoddesc}[FaultSystem]{getStart}{tag}  \begin{methoddesc}[FaultSystem]{getStart}{tag}
# Line 173  returns the starting point of fault \var Line 207  returns the starting point of fault \var
207  \end{methoddesc}  \end{methoddesc}
208
209  \begin{methoddesc}[FaultSystem]{getDim}{}  \begin{methoddesc}[FaultSystem]{getDim}{}
210  returns the spatial dimension  returns the spatial dimension.
211  \end{methoddesc}  \end{methoddesc}
212
213  \begin{methoddesc}[FaultSystem]{getDepths}{tag}  \begin{methoddesc}[FaultSystem]{getDepths}{tag}
214  returns the list of the depths of the segements in fault \var{tag}.  returns the list of the depths of the segments in fault \var{tag}.
215  \end{methoddesc}  \end{methoddesc}
216

217  \begin{methoddesc}[FaultSystem]{getTopPolyline}{tag}  \begin{methoddesc}[FaultSystem]{getTopPolyline}{tag}
218  returns the polyline used to describe fault tagged by \var{tag}  returns the polyline used to describe the fault tagged by \var{tag}.
219  \end{methoddesc}  \end{methoddesc}
220
221  \begin{methoddesc}[FaultSystem]{getStrikes}{tag}  \begin{methoddesc}[FaultSystem]{getStrikes}{tag}
222  returns the list of strikes $\sigma^{ti}$ of the segements in fault $t=$\var{tag}  returns the list of strikes $\sigma^{ti}$ of the segments in fault
223    $t=$\var{tag}.
224  \end{methoddesc}  \end{methoddesc}
225

226  \begin{methoddesc}[FaultSystem]{getStrikeVectors}{tag}  \begin{methoddesc}[FaultSystem]{getStrikeVectors}{tag}
227  returns the strike vectors $S^{ti}$ of fault $t=$\var{tag}  returns the strike vectors $S^{ti}$ of fault $t=$\var{tag}.
228  \end{methoddesc}  \end{methoddesc}
229

230  \begin{methoddesc}[FaultSystem]{getLengths}{tag}  \begin{methoddesc}[FaultSystem]{getLengths}{tag}
231  returns the lengths $l^{ti}$ of segments in fault $t=$\var{tag}  returns the lengths $l^{ti}$ of the segments in fault $t=$\var{tag}.
232  \end{methoddesc}  \end{methoddesc}
233

234  \begin{methoddesc}[FaultSystem]{getTotalLength}{tag}  \begin{methoddesc}[FaultSystem]{getTotalLength}{tag}
235  returns the total unrolled length of fault \var{tag}  returns the total unrolled length of fault \var{tag}.
236  \end{methoddesc}  \end{methoddesc}
237
238  \begin{methoddesc}[FaultSystem]{getDips}{tag}  \begin{methoddesc}[FaultSystem]{getDips}{tag}
239  returns the list of the dips of the segements in fault \var{tag}.  returns the list of the dips of the segments in fault \var{tag}.
240  \end{methoddesc}  \end{methoddesc}
241
242  \begin{methoddesc}[FaultSystem]{getBottomPolyline}{tag}  \begin{methoddesc}[FaultSystem]{getBottomPolyline}{tag}
# Line 221  returns the list of the depth vectors $d Line 252 returns the list of the depth vectors$d
252  \end{methoddesc}  \end{methoddesc}
253
254  \begin{methoddesc}[FaultSystem]{getDepths}{tag}  \begin{methoddesc}[FaultSystem]{getDepths}{tag}
255  returns the list of the depths of the segements in fault \var{tag}.  returns the list of the depths of the segments in fault \var{tag}.
256  \end{methoddesc}  \end{methoddesc}
257
258  \begin{methoddesc}[FaultSystem]{getW0Range}{tag}  \begin{methoddesc}[FaultSystem]{getW0Range}{tag}
259  returns the range of the parameterization in $w_{0}$.  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 number of segments in the fault.  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})$.  In most cases one has $(\Omega^{t0},\Omega^{tn})=(0,w^t_{0 max})$.
263  \end{methoddesc}  \end{methoddesc}
264
# Line 241  For tag \var{tag}=$t$ this is the list $Line 273 For tag \var{tag}=$t$this is the list$
273  \end{methoddesc}  \end{methoddesc}
274
275  \begin{methoddesc}[FaultSystem]{getCenterOnSurface}{}  \begin{methoddesc}[FaultSystem]{getCenterOnSurface}{}
276  returns the center point of the fault system at the surfaces. In 3D the calculation of the center is  returns the center point of the fault system at the surfaces.
277  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.  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}  \end{methoddesc}
281
282  \begin{methoddesc}[FaultSystem]{getOrientationOnSurface}{}  \begin{methoddesc}[FaultSystem]{getOrientationOnSurface}{}
283  returns the orientation of the fault system in RAD on the surface ($x_{2}=0$ plane) around the fault system center.  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}  \end{methoddesc}
286
287  \begin{methoddesc}[FaultSystem]{transform}{\optional{rot=0, \optional{shift=numpy.zeros((3,)}}}  \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.  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.  \var{rot} is a float number and \var{shift} an \numpyNDA object.
290  \end{methoddesc}  \end{methoddesc}
291
292  \begin{methoddesc}[FaultSystem]{getMaxValue}{f\optional{, tol=1.e-8}}  \begin{methoddesc}[FaultSystem]{getMaxValue}{f\optional{, tol=1.e-8}}
293  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.  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}  \begin{python}
297  fs=FaultSystem()    fs=FaultSystem()
298  f=Scalar(..)    f=Scalar(..)
299  t, loc=fs.getMaxValue(f)    t, loc=fs.getMaxValue(f)
300  print maximum value of f on the fault %s is %s at location.'%(t,loc(f),loc.getX())    print "maximum value of f on the fault %s is %s at location."%(t,loc(f),loc.getX())
301  \end{python}  \end{python}
302  \var{f} must be a \Scalar. When the maximum is calculated only \DataSamplePoints are considered  \var{f} must be a \Scalar. When the maximum is calculated only
303  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  \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.  the maximum value as well as the location of the maximum value are undefined.
307  \end{methoddesc}  \end{methoddesc}
308
309  \begin{methoddesc}[FaultSystem]{getMinValue}{f\optional{, tol=1.e-8}}  \begin{methoddesc}[FaultSystem]{getMinValue}{f\optional{, tol=1.e-8}}
310  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.  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}  \begin{python}
314  fs=FaultSystem()    fs=FaultSystem()
315  f=Scalar(..)    f=Scalar(..)
316  t, loc=fs.getMinValue(f)    t, loc=fs.getMinValue(f)
317  print minimum value of f on the fault %s is %s at location.'%(t,loc(f),loc.getX())    print "minimum value of f on the fault %s is %s at location."%(t,loc(f),loc.getX())
318  \end{python}  \end{python}
319  \var{f} must be a \Scalar. When the minimum is calculated only \DataSamplePoints are considered  \var{f} must be a \Scalar. When the minimum is calculated only
320  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  \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.  the minimum value as well as the location of the minimum value are undefined.
324  \end{methoddesc}  \end{methoddesc}
325
326  \begin{methoddesc}[FaultSystem]{getParametrization}{x,tag \optional{\optional{, tol=1.e-8}, outsider=None}}  \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 provide \var{x}  returns the argument $w$ of the parameterization $P^t$ for \var{tag}=$t$ to
328  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  provide \var{x} together with a mask indicating where the given location if on
329  \var{outside} is the value used as a replacement value for $w$ where the corresponding value in \var{x} is not  a fault in the fault system by the value $1$ (otherwise the value is set to $0$).
330  on a fault. If not \var{outside} is not present an appropriate value is used.  \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}  \end{methoddesc}
336
337  \begin{methoddesc}[FaultSystem]{getSideAndDistance}{x,tag}  \begin{methoddesc}[FaultSystem]{getSideAndDistance}{x,tag}
338  returns the side and the distance at locations \var{x} from the fault \var{tag}.  returns the side and the distance at locations \var{x} from the fault \var{tag}.
339  \var{x} needs to be \Vector or \numpyNDA object. Positive values for side means that the corresponding location is  \var{x} needs to be a \Vector or \numpyNDA object.
340  to the right of the fault, a negative value means that the corresponding location is  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.  to the left of the fault. The value zero means that the side is undefined.
343  \end{methoddesc}  \end{methoddesc}
344

345  \begin{methoddesc}[FaultSystem]{getFaultSegments}{tag}  \begin{methoddesc}[FaultSystem]{getFaultSegments}{tag}
346  returns the polylines used to describe fault \var{tag}. For \var{tag}=$t$ this is the list of the vertices  returns the polylines used to describe fault \var{tag}. For \var{tag}=$t$ this
347  $[V^{ti}]$ for the 2D and the pair of lists of the top vertices $[V^{ti}]$ and the bottom vertices  $[v^{ti}]$ in 3D.  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.  Note that the coordinates are represented as \numpyNDA objects.
350  \end{methoddesc}  \end{methoddesc}
351
# Line 311  dips=None\optional{, Line 358  dips=None\optional{,
358  depths= None\optional{,  depths= None\optional{,
359  w0_offsets=None\optional{,  w0_offsets=None\optional{,
360  w1_max=None}}}}}}}}  w1_max=None}}}}}}}}
361  adds the  fault \var{tag} to the fault system.  adds the fault \var{tag} to the fault system.
362  \var{V0} defines the start point of fault names $t=$\var{tag}. The polyline  \var{V0} defines the start point of fault names $t=$\var{tag}. The polyline
363  defining the fault segments on the surface are set  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  by the strike angles \var{strikes} (=$\sigma^{ti}$, north = $\pi/2$, the orientation is counter clockwise.) and

Legend:
 Removed from v.3295 changed lines Added in v.3329