Renumbering and symbolic factorization: MLTPRE
===================================================

For convenience, the prefix NU has been omitted in front of the structure names.

**Data structures read**.

From the data structure: nume_ddl, we extract the records:

NUME. DELG: Indicates whether the degree of freedom is "Lagrange" or not.

NUME. DEEQ,

NUME. NUEQ,

NUME. PRNO: These 3 recordings establish the links between the degrees of freedom subject to a boundary condition and the corresponding Lagranges.

The next 3 records describe a "Morse" matrix.

SMOS. SMHC: Term column number

SMOS. SMDI: Addresses of diagonal terms

SMOS. SMDE.: Numbers of unknowns, and terms in the matrix

**Written data structures.**

(In front of each *Code_Aster* structure, we wrote the name of the corresponding table FORTRAN, which will be used later for more convenience.)

MLTF. ADNT ADINIT: addresses of the initial terms in the factored matrix

MLTF. LGBL LGBLOC: length of the blocks of the factored matrix

MLTF. LGSN LGSN: length of the supernodes

MLTF. LOCL LOCAL: used in assembling front matrices, correspondence between the local numbers of the father and son supernode.

MLTF. ADRE ADRESS

MLTF. SUPN SUPND: definition of supernodes

MLTF. FILS FILS: son of the supernodes in the elimination tree

MLTF. FRER FRERE: brother of the supernodes in the elimination tree

MLTF. LGSN LGSN: length of the supernodes

MLTF. LFRN LFRONT: order of the frontal matrices (after elimination)

MLTF. NBAS NBASS: pointer linked to the assembly of the front matrices

MLTF. ADPI ADPILE: addresses in the front-end matrix stack

MLTF. ANCI ANC: inverse renumbering table

MLTF. NBLI NBLIGN: order of the frontal matrices (before elimination)

MLTF. NCBL NCBLOC: number of degrees of freedom for each block

MLTF. DECA DECAL: offset between the start of the column of a supernode and the start of the block JEVEUX that contains it

MLTF. SEQU SEQ: order of elimination of supernodes (tree path).

These data structures will be described in the following paragraphs.

**Code description.**

There are 2 phases, the first consists in renumbering, the second in what is called in the language of the multi-frontal method, symbolic factorization.

Data structure NUME_DDL describes a numbering of :math:`\text{NEQ}` degrees of freedom, including, most of the time, so-called Lagrange degrees of freedom. These degrees of freedom must satisfy the following order relationship:

(1) :math:`\mathit{L1}<U<\mathit{L2}`, if :math:`\mathit{L1}` and :math:`\mathit{L2}` are the "Lagranges" associated with the boundary condition on :math:`U`.

In order to maintain this order, we will subject only the degrees of freedom that are not "Lagranges" to the renumbering algorithm. The "Lagranges" degrees of freedom are therefore removed and the information concerning them is stored in order to reintegrate them into the new numbering, while satisfying (1).

**Routines called** (a first brief description of the code).

For the first phase, the routines called are as follows:

PREML0: extraction of information on the "Lagranges"

PREMLA: treatment for linear relationship "Lagranges"

PREML1: pre-treatment and renumbering.

PREMLC: post-processing of the renumbering (addition of "Lagranges").

PREMLD: same

For the second:

PREML2: symbolic factorization.




PREML0
------

The blocking "Lagranges" are stored in tables :math:`\mathit{LBD1}`, :math:`\mathit{LBD2}`, and in :math:`\mathit{RL}` the linear relationship "Lagranges".

We get a new numbering from :math:`1` to :math:`\mathit{N2}` of the degrees of freedom without Lagrange, defined by:

:math:`P` of :math:`\mathrm{[}1\mathrm{:}\text{NEQ}\mathrm{]}\mathrm{\Rightarrow }\mathrm{[}1\mathrm{-}\mathit{N2}\mathrm{]}`, and :math:`Q` Inverse of :math:`P`.

