smumps_sol_es Module Reference

Functions/Subroutines
subroutine, public	smumps_sol_es_init (size_of_block_arg, keep201)
subroutine, public	smumps_tree_prun_nodes (fill, dad, ne_steps, frere, keep28, fils, step, n, nodes_rhs, nb_nodes_rhs, to_process, nb_prun_nodes, nb_prun_roots, nb_prun_leaves, pruned_list, pruned_roots, pruned_leaves)
subroutine, public	smumps_chain_prun_nodes (fill, dad, keep28, step, n, nodes_rhs, nb_nodes_rhs, pruned_sons, to_process, nb_prun_nodes, nb_prun_roots, nb_prun_leaves, pruned_list, pruned_roots, pruned_leaves)
subroutine, public	smumps_initialize_rhs_bounds (step, n, irhs_ptr, nbcol, irhs_sparse, nz_rhs, jbeg_rhs, perm_rhs, size_perm_rhs, k242, k243, uns_perm_inv, size_uns_perm_inv, k23, rhs_bounds, nsteps, nb_sparse, myid, mode)
subroutine, public	smumps_propagate_rhs_bounds (pruned_leaves, nb_pruned_leaves, step, n, pruned_sons, dad, rhs_bounds, nsteps, myid, comm, keep485, iw, liw, ptrist, kixsz, ooc_fct_loc, phase, ldlt, k38)
integer(8) function	smumps_local_factor_size (iw, liw, ptr, phase, ldlt, is_root)
integer(8) function	smumps_local_factor_size_blr (iw, liw, ptr, lrstatus, iwhandler, phase, ldlt, is_root)
subroutine, public	smumps_tree_prun_nodes_stats (myid, n, keep28, keep201, fr_fact, step, pruned_list, nb_prun_nodes, ooc_fct_type_loc)
subroutine, public	smumps_chain_prun_nodes_stats (myid, n, keep28, keep201, keep485, fr_fact, step, pruned_list, nb_prun_nodes, ooc_fct_type_loc)

Variables
integer(8), dimension(:,:), pointer	size_of_block
integer(8), public	pruned_size_loaded

Function/Subroutine Documentation

smumps_chain_prun_nodes()

subroutine, public smumps_sol_es::smumps_chain_prun_nodes	(	logical, intent(in)	fill,
		integer, dimension(keep28), intent(in)	dad,
		integer, intent(in)	keep28,
		integer, dimension(n), intent(in)	step,
		integer, intent(in)	n,
		integer, dimension(nb_nodes_rhs), intent(in)	nodes_rhs,
		integer, intent(in)	nb_nodes_rhs,
		integer, dimension(keep28)	pruned_sons,
		logical, dimension(keep28)	to_process,
		integer	nb_prun_nodes,
		integer	nb_prun_roots,
		integer	nb_prun_leaves,
		integer, dimension(nb_prun_nodes), intent(inout), optional	pruned_list,
		integer, dimension(nb_prun_roots), intent(inout), optional	pruned_roots,
		integer, dimension(nb_prun_leaves), intent(inout), optional	pruned_leaves )

