C Last change: DAS 4 Feb 2000 Loop over parameters c c This program evaluates the dimensionless displacement at the middle of c the free edge of an SSSF Mindlin plate. For questions contact c Don Simons at dsimons@logicon.com. The analysis is explained in c Mindlin2.pdf which should be available near where you got this c code. c c Input parameters go into a free-form ascii file named mindpar.inp c gnu1 = First value of Poisson's ratio c dgnu = Increment in Poisson's ratio c ngnu = Number of Poisson's ratios c beta1 = First value of b/a. a=length of free edge c dbeta = Increment in beta c nbeta = Number of betas c epsq1 = epsilon squared (see below for definition) c depsq = increment in epsq c nepsq = number of epsq's c itolr1 = initial tolerance (number of stable decimal places in c the sum for dimensionless displacement). c ntolr = number of tolerances c nmin = minimum number of terms to keep in the sum c nmax = maximum number of terms to keep c c epsq is defined as (h^2)/[6(a^2)(k^2)(1-gnu)] where c h = thickness c k = shear constant = 5/6 for solid section c gnu = Poisson's ratio c c Physical displacement can be computed offline from c wphys = 12(1-gnu^2)p(a^4)w/(Eh^3) c !============================================================================== PROGRAM CALL_MINDLIN ! 2 February 2000 IMPLICIT REAL*8 (A-H, O-Z), INTEGER*4 (I-N) c REAL (KIND=8), DIMENSION(:,:), ALLOCATABLE :: WW c REAL (KIND=8), DIMENSION(:) , ALLOCATABLE :: XV, YV real*8 ww(100,100) !------------------------------------------------------------------------------ ! TYPICAL PARAMETERS ARE ... ! ! GNU = 0.3 ! BETA = 0.25 ! EPSQ = 0.1 ! TOLR = 0.00001 !------------------------------------------------------------------------------ OPEN (UNIT=1,FILE='mindpar.inp',STATUS='OLD') read(1,*) gnu1,dgnu,ngnu,beta1,dbeta,nbeta,epsq1,depsq,nepsq read(1,*) itolr1,ntolr read(1,*) nmin,nmax CLOSE (1) !------------------------------------------------------------------------------ open(10,file='mindpar.out') write( *,'(1x,a6,4a12,a13)')'gnu','beta','epsq','tolr','nret','ww' do 10 ignu = 1 , ngnu gnu = gnu1+(ignu-1)*dgnu do 10 ibeta = 1 , nbeta beta = beta1+(ibeta-1)*dbeta do 10 iepsq = 1 , nepsq epsq = epsq1+(iepsq-1)*depsq do 10 itolr = itolr1 , itolr1+ntolr-1 tolr = 10.**(-itolr) CALL MINDLIN(WW,1,1,GNU,BETA,EPSQ,TOLR,NMIN,NMAX,NRET) write(10,'(1p4e12.4,i5,e20.12)')gnu,beta,epsq,tolr,nret,ww(1,1) write( *,'(1p4e12.4,i5,e20.12)')gnu,beta,epsq,tolr,nret,ww(1,1) 10 continue !------------------------------------------------------------------------------ STOP 'OK' END PROGRAM !============================================================================== SUBROUTINE MINDLIN(W,NX,NY,GNU,BETA,EPSQ,TOLR,NMIN,NMAX,NRET) IMPLICIT REAL*8 (A-H, O-Z), INTEGER*4 (I-N) ! 2 February 2000 real*8 w(100,100) LOGICAL FINISH !------------------------------------------------------------------------------ ! Computes W(x,y), according to Don Simon's MINDLIN protocol ! ! Inputs are ... ! ! NX = Number of x values desired If NX = 1, then x = 0 ! NY = Number of y values desired If NY = 1, then y = Beta ! ! We will compute for NX values of x for 0 .LE. x .LE. 0.5 ! and NY values of y for 0 .LE. y .LE. Beta ! ! GNU, BETA, EPSQ are input parameters (Typically: 0.3, 0.25, 0.1) ! ! TOLR = Tolerance desired in computing W(x,y) (Typically 10^-5) ! NMIN = Minimum number of n's desired ! NMAX = Maximum number of n's desired ! ! Outputs are ... ! ! W(x,y) = The displacements as function of x & y ! NRET = Actual number of n's used in computing W(x,y) ! ! If (TOLR .LE. 0.0), We will use NMAX values of n's (Return NRET=NMAX) ! If (TOLR .GT. 0.0), We will use as many n's as desired to achieve ! the stated tolerance up to NMAX (Will return NRET) !------------------------------------------------------------------------------ real*8 VBDPOS(100), VBDNEG(100), VACPOS(100), VACNEG(100), & VALPHA(100) DO n=1,NMAX CALL FCTN(VBDPOS(n),VBDNEG(n),VACPOS(n),VACNEG(n),VALPHA(n),n, & GNU,BETA,EPSQ,TOLR,FINISH) NRET = n IF (FINISH . AND. (n .GE. NMIN) ) EXIT END DO IF (NX .GT. 1) DX = 0.5 / DBLE(NX-1) IF (NY .GT. 1) DY = BETA / DBLE(NY-1) DO i=1,NX IF (NX .GT. 1) THEN X = DBLE(i-1) * DX ELSE X = 0.0 END IF QX = 5.0 / 384.0 + EPSQ / 8.0 & - (1.0 / 16.0 + EPSQ / 2.0) * X**2 + X**4 / 24.0 W(i,:) = QX DO j=1,NY IF (NY .GT. 1) THEN Y = DBLE(j-1) * DY ELSE Y = BETA END IF DO n=1,NRET ALF = VALPHA(n) EXB = EXP(-ALF*(BETA-Y)) EXY = EXP(-ALF*Y) WN = VBDPOS(n) * Y * EXB + VACPOS(n) * EXB & + VBDNEG(n) * Y * EXY + VACNEG(n) * EXY W(i,j) = W(i,j) + WN * COS(ALF*X) END DO END DO END DO RETURN END !============================================================================== SUBROUTINE FCTN(BDPOS,BDNEG,ACPOS,ACNEG,ALPHA,N, & GNU,BETA,EPSQ,TOLR,FINISH) IMPLICIT REAL*8 (A-H, O-Z), INTEGER*4 (I-N) LOGICAL FINISH !------------------------------------------------------------------------------ ! Calculate the 4 coefficients BDPOS = (b+d)/2 BDNEG = (b-d)/2 ! ACPOS = (a+c)/2 ACNEG = (a-c)/2 ! ! for N and for the constants GNU, BETA, EPSQ ! ! We also return ALPHA because the terms BDPOS & ACPOS are returned ! with a missing Sqrt(F) at the end. We will tack it on later when ! we evaluate W(y). Thus EXP(-ALPHA*(BETA-y)) ! ! Determine whether this value of "n" is enough to achieve the ! tolerance TOLR. If so, then return FINISH = .True. !------------------------------------------------------------------------------ ONE = 1.0D0 TWO = 2.0D0 THREE = 3.0D0 FOUR = 4.0D0 FIVE = 5.0D0 EIGHT = TWO * FOUR GNU1 = GNU - ONE GNUP3 = GNU + THREE GNU5 = GNU - FIVE PI = FOUR * ATAN(ONE) ALPHA = (2*N-1) * PI ATILD = SQRT(ALPHA**2 - TWO / GNU1 / EPSQ) FSQRT = EXP(- ALPHA*BETA) FTILD = EXP(-TWO*ATILD*BETA) F = FSQRT * FSQRT F32 = FSQRT * F ALPHA2 = ALPHA**2 ALPHA3 = ALPHA**3 ALPHA4 = ALPHA**4 ALPHA5 = ALPHA**5 BETA2 = BETA**2 EPS4 = EPSQ**2 CC1 = FOUR * ALPHA * EPSQ * GNU1 CC2 = TWO * (GNU+THREE) H1 = CC1 * (ALPHA - ATILD) - CC2 H2 = CC1 * (ALPHA + ATILD) - CC2 H3 = - CC1 * ALPHA + CC2 H4 = CC1 * ATILD H5 = EPSQ * ATILD DELTA = H1 + H2 * FTILD + EIGHT * F * ALPHA * GNU1 * * ((BETA-H5) + FTILD * (BETA+H5)) * + F*F * ((H3-H4) + FTILD * (H3+H4)) AMP1 = - FOUR * (-1)**N / (ALPHA4 * DELTA) AMP2 = TWO * (-1)**N / (ALPHA5 * DELTA * GNU1) F1 = - TWO * GNU * (ONE+FTILD) F2 = (THREE + TWO * ALPHA2 * EPSQ) * GNU1 F3 = - TWO * ALPHA * BETA * GNU1 F4 = TWO * ALPHA * ATILD * EPSQ * GNU1 F5 = - TWO * ALPHA * ALPHA * EPSQ * GNU1 + GNUP3 F6 = F4 G1 = FOUR * GNU * (ALPHA * BETA * GNU1 - GNU - ONE) G2 = FOUR * GNU * (ALPHA * BETA * GNU1 + GNU + ONE) G3 = THREE + ALPHA2 * EPSQ * GNU5 * GNU1 + GNU**2 G4 = ALPHA2 * BETA2 + TWO * ALPHA4 * EPS4 * - TWO * ALPHA2 * BETA * ATILD * EPSQ G5 = TWO * ALPHA * BETA + TWO * ALPHA3 * BETA * EPSQ * - TWO * ALPHA * EPSQ * ATILD * - TWO * ALPHA3 * EPS4 * ATILD G6 = THREE + ALPHA2 * (EPSQ * GNU5 + BETA2 * GNU1) * GNU1 * + TWO * ALPHA4 * EPS4 * GNU1**2 + GNU**2 * + TWO * ALPHA2 * BETA * EPSQ * GNU1**2 * ATILD G7 = TWO * ALPHA * (ONE + ALPHA2 * EPSQ) * * GNU1**2 * (BETA + EPSQ * ATILD) G8 = - GNUP3 + TWO * EPSQ * GNU1 * ALPHA * (ALPHA + ATILD) G9 = - GNUP3 + TWO * EPSQ * GNU1 * ALPHA * (ALPHA - ATILD) A0 = F1 A1 = F2 - F3 - F4 + (F2 - F3 + F4) * FTILD A2 = F1 A3 = F5 - F6 + (F5 + F6) * FTILD B0 = F5 + F6 + (F5 - F6) * FTILD B1 = F1 B2 = F2 + F3 + F4 + (F2 + F3 - F4) * FTILD B3 = F1 C0 = - G2 * (ONE + FTILD) C1 = FOUR * (G3 + (G4 + G5) * GNU1**2 + (G6 + G7) * FTILD) C2 = G1 * (ONE + FTILD) C3 = - FOUR * (ONE + ALPHA2 * EPSQ) * GNU1 * (G8 + G9 * FTILD) D0 = FOUR * (ONE + ALPHA2 * EPSQ) * GNU1 * (G9 + G8 * FTILD) D1 = G2 * (ONE + FTILD) D2 = - FOUR * (G3 + (G4 - G5) * GNU1**2 + (G6 - G7) * FTILD) D3 = - G1 * (ONE + FTILD) BDPOS = AMP1 * (A0 + A1 * FSQRT + A2 * F + A3 * F32) ! * FSQRT BDNEG = AMP1 * (B0 + B1 * FSQRT + B2 * F + B3 * F32) ACPOS = AMP2 * (C0 + C1 * FSQRT + C2 * F + C3 * F32) ! * FSQRT ACNEG = AMP2 * (D0 + D1 * FSQRT + D2 * F + D3 * F32) ! Test to see whether Tolerance is achieved TERM1 = ABS(BDPOS * BETA) TERM2 = ABS(BDNEG / ALPHA * EXP(-ONE)) TERM3 = ABS(ACPOS) TERM4 = ABS(ACNEG) FINISH = (TERM1 .LT. TOLR) .AND. (TERM2 .LT. TOLR) .AND. & (TERM3 .LT. TOLR) .AND. (TERM4 .LT. TOLR) RETURN END SUBROUTINE !==============================================================================