For :math:`I` from :math:`1` to :math:`\text{NEQ}`, if :math:`I` is a blocked degree of freedom, :math:`\mathit{LBD1}(I)`, (resp. :math:`\mathit{LBD2}(I)`), is the sound number L1 (resp. :math:`\mathit{L2}`).

In the case of :math:`\mathit{NRL}` linear relationships, we will have:

:math:`\mathit{RL}(\mathrm{1,}I)`: :math:`\mathit{L1}` of the relationship :math:`I`,

:math:`\mathit{RL}(\mathrm{2,}I)`: :math:`\mathit{L2}` of the :math:`I` relationship.

*N.B. Programming*

*In some routines, we'll use the variable name* :math:`\mathit{N1}` *instead of* :math:`\text{NEQ}` *.*




PREMLA
------

For all degrees of freedom :math:`\mathit{L2}` of linear relationship, (second "Lagrange"), its lower-numbered neighbors are known by extracting information from the SMOS data structure. SMHC (table COL).

From this information, PREMLAcrée linked lists (tables DEB, VOIS, SUIT) (tables,,) for the degrees of freedom of linear relationship :math:`\mathit{L2}`.

Let :math:`J` be a degree of freedom included in a linear relationship, :math:`\mathit{j0}\mathrm{=}\mathit{DEB}(j)` is the address of the first neighbor of :math:`J` in table :math:`\mathit{VOIS}`, :math:`\mathit{J1}\mathrm{=}\mathit{SUIV}(\mathit{J0})` is the address of the next neighbor, :math:`\mathit{J2}\mathrm{=}\mathit{SUIV}(\mathit{J1})` is the address of the next neighbor, and so on.

This linked list will be used later in PREML1, for the manufacture of :math:`\mathit{ADJNCY}`.

*N.B. Memory Allowance*

*The linked list consists of 2 local structures, names* NOMVOI *and* NOMSUI *, (created by* WKVECT *and destroyed at the end of* MLTPRE *) .*

*Their length:* :math:`\mathit{LGLIST}` *,* *is estimated a priori* *by* PREML0 *(output parameter* :math:`\text{LT}` *), if insufficient,* PREMLA *provides an error code, and is called again with structures whose length is*2 times larger. *




PREML1
------

PREML1 calls the following routines:

PRMADJ, GENMMD, AMDBAR, ONMETL.

The essential role of PREML1 is to start renumbering. This, carried out at your choice by: METIS (dissection method), GENMMD (minimum degree) or AMDBAR (improved minimum degree), requires 2 prior actions.




Reconstitution of nodes (in the sense of discretization by finite elements).
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

In a first version of the code, the renumbering algorithm worked on the :math:`\mathit{N2}` degrees of freedom (without Lagranges).

We then wanted to preserve the internal order of the unknowns within the finite element discretization nodes (for example :math:`\mathit{ux}`, :math:`\mathit{uy}`, :math:`\mathit{uz}`, :math:`p`).

A development has been carried out for this purpose. **On** **now subjects all the nodes to the renumbering algorithm and not the** :math:`\mathit{N2}` **degrees of liberty**.

We therefore form a new set of :math:`\mathit{NBND}` nodes and 2 associated pointers:

:math:`\mathit{NŒUD}\mathrm{[}\mathrm{1 }\mathrm{:}\mathit{N2}\mathrm{]}\mathrm{\Rightarrow }\mathrm{[}\mathrm{1 }\mathrm{:}\mathit{NBND}\mathrm{]}`, and the reverse pointer :math:`\mathit{DDL}\mathrm{[}\mathrm{1 }\mathrm{:}\mathit{NBND}\mathrm{]}`

We thus have 3 numberings:


*
    * Initial numbering from :math:`1` to :math:`\text{NEQ}`,


    * That of the degrees of freedom without Lagranges :math:`1` to :math:`\mathit{N2}`,


    * That of interpolation nodes :math:`1` to :math:`\mathit{NBND}`.

Equipped with tables :math:`P` and :math:`Q` between the first and the second, :math:`\mathit{NŒUD}` and :math:`\mathit{DDL}` between the second and the third.




