FrontISTR  5.7.0
Large-scale structural analysis program with finit element method
fstr_dynamic_nlexplicit.f90
Go to the documentation of this file.
1 !-------------------------------------------------------------------------------
2 ! Copyright (c) 2019 FrontISTR Commons
3 ! This software is released under the MIT License, see LICENSE.txt
4 !-------------------------------------------------------------------------------
6 
7 module fstr_dynamic_nlexplicit
8  use m_fstr
9  use m_static_lib
10  use m_dynamic_output
11  use m_fstr_eig_setmass
12  use m_dynamic_mat_ass_bc_ac
13  use m_dynamic_mat_ass_bc
14  use m_dynamic_mat_ass_bc_vl
15  use m_dynamic_mat_ass_load
16  use m_fstr_update
17  use m_fstr_restart
18  use m_dynamic_mat_ass_couple
19  use m_fstr_rcap_io
20  use mcontact
21 
22 contains
23 
24  !C================================================================C
25  !C-- subroutine fstr_solve_LINEAR_DYNAMIC
26  !C================================================================C
27  subroutine fstr_solve_dynamic_nlexplicit(hecMESH,hecMAT,fstrSOLID,fstrEIG &
28  ,fstrDYN,fstrRESULT,fstrPARAM,infoCTChange &
29  ,fstrCPL, restrt_step_num )
30  implicit none
31  type(hecmwst_local_mesh) :: hecMESH
32  type(hecmwst_matrix) :: hecMAT
33  type(fstr_eigen) :: fstrEIG
34  type(fstr_solid) :: fstrSOLID
35  type(hecmwst_result_data) :: fstrRESULT
36  type(fstr_param) :: fstrPARAM
37  type(fstr_dynamic) :: fstrDYN
38  type(hecmwst_matrix_lagrange) :: hecLagMAT
39  type(fstr_info_contactchange) :: infoCTChange
40  type(fstr_couple) :: fstrCPL !for COUPLE
41  type(hecmwst_matrix), pointer :: hecMATmpc
42  integer(kind=kint), allocatable :: mark(:)
43  integer(kind=kint) :: nnod, ndof, nn, numnp
44  integer(kind=kint) :: i, j, ids, ide, kk
45  integer(kind=kint) :: kkk0, kkk1
46  integer(kind=kint) :: ierror
47  integer(kind=kint) :: iiii5, iexit
48  integer(kind=kint) :: revocap_flag
49  real(kind=kreal), allocatable :: prevb(:)
50  real(kind=kreal) :: a1, a2, a3, b1, b2, b3, c1, c2
51  real(kind=kreal) :: bsize, res
52  real(kind=kreal) :: time_1, time_2
53  integer(kind=kint) :: restrt_step_num
54  real(kind=kreal), parameter :: pi = 3.14159265358979323846d0
55 
56  a1 = 0.0d0; a2 = 0.0d0; a3 = 0.0d0; b1 = 0.0d0; b2 = 0.0d0; b3 = 0.0d0
57  c1 = 0.0d0; c2 = 0.0d0
58 
59  call hecmw_mpc_mat_init_explicit(hecmesh, hecmat, hecmatmpc)
60 
61  hecmat%NDOF=hecmesh%n_dof
62  nnod=hecmesh%n_node
63  ndof=hecmat%NDOF
64  nn=ndof*ndof
65 
66  if( fstrparam%fg_couple == 1) then
67  if( fstrparam%fg_couple_type==5 .or. &
68  fstrparam%fg_couple_type==6 ) then
69  allocate( prevb(hecmat%NP*ndof) ,stat=ierror )
70  prevb = 0.0d0
71  if( ierror /= 0 ) then
72  write(idbg,*) 'stop due to allocation error <fstr_solve_NONLINEAR_DYNAMIC, prevB>'
73  write(idbg,*) ' rank = ', hecmesh%my_rank,' ierror = ',ierror
74  call flush(idbg)
75  call hecmw_abort( hecmw_comm_get_comm())
76  endif
77  endif
78  endif
79 
80  fstrsolid%dunode(:) =0.d0
81 
82  a1 = 1.d0/fstrdyn%t_delta**2
83  a2 = 1.d0/(2.d0*fstrdyn%t_delta)
84 
85  call setmass(fstrsolid,hecmesh,hecmat,fstreig)
86  call hecmw_mpc_trans_mass(hecmesh, hecmat, fstreig%mass)
87 
88  allocate(mark(hecmat%NP * hecmat%NDOF))
89  call hecmw_mpc_mark_slave(hecmesh, hecmat, mark)
90 
91  do j = 1 ,ndof*nnod
92  fstrdyn%VEC1(j) = (a1 + a2 *fstrdyn%ray_m) * fstreig%mass(j)
93  if(mark(j) == 1) fstrdyn%VEC1(j) = 1.d0
94  if(dabs(fstrdyn%VEC1(j)) < 1.0e-20) then
95  if( hecmesh%my_rank == 0 ) then
96  write(*,*) 'stop due to fstrDYN%VEC(j) = 0 , j = ', j
97  write(imsg,*) 'stop due to fstrDYN%VEC(j) = 0 , j = ', j
98  end if
99  call hecmw_abort( hecmw_comm_get_comm())
100  endif
101  end do
102 
103  deallocate(mark)
104 
105  !C-- output of initial state
106  if( restrt_step_num == 1 ) then
107  do j = 1 ,ndof*nnod
108  fstrdyn%DISP(j,3) = fstrdyn%DISP(j,1) - fstrdyn%VEL (j,1)/(2.d0*a2) + fstrdyn%ACC (j,1)/ (2.d0*a1)
109  fstrdyn%DISP(j,2) = fstrdyn%DISP(j,1) - fstrdyn%VEL (j,1)/ a2 + fstrdyn%ACC (j,1)/ (2.d0*a1) * 4.d0
110  end do
111 
112  call fstr_dynamic_output(hecmesh, fstrsolid, fstrdyn, fstrparam)
113  call dynamic_output_monit(hecmesh, fstrparam, fstrdyn, fstreig, fstrsolid)
114  end if
115 
116  if( associated( fstrsolid%contacts ) ) then
117  call initialize_contact_output_vectors(fstrsolid,hecmat)
118  call forward_increment_lagrange(1,ndof,fstrdyn%VEC1,hecmesh,fstrsolid,infoctchange,&
119  & fstrdyn%DISP(:,2),fstrsolid%ddunode)
120  endif
121 
122  do i= restrt_step_num, fstrdyn%n_step
123 
124  fstrdyn%i_step = i
125  fstrdyn%t_curr = fstrdyn%t_delta * i
126 
127  !C-- mechanical boundary condition
128  call dynamic_mat_ass_load (hecmesh, hecmat, fstrsolid, fstrdyn, fstrparam)
129  do j=1, hecmesh%n_node* hecmesh%n_dof
130  hecmat%B(j)=hecmat%B(j)-fstrsolid%QFORCE(j)
131  end do
132 
133  !C ********************************************************************************
134  !C for couple analysis
135  if( fstrparam%fg_couple == 1 ) then
136  if( fstrparam%fg_couple_type==5 .or. &
137  fstrparam%fg_couple_type==6 ) then
138  do j = 1, hecmat%NP * ndof
139  prevb(j) = hecmat%B(j)
140  enddo
141  endif
142  endif
143  do
144  if( fstrparam%fg_couple == 1 ) then
145  if( fstrparam%fg_couple_type==1 .or. &
146  fstrparam%fg_couple_type==3 .or. &
147  fstrparam%fg_couple_type==5 ) call fstr_rcap_get( fstrcpl )
148  if( fstrparam%fg_couple_first /= 0 ) then
149  bsize = dfloat( i ) / dfloat( fstrparam%fg_couple_first )
150  if( bsize > 1.0 ) bsize = 1.0
151  do kkk0 = 1, fstrcpl%coupled_node_n
152  kkk1 = 3 * kkk0
153  fstrcpl%trac(kkk1-2) = bsize * fstrcpl%trac(kkk1-2)
154  fstrcpl%trac(kkk1-1) = bsize * fstrcpl%trac(kkk1-1)
155  fstrcpl%trac(kkk1 ) = bsize * fstrcpl%trac(kkk1 )
156  enddo
157  endif
158  if( fstrparam%fg_couple_window > 0 ) then
159  j = i - restrt_step_num + 1
160  kk = fstrdyn%n_step - restrt_step_num + 1
161  bsize = 0.5*(1.0-cos(2.0*pi*dfloat(j)/dfloat(kk)))
162  do kkk0 = 1, fstrcpl%coupled_node_n
163  kkk1 = 3 * kkk0
164  fstrcpl%trac(kkk1-2) = bsize * fstrcpl%trac(kkk1-2)
165  fstrcpl%trac(kkk1-1) = bsize * fstrcpl%trac(kkk1-1)
166  fstrcpl%trac(kkk1 ) = bsize * fstrcpl%trac(kkk1 )
167  enddo
168  endif
169  call dynamic_mat_ass_couple( hecmesh, hecmat, fstrsolid, fstrcpl )
170  endif
171  !C ********************************************************************************
172 
173  call hecmw_mpc_trans_rhs(hecmesh, hecmat, hecmatmpc)
174 
175  do j = 1 ,ndof*nnod
176  hecmatmpc%B(j) = hecmatmpc%B(j) + 2.d0*a1* fstreig%mass(j) * fstrdyn%DISP(j,1) &
177  + (- a1 + a2 * fstrdyn%ray_m) * fstreig%mass(j) * fstrdyn%DISP(j,3)
178  end do
179 
180  !C
181  !C-- geometrical boundary condition
182 
183  call dynamic_explicit_ass_bc(hecmesh, hecmatmpc, fstrsolid, fstrdyn)
184  call dynamic_explicit_ass_vl(hecmesh, hecmatmpc, fstrsolid, fstrdyn)
185  call dynamic_explicit_ass_ac(hecmesh, hecmatmpc, fstrsolid, fstrdyn)
186  !call dynamic_mat_ass_bc (hecMESH, hecMATmpc, fstrSOLID, fstrDYN, fstrPARAM, hecLagMAT)
187  !call dynamic_mat_ass_bc_vl(hecMESH, hecMATmpc, fstrSOLID, fstrDYN, fstrPARAM, hecLagMAT)
188  !call dynamic_mat_ass_bc_ac(hecMESH, hecMATmpc, fstrSOLID, fstrDYN, fstrPARAM, hecLagMAT)
189 
190  ! Finish the calculation
191  do j = 1 ,ndof*nnod
192  hecmatmpc%X(j) = hecmatmpc%B(j) / fstrdyn%VEC1(j)
193  if(dabs(hecmatmpc%X(j)) > 1.0d+5) then
194  if( hecmesh%my_rank == 0 ) then
195  print *, 'Displacement increment too large, please adjust your step size!',i,hecmatmpc%X(j)
196  write(imsg,*) 'Displacement increment too large, please adjust your step size!',i,hecmatmpc%B(j),fstrdyn%VEC1(j)
197  end if
198  call hecmw_abort( hecmw_comm_get_comm())
199  end if
200  end do
201  call hecmw_mpc_tback_sol(hecmesh, hecmat, hecmatmpc)
202 
203  !C *****************************************************
204  !C for couple analysis
205  if( fstrparam%fg_couple == 1 ) then
206  if( fstrparam%fg_couple_type>1 ) then
207  do j=1, fstrcpl%coupled_node_n
208  if( fstrcpl%dof == 3 ) then
209  kkk0 = j*3
210  kkk1 = fstrcpl%coupled_node(j)*3
211 
212  fstrcpl%disp (kkk0-2) = hecmat%X(kkk1-2)
213  fstrcpl%disp (kkk0-1) = hecmat%X(kkk1-1)
214  fstrcpl%disp (kkk0 ) = hecmat%X(kkk1 )
215 
216  fstrcpl%velo (kkk0-2) = -b1*fstrdyn%ACC(kkk1-2,1) - b2*fstrdyn%VEL(kkk1-2,1) + &
217  b3*( hecmat%X(kkk1-2) - fstrdyn%DISP(kkk1-2,1) )
218  fstrcpl%velo (kkk0-1) = -b1*fstrdyn%ACC(kkk1-1,1) - b2*fstrdyn%VEL(kkk1-1,1) + &
219  b3*( hecmat%X(kkk1-1) - fstrdyn%DISP(kkk1-1,1) )
220  fstrcpl%velo (kkk0 ) = -b1*fstrdyn%ACC(kkk1,1) - b2*fstrdyn%VEL(kkk1,1) + &
221  b3*( hecmat%X(kkk1) - fstrdyn%DISP(kkk1,1) )
222  fstrcpl%accel(kkk0-2) = -a1*fstrdyn%ACC(kkk1-2,1) - a2*fstrdyn%VEL(kkk1-2,1) + &
223  a3*( hecmat%X(kkk1-2) - fstrdyn%DISP(kkk1-2,1) )
224  fstrcpl%accel(kkk0-1) = -a1*fstrdyn%ACC(kkk1-1,1) - a2*fstrdyn%VEL(kkk1-1,1) + &
225  a3*( hecmat%X(kkk1-1) - fstrdyn%DISP(kkk1-1,1) )
226  fstrcpl%accel(kkk0 ) = -a1*fstrdyn%ACC(kkk1,1) - a2*fstrdyn%VEL(kkk1,1) + &
227  a3*( hecmat%X(kkk1) - fstrdyn%DISP(kkk1,1) )
228  else
229  kkk0 = j*2
230  kkk1 = fstrcpl%coupled_node(j)*2
231 
232  fstrcpl%disp (kkk0-1) = hecmat%X(kkk1-1)
233  fstrcpl%disp (kkk0 ) = hecmat%X(kkk1 )
234 
235  fstrcpl%velo (kkk0-1) = -b1*fstrdyn%ACC(kkk1-1,1) - b2*fstrdyn%VEL(kkk1-1,1) + &
236  b3*( hecmat%X(kkk1-1) - fstrdyn%DISP(kkk1-1,1) )
237  fstrcpl%velo (kkk0 ) = -b1*fstrdyn%ACC(kkk1,1) - b2*fstrdyn%VEL(kkk1,1) + &
238  b3*( hecmat%X(kkk1) - fstrdyn%DISP(kkk1,1) )
239  fstrcpl%accel(kkk0-1) = -a1*fstrdyn%ACC(kkk1-1,1) - a2*fstrdyn%VEL(kkk1-1,1) + &
240  a3*( hecmat%X(kkk1-1) - fstrdyn%DISP(kkk1-1,1) )
241  fstrcpl%accel(kkk0 ) = -a1*fstrdyn%ACC(kkk1,1) - a2*fstrdyn%VEL(kkk1,1) + &
242  a3*( hecmat%X(kkk1) - fstrdyn%DISP(kkk1,1) )
243  endif
244  end do
245  call fstr_rcap_send( fstrcpl )
246  endif
247 
248  select case ( fstrparam%fg_couple_type )
249  case (4)
250  call fstr_rcap_get( fstrcpl )
251  case (5)
252  call fstr_get_convergence( revocap_flag )
253  if( revocap_flag==0 ) then
254  do j = 1, hecmat%NP * ndof
255  hecmat%B(j) = prevb(j)
256  enddo
257  cycle
258  endif
259  case (6)
260  call fstr_get_convergence( revocap_flag )
261  if( revocap_flag==0 ) then
262  do j = 1, hecmat%NP * ndof
263  hecmat%B(j) = prevb(j)
264  enddo
265  call fstr_rcap_get( fstrcpl )
266  cycle
267  else
268  if( i /= fstrdyn%n_step ) call fstr_rcap_get( fstrcpl )
269  endif
270  end select
271  endif
272  exit
273  enddo
274 
275  !C *****************************************************
276  !C-- contact corrector
277  !C
278  do j = 1 ,ndof*nnod
279  fstrsolid%unode(j) = fstrdyn%DISP(j,1)
280  fstrsolid%dunode(j) = hecmat%X(j)-fstrdyn%DISP(j,1)
281  enddo
282  if( associated( fstrsolid%contacts ) ) then
283  !call fstr_scan_contact_state( 1, fstrDYN%t_delta, kcaSLAGRANGE, hecMESH, fstrSOLID, infoCTChange )
284  call forward_increment_lagrange(1,ndof,fstrdyn%VEC1,hecmesh,fstrsolid,infoctchange,&
285  & fstrdyn%DISP(:,2),fstrsolid%ddunode)
286  do j = 1 ,ndof*nnod
287  hecmat%X(j) = hecmat%X(j) + fstrsolid%ddunode(j)
288  enddo
289  endif
290 
291  !C-- new displacement, velocity and acceleration
292  do j = 1 ,ndof*nnod
293  fstrdyn%ACC (j,1) = a1*(hecmat%X(j) - 2.d0*fstrdyn%DISP(j,1) + fstrdyn%DISP(j,3))
294  fstrdyn%VEL (j,1) = a2*(hecmat%X(j) - fstrdyn%DISP(j,3))
295  fstrsolid%unode(j) = fstrdyn%DISP(j,1)
296  fstrsolid%dunode(j) = hecmat%X(j)-fstrdyn%DISP(j,1)
297  fstrdyn%DISP(j,3) = fstrdyn%DISP(j,1)
298  fstrdyn%DISP(j,1) = hecmat%X(j)
299  hecmat%X(j) = fstrsolid%dunode(j)
300  end do
301 
302  ! ----- update strain, stress, and internal force
303  call fstr_updatenewton( hecmesh, hecmat, fstrsolid, fstrdyn%t_curr, fstrdyn%t_delta, 1 )
304 
305  do j = 1 ,ndof*nnod
306  fstrsolid%unode(j) = fstrsolid%unode(j) + fstrsolid%dunode(j)
307  end do
308  call fstr_updatestate( hecmesh, fstrsolid, fstrdyn%t_delta )
309 
310  if( fstrdyn%restart_nout > 0 ) then
311  if ( mod(i,fstrdyn%restart_nout).eq.0 .or. i.eq.fstrdyn%n_step ) then
312  call fstr_write_restart_dyna_nl(i,hecmesh,fstrsolid,fstrdyn,fstrparam)
313  end if
314  end if
315  !
316  !C-- output new displacement, velocity and acceleration
317  call fstr_dynamic_output(hecmesh, fstrsolid, fstrdyn, fstrparam)
318  call dynamic_output_monit(hecmesh, fstrparam, fstrdyn, fstreig, fstrsolid)
319 
320  enddo
321 
322  if( fstrparam%fg_couple == 1) then
323  if( fstrparam%fg_couple_type==5 .or. &
324  fstrparam%fg_couple_type==6 ) then
325  deallocate( prevb ,stat=ierror )
326  if( ierror /= 0 ) then
327  write(idbg,*) 'stop due to deallocation error <fstr_solve_NONLINEAR_DYNAMIC, prevB>'
328  write(idbg,*) ' rank = ', hecmesh%my_rank,' ierror = ',ierror
329  call flush(idbg)
330  call hecmw_abort( hecmw_comm_get_comm())
331  endif
332  endif
333  endif
334 
335  call hecmw_mpc_mat_finalize_explicit(hecmesh, hecmat, hecmatmpc)
336 
337  end subroutine fstr_solve_dynamic_nlexplicit
338 
339 
340  subroutine forward_increment_lagrange(cstep,ndof,mmat,hecMESH,fstrSOLID,infoCTChange,wkarray,uc)
341  integer, intent(in) :: cstep
342  integer, intent(in) :: ndof
343  real(kind=kreal), intent(in) :: mmat(:)
344  type( hecmwst_local_mesh ), intent(in) :: hecmesh
345  type(fstr_solid), intent(inout) :: fstrSOLID
346  type(fstr_info_contactchange) :: infoCTChange
347  real(kind=kreal), intent(out) :: wkarray(:)
348  real(kind=kreal), intent(out) :: uc(:)
349  integer :: i, j, k, m, grpid, slave, nn, iSS, sid, etype, iter
350  real(kind=kreal) :: fdum, conv, dlambda, shapefunc(l_max_surface_node), lambda(3)
351 
352  call fstr_scan_contact_state_exp( cstep, hecmesh, fstrsolid, infoctchange )
353  if( .not. infoctchange%active ) return
354 
355  uc = 0.0d0
356 
357  iter = 0
358  do
359  wkarray = 0.0d0
360  do i=1,fstrsolid%n_contacts
361  do j= 1, size(fstrsolid%contacts(i)%slave)
362  if( fstrsolid%contacts(i)%states(j)%state == contactfree ) cycle
363  if( fstrsolid%contacts(i)%states(j)%distance>epsilon(1.d0) ) then
364  fstrsolid%contacts(i)%states(j)%state = contactfree
365  cycle
366  endif
367  if( iter==0 ) then
368  fstrsolid%contacts(i)%states(j)%multiplier(:) =0.d0
369  fstrsolid%contacts(i)%states(j)%wkdist =0.d0
370  cycle
371  endif
372  slave = fstrsolid%contacts(i)%slave(j)
373 
374  sid = fstrsolid%contacts(i)%states(j)%surface
375  nn = size( fstrsolid%contacts(i)%master(sid)%nodes )
376  etype = fstrsolid%contacts(i)%master(sid)%etype
377  call getshapefunc( etype, fstrsolid%contacts(i)%states(j)%lpos(:), shapefunc )
378  wkarray( slave ) = -fstrsolid%contacts(i)%states(j)%multiplier(1)
379  do k=1,nn
380  iss = fstrsolid%contacts(i)%master(sid)%nodes(k)
381  wkarray( iss ) = wkarray( iss ) + shapefunc(k) * fstrsolid%contacts(i)%states(j)%multiplier(1)
382  enddo
383  enddo
384  enddo
385 
386  if(iter > 0)then
387  do i=1,fstrsolid%n_contacts
388  do j= 1, size(fstrsolid%contacts(i)%slave)
389  if( fstrsolid%contacts(i)%states(j)%state == contactfree ) cycle
390  slave = fstrsolid%contacts(i)%slave(j)
391  sid = fstrsolid%contacts(i)%states(j)%surface
392  nn = size( fstrsolid%contacts(i)%master(sid)%nodes )
393  etype = fstrsolid%contacts(i)%master(sid)%etype
394  call getshapefunc( etype, fstrsolid%contacts(i)%states(j)%lpos(:), shapefunc )
395  fstrsolid%contacts(i)%states(j)%wkdist = -wkarray( slave )/mmat( (slave-1)*ndof+1 )
396  do k=1,nn
397  iss = fstrsolid%contacts(i)%master(sid)%nodes(k)
398  fstrsolid%contacts(i)%states(j)%wkdist = fstrsolid%contacts(i)%states(j)%wkdist &
399  + shapefunc(k) * wkarray(iss) / mmat( (iss-1)*ndof+1 )
400  enddo
401  enddo
402  enddo
403  endif
404 
405  conv = 0.d0
406  wkarray = 0.d0
407  do i=1,fstrsolid%n_contacts
408  do j= 1, size(fstrsolid%contacts(i)%slave)
409  if( fstrsolid%contacts(i)%states(j)%state == contactfree ) cycle
410  slave = fstrsolid%contacts(i)%slave(j)
411  sid = fstrsolid%contacts(i)%states(j)%surface
412  nn = size( fstrsolid%contacts(i)%master(sid)%nodes )
413  etype = fstrsolid%contacts(i)%master(sid)%etype
414  call getshapefunc( etype, fstrsolid%contacts(i)%states(j)%lpos(:), shapefunc )
415  fdum = 1.d0/mmat( (slave-1)*ndof+1 )
416  do k=1,nn
417  iss = fstrsolid%contacts(i)%master(sid)%nodes(k)
418  fdum = fdum + shapefunc(k)*shapefunc(k)/mmat( (iss-1)*ndof+1 )
419  enddo
420  dlambda= (fstrsolid%contacts(i)%states(j)%distance-fstrsolid%contacts(i)%states(j)%wkdist) /fdum
421  conv = conv + dlambda*dlambda;
422  fstrsolid%contacts(i)%states(j)%multiplier(1) = fstrsolid%contacts(i)%states(j)%multiplier(1) + dlambda
423  if( fstrsolid%contacts(i)%fcoeff>0.d0 ) then
424  if( fstrsolid%contacts(i)%states(j)%state == contactslip ) then
425  fstrsolid%contacts(i)%states(j)%multiplier(2) = &
426  fstrsolid%contacts(i)%fcoeff * fstrsolid%contacts(i)%states(j)%multiplier(1)
427  else ! stick
428  ! fstrSOLID%contacts(i)%states(j)%multiplier(2) =
429  endif
430  endif
431  lambda = fstrsolid%contacts(i)%states(j)%multiplier(1)* fstrsolid%contacts(i)%states(j)%direction
432  wkarray((slave-1)*ndof+1:(slave-1)*ndof+3) = lambda(:)
433  do k=1,nn
434  iss = fstrsolid%contacts(i)%master(sid)%nodes(k)
435  wkarray((iss-1)*ndof+1:(iss-1)*ndof+3) = wkarray((iss-1)*ndof+1:(iss-1)*ndof+3) -lambda(:)*shapefunc(k)
436  enddo
437  enddo
438  enddo
439  if( dsqrt(conv)<1.d-8 ) exit
440  iter = iter+1
441  enddo
442 
443  do i=1,hecmesh%n_node*ndof
444  uc(i) = wkarray(i)/mmat(i)
445  enddo
446  end subroutine forward_increment_lagrange
447 
448 end module fstr_dynamic_nlexplicit
m_fstr_rcap_io
Definition: fstr_rcap_io.F90:5
m_dynamic_mat_ass_couple::dynamic_mat_ass_couple
subroutine dynamic_mat_ass_couple(hecMESH, hecMAT, fstrSOLID, fstrCPL)
Definition: dynamic_mat_ass_couple.f90:17
m_fstr_rcap_io::fstr_get_convergence
subroutine fstr_get_convergence(revocap_flag)
Definition: fstr_rcap_io.F90:256
m_dynamic_output
This module provides functions to output result.
Definition: dynamic_output.f90:6
m_dynamic_output::fstr_dynamic_output
subroutine fstr_dynamic_output(hecMESH, fstrSOLID, fstrDYNAMIC, fstrPARAM)
Output result.
Definition: dynamic_output.f90:13
m_fstr_eig_setmass::setmass
subroutine setmass(fstrSOLID, hecMESH, hecMAT, fstrEIG)
Definition: fstr_EIG_setMASS.f90:16
m_fstr_update
This module provides function to calculate to do updates.
Definition: fstr_Update.f90:6
m_fstr::fstr_eigen
Package of data used by Lanczos eigenvalue solver.
Definition: m_fstr.f90:593
fstr_dynamic_nlexplicit
This module contains subroutines for nonlinear explicit dynamic analysis.
Definition: fstr_dynamic_nlexplicit.f90:7
m_fstr::fstr_solid
Definition: m_fstr.f90:238
m_fstr::fstr_dynamic
Data for DYNAMIC ANSLYSIS (fstrDYNAMIC)
Definition: m_fstr.f90:504
m_fstr::idbg
integer(kind=kint), parameter idbg
Definition: m_fstr.f90:111
m_fstr::fstr_param
FSTR INNER CONTROL PARAMETERS (fstrPARAM)
Definition: m_fstr.f90:154
m_dynamic_mat_ass_load::dynamic_mat_ass_load
subroutine dynamic_mat_ass_load(hecMESH, hecMAT, fstrSOLID, fstrDYNAMIC, fstrPARAM, iter)
This function sets boundary condition of external load.
Definition: dynamic_mat_ass_load.f90:16
m_dynamic_mat_ass_bc_vl
This module contains functions to set velocity boundary condition in dynamic analysis.
Definition: dynamic_mat_ass_bc_vl.f90:6
m_fstr_eig_setmass
Set up lumped mass matrix.
Definition: fstr_EIG_setMASS.f90:6
m_dynamic_mat_ass_bc_vl::dynamic_explicit_ass_vl
subroutine dynamic_explicit_ass_vl(hecMESH, hecMAT, fstrSOLID, fstrDYNAMIC, iter)
Definition: dynamic_mat_ass_bc_vl.f90:212
m_dynamic_output::dynamic_output_monit
subroutine dynamic_output_monit(hecMESH, fstrPARAM, fstrDYNAMIC, fstrEIG, fstrSOLID)
Definition: dynamic_output.f90:356
m_dynamic_mat_ass_couple
This module contains functions relates to coupling analysis.
Definition: dynamic_mat_ass_couple.f90:6
fstr_dynamic_nlexplicit::forward_increment_lagrange
subroutine forward_increment_lagrange(cstep, ndof, mmat, hecMESH, fstrSOLID, infoCTChange, wkarray, uc)
Definition: fstr_dynamic_nlexplicit.f90:341
m_dynamic_mat_ass_bc::dynamic_explicit_ass_bc
subroutine dynamic_explicit_ass_bc(hecMESH, hecMAT, fstrSOLID, fstrDYNAMIC, iter)
This subroutine setup disp boundary condition.
Definition: dynamic_mat_ass_bc.f90:264
m_fstr
This module defines common data and basic structures for analysis.
Definition: m_fstr.f90:15
mcontact::initialize_contact_output_vectors
subroutine initialize_contact_output_vectors(fstrSOLID, hecMAT)
Definition: fstr_contact.f90:565
m_fstr::fstr_couple
Data for coupling analysis.
Definition: m_fstr.f90:611
m_dynamic_mat_ass_load
This module contains function to set boundary condition of external load in dynamic analysis.
Definition: dynamic_mat_ass_load.f90:7
m_fstr_rcap_io::fstr_rcap_get
subroutine, public fstr_rcap_get(fstrCPL)
Definition: fstr_rcap_io.F90:215
m_fstr_update::fstr_updatenewton
subroutine fstr_updatenewton(hecMESH, hecMAT, fstrSOLID, time, tincr, iter, strainEnergy)
Update displacement, stress, strain and internal forces.
Definition: fstr_Update.f90:26
m_dynamic_mat_ass_bc_ac
This module contains functions to set acceleration boundary condition in dynamic analysis.
Definition: dynamic_mat_ass_bc_ac.f90:7
m_dynamic_mat_ass_bc_ac::dynamic_explicit_ass_ac
subroutine dynamic_explicit_ass_ac(hecMESH, hecMAT, fstrSOLID, fstrDYNAMIC, iter)
Definition: dynamic_mat_ass_bc_ac.f90:208
m_fstr_restart::fstr_write_restart_dyna_nl
subroutine fstr_write_restart_dyna_nl(cstep, hecMESH, fstrSOLID, fstrDYNAMIC, fstrPARAM, contactNode)
write out restart file for nonlinear dynamic analysis
Definition: fstr_Restart.f90:308
fstr_dynamic_nlexplicit::fstr_solve_dynamic_nlexplicit
subroutine fstr_solve_dynamic_nlexplicit(hecMESH, hecMAT, fstrSOLID, fstrEIG, fstrDYN, fstrRESULT, fstrPARAM, infoCTChange, fstrCPL, restrt_step_num)
Definition: fstr_dynamic_nlexplicit.f90:30
m_static_lib
This modules just summarizes all modules used in static analysis.
Definition: static_LIB.f90:6
m_fstr_update::fstr_updatestate
subroutine fstr_updatestate(hecMESH, fstrSOLID, tincr)
Update elastiplastic status.
Definition: fstr_Update.f90:250
m_dynamic_mat_ass_bc
This module contains functions to set displacement boundary condition in dynamic analysis.
Definition: dynamic_mat_ass_bc.f90:7
mcontact::fstr_scan_contact_state_exp
subroutine fstr_scan_contact_state_exp(cstep, hecMESH, fstrSOLID, infoCTChange)
Scanning contact state.
Definition: fstr_contact.f90:350
m_fstr_rcap_io::fstr_rcap_send
subroutine, public fstr_rcap_send(fstrCPL)
Definition: fstr_rcap_io.F90:185
m_fstr_restart
This module provides functions to read in and write out restart files.
Definition: fstr_Restart.f90:8
mcontact
This module provides functions to calculate contact stiff matrix.
Definition: fstr_contact.f90:6
m_fstr::imsg
integer(kind=kint), parameter imsg
Definition: m_fstr.f90:110