MAKE_STRESS_TENSOR_DAMPED.f90 File Reference

Go to the source code of this file.

Functions/Subroutines
subroutine	make_stress_tensor_damped (nn, lambda, mu, duxdx, duydx, duzdx, duxdy, duydy, duzdy, duxdz, duydz, duzdz, strain_visc_xx, strain_visc_xy, strain_vi
	Computes the stress tensor.

Function/Subroutine Documentation

make_stress_tensor_damped()

subroutine make_stress_tensor_damped	(	integer*4	nn,
		real*8, dimension(nn,nn,nn)	lambda,
		real*8, dimension(nn,nn,nn)	mu,
		real*8, dimension(nn,nn,nn)	duxdx,
		real*8, dimension(nn,nn,nn)	duydx,
			duzdx,
		real*8, dimension(nn,nn,nn)	duxdy,
		real*8, dimension(nn,nn,nn)	duydy,
			duzdy,
		real*8, dimension(nn,nn,nn)	duxdz,
		real*8, dimension(nn,nn,nn)	duydz,
			duzdz,
		real*8, dimension(nn,nn,nn,n_sls)	strain_visc_xx,
			strain_visc_xy,
			strain_vi
	)

Computes the stress tensor.

Author

Ilario Mazzieri

Date

November, 2014

Version

1.0

Parameters

[in]	nn	number of 1-D Legendre nodes
[in]	lambda	nodal values of Lame coefficient lambda
[in]	mu	nodal values of Lame coefficient mu
[in]	duxdx	nodal values for spatial derivatives of the displacement
[in]	duydx	nodal values for spatial derivatives of the displacement
[in]	duzdx	nodal values for spatial derivatives of the displacement
[in]	duxdy	nodal values for spatial derivatives of the displacement
[in]	duydy	nodal values for spatial derivatives of the displacement
[in]	duzdy	nodal values for spatial derivatives of the displacement
[in]	duxdz	nodal values for spatial derivatives of the displacement
[in]	duydz	nodal values for spatial derivatives of the displacement
[in]	duzdz	nodal values for spatial derivatives of the displacement
[in]	strain_visc_xx	nodal values for viscoelastic stress tensor
[in]	strain_visc_xy	nodal values for viscoelastic stress tensor
[in]	strain_visc_xz	nodal values for viscoelastic stress tensor
[in]	strain_visc_yy	nodal values for viscoelastic stress tensor
[in]	strain_visc_yz	nodal values for viscoelastic stress tensor
[in]	strain_visc_zz	nodal values for viscoelastic stress tensor
[in]	Ylambda	anelastic coefficients (1st Lame modulus)
[in]	Ymu	anelastic coefficients (2nd Lame modulus)
[in]	ie	local element id
[out]	sxx	nodal values for the stress tensor
[out]	syy	nodal values for the stress tensor
[out]	szz	nodal values for the stress tensor
[out]	syz	nodal values for the stress tensor
[out]	szx	nodal values for the stress tensor
[out]	sxy	nodal values for the stress tensor

Definition at line 52 of file MAKE_STRESS_TENSOR_DAMPED.f90.

                               strain_visc_yy, strain_visc_yz, strain_visc_zz, &
                               ylambda,ymu, n_sls, & 
                               sxx,syy,szz,&
                               syz,szx,sxy,ie)
      
      
      implicit none
      
      integer*4 :: nn,N_SLS
      integer*4 :: p,q,r,ie
      
      real*8, dimension(N_SLS) :: ylambda, ymu, temp
      real*8, dimension(nn,nn,nn) :: lambda,mu
      real*8, dimension(nn,nn,nn) :: sxx,syy,szz,syz,szx,sxy
      real*8, dimension(nn,nn,nn) :: duxdx,duxdy,duxdz,duydx,duydy,duydz,duzdx,duzdy,duzdz
      real*8, dimension(nn,nn,nn,N_SLS) :: strain_visc_xx, strain_visc_xy, strain_visc_xz, &
                                           strain_visc_yy, strain_visc_yz, strain_visc_zz
 
      
      do r = 1,nn
         do q = 1,nn
            do p = 1,nn
            
               
               temp = strain_visc_xx(p,q,r,:) + strain_visc_yy(p,q,r,:) + strain_visc_zz(p,q,r,:) 
                   
               sxx(p,q,r) = lambda(p,q,r) * (duxdx(p,q,r) +duydy(p,q,r) +duzdz(p,q,r) &
                                        - dot_product(ylambda,temp)) &
                                        +2.0d0*mu(p,q,r) * (duxdx(p,q,r) - dot_product(ymu,strain_visc_xx(p,q,r,:)))
                                        
               syy(p,q,r) = lambda(p,q,r) * (duxdx(p,q,r) +duydy(p,q,r) +duzdz(p,q,r) &
                                        - dot_product(ylambda,temp)) &
                                        +2.0d0*mu(p,q,r) * (duydy(p,q,r) - dot_product(ymu,strain_visc_yy(p,q,r,:)))
                                        
               szz(p,q,r) = lambda(p,q,r) * (duxdx(p,q,r) +duydy(p,q,r) +duzdz(p,q,r) &
                                        - dot_product(ylambda,temp)) &
                                        +2.0d0*mu(p,q,r) * (duzdz(p,q,r) - dot_product(ymu,strain_visc_zz(p,q,r,:)))
               
               syz(p,q,r) = mu(p,q,r) * (duydz(p,q,r) + duzdy(p,q,r) -  dot_product(ymu,strain_visc_yz(p,q,r,:)))
               szx(p,q,r) = mu(p,q,r) * (duzdx(p,q,r) + duxdz(p,q,r) -  dot_product(ymu,strain_visc_xz(p,q,r,:)))
               sxy(p,q,r) = mu(p,q,r) * (duxdy(p,q,r) + duydx(p,q,r) -  dot_product(ymu,strain_visc_xy(p,q,r,:)))
               
              ! write(*,*) p,q,r
              ! write(*,*) temp
              ! write(*,*) DOT_PRODUCT(Ylambda,temp)
              ! write(*,*) DOT_PRODUCT(Ymu,strain_visc_xx(p,q,r,:))
              ! write(*,*) DOT_PRODUCT(Ymu,strain_visc_yy(p,q,r,:))
              ! write(*,*) DOT_PRODUCT(Ymu,strain_visc_zz(p,q,r,:))
              ! write(*,*) DOT_PRODUCT(Ymu,strain_visc_yz(p,q,r,:))
              ! write(*,*) DOT_PRODUCT(Ymu,strain_visc_xz(p,q,r,:))
              ! write(*,*) DOT_PRODUCT(Ymu,strain_visc_xy(p,q,r,:))
              ! write(*,*) '--------------------------------------'
            enddo
         enddo
      enddo
      
      return