Definition at line 130 of file smumps_sol_es.F.

      IMPLICIT NONE
      LOGICAL, INTENT(IN) :: fill
      INTEGER, INTENT(IN) :: N
      INTEGER, INTENT(IN) :: STEP(N)
      INTEGER, INTENT(IN) :: KEEP28
      INTEGER, INTENT(IN) :: DAD(KEEP28)
      INTEGER, INTENT(IN) :: nb_nodes_RHS
      INTEGER, INTENT(IN) :: nodes_RHS(nb_nodes_RHS)
      INTEGER :: nb_prun_nodes
      INTEGER, OPTIONAL, INTENT(INOUT):: Pruned_List(nb_prun_nodes)
      INTEGER :: nb_prun_roots
      INTEGER, OPTIONAL, INTENT(INOUT):: Pruned_Roots(nb_prun_roots)
      INTEGER :: nb_prun_leaves
      INTEGER, OPTIONAL, INTENT(INOUT):: Pruned_Leaves(nb_prun_leaves)
      INTEGER :: Pruned_SONS(KEEP28)
      LOGICAL :: TO_PROCESS(KEEP28)
      INTEGER :: IN, I, ISTEP, TMP
      nb_prun_nodes = 0
      nb_prun_roots = 0
      to_process(:) = .false.
      pruned_sons(:) = -1
      DO i = 1, nb_nodes_rhs
         tmp = nodes_rhs(i)
         istep = step(tmp)
         to_process(istep) = .true.
         IF (pruned_sons(istep) .eq. -1) THEN
            pruned_sons(istep) = 0
            nb_prun_nodes = nb_prun_nodes + 1
            IF(fill) THEN
               pruned_list(nb_prun_nodes) = nodes_rhs(i)
            END IF
            in = nodes_rhs(i)
            in = dad(step(in))
            DO WHILE (in.NE.0)
               to_process(step(in)) = .true.
               IF (pruned_sons(step(in)).eq.-1) THEN 
                  nb_prun_nodes = nb_prun_nodes + 1
                  IF(fill) THEN
                     pruned_list(nb_prun_nodes) = in
                  END IF
                  pruned_sons(step(in)) = 1
                  tmp = in
                  in = dad(step(in))
               ELSE 
                  pruned_sons(step(in)) = pruned_sons(step(in)) + 1
                  GOTO 201
               ENDIF
            ENDDO
            nb_prun_roots = nb_prun_roots +1
            IF(fill) THEN
               pruned_roots(nb_prun_roots) = tmp
            END IF
         ENDIF
  201    CONTINUE
      ENDDO
      nb_prun_leaves = 0
      DO i = 1, nb_nodes_rhs
         tmp = nodes_rhs(i)
         istep = step(tmp)
         IF (pruned_sons(istep).EQ.0) THEN
            nb_prun_leaves = nb_prun_leaves +1
            IF(fill) THEN
              pruned_leaves(nb_prun_leaves) = tmp
            END IF
         END IF
      ENDDO
      RETURN

smumps_chain_prun_nodes_stats()

subroutine, public smumps_sol_es::smumps_chain_prun_nodes_stats	(	integer, intent(in)	myid,
		integer, intent(in)	n,
		integer, intent(in)	keep28,
		integer, intent(in)	keep201,
		integer, intent(in)	keep485,
		integer(8), intent(in)	fr_fact,
		integer, dimension(n), intent(in)	step,
		integer, dimension(nb_prun_nodes), intent(in)	pruned_list,
		integer, intent(in)	nb_prun_nodes,
		integer, intent(in)	ooc_fct_type_loc )

Definition at line 435 of file smumps_sol_es.F.

      IMPLICIT NONE
      INTEGER, intent(in) :: KEEP28, KEEP201, OOC_FCT_TYPE_LOC, N,
     &                       KEEP485
      INTEGER(8), intent(in) :: FR_FACT
      INTEGER, intent(in) :: nb_prun_nodes, MYID
      INTEGER, intent(in) :: Pruned_List(nb_prun_nodes)
      INTEGER, intent(in) :: STEP(N)
      include 'mpif.h'
      INTEGER I, ISTEP
      INTEGER(8) :: Pruned_Size
      pruned_size = 0_8
      DO i = 1, nb_prun_nodes
        istep = step(pruned_list(i))
        IF (keep201 .GT. 0) THEN
            pruned_size = pruned_size + size_of_block
     &                    (istep, ooc_fct_type_loc)
        ENDIF
      ENDDO
      IF (keep201.GT.0) THEN
        IF (fr_fact .NE. 0_8) THEN
          pruned_size_loaded = pruned_size_loaded +pruned_size
        ENDIF
      ENDIF
      RETURN

smumps_initialize_rhs_bounds()

subroutine, public smumps_sol_es::smumps_initialize_rhs_bounds	(	integer, dimension(n), intent(in)	step,
		integer, intent(in)	n,
		integer, dimension(nbcol+1), intent(in)	irhs_ptr,
		integer, intent(in)	nbcol,
		integer, dimension(nz_rhs), intent(in)	irhs_sparse,
		integer, intent(in)	nz_rhs,
		integer, intent(in)	jbeg_rhs,
		integer, dimension(size_perm_rhs), intent(in)	perm_rhs,
		integer, intent(in)	size_perm_rhs,
		integer, intent(in)	k242,
		integer, intent(in)	k243,
		integer, dimension(size_uns_perm_inv), intent(in)	uns_perm_inv,
		integer, intent(in)	size_uns_perm_inv,
		integer, intent(in)	k23,
		integer, dimension(2*nsteps), intent(inout)	rhs_bounds,
		integer, intent(in)	nsteps,
		integer, intent(in)	nb_sparse,
		integer, intent(in)	myid,
		integer, intent(in)	mode )