Creating the structure (:math:`\mathit{ADJNCY}`, :math:`\mathit{XADJ}`)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

This structure is the standard data structure for the renumbering algorithms mentioned above. We have 2 tables :math:`\mathit{ADJNCY}` and :math:`\mathit{XADJ}` defined as follows:

Being a :math:`I` node, its neighbors are stored in table :math:`\mathit{ADJNCY}`, between the addresses :math:`\mathit{XADJ}(I)+1` and :math:`\mathit{XADJ}(I+1)`.

First, we create a :math:`(\mathit{ADJNCY},\mathit{XADJ})` structure relating to the :math:`\mathit{N2}` degrees of freedom, then the routine PRMADJ transforms it into a structure :math:`(\mathit{ADJNCY},\mathit{XADJD})` relating to the :math:`\mathit{NBND}` nodes.

To create :math:`\mathit{ADJNCY}`, we use the :math:`(\mathit{DEB},\mathit{VOIS},\mathit{SUIT})` linked list created by PREMLA, by forcing the degrees of freedom of a linear relationship to be neighbors. So these degrees of freedom will be in the same super node, as will their :math:`\mathit{L2}`. The order relationship will thus be respected.

We then make the call to GENMMD, AMDBAR, or METIS. The usual results of this algorithm are obtained:


1. Renumbering,


2. Definition of supernodes,


3. Arborescence

The sources of these 3 methods are in the public domain.

Regarding the last 2 points, they had to be adapted. Renumbering concerns nodes (:math:`1` to :math:`\mathit{NBND}`), it has the form of 2 tables that are the opposite of each other: :math:`\mathit{INVPND}`, :math:`\mathit{PERMND}`. (:math:`\mathit{INVPND}(I)` is the new node number :math:`I`).

The tree, on the other hand, focuses on the supernodes created by renumbering. Supernode :math:`\mathit{SND}` is defined as follows: it consists of node segment :math:`\mathrm{[}\mathit{SPNDND}(\mathit{SND}\mathrm{-}1)+\mathrm{1,}\mathit{SPNDND}(\mathit{SND})\mathrm{]}`. :math:`\mathit{SPNDND}` is thus an injection from segment :math:`\mathrm{[}\mathrm{1 }\mathrm{:}\mathit{NBSND}\mathrm{]}` to :math:`\mathrm{[}\mathrm{1 }\mathrm{:}\mathit{NBND}\mathrm{]}`, :math:`\mathit{NBSND}`: number of supernodes.

The tree is defined as follows: :math:`\mathit{PARENT}(\mathit{SND})` is the "father" node of supernode :math:`\mathit{SND}`.

*N.B. Programming*

*The multi-front end supernode tree appears under* *2 names:* :math:`\mathit{PARENT}` *and* :math:`\mathit{PAREND}`

*The first contains the tree of SNs excluding Lagrange, it is provided by renumbering (* GENMMD/AMDBAR/METIS *. )*

*The second is the complement of the first by adding the Lagranges, it is calculated by* PREMLC *starting from the first.*

In the program calling MLTPRE, :math:`\mathit{PARENT}`, which is an intermediary, is stored in :math:`\mathit{ZI}` at the address :math:`\mathit{SEQ}`, reused later (saving space).

These previous tables are defined according to the :math:`\mathit{NBND}` discretization nodes of*Code_Aster*, (:math:`1` to :math:`\mathit{NBND}`). They are then rebuilt in the numbering of the :math:`\mathit{N2}` degrees of freedom not "Lagrange".

So :math:`\mathit{INVPND}` becomes :math:`\mathit{INVP}`, :math:`\mathit{PERMND}` becomes :math:`\mathit{PERM}`, and :math:`\mathit{SPNDND}` becomes :math:`\mathit{SUPND}`. (See loops 400 405 406 407 from PREML1).

N.B. Memory Allocation

