FrontISTR  5.9.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, t_curr, iter, conMAT)
89  use m_fstr
90  use m_table_dyn
91  use mcontact
92  use m_utilities
93 
94  implicit none
95  integer(kind=kint) :: cstep
96  type(hecmwst_matrix) :: hecMAT
97  type(hecmwst_local_mesh) :: hecMESH
98  type(fstr_solid) :: fstrSOLID
99  type(fstr_dynamic) :: fstrDYNAMIC
100  type(fstr_param) :: fstrPARAM
101  type(hecmwst_matrix_lagrange) :: hecLagMAT
102  real(kind=kreal) :: t_curr
103  type(hecmwst_matrix), optional :: conmat
104 
105  integer, optional :: iter
106 
107  integer(kind=kint) :: ig0, ig, ityp, ndof, is0, ie0, ik, in, idofs, idofe, idof
108  integer(kind=kint) :: flag_u, grpid
109  real(kind=kreal) :: b2, b3, b4, c1
110  real(kind=kreal) :: rhs, rhs0, f_t
111 
112  !for rotation
113  integer(kind=kint) :: n_rot, rid
114  type(trotinfo) :: rinfo
115  real(kind=kreal) :: ccoord(3), cdiff(3), vnode(3), omega(3)
116 
117  if( fstrsolid%VELOCITY_type == kbcinitial )return
118 
119  flag_u = 2
120 
121  if(dabs(fstrdynamic%gamma) .lt. 1.0e-20) then
122  if( hecmesh%my_rank == 0 ) then
123  write(imsg,*) 'stop due to fstrDYNAMIC%gamma = 0'
124  end if
125  call hecmw_abort( hecmw_comm_get_comm())
126  end if
127 
128  b2 = fstrdynamic%t_delta &
129  *(fstrdynamic%gamma-fstrdynamic%beta)/fstrdynamic%gamma
130  b3 = fstrdynamic%t_delta**2 &
131  *(fstrdynamic%gamma-2.0*fstrdynamic%beta) &
132  /(2.0*fstrdynamic%gamma)
133  b4 = fstrdynamic%t_delta*fstrdynamic%beta/fstrdynamic%gamma
134  c1 = 2.0*fstrdynamic%t_delta
135 
136  ndof = hecmat%NDOF
137 
138  n_rot = fstrsolid%VELOCITY_ngrp_rot
139  if( n_rot > 0 ) then
140  call fstr_rotinfo_init(n_rot, rinfo)
141  call gather_rotvel_info(hecmesh, fstrsolid, fstrdynamic, t_curr, ndof, rinfo, cstep)
142  endif
143 
144  !C=============================C
145  !C-- implicit dynamic analysis
146  !C=============================C
147  if( fstrdynamic%idx_eqa == 1 ) then
148 
149  do ig0 = 1, fstrsolid%VELOCITY_ngrp_tot
150  if( fstrsolid%VELOCITY_ngrp_rotID(ig0) > 0 ) cycle
151  ig = fstrsolid%VELOCITY_ngrp_ID(ig0)
152  grpid = fstrsolid%VELOCITY_ngrp_GRPID(ig0)
153  if( .not. fstr_isboundaryactive( fstrsolid, grpid, cstep ) ) cycle
154  rhs = fstrsolid%VELOCITY_ngrp_val(ig0)
155 
156  call fstr_get_amplitude_dyn(hecmesh, fstrsolid, fstrdynamic, ig0, t_curr, rhs, flag_u)
157  rhs0 = rhs
158 
159  ityp = fstrsolid%VELOCITY_ngrp_type(ig0)
160 
161  idofs = ityp/10
162  idofe = ityp - idofs*10
163 
164  is0 = hecmesh%node_group%grp_index(ig-1) + 1
165  ie0 = hecmesh%node_group%grp_index(ig )
166 
167  do ik = is0, ie0
168  in = hecmesh%node_group%grp_item(ik)
169  do idof = idofs, idofe
170 
171  if( present(iter) ) then ! increment
172  if( iter>1 ) then
173  rhs = 0.d0
174  else
175  rhs = &
176  + b2*fstrdynamic%VEL (ndof*in-(ndof-idof),1) &
177  + b3*fstrdynamic%ACC (ndof*in-(ndof-idof),1) &
178  + b4*rhs0
179  endif
180  else
181  rhs = fstrdynamic%DISP(ndof*in-(ndof-idof),1) &
182  + b2*fstrdynamic%VEL (ndof*in-(ndof-idof),1) &
183  + b3*fstrdynamic%ACC (ndof*in-(ndof-idof),1) &
184  + b4*rhs0
185  endif
186  if(present(conmat)) then
187  call hecmw_mat_ass_bc(hecmat, in, idof, rhs, conmat)
188  else
189  call hecmw_mat_ass_bc(hecmat, in, idof, rhs)
190  endif
191  if( fstr_is_contact_active() .and. fstrparam%contact_algo == kcaslagrange &
192  .and. fstrparam%nlgeom .and. fstrdynamic%idx_resp == 1 ) then
193  if(present(conmat)) then
194  call hecmw_mat_ass_bc_contactlag(conmat,heclagmat,in,idof,rhs)
195  else
196  call hecmw_mat_ass_bc_contactlag(hecmat,heclagmat,in,idof,rhs)
197  endif
198  endif
199  enddo
200  enddo
201  enddo
202 
203  !C-- rotational velocity boundary condition (implicit)
204  do rid = 1, n_rot
205  if( .not. rinfo%conds(rid)%active ) cycle
206  omega(1:3) = rinfo%conds(rid)%vec(1:3)
207  call get_rotcenter_coord(hecmesh, fstrsolid, rinfo%conds(rid)%center_ngrp_id, ndof, ccoord)
208  ig = rinfo%conds(rid)%torque_ngrp_id
209  is0 = hecmesh%node_group%grp_index(ig-1) + 1
210  ie0 = hecmesh%node_group%grp_index(ig )
211  do ik = is0, ie0
212  in = hecmesh%node_group%grp_item(ik)
213  cdiff = 0.d0
214  cdiff(1:ndof) = hecmesh%node(ndof*(in-1)+1:ndof*in) &
215  + fstrsolid%unode(ndof*(in-1)+1:ndof*in) - ccoord(1:ndof)
216  call cross_product(omega, cdiff, vnode) ! v = omega x (x - x_center)
217  do idof = 1, ndof
218  if( present(iter) ) then
219  if( iter>1 ) then
220  rhs = 0.d0
221  else
222  rhs = b2*fstrdynamic%VEL(ndof*in-(ndof-idof),1) &
223  + b3*fstrdynamic%ACC(ndof*in-(ndof-idof),1) &
224  + b4*vnode(idof)
225  endif
226  else
227  rhs = fstrdynamic%DISP(ndof*in-(ndof-idof),1) &
228  + b2*fstrdynamic%VEL(ndof*in-(ndof-idof),1) &
229  + b3*fstrdynamic%ACC(ndof*in-(ndof-idof),1) &
230  + b4*vnode(idof)
231  endif
232  if(present(conmat)) then
233  call hecmw_mat_ass_bc(hecmat, in, idof, rhs, conmat)
234  else
235  call hecmw_mat_ass_bc(hecmat, in, idof, rhs)
236  endif
237  if( fstr_is_contact_active() .and. fstrparam%contact_algo == kcaslagrange &
238  .and. fstrparam%nlgeom .and. fstrdynamic%idx_resp == 1 ) then
239  if(present(conmat)) then
240  call hecmw_mat_ass_bc_contactlag(conmat,heclagmat,in,idof,rhs)
241  else
242  call hecmw_mat_ass_bc_contactlag(hecmat,heclagmat,in,idof,rhs)
243  endif
244  endif
245  enddo
246  enddo
247  enddo
248  !C
249  !C-- end of implicit dynamic analysis
250  !C
251 
252  !C=============================C
253  !C-- explicit dynamic analysis
254  !C=============================C
255  else if( fstrdynamic%idx_eqa == 11 ) then
256  !C
257  do ig0 = 1, fstrsolid%VELOCITY_ngrp_tot
258  if( fstrsolid%VELOCITY_ngrp_rotID(ig0) > 0 ) cycle
259  ig = fstrsolid%VELOCITY_ngrp_ID(ig0)
260  rhs = fstrsolid%VELOCITY_ngrp_val(ig0)
261 
262  call fstr_get_amplitude_dyn(hecmesh, fstrsolid, fstrdynamic, ig0, t_curr, rhs, flag_u)
263  rhs0 = rhs
264 
265  ityp = fstrsolid%VELOCITY_ngrp_type(ig0)
266 
267  is0 = hecmesh%node_group%grp_index(ig-1) + 1
268  ie0 = hecmesh%node_group%grp_index(ig )
269  idofs = ityp/10
270  idofe = ityp - idofs*10
271 
272  do ik = is0, ie0
273  in = hecmesh%node_group%grp_item(ik)
274  do idof = idofs, idofe
275  rhs = fstrdynamic%DISP(ndof*in-(ndof-idof),3) &
276  + c1*rhs0
277  hecmat%B (ndof*in-(ndof-idof)) = rhs
278  fstrdynamic%VEC1(ndof*in-(ndof-idof)) = 1.0d0
279  end do
280  enddo
281  enddo
282 
283  !C-- rotational velocity boundary condition (explicit)
284  do rid = 1, n_rot
285  if( .not. rinfo%conds(rid)%active ) cycle
286  omega(1:3) = rinfo%conds(rid)%vec(1:3)
287  call get_rotcenter_coord(hecmesh, fstrsolid, rinfo%conds(rid)%center_ngrp_id, ndof, ccoord)
288  ig = rinfo%conds(rid)%torque_ngrp_id
289  is0 = hecmesh%node_group%grp_index(ig-1) + 1
290  ie0 = hecmesh%node_group%grp_index(ig )
291  do ik = is0, ie0
292  in = hecmesh%node_group%grp_item(ik)
293  cdiff = 0.d0
294  cdiff(1:ndof) = hecmesh%node(ndof*(in-1)+1:ndof*in) &
295  + fstrsolid%unode(ndof*(in-1)+1:ndof*in) - ccoord(1:ndof)
296  call cross_product(omega, cdiff, vnode)
297  do idof = 1, ndof
298  rhs = fstrdynamic%DISP(ndof*in-(ndof-idof),3) + c1*vnode(idof)
299  hecmat%B (ndof*in-(ndof-idof)) = rhs
300  fstrdynamic%VEC1(ndof*in-(ndof-idof)) = 1.0d0
301  enddo
302  enddo
303  enddo
304  !C
305  !C-- end of explicit dynamic analysis
306  !C
307  end if
308  !
309  if( n_rot > 0 ) call fstr_rotinfo_finalize(rinfo)
310 
311  return
312  end subroutine dynamic_mat_ass_bc_vl
313 
314 
315  !C***
317  !C***
318  subroutine dynamic_bc_init_vl(hecMESH, hecMAT, fstrSOLID ,fstrDYNAMIC, t_curr)
319  use m_fstr
320  use m_table_dyn
321  use m_utilities
322 
323  implicit none
324  type(hecmwst_matrix) :: hecmat
325  type(hecmwst_local_mesh) :: hecMESH
326  type(fstr_solid) :: fstrSOLID
327  type(fstr_dynamic) :: fstrDYNAMIC
328 
329  integer(kind=kint) :: NDOF, ig0, ig, ityp, iS0, iE0, ik, in, idofS, idofE, idof
330 
331  integer(kind=kint) :: flag_u, grpid
332  real(kind=kreal) :: rhs, f_t, t_curr
333 
334  !for rotation
335  integer(kind=kint) :: n_rot, rid
336  type(trotinfo) :: rinfo
337  real(kind=kreal) :: ccoord(3), cdiff(3), vnode(3), omega(3)
338 
339  if( fstrsolid%VELOCITY_type == kbctransit )return
340 
341  flag_u = 2
342  ndof = hecmat%NDOF
343 
344  n_rot = fstrsolid%VELOCITY_ngrp_rot
345  if( n_rot > 0 ) then
346  call fstr_rotinfo_init(n_rot, rinfo)
347  call gather_rotvel_info(hecmesh, fstrsolid, fstrdynamic, t_curr, ndof, rinfo, 1)
348  endif
349 
350  do ig0 = 1, fstrsolid%VELOCITY_ngrp_tot
351  if( fstrsolid%VELOCITY_ngrp_rotID(ig0) > 0 ) cycle
352  ig = fstrsolid%VELOCITY_ngrp_ID(ig0)
353  rhs = fstrsolid%VELOCITY_ngrp_val(ig0)
354  grpid = fstrsolid%VELOCITY_ngrp_GRPID(ig0)
355  if( .not. fstr_isboundaryactive( fstrsolid, grpid, 1 ) ) cycle
356 
357  call fstr_get_amplitude_dyn(hecmesh, fstrsolid, fstrdynamic, ig0, t_curr, rhs, flag_u)
358 
359  ityp = fstrsolid%VELOCITY_ngrp_type(ig0)
360 
361  is0 = hecmesh%node_group%grp_index(ig-1) + 1
362  ie0 = hecmesh%node_group%grp_index(ig )
363  idofs = ityp/10
364  idofe = ityp - idofs*10
365 
366  do ik = is0, ie0
367  in = hecmesh%node_group%grp_item(ik)
368 
369  do idof = idofs, idofe
370  fstrdynamic%VEL (ndof*in-(ndof-idof),1) = rhs
371  end do
372  enddo
373  enddo
374 
375  !C-- rotational velocity initial condition
376  do rid = 1, n_rot
377  if( .not. rinfo%conds(rid)%active ) cycle
378  omega(1:3) = rinfo%conds(rid)%vec(1:3)
379  call get_rotcenter_coord(hecmesh, fstrsolid, rinfo%conds(rid)%center_ngrp_id, ndof, ccoord)
380  ig = rinfo%conds(rid)%torque_ngrp_id
381  is0 = hecmesh%node_group%grp_index(ig-1) + 1
382  ie0 = hecmesh%node_group%grp_index(ig )
383  do ik = is0, ie0
384  in = hecmesh%node_group%grp_item(ik)
385  cdiff = 0.d0
386  cdiff(1:ndof) = hecmesh%node(ndof*(in-1)+1:ndof*in) &
387  + fstrsolid%unode(ndof*(in-1)+1:ndof*in) - ccoord(1:ndof)
388  call cross_product(omega, cdiff, vnode)
389  do idof = 1, ndof
390  fstrdynamic%VEL (ndof*in-(ndof-idof),1) = vnode(idof)
391  enddo
392  enddo
393  enddo
394 
395  if( n_rot > 0 ) call fstr_rotinfo_finalize(rinfo)
396 
397  return
398  end subroutine dynamic_bc_init_vl
399 
400  subroutine dynamic_explicit_ass_vl(hecMESH, hecMAT, fstrSOLID, fstrDYNAMIC, t_curr, iter)
401  use m_fstr
402  use m_table_dyn
403  use mcontact
404  use m_utilities
405 
406  implicit none
407  type(hecmwst_matrix) :: hecmat
408  type(hecmwst_local_mesh) :: hecMESH
409  type(fstr_solid) :: fstrSOLID
410  type(fstr_dynamic) :: fstrDYNAMIC
411  real(kind=kreal) :: t_curr
412  integer, optional :: iter
413 
414  integer(kind=kint) :: ig0, ig, ityp, NDOF, iS0, iE0, ik, in, idofS, idofE, idof
415  integer(kind=kint) :: flag_u
416  real(kind=kreal) :: b2, b3, b4, c1
417  real(kind=kreal) :: rhs, rhs0, f_t
418 
419  !for rotation
420  integer(kind=kint) :: n_rot, rid
421  type(trotinfo) :: rinfo
422  real(kind=kreal) :: ccoord(3), cdiff(3), vnode(3), omega(3)
423 
424  if( fstrsolid%VELOCITY_type == kbcinitial )return
425 
426  flag_u = 2
427 
428  if(dabs(fstrdynamic%gamma) .lt. 1.0e-20) then
429  if( hecmesh%my_rank == 0 ) then
430  write(imsg,*) 'stop due to fstrDYNAMIC%gamma = 0'
431  end if
432  call hecmw_abort( hecmw_comm_get_comm())
433  end if
434 
435  b2 = fstrdynamic%t_delta &
436  *(fstrdynamic%gamma-fstrdynamic%beta)/fstrdynamic%gamma
437  b3 = fstrdynamic%t_delta**2 &
438  *(fstrdynamic%gamma-2.0*fstrdynamic%beta) &
439  /(2.0*fstrdynamic%gamma)
440  b4 = fstrdynamic%t_delta*fstrdynamic%beta/fstrdynamic%gamma
441  c1 = 2.0*fstrdynamic%t_delta
442 
443  ndof = hecmat%NDOF
444 
445  n_rot = fstrsolid%VELOCITY_ngrp_rot
446  if( n_rot > 0 ) then
447  call fstr_rotinfo_init(n_rot, rinfo)
448  call gather_rotvel_info(hecmesh, fstrsolid, fstrdynamic, t_curr, ndof, rinfo)
449  endif
450 
451  !C
452  do ig0 = 1, fstrsolid%VELOCITY_ngrp_tot
453  if( fstrsolid%VELOCITY_ngrp_rotID(ig0) > 0 ) cycle
454  ig = fstrsolid%VELOCITY_ngrp_ID(ig0)
455  rhs = fstrsolid%VELOCITY_ngrp_val(ig0)
456 
457  call fstr_get_amplitude_dyn(hecmesh, fstrsolid, fstrdynamic, ig0, t_curr, rhs, flag_u)
458  rhs0 = rhs
459 
460  ityp = fstrsolid%VELOCITY_ngrp_type(ig0)
461 
462  is0 = hecmesh%node_group%grp_index(ig-1) + 1
463  ie0 = hecmesh%node_group%grp_index(ig )
464  idofs = ityp/10
465  idofe = ityp - idofs*10
466 
467  do ik = is0, ie0
468  in = hecmesh%node_group%grp_item(ik)
469  do idof = idofs, idofe
470  rhs = fstrdynamic%DISP(ndof*in-(ndof-idof),3) &
471  + c1*rhs0
472  hecmat%B(ndof*in-(ndof-idof)) = rhs* fstrdynamic%VEC1(ndof*in-(ndof-idof))
473  ! fstrDYNAMIC%VEC1(NDOF*in-(NDOF-idof)) = 1.0d0
474  end do
475  enddo
476  enddo
477 
478  !C-- rotational velocity boundary condition (explicit)
479  do rid = 1, n_rot
480  if( .not. rinfo%conds(rid)%active ) cycle
481  omega(1:3) = rinfo%conds(rid)%vec(1:3)
482  call get_rotcenter_coord(hecmesh, fstrsolid, rinfo%conds(rid)%center_ngrp_id, ndof, ccoord)
483  ig = rinfo%conds(rid)%torque_ngrp_id
484  is0 = hecmesh%node_group%grp_index(ig-1) + 1
485  ie0 = hecmesh%node_group%grp_index(ig )
486  do ik = is0, ie0
487  in = hecmesh%node_group%grp_item(ik)
488  cdiff = 0.d0
489  cdiff(1:ndof) = hecmesh%node(ndof*(in-1)+1:ndof*in) &
490  + fstrsolid%unode(ndof*(in-1)+1:ndof*in) - ccoord(1:ndof)
491  call cross_product(omega, cdiff, vnode)
492  do idof = 1, ndof
493  rhs = fstrdynamic%DISP(ndof*in-(ndof-idof),3) + c1*vnode(idof)
494  hecmat%B(ndof*in-(ndof-idof)) = rhs* fstrdynamic%VEC1(ndof*in-(ndof-idof))
495  enddo
496  enddo
497  enddo
498 
499  if( n_rot > 0 ) call fstr_rotinfo_finalize(rinfo)
500 
501  end subroutine dynamic_explicit_ass_vl
502 
503 end module m_dynamic_mat_ass_bc_vl
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:401
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:319
m_dynamic_mat_ass_bc_vl::dynamic_mat_ass_bc_vl
subroutine dynamic_mat_ass_bc_vl(cstep, hecMESH, hecMAT, fstrSOLID, fstrDYNAMIC, fstrPARAM, hecLagMAT, t_curr, iter, conMAT)
This subrouitne set velocity boundary condition in dynamic analysis.
Definition: dynamic_mat_ass_bc_vl.f90:89
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:113
m_fstr::kcaslagrange
integer(kind=kint), parameter kcaslagrange
contact analysis algorithm
Definition: m_fstr.F90:61
m_fstr::kbcinitial
integer(kind=kint), parameter kbcinitial
Definition: m_fstr.F90:68
m_fstr::kbctransit
integer(kind=kint), parameter kbctransit
Definition: m_fstr.F90:69
m_fstr::fstr_isboundaryactive
logical function fstr_isboundaryactive(fstrSOLID, nbc, cstep)
Definition: m_fstr.F90:1061
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:406
mcontact
Top-level contact analysis module (System level)
Definition: fstr_contact.f90:33
mcontact::fstr_is_contact_active
logical function fstr_is_contact_active()
Definition: fstr_contact.f90:349
m_fstr::fstr_dynamic
Data for DYNAMIC ANSLYSIS (fstrDYNAMIC)
Definition: m_fstr.F90:535
m_fstr::fstr_param
FSTR INNER CONTROL PARAMETERS (fstrPARAM)
Definition: m_fstr.F90:157
m_fstr::fstr_solid
Definition: m_fstr.F90:243