Definition at line 207 of file smumps_sol_es.F.

      IMPLICIT NONE
      INTEGER, INTENT(IN) :: MYID, N, NSTEPS, K242, K243, K23
      INTEGER, INTENT(IN) :: JBEG_RHS, SIZE_PERM_RHS, nb_sparse
      INTEGER, INTENT(IN) :: NBCOL, NZ_RHS, SIZE_UNS_PERM_INV
      INTEGER, INTENT(IN) :: STEP(N), PERM_RHS(SIZE_PERM_RHS)
      INTEGER, INTENT(IN) :: IRHS_PTR(NBCOL+1),IRHS_SPARSE(NZ_RHS)
      INTEGER, INTENT(IN) :: UNS_PERM_INV(SIZE_UNS_PERM_INV)
      INTEGER, INTENT(INOUT):: RHS_BOUNDS(2*NSTEPS)
      INTEGER, INTENT(IN) :: mode 
      INTEGER :: I, ICOL, JPTR, J, JAM1, node, bound
      rhs_bounds = 0
      icol = 0 
      DO i = 1, nbcol
        IF ( (irhs_ptr(i+1)-irhs_ptr(i)).EQ.0) cycle
        icol = icol + 1
        bound = icol - mod(icol, nb_sparse) + 1
        IF(mod(icol, nb_sparse).EQ.0) bound = bound - nb_sparse
        IF(mode.EQ.0) THEN 
          IF ((k242.NE.0).OR.(k243.NE.0)) THEN
            jam1 = perm_rhs(jbeg_rhs+i-1)
          ELSE
            jam1 = jbeg_rhs+i-1
          ENDIF
          node = abs(step(jam1))
          IF(rhs_bounds(2*node - 1).EQ.0) THEN 
            rhs_bounds(2*node - 1) = bound                 
            rhs_bounds(2*node)     = bound + nb_sparse - 1 
          ELSE
            rhs_bounds(2*node) = bound + nb_sparse - 1
          END IF
        ELSE  
          DO jptr = irhs_ptr(i), irhs_ptr(i+1)-1
            j = irhs_sparse(jptr)
            IF ( mode .EQ. 1 ) THEN
              IF (k23.NE.0) j = uns_perm_inv(j)
            ENDIF
            node = abs(step(j))
            IF(rhs_bounds(2*node - 1).EQ.0) THEN
              rhs_bounds(2*node - 1) = bound
              rhs_bounds(2*node)     = bound + nb_sparse - 1
            ELSE
              rhs_bounds(2*node) = bound + nb_sparse - 1
            END IF
          END DO
        END IF
      END DO
      RETURN

smumps_local_factor_size()

integer(8) function smumps_sol_es::smumps_local_factor_size ( integer, dimension(liw), intent(in) iw, integer, intent(in) liw, integer, intent(in) ptr, integer, intent(in) phase, integer, intent(in) ldlt, logical, intent(in) is_root )

private

Definition at line 319 of file smumps_sol_es.F.

        INTEGER, INTENT(IN) :: LIW, PTR, PHASE, LDLT
        INTEGER, INTENT(IN) :: IW(LIW)
        LOGICAL, INTENT(IN) :: IS_ROOT
        INTEGER(8) :: NCB, NELIM, LIELL, NPIV, NROW
        ncb   = int(iw(ptr),8)     
        nelim = int(iw(ptr+1),8)   
        nrow  = int(iw(ptr+2),8)
        npiv  = int(iw(ptr+3),8)
        liell = npiv + ncb
        IF (is_root) THEN
          smumps_local_factor_size = int(iw(ptr+1),8) *     
     &                               int(iw(ptr+2),8) / 2_8 
          RETURN
        ENDIF
        IF (ncb.GE.0_8) THEN 
          IF (phase.EQ.0   
     &      .OR. (phase.EQ.1.AND.ldlt.NE.0) 
     &  ) THEN
            smumps_local_factor_size =
     &            npiv*(npiv-1_8)/2_8 + (nrow-npiv)*npiv
          ELSE
            smumps_local_factor_size =
     &      npiv*(npiv+1_8)/2_8 + (liell-npiv)*npiv
          ENDIF
        ELSE
          smumps_local_factor_size =
     &      -ncb*nelim
        END IF
      RETURN

smumps_local_factor_size_blr()

integer(8) function smumps_sol_es::smumps_local_factor_size_blr ( integer, dimension(liw), intent(in) iw, integer, intent(in) liw, integer, intent(in) ptr, integer, intent(in) lrstatus, integer, intent(in) iwhandler, integer, intent(in) phase, integer, intent(in) ldlt, logical, intent(in) is_root )