*The structure* :math:`(\mathit{XADJ},\mathit{ADJNCY})` *of* PREML1 *, is called* :math:`(\mathit{XADJ2},\mathit{ADJNC2})` *in* MLTPRE\ *. It is created before* PREML1 *and destroyed afterwards. The length of* :math:`\mathit{ADJNC2}` *,* :math:`\mathit{LGADJN}` *,* * *is estimated to* :math:`2\mathrm{\times }(\mathit{lmat}\mathrm{-}\text{neq}+\mathit{lglist})` *, with* :math:`\mathit{lglist}` *= length of the neighbor list used in* PREML0

:math:`\mathit{lmat}` *= length of the initial matrix (provided by* SMOS *) .*

*If* :math:`\mathit{LGADJN}` *is insufficient,* PREML1 *provides the required length in return code, and is restarted.*

NB. METIS

*Previously, we produced a software executable* METIS *, written in C, compiled and linked separately. This executable was called through* APLEXT *, the call layer of an external executable by Code_Aster. Now the routines of* METIS *are compiled and called by a call to* ONMETL *, calling C function.*




PREMLC
------

At the output of PREML1, the results are expressed in terms of non-" Lagrange" degrees of freedom (:math:`1` to :math:`\mathit{N2}`), the routine PREMLC completes the numbering from :math:`1` to :math:`\mathit{N2}` by adding the "Lagrange" and by creating new supernodes.

The "Lagranges" are included in the new numbering as follows:

For each :math:`\mathit{L1}`, a new :math:`\mathit{SN}` supernode is created, consisting of a single degree of freedom (:math:`\mathit{L1}`), and the son of the first degree of freedom of which it is the "Lagrange" (locked or linear relationship). By being the son of this degree of freedom, he will be eliminated before, which is the rule.

For :math:`\mathit{L2}`, we don't create a new :math:`\mathit{SN}`, we just add an additional degree of freedom (:math:`\mathit{L2}`) to the supernode containing the degree of freedom (locked or R.L.) of which it is the "Lagrange".

In case of a linear relationship, all the degrees of freedom of the relationship are put by the algorithm into the same supernode. This is achieved in the previous paragraph (PREML1), during the fabrication of the :math:`\mathit{ADJNCY}` structure, by forcing the degrees of freedom of the linear relationships to be neighboring each other, by means of the linked list (:math:`\mathit{DEB}`, :math:`\mathit{VOIS}`, :math:`\mathit{SUIV}`).

We get the new renumbers :math:`\mathit{NOUV}` and :math:`\mathit{ANC}` on :math:`\mathrm{[}1\mathrm{:}\text{NEQ}\mathrm{]}`, for all degrees of freedom in the new numbering, :math:`\mathit{ANC}(I)` will provide its number in the initial numbering. :math:`\mathit{NOUV}` is the opposite table.

:math:`\mathit{NBSN}` the new number of supernodes and :math:`\mathit{SUPND}\mathrm{[}1\mathrm{:}\mathit{nbsnd}+1\mathrm{]}` defines these :math:`\mathit{SN}`.

Supernode :math:`\mathit{SN}` consists of node segment :math:`\mathrm{[}\mathit{SUPND}(\mathit{SN}\mathrm{-}1)+\mathrm{1,}\mathit{SUPND}(\mathit{SN})\mathrm{]}`.

:math:`\mathit{SUPND}` is thus an application from segment :math:`\mathrm{[}\mathrm{1 }\mathrm{:}\mathit{NBSN}\mathrm{]}` to :math:`\mathrm{[}\mathrm{1 }\mathrm{:}\text{NEQ}\mathrm{]}`.

*N.B. Memory Allowance*

:math:`\mathit{LGIND}` *is the estimated length of the arrays* :math:`\mathit{GLOBAL}` *AND* :math:`\mathit{LOCAL}` *, (See farther* :ref:`2.6 <Ref313437826>` *) that are allocated before* *PREML2 (* :math:`\mathit{NOPGLO}` *and* :math:`\mathit{NOPLOC}` *)*

:math:`\mathit{LGIND}` *is primarily a result of renumbering, provided by* PREML1 *and* *increased by* PREMLC *depending on boundary conditions.*

