Functions/Subroutines
subroutine	make_system_position_lglnodes (nn_loc, local_node_num, cs_nnz_loc, cs_loc, xs_loc, ys_loc, zs_loc, nsdof, sys_label, x_system_lst, y_system_lst, z_system_lst, mpi_id, mpi_comm, mpi_np)
	Reads oscillator position from SYS.input, and finds to which local-LGL node it should be applied.

Function/Subroutine Documentation

◆ make_system_position_lglnodes()

subroutine make_system_position_lglnodes	(	integer*4	nn_loc,
		integer*4, dimension(nn_loc)	local_node_num,
		integer*4	cs_nnz_loc,
		integer*4, dimension(0:cs_nnz_loc)	cs_loc,
		real*8, dimension(nn_loc)	xs_loc,
		real*8, dimension(nn_loc)	ys_loc,
		real*8, dimension(nn_loc)	zs_loc,
		integer*4	nsdof,
		integer*4, dimension(nsdof)	sys_label,
		real*8, dimension(nsdof)	x_system_lst,
		real*8, dimension(nsdof)	y_system_lst,
		real*8, dimension(nsdof)	z_system_lst,
		integer*4	mpi_id,
		integer*4	mpi_comm,
		integer*4	mpi_np
	)

Reads oscillator position from SYS.input, and finds to which local-LGL node it should be applied.

Author: Ilario Mazzieri, Srihari Sangaraju

Date: February, 2022 Outputs: (directly saved in module variables of speed_par) locnode_buildID_map - For each local LGL node, has information about SDOFs that have to be applied at that location. node_counter_sdof - Number of partitions that are sharing LGL node corresponding to each SDOF Oscillator.

Definition at line 27 of file MAKE_SYSTEM_POSITION_LGLNODES.f90.

 
  use speed_par, only : locnode_buildid_map, node_counter_sdof
 
  implicit none
  
  include 'SPEED.MPI'
 
  integer*4 :: nn_loc, nsdof, cs_nnz_loc
  integer*4 :: mpi_np, mpi_id, mpi_comm, mpi_ierr
  integer*4 :: i, j, max_nsdof_per_node
  integer*4, dimension(0:cs_nnz_loc) :: cs_loc
  integer*4, dimension(nn_loc) :: node_counter_loc
  integer*4, dimension(nsdof) :: node_counter_sdof_dum
  integer*4, dimension(nsdof) :: node_sys_loc, sys_label, nearestnode_globnum, nearestnode_locnum
  integer*4, dimension(nsdof*mpi_np) :: node_sys_glo
  integer*4, dimension(nn_loc) :: local_node_num
 
  !integer*4, dimension(:,:), allocatable  :: locnode_buildID_map   !INTENT(OUT)
 
  real*8, dimension(nn_loc) :: xs_loc, ys_loc, zs_loc
  real*8, dimension(nsdof) :: x_system_lst, y_system_lst, z_system_lst
  real*8, dimension(nsdof) :: dist_system_loc
  real*8, dimension(nsdof*mpi_np) :: dist_system_glo
 
  node_counter_loc = 0
 
  ! Find if LGL_gob_num is inside the local partition
  ! Finding Nearest Node to SDOF Oscillator across all partitions - in Global Numeration
  do i = 1,nsdof
    call get_nearest_node(nn_loc, xs_loc, ys_loc, zs_loc, x_system_lst(i), y_system_lst(i), z_system_lst(i), &
                          node_sys_loc(i), dist_system_loc(i))
    node_sys_loc(i) = local_node_num(node_sys_loc(i))
  enddo
 
  call mpi_barrier(mpi_comm, mpi_ierr)
 
  call mpi_allgather(dist_system_loc, nsdof, speed_double, dist_system_glo, nsdof, speed_double, mpi_comm, mpi_ierr)
  call mpi_allgather(node_sys_loc, nsdof, speed_integer, node_sys_glo, nsdof, speed_integer, mpi_comm, mpi_ierr)
 
  node_sys_loc = 0
 
  call get_minvalues(node_sys_glo, dist_system_glo, nsdof*mpi_np, node_sys_loc, nsdof, mpi_np)
  call mpi_barrier(mpi_comm, mpi_ierr)
  
  ! Finding if this nearest node is common in multiple partitions
  node_counter_sdof_dum = 0
  do i = 1, nsdof
    nearestnode_globnum(i) = node_sys_glo(node_sys_loc(i))
 
    call get_indloc_from_indglo(local_node_num, nn_loc, nearestnode_globnum(i), nearestnode_locnum(i))
 
    if (nearestnode_locnum(i).ne.0) then
      node_counter_sdof_dum(i) = 1;
      node_counter_loc(nearestnode_locnum(i)) = node_counter_loc(nearestnode_locnum(i)) + 1
    endif
  enddo
  
  ! Finiding LGL nodes that are shared by different partitions
  allocate(node_counter_sdof(nsdof))
  call mpi_barrier(mpi_comm, mpi_ierr)
  call mpi_allreduce(node_counter_sdof_dum, node_counter_sdof, nsdof, speed_integer, mpi_sum, mpi_comm, mpi_ierr)
 
  max_nsdof_per_node = maxval(node_counter_loc)  ! num on SDOFs allocated to a LGL node, id of 1st SDOF, id of 2nd SDOF etc...
  allocate(locnode_buildid_map(nn_loc, max_nsdof_per_node + 1))
  locnode_buildid_map = 0
 
  ! Mapping SDOFs to nearest LGL nodes; 
  do i = 1, nsdof
    nearestnode_globnum(i) = node_sys_glo(node_sys_loc(i))
 
    call get_indloc_from_indglo(local_node_num, nn_loc, nearestnode_globnum(i), nearestnode_locnum(i))
 
    if (nearestnode_locnum(i).ne.0) then
      locnode_buildid_map(nearestnode_locnum(i), 1) = locnode_buildid_map(nearestnode_locnum(i), 1) + 1
      locnode_buildid_map(nearestnode_locnum(i), locnode_buildid_map(nearestnode_locnum(i), 1)+1 ) = sys_label(i)
      ! write(*,*) mpi_id, i, sys_label(i),'; node_counter = ', node_counter_sdof, '; coords = ', xs_loc(nearestnode_locnum(i)), &
      ! ys_loc(nearestnode_locnum(i)), zs_loc(nearestnode_locnum(i)) 
    endif
  enddo
 

References speed_par::dist_system_glo, get_indloc_from_indglo(), get_minvalues(), get_nearest_node(), speed_par::locnode_buildid_map, speed_par::node_counter_sdof, speed_par::x_system_lst, speed_par::y_system_lst, and speed_par::z_system_lst.

Referenced by read_system_position().

Here is the call graph for this function:

Here is the caller graph for this function:

Functions/Subroutines

Function/Subroutine Documentation

◆ make_system_position_lglnodes()