private

Definition at line 351 of file smumps_sol_es.F.

      USE smumps_lr_data_m
      USE smumps_lr_type
        INTEGER, INTENT(IN) :: LIW, PTR, PHASE, LDLT
        INTEGER, INTENT(IN) :: LRSTATUS, IWHANDLER
        INTEGER, INTENT(IN) :: IW(LIW)
        LOGICAL, INTENT(IN) :: IS_ROOT
        INTEGER(8) :: NCB, NELIM, LIELL, NPIV, NROW, FACTOR_SIZE
        INTEGER :: NB_PANELS, IPANEL, LorU, IBLOCK
        LOGICAL :: LR_ACTIVATED
        TYPE(LRB_TYPE), POINTER, DIMENSION(:) :: LRB_PANEL
        ncb   = int(iw(ptr),8)     
        nelim = int(iw(ptr+1),8)   
        nrow  = int(iw(ptr+2),8)
        npiv  = int(iw(ptr+3),8)
        liell = npiv + ncb
        lr_activated=(lrstatus.GE.2)
        IF (lr_activated) THEN
          factor_size = 0_8
          CALL smumps_blr_retrieve_nb_panels(iwhandler, nb_panels)
          IF (ldlt.EQ.0) THEN 
            loru = phase
          ELSE
            loru = 0
          ENDIF
          DO ipanel=1,nb_panels
            IF (is_root.AND.ipanel.EQ.nb_panels) THEN
              cycle
            ENDIF
            IF (smumps_blr_empty_panel_loru(iwhandler, loru, ipanel))
     &        THEN
              cycle
            ENDIF
             CALL smumps_blr_retrieve_panel_loru(iwhandler, loru,
     &                       ipanel, lrb_panel)
            IF (size(lrb_panel).GT.0) THEN
              IF (phase.EQ.0) THEN
                factor_size = factor_size + 
     &            int(lrb_panel(1)%N,8)*(int(lrb_panel(1)%N,8)-1_8)/2_8
              ELSE
                factor_size = factor_size + 
     &           int(lrb_panel(1)%N,8)*(int(lrb_panel(1)%N,8)+1_8)/2_8
              ENDIF
            ENDIF
            DO iblock=1,size(lrb_panel)
              IF (lrb_panel(iblock)%ISLR) THEN
                factor_size = factor_size + int(lrb_panel(iblock)%K,8)*
     &            int(lrb_panel(iblock)%M+lrb_panel(iblock)%M,8)
              ELSE
                factor_size = factor_size +
     &             int(lrb_panel(iblock)%M*lrb_panel(iblock)%N,8)
              ENDIF
            ENDDO
          ENDDO
          smumps_local_factor_size_blr = factor_size
        ELSE
          smumps_local_factor_size_blr = 
     &      smumps_local_factor_size(iw, liw, ptr, phase, ldlt, is_root)
        ENDIF
      RETURN

smumps_propagate_rhs_bounds()

subroutine, public smumps_sol_es::smumps_propagate_rhs_bounds	(	integer, dimension(nb_pruned_leaves), intent(in)	pruned_leaves,
		integer, intent(in)	nb_pruned_leaves,
		integer, dimension(n), intent(in)	step,
		integer, intent(in)	n,
		integer, dimension(nsteps), intent(in)	pruned_sons,
		integer, dimension(nsteps), intent(in)	dad,
		integer, dimension(2*nsteps), intent(inout)	rhs_bounds,
		integer, intent(in)	nsteps,
		integer, intent(in)	myid,
		integer, intent(in)	comm,
		integer, intent(in)	keep485,
		integer, dimension(liw), intent(in)	iw,
		integer, intent(in)	liw,
		integer, dimension(nsteps), intent(in)	ptrist,
		integer, intent(in)	kixsz,
		integer, intent(in)	ooc_fct_loc,
		integer, intent(in)	phase,
		integer, intent(in)	ldlt,
		integer, intent(in)	k38 )

