source: trunk/anuga_core/source/anuga/shallow_water/eqf_v2.py @ 7841

Last change on this file since 7841 was 7769, checked in by hudson, 14 years ago

Moved some file modules out of data_manager.

File size: 24.8 KB
Line 
1#
2# earthquake_tsunami function
3#
4
5"""This function returns a callable object representing an initial water
6   displacement generated by a submarine earthqauke.
7   
8Using input parameters:
9
10Required
11 length  along-stike length of rupture area
12 width   down-dip width of rupture area
13 strike  azimuth (degrees, measured from north) of fault axis
14 dip     angle of fault dip in degrees w.r.t. horizontal
15 depth   depth to base of rupture area
16 
17Optional
18 x0      x origin (0)
19 y0      y origin (0)
20 slip    metres of fault slip (1)
21 rake    angle of slip (w.r.t. horizontal) in fault plane (90 degrees)
22
23The returned object is a callable okada function that represents
24the initial water displacement generated by a submarine earthuake.
25
26"""
27
28import numpy as num
29
30
31def earthquake_tsunami(length, width, strike, depth, \
32                       dip, x0=0.0, y0=0.0, slip=1.0, rake=90.,\
33                       domain=None, verbose=False):
34    """ return a function representing a tsunami event
35    """
36
37    from math import sin, radians
38
39    if domain is not None:
40        xllcorner = domain.geo_reference.get_xllcorner()
41        yllcorner = domain.geo_reference.get_yllcorner()
42        x0 = x0 - xllcorner  # fault origin (relative)
43        y0 = y0 - yllcorner
44
45    #a few temporary print statements
46    if verbose is True:
47        print '\nThe Earthquake ...'
48        print '\tLength: ', length
49        print '\tDepth: ', depth
50        print '\tStrike: ', strike
51        print '\tWidth: ', width
52        print '\tDip: ', dip
53        print '\tSlip: ', slip
54        print '\tx0: ', x0
55        print '\ty0: ', y0
56
57    # warning state
58#    test = width*1000.0*sin(radians(dip)) - depth
59    test = width*1000.0*sin(radians(dip)) - depth*1000
60   
61    if test > 0.0:
62        msg = 'Earthquake source not located below seafloor - check depth'
63        raise Exception, msg
64
65    return Okada_func(length=length, width=width, dip=dip, \
66                      x0=x0, y0=y0, strike=strike, depth=depth, \
67                      slip=slip, rake=rake)
68
69#
70# Okada class
71#
72
73"""This is a callable class representing the initial water displacment
74   generated by an earthquake.
75
76Using input parameters:
77
78Required
79 length  along-stike length of rupture area
80 width   down-dip width of rupture area
81 strike  azimuth (degrees, measured from north) of fault axis
82 dip     angle of fault dip in degrees w.r.t. horizontal
83 depth   depth to base of rupture area
84 
85Optional
86 x0      x origin (0)
87 y0      y origin (0)
88 slip    metres of fault slip (1)
89 rake    angle of slip (w.r.t. horizontal) in fault plane (90 degrees)
90
91"""
92
93class Okada_func:
94
95    def __init__(self, length, width, dip, x0, y0, strike, \
96                 depth, slip, rake):
97        self.dip = dip
98        self.length = length
99        self.width = width
100        self.x0 = x0
101        self.y0 = y0
102        self.strike = strike
103        self.depth = depth
104        self.slip = slip
105        self.rake = rake
106
107
108    def __call__(self, x, y):
109        """Make Okada_func a callable object.
110
111        If called as a function, this object returns z values representing
112        the initial 3D distribution of water heights at the points (x,y)
113        produced by a submarine mass failure.
114        """
115
116        from math import sin, cos, radians
117        #from okada import okadatest
118
119        #ensure vectors x and y have the same length
120        N = len(x)
121        assert N == len(y)
122
123        depth = self.depth
124        dip = self.dip
125        length = self.length
126        width = self.width
127        x0 = self.x0
128        y0 = self.y0
129        strike = self.strike
130        dip = self.dip
131        rake = self.rake
132        slip = self.slip
133       
134        #double Gaussian calculation assumes water displacement is oriented
135        #E-W, so, for displacement at some angle alpha clockwise from the E-W
136        #direction, rotate (x,y) coordinates anti-clockwise by alpha
137
138        cosa = cos(radians(strike))
139        sina = sin(radians(strike))
140
141        xr = ( (x-x0) * sina + (y-y0) * cosa)
142        yr = (-(x-x0) * cosa + (y-y0) * sina)
143
144        # works on nautilus when have already done
145        # f2py -c okada.f -m okada
146        #z1 = okada(xr,yr,depth,length,width,dip,rake,slip)
147
148        z2 = num.zeros(N, num.float)
149        alp = 0.5
150        disl3 = 0.0
151        zero = 0.0
152        disl1 = slip*cos(radians(rake))
153        disl2 = slip*sin(radians(rake))
154        cd = cos(radians(dip))
155        sd = sin(radians(dip))
156
157        for i in range(N-1):
158            self.SRECTF(alp, xr[i]*.001, yr[i]*.001, depth*.001, zero, length,\
159                        zero, width, sd, cd, disl1, disl2, disl3)
160           
161            z2[i] = self.U3
162
163        return z2
164
165    def SRECTF(self,ALP,X,Y,DEP,AL1,AL2,AW1,AW2,SD,CD,DISL1,DISL2,DISL3):
166        """ SURFACE DISPLACEMENT,STRAIN,TILT DUE TO RECTANGULAR FAULT
167            IN A HALF-SPACE. CODED BY  Y.OKADA ... JAN 1985               
168             
169                                                                         
170         INPUT                                                           
171           ALP     : MEDIUM CONSTANT  MYU/(LAMDA+MYU)=1./((VP/VS)**2-1)   
172           X,Y     : COORDINATE OF STATION                               
173           DEP     : SOURCE DEPTH                                         
174           AL1,AL2 : FAULT LENGTH RANGE                                   
175           AW1,AW2 : FAULT WIDTH RANGE                                   
176           SD,CD   : SIN,COS OF DIP-ANGLE                                 
177                  (CD=0.D0, SD=+/-1.D0 SHOULD BE GIVEN FOR VERTICAL FAULT)
178           DISL1,DISL2,DISL3 : STRIKE-, DIP- AND TENSILE-DISLOCATION     
179                                                                             
180         OUTPUT                                                           
181           U1, U2, U3      : DISPLACEMENT ( UNIT= UNIT OF DISL     )     
182           U11,U12,U21,U22 : STRAIN       ( UNIT= UNIT OF DISL /         
183           U31,U32         : TILT                 UNIT OF X,Y,,,AW )     
184                                                                             
185         SUBROUTINE USED...SRECTG                                         
186        """                                                                   
187       
188        U = num.zeros(9, num.float)
189        DU = num.zeros(9, num.float)
190       
191        F0 = 0.0
192        F1 = 1.0
193                                                                   
194        P = Y*CD + DEP*SD                                                 
195        Q = Y*SD - DEP*CD
196
197        KVEC = [1,2]
198        JVEC = [1,2]
199        for K in KVEC:
200            if K == 1: ET=P-AW1
201            if K == 2: ET=P-AW2
202            for J in JVEC:
203                if J == 1: XI=X-AL1
204                if J == 2: XI=X-AL2
205                JK=J+K
206                if JK != 3:
207                    SIGN= F1
208                else:
209                    SIGN=-F1
210
211                self.SRECTG(ALP,XI,ET,Q,SD,CD,DISL1,DISL2,DISL3)
212           
213                DU[0] = self.DU1
214                DU[1] = self.DU2
215                DU[2] = self.DU3
216                DU[3] = self.DU11
217                DU[4] = self.DU12
218                DU[5] = self.DU21
219                DU[6] = self.DU22
220                DU[7] = self.DU31
221                DU[8] = self.DU32
222           
223                for i in range(len(U)):
224                    U[i]=U[i]+SIGN*DU[i]
225           
226        U1  = U[0]                                                         
227        U2  = U[1]                                                         
228        U3  = U[2]                                                         
229        U11 = U[3]                                                         
230        U12 = U[4]                                                         
231        U21 = U[5]                                                         
232        U22 = U[6]                                                         
233        U31 = U[7]                                                         
234        U32 = U[8]
235
236        self.U3 = U3
237       
238    def SRECTG(self,ALP,XI,ET,Q,SD,CD,DISL1,DISL2,DISL3):
239        """
240        C                                                                       
241        C********************************************************************* 
242        C*****                                                           ***** 
243        C*****  INDEFINITE INTEGRAL OF SURFACE DISPLACEMENT,STRAIN,TILT  ***** 
244        C*****  DUE TO RECTANGULAR FAULT IN A HALF-SPACE                 ***** 
245        C*****                          CODED BY  Y.OKADA ... JAN 1985   ***** 
246        C*****                                                           ***** 
247        C********************************************************************* 
248        C                                                                       
249        C***** INPUT                                                           
250        C*****   ALP     : MEDIUM CONSTANT  MYU/(LAMDA+MYU)=1./((VP/VS)**2-1)   
251        C*****   XI,ET,Q : FAULT COORDINATE                                     
252        C*****   SD,CD   : SIN,COS OF DIP-ANGLE                                 
253        C*****          (CD=0.D0, SD=+/-1.D0 SHOULD BE GIVEN FOR VERTICAL FAULT)
254        C*****   DISL1,DISL2,DISL3 : STRIKE-, DIP- AND TENSILE-DISLOCATION     
255        C                                                                       
256        C***** OUTPUT                                                           
257        C*****   U1, U2, U3      : DISPLACEMENT ( UNIT= UNIT OF DISL    )       
258        C*****   U11,U12,U21,U22 : STRAIN       ( UNIT= UNIT OF DISL /         
259        C*****   U31,U32         : TILT                 UNIT OF XI,ET,Q )       
260        C
261        """
262       
263        from math import sqrt, atan, log, radians
264        F0 = 0.0
265        F1 = 1.0
266        F2 = 2.0
267        PI2=6.283185307179586
268
269        XI2=XI*XI                                                         
270        ET2=ET*ET                                                         
271        Q2=Q*Q                                                           
272        R2=XI2+ET2+Q2                                                     
273        R =sqrt(R2)                                                     
274        R3=R*R2                                                           
275        D =ET*SD-Q*CD                                                     
276        Y =ET*CD+Q*SD                                                     
277        RET=R+ET
278        if RET < F0: RET=F0
279        RD =R+D                                                           
280        RRD=F1/(R*RD)                                                     
281
282        if Q != F0:
283            TT = atan( radians( XI*ET/(Q*R) ))
284        else:
285            TT = F0
286
287        if RET != F0:
288            RE = F1/RET
289            DLE= log(RET)
290        else:
291            RE = F0
292            DLE=-log(R-ET)
293                           
294        RRX=F1/(R*(R+XI))                                                 
295        RRE=RE/R                                                         
296        AXI=(F2*R+XI)*RRX*RRX/R                                           
297        AET=(F2*R+ET)*RRE*RRE/R
298
299        if CD == 0:
300            #C==============================     
301            #C=====   INCLINED FAULT   =====     
302            #C==============================
303            RD2=RD*RD
304            A1=-ALP/F2*XI*Q/RD2                                               
305            A3= ALP/F2*( ET/RD + Y*Q/RD2 - DLE )                             
306            A4=-ALP*Q/RD                                                     
307            A5=-ALP*XI*SD/RD                                                 
308            B1= ALP/F2*  Q  /RD2*(F2*XI2*RRD - F1)                           
309            B2= ALP/F2*XI*SD/RD2*(F2*Q2 *RRD - F1)                           
310            C1= ALP*XI*Q*RRD/RD                                               
311            C3= ALP*SD/RD*(XI2*RRD - F1) 
312        else:
313            #C==============================   
314            #C=====   VERTICAL FAULT   =====     
315            #C==============================
316            TD=SD/CD                                                         
317            X =sqrt(XI2+Q2)
318            if XI == F0:
319                A5=F0
320            else:                                                   
321                A5= ALP*F2/CD*atan( radians((ET*(X+Q*CD)+X*(R+X)*SD) / \
322                                    (XI*(R+X)*CD) ))   
323            A4= ALP/CD*(  log(RD) - SD*DLE )                                 
324            A3= ALP*(Y/RD/CD - DLE) + TD*A4                                   
325            A1=-ALP/CD*XI/RD        - TD*A5                                   
326            C1= ALP/CD*XI*(RRD - SD*RRE)                                     
327            C3= ALP/CD*(Q*RRE - Y*RRD)                                       
328            B1= ALP/CD*(XI2*RRD - F1)/RD - TD*C3                             
329            B2= ALP/CD*XI*Y*RRD/RD       - TD*C1
330                                       
331        A2=-ALP*DLE - A3                                                 
332        B3=-ALP*XI*RRE - B2                                               
333        B4=-ALP*( CD/R + Q*SD*RRE ) - B1                                 
334        C2= ALP*(-SD/R + Q*CD*RRE ) - C3                                 
335                                                                 
336        U1 =F0                                                           
337        U2 =F0                                                           
338        U3 =F0                                                           
339        U11=F0                                                           
340        U12=F0                                                           
341        U21=F0                                                           
342        U22=F0                                                           
343        U31=F0                                                           
344        U32=F0
345       
346        if DISL1 != F0:
347            #C======================================   
348            #C=====  STRIKE-SLIP CONTRIBUTION  ===== 
349            #C======================================
350            UN=DISL1/PI2                                                     
351            REQ=RRE*Q                                                         
352            U1 =U1 - UN*( REQ*XI +   TT    + A1*SD )                         
353            U2 =U2 - UN*( REQ*+ Q*CD*RE + A2*SD )                         
354            U3 =U3 - UN*( REQ*+ Q*SD*RE + A4*SD )                         
355            U11=U11+ UN*( XI2*Q*AET - B1*SD )                                 
356            U12=U12+ UN*( XI2*XI*( D/(ET2+Q2)/R3 - AET*SD ) - B2*SD )         
357            U21=U21+ UN*( XI*Q/R3*CD + (XI*Q2*AET - B2)*SD )                 
358            U22=U22+ UN*( Y *Q/R3*CD + (Q*SD*(Q2*AET-F2*RRE) - \
359                        (XI2+ET2)/R3*CD - B4)*SD )           
360            U31=U31+ UN*(-XI*Q2*AET*CD + (XI*Q/R3 - C1)*SD )                 
361            U32=U32+ UN*( D*Q/R3*CD + (XI2*Q*AET*CD - SD/R + Y*Q/R3 - C2)*SD )
362
363        if DISL2 != F0:
364            #C=================================== 
365            #C=====  DIP-SLIP CONTRIBUTION  =====       
366            #C===================================
367            UN=DISL2/PI2                                                     
368            SDCD=SD*CD                                                       
369            U1 =U1 - UN*( Q/R             - A3*SDCD )                         
370            U2 =U2 - UN*( Y*Q*RRX + CD*TT - A1*SDCD )                         
371            U3 =U3 - UN*( D*Q*RRX + SD*TT - A5*SDCD )                         
372            U11=U11+ UN*( XI*Q/R3            + B3*SDCD )                     
373            U12=U12+ UN*( Y *Q/R3 - SD/R     + B1*SDCD )                     
374            U21=U21+ UN*( Y *Q/R3 + Q*CD*RRE + B1*SDCD )                     
375            U22=U22+ UN*( Y*Y*Q*AXI - (F2*Y*RRX + XI*CD*RRE)*SD + B2*SDCD )   
376            U31=U31+ UN*( D *Q/R3 + Q*SD*RRE + C3*SDCD )                     
377            U32=U32+ UN*( Y*D*Q*AXI - (F2*D*RRX + XI*SD*RRE)*SD + C1*SDCD ) 
378           
379        if DISL3 != F0:
380            #C========================================
381            #C=====  TENSILE-FAULT CONTRIBUTION  =====   
382            #C========================================
383            UN=DISL3/PI2                                                     
384            SDSD=SD*SD                                                       
385            U1 =U1 + UN*( Q2*RRE                       - A3*SDSD )           
386            U2 =U2 + UN*(-D*Q*RRX - SD*(XI*Q*RRE - TT) - A1*SDSD )           
387            U3 =U3 + UN*( Y*Q*RRX + CD*(XI*Q*RRE - TT) - A5*SDSD )           
388            U11=U11- UN*( XI*Q2*AET             + B3*SDSD )                   
389            U12=U12- UN*(-D*Q/R3 - XI2*Q*AET*SD + B1*SDSD )                   
390            U21=U21- UN*( Q2*(CD/R3 + Q*AET*SD) + B1*SDSD )                   
391            U22=U22- UN*((Y*CD-D*SD)*Q2*AXI - F2*Q*SD*CD*RRX - \
392                                    (XI*Q2*AET - B2)*SDSD )                   
393            U31=U31- UN*( Q2*(SD/R3 - Q*AET*CD) + C3*SDSD )                   
394            U32=U32- UN*((Y*SD+D*CD)*Q2*AXI + XI*Q2*AET*SD*CD - \
395                                    (F2*Q*RRX - C1)*SDSD )
396
397        self.DU1 = U1
398        self.DU2 = U2
399        self.DU3 = U3
400
401        self.DU11 = U11
402        self.DU12 = U12
403
404        self.DU21 = U21
405        self.DU22 = U22
406       
407        self.DU31 = U31
408        self.DU32 = U32
409       
410    def spoint(self,alp,x,y,dep,sd,cd,pot1,pot2,pot3):
411        """ Calculate surface displacement, strain, tilt due to buried point
412        source in a semiinfinite medium. Y. Okada Jan 1985
413
414        Input:
415                                                           
416        ALP   : MEDIUM CONSTANT  MYU/(LAMDA+MYU)=1./((VP/VS)**2-1)     
417        X,Y   : COORDINATE OF STATION                                 
418        DEP     : SOURCE DEPTH                                         
419        SD,CD : SIN,COS OF DIP-ANGLE                                   
420               (CD=0.D0, SD=+/-1.D0 SHOULD BE GIVEN FOR VERTICAL FAULT)
421        POT1,POT2,POT3 : STRIKE-, DIP- AND TENSILE-POTENCY             
422            POTENCY=(  MOMENT OF DOUBLE-COUPLE  )/MYU    FOR POT1,2   
423            POTENCY=(INTENSITY OF ISOTROPIC PART)/LAMDA  FOR POT3
424           
425        Output:
426
427        U1, U2, U3      : DISPLACEMENT ( UNIT=(UNIT OF POTENCY) /     
428                        :                     (UNIT OF X,Y,D)**2  )   
429        U11,U12,U21,U22 : STRAIN       ( UNIT= UNIT OF POTENCY) /     
430        U31,U32         : TILT                (UNIT OF X,Y,D)**3  )
431        """
432
433        from math import sqrt
434
435        F0 = 0.0
436        F1 = 1.0
437        F2 = 2.0
438        F3 = 3.0
439        F4 = 4.0
440        F5 = 5.0
441        F8 = 8.0
442        F9 = 9.0
443        PI2 = 6.283185307179586
444
445        D = DEP                                                           
446        P = Y*CD + D*SD                                                   
447        Q = Y*SD - D*CD                                                   
448        S = P*SD + Q*CD                                                   
449        X2 = X*X                                                           
450        Y2 = Y*Y                                                           
451        XY = X*Y                                                           
452        D2 = D*D                                                           
453        R2= X2 + Y2 + D2                                                   
454        R = sqrt(R2)                                                       
455        R3 = R *R2
456        R5 = R3*R2
457        QR = F3*Q/R5
458        XR = F5*X2/R2
459        YR = F5*Y2/R2
460        XYR = F5*XY/R2
461        DR  = F5*D /R2
462        RD = R + D
463        R12 = F1/(R*RD*RD)
464        R32 = R12*(F2*R + D)/ R2
465        R33 = R12*(F3*R + D)/(R2*RD)
466        R53 = R12*(F8*R2 + F9*R*D + F3*D2)/(R2*R2*RD)
467        R54 = R12*(F5*R2 + F4*R*D +    D2)/R3*R12                           
468
469        A1 =  ALP*Y*(R12-X2*R33)                                           
470        A2 =  ALP*X*(R12-Y2*R33)                                           
471        A3 =  ALP*X/R3 - A2                                                 
472        A4 = -ALP*XY*R32                                                   
473        A5 =  ALP*( F1/(R*RD) - X2*R32 )                                   
474        B1 =  ALP*(-F3*XY*R33      + F3*X2*XY*R54)                         
475        B2 =  ALP*( F1/R3 - F3*R12 + F3*X2*Y2*R54)                         
476        B3 =  ALP*( F1/R3 - F3*X2/R5) - B2                                 
477        B4 = -ALP*F3*XY/R5 - B1                                             
478        C1 = -ALP*Y*(R32 - X2*R53)                                         
479        C2 = -ALP*X*(R32 - Y2*R53)                                         
480        C3 = -ALP*F3*X*D/R5 - C2                                           
481
482        U1 = F0                                                           
483        U2 = F0                                                           
484        U3 = F0                                                           
485        U11= F0                                                           
486        U12= F0                                                           
487        U21= F0                                                           
488        U22= F0                                                           
489        U31= F0                                                           
490        U32= F0
491       
492        #======================================                                 
493        #=====  STRIKE-SLIP CONTRIBUTION  =====                                 
494        #======================================                                 
495
496        if POT1 != F0:
497            UN = POT1/PI2                                                       
498            QRX = QR*X                                                         
499            FX = F3*X/R5*SD                                                     
500            U1 = U1 - UN*( QRX*X + A1*SD )                                     
501            U2 = U2 - UN*( QRX*Y + A2*SD )                                     
502            U3 = U3 - UN*( QRX*D + A4*SD )
503             
504            U11 = U11 - UN * ( QRX* (F2-XR)        + B1*SD ) 
505            U12 = U12 - UN * (-QRX*XYR      + FX*X + B2*SD )   
506            U21 = U21 - UN * ( QR*Y*(F1-XR)        + B2*SD )   
507            U22 = U22 - UN * ( QRX *(F1-YR) + FX*Y + B4*SD )   
508            U31 = U31 - UN * ( QR*D*(F1-XR)        + C1*SD ) 
509            U32 = U32 - UN * (-QRX*DR*Y     + FX*D + C2*SD ) 
510
511        #======================================           
512        #=====    DIP-SLIP CONTRIBUTION   =====         
513        #======================================         
514
515        if POT2 != F0:
516            UN = POT2/PI2                                                       
517            SDCD = SD*CD                                                       
518            QRP = QR*P                                                         
519            FS = F3*S/R5                                                       
520            U1  = U1 - UN*( QRP*X - A3*SDCD )                                   
521            U2  = U2 - UN*( QRP*Y - A1*SDCD )                                   
522            U3  = U3 - UN*( QRP*D - A5*SDCD )                                   
523            U11 = U11- UN*( QRP*(F1-XR)        - B3*SDCD )                     
524            U12 = U12- UN*(-QRP*XYR     + FS*X - B1*SDCD )                     
525            U21 = U21- UN*(-QRP*XYR            - B1*SDCD )                     
526            U22 = U22- UN*( QRP*(F1-YR) + FS*Y - B2*SDCD )                     
527            U31 = U31- UN*(-QRP*DR*X           - C3*SDCD )                     
528            U32 = U32- UN*(-QRP*DR*Y    + FS*D - C1*SDCD )
529           
530        #========================================   
531        #=====  TENSILE-FAULT CONTRIBUTION  =====   
532        #========================================                             
533
534        if POT3 != F0:
535            UN = POT3/PI2                                                       
536            SDSD = SD*SD                                                       
537            QRQ = QR*Q                                                         
538            FQ = F2*QR*SD                                                       
539            U1  = U1 + UN*( QRQ*X - A3*SDSD )                                   
540            U2  = U2 + UN*( QRQ*Y - A1*SDSD )                                   
541            U3  = U3 + UN*( QRQ*D - A5*SDSD )                                   
542            U11 = U11+ UN*( QRQ*(F1-XR)        - B3*SDSD )                     
543            U12 = U12+ UN*(-QRQ*XYR     + FQ*X - B1*SDSD )                     
544            U21 = U21+ UN*(-QRQ*XYR            - B1*SDSD )                     
545            U22 = U22+ UN*( QRQ*(F1-YR) + FQ*Y - B2*SDSD )                     
546            U31 = U31+ UN*(-QRQ*DR*X           - C3*SDSD )                     
547            U32 = U32+ UN*(-QRQ*DR*Y    + FQ*D - C1*SDSD )
548
Note: See TracBrowser for help on using the repository browser.