:math:`\mathit{LGIND}` *is an overestimation of* :math:`\mathit{GLOBAL}` *and* :math:`\mathit{LOCAL}` *we don't want to keep a structure that's too important.*

*So, after* PREML2 *, we know the real length of these arrays, we redefine* :math:`\mathit{LGIND}` *to this value, and we copy* :math:`\mathit{GLOBAL}` *and* :math:`\mathit{LOCAL}` *into structures* :math:`\mathit{NOMGLO}` *and* :math:`\mathit{NOMLOC}` *of exact length.*




PREMLD
------

This is a technical step: this routine makes a :math:`\mathit{ADJNCY}` structure like those used by renumbering algorithms, this time all degrees of freedom from :math:`1` to :math:`\text{NEQ}` are taken into account.

*N.B. Memory Allowance*

*The structure* :math:`(\mathit{XADJ},\mathit{ADJNCY})` *made by* PREMLD *, is called* :math:`(\mathit{XADJ1},\mathit{ADJNC1})` *in* MLTPRE\ *.*

*We use the same length* :math:`\mathit{LGADJN}` *calculated previously*.


.. _Ref313437826:




PREML2
------

This is the second phase of MLTPRE: among other things, we perform symbolic factorization, which is a simulation of real factorization, without floating operation, intended to facilitate the work of real factorization, by manufacturing certain necessary pointers.

PREML2 calls the following routines:


* FACSMB: symbolic factorization itself.


* MLTPOS: fabrication of the factorization sequence, i.e., raising the tree defined by table :math:`\mathit{PAREND}`, which thus defines the order in which supernodes are eliminated.


* MLTBLC: We define here the division into blocks of the factored matrix, virtually "out of core", because it is divided into blocks that can be released by the JEVEUX software package.


* MLTPAS: Here we calculate the address of the initial coefficients in the factored matrix.




FACSMB
~~~~~

**Data** (They are the result of renumbering):

:math:`\mathit{SUPND}`

:math:`\mathit{PAREND}`,

(And from the initial topology):

:math:`\mathit{ADJNCY}`.

**Results**:

:math:`\mathit{GLOBAL}`

:math:`\mathit{LOCAL}`

:math:`\mathit{ADRESS}`

:math:`\mathit{NBASS}`

:math:`\mathit{DEBFAC}`

:math:`\mathit{DEBFSN}`

:math:`\mathit{LGSN}`

:math:`\mathit{LFRON}`

:math:`\mathit{FILS}`

:math:`\mathit{FRERE}`.

These tables are described below.

:math:`\mathit{FILS}` and :math:`\mathit{FRERE}` are the "inverse" arrays of table :math:`\mathit{PAREND}`, they allow you to know all the "child" supernodes of a given supernode :math:`\mathit{SN}`, they are :math:`\mathit{FILS}(\mathit{SN})`, :math:`\mathit{FRERE}(\mathit{FILS}(\mathit{SN}))`, and so on. For the other results, it is necessary to return to the basic principles of the multi-frontal method, using the following figures:


+-----------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                             |
+ .. image:: images/100000000000041C000001B681D7F3E828138D17.png                                                              +
|    :width: 6.8126in                                                                                                         |
+    :height: 2.8362in                                                                                                        +
|                                                                                                                             |
+                                                                                                                             +
|                                                                                                                             |
+-----------------------------------------------------------------------------------------------------------------------------+



.. _Ref314476805:


.. _Ref302564019:

**Figure** **1 Assembling 2 daughter matrices into a mother matrix**


+-----------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                             |
+ .. image:: images/1000000000000394000001CEA24FD123DA6F62FC.png                                                              +
|    :width: 6.8126in                                                                                                         |
+    :height: 3.4362in                                                                                                        +
|                                                                                                                             |
+                                                                                                                             +
|                                                                                                                             |
+-----------------------------------------------------------------------------------------------------------------------------+



.. _Ref3144768051:


.. _Ref3025640191:

**Figure** **2 Front matrix** :math:`\mathit{SN}`

