FrontISTR  6.0.0
Large-scale structural analysis program with finit element method
dynamic_mat_ass_bc_vl.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 module m_dynamic_mat_ass_bc_vl
7 contains
8 
9  !C***
13  !C***
14  subroutine gather_rotvel_info(hecMESH, fstrSOLID, fstrDYNAMIC, t_curr, ndof, rinfo, cstep)
15  use m_fstr
16  use m_table_dyn
17  implicit none
18  type(hecmwst_local_mesh) :: hecMESH
19  type(fstr_solid) :: fstrSOLID
20  type(fstr_dynamic) :: fstrDYNAMIC
21  real(kind=kreal), intent(in) :: t_curr
22  integer(kind=kint), intent(in) :: ndof
23  type(trotinfo) :: rinfo
24  integer(kind=kint), optional :: cstep
25 
26  integer(kind=kint) :: ig0, ig, ityp, idofS, idofE, idof, rid, grpid, flag_u
27  real(kind=kreal) :: rhs
28 
29  flag_u = 2
30  do ig0 = 1, fstrsolid%VELOCITY_ngrp_tot
31  if( fstrsolid%VELOCITY_ngrp_rotID(ig0) <= 0 ) cycle
32  grpid = fstrsolid%VELOCITY_ngrp_GRPID(ig0)
33  if( present(cstep) ) then
34  if( .not. fstr_isboundaryactive( fstrsolid, grpid, cstep ) ) cycle
35  endif
36 
37  rhs = fstrsolid%VELOCITY_ngrp_val(ig0)
38  call fstr_get_amplitude_dyn(hecmesh, fstrsolid, fstrdynamic, ig0, t_curr, rhs, flag_u)
39 
40  rid = fstrsolid%VELOCITY_ngrp_rotID(ig0)
41  ig = fstrsolid%VELOCITY_ngrp_ID(ig0)
42  if( .not. rinfo%conds(rid)%active ) then
43  rinfo%conds(rid)%active = .true.
44  rinfo%conds(rid)%center_ngrp_id = fstrsolid%VELOCITY_ngrp_centerID(ig0)
45  rinfo%conds(rid)%torque_ngrp_id = ig
46  endif
47 
48  ityp = fstrsolid%VELOCITY_ngrp_type(ig0)
49  idofs = ityp/10
50  idofe = ityp - idofs*10
51  do idof = idofs, idofe
52  if( idof > ndof ) then
53  rinfo%conds(rid)%vec(idof-ndof) = rhs
54  else
55  rinfo%conds(rid)%vec(idof) = rhs
56  endif
57  enddo
58  enddo
59  end subroutine gather_rotvel_info
60 
61  !C***
63  !C***
64  subroutine get_rotcenter_coord(hecMESH, fstrSOLID, ig, ndof, ccoord)
65  use m_fstr
66  implicit none
67  type(hecmwst_local_mesh) :: hecmesh
68  type(fstr_solid) :: fstrSOLID
69  integer(kind=kint), intent(in) :: ig, ndof
70  real(kind=kreal), intent(out) :: ccoord(3)
71 
72  integer(kind=kint) :: idof
73  real(kind=kreal) :: cdisp(3)
74 
75  ccoord = 0.d0
76  cdisp = 0.d0
77  do idof = 1, ndof
78  ccoord(idof) = hecmw_ngrp_get_totalvalue(hecmesh, ig, ndof, idof, hecmesh%node)
79  cdisp(idof) = hecmw_ngrp_get_totalvalue(hecmesh, ig, ndof, idof, fstrsolid%unode)
80  enddo
81  ccoord(1:ndof) = ccoord(1:ndof) + cdisp(1:ndof)
82  end subroutine get_rotcenter_coord
83 
84  !C***
86  !C***
87 
88  subroutine dynamic_mat_ass_bc_vl(cstep, hecMESH, hecMAT, fstrSOLID, fstrDYNAMIC, fstrPARAM, hecLagMAT, hecEBC, &
89  t_curr, iter, conMAT)
90  use m_fstr
91  use m_table_dyn
92  use mcontact
93  use m_utilities
94  use hecmw_ebc_defer
95 
96  implicit none
97  integer(kind=kint) :: cstep
98  type(hecmwst_matrix) :: hecMAT
99  type(hecmwst_local_mesh) :: hecMESH
100  type(fstr_solid) :: fstrSOLID
101  type(fstr_dynamic) :: fstrDYNAMIC
102  type(fstr_param) :: fstrPARAM
103  type(hecmwst_matrix_lagrange) :: hecLagMAT
104  type(hecmwst_ebc) :: hecEBC
105  real(kind=kreal) :: t_curr
106  type(hecmwst_matrix), optional :: conmat
107 
108  integer, optional :: iter
109 
110  integer(kind=kint) :: ig0, ig, ityp, ndof, is0, ie0, ik, in, idofs, idofe, idof
111  integer(kind=kint) :: flag_u, grpid
112  real(kind=kreal) :: b2, b3, b4, c1
113  real(kind=kreal) :: rhs, rhs0
114 
115  !for rotation
116  integer(kind=kint) :: n_rot, rid
117  type(trotinfo) :: rinfo
118  real(kind=kreal) :: ccoord(3), cdiff(3), vnode(3), omega(3)
119 
120  if( fstrsolid%VELOCITY_type == kbcinitial )return
121 
122  flag_u = 2
123 
124  if(dabs(fstrdynamic%gamma) .lt. 1.0e-20) then
125  if( hecmesh%my_rank == 0 ) then
126  write(imsg,*) 'stop due to fstrDYNAMIC%gamma = 0'
127  end if
128  call hecmw_abort( hecmw_comm_get_comm())
129  end if
130 
131  b2 = fstrdynamic%t_delta &
132  *(fstrdynamic%gamma-fstrdynamic%beta)/fstrdynamic%gamma
133  b3 = fstrdynamic%t_delta**2 &
134  *(fstrdynamic%gamma-2.0*fstrdynamic%beta) &
135  /(2.0*fstrdynamic%gamma)
136  b4 = fstrdynamic%t_delta*fstrdynamic%beta/fstrdynamic%gamma
137  c1 = 2.0*fstrdynamic%t_delta
138 
139  ndof = hecmat%NDOF
140 
141  n_rot = fstrsolid%VELOCITY_ngrp_rot
142  if( n_rot > 0 ) then
143  call fstr_rotinfo_init(n_rot, rinfo)
144  call gather_rotvel_info(hecmesh, fstrsolid, fstrdynamic, t_curr, ndof, rinfo, cstep)
145  endif
146 
147  !C=============================C
148  !C-- implicit dynamic analysis
149  !C=============================C
150  if( fstrdynamic%idx_eqa /= 11 ) then
151 
152  do ig0 = 1, fstrsolid%VELOCITY_ngrp_tot
153  if( fstrsolid%VELOCITY_ngrp_rotID(ig0) > 0 ) cycle
154  ig = fstrsolid%VELOCITY_ngrp_ID(ig0)
155  grpid = fstrsolid%VELOCITY_ngrp_GRPID(ig0)
156  if( .not. fstr_isboundaryactive( fstrsolid, grpid, cstep ) ) cycle
157  rhs = fstrsolid%VELOCITY_ngrp_val(ig0)
158 
159  call fstr_get_amplitude_dyn(hecmesh, fstrsolid, fstrdynamic, ig0, t_curr, rhs, flag_u)
160  rhs0 = rhs
161 
162  ityp = fstrsolid%VELOCITY_ngrp_type(ig0)
163 
164  idofs = ityp/10
165  idofe = ityp - idofs*10
166 
167  is0 = hecmesh%node_group%grp_index(ig-1) + 1
168  ie0 = hecmesh%node_group%grp_index(ig )
169 
170  do ik = is0, ie0
171  in = hecmesh%node_group%grp_item(ik)
172  do idof = idofs, idofe
173 
174  if( present(iter) ) then ! increment
175  if( iter>1 ) then
176  rhs = 0.d0
177  else
178  rhs = &
179  + b2*fstrdynamic%VEL (ndof*in-(ndof-idof),1) &
180  + b3*fstrdynamic%ACC (ndof*in-(ndof-idof),1) &
181  + b4*rhs0
182  endif
183  else
184  rhs = fstrdynamic%DISP(ndof*in-(ndof-idof),1) &
185  + b2*fstrdynamic%VEL (ndof*in-(ndof-idof),1) &
186  + b3*fstrdynamic%ACC (ndof*in-(ndof-idof),1) &
187  + b4*rhs0
188  endif
189  call hecmw_ebc_set(hecebc, in, idof, rhs)
190  if( fstr_is_contact_active() .and. fstrparam%contact_algo == kcaslagrange &
191  .and. fstrparam%nlgeom .and. fstrdynamic%idx_resp == 1 ) then
192  if(present(conmat)) then
193  call hecmw_mat_ass_bc_contactlag(conmat,heclagmat,in,idof,rhs)
194  else
195  call hecmw_mat_ass_bc_contactlag(hecmat,heclagmat,in,idof,rhs)
196  endif
197  endif
198  enddo
199  enddo
200  enddo
201 
202  !C-- rotational velocity boundary condition (implicit)
203  do rid = 1, n_rot
204  if( .not. rinfo%conds(rid)%active ) cycle
205  omega(1:3) = rinfo%conds(rid)%vec(1:3)
206  call get_rotcenter_coord(hecmesh, fstrsolid, rinfo%conds(rid)%center_ngrp_id, ndof, ccoord)
207  ig = rinfo%conds(rid)%torque_ngrp_id
208  is0 = hecmesh%node_group%grp_index(ig-1) + 1
209  ie0 = hecmesh%node_group%grp_index(ig )
210  do ik = is0, ie0
211  in = hecmesh%node_group%grp_item(ik)
212  cdiff = 0.d0
213  cdiff(1:ndof) = hecmesh%node(ndof*(in-1)+1:ndof*in) &
214  + fstrsolid%unode(ndof*(in-1)+1:ndof*in) - ccoord(1:ndof)
215  call cross_product(omega, cdiff, vnode) ! v = omega x (x - x_center)
216  do idof = 1, ndof
217  if( present(iter) ) then
218  if( iter>1 ) then
219  rhs = 0.d0
220  else
221  rhs = b2*fstrdynamic%VEL(ndof*in-(ndof-idof),1) &
222  + b3*fstrdynamic%ACC(ndof*in-(ndof-idof),1) &
223  + b4*vnode(idof)
224  endif
225  else
226  rhs = fstrdynamic%DISP(ndof*in-(ndof-idof),1) &
227  + b2*fstrdynamic%VEL(ndof*in-(ndof-idof),1) &
228  + b3*fstrdynamic%ACC(ndof*in-(ndof-idof),1) &
229  + b4*vnode(idof)
230  endif
231  call hecmw_ebc_set(hecebc, in, idof, rhs)
232  if( fstr_is_contact_active() .and. fstrparam%contact_algo == kcaslagrange &
233  .and. fstrparam%nlgeom .and. fstrdynamic%idx_resp == 1 ) then
234  if(present(conmat)) then
235  call hecmw_mat_ass_bc_contactlag(conmat,heclagmat,in,idof,rhs)
236  else
237  call hecmw_mat_ass_bc_contactlag(hecmat,heclagmat,in,idof,rhs)
238  endif
239  endif
240  enddo
241  enddo
242  enddo
243  !C
244  !C-- end of implicit dynamic analysis
245  !C
246 
247  !C=============================C
248  !C-- explicit dynamic analysis
249  !C=============================C
250  else if( fstrdynamic%idx_eqa == 11 ) then
251  !C
252  do ig0 = 1, fstrsolid%VELOCITY_ngrp_tot
253  if( fstrsolid%VELOCITY_ngrp_rotID(ig0) > 0 ) cycle
254  ig = fstrsolid%VELOCITY_ngrp_ID(ig0)
255  rhs = fstrsolid%VELOCITY_ngrp_val(ig0)
256 
257  call fstr_get_amplitude_dyn(hecmesh, fstrsolid, fstrdynamic, ig0, t_curr, rhs, flag_u)
258  rhs0 = rhs
259 
260  ityp = fstrsolid%VELOCITY_ngrp_type(ig0)
261 
262  is0 = hecmesh%node_group%grp_index(ig-1) + 1
263  ie0 = hecmesh%node_group%grp_index(ig )
264  idofs = ityp/10
265  idofe = ityp - idofs*10
266 
267  do ik = is0, ie0
268  in = hecmesh%node_group%grp_item(ik)
269  do idof = idofs, idofe
270  rhs = fstrdynamic%DISP(ndof*in-(ndof-idof),3) &
271  + c1*rhs0
272  hecmat%B (ndof*in-(ndof-idof)) = rhs
273  fstrdynamic%VEC1(ndof*in-(ndof-idof)) = 1.0d0
274  end do
275  enddo
276  enddo
277 
278  !C-- rotational velocity boundary condition (explicit)
279  do rid = 1, n_rot
280  if( .not. rinfo%conds(rid)%active ) cycle
281  omega(1:3) = rinfo%conds(rid)%vec(1:3)
282  call get_rotcenter_coord(hecmesh, fstrsolid, rinfo%conds(rid)%center_ngrp_id, ndof, ccoord)
283  ig = rinfo%conds(rid)%torque_ngrp_id
284  is0 = hecmesh%node_group%grp_index(ig-1) + 1
285  ie0 = hecmesh%node_group%grp_index(ig )
286  do ik = is0, ie0
287  in = hecmesh%node_group%grp_item(ik)
288  cdiff = 0.d0
289  cdiff(1:ndof) = hecmesh%node(ndof*(in-1)+1:ndof*in) &
290  + fstrsolid%unode(ndof*(in-1)+1:ndof*in) - ccoord(1:ndof)
291  call cross_product(omega, cdiff, vnode)
292  do idof = 1, ndof
293  rhs = fstrdynamic%DISP(ndof*in-(ndof-idof),3) + c1*vnode(idof)
294  hecmat%B (ndof*in-(ndof-idof)) = rhs
295  fstrdynamic%VEC1(ndof*in-(ndof-idof)) = 1.0d0
296  enddo
297  enddo
298  enddo
299  !C
300  !C-- end of explicit dynamic analysis
301  !C
302  end if
303  !
304  if( n_rot > 0 ) call fstr_rotinfo_finalize(rinfo)
305 
306  return
307  end subroutine dynamic_mat_ass_bc_vl
308 
309 
310  !C***
312  !C***
313  subroutine dynamic_bc_init_vl(hecMESH, hecMAT, fstrSOLID ,fstrDYNAMIC, t_curr)
314  use m_fstr
315  use m_table_dyn
316  use m_utilities
317 
318  implicit none
319  type(hecmwst_matrix) :: hecmat
320  type(hecmwst_local_mesh) :: hecMESH
321  type(fstr_solid) :: fstrSOLID
322  type(fstr_dynamic) :: fstrDYNAMIC
323 
324  integer(kind=kint) :: NDOF, ig0, ig, ityp, iS0, iE0, ik, in, idofS, idofE, idof
325 
326  integer(kind=kint) :: flag_u, grpid
327  real(kind=kreal) :: rhs, t_curr
328 
329  !for rotation
330  integer(kind=kint) :: n_rot, rid
331  type(trotinfo) :: rinfo
332  real(kind=kreal) :: ccoord(3), cdiff(3), vnode(3), omega(3)
333 
334  if( fstrsolid%VELOCITY_type == kbctransit )return
335 
336  flag_u = 2
337  ndof = hecmat%NDOF
338 
339  n_rot = fstrsolid%VELOCITY_ngrp_rot
340  if( n_rot > 0 ) then
341  call fstr_rotinfo_init(n_rot, rinfo)
342  call gather_rotvel_info(hecmesh, fstrsolid, fstrdynamic, t_curr, ndof, rinfo, 1)
343  endif
344 
345  do ig0 = 1, fstrsolid%VELOCITY_ngrp_tot
346  if( fstrsolid%VELOCITY_ngrp_rotID(ig0) > 0 ) cycle
347  ig = fstrsolid%VELOCITY_ngrp_ID(ig0)
348  rhs = fstrsolid%VELOCITY_ngrp_val(ig0)
349  grpid = fstrsolid%VELOCITY_ngrp_GRPID(ig0)
350  if( .not. fstr_isboundaryactive( fstrsolid, grpid, 1 ) ) cycle
351 
352  call fstr_get_amplitude_dyn(hecmesh, fstrsolid, fstrdynamic, ig0, t_curr, rhs, flag_u)
353 
354  ityp = fstrsolid%VELOCITY_ngrp_type(ig0)
355 
356  is0 = hecmesh%node_group%grp_index(ig-1) + 1
357  ie0 = hecmesh%node_group%grp_index(ig )
358  idofs = ityp/10
359  idofe = ityp - idofs*10
360 
361  do ik = is0, ie0
362  in = hecmesh%node_group%grp_item(ik)
363 
364  do idof = idofs, idofe
365  fstrdynamic%VEL (ndof*in-(ndof-idof),1) = rhs
366  end do
367  enddo
368  enddo
369 
370  !C-- rotational velocity initial condition
371  do rid = 1, n_rot
372  if( .not. rinfo%conds(rid)%active ) cycle
373  omega(1:3) = rinfo%conds(rid)%vec(1:3)
374  call get_rotcenter_coord(hecmesh, fstrsolid, rinfo%conds(rid)%center_ngrp_id, ndof, ccoord)
375  ig = rinfo%conds(rid)%torque_ngrp_id
376  is0 = hecmesh%node_group%grp_index(ig-1) + 1
377  ie0 = hecmesh%node_group%grp_index(ig )
378  do ik = is0, ie0
379  in = hecmesh%node_group%grp_item(ik)
380  cdiff = 0.d0
381  cdiff(1:ndof) = hecmesh%node(ndof*(in-1)+1:ndof*in) &
382  + fstrsolid%unode(ndof*(in-1)+1:ndof*in) - ccoord(1:ndof)
383  call cross_product(omega, cdiff, vnode)
384  do idof = 1, ndof
385  fstrdynamic%VEL (ndof*in-(ndof-idof),1) = vnode(idof)
386  enddo
387  enddo
388  enddo
389 
390  if( n_rot > 0 ) call fstr_rotinfo_finalize(rinfo)
391 
392  return
393  end subroutine dynamic_bc_init_vl
394 
395  subroutine dynamic_explicit_ass_vl(hecMESH, hecMAT, fstrSOLID, fstrDYNAMIC, t_curr, iter)
396  use m_fstr
397  use m_table_dyn
398  use mcontact
399  use m_utilities
400 
401  implicit none
402  type(hecmwst_matrix) :: hecmat
403  type(hecmwst_local_mesh) :: hecMESH
404  type(fstr_solid) :: fstrSOLID
405  type(fstr_dynamic) :: fstrDYNAMIC
406  real(kind=kreal) :: t_curr
407  integer, optional :: iter
408 
409  integer(kind=kint) :: ig0, ig, ityp, NDOF, iS0, iE0, ik, in, idofS, idofE, idof
410  integer(kind=kint) :: flag_u
411  real(kind=kreal) :: b2, b3, b4, c1
412  real(kind=kreal) :: rhs, rhs0
413 
414  !for rotation
415  integer(kind=kint) :: n_rot, rid
416  type(trotinfo) :: rinfo
417  real(kind=kreal) :: ccoord(3), cdiff(3), vnode(3), omega(3)
418 
419  if( fstrsolid%VELOCITY_type == kbcinitial )return
420 
421  flag_u = 2
422 
423  if(dabs(fstrdynamic%gamma) .lt. 1.0e-20) then
424  if( hecmesh%my_rank == 0 ) then
425  write(imsg,*) 'stop due to fstrDYNAMIC%gamma = 0'
426  end if
427  call hecmw_abort( hecmw_comm_get_comm())
428  end if
429 
430  b2 = fstrdynamic%t_delta &
431  *(fstrdynamic%gamma-fstrdynamic%beta)/fstrdynamic%gamma
432  b3 = fstrdynamic%t_delta**2 &
433  *(fstrdynamic%gamma-2.0*fstrdynamic%beta) &
434  /(2.0*fstrdynamic%gamma)
435  b4 = fstrdynamic%t_delta*fstrdynamic%beta/fstrdynamic%gamma
436  c1 = 2.0*fstrdynamic%t_delta
437 
438  ndof = hecmat%NDOF
439 
440  n_rot = fstrsolid%VELOCITY_ngrp_rot
441  if( n_rot > 0 ) then
442  call fstr_rotinfo_init(n_rot, rinfo)
443  call gather_rotvel_info(hecmesh, fstrsolid, fstrdynamic, t_curr, ndof, rinfo)
444  endif
445 
446  !C
447  do ig0 = 1, fstrsolid%VELOCITY_ngrp_tot
448  if( fstrsolid%VELOCITY_ngrp_rotID(ig0) > 0 ) cycle
449  ig = fstrsolid%VELOCITY_ngrp_ID(ig0)
450  rhs = fstrsolid%VELOCITY_ngrp_val(ig0)
451 
452  call fstr_get_amplitude_dyn(hecmesh, fstrsolid, fstrdynamic, ig0, t_curr, rhs, flag_u)
453  rhs0 = rhs
454 
455  ityp = fstrsolid%VELOCITY_ngrp_type(ig0)
456 
457  is0 = hecmesh%node_group%grp_index(ig-1) + 1
458  ie0 = hecmesh%node_group%grp_index(ig )
459  idofs = ityp/10
460  idofe = ityp - idofs*10
461 
462  do ik = is0, ie0
463  in = hecmesh%node_group%grp_item(ik)
464  do idof = idofs, idofe
465  rhs = fstrdynamic%DISP(ndof*in-(ndof-idof),3) &
466  + c1*rhs0
467  hecmat%B(ndof*in-(ndof-idof)) = rhs* fstrdynamic%VEC1(ndof*in-(ndof-idof))
468  ! fstrDYNAMIC%VEC1(NDOF*in-(NDOF-idof)) = 1.0d0
469  end do
470  enddo
471  enddo
472 
473  !C-- rotational velocity boundary condition (explicit)
474  do rid = 1, n_rot
475  if( .not. rinfo%conds(rid)%active ) cycle
476  omega(1:3) = rinfo%conds(rid)%vec(1:3)
477  call get_rotcenter_coord(hecmesh, fstrsolid, rinfo%conds(rid)%center_ngrp_id, ndof, ccoord)
478  ig = rinfo%conds(rid)%torque_ngrp_id
479  is0 = hecmesh%node_group%grp_index(ig-1) + 1
480  ie0 = hecmesh%node_group%grp_index(ig )
481  do ik = is0, ie0
482  in = hecmesh%node_group%grp_item(ik)
483  cdiff = 0.d0
484  cdiff(1:ndof) = hecmesh%node(ndof*(in-1)+1:ndof*in) &
485  + fstrsolid%unode(ndof*(in-1)+1:ndof*in) - ccoord(1:ndof)
486  call cross_product(omega, cdiff, vnode)
487  do idof = 1, ndof
488  rhs = fstrdynamic%DISP(ndof*in-(ndof-idof),3) + c1*vnode(idof)
489  hecmat%B(ndof*in-(ndof-idof)) = rhs* fstrdynamic%VEC1(ndof*in-(ndof-idof))
490  enddo
491  enddo
492  enddo
493 
494  if( n_rot > 0 ) call fstr_rotinfo_finalize(rinfo)
495 
496  end subroutine dynamic_explicit_ass_vl
497 
498 end module m_dynamic_mat_ass_bc_vl
hecmw_ebc_defer
Essential boundary conditions kept as per-DOF marks and values so that they can be imposed on the mat...
Definition: hecmw_ebc_defer.f90:8
hecmw_ebc_defer::hecmw_ebc_set
subroutine, public hecmw_ebc_set(hecEBC, inode, idof, val)
Definition: hecmw_ebc_defer.f90:54
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_dynamic_mat_ass_bc_vl::get_rotcenter_coord
subroutine get_rotcenter_coord(hecMESH, fstrSOLID, ig, ndof, ccoord)
Return the current-configuration coordinate of the rotation center node group.
Definition: dynamic_mat_ass_bc_vl.f90:65
m_dynamic_mat_ass_bc_vl::dynamic_explicit_ass_vl
subroutine dynamic_explicit_ass_vl(hecMESH, hecMAT, fstrSOLID, fstrDYNAMIC, t_curr, iter)
Definition: dynamic_mat_ass_bc_vl.f90:396
m_dynamic_mat_ass_bc_vl::dynamic_bc_init_vl
subroutine dynamic_bc_init_vl(hecMESH, hecMAT, fstrSOLID, fstrDYNAMIC, t_curr)
This function sets initial condition of velocity.
Definition: dynamic_mat_ass_bc_vl.f90:314
m_dynamic_mat_ass_bc_vl::dynamic_mat_ass_bc_vl
subroutine dynamic_mat_ass_bc_vl(cstep, hecMESH, hecMAT, fstrSOLID, fstrDYNAMIC, fstrPARAM, hecLagMAT, hecEBC, t_curr, iter, conMAT)
This subrouitne set velocity boundary condition in dynamic analysis.
Definition: dynamic_mat_ass_bc_vl.f90:90
m_dynamic_mat_ass_bc_vl::gather_rotvel_info
subroutine gather_rotvel_info(hecMESH, fstrSOLID, fstrDYNAMIC, t_curr, ndof, rinfo, cstep)
Gather rotational velocity information (!VELOCITY, ROT_CENTER=) into rinfo. For each velocity BC with...
Definition: dynamic_mat_ass_bc_vl.f90:15
m_fstr
This module defines common data and basic structures for analysis.
Definition: m_fstr.F90:15
m_fstr::imsg
integer(kind=kint), parameter imsg
Definition: m_fstr.F90:121
m_fstr::kcaslagrange
integer(kind=kint), parameter kcaslagrange
contact analysis algorithm
Definition: m_fstr.F90:62
m_fstr::kbcinitial
integer(kind=kint), parameter kbcinitial
Definition: m_fstr.F90:69
m_fstr::kbctransit
integer(kind=kint), parameter kbctransit
Definition: m_fstr.F90:70
m_fstr::fstr_isboundaryactive
logical function fstr_isboundaryactive(fstrSOLID, nbc, cstep)
Definition: m_fstr.F90:1252
m_table_dyn
Amplitude evaluation for loading conditions in dynamic analysis.
Definition: table_dyn.f90:6
m_table_dyn::fstr_get_amplitude_dyn
subroutine fstr_get_amplitude_dyn(hecMESH, fstrSOLID, fstrDYNAMIC, ig0, t_curr, value, flag_u)
Evaluate the amplitude-scaled target value a(t) for dynamic analysis.
Definition: table_dyn.f90:28
m_utilities
This module provides aux functions.
Definition: utilities.f90:6
m_utilities::cross_product
subroutine cross_product(v1, v2, vn)
Definition: utilities.f90:383
mcontact
Top-level contact analysis module (System level)
Definition: fstr_contact.f90:33
mcontact::fstr_is_contact_active
logical function fstr_is_contact_active()
Whether contact stiffness and residual have to be assembled. Broader than is_contact_active(state): a...
Definition: fstr_contact.f90:428
m_fstr::fstr_dynamic
Data for DYNAMIC ANSLYSIS (fstrDYNAMIC)
Definition: m_fstr.F90:525
m_fstr::fstr_param
FSTR INNER CONTROL PARAMETERS (fstrPARAM)
Definition: m_fstr.F90:142
m_fstr::fstr_solid
Definition: m_fstr.F90:230