Definition at line 263 of file smumps_sol_es.F.

      IMPLICIT NONE
      include 'mpif.h'
      include 'mumps_headers.h'
      INTEGER, INTENT(IN) :: nb_pruned_leaves, N, NSTEPS
      INTEGER, INTENT(IN) :: STEP(N), DAD(NSTEPS), Pruned_SONS(NSTEPS)
      INTEGER, INTENT(IN) :: MYID, COMM, KEEP485
      INTEGER, INTENT(IN) :: pruned_leaves(nb_pruned_leaves)
      INTEGER, INTENT(IN) :: LIW, IW(LIW), PTRIST(NSTEPS)
      INTEGER, INTENT(IN) :: KIXSZ, OOC_FCT_LOC, PHASE, LDLT, K38
      INTEGER, INTENT(INOUT):: RHS_BOUNDS(2*NSTEPS)
      INTEGER :: I, node, father, size_pool, next_size_pool
      INTEGER :: IERR
      INTEGER, ALLOCATABLE, DIMENSION(:) :: POOL, NBSONS
      ALLOCATE(pool(nb_pruned_leaves),
     &         nbsons(nsteps),
     &         stat=ierr)
      IF (ierr.NE.0) THEN
         WRITE(6,*)'Allocation problem in SMUMPS_PROPAGATE_RHS_BOUNDS'
         CALL mumps_abort()
      END IF
      size_pool = nb_pruned_leaves
      pool = pruned_leaves
      nbsons = pruned_sons
      DO WHILE (size_pool.ne.0)
        next_size_pool =0 
        DO i=1, size_pool 
          node = step(pool(i)) 
          IF (dad(node).NE.0) THEN
            father = step(dad(node))
            nbsons(father) = nbsons(father)-1
            IF (rhs_bounds(2*father-1).EQ.0) THEN
              rhs_bounds(2*father-1) = rhs_bounds(2*node-1)
              rhs_bounds(2*father)   = rhs_bounds(2*node)
            ELSE
              rhs_bounds(2*father-1) = min(rhs_bounds(2*father-1),
     &                                     rhs_bounds(2*node-1))
              rhs_bounds(2*father) = max(rhs_bounds(2*father),
     &                                     rhs_bounds(2*node))
            END IF
            IF(nbsons(father).EQ.0) THEN 
              next_size_pool = next_size_pool+1
              pool(next_size_pool) = dad(node)
            END IF
          END IF
        END DO
        size_pool = next_size_pool 
      END DO
      DEALLOCATE(pool, nbsons)
      RETURN

smumps_sol_es_init()

subroutine, public smumps_sol_es::smumps_sol_es_init	(	integer(8), dimension(:,:), pointer	size_of_block_arg,
		integer, intent(in)	keep201 )

Definition at line 28 of file smumps_sol_es.F.

      IMPLICIT NONE
      INTEGER, INTENT(IN) :: KEEP201
      INTEGER(8), POINTER, DIMENSION(:,:) :: SIZE_OF_BLOCK_ARG
      IF (keep201 > 0) THEN
        size_of_block => size_of_block_arg
      ELSE
        NULLIFY(size_of_block)
      ENDIF
      RETURN

smumps_tree_prun_nodes()

subroutine, public smumps_sol_es::smumps_tree_prun_nodes	(	logical, intent(in)	fill,
		integer, dimension(keep28), intent(in)	dad,
		integer, dimension(keep28), intent(in)	ne_steps,
		integer, dimension(keep28), intent(in)	frere,
		integer, intent(in)	keep28,
		integer, dimension(n), intent(in)	fils,
		integer, dimension(n), intent(in)	step,
		integer, intent(in)	n,
		integer, dimension(keep28), intent(in)	nodes_rhs,
		integer, intent(in)	nb_nodes_rhs,
		logical, dimension(keep28)	to_process,
		integer	nb_prun_nodes,
		integer	nb_prun_roots,
		integer	nb_prun_leaves,
		integer, dimension(nb_prun_nodes), intent(inout), optional	pruned_list,
		integer, dimension(nb_prun_roots), intent(inout), optional	pruned_roots,
		integer, dimension(nb_prun_leaves), intent(inout), optional	pruned_leaves )

Definition at line 39 of file smumps_sol_es.F.

      IMPLICIT NONE
      LOGICAL, INTENT(IN) :: fill
      INTEGER, INTENT(IN) :: N, KEEP28
      INTEGER, INTENT(IN) :: DAD(KEEP28),NE_STEPS(KEEP28),FRERE(KEEP28)
      INTEGER, INTENT(IN) :: FILS(N), STEP(N)
      INTEGER, INTENT(IN) :: nodes_RHS(KEEP28),  nb_nodes_RHS
      INTEGER :: nb_prun_nodes
      INTEGER, OPTIONAL, INTENT(INOUT):: Pruned_List(nb_prun_nodes)
      INTEGER :: nb_prun_roots
      INTEGER, OPTIONAL, INTENT(INOUT):: Pruned_Roots(nb_prun_roots)
      INTEGER :: nb_prun_leaves
      INTEGER, OPTIONAL, INTENT(INOUT):: Pruned_Leaves(nb_prun_leaves)
      LOGICAL :: TO_PROCESS(KEEP28) 
      INTEGER :: IN, I, ISTEP, TMP, TMPsave
      LOGICAL :: FILS_VISITED
      nb_prun_nodes = 0
      nb_prun_leaves = 0
      to_process(:) = .false.
      DO i = 1, nb_nodes_rhs
         tmp = nodes_rhs(i)
         tmpsave = tmp
         istep = step(tmp)
         DO WHILE(.NOT.to_process(istep))
            to_process(istep) = .true.
            nb_prun_nodes = nb_prun_nodes + 1
            IF(fill) THEN
               pruned_list(nb_prun_nodes) = tmp
            END IF
            in = fils(tmp) 
            DO WHILE(in.GT.0) 
               in = fils(in)
            END DO
            fils_visited = .false.
            IF (in.LT.0) THEN 
             fils_visited = to_process(step(-in))
            ENDIF
            IF ( in.LT.0.and..NOT.fils_visited)
     &            THEN 
               tmp = -in
               istep = step(tmp)
            ELSE 
               IF (in.EQ.0) THEN
                 nb_prun_leaves = nb_prun_leaves + 1
                 IF (fill) THEN
                    pruned_leaves(nb_prun_leaves) = tmp
                 END IF
               ELSE 
                 tmp = -in
                 istep = step(tmp)
               ENDIF
               DO WHILE (tmp.NE.tmpsave) 
                  tmp = abs(frere(istep))
                  IF(tmp.NE.0) THEN 
                     istep = step(tmp) 
                  ELSE 
                     exit
                  END IF
                  IF (.NOT.to_process(istep)) exit
               END DO
            END IF
         END DO
      END DO
      nb_prun_roots = 0
      DO i=1,nb_nodes_rhs
         tmp = nodes_rhs(i)
         istep = step(tmp)
         IF(dad(istep).NE.0) THEN 
            IF(.NOT.to_process(step(dad(istep)))) THEN
               nb_prun_roots = nb_prun_roots + 1
               IF(fill) THEN
                  pruned_roots(nb_prun_roots) = tmp
               END IF
            END IF
         ELSE 
            nb_prun_roots = nb_prun_roots + 1
            IF(fill) THEN
               pruned_roots(nb_prun_roots) = tmp
            END IF          
         END IF
      END DO
      RETURN

smumps_tree_prun_nodes_stats()

subroutine, public smumps_sol_es::smumps_tree_prun_nodes_stats	(	integer, intent(in)	myid,
		integer, intent(in)	n,
		integer, intent(in)	keep28,
		integer, intent(in)	keep201,
		integer(8), intent(in)	fr_fact,
		integer, dimension(n), intent(in)	step,
		integer, dimension(nb_prun_nodes), intent(in)	pruned_list,
		integer, intent(in)	nb_prun_nodes,
		integer, intent(in)	ooc_fct_type_loc )

Definition at line 414 of file smumps_sol_es.F.

      INTEGER, intent(in) :: KEEP28, KEEP201, OOC_FCT_TYPE_LOC, MYID, N
      INTEGER(8), intent(in) :: FR_FACT
      INTEGER, intent(in) :: nb_prun_nodes
      INTEGER, intent(in) :: Pruned_List(nb_prun_nodes)
      INTEGER, intent(in) :: STEP(N)
      INTEGER I, ISTEP
      INTEGER(8) :: Pruned_Size
      IF (keep201 .GT. 0) THEN
        pruned_size = 0_8
        DO i = 1, nb_prun_nodes
          istep = step(pruned_list(i))
          pruned_size = pruned_size + size_of_block
     &                  (istep, ooc_fct_type_loc)
        ENDDO
        pruned_size_loaded = pruned_size_loaded +pruned_size
      ENDIF
      RETURN

Variable Documentation

pruned_size_loaded

integer(8), public smumps_sol_es::pruned_size_loaded

Definition at line 25 of file smumps_sol_es.F.

      INTEGER(8) :: PRUNED_SIZE_LOADED

size_of_block

integer(8), dimension(:,:), pointer smumps_sol_es::size_of_block

private

Definition at line 24 of file smumps_sol_es.F.

      INTEGER(8), POINTER, DIMENSION(:,:) :: SIZE_OF_BLOCK