FIG. 1 shows the frontal matrix :math:`\mathit{SN}` (of the supernode :math:`\mathit{SN}`), consisting of the terms coming from the initial matrix, as well as the terms coming from the daughter matrices :math:`\mathit{SNF1}` and SNF2, after eliminating the supernodes :math:`\mathit{SNF1}` and :math:`\mathit{SNF2}`. After elimination, the gray part of the front matrix will constitute the columns of the factored matrix, and the remaining white part stored in the stack of front matrices will agglomerate to the mother matrix during the assembly of this last one.

The symbolic factorization performed by FACSMB will simulate this assembly/elimination process. For each supernode :math:`\mathit{SN}`, we will create a linked list containing the unknown numbers of the supernode itself, as well as the unknown numbers of the neighbors of all the sons of :math:`\mathit{SN}`. Neighbors of the sons are included, but not the sons themselves who have been eliminated.

In FORTRAN language, FACSMB produces the following tables:

:math:`\mathit{LGSN}(\mathit{SN})`: number of unknowns of the supernode :math:`\mathit{SN}` (in fact = :math:`\mathit{supnd}(\mathit{sn}+1)\mathrm{-}\mathit{supnd}(\mathit{sn})`),

:math:`\mathit{NBLIGN}(\mathit{SN})`: total number of unknowns of the SN front-end matrix

:math:`\mathit{LFRONT}(\mathit{SN})\mathrm{=}\mathit{NBLIGN}(\mathit{SN})\mathrm{-}\mathit{LGSN}(\mathit{SN})`, order of the front-end matrix after elimination that will be stored in the stack.

FACSMB also makes an array :math:`\mathit{GLOBAL}`, equipped with an array of :math:`\mathit{ADRESS}` pointers.

:math:`\mathit{GLOBAL}` contains the numbers of the unknowns of the front-end matrix :math:`\mathit{SN}` (before elimination), between the addresses :math:`\mathit{ADRESS}(\mathit{SN})` and :math:`\mathit{ADRESS}(\mathit{SN}+1)\mathrm{-}1`.

These unknowns are :math:`\mathit{NBLIGN}(\mathit{SN})\mathrm{=}(\mathit{ADRESS}(\mathit{SN}+1)\mathrm{-}\mathit{ADRESS}(\mathit{SN}))` in number.

Table :math:`\mathit{LOCAL}` is accessed as :math:`\mathit{GLOBAL}`, using table :math:`\mathit{ADRESS}`. Let :math:`\mathit{FSN1}` be the supernode "son" of the supernode :math:`\mathit{SN}`, as in the figure above, and let :math:`I` be an index between :math:`\mathit{ADRESS}(\mathit{FSN1})+\mathit{LGSN}(\mathit{FSN1})` and :math:`\mathit{ADRESS}(\mathit{FSN1}+1),\mathit{LOCAL}(I)` will be the local number (between :math:`1` and :math:`\mathit{NBLIGN}(\mathit{SN})`) of this unknown in the matrix of the supernode "father" :math:`\mathit{SN}` (we have :math:`\mathit{PAREND}(\mathit{FSN1})\mathrm{=}\mathit{SN}`).

:math:`\mathit{LOCAL}` will be used in assembling the "daughter" front-end matrix into the "parent" front-end matrix, it gives the destination address directly. This is illustrated using the following example:


+-----------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                             |
+ .. image:: images/100000000000023D0000015030F60FD78052E695.png                                                              +
|    :width: 4.4791in                                                                                                         |
+    :height: 2.9909in                                                                                                        +
|                                                                                                                             |
+                                                                                                                             +
|                                                                                                                             |
+-----------------------------------------------------------------------------------------------------------------------------+


Front-end matrix :math:`\mathit{SN}` has :math:`(p+q)` unknowns: :math:`\mathit{i1},\mathit{i2},\mathrm{..},\mathit{ip},\mathit{e1},\mathit{e2},\dots ,\mathit{eq}`, with

:math:`\mathit{NBLIGN}(\mathit{SN})\mathrm{=}p+q`

