cini__defaults_8F_source.html

C

C  This file is part of MUMPS 5.5.1, released

C  on Tue Jul 12 13:17:24 UTC 2022

C

C

C  Copyright 1991-2022 CERFACS, CNRS, ENS Lyon, INP Toulouse, Inria,

C  Mumps Technologies, University of Bordeaux.

C

C  This version of MUMPS is provided to you free of charge. It is

C  released under the CeCILL-C license

C  (see doc/CeCILL-C_V1-en.txt, doc/CeCILL-C_V1-fr.txt, and

C  https://cecill.info/licences/Licence_CeCILL-C_V1-en.html)

C

C

C**********************************************************************

C


      SUBROUTINE cmumps_set_type_sizes( K34, K35, K16, K10 )

      IMPLICIT NONE

C

C     Purpose:

C     =======

C

C     Set the size in bytes of an "INTEGER" in K34

C     Set the size of the default arithmetic (REAL, DOUBLE PRECISION,

C     COMPLEX or DOUBLE COMPLEX) in K35

C     Set the size of floating-point types that are real or double

C     precision even for complex versions of MUMPS (REAL for S and

C     C versions, DOUBLE PRECISION for D and Z versions)

C     Assuming that the size of an INTEGER(8) is 8, store the ratio

C     nb_bytes(INTEGER(8)) / nb_bytes(INTEGER) = 8 / K34 into K10.

C

C     In practice, we have:

C

C     K35:  Arithmetic   Value    Value for T3E

C              S           4           8

C              D           8          16

C              C           8          16

C              Z          16          32

C

C     K16 = K35 for S and D arithmetics

C     K16 = K35 / 2 for C and Z arithmetics

C

C     K34= 4 and K10 = 2, except on CRAY machines or when compilation

C     flag -i8 is used, in which case, K34 = 8 and K10 = 1

C

C

      INTEGER, INTENT(OUT) :: K34, K35, K10, K16

      INTEGER(8) :: SIZE_INT, SIZE_REAL_OR_DOUBLE ! matches MUMPS_INT8

      INTEGER I(2)

      REAL R(2) ! Will be DOUBLE PRECISION if 0

      CALL mumps_size_c(i(1),i(2),size_int)

      CALL mumps_size_c(r(1),r(2),size_real_or_double)

      k34 = int(size_int)

      k10 = 8 / k34

      k16 = int(size_real_or_double)

      k35 = k16

      k35 = k35 * 2

      RETURN


      END SUBROUTINE cmumps_set_type_sizes

C

C**********************************************************************

C


      SUBROUTINE cmumpsid( NSLAVES, LWK_USER, CNTL, ICNTL,

     &                    KEEP,KEEP8,

     &                    INFO, INFOG, RINFO, RINFOG, SYM, PAR,

     &                    DKEEP, MYID )

!$    USE OMP_LIB

      IMPLICIT NONE

C

C  Purpose

C  =======

C

C  The elements of the arrays CNTL and ICNTL control the action of

C  CMUMPS, CMUMPS_ANA_DRIVER, CMUMPS_FAC_DRIVER, CMUMPS_SOLVE_DRIVER

C  Default values for the elements are set in this routine.

C

      REAL    DKEEP(230)

      REAL    CNTL(15), RINFO(40), RINFOG(40)

      INTEGER ICNTL(60), KEEP(500), SYM, PAR, NSLAVES, MYID

      INTEGER INFO(80), INFOG(80)

      INTEGER(8) KEEP8(150)

      INTEGER LWK_USER

C

C  Parameters

C  ==========

C===========================================

C       Arrays for control and information

C===========================================

C

C  N  Matrix order

C

C  NELT Number of elements for matrix in ELt format

C

C

C  SYM = 0 ... initializes the defaults for unsymmetric code

C      = 1,2 ... initializes the defaults for symmetric code

C

C

C

C  PAR = 0 ... instance where host is not working

C      = 1 ... instance where host is working as a normal node.

C              (host uses more memory than other processors in

C               the latter case)

C

C  CNTL and the elements of the array ICNTL control the action of

C     CMUMPS Default values

C     are set by CMUMPSID.  The elements of the arrays RINFO

C     and INFO provide information on the action of CMUMPS.

C

C  CNTL(1) threshold for partial pivoting

C     has default value 0.0 when SYM=1 and 0.01 otherwise

C     Values and less than zero as treated as zero.

C     Values greater than 1.0 are treated as 1.0 for

C     SYM=1 and as 0.5 for SYM=2

C     In general, a larger value of CNTL(1) leads to

C     greater fill-in but a more accurate factorization.

C     If CNTL(1) is nonzero, numerical pivoting will be performed.

C     If CNTL(1) is zero, no pivoting will be performed and

C     the subroutine will fail if a zero pivot is encountered.

C     If the matrix A is diagonally dominant, then

C     setting CNTL(1) to zero will decrease the factorization

C     time while still providing a stable decomposition.

C

C  CNTL(2) must be set to the tolerance for convergence of iterative

C     refinement.

C     Default value is sqrt(macheps).

C     Values less than zero are treated as sqrt(macheps).

C

C  CNTL(3) is used with null pivot row detection (ICNTL(24) .eq. 1)

C     Default value is 0.0.

C     Let A_{preproc} be the preprocessed matrix to be factored (see

C       equation in the user's guide).

C     A pivot is considered to be null if the infinite norm of its

C     row/column is smaller than a threshold. Let MACHEPS be the

C     machine precision and ||.|| be the infinite norm.

C     The absolute value to detect a null pivot row (when ICNTL(24) .EQ.1)

C     is stored in DKEEP(1).

C      IF CNTL(3)  > 0 THEN

C          DKEEP(1) = CNTL(3)  ||A_{preproc}||

C      ELSE IF CNTL(3)  = 0.0 THEN

C          DKEEP(1) = MACHEPS 10^{-5} ||A_{preproc}||

C      ELSE IF CNTL(3)  < 0 THEN

C          DKEEP(1) = abs(CNTL(3))! this was added for EDF

C                                 ! in the context of SOLSTICE project

C      ENDIF

C

C  CNTL(4) must be set to value for static pivoting.

C     Default value is -1.0

C     Note that static pivoting is enabled only when

C     Rank-Revealing and null pivot detection

C     are off (KEEP(19).EQ.0).AND.(KEEP(110).EQ.0).

C     If negative, static pivoting will be set OFF (KEEP(97)=0)

C     If positive, static pivoting is ON (KEEP(97=1) with

C     threshold CNTL(4)

C     If = 0, static pivoting is ON with threshold MACHEPS^1/2 || A ||

C

C  CNTL(5) fixation for null pivots

C     Default value is 0.0

C     Only active if ICNTL(24) = 1

C     If > 0 after finding a null pivot, it is set to CNTL(5) x ||A||

C     (This value is stored in DKEEP(2))

C     If <=  0 then

C       SYM=2:

C         the row/column (except the pivot) is set to zero

C         and the pivot is set to 1

C       SYM=0:

C         the fixation is automatically

C         set to a large potitive value and the pivot row of the

C         U factors is set to zero.

C     Default is 0.

C

C CNTL(6) not used yet

C

C CNTL(7) tolerance for Low Rank approximation of the Blocks (BLR).

C         Dropping parameter expressed with a double precision,

C         real value, controlling

C         compression and used to truncate the RRQR algorithm

C         default value is 0.0.  (i.e. no approximation).

C         The truncated RRQR operation is implemented as

C         as variant of the LAPACK GEQP3 and LAQPS routines.

C           0.0 : full precision approximation.

C         > 0.0 : the dropping parameter is DKEEP(8).

C

C        Warning: using negative values is an experimental and

C        non recommended setting.

C        < 0.0 : the dropping parameter is |DKEEP(8)|*|Apre|, Apre

C                as defined in user's guide

C

C

C  -----------------------------------------

C

C  ICNTL(1) has default value 6.

C     It is the output stream for error messages.

C     If it is set to zero, these

C     messages will be suppressed.

C

C  ICNTL(2) has default value 0.

C     It is the output stream for diagnostic printing and

C     for warning messages that are local to each MPI process.

C     If it is set to zero, these messages are suppressed.

C

C  ICNTL(3) -- Host only

C            It is the output stream for diagnostic printing

C            and  for warning messages. Default value is 6.

C            If it is set to zero, these messages are suppressed.

C

C  ICNTL(4) is used by CMUMPS to control printing of error,

C     warning, and diagnostic messages. It has default value 2.

C     Possible values are:

C

C    <1       __No messages output.

C     1       __Only error messages printed.

C     2       __Errors and warnings printed.

C     3       __Errors and warnings and terse diagnostics

C                (only first ten entries

C               of arrays printed).

C     4       __Errors and warnings and all information

C               on input and output parameters printed.

C

C

C  ICNTL(5) is the format of the input matrix and rhs

C     0: assembled matrix, assembled rhs

C     1: elemental matrix, assembled rhs

C     Default value is 0.

C

C  ICNTL(6) has default value 7 for unsymmetric and

C      general symmetric matrices, and 0 for SPD matrices.

C      It is only accessed and operational

C      on a call that includes an analysis phase

C      (JOB = 1, 4, or 6).

C      In these cases, if ICNTL(6)=1, 2, 3, 4, 5, 6 or 7,

C      a column permutation based on algorithms described in

C      Duff and Koster, 1997, *SIMAX <20>, 4, 889-901,

C      is applied to the original matrix. Column permutations are

C      then applied to the original matrix to get a zero-free diagonal.

C      Except for ICNTL(6)=1, the numerical values of the

C      original matrix, id%A(NE), need be provided by the user

C      during the analysis phase.

C      If ICNTL(6)=7, based on the structural symmetry of the

C      input matrix the value of ICNTL(6) is automatically chosen.

C     If the ordering is provided by the user

C     (ICNTL(7)=1) then the value of ICNTL(6) is ignored.

C

C  ICNTL(7) has default value 7 and must be set by the user to

C     1 if the pivot order in IS is to be used.

C     Effective value of ordering stored in KEEP(256).

C     Possible values are (depending on the softwares installed)

C       0 AMD: Approximate minimum degree (included in CMUMPS package)

C       1 Ordering provided by the user

C       2 Approximate minimum fill (included in CMUMPS package)

C       3 SCOTCH (see http://gforge.inria.fr/projects/scotch/)

C         should be downloaded/installed separately.

C       4 PORD from Juergen Schulze (js@juergenschulze.de)

C         PORD package is extracted from the SPACE-1.0 package developed at the

C         University of Paderborn by Juergen Schulze

C         and is provided as a separate package.

C       5 Metis ordering should be downloaded/installed separately.

C       6 Approximate minimum degree with automatic quasi

C           dense row detection (included in CMUMPS package).

C           (to be used when ordering time with AMD is abnormally large)

C       7 Automatic choice done during analysis phase

C     For any other

C     value of ICNTL(7), a suitable pivot order will be

C     chosen automatically.

C

C  ICNTL(8)  is used to describe the scaling strategy.

C     Default value is 77.

C     Note that scaling is performed only when the numerical

C     factorization step is performed (JOB = 2, 4>, 5>, or 6>).

C     If ICNTL(8) is not equal to

C     any of the values listed below then ICNTL(8) is treated

C     as if it had its default value of 0 (no scaling).

C     If the matrix is known to be very badly scaled,

C     our experience has been that option 6 is the most robust but

C     the best scaling is very problem dependent.

C     If ICNTL(8)=0, COLSCA and ROWSCA are dummy arguments

C     of the subroutine that are not accessed.

C     Possible values of ICNTL(8) are:

C

C     -2 scaling computed during analysis (and applied during the

C       factorization)

C

C     -1 the user must provide the scaling in arrays

C        COLSCA and ROWSCA

C

C     0 no scaling

C

C     1 Diagonal scaling

C

C     2 not defined

C

C     3 Column scaling

C

C     4 Row and column scaling

C

C     5,6 not defined

C     7, 8 Scaling based on Daniel Ruiz and Bora Ucar's work done

C     during the ANR-SOLSTICE project.

C     Reference for this work are:

C     The scaling algorithms are based on those discussed in

C     [1] D. Ruiz, "A scaling algorithm to equilibrate both rows and

C         columns norms in matrices", Tech. Rep. Rutherford

C         Appleton Laboratory, Oxon, UK and ENSEEIHT-IRIT,

C         Toulouse, France, RAL-TR-2001-034 and RT/APO/01/4, 2001.

C     [2] D. Ruiz and B. Ucar, "A symmetry preserving algorithm for

C         matrix scaling", in preparation as of Jan'08.

C     This scaling can work on both centralized and distributed

C     assembled input matrix format. (it works for both symmetric

C     and unsymmetric matrices)

C     Option 8 is similar to 7 but more rigourous and expensive to compute.

C     77 Automatic choice of scaling value done. Proposed algo:

C          if (sym=1) then

C           option = 0

C          else

C           if distributed matrix entry then

C              option = 7

C           else

C               if (maximum transversal is called

C                    and makes use of numerical values) then

C                 option=-2 and ordering is computed during analysis

C               else

C                 option = 7

C               endif

C           endif

C          endif

C

C  ICNTL(9) has default value 1. If ICNTL(9)=1

C     the system of equations A * x = b  is solved. For other

C     values the system A^T *  x = b  is solved.

C     When ICNTL(30) (compute selected entries in A-1) is activated

C     ICNTL(9) is ignored.

C

C  ICNTL(10) has default value 0.

C     If ICNTL(10)=0 : iterative refinement is not performed.

C     Values of  ICNTL(10) < 0 : a fix number of steps equal

C     to ICNTL(10) of IR is done.

C     Values of ICNTL(10) > 0 : mean a maximum of ICNTL(10) number

C                           of steps of IR is done, and a test of

C                           convergence is used

C

C  ICNTL(11) has default value 0.

C     A value equal to 1 will return a backward error estimate in

C     RINFO(4-11).

C     A value equal to 2 will return a backward error estimate in

C     RINFO(4-8). No LCOND 1, 2 and forward error are computed.

C     If ICNTL(11) is negative, zero or greater than 2 no estimate

C     is returned.

C

C

C  ICNTL(12) has default value 0 and defines the strategy for

C     LDLT orderings

C     0 : automatic choice

C     1 : usual ordering (nothing done)

C     2 : ordering on the compressed graph, available with all orderings

C         except with AMD

C     3 : constraint ordering, only available with AMF,

C         -> reset to 2 with other orderings

C     Other values are treated as 1 (nothing done).

C     On output KEEP(95) holds the internal value used and INFOG(24) gives

C     access to KEEP(95) to the user.

C     in LU facto it is always reset to 1

C

C     - ICNTL(12) = 3 has a lower priority than ICNTL(7)

C     thus if ICNTL(12) = 3 and the ordering required is not AMF

C     then ICNTL(12) is set to 2

C

C     - ICNTL(12) = 2 has a higher priority than ICNTL(7)

C     thus if ICNTL(12) = 2 and the ordering required is AMD

C     then the ordering used is QAMD

C

C     - ICNTL(12) has a higher priority than ICNTL(6) and ICNTL(8)

C     thus if ICNTL(12) = 2 then ICNTL(6) is automatically

C     considered as if it was set to a value between 1-6

C     if ICNTL(12) = 3 then ICNTL(6) is considered as if

C     set to 5 and ICNTL(8) as if set to -2 (we need the scaling

C     factors to define free and constrained variables)

C

C  ICNTL(13) has default value 0 and allows for selecting Type 3 node.

C            IF ICNTL(13).GT. 0 scalapack is forbidden. Otherwise,

C            scalapack will be activated if the root is large enough.

C            Furthermore

C             IF ((ICNTL(13).GT.0) .AND. (NSLAVES.GT.ICNTL(13),

C               or ICNTL(13)=-1 THEN

C               extra splitting of the root will be activated

C               and is controlled by abs(KEEP(82)).

C               The order of the root node is divided by KEEP(82)

C            ENDIF

C            If ICNTL(13) .EQ. -1 then splitting of the root

C            is done whatever the nb of procs is.

C

C            To summarize:

C               -1         : root splitting and scalapack on

C               0  or < -1 : root splitting off and sclalapack on

C               > 0        : scalapack off

C

C  ICNTL(14) has default value 20 (5 if NSLAVES=1 and SYM=1)

C            and is the value for memory relaxation

C            so called "PERLU" in the following.

C

C

C ICNTL(15) : Describes the compression of the graph of the input matrix

C             The analysis step is then performed on the compressed

C             graph

C             Must be set during analysis on the master

C           0 : OFF

C           1 : Compression provided by the user:

C               BLKPTR(1:id%NBLK+1) and

C               BLKVAR(1:N or N_LOC if distributed format)

C               (BLKVAR(BLKPTR(iblk):BLKPTR(iblk+1)-1):

C                                           dof list for iblk)

C                - If BLKVAR is not provided then BLKVAR is

C                  treated as the identity

C                  (contiguous variables in blocks)

C                - Distributed format if on MASTER N_LOC#N

C

C  ICNTL(16) : number of OpenMP threads asked by the user.

C

C  ICNTL(17) not used in this version

C

C  ICNTL(18) has default value 0 and is only accessed by the host during

C      the analysis phase if the matrix is assembled (ICNTL(5))= 0).

C      ICNTL(18) defines the strategy for the distributed input matrix.

C      Possible values are:

C      0: input matrix is centralized on the host. This is the default

C      1: user provides the structure of the matrix on the host at analysis,

C        CMUMPS returns

C        a mapping and user should provide the matrix distributed according

C        to the mapping

C      2:  user provides the structure of the matrix on the host at analysis,

C          and the

C          distributed matrix on all slave processors at factorization.

C          Any distribution is allowed

C      3: user directly provides the distributed matrix input both

C         for analysis and factorization

C

C      For flexibility and performance issues, option 3 is recommended.

C

C   ICNTL(19) has default value 0 and is only accessed by the host

C    during the analysis phase. If ICNTL(19) \neq 0 then Schur matrix will

C    be returned to the user.

C    The user must set on entry on the host node (before analysis):

C    the integer variable SIZE\_SCHUR to the size fo the Schur matrix,

C    the integer array pointer LISTVAR\_SCHUR to the list of indices

C    of the schur matrix.

C     if = 0      : Schur is off and the root node gets factorized

C     if = 1      : Schur is on and the Schur complement is returned entirely

C                   on a memory area provided by the user ONLY on the host node

C     if = 2 or 3 : Schur is on and the Schur complement is returned in a

C                   distributed fashion according to a 2D block-cyclic

C                   distribution. In the case where the matrix is symmetric

C                   the lower part is returned if =2 or the complete

C                   matrix if =3.

C

C   ICNTL(20) has default value 0 and is only accessed  by the host

C    during the solve phase. If ICNTL(20)=0, the right-hand side must given

C    in dense form in the structure component RHS.

C    If ICNTL(20)=1,2,3, then the right-hand side must be given in sparse form

C    using the structure components IRHS\_SPARSE, RHS\_SPARSE, IRHS\_PTR and

C    NZ\_RHS.

C    When the right-hand side is provided in sparse form then duplicate entries

C    are summed.

C

C       0 : dense RHS

C       1,2,3 : Sparse RHS

C          1 The decision of exploiting sparsity of the right-hand side to

C            accelerate the solution phase is done automatically.

C          2 Sparsity of the right-hand sides is NOT exploited

C            to improve solution phase.

C          3 Sparsity of the right-hand sides is exploited

C            to improve solution phase.

C    Values different from 0,1, 2,3 are treated as 0.

C    For sparse RHS recommended value is 1.

C

C   ICNTL(21) has default value 0 and is only accessed by the host

C    during the solve phase. If ICNTL(21)=0, the solution vector will be assembled

C    and stored in the structure component RHS, that must have been allocated by

C    the user. If ICNTL(21)=1, the solution vector is kept distributed at the

C    end of the solve phase, and will be available on each slave processor

C    in the structure components ISOL_loc and SOL_loc. ISOL_loc and SOL_loc

C    must then have been allocated by the user and must be of size at least

C    INFO(23), where INFO(23) has been returned by CMUMPS at the end of the

C    factorization phase.

C    Values of ICNTL(21) different from 0 and 1 are currently treated as 0.

C

C   ICNTL(22) (saved in KEEP(201) controls the OOC setting (0=incore, 1 =OOC)

C    It has default value 0 (incore).Out-of-range values are treated as 1.

C    If set before analysis then special setting and massage of the tree

C    might be done (so far only extra splitting  CUTNODES) is performed.

C    It is then accessed by the host

C    during the factorization phase. If ICNTL(22)=0, then no attempt

C    to use the disks is made. If ICNTL(22)=1, then CMUMPS will store

C    the computed factors on disk for later use during the solution

C    phase.

C

C   ICNTL(23) has default value 0 and is accessed by ALL processors

C    at the beginning of the factorization phase.  If positive

C    it corresponds to the maximum size of the working memory

C    in MegaBytes that MUMPS can allocate per working processor.

C    If only the host

C    value is non zero, then other processors also use the value on

C    the host. Otherwise, each processor uses the local value

C    provided.

C

C   ICNTL(24) default value is 0

C     if = 0 no null pivot detection (CNTL(5) and CNTL(3) are inactive),

C        = 1 null pivot row detection; CNTL(3) and CNTL(5) are

C            then used to describe the action taken.

C

C

C   ICNTL(25) has default value 0 and is only accessed by the

C   host during the solution stage. It is only significant if

C   a null space basis was requested during the factorization

C   phase (INFOG(28) .GT. 0); otherwise a normal solution step

C   is performed.

C   If ICNTL(25)=0, then a normal solution step is performed,

C   on the internal problem (excluding the null space).

C   No special property on the solution (discussion with Serge)

C   If ICNTL(25)=i, 1 <= i <= INFOG(28), then the i-th vector

C   of the null space basis is computed. In that case, note

C   that NRHS should be set to 1.

C   If ICNTL(25)=-1, then all null space is computed. The

C   user should set NRHS=INFOG(28) in that case.

C   Note that centralized or distributed solutions are

C   applicable in that case, but that iterative refinement,

C   error analysis, etc... are excluded. Note also that the

C   option to solve the transpose system (ICNTL(9)) is ignored.

C

C

C   ICNTL(26) has default value 0 and is accessed on the host only

C     at the beginning of the solution step.

C     It is only effective if the Schur option is ON.

C     (copy in KEEP(221))

C

C

C     During the solution step, a value of 0 will perform a normal

C     solution step on the reduced problem not involving the Schur

C     variables.

C     During the solution step, if ICNTL(26)=1 or 2, then REDRHS

C     should be allocated of size at least LREDRHS*(NRHS-1)+

C     SIZE_SCHUR, where LREDRHS is the leading dimension of

C     LREDRHS (LREDRHS >= SIZE_SCHUR).

C

C     If ICNTL(26)=1, then only a forward substitution is performed,

C     and a reduced RHS will be computed and made available in

C     REDRHS(i+(k-1)*LREDRHS), i=1, ..., SIZE_SCHUR, k=1, ..., NRHS.

C     If ICNTL(26)=2, then REDRHS(i+(k-1)*LREDRHS),i=1, SIZE_SCHUR,

C     k=1,NRHS is considered to be the solution corresponding to the

C     Schur variables. It is injected in CMUMPS, that computes the

C     solution on the "internal" problem during the backward

C     substitution.

C

C ICNTL(27)  controls the blocking factor for multiple right-hand-sides

C     during the solution phase.

C     It influences both the memory used (see INFOG(30-31)) and

C     the solution time

C     (Larger values of ICNTL(27) leads to larger memory requirements).

C     Its tuning can be critical when

C     the factors are written on disk (out-of core, ICNTL(22)=1).

C     A negative value indicates that  automatic setting is

C     performed by the solver.

C

C

C   ICNTL(28) decides whether parallel or sequential analysis should be used. Three

C       values are possible at the moment:

C       0: automatic. This defaults to sequential analysis

C       1: sequential. In this case the ordering strategy is defined by ICNTL(7)

C       2: parallel. In this case the ordering strategy is defined by ICNTL(29)

C

C   ICNTL(29) defines the ordering too to be used during the parallel analysis. Three

C       values are possible at the moment:

C       0: automatic. This defaults to PT-SCOTCH

C       1: PT-SCOTCH.

C       2: ParMetis.

C

C

C   ICNTL(30) controls the activation of functionality A-1.

C             It has default value 0 and is only accessed by the master

C             during the solution phase. It enables the solver to

C             compute entries in the inverse of the original matrix.

C             Possible values are:

C              0  normal solution

C              other values:   compute entries in A-1

C             When ICNTL(30).NE.0 then the user

C             must describe on entry to the solution phase,

C             in the sparse right-hand-side

C             (NZ_RHS, NRHS, RHS_SPARSE, IRHS_SPARSE, IRHS_PTR)

C             the target entries of A-1 that need be computed.

C             Note that RHS_SPARSE must be allocated but need not be

C             initialized.

C             On output RHS_SPARSE then holds the requested

C             computed values of A-1.

C             Note that when ICNTL(30).NE.0 then

C              - sparse right hand side interface is implicitly used

C                functionality (ICNTL(20)= 1) but RHS need not be

C                allocated since computed A-1 entries will be stored

C                in place.

C              - ICNTL(9) option (solve Ax=b or Atx=b) is ignored

C             In case of duplicate entries in the sparse rhs then

C             on output duplicate entries in the solution are provided

C             in the same place.

C             This need not be mentioned in the spec since it is a

C             "natural" extension.

C

C   -----------

C   Fwd in facto

C   -----------

C   ICNTL(31) Must be set before analysis to control storage

C             of LU factors. Default value is 0. Out of range

C             values considered as 0.

C             (copied in KEEP(251) and broadcast,

C              when setting of ICNTL(31)

C              results in not factors to be stored then

C              KEEP(201) = -1, OOC is "suppressed")

C            0 Keep factors needed for solution phase

C              (when option forward during facto is used then

C               on unsymmetric matrices L factors are not stored)

C            1 Solve not needed (solve phase will never be called).

C              When the user is only interested in the inertia or the

C              determinant then

C              all factor matrices need not be stored.

C              This can also be useful for testing :

C              to experiment facto OOC without

C              effective storage of factors on disk.

C            2 L factors not stored: meaningful when both

C              - matrix is unsymmetric and fwd performed during facto

C              - the user is only interested in the null-space basis

C              and thus only need the U factors to be stored.

C              Currently, L factors are always stored in IC.

C

C   -----------

C   Fwd in facto

C   -----------

C   ICNTL(32) Must be set before analysis to indicate whether

C             forward is performed during factorization.

C             Default value is 0 (normal factorization without fwd)

C             (copied in KEEP(252) and broadcast)

C            0 Normal factorization (default value)

C            1 Forward performed during factorization

C

C

C   ICNTL(33) Must be set before the factorization phase to compute

C             the determinant. See also KEEP(258), KEEP(259),

C             DKEEP(6), DKEEP(7), INFOG(34), RINFOG(12)

C

C            If ICNTL(33)=0 the determinant is not computed

C            For all other values, the determinant is computed. Note that

C            null pivots and static pivots are excluded from the

C            computation of the determinant.

C

C   ICNTL(34) Must be set before a call to MUMPS with JOB=-2 in case

C             the save/restore feature was used and user wants to clean

C             save/restore files (and possibly OOC files).

C             ICTNL(34)=0 => user wants to be able to restore instance later

C             ICTNL(34)=1 => user will not restore the instance again (clean

C                            to be done)

C

C    ICNTL(35) : Block Low-Rank (BLR) functionality,

C                need be set before analysis

C             Default value is 0

C             0: FR factorization and FR solve

C             1: Automatic BLR option setting (=> 2)

C             2: BLR factorization + BLR Solve

C                => keep BLR factors only

C             3: BLR factorization + FR Solve

C             Other values are treated as zero

C      Note that this functionality is currently incompatible

C      with elemental matrices (ICNTL(5) = 1) and with

C      forward elimination during factorization (ICNTL(32) = 1)

C

C    ICNTL(36) : Block Low-Rank variant choice

C             Default value is 0

C             0: UFSC variant, no recompression: Compress step is

C             performed after the Solve; the low-rank updates are not

C             recompressed

C             1: UCFS variant, no recompression: Compress step is

C             performed before the Solve; pivoting strategy is adapted

C             to pe performed on low-rank blocks; the low-rank updates are not

C             recompressed

C

C

C    ICNTL(38): Compression rate of LU factors, can be set before

C               analysis/factorization

C               Between 0 and 1000; other values ares treated as 0;

C               ICNTL(38)/10 is a percentage representing the typical

C               compressed factors compression of the factor matrices

C               in BLR fronts:

C               ICNTL(38)/10= compressed/uncompressed factors × 100.

C               Default value: 600

C               (when factors of BLR fronts are compressed,

C               their size is 60% of their full- rank size).

C

C   ICNTL(58): strategy for symbolic factorization used

C              with centralized ordering based on METIS (ICNTL(7)=5)

C              or with given given ordering (ICNTL(7)=1)

C

#if defined(__ve__)

C   Default value 2

#else

C   Default value 1

#endif

C     1 => SYMBQAMD based symbolic factorization

C     2 => Column count based symbolic factorization

C          Symbolic factorization based on

C          [GIMP94] "An efficient algorithm to compute row and column

C          counts for sparse cholesky factorization"

C          John R. Gilbert, Esmond G. Ng, and Barry W. Peyton

C          SIMAX 1994

C          implementation of the algorithm described in figure 3

C          of the [GINP94] article

C

C     Other values are treated as 1

C

C=========================

C  ARRAYS FOR INFORMATION

C========================

C

C-----

C INFO is an INTEGER array of length 80 that need not be

C     set by the user.

C-----

C

C  INFO(1) is zero if the routine is successful, is negative if an

C     error occurred, and is positive for a warning (see CMUMPS for

C     a partial documentation and the userguide for a full documentation

C     of INFO(1)).

C

C  INFO(2)   holds additional information concerning the

C     error (see CMUMPS).

C

C ------------------------------------------

C Statistics produced after analysis phase

C ------------------------------------------

C

C  INFO(3)   Estimated real space needed for factors.

C

C  INFO(4)   Estimated integer space needed for factors.

C

C  INFO(5)  Estimated maximum frontal size.

C

C  INFO(6)  Number of nodes in the tree.

C

C  INFO(7)  Minimum value of integer working array IS (old MAXIS)

C     estimated by the analysis phase

C     to run the numerical factorization.

C

C  INFO(8)  Minimum value of real/complex array S (old MAXS)

C     estimated by the analysis phase

C     to run the numerical factorization.

C

C  INFO(15) Estimated size in MBytes of all CMUMPS internal data

C      structures to run factorization

C

C  INFO(17) provides an estimation (minimum in Megabytes)

C  of the total memory required to run

C  the numerical phases  out-of-core.

C  This memory estimation corresponds to

C  the least memory consuming out-of-core strategy and it can be

C  used as a lower bound if the user wishes to provide ICNTL(23).

C ---------------------------------------

C Statistics produced after factorization

C ---------------------------------------

C  INFO(9)  Size of the real space used to store the LU factors possibly

C                 including BLR compressed factors

C

C  INFO(10)  Size of the integer space used to store the LU factors

C

C  INFO(11)  Order of largest frontal matrix.

C

C  INFO(12)  Number of off-diagonal pivots.

C

C  INFO(13)  Number of uneliminated variables sent to the father.

C

C  INFO(14)  Number of memory compresses.

C

C  INFO(18)  On exit to factorization:

C              Local number of null pivots (ICNTL(24)=1)

C              on the local processor even on master.

C              (local size of array PIVNUL_LIST).

C

C  INFO(19) - after analysis:

C           Estimated size of the main internal integer workarray IS

C     (old MAXIS) to run the numerical factorization out-of-core.

C

C  INFO(21) - after factorization: Effective space used in the main

C           real/complex workarray S -- or in the workarray WK_USER,

C           in the case where WK_USER is provided.

C

C  INFO(22) - after factorization:

C      Size in millions of bytes of memory effectively used during

C      factorization.

C      This includes the memory effectively used in the workarray

C      WK_USER, in the case where WK_user is provided.

C

C  INFO(23) - after factorization: total number of pivots eliminated

C      on the processor. In the case of a distributed solution (see

C      ICNTL(21)), this should be used by the user to allocate solution

C      vectors ISOL_loc and SOL_loc of appropriate dimensions

C      (ISOL_LOC of size INFO(23), SOL_LOC of size LSOL_LOC * NRHS

C      where LSOL_LOC >= INFO(23)) on that processor, between the

C      factorization and solve steps.

C

C  INFO(24) - after analysis: estimated number of entries in factors on

C      the processor. If negative, then

C      the absolute value corresponds to {\it millions} of entries

C      in the factors.

C      Note that in the unsymmetric case, INFO(24)=INFO(3).

C      In the symmetric case, however, INFO(24) < INFO(3).

C  INFO(25) - after factorization: number of tiny pivots (number of

C       pivots modified by static pivoting) detected on the processor.

C  INFO(26) - after solution:

C                 effective size in Megabytes of all working space

C                 to run  the solution phase.

C     (The maximum and sum over all processors are returned

C    respectively in INFOG(30) and INFOG(31)).

C  INFO(27) - after factorization: effective number of entries in factors

C      on the processor. If negative, then

C      the absolute value corresponds to {\it millions} of entries

C      in the factors.

C      Note that in the unsymmetric case, INFO(27)=INFO(9).

C      In the symmetric case, however, INFO(27) < INFO(9).

C      The total number of entries over all processors is

C      available in INFOG(29).

C

C

C -------------------------------------------------------------

C -------------------------------------------------------------

C RINFO is a REAL/DOUBLE PRECISION array of length 40 that

C       need not be set by the user. This array supplies

C       local information on the execution of CMUMPS.

C

C

C RINFOG is a REAL/DOUBLE PRECISION array of length 40 that

C       need not be set by the user. This array supplies

C       global information on the execution of CMUMPS.

C       RINFOG is only significant on processor 0

C

C

C  RINFO(1) hold the estimated number of floating-point operations

C           for the elimination process on the local processor

C

C  RINFOG(1) hold the estimated number of floating-point operations

C           for the elimination process on all processors

C

C  RINFO(2)  Number of floating-point operations

C     for the assembly process on local processor.

C

C  RINFOG(2) Number of floating-point operations

C     for the assembly process.

C

C  RINFO(3)  Number of floating-point operations

C     for the elimination process on the local processor.

C

C  RINFOG(3)  Number of floating-point operations

C     for the elimination process on all processors.

C

C----------------------------------------------------

C Statistics produced after solve with error analysis

C----------------------------------------------------

C

C  RINFOG(4) Infinite norm of the input matrix.

C

C  RINFOG(5) Infinite norm of the computed solution, where

C

C  RINFOG(6) Norm of scaled residuals

C

C  RINFOG(7), `RINFOG(8) and `RINFOG(9) are used to hold information

C     on the backward error.

C     We calculate an estimate of the sparse backward error using the

C     theory and measure developed

C     by Arioli, Demmel, and Duff (1989). The scaled residual w1

C     is calculated for all equations except those

C     for which numerator is nonzero and the denominator is small.

C     For the exceptional equations, w2, is used instead.

C     The largest scaled residual (w1) is returned in

C     RINFOG(7) and the largest scaled

C     residual (w2) is returned in `RINFOG(8)>. If all equations are

C     non exceptional then zero is returned in `RINFOG(8).

C     The upper bound error is returned in `RINFOG(9).

C

C  RINFOG(14) Number of floating-point operations

C     for the elimination process (on all fronts, BLR or not)

C     performed when BLR option is activated on all processors.

C     (equal to zero if BLR option not used, ICNTL(35).EQ.1)

C

C  RINFOG(15) - after analysis: if the user decides to perform an

C     out-of-core factorization (ICNTL(22)=1), then a rough

C     estimation of the total size of the disk space in MegaBytes of

C     the files written by all processors is provided in RINFOG(15).

C

C  RINFOG(16) - after factorization: in the case of an out-of-core

C     execution (ICNTL(22)=1), the total

C     size in MegaBytes of the disk space used by the files written

C     by all processors is provided.

C

C  RINFOG(17) - after each job: sum over all processors of the sizes

C      (in MegaBytes) of the files used to save the instance

C

C  RINFOG(18) - after each job: sum over all processors of the sizes

C     (in MegaBytes) of the MUMPS structures.

C

C  RINFOG(19) - after factorization: smallest pivot in absolute

C             value selected during factorization of the preprocessed

C             matrix A_pre and considering also

C             small pivots selected as null-pivots (see ICNTL(24))

C             and pivots on which static pivoting was applied

C

C  RINFOG(20) - after factorization: smallest pivot in absolute

C             value selected during factorization of the preprocessed

C             matrix A_pre and NOT considering

C             small pivots selected as null-pivots (see ICNTL(24))

C             and pivots on which static pivoting was applied

C

C  RINFOG(21) -  after factorization: largest pivot in absolute

C             value selected during factorization of the preprocessed

C             matrix A_pre.

C===========================

C DESCRIPTION OF KEEP8 ARRAY

C===========================

C

C   KEEP8 is a 64-bit integer array of length 150 that need not

C   be set by the user

C

C===========================

C DESCRIPTION OF KEEP ARRAY

C===========================

C

C  KEEP is an INTEGER array of length 500 that need not

C     be set by the user.

C

C

C=============================

C Description of DKEEP array

C=============================

C

C DKEEP internal control array for REAL parameters

C     of size 30

C===================================

C Default values for control arrays

C==================================

C     uninitialized values should be 0

      lwk_user = 0

      keep(1:500) = 0

      keep8(1:150)= 0_8

      info(1:80)  = 0

      infog(1:80) = 0

      icntl(1:60) = 0

      rinfo(1:40) = 0.0e0

      rinfog(1:40)= 0.0e0

      cntl(1:15)  = 0.0e0

      dkeep(1:230) = 0.0e0

C     ----------------

C     Symmetric code ?

C     ----------------

      keep( 50 ) = sym

C     Check value of SYM

      IF (sym.EQ.1) THEN

C

C     this option is not available with the complex

C     code on symmetric matrices.

C     We set KEEP(50) to 2 and will exploit symmetry

C     up to the root.

          keep(50) = 2

      ENDIF

C     -------------------------------------

C     Only options 0, 1, or 2 are available

C     -------------------------------------

      IF ( keep(50).NE.1 .and. keep(50).NE.2 ) keep( 50 ) = 0

C     threshold value for pivoting

      IF ( keep(50) .NE. 1 ) THEN

        cntl(1)   = 0.01e0

      ELSE

        cntl(1)   = 0.0e0

      END IF

      cntl(2) = sqrt(epsilon(0.0e0))

      cntl(3) = 0.0e0

      cntl(4) = -1.0e0

      cntl(5) = 0.0e0

C     Working host ?

      keep(46) = par

      IF ( keep(46) .NE. 0 .AND.

     &     keep(46) .NE. 1 ) THEN

C          ----------------------

C          If out-of-range value,

C          use a working host

C          ----------------------

           keep(46) = 1

      END IF

C     control printing

      icntl(1)  = 6

      icntl(2)  = 0

      icntl(3)  = 6

      icntl(4)  = 2

C     format of input matrix

      icntl(5)  = 0

C     maximum transversal (0=NO, 7=automatic)

      IF (sym.NE.1) THEN

       icntl(6)  = 7

      ELSE

       icntl(6)  = 0

      ENDIF

C     Ordering option (icntl(7))

C     Default is automatic choice done during analysis

      icntl(7) = 7

C     ask for scaling (0=NO, 4=Row and Column)

C     Default value is 77: automatic choice for analysis

      icntl(8)  = 77

C     solve Ax=b (1) or Atx=b (other values)

      icntl(9)  = 1

C     Naximum number of IR (0=NO)

      icntl(10)  = 0

C     Error analysis (0=NO)

      icntl(11)  = 0

C     Control ordering strategy

C     automatic choice

      IF(sym .EQ. 2) THEN

         icntl(12)  = 0

      ELSE

         icntl(12)  = 1

      ENDIF

C     Control of the use of ScaLAPACK for root node

C     If null space options asked, ScaLAPACK is always ignored

C        and ICNTL(13) is not significant

C     ICNTL(13) = 0 : Root parallelism on (if size large enough)

C     ICNTL(13) = 1 : Root parallelism off

      icntl(13) = 0

C     Default value for the memory relaxation

      IF (sym.eq.1.AND.nslaves.EQ.1) THEN

        icntl(14) = 5  ! it should work with 0

      ELSE

        icntl(14) = 20

      END IF

      IF (nslaves.GT.4) icntl(14) = icntl(14) + 5

      IF (nslaves.GT.8) icntl(14) = icntl(14) + 5

      IF (nslaves.GT.16) icntl(14)= icntl(14) + 5

C     Distributed matrix entry

      icntl(18) = 0

C     Schur  (default is not active)

      icntl(19) = 0

C     dense RHS by default

      icntl(20) = 0

C     solution vector centralized on host

      icntl(21) = 0

C     out-of-core flag

      icntl(22) = 0

C     MEM_ALLOWED (0: not provided)

      icntl(23) = 0

C     null pivots

      icntl(24) = 0

C     blocking factor for multiple RHS during solution phase

      icntl(27) = -32

C     analysis strategy: 0=auto, 1=sequential, 2=parallel

      icntl(28) = 1

C     tool used for parallel ordering computation :

C     0 = auto, 1 = PT-SCOTCH, 2 = ParMETIS

      icntl(29) = 0

C     Default BLR compression rate of factors (60%)

      icntl(38) = 600

      icntl(55) = 0

      icntl(56) = 0

      icntl(57) = 0

#if defined(__ve__)

      icntl(58) = 2

#else

      icntl(58) = 1

#endif

C===================================

C Default values for some components

C of KEEP array

C===================================

      keep(12) = 0

      keep(24) = 18

      keep(68) = 0

      keep(30) = 2000

      keep(36) = 1

      keep(1) = 5

      keep(7)  = 150

      keep(8)  = 120

      keep(57) = 2000

      keep(58) = 1000

      IF ( sym .eq. 0 ) THEN

        keep(4)  = 32

        keep(3)  = 96

        keep(5)  = 16

        keep(6)  = 32

        keep(9)  = 700

        keep(85) =  300

        keep(62) =  50

      ELSE

        keep(4)  = 24

        keep(3)  = 96

        keep(5)  = 16

        keep(6)  = 32

        keep(9)  = 400

        keep(85) = 100

        keep(62) = 50

      END IF

      keep(63) = 60

      keep(48) = 5

      CALL cmumps_set_type_sizes( keep(34), keep(35),

     &                            keep(16), keep(10) )

      keep(51) = 70

      keep(37) = max(800, int(sqrt(real(nslaves+1))*real(keep(51))))

      IF ( nslaves > 256 ) THEN

        keep(39) = 10000

      ELSEIF ( nslaves > 128 ) THEN

        keep(39) = 20000

      ELSEIF ( nslaves > 64 ) THEN

        keep(39) = 40000

      ELSEIF ( nslaves > 16 ) THEN

        keep(39) = 80000

      ELSE

        keep(39) = 160000

      END IF

      keep(40) = -1 - 456789

      keep(45) = 0

      keep(47) = 2

      keep(64) = 20

      keep(69) = 4

C     To disable SMP management when using new mapping strategy

C      KEEP(69) = 1

C     Forcing proportional is ok with strategy 5

      keep(75) = 1

      keep(76) = 2

      keep(77) = 30

      keep(79) = 0  ! old splitting

      IF (nslaves.GT.4) THEN

          keep(78)=max(

     &       int(log(real(nslaves))/log(real(2))) - 2

     &       , 0         )

      ENDIF

      keep(210) = 2

      keep8(79) = -10_8

      keep(80) = 1

      keep(81) = 0

      keep(82) = 30

      keep(83) = min(8,nslaves/4)

      keep(83) = max(min(4,nslaves),max(keep(83),1))

      keep(86)=1

      keep(87)=0

      keep(88)=0

      keep(90)=1

      keep(91)=min(8, nslaves)

      keep(91) = max(min(4,nslaves),min(keep(83),keep(91)))

      IF(nslaves.LT.48)THEN

         keep(102)=150

      ELSEIF(nslaves.LT.128)THEN

         keep(102)=150

      ELSEIF(nslaves.LT.256)THEN

         keep(102)=200

      ELSEIF(nslaves.LT.512)THEN

         keep(102)=300

      ELSEIF(nslaves.GE.512)THEN

         keep(102)=400

      ENDIF

#if defined(OLD_OOC_NOPANEL)

      keep(99)=0  ! no panel -> synchronous / no buffer

#else

      keep(99)=4  ! new OOC -> asynchronous + buffer

#endif

      keep(100)=0

      keep(114) = 1

C     Threshold value for null pîvot detection during

C     LU factorization on root in case of RR

      keep(118)=41

C     strategy for MUMPS_BLOC2_GET_NSLAVESMIN

      keep(119)=0

C     Scaling is enabled by default with the Schur complement option

      keep(125) = 1

      keep(197)=0

#if defined(__ve__)

C     More amalgamation of small fronts to better exploit vector engine

      keep(197)=1

#endif

C     KEEP(199) for MUMPS_PROCNODE, MUMPS_TYPENODE, etc

C     KEEP(199)=NSLAVES + 7

      keep(199)=-1

      keep(200)=0 ! root pre-assembled in id%S

C     Pre-assemble type 3 root in id%S if no L0-OMP,

C     allocate id%S later otherwise.

      keep(200) = -1

      keep(204)=0

      keep(205)=0

      keep(209)=-1

      keep(104) = 16

      keep(107)=0

      keep(121)=-999999

      keep(122)=15

       keep(141)=1 ! min needed

      keep(206)=1

      keep(207) = 1

      keep(211)=2

      IF (nslaves .EQ. 2) THEN

        keep(213) = 101

      ELSE

        keep(213) = 201

      ENDIF

      keep(217)=0

      keep(215)=0

      keep(216)=1

      keep(218)=250

      keep(219)=1

      IF (keep(50).EQ.2) THEN

        keep(227)= max(2,32)

      ELSE

        keep(227)= max(1,32)

      ENDIF

      keep(231) = 1

      keep(232) = 3

      keep(233) = 0

      keep(239) = 1

      keep(240) = 10

      dkeep(4) = -1.0e0

      dkeep(5) = -1.0e0

      dkeep(10) = -9e0  ! default value is 10E-1 set in fac_driver.F

      dkeep(13) = -9e0  ! to define SEUIL for postponing with RR

                        ! (default value is 10 set in fac_driver.F)

      dkeep(24) = 1000.0e0 ! gap should be larger than dkeep(14)

      dkeep(25) = 10.0e0 ! gap precision

      keep(238)=18

      keep(234)= 1

      keep(235)=-1

      dkeep(3) =-5.0e0

      dkeep(18)= 1.0e12

      keep(242) = -9

      keep(243) = -1

      keep(249)=1

!$    KEEP(249) = OMP_GET_MAX_THREADS()

      keep(250) = 1

      keep(261) = 1

      keep(262) = 0

      keep(263) = 1

      keep(266) = 0

      keep(267) = 0

      keep(268)=77

      keep(350) = 1

      keep(351) = 0

      keep(360) = 256

      keep(361) = 2048

      keep(362) = 4

      keep(363) = 512

      keep(364) = 32768

      keep(378) = 1

C     OMP parallelization of arrowheads

      keep(399) = 1

      keep(397) = -1

#if defined(__ve__)

      keep(401) = 1

#else

      keep(401) = 0

#endif

      keep(402) = 1

      keep(405) = 0 ! 1 under L0OMP

      keep(406) = 2

C     0.9 equilibration

      keep(408) = 90

      keep(420) =  4*keep(6)   ! if KEEP(6)=32 then 128

#if defined(GEMMT_AVAILABLE)

      keep(421) = -1

#endif

C     Default size of KEEP(424) is defined below.

C     It does not depend on arithmetic,

C     it is related to L1 cache size: 250 * 64 bytes

C     is about half of the cache size (32768 bytes).

C     This leaves space in cache for the destination,

C     of size 250*sizeof(arith). (4k bytes for z)

C     At each new block of size KEEP(424), there is

C     probably a cache miss on the pivot.

      keep(424) = 250

      keep(459) = 10 ! max number of panels

      keep(460) = 63 ! min panel size

      keep(461) = 10

      keep(462) = 10

      keep(466) = 1

      keep(468) = 3

      keep(469) = 3

      keep(471) = -1

      keep(479) = 1

      keep(480) = 3

      keep(472) = 1

      keep(476) = 50

      keep(477) = 100

      keep(483) = 50

      keep(484) = 50

      keep(487) = 1

      IF (keep(472).EQ.1) THEN

        keep(488) = 512

      ELSE

        keep(488) =  8*keep(6)   ! if KEEP(6)=32 then 256

      ENDIF

      keep(490) = 128

      keep(491) = 1000

      keep(492) = 1

      keep(82) = 30

      keep(493) = 0

      keep(496) = 1

      keep(495) = -1

      keep(497) = -1

C

      RETURN


      END SUBROUTINE cmumpsid


      SUBROUTINE cmumps_set_keep72(id, LP)

      USE cmumps_struc_def

      IMPLICIT NONE

      TYPE (CMUMPS_STRUC) :: id

      INTEGER LP

      IF (id%KEEP(72)==1) THEN

         id%KEEP(37) = 2*id%NSLAVES

         id%KEEP(3)=3

         id%KEEP(4)=2

         id%KEEP(5)=1

         id%KEEP(6)=2

         id%KEEP(9)=3

         id%KEEP(39)=300

         id%KEEP(7) = 3

         id%KEEP(8) = 2

         id%KEEP(57)= 3

         id%KEEP(58)= 2

         id%KEEP(63)=3

         id%CNTL(1)=0.1e0

         id%KEEP(213) = 101

         id%KEEP(85)=2

         id%KEEP(85)=-4

         id%KEEP(62) = 2

         id%KEEP(1)  = 1

         id%KEEP(51) = 2

!$       id%KEEP(360) = 2

!$       id%KEEP(361) = 2

!$       id%KEEP(362) = 1

!$       id%KEEP(363) = 2

         id%KEEP(364) = 10

         id%KEEP(420) = 4

         id%KEEP(488) = 4

         id%KEEP(490) = 5

         id%KEEP(491) = 5

         id%ICNTL(27)=-3

         id%KEEP(227)=3

         id%KEEP(30) = 1000

C        Activate L0OMP with test_mumps in case KEEP(72)=1

         id%KEEP(401) = 1

      ELSE IF (id%KEEP(72)==2) THEN

         id%KEEP(85)=2            ! default is

         id%KEEP(85)=-10000         ! default is 160

         id%KEEP(62) = 10       ! default is 50

         id%KEEP(210) = 1       ! defaults is 0 (automatic)

         id%KEEP8(79) = 160000_8

         id%KEEP(1) = 2  ! default is 8

         id%KEEP(102) = 110     ! defaults is 150 up to 48 procs

         id%KEEP(213) = 121   ! default is 201

      END IF

      RETURN


      END SUBROUTINE cmumps_set_keep72

cmumps_set_type_sizes
subroutine cmumps_set_type_sizes(k34, k35, k16, k10)
Definition cini_defaults.F:18

cmumpsid
subroutine cmumpsid(nslaves, lwk_user, cntl, icntl, keep, keep8, info, infog, rinfo, rinfog, sym, par, dkeep, myid)
Definition cini_defaults.F:67

cmumps_set_keep72
subroutine cmumps_set_keep72(id, lp)
Definition cini_defaults.F:1302

min
#define min(a, b)
Definition macros.h:20

max
#define max(a, b)
Definition macros.h:21

cmumps_struc_def
Definition cmumps_struc_def.F:14