:math:`\mathit{LGSN}(\mathit{SN})\mathrm{=}p`

:math:`\mathit{LFRONT}(\mathit{SN})\mathrm{=}q`

:math:`\mathit{ADRESS}(\mathit{SN}+1)–\mathit{ADRESS}(\mathit{SN})\mathrm{=}p+q`,

:math:`\mathit{GLOBAL}\mathrm{=}\mathrm{[}\mathit{i1},\mathit{i2},\dots \mathit{ip},\mathit{e1},\mathit{e2},\dots \mathrm{..}\mathit{eq}\mathrm{]}`, with addresses varying between :math:`\mathit{ADRESS}(\mathit{SN})+1` and :math:`\mathit{ADRESS}(\mathit{SN}+1)`,

:math:`\mathit{LOCAL}\mathrm{=}\mathrm{[}\mathrm{0,0},\mathrm{..},\mathrm{0,}\mathit{l1},\mathit{l2},\dots \dots \mathrm{.}\mathit{lq}\mathrm{]}`

At the same addresses as above, :math:`\mathit{l1},\mathit{l2},\mathit{lq}` are the local numbers in the :math:`\mathit{PAREND}(\mathit{SN})` front-end matrix. (values between :math:`1` and :math:`\mathit{NBLIGN}(\mathit{PAREND}(\mathit{SN}))`).

:math:`\mathit{NBASS}`, a counter also used for assembly, is defined as follows: :math:`\mathit{NBASS}(\mathit{FSN1})` is the number of unknowns :math:`\mathit{INC}` such as :math:`\mathit{INC}<\mathit{SUPND}(\mathit{SN}+1)`, where :math:`\mathit{PAREND}(\mathit{FSN1})\mathrm{=}\mathit{SN}`. So this is the number of unknowns in :math:`\mathit{FSN1}`, assembled in the mother matrix :math:`\mathit{SN}` and which will be eliminated when :math:`\mathit{SN}` is eliminated.

:math:`\mathit{DEBFAC}` and :math:`\mathit{DEBFSN}`, these 2 tables give the same values, the first is indexed by unknown, the second by supernode, they provide, for :math:`\mathit{DEBFAC}`, the addresses of the diagonal coefficients of the unknowns in the factored matrix. For :math:`\mathit{DEBFSN}`, this is the address of the diagonal coefficient of the first unknown of the supernode.

We saw in Figure 2 that the columns corresponding to the unknowns of the eliminated supernode, (in gray), constituted the columns of the factored matrix called :math:`\mathit{FACTOR}`. The addresses of the diagonal coefficients provided by DEBFAC are addresses in a virtual array :math:`\mathit{FACTOR}` containing the factored matrix. In fact, a set of JEVEUX blocks will contain the factored matrix, and an additional pointer will be used for each block.

N.B. Programming

We can see in the previous figures that we store the columns of :math:`\mathit{SN}`, all integer, (gray rectangle), without taking into account the symmetry of the diagonal block. We thus consume a little more memory, but we are dealing with regular storage necessary for the use of routines BLAS which require storages in 2-dimensional FORTRAN arrays.




MLTPOS
~~~~~

It should be noted that the frontal matrices resulting from the removals are stored in a stack. All the daughter matrices of the same super node :math:`\mathit{SN}` are stored (stacked), consecutively. Once read (unstacked), they are no longer reused, and the front-end matrix resulting from the elimination of :math:`\mathit{SN}` is stored in their place. The length of this pile decreases or increases as you kill it, it reaches a maximum that you need to know.

MLTPOS goes through the tree, calculates :math:`\mathit{ESTIM}`, the maximum length of the stack for its subsequent allocation, constructs an array :math:`\mathit{SEQ}(\mathrm{1 }\mathrm{:}\mathit{NBSN})` that provides the order of elimination of supernodes by going through the tree from the bottom up. It provides :math:`\mathit{ADPILE}` which contains the address in the stack of the :math:`\mathit{SN}` front-end matrices.

MLTPOS contains an algorithm for renumbering the order in which supernodes are eliminated, intended to minimize the length of the front-end matrix stack ([:ref:`AS87 <AS87>`])




MLTBLC
~~~~~

This routine builds the pointers for the block division of the factored matrix. Each block will contain the columns of an integer number of supernodes. We will never encounter the configuration where the different columns of the same supernode belong to 2 blocks.

**Data**:

:math:`\mathit{MAXBLOC}`: maximum block length. Each block will contain columns for as many super nodes as possible. :math:`\mathit{MAXBLOC}` is calculated before the call to MLTBLC, it is in fact the length (in columns) of the largest of the supernodes, and the latter (generally the highest in the tree) will occupy a block by itself.

**Results**:

:math:`\mathit{NBLOC}`: Number of blocks.

:math:`\mathit{LGBLOC}(\mathrm{1 }\mathrm{:}\mathit{NBLOC})`: lengths of each block.

:math:`\mathit{NCBLOC}(\mathrm{1 }\mathrm{:}\mathit{NBLOC})`: definition of the blocks, as follows block :math:`\mathit{IB}` consists of the columns of the supernodes :math:`\mathit{SEQ}(\mathit{NCBLOC}(\mathit{IB}\mathrm{-}1)+1)`, to :math:`\mathit{SEQ}(\mathit{NCBLOC}(\mathit{IB}))`.

:math:`\mathit{DECAL}(\mathrm{1 }\mathrm{:}\mathit{NBSN})` lag table that allows access to the first diagonal term of each supernode in the factored matrix. We will illustrate this with the following diagram:

ISN =0

For IB=1, NBLOC! Loop over the blocks of the factored

JEVEUO (JEXNUM (FACTOL, IB), 'L', IFACL)

! Block IB from collection FACTOL is loaded in IFACL

For NC = 1, NCBLOC (IB)! Loop on the Supernodes of Block IB

ISN = ISN +1

SN= SEQ (ISN)! We follow the elimination sequence

ADFAC = IFACL + DECAL (SN) —1

! ADFAC is the address in ZR of the first coefficient of the supernode SN




MLTPAS
~~~~~

This routine calculates the addresses in the factored matrix, coefficients from the initial matrix.

These addresses are stored in structure MLTF. ADNT, whose name is FORTRAN :math:`\mathit{ADINIT}` or :math:`\mathit{COL}` and whose length is :math:`\mathit{LMAT}`.

N.B. Programming particularity.

*Some addresses calculated of* :math:`\mathit{ADINIT}` *are negative. Indeed in the non-symmetric case, we have 2 initial matrices* :math:`\mathit{MATI}` *and* :math:`\mathit{MATS}` *which have the same topology, (same neighbors, same trough), the symbolic factorization is the same.*

*However, it may happen that a coefficient of* :math:`\mathit{MATI}` *(lower part of the initial matrix), has a destination in the upper part of the factored matrix. (In the same way between* :math:`\mathit{MATS}` *and the lower part of the factorized one). In this case the address of the initial coefficient is stored negative and the routine for injecting the coefficients of the initial matrix,* * *MLTASAle takes into account and addresses the coefficients* correctly.

IF (CODE .GT.0) THEN

ZR (IFACL + ADPROV - DEB) = ZR (MATI +I1-1): MATI injected into IFACL (ower)

ZR (IFACU + ADPROV - DEB) = ZR (MATS +I1-1)

ELSE

ZR (IFACL + ADPROV - DEB) = ZR (MATS +I1-1)

ZR (IFACU + ADPROV - DEB) = ZR (MATI +I1-1) MATI injected into IFACU (pper)

ENDIF




MLTPRE call tree
-----------------------


+----------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                            |
+ .. image:: images/100000000000042E000001E691EA26C9734CA710.png                                                             +
|    :width: 6.889in                                                                                                         |
+    :height: 3.1283in                                                                                                       +
|                                                                                                                            |
+                                                                                                                            +
|                                                                                                                            |
+----------------------------------------------------------------------------------------------------------------------------+