wrrestp.F

Go to the documentation of this file.

Copyright>        OpenRadioss
Copyright>        Copyright (C) 1986-2025 Altair Engineering Inc.
Copyright>
Copyright>        This program is free software: you can redistribute it and/or modify
Copyright>        it under the terms of the GNU Affero General Public License as published by
Copyright>        the Free Software Foundation, either version 3 of the License, or
Copyright>        (at your option) any later version.
Copyright>
Copyright>        This program is distributed in the hope that it will be useful,
Copyright>        but WITHOUT ANY WARRANTY; without even the implied warranty of
Copyright>        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
Copyright>        GNU Affero General Public License for more details.
Copyright>
Copyright>        You should have received a copy of the GNU Affero General Public License
Copyright>        along with this program.  If not, see <https://www.gnu.org/licenses/>.
Copyright>
Copyright>
Copyright>        Commercial Alternative: Altair Radioss Software
Copyright>
Copyright>        As an alternative to this open-source version, Altair also offers Altair Radioss
Copyright>        software under a commercial license.  Contact Altair to discuss further if the
Copyright>        commercial version may interest you: https://www.altair.com/radioss/.
!||====================================================================
!||    wrrestp                      ../engine/source/output/restart/wrrestp.F
!||--- called by ------------------------------------------------------
!||    resol                        ../engine/source/engine/resol.F
!||--- calls      -----------------------------------------------------
!||    alelag_wrest                 ../engine/source/output/restart/wrrest.F
!||    checksum_restart_write       ../common_source/modules/output/checksum_mod.F90
!||    close_c                      ../common_source/tools/input_output/write_routines.c
!||    compress_i_nnz               ../common_source/comm/compress_nnz.F
!||    compress_r_nnz               ../common_source/comm/compress_nnz.F
!||    convwrest                    ../engine/source/output/restart/wrrest.F
!||    crkxfem_wrest                ../engine/source/output/restart/wrrest.F
!||    crkxfem_wrestanim            ../engine/source/output/restart/wrrest.F
!||    cur_fil_c                    ../common_source/tools/input_output/write_routines.c
!||    drape_wrest                  ../engine/source/output/restart/wrrest.F
!||    eigwrest                     ../engine/source/output/restart/wrrest.F
!||    file_size                    ../common_source/tools/input_output/write_routines.c
!||    fvwrest                      ../engine/source/output/restart/wrrest.F
!||    fxbwrest                     ../engine/source/output/restart/wrrest.F
!||    fxfluxwrest                  ../engine/source/constraints/thermic/fxfluxwrest.F
!||    fxtempwrest                  ../engine/source/output/restart/wrrest.F
!||    imp_trans                    ../engine/source/output/restart/wrrest.F
!||    impwrest                     ../engine/source/output/restart/wrrest.F
!||    intfric_wresti               ../common_source/modules/interfaces/intbuf_fric_mod.F90
!||    intfric_wrestr               ../common_source/modules/interfaces/intbuf_fric_mod.F90
!||    intstamp_wresti              ../engine/share/modules/intstamp_mod.F
!||    intstamp_wrestr              ../engine/share/modules/intstamp_mod.F
!||    nfwrest                      ../engine/source/output/restart/wrrest.F
!||    nitschewrest                 ../engine/source/output/restart/wrrest.F
!||    open_c                       ../common_source/tools/input_output/write_routines.c
!||    pblast_write_engine          ../common_source/modules/loads/pblast_mod.F90
!||    ply_info_wrest               ../engine/source/output/restart/wrrest.F
!||    plyxfem_wravuply             ../engine/source/output/restart/wrrest.F
!||    plyxfem_wrest                ../engine/source/output/restart/wrrest.F
!||    plyxfem_wrestanim            ../engine/source/output/restart/wrrest.F
!||    python_serialize             ../common_source/modules/python_mod.F90
!||    radiawrest                   ../engine/source/output/restart/wrrest.F
!||    rigmatwrest                  ../engine/source/output/restart/wrrest.F
!||    rthbufwrest                  ../engine/source/output/restart/wrrest.F
!||    spmd_glob_dmin9              ../engine/source/mpi/fluid/spmd_cfd.F
!||    spmd_glob_dsum9              ../engine/source/mpi/interfaces/spmd_th.F
!||    spmd_savefi                  ../engine/source/mpi/interfaces/spmd_i7tool.F
!||    spmd_savesph                 ../engine/source/mpi/sph/spmd_sptool.F
!||    stack_wrest                  ../engine/source/output/restart/wrrest.F
!||    table_wresti                 ../engine/source/tools/curve/table_tools.F
!||    table_wrestr                 ../engine/source/tools/curve/table_tools.F
!||    thcwrest                     ../engine/source/output/restart/wrrest.F
!||    thsurf_write_restart         ../common_source/modules/interfaces/th_surf_mod.F
!||    userwi_write                 ../engine/source/user_interface/userwindow_interface_routines.F
!||    w_bufbric_22                 ../engine/source/interfaces/int22/w_bufbric_22.F
!||    w_cluster                    ../engine/source/output/cluster/w_cluster.F
!||    w_elbuf_str                  ../engine/source/elements/elbuf/w_elbuf_str.F
!||    w_failwave                   ../engine/source/output/restart/w_failwave.F
!||    w_group_str                  ../engine/source/output/restart/w_group_str.F
!||    w_line_str                   ../engine/source/output/restart/w_line_str.F
!||    w_subset_str                 ../engine/source/output/restart/w_subset_str.F
!||    w_surf_str                   ../engine/source/output/restart/w_surf_str.F
!||    wrcomi                       ../engine/source/output/restart/wrcomm.F
!||    wrcomr                       ../engine/source/output/restart/wrcomm.F
!||    write_ale_grid               ../common_source/output/restart/write_ale_grid.F90
!||    write_bcs_nrf                ../common_source/output/restart/write_bcs_nrf.F90
!||    write_bcs_wall               ../common_source/output/restart/write_bcs_wall.F90
!||    write_c_c                    ../common_source/tools/input_output/write_routines.c
!||    write_db                     ../common_source/tools/input_output/write_db.F
!||    write_dpdb                   ../common_source/tools/input_output/write_db.F
!||    write_elgroup_param          ../engine/source/output/restart/write_elgroup_param.F
!||    write_i_c                    ../common_source/tools/input_output/write_routines.c
!||    write_inivel                 ../engine/source/output/restart/write_inivel.F90
!||    write_intbuf                 ../engine/source/output/restart/write_intbuf.F
!||    write_joint                  ../engine/source/output/restart/write_joint.F
!||    write_matparam               ../engine/source/output/restart/write_matparam.F
!||    write_nloc_struct            ../engine/source/output/restart/write_nloc_struct.F
!||    write_pcyl                   ../engine/source/output/restart/write_pcyl.F
!||    write_rrbe3pen               ../engine/source/output/restart/restart_rbe3pen.F90
!||    write_rrwallpen              ../engine/source/output/restart/restart_rwallpen.F90
!||    write_sensors                ../engine/source/output/restart/write_sensors.F
!||    write_th_restart             ../engine/source/output/th/write_th_restart.F
!||    write_units                  ../common_source/comm/write_units.F
!||--- uses       -----------------------------------------------------
!||    ale_connectivity_mod         ../common_source/modules/ale/ale_connectivity_mod.F
!||    ale_mod                      ../common_source/modules/ale/ale_mod.F
!||    alefvm_mod                   ../common_source/modules/ale/alefvm_mod.F
!||    bcs_mod                      ../common_source/modules/boundary_conditions/bcs_mod.F90
!||    checksum_output_option_mod   ../common_source/modules/output/checksum_mod.F90
!||    cluster_mod                  ../engine/share/modules/cluster_mod.F
!||    connectivity_mod             ../common_source/modules/connectivity.F90
!||    damp_mod                     ../engine/share/modules/damp_mod.F
!||    drape_mod                    ../engine/share/modules/drape_mod.F
!||    ebcs_mod                     ../common_source/modules/boundary_conditions/ebcs_mod.F90
!||    ecnd_mod                     ../engine/share/modules/ecdn_mod.F
!||    elbufdef_mod                 ../common_source/modules/mat_elem/elbufdef_mod.F90
!||    glob_therm_mod               ../common_source/modules/mat_elem/glob_therm_mod.F90
!||    group_mod                    ../engine/share/modules/group_mod.F
!||    groupdef_mod                 ../common_source/modules/groupdef_mod.F
!||    h3d_mod                      ../engine/share/modules/h3d_mod.F
!||    impbufdef_mod                ../engine/share/modules/impbufdef_mod.F
!||    inoutfile_mod                ../common_source/modules/inoutfile_mod.F
!||    int8_mod                     ../common_source/modules/interfaces/int8_mod.F90
!||    intbuf_fric_mod              ../common_source/modules/interfaces/intbuf_fric_mod.F90
!||    intbufdef_mod                ../common_source/modules/interfaces/intbufdef_mod.F90
!||    interfaces_mod               ../common_source/modules/interfaces/interfaces_mod.F90
!||    intstamp_glob_mod            ../engine/share/modules/intstamp_glob_mod.F
!||    loads_mod                    ../common_source/modules/loads/loads_mod.F90
!||    mat_elem_mod                 ../common_source/modules/mat_elem/mat_elem_mod.F90
!||    monvol_struct_mod            ../engine/share/modules/monvol_struct_mod.F
!||    multi_fvm_mod                ../common_source/modules/ale/multi_fvm_mod.F90
!||    names_and_titles_mod         ../common_source/modules/names_and_titles_mod.F
!||    nodal_arrays_mod             ../common_source/modules/nodal_arrays.F90
!||    outmax_mod                   ../common_source/modules/outmax_mod.F
!||    output_mod                   ../common_source/modules/output/output_mod.F90
!||    pblast_mod                   ../common_source/modules/loads/pblast_mod.F90
!||    pinchtype_mod                ../common_source/modules/pinchtype_mod.F
!||    python_funct_mod             ../common_source/modules/python_mod.F90
!||    rbe3_mod                     ../common_source/modules/constraints/rbe3_mod.F90
!||    restart_rbe3pen_mod          ../engine/source/output/restart/restart_rbe3pen.F90
!||    restart_rwallpen_mod         ../engine/source/output/restart/restart_rwallpen.F90
!||    restmod                      ../engine/share/modules/restart_mod.F
!||    rwall_mod                    ../common_source/modules/constraints/rwall_mod.F90
!||    seatbelt_mod                 ../common_source/modules/seatbelt_mod.F
!||    sensor_mod                   ../common_source/modules/sensor_mod.F90
!||    skew_mod                     ../common_source/modules/skew_mod.F90
!||    sms_mod                      ../engine/share/modules/sms_mod.F
!||    sph_mod                      ../engine/share/modules/sph_mod.F
!||    stack_mod                    ../engine/share/modules/stack_mod.F
!||    state_mod                    ../common_source/modules/state_mod.F
!||    table_glob_mod               ../engine/share/modules/table_glob_mod.F
!||    time_mod                     ../engine/share/modules/time_mod.F
!||    unitab_mod                   ../common_source/modules/unitab_mod.F
!||    user_windows_mod             ../common_source/modules/user_windows_mod.F
!||    write_ale_grid_mod           ../common_source/output/restart/write_ale_grid.F90
!||    write_bcs_nrf_mod            ../common_source/output/restart/write_bcs_nrf.F90
!||    write_bcs_wall_mod           ../common_source/output/restart/write_bcs_wall.F90
!||    write_inivel_mod             ../engine/source/output/restart/write_inivel.F90
!||    xfem2vars_mod                ../engine/share/modules/xfem2vars_mod.F
!||====================================================================
      SUBROUTINE wrrestp(ELEMENTS, NODES, AF         ,IAF      ,ICH       ,ADDCNE,
     .                   ELBUF_TAB  ,XFEM_TAB        ,INTBUF_TAB ,MULTI_FVM   ,MAT_ELEM         ,
     .                   H3D_DATA   ,INTBUF_FRIC_TAB ,SUBSET     ,PINCH_DATA  ,ALE_CONNECTIVITY ,
     .                   T_MONVOL   ,SENSORS         ,EBCS_TAB   ,DYNAIN_DATA ,USER_WINDOWS     ,
     .                   OUTPUT     ,INTERFACES      ,LOADS      ,PYTHON      ,NAMES_AND_TITLES ,
     .                   EIGIPM     ,EIGIBUF         ,EIGRPM     ,NEIPM       ,LEIBUF           ,
     .                   NERPM      ,IFLOW           ,RFLOW      ,LIFLOW      ,LRFLOW           ,
     .                   IMPBUF_TAB ,IMPL_S          ,IMPL_S0    ,MCP         ,TEMP             ,
     .                   FORNEQS    ,UNITAB          ,STACK      ,NDRAPE      ,DRAPE_SH3N       ,
     .                   DRAPE_SH4N ,DRAPEG          ,RESTSIZE   ,SKEWS       ,GLOB_THERM       ,
     .                   PBLAST     ,RBE3            ,RWALL      )
C-----------------------------------------------
C   M o d u l e s
C-----------------------------------------------
      USE restmod
      USE nodal_arrays_mod
      USE connectivity_mod
      USE intstamp_glob_mod
      USE sms_mod
      USE table_glob_mod
      USE mat_elem_mod
      USE sph_mod
      USE intbufdef_mod
      USE int8_mod
      USE cluster_mod
      USE ecnd_mod
      USE multi_fvm_mod
      USE h3d_mod
      USE intbuf_fric_mod
      USE groupdef_mod
      USE group_mod
      USE pinchtype_mod
      USE inoutfile_mod
      USE ale_connectivity_mod
      USE monvol_struct_mod
      USE sensor_mod
      USE ebcs_mod
      USE seatbelt_mod
      USE pblast_mod
      USE outmax_mod
      USE loads_mod
      USE state_mod
      USE user_windows_mod
      USE ale_mod
      USE output_mod
      USE interfaces_mod
      USE python_funct_mod
      USE damp_mod
      USE xfem2vars_mod
      USE alefvm_mod
      USE names_and_titles_mod
      USE bcs_mod , only : bcs
      USE skew_mod
      USE impbufdef_mod, only: impbuf_struct_
      USE unitab_mod, ONLY : unit_type_
      USE stack_mod
      USE drape_mod
      USE time_mod
      USE elbufdef_mod
      use write_inivel_mod , only : write_inivel
      use glob_therm_mod
      use write_ale_grid_mod , only : write_ale_grid
      use write_bcs_wall_mod , only : write_bcs_wall
      use write_bcs_nrf_mod , only : write_bcs_nrf
      use rbe3_mod
      use restart_rbe3pen_mod, only : write_rrbe3pen
      use checksum_output_option_mod, only : checksum_restart_write
      use rwall_mod
      use restart_rwallpen_mod, only : write_rrwallpen
C-----------------------------------------------
C   I m p l i c i t   T y p e s
C-----------------------------------------------
#include      "implicit_f.inc"
C-----------------------------------------------
C   D u m m y   A r g u m e n t s
C-----------------------------------------------
      TYPE(nodal_arrays_) :: NODES
      TYPE(connectivity_) :: ELEMENTS
      INTEGER, INTENT(IN) :: NDRAPE
      INTEGER, INTENT(IN) :: IMPL_S
      INTEGER, INTENT(IN) :: IMPL_S0
      my_real, INTENT(INOUT) :: MCP(NUMNOD)
      my_real, INTENT(INOUT) :: TEMP(NUMNOD)      
      INTEGER, INTENT(INOUT) :: NEIPM, LEIBUF, NERPM
      INTEGER, INTENT(INOUT) :: EIGIPM(NEIPM,NEIG),EIGIBUF(LEIBUF)
      my_real, INTENT(INOUT) :: EIGRPM(NERPM,NEIG)
      INTEGER, INTENT(IN) :: FORNEQS(3,NUMNOD)
      INTEGER IAF(*),ICH,ADDCNE(*)
      my_real  af(*)
      TYPE(ELBUF_STRUCT_), TARGET, DIMENSION(NGROUP)      :: ELBUF_TAB
      TYPE(elbuf_struct_), TARGET, DIMENSION(NGROUP,NXEL) :: XFEM_TAB
      TYPE(intbuf_struct_) INTBUF_TAB(*)
      TYPE(multi_fvm_struct), INTENT(INOUT)               :: MULTI_FVM
c     TYPE (CLUSTER_) ,DIMENSION(NCLUSTER) :: CLUSTER
      TYPE(h3d_database), INTENT(IN)                      :: H3D_DATA
      TYPE(intbuf_fric_struct_) INTBUF_FRIC_TAB(*)
      TYPE(subset_), TARGET, DIMENSION(NSUBS)             :: SUBSET
      TYPE(pinch)                                         :: PINCH_DATA
      TYPE(t_ale_connectivity), INTENT(IN)                :: ALE_CONNECTIVITY
      TYPE(monvol_struct_), DIMENSION(NVOLU), INTENT(IN)  :: T_MONVOL
      TYPE(t_ebcs_tab), INTENT(INOUT)                     :: EBCS_TAB
      TYPE(dynain_database) ,INTENT(IN)                   :: DYNAIN_DATA
      TYPE(user_windows_)   ,INTENT(IN)                   :: USER_WINDOWS
      TYPE(OUTPUT_)         ,INTENT(INOUT)                :: OUTPUT !< output structure
      TYPE(interfaces_)     ,INTENT(IN)                   :: INTERFACES
      TYPE(sensors_)        ,INTENT(IN)                   :: SENSORS
      TYPE(loads_)          ,INTENT(IN)                   :: LOADS
      TYPE(mat_elem_)       ,INTENT(IN)                   :: MAT_ELEM
      TYPE(python_)         ,INTENT(INOUT)                :: PYTHON
      TYPE(names_and_titles_),INTENT(IN)                  :: NAMES_AND_TITLES !< NAMES_AND_TITLES host the input deck names and titles for outputs
      TYPE(skew_),INTENT(IN)                              :: SKEWS
      TYPE(impbuf_struct_), TARGET :: IMPBUF_TAB
      TYPE(unit_type_) :: UNITAB !< structure containing units conversion ratios
      TYPE (STACK_PLY) :: STACK
      TYPE(drape_)     :: DRAPE_SH3N(NUMELTG_DRAPE),DRAPE_SH4N(NUMELC_DRAPE)
      TYPE(drapeg_)    :: DRAPEG
      type (glob_therm_) ,intent(inout) :: GLOB_THERM
      TYPE(pblast_)    ,INTENT(INOUT) :: PBLAST
      TYPE(rbe3_)      ,INTENT(INOUT) :: RBE3
      TYPE(rwall_)     ,INTENT(INOUT) :: RWALL
C-----------------------------------------------
C   C o m m o n   B l o c k s
C-----------------------------------------------
#include      "chara_c.inc"
#include      "couple_c.inc"
#include      "com01_c.inc"
#include      "com04_c.inc"
#include      "com06_c.inc"
#include      "com_xfem1.inc"
#include      "intstamp_c.inc"
#include      "param_c.inc"
#include      "parit_c.inc"
#include      "scr03_c.inc"
#include      "scr05_c.inc"
#include      "scr07_c.inc"
#include      "scr14_c.inc"
#include      "scr16_c.inc"
#include      "scr19_c.inc"
#include      "scrcut_c.inc"
#include      "scrfs_c.inc"
#include      "scrnoi_c.inc"
#include      "scr_fac_c.inc"
#include      "sms_c.inc"
#include      "spmd_c.inc"
#include      "tabsiz_c.inc"
#include      "task_c.inc"
#include      "units_c.inc"
#include      "remesh_c.inc"
#include      "sphcom.inc"
#include      "inter18.inc"
C-----------------------------------------------
C   L o c a l   V a r i a b l e s
C-----------------------------------------------
      INTEGER I,J,LEN,IFILNAM(2148), IFIL,LEN_G,LEN_M,LENG,LEN_S,IXEL,
     .        FLAG_XFEM
      CHARACTER FILNAM*100, FILNAMR*100, FILNAMG*128,
     .          PROCNAM*4, CHRUNR*4,PLAST*4
      CHARACTER*1 IJK(26)
      INTEGER LHEADER,LVARINT,LVARREA,LMXVINT,LMXVREA,M
      PARAMETER (LHEADER=15)
      parameter (lmxvint=4000)
      parameter(lmxvrea=1000+30*maxlaw+30)
      INTEGER   TABHEAD(LHEADER),TABVINT(LMXVINT)
      my_real
     .          tabvrea(lmxvrea), entmp(100)
      INTEGER MY_ILEN,MY_RLEN,LTABLE, LENI, LENR
 
      INTEGER :: LEN_TMP_NAME
      CHARACTER(len=2048) :: TMP_NAME
      INTEGER, DIMENSION(NVOLU) :: NTRI
      INTEGER :: II, NS_DIFF, ITMP
      INTEGER :: MY_SIZE
      INTEGER,DIMENSION(LTITLE) :: ITITLE
      INTEGER :: SKEW_LEN
      INTEGER, INTENT(IN) :: LIFLOW  !< Size of IFLOW
      INTEGER, INTENT(IN) :: LRFLOW  !< Size of RFLOW
      INTEGER, INTENT(IN), DIMENSION(LIFLOW) :: IFLOW
      INTEGER, INTENT(IN), DIMENSION(LRFLOW) :: RFLOW
      INTEGER :: NPT
C-----------------------------------------------
C     Python interface
C-----------------------------------------------
      INTEGER, DIMENSION(:), ALLOCATABLE :: BUFFER
      INTEGER :: BUFFER_SIZE
C-----------------------------------------------
C     Restart size
      INTEGER,INTENT(INOUT) :: RESTSIZE
C-----------------------------------------------
      DATA ijk/'I','J','K','L','M','N','O','P','Q','R',
     .         'S','T','U','V','W','X','Y','Z','A','B',
     .         'C','D','E','F','G','H'/
C--------------------------------------
C     preparation of integer and real variables.
C--------------------------------------
      ipari0 = iparit
      sfr_elem = SIZE(nodes%BOUNDARY,1)
      siad_elem = SIZE(nodes%BOUNDARY_ADD,1) * SIZE(nodes%BOUNDARY_ADD,2)
      CALL wrcomi(output,lmxvint,lvarint,tabvint,1,multi_fvm,h3d_data,dynain_data,
     .     interfaces%PARAMETERS,sensors,loads,glob_therm,pblast)
C
      entmp(1) = output%TH%WFEXT
      entmp(2) = ehour
      entmp(3) = econtv
      entmp(4) = epor
      entmp(5) = glob_therm%HEAT_STORED
      entmp(6) = glob_therm%HEAT_MECA
      entmp(7) = glob_therm%HEAT_CONV
      entmp(8) = glob_therm%HEAT_RADIA
      entmp(9) = glob_therm%HEAT_FFLUX
      entmp(10)= econtd
      entmp(11)= econt_cumu
      IF(nspmd > 1) CALL spmd_glob_dsum9(entmp,11)
      IF(ispmd/=0) THEN
        output%TH%WFEXT = zero
        ehour = zero
        econtv = zero
        epor = zero
        glob_therm%HEAT_STORED = zero
        glob_therm%HEAT_MECA   = zero
        glob_therm%HEAT_CONV   = zero
        glob_therm%HEAT_RADIA  = zero
        glob_therm%HEAT_FFLUX  = zero
        econtd = zero
        econt_cumu = zero
      ELSE
        output%TH%WFEXT = entmp(1)
        ehour = entmp(2)
        econtv= entmp(3)
        epor  = entmp(4)
        glob_therm%HEAT_STORED = entmp(5)
        glob_therm%HEAT_MECA   = entmp(6)
        glob_therm%HEAT_CONV   = entmp(7)
        glob_therm%HEAT_RADIA  = entmp(8)
        glob_therm%HEAT_FFLUX  = entmp(9)
        econtd = entmp(10)
        econt_cumu = entmp(11)
      ENDIF
C
      IF(ale%GRID%NWALE == 2) THEN
        entmp(1) = ale%GRID%VGZ
        IF(nspmd > 1) CALL spmd_glob_dmin9(entmp,1)
        IF(ispmd==0) ale%GRID%VGZ = entmp(1)
      ENDIF
 
      entmp(1) = output%DATA%INOUT%DM_IN
      entmp(2) = output%DATA%INOUT%DM_OUT
      entmp(3) = output%DATA%INOUT%DE_IN
      entmp(4) = output%DATA%INOUT%DE_OUT
      IF(nspmd > 1) CALL spmd_glob_dsum9(entmp,4)
      IF(ispmd /= 0) THEN
        output%DATA%INOUT%DM_IN = zero
        output%DATA%INOUT%DM_OUT = zero
        output%DATA%INOUT%DE_IN = zero
        output%DATA%INOUT%DE_OUT = zero
      ELSE
        output%DATA%INOUT%DM_IN = entmp(1)
        output%DATA%INOUT%DM_OUT = entmp(2)
        output%DATA%INOUT%DE_IN = entmp(3)
        output%DATA%INOUT%DE_OUT = entmp(4)
      ENDIF
C
      CALL wrcomr(lmxvrea,lvarrea,tabvrea,dynain_data,interfaces%PARAMETERS,
     .            output,glob_therm)
C--------------------------------------
C     OPEN
C--------------------------------------
      WRITE(chrunr,'(I4.4)')irun
      WRITE(procnam,'(I4.4)')ispmd+1
        filnam=rootnam(1:rootlen)//'_'//chrunr//'_'//procnam
      WRITE(plast,'(I4.4)')nspmd
      filnamg=rootnam(1:rootlen)//'_'//chrunr//'_[0001-'//plast//']'
      leng = rootlen+17
      len = rootlen + 10
      filnamr = filnam
      ifil = 2
      IF(ich/=0)ifil = 41
      IF(multirest/=0.AND.mcheck==0)THEN
        irprev = 1 + mod(irprev,multirest)
        filnam=filnam(1:len)//'_'//ijk(irprev)
        len = len+2
        filnamg=filnamg(1:leng)//'_'//ijk(irprev)
        leng = leng+2
      ENDIF
      filnam=filnam(1:len)//'.rst'
      len = len +4
      filnamg=filnamg(1:leng)//'.rst'
      leng = leng+4
 
      len_tmp_name = outfile_name_len + len
      tmp_name=outfile_name(1:outfile_name_len)//filnam(1:len)
 
      DO i = 1, len_tmp_name
        ifilnam(i) = ichar(tmp_name(i:i))
      END DO
      CALL cur_fil_c(ifil)
      IF (irform/5==2) THEN
        CALL open_c(ifilnam,len_tmp_name,0)
      ELSEIF (irform/5==3) THEN
        CALL open_c(ifilnam,len_tmp_name,3)
      ELSEIF (irform/5==4) THEN
        CALL open_c(ifilnam,len_tmp_name,6)
      ENDIF
      DO i = 1, len
        ifilnam(i) = ichar(filnam(i:i))
      END DO
      CALL write_c_c(ifilnam,len)
C--------------------------------------
C     Deck title
C--------------------------------------
      DO i=1,ltitle
        ititle(i) = ichar( names_and_titles%TITLE(i:i) )
      ENDDO
      CALL write_i_c(ititle,ltitle)
C--------------------------------------
C     writing the header.
C--------------------------------------
C     RADIOSS FILE R/W
      tabhead(1) =iradios
C     RESTART FILE
      tabhead(2) =iresfil
C     ITESTV
      tabhead(3) =itestv
C     THIS RUN NUMBER
      tabhead(4) =irun
C     CODE FOR THIS RUN (-1:UNKNOWN,0:STARTER,1:ENGINE,2:MODIF)
      icodrun =1
      tabhead(5) =icodrun
C     CODVERS FOR THIS RUN
      tabhead(6) =codvers
C     MINOR VERSION CODE FOR THIS RUN
      tabhead(7) =iminver
C     SOURCE VERSION CODE FOR THIS RUN
      tabhead(8) =isrcver
C     INPUT VERSION FOR THIS RUN
      tabhead(9) =invers
C     STARTER CODVERS
      tabhead(10)=scodver
C     STARTER MINOR VERSION CODE.
      tabhead(11)=sminver
C     STARTER SOURCE VERSION CODE.
      tabhead(12)=ssrcver
C     STARTER INPUT VERSION
      tabhead(13)=invstr
C
      tabhead(14) =lvarint
      tabhead(15)=lvarrea
      CALL write_i_c(lheader, 1)
      CALL write_i_c(tabhead, lheader)
C--------------------------------------
C     writing integer variables
C--------------------------------------
      CALL write_i_c(tabvint,lvarint)
C--------------------------------------
C     WRITE CHECKSUM DIGEST
C--------------------------------------
      CALL checksum_restart_write(output%CHECKSUM)
C--------------------------------------
C     writing integers
C--------------------------------------
      len_g = npropgi*numgeo
      len_m = npropmi*nummat
      len_s = npart
        CALL write_i_c(nodes%NODGLOB,nodes%NUMNOD)
 
        CALL write_i_c(nodes%MAIN_PROC,sweight)
 
        CALL write_i_c(nodes%WEIGHT,sweight)
 
        CALL write_i_c(nodes%ICODE,sicode)
 
        CALL write_i_c(nodes%ISKEW,siskew)
 
        CALL write_i_c(iskwn,siskwn)
 
        CALL write_i_c(iframe,siframe)
 
        CALL write_i_c(neth,sneth)
 
        CALL write_i_c(ibcslag,sibcslag)
 
        CALL write_i_c(ipart,sipart)
 
        CALL write_i_c(nom_opt,snom_opt)
 
        CALL python_serialize(python,buffer, buffer_size)
        CALL write_i_c(buffer, buffer_size)
 
        CALL write_i_c(npc,snpc)
 
        CALL write_i_c(ixtg,sixtg)
 
        CALL write_i_c(ixtg1,sixtg1)
 
        CALL write_i_c(ixs,sixs)
 
        CALL write_i_c(ixq,sixq)
 
        CALL write_i_c(elements%SHELL%IXC,sixc)
 
        CALL write_i_c(ixt,sixt)
 
        CALL write_i_c(ixp,sixp)
 
        CALL write_i_c(ixr,sixr)
 
        CALL write_i_c(nodes%ITAB,sitab)
 
        CALL write_i_c(nodes%ITABM1,sitabm1)
 
        CALL write_i_c(gjbufi,sgjbufi)
 
        CALL write_i_c(ale_connectivity%NALE,ale%GLOBAL%SNALE)
 
        IF (iale + ieuler + ialelag + glob_therm%ITHERM /= 0) THEN
           itmp = SIZE(ale_connectivity%ee_connect%iad_connect)
           CALL write_i_c(itmp, 1)
           CALL write_i_c(ale_connectivity%ee_connect%iad_connect, itmp)
 
           itmp = SIZE(ale_connectivity%ee_connect%connected)
           CALL write_i_c(itmp, 1)
           CALL write_i_c(ale_connectivity%ee_connect%connected, itmp)
 
           itmp = SIZE(ale_connectivity%ee_connect%type)
           CALL write_i_c(itmp, 1)
           CALL write_i_c(ale_connectivity%ee_connect%type, itmp)
 
           itmp = SIZE(ale_connectivity%ee_connect%iface2)
           CALL write_i_c(itmp, 1)
           CALL write_i_c(ale_connectivity%ee_connect%iface2, itmp)
        ENDIF
 
        CALL write_i_c(id_global_vois,ale%GLOBAL%SIELVS)
 
        CALL write_i_c(face_vois,ale%GLOBAL%SIELVS)
 
        IF(iale > 0 .AND. ale%GRID%NWALE == 6 .OR. inter18_autoparam == 1 .OR. inter18_is_variable_gap_defined) THEN
           CALL write_i_c(ne_nercvois, nspmd + 1)
           CALL write_i_c(ne_lercvois, ne_slercvois)
           CALL write_i_c(ne_nesdvois, nspmd + 1)
           CALL write_i_c(ne_lesdvois, ne_slesdvois)
        ENDIF
        IF (iale > 0 .AND. (ale%GRID%NWALE < 2 .OR. ale%GRID%NWALE == 5.OR. ale%GRID%NWALE == 7)) THEN
           CALL write_i_c(ale_connectivity%NN_CONNECT%IAD_CONNECT, numnod + 1)
           CALL write_i_c(ale_connectivity%NN_CONNECT%CONNECTED, ale_connectivity%NN_CONNECT%IAD_CONNECT(numnod + 1))
        ENDIF
        IF (iale > 0 .AND. ale%GRID%NWALE == 6 .OR. inter18_autoparam == 1 .OR. inter18_is_variable_gap_defined) THEN
           CALL write_i_c(ale_connectivity%NE_CONNECT%IAD_CONNECT, numnod + 1)
           CALL write_i_c(ale_connectivity%NE_CONNECT%CONNECTED,
     .          ale_connectivity%NE_CONNECT%IAD_CONNECT(numnod + 1))
        ENDIF
 
        ns_diff = 0
        IF (multi_fvm%NS_DIFF) THEN
           ns_diff = 1
        ENDIF
        CALL write_i_c(ns_diff, 1)
        IF (ns_diff == 1) THEN
           CALL write_i_c(ale_connectivity%IDGLOB%ID,
     .          numels + nsvois + numelq + nqvois + numeltg + ntgvois)
        ENDIF
 
        CALL write_i_c(ifill,sifill)
 
        CALL write_i_c(ims,sims)
 
        CALL w_subset_str(subset)
 
        CALL w_group_str
 
        CALL w_surf_str(igrsurf)
 
        CALL w_line_str(igrslin)
 
        CALL write_i_c(kxx,skxx)
 
        CALL write_i_c(ixx,sixx)
 
        CALL write_i_c(kxsp,skxsp)
 
        CALL write_i_c(ixsp,sixsp)
 
        CALL write_i_c(nod2sp,snod2sp)
 
        CALL write_i_c(ispsym,sispsym)
 
        CALL write_i_c(ispcond,sispcond)
 
        CALL write_i_c(isphio,sisphio)
 
        CALL write_i_c(lprtsph,slprtsph)
 
        CALL write_i_c(lonfsph,slonfsph)
 
        CALL write_i_c(ibufssg_io,sibufssg_io)
 
        IF(nsphsol/=0)THEN
 
          CALL write_i_c(sph2sol,numsph)
 
          CALL write_i_c(sol2sph,2*numels8)
 
          CALL write_i_c(irst,3*nsphsol)
 
          CALL write_i_c(sol2sph_typ,numels8)
        END IF
 
        CALL write_i_c(ibcl,sibcl)
 
        IF (nintloadp>0) THEN
            CALL write_i_c(kloadpinter, ninter+1)
            CALL write_i_c(loadpinter,ninter*nloadp_hyd)
        ENDIF
 
        CALL write_i_c(ibfv,sibfv)
 
        CALL write_i_c(iecran,siecran)
 
        CALL write_i_c(ilas,silas)
       
        ! -----------------------------
        ! EBCS option
        CALL write_i_c(ebcs_tab%nebcs, 1) ! total number of EBCS
        CALL write_i_c(ebcs_tab%nebcs_fvm, 1) ! number of multifluid ebcs
        CALL write_i_c(ebcs_tab%nebcs_parallel, 1) ! number of parallel ebcs
        CALL write_i_c(ebcs_tab%nebcs_loc, 1) ! number of other ebcs
        leni = 0
        lenr = 0
        IF (ebcs_tab%nebcs > 0) THEN
            ! write the type of /EBCS ( /EBCS/NRF --> typ = 10) ( /EBCS/PROPELLANT --> typ = 11)
            CALL write_i_c(ebcs_tab%my_typ,ebcs_tab%nebcs)
        ENDIF
        ! -------------
        ! write the data of /EBCS options
        IF (ebcs_tab%nebcs_loc +ebcs_tab%nebcs_parallel +  ebcs_tab%nebcs_fvm> 0) THEN
           DO ii = 1, ebcs_tab%nebcs_fvm + ebcs_tab%nebcs_loc + ebcs_tab%nebcs_parallel
              CALL ebcs_tab%tab(ii)%poly%write_common_data(leni, lenr)
              CALL ebcs_tab%tab(ii)%poly%write_data(leni, lenr)
           ENDDO
        ENDIF
        ! -----------------------------
 
        CALL write_i_c(laccelm,slaccelm)
 
        CALL write_i_c(lgauge,3*nbgauge)
 
        CALL write_i_c(nnlink,snnlink)
 
        CALL write_i_c(lnlink,slnlink)
 
        CALL userwi_write(user_windows,ispmd,nspmd,numnod)
 
        CALL write_i_c(iparg,siparg)
 
        CALL write_i_c(dd_iad,sdd_iad)
 
        CALL write_i_c(igrv,sigrv)
 
        CALL write_i_c(lgrav,slgrav)
 
        CALL write_i_c(iexlnk,siexlnk)
 
        CALL write_i_c(ibvel,sibvel)
 
        CALL write_i_c(lbvel,slbvel)
 
        CALL write_i_c(irbe2,sirbe2)
 
        CALL write_i_c(lrbe2,slrbe2)
 
        CALL write_i_c(rbe3%IRBE3,rbe3%NRBE3*irbe3_variables)
 
        CALL write_i_c(rbe3%LRBE3,rbe3%lrbe3_sz)
 
        CALL write_i_c(iactiv,siactiv)
 
        CALL write_i_c(ibmpc,sibmpc)
 
        CALL write_i_c(nodes%KINET,numnod)
 
        CALL write_i_c(fasolfr,sfasolfr)
 
        CALL write_i_c(segquadfr,ssegquadfr)
 
        CALL write_i_c(ipari,sipari)
 
c        CALL WRITE_I_C(INBUF,SINBUF)
 
        CALL w_bufbric_22() !inter22
 
        !write new structure INTBUF_TAB
        CALL write_intbuf(intbuf_tab)
 
        CALL write_i_c(rwall%NPRW,rwall%NNPRW*rwall%NRWALL)
 
        CALL write_i_c(rwall%LPRW,rwall%sz_lprw)
 
        CALL write_i_c(iconx,siconx)
 
        CALL write_i_c(madprt,smadprt)
 
        CALL write_i_c(madsh4,smadsh4)
 
        CALL write_i_c(madsh3,smadsh3)
 
        CALL write_i_c(madsol,smadsol)
 
        CALL write_i_c(madnod,smadnod)
 
        CALL write_i_c(madclnod,madclnods)
 
        CALL write_i_c(madfail,smadfail)
 
        CALL write_i_c(madidx,smadidx)
 
        CALL write_i_c(npby,snpby)
 
        CALL write_i_c(npbyl,snpbyl)
 
        CALL write_i_c(lpby,slpby)
 
        CALL write_i_c(lpbyl,slpbyl)
 
        CALL write_i_c(lrivet,slrivet)
 
        CALL write_i_c(nstrf,snstrf)
 
        CALL write_i_c(nom_sect,snom_sect)
 
        CALL write_joint()
 
        CALL write_i_c(nodpor,snodpor)
 
        CALL write_i_c(monvol,smonvol)
 
        DO ii = 1, nvolu
           ntri(ii) = t_monvol(ii)%NB_FILL_TRI
        ENDDO
 
        CALL write_i_c(ntri, nvolu)
        DO ii = 1, nvolu
           IF (ntri(ii) > 0) THEN
              CALL write_i_c(t_monvol(ii)%FILL_TRI(1:3* ntri(ii)), 3* ntri(ii))
           ENDIF
        ENDDO
 
        CALL write_i_c(lagbuf,slagbuf)
 
        IF(ns10e > 0)THEN
          CALL write_i_c(icnds10,3*ns10e)
        ENDIF
 
        CALL write_th_restart(output%TH)   ! Write Time History Buffer
 
        CALL thsurf_write_restart(output%TH%TH_SURF,2)
        
        CALL write_i_c(fr_mv,sfr_mv)
 
        CALL write_i_c(nodes%BOUNDARY_ADD,siad_elem)
 
        CALL write_i_c(iad_rby,siad_rby)
 
        CALL write_i_c(iad_rby2,siad_rby2)
 
        CALL write_i_c(iad_i2m,siad_i2m)
 
        CALL write_i_c(iadcj,siadcj)
 
        CALL write_i_c(iad_rbm,siad_rbm)
 
        CALL write_i_c(iad_rbm2,siad_rbm2)
 
        CALL write_i_c(iad_rbe2,siad_rbe2)
 
        CALL write_i_c(rbe3%mpi%IAD_RBE3,nspmd+1)
 
        CALL write_i_c(iad_sec,siad_sec)
 
        CALL write_i_c(iad_cut,siad_cut)
C
        CALL write_i_c(iad_rbym,siad_rbym)
 
        CALL write_i_c(iad_rbym2,siad_rbym2)
 
        CALL write_i_c(nodes%BOUNDARY,sfr_elem)
 
        CALL write_i_c(fr_rby,sfr_rby)
 
        CALL write_i_c(rwall%FR_WALL,sfr_wall)
 
        CALL write_i_c(fr_rby2,sfr_rby2)
 
        CALL write_i_c(fr_i2m,sfr_i2m)
 
        CALL write_i_c(fr_ll,sfr_ll)
 
        CALL write_i_c(fr_cj,sfr_cj)
 
        CALL write_i_c(fr_rbm,sfr_rbm)
 
        CALL write_i_c(fr_rbm2,sfr_rbm2)
 
        CALL write_i_c(fr_rbe2,sfr_rbe2)
 
        CALL write_i_c(rbe3%mpi%FR_RBE3,rbe3%mpi%fr_rbe3_sz)
 
        CALL write_i_c(rbe3%mpi%FR_RBE3MP,rbe3%mpi%fr_rbe3_sz)
 
        CALL write_i_c(fr_sec,sfr_sec)
 
        CALL write_i_c(fr_cut,sfr_cut)
 
        CALL write_i_c(rg_cut,srg_cut)
 
        CALL write_i_c(fr_mad,sfr_mad)
 
        CALL write_i_c(fr_i18,sfr_i18)
 
        CALL write_i_c(dd_r2r,sdd_r2r)
 
        CALL write_i_c(dd_r2r_elem,sdd_r2r_elem)
 
        CALL write_i_c(fr_rbym,sfr_rbym)
 
        CALL write_i_c(fr_rbym2,sfr_rbym2)
 
        CALL write_i_c(addcsrect,numnor+1)
 
        CALL write_i_c(fr_nor,nbddnort)
 
        CALL write_i_c(iad_frnor,(nspmd+1)*ninter25)
 
        CALL write_i_c(procnor,nbccnor)
 
        CALL write_i_c(interfaces%SPMD_ARRAYS%FR_EDG,2*nbddedgt)
 
        CALL write_i_c(interfaces%SPMD_ARRAYS%IAD_FREDG,(nspmd+1)*ninter25)
 
        CALL write_i_c(iskwp,siskwp)
 
        CALL write_i_c(nskwp,snskwp)
 
        IF(snskwp>0) CALL write_i_c(iskwp_l,nskwp(ispmd+1))
 
        CALL write_i_c(isensp,sisensp)
 
        CALL write_i_c(nsensp,snsensp)
 
        CALL write_i_c(iaccp,siaccp)
 
        CALL write_i_c(naccp,snaccp)
 
        CALL write_i_c(igaup,sigaup)
 
        CALL write_i_c(ngaup,sngaup)
 
        CALL write_i_c(fr_lagf,sfr_lagf)
 
        CALL write_i_c(newfront,snewfront)
 
        CALL write_i_c(nbrcvois,snbrcvois)
 
        CALL write_i_c(lnrcvois,slnrcvois)
 
        CALL write_i_c(nbsdvois,snbsdvois)
 
        CALL write_i_c(lnsdvois,slnsdvois)
 
        CALL write_i_c(nercvois,snercvois)
 
        CALL write_i_c(lercvois,slercvois)
 
        CALL write_i_c(nesdvois,snesdvois)
 
        CALL write_i_c(lesdvois,slesdvois)
 
        CALL write_i_c(npsegcom,snpsegcom)
 
        CALL write_i_c(lsegcom,slsegcom)
 
        CALL write_i_c(nporgeo,snporgeo)
 
        CALL write_i_c(lnodpor,slnodpor)
 
        CALL write_i_c(llagf,sllagf)
 
        IF(icrack3d > 0)THEN
          CALL write_i_c(iad_edge,siad_edge)
          CALL write_i_c(fr_edge,sfr_edge)
          CALL write_i_c(fr_nbedge,sfr_nbedge)
        ENDIF
 
c        IF(NS10E > 0)THEN
          CALL write_i_c(iad_cndm,siad_cndm)
          CALL write_i_c(fr_cndm,sfr_cndm)
c        ENDIF
 
      IF(iparit==1)THEN
        CALL write_i_c(elements%PON%ADSKY,numnod+1)
        CALL write_i_c(elements%PON%PROCNE,SIZE(elements%PON%PROCNE))
        IF(i2nsnt>0)THEN
          CALL write_i_c(addcni2,numnod+1)
        ENDIF
        CALL write_i_c(procni2,lcni2)
        IF(ns10e>0) THEN
         CALL write_i_c(addcncnd,saddcncnd)
        ENDIF
        CALL write_i_c(procncnd,sprocncnd)
        CALL write_i_c(elements%PON%IADS       ,SIZE(elements%PON%IADS))       !< 1 ; 8xNUMELS  solid indexes to FSKY
        CALL write_i_c(elements%PON%IADS10     ,SIZE(elements%PON%IADS10 ))    !< 6* NUMELS10 
        CALL write_i_c(elements%PON%IADS20     ,SIZE(elements%PON%IADS20 ))     ! 12*NUMELS20
        CALL write_i_c(elements%PON%IADS16     ,SIZE(elements%PON%IADS16 ))       ! 8*NUMELS16
        CALL write_i_c(elements%PON%IADQ       ,SIZE(elements%PON%IADQ  ))        !<i87b ; quad i87b 
        CALL write_i_c(elements%PON%IADC       ,SIZE(elements%PON%IADC  ))         !<i87C shell (4 nodes) indexes to FSKY
        CALL write_i_c(elements%PON%IAD_TRUSS  ,SIZE(elements%PON%IAD_TRUSS))        !< I87D 2xNUMELT
        CALL write_i_c(elements%PON%IAD_BEAM   ,SIZE(elements%PON%IAD_BEAM ))         !< I87E 2xNUMELP
        CALL write_i_c(elements%PON%IAD_SPRING ,SIZE(elements%PON%IAD_SPRING ))       !<F 3xNUMELR
        CALL write_i_c(elements%PON%IAD_TG     ,SIZE(elements%PON%IAD_TG  ))       !<G 3xNUMELTG
        CALL write_i_c(elements%PON%IAD_TG6    ,SIZE(elements%PON%IAD_TG6 ))        !<H 3xNUMELTG6
        CALL write_i_c(elements%PON%IAD_MV     ,SIZE(elements%PON%IAD_MV  ))         !I 4xNSKYMV0
        CALL write_i_c(elements%PON%IAD_CONLD  ,SIZE(elements%PON%IAD_CONLD))         !<J 4xNCONLD
        CALL write_i_c(elements%PON%IAD_CONV   ,SIZE(elements%PON%IAD_CONV))        !<K 4x glob_therm%NCONV
        CALL write_i_c(elements%PON%IAD_RADIA  ,SIZE(elements%PON%IAD_RADIA))          !<L 4x glob_therm%Numrada
        CALL write_i_c(elements%PON%IAD_LOADP  ,SIZE(elements%PON%IAD_LOADP))          !<M SLLOADP
        CALL write_i_c(elements%PON%IAD_FXFLUX ,SIZE(elements%PON%IAD_FXFLUX))     !<N 4x glob_therm%nfxflux
 
 
C       CALL WRITE_I_C(IADS,NISKY0)
        CALL write_i_c(iadwal,nskyrw0)
        CALL write_i_c(iadrbk,nskyrbk0)
        CALL write_i_c(iadi2,niskyi2)
        CALL write_i_c(iadcnd,siadcnd)
        CALL write_i_c(iadmv2,nskymv0)
        CALL write_i_c(iadmv3,nskymvc0)
        CALL write_i_c(iadll,nskyll0)
        CALL write_i_c(iadrbm,nskyrbm0)
        CALL write_i_c(iadi18,nskyi18)
        CALL write_i_c(iadrbmk,nskyrbmk0)
C
C  ply xfem
C
        IF(iplyxfem > 0) THEN
            CALL write_i_c(adsky_pxfem,nplyxfe+1 )
C direct reading of PROCNE
            CALL write_i_c(procne_pxfem,lcnepxfem)
            CALL write_i_c(iadc_pxfem,4*eplyxfe)
        ENDIF
C
C  xfem for layered shell (cracks)
C
        IF(icrack3d > 0) THEN
          CALL write_i_c(adsky_crkxfem,ncrkxfe+1)
          CALL write_i_c(cne_crkxfem,lcnecrkxfem)
          CALL write_i_c(procne_crkxfem,lcnecrkxfem)
          CALL write_i_c(iadc_crkxfem,4*ecrkxfec+3*ecrkxfetg)
          CALL write_i_c(crknodiad,lcnecrkxfem)
        ENDIF
      ENDIF
      ! ---------------
      ! ebcs option : adress of FSKY array
      IF(ebcs_tab%nebcs_parallel>0) THEN
        DO i=1,ebcs_tab%nebcs
                IF(ebcs_tab%my_typ(i)==10 .or. ebcs_tab%my_typ(i)==11) THEN
                    my_size = ebcs_tab%tab(i)%poly%nb_elem
                    CALL write_i_c(ebcs_parithon(i)%ELEM_ADRESS,4*my_size)
                ENDIF
            ENDDO
       ENDIF
       ! ---------------
 
      CALL compress_i_nnz(igeo,len_g)
      CALL compress_i_nnz(ipm,len_m)
 
      CALL write_i_c(icontact ,sicontact)
      CALL write_i_c(ipart_state,len_s)
 
      IF(nadmesh /= 0)THEN
        CALL write_i_c(sh4tree,ksh4tree*numelc)
        CALL write_i_c(sh3tree,ksh3tree*numeltg)
        CALL write_i_c(ipadmesh,kipadmesh*npart)
        len=abs(lsh4trim)
        CALL write_i_c(sh4trim,len)
        len=abs(lsh3trim)
        CALL write_i_c(sh3trim,len)
      END IF
C--------------------------------------
C Writing Additional Tables Boundary Interfaces (entire part)
C--------------------------------------
      CALL spmd_savefi(ipari,1,intbuf_tab,sensors%NSENSOR,sensors%SENSOR_TAB,
     .                 interfaces%PARAMETERS)
C--------------------------------------
C Writing Additional Tables Frontieres SPH (integer part)
C--------------------------------------
      CALL spmd_savesph(1,numsphg)
C--------------------------------------
C Int 21 structures
C--------------------------------------
      IF(nintstamp /= 0)THEN
        CALL intstamp_wresti(intstamp)
      END IF
C--------------------------------------
C  Interface friction buffer (integer )
C--------------------------------------
      IF(ninterfric /= 0)THEN
        CALL intfric_wresti(intbuf_fric_tab,ninterfric)
      END IF
C--------------------------------------
C Table structure (integer part)
C--------------------------------------
      IF(ntable /= 0)THEN
        CALL table_wresti(table, ltable)
      END IF
C--------------------------------------
      CALL write_i_c(ithvar,sithvar)
C--------------------------------------
      IF (nloadc>0)THEN
        CALL write_i_c(icfield,sizfield*nloadc)
        CALL write_i_c(lcfield,slcfield)
      ENDIF
      IF (nloadp>0)THEN
        CALL write_i_c(iloadp,sizloadp*nloadp)
        CALL write_i_c(lloadp,slloadp)
      ENDIF
      IF (pblast%NLOADP_B>0)THEN
        CALL pblast_write_engine(pblast)
      ENDIF
C--------------------------------------
      IF (loads%NLOAD_CYL > 0) THEN
        CALL write_pcyl(loads)
      ENDIF
C--------------------------------------
      IF(icrack3d > 0)THEN
        CALL write_i_c(ibordnode,sibordnode)
        CALL write_i_c(iedgesh,siedgesh)
        CALL write_i_c(nodedge,2*numedges)
        CALL write_i_c(iedge,numedges)
        CALL write_i_c(nodglobxfe,snodglobxfe)
      END IF
C--------------------------------------
      IF(numelig3d > 0)THEN
        CALL write_i_c(kxig3d,skxig3d)
 
        CALL write_i_c(ixig3d,sixig3d)
      ENDIF
C----------------------------------
      CALL write_i_c(tag_skins6,numels)
C--------------------------------------
C /BCS/CYCLIC
C--------------------------------------
      IF(nbcscyc > 0)THEN
        CALL write_i_c(ibcscyc,sibcscyc)
        CALL write_i_c(lbcscyc,slbcscyc)
      ENDIF
C--------------------------------------
C /BCS/WALL
C--------------------------------------
      itmp = bcs%NUM_WALL
      CALL write_i_c(itmp,1)
      IF(bcs%NUM_WALL > 0)THEN
        DO i=1, bcs%NUM_WALL
          CALL write_bcs_wall(bcs%WALL(i))
        ENDDO
      ENDIF
C--------------------------------------
C /BCS/NRF
C--------------------------------------
      itmp = bcs%NUM_NRF
      CALL write_i_c(itmp,1)
      IF(bcs%NUM_NRF > 0)THEN
        DO i=1, bcs%NUM_NRF
          CALL write_bcs_nrf(bcs%NRF(i))
        ENDDO
      ENDIF
C--------------------------------------
C     writing real variables
C--------------------------------------
      CALL write_db(tabvrea, lvarrea)
C--------------------------------------
C     writing reals
C--------------------------------------
         CALL write_db(nodes%X,sx)
 
         CALL write_db(nodes%D,sd)
 
         CALL write_db(nodes%V,sv)
 
         CALL write_db(nodes%VR,svr)
 
         CALL write_db(nodes%DR,sdr)
 
         CALL write_db(thke,sthke)
 
         CALL write_db(dampr,sdampr)
 
         CALL write_db(damp,sdamp)
 
         CALL write_db(nodes%MS,sms)
 
         IF (n2d >0) THEN
           CALL write_db(ms_2d,numnod)
         ENDIF
 
         CALL write_db(nodes%IN,sin)
 
         CALL write_db(tf,stf)
 
         CALL write_db(pm,spm)
 
         CALL write_matparam(mat_elem)
 
         CALL write_elgroup_param(mat_elem%GROUP_PARAM,ngroup)
 
         skew_len = skews%N_SKEW_VAR * skews%TOTAL_SKEW_NUMBER
         CALL write_db(skews%SKEW,skew_len)
 
         CALL write_db(xframe,sxframe)
 
         CALL compress_r_nnz(geo,sgeo)
 
         CALL write_db(eani,seani)
 
         CALL write_db(bufmat,sbufmat)
 
         CALL write_db(bufgeo,sbufgeo)
 
         CALL write_db(bufsf,sbufsf)
 
         CALL write_db(rbmpc,srbmpc)
 
         CALL write_db(gjbufr,sgjbufr)
 
         CALL write_db(w,sw)
 
         CALL write_db(veul,sveul)
 
         IF (multi_fvm%IS_USED) THEN
            CALL write_db(multi_fvm%PRES_SHIFT, 1)
            IF (n2d == 0) THEN
               CALL write_db(multi_fvm%VEL(1, :), numels)
               CALL write_db(multi_fvm%VEL(2, :), numels)
               CALL write_db(multi_fvm%VEL(3, :), numels)
            ELSE
               CALL write_db(multi_fvm%VEL(1, :), numelq + numeltg)
               CALL write_db(multi_fvm%VEL(2, :), numelq + numeltg)
               CALL write_db(multi_fvm%VEL(3, :), numelq + numeltg)
            ENDIF
         ENDIF
 
         CALL write_db(fill,sfill)
 
         CALL write_db(dfill,sdfill)
 
         CALL write_db(alph,salph)
 
         CALL write_db(wb,swb)
 
         CALL write_db(dsave,sdsave)
 
         CALL write_db(asave,sasave)
 
         CALL write_db(spbuf,sspbuf)
 
         CALL write_db(vsphio,svsphio)
 
         CALL write_db(sphveln,ssphveln)
 
         CALL write_db(msnf,smsnf)
 
         CALL write_db(forc,sforc)
 
         CALL write_db(vel,svel)
 
         CALL write_db(fsav,sfsav)
 
         CALL write_i_c(tab_ump,7*taille)
 
         CALL write_i_c(poin_ump,nummat)
 
         CALL write_db(tab_mat,stab_mat)
 
         CALL write_db(fzero,sfzero)
 
         CALL write_db(xlas,sxlas)
 
         CALL write_db(accelm,saccelm)
 
         CALL write_db(gauge,llgauge*nbgauge)
 
         CALL write_sensors(sensors)
 
         CALL write_db(fbvel,sfbvel)
 
         CALL write_db(rbe3%FRBE3,rbe3%frbe3_sz)
 
         CALL write_rrbe3pen(rbe3%PEN)
 
         CALL write_db(factiv,lractiv*nactiv)
 
         CALL write_db(grav,sgrav)
 
         CALL write_db(fr_wave,sfr_wave)
 
         CALL w_failwave(failwave)
 
         CALL write_nloc_struct(nloc_dmg)
 
         CALL write_db(parts0,sparts0)
 
         CALL write_db(elbuf,selbuf)
 
         flag_xfem = 0
         CALL w_elbuf_str(iparg,elbuf_tab,flag_xfem)
 
C  if xfem
         IF (icrack3d > 0) THEN
           flag_xfem = 1
           DO ixel=1,nxel
             CALL w_elbuf_str(iparg,xfem_tab(1:ngroup,ixel),flag_xfem)
           ENDDO
         ENDIF
 
         CALL w_cluster(cluster)
 
         CALL write_db(rwall%RWBUF,rwall%nrwlp*rwall%nrwall)
 
         CALL write_db(rwall%RWSAV,rwall%sz_rwsav)
 
         CALL write_rrwallpen(rwall%nrwall_pen,rwall%PEN,rwall%PEN%lnspen)
 
         CALL write_db(rby,srby)
 
         CALL write_db(rbyl,srbyl)
 
         CALL write_db(rivet,srivet)
 
         CALL write_db(secbuf,ssecbuf)
 
         CALL write_db(volmon,svolmon)
 
         CALL write_db(lambda,slambda)
 
         CALL write_db(rconx,srconx)
 
         CALL write_db(rcontact,srcontact)
         CALL write_db(acontact,srcontact)
         CALL write_db(pcontact,srcontact)
C--------------------------------------
C Writing Additional Tables Boundary Interfaces (real part)
C--------------------------------------
      CALL spmd_savefi(ipari,2,intbuf_tab,sensors%NSENSOR,sensors%SENSOR_TAB,
     .                 interfaces%PARAMETERS)
C--------------------------------------
C Writing Additional Tables Frontieres SPH (Real part)
C--------------------------------------
      CALL spmd_savesph(2,numsphg)
C--------------------------------------
C     OPTIONAL WRITES
C--------------------------------------
      IF (iresmd==0.AND.npsav>=25) THEN
C   bring PARTSAV back to the proc and set the others to zero
          IF(nspmd > 1)
     .      CALL spmd_glob_dsum9(partsav,npsav*npart)
          IF (ispmd/=0)THEN
            DO m=1,npsav*npart
                 partsav(m) = zero
            ENDDO
          ENDIF
          CALL write_db(partsav,npsav*npart)
      ENDIF
      IF(nnoise>0)THEN
        CALL write_i_c (iaf(if01),2*nnoise+10)
        CALL write_db(af(mf01),6*ncnois*nnoise+1)
      ENDIF
C-----
C  Save A, AR to Restart RAD2MD
      IF (iresmd==1) THEN
        CALL write_db(nodes%A,3*numnod)
        CALL write_db(nodes%AR,3*numnod)
C    Save PARTSAV.
        CALL write_db(partsav,npsav*npart)
      ENDIF
C
      IF (iresp == 1) THEN
        CALL write_dpdb(nodes%XDP,3*numnod)
        CALL write_dpdb(nodes%DDP,3*numnod)
      ENDIF
C needed for check restart
C needed because the restarts are the same as the check restart
        my_ilen = 4*nrlink+nrlink*(nspmd+2)
     .           +lllink+lllink*min(1,iparit)
     .           +nsflsw+8*ntflsw+44*ncuts !+LLINAL
        CALL write_i_c (my_ilen,1)
        my_rlen = 9*nsflsw+7*ncuts
        CALL write_i_c (my_rlen,1)
        CALL write_i_c (ilink,4*nrlink)
        CALL write_i_c (fr_rl,nrlink*(nspmd+2))
        CALL write_i_c (llink,lllink)
        CALL write_i_c (iadrl,lllink*min(1,iparit))
        !CALL WRITE_I_C (LINALE,LLINAL)
C       section
        CALL write_i_c(neflsw,nsflsw)
        CALL write_i_c(nnflsw,8*ntflsw)
        CALL write_i_c(icut,44*ncuts)
        CALL write_db (crflsw,9*nsflsw)
        CALL write_db (xcut,7*ncuts)
C--------------------------------------
        IF(nadmesh /= 0 .OR. irest_mselt /= 0)THEN
          CALL write_db(msc,numelc)
          CALL write_db(inc,numelc)
          CALL write_db(mstg,numeltg)
          CALL write_db(intg,numeltg)
          CALL write_db(ptg,3*numeltg)
        END IF
 
        IF(irest_mselt /= 0)THEN
          CALL write_db(mssa,numels)
          CALL write_db(mstr,numelt)
          CALL write_db(msp,numelp)
          CALL write_db(msrt,numelr)
        END IF
 
        IF(nadmesh /= 0)THEN
          CALL write_db(padmesh,kpadmesh*npart)
          IF(glob_therm%ITHERM_FE > 0)THEN
            CALL write_db(mcpc,numelc)
            CALL write_db(mcptg,numeltg)
          END IF
        END IF
C pinching shell
        IF(npinch > 0) THEN
          CALL write_db(pinch_data%VPINCH,3*npinch)
          CALL write_db(pinch_data%DPINCH,3*npinch)
          CALL write_db(pinch_data%XPINCH,3*npinch)
          CALL write_db(pinch_data%MSPINCH,npinch)
        ENDIF
C--------------------------------------
        IF(istatcnd /= 0)THEN
          CALL write_db(mscnd,numnod)
          CALL write_db(incnd,numnod)
        ENDIF
C--------------------------------------
C Int 21 structures
C--------------------------------------
        IF(nintstamp /= 0)THEN
          CALL intstamp_wrestr(intstamp)
        END IF
 
        IF(h3d_data%N_SCAL_SKID > 0) THEN
         IF(nintstamp/=0) THEN
           CALL write_db(pskids, h3d_data%N_SCAL_SKID*numnodg)
         ELSE
           CALL write_db(pskids, h3d_data%N_SCAL_SKID*numnod)
         ENDIF
       ENDIF
 
        IF(ifcontmax >0)THEN
          IF(nintstamp/=0.AND.nspmd > 1 ) THEN
             IF(ispmd == 0) CALL write_db(fcont_max, 3*numnodg)
          ELSE
             CALL write_db(fcont_max, 3*numnod)
         ENDIF
        ENDIF
 
        IF(ifcontpmax >0)THEN
          CALL write_db(fncont_max, 3*spcont_max)
          CALL write_db(ftcont_max, 3*spcont_max)
        ENDIF
 
        IF(ifcont2max >0)THEN
          CALL write_db(fcont2_max, 3*numnod)
        ENDIF
        IF(ifcontp2max >0)THEN
          CALL write_db(fncont2_max, 3*numnod)
          CALL write_db(ftcont2_max, 3*numnod)
          CALL write_db(npcont2_max, 3*numnod)
        ENDIF
 
        IF(ifcont2min >0)THEN
          CALL write_db(fcont2_min, 3*numnod)
        ENDIF
        IF(ifcontp2min >0)THEN
          CALL write_db(fncont2_min, 3*numnod)
          CALL write_db(ftcont2_min, 3*numnod)
          CALL write_db(npcont2_min, 3*numnod)
        ENDIF
C--------Frictional energy output-------
      IF(output%DATA%S_EFRICINT >0)THEN
         IF(output%DATA%NINEFRIC > 0) CALL write_db(output%DATA%EFRIC, output%DATA%NINEFRIC*numnod)
         IF(output%DATA%NINEFRIC_STAMP > 0) CALL write_db(output%DATA%EFRIC_STAMP, output%DATA%NINEFRIC_STAMP*numnodg)
      ENDIF
      IF(output%DATA%S_EFRIC >0)THEN
         CALL write_db(output%DATA%EFRICG, numnod)
         IF(nintstamp/=0) CALL write_db(output%DATA%EFRICG_STAMP, numnodg)
      ENDIF
C--------------------------------------
C  Interface friction buffer (integer )
C--------------------------------------
      IF(ninterfric /= 0)THEN
        CALL intfric_wrestr(intbuf_fric_tab,ninterfric)
      END IF
C--------------------------------------
        CALL write_db(nodes%MS0,numnod)
        CALL write_db(nodes%IN0,sin)
        IF(idtmins==1)THEN
          CALL write_db(admsms,numnod)
        ELSEIF(idtmins==2)THEN
          CALL write_db(dmelc ,numelc)
          CALL write_db(dmeltg,numeltg)
          CALL write_db(dmels ,numels)
          CALL write_db(dmeltr,numelt)
          CALL write_db(dmelp ,numelp)
          CALL write_db(dmelrt,numelr)
        END IF
        IF(idtmins/=0.OR.idtmins_int/=0)THEN
          CALL write_db(res_sms,3*numnod)
        END IF
c
        IF(idtmins==2.OR.idtmins_int/=0) THEN
Cfor TYPE20
          CALL write_db(diag_sms ,numnod)
Cfor TYPE2
          CALL write_db(dmint2 ,4*i2nsn25)
        END IF
C
        IF (isms_selec /= 0) THEN
          CALL write_i_c(nativ0_sms,numnod)
        ENDIF
C--------------------------------------
C Table structure (real part)
C--------------------------------------
      IF(ntable /= 0)THEN
        CALL table_wrestr(table, ltable)
      END IF
C--------------------------------------
C    MDS Parameters
C--------------------------------------
#ifdef DNC
      CALL eng_wrt_mds()
#endif
C--------------------------------------
C ALE LINKS
C--------------------------------------
      IF(slinale > 0)THEN
        CALL write_i_c(linale,slinale)
      END IF
C--------------------------------------
C ALE GRID
C--------------------------------------
      CALL write_ale_grid()
C--------------------------------------
C FXBODY (moved from resol.F)
C--------------------------------------
      IF (nfxbody>0) CALL fxbwrest(ich)
C--------------------------------------
C EIGEN MODES
C--------------------------------------
      IF (neig>0) THEN
         CALL eigwrest(eigipm, eigibuf, eigrpm)
      ENDIF
C--------------------------------------
C SEATBELTS - SLIPRING / RETRACTOR
C--------------------------------------
      DO i = 1, nslipring
        CALL write_i_c(slipring(i)%ID, 1)
        CALL write_i_c(slipring(i)%IDG, 1)
        CALL write_i_c(slipring(i)%NFRAM, 1)
        CALL write_i_c(slipring(i)%IFUNC, 4)
        CALL write_i_c(slipring(i)%SENSID, 1)
        CALL write_i_c(slipring(i)%FL_FLAG, 1)
        CALL write_i_c(slipring(i)%RBODY, 1)
C
        CALL write_db(slipring(i)%DC, 1)
        CALL write_db(slipring(i)%A, 1)
        CALL write_db(slipring(i)%FRIC, 1)
        CALL write_db(slipring(i)%FAC_D, 3)
        CALL write_db(slipring(i)%FRICS, 1)
        CALL write_db(slipring(i)%FAC_S, 3)
C
        DO j=1,slipring(i)%NFRAM
C
          CALL write_i_c(slipring(i)%FRAM(j)%UPDATE, 1)
          CALL write_i_c(slipring(i)%FRAM(j)%ANCHOR_NODE, 1)
          CALL write_i_c(slipring(i)%FRAM(j)%NODE, 3)
          CALL write_i_c(slipring(i)%FRAM(j)%NODE_NEXT, 3)
          CALL write_i_c(slipring(i)%FRAM(j)%NODE2_PREV, 1)
          CALL write_i_c(slipring(i)%FRAM(j)%N_REMOTE_PROC, 1)
          CALL write_i_c(slipring(i)%FRAM(j)%ORIENTATION_NODE, 1)
          CALL write_i_c(slipring(i)%FRAM(j)%STRAND_DIRECTION, 2)
          CALL write_i_c(slipring(i)%FRAM(j)%LOCKED, 1)
C
          CALL write_db(slipring(i)%FRAM(j)%VECTOR, 6)
          CALL write_db(slipring(i)%FRAM(j)%ORIENTATION_ANGLE, 1)
          CALL write_db(slipring(i)%FRAM(j)%MATERIAL_FLOW, 1)
          CALL write_db(slipring(i)%FRAM(j)%MATERIAL_FLOW_OLD, 1)
          CALL write_db(slipring(i)%FRAM(j)%DFS, 1)
          CALL write_db(slipring(i)%FRAM(j)%RESIDUAL_LENGTH, 2)
          CALL write_db(slipring(i)%FRAM(j)%CURRENT_LENGTH, 2)
          CALL write_db(slipring(i)%FRAM(j)%RINGSLIP, 1)
          CALL write_db(slipring(i)%FRAM(j)%BETA, 1)
          CALL write_db(slipring(i)%FRAM(j)%SLIP_FORCE, 3)
          CALL write_db(slipring(i)%FRAM(j)%PREV_REF_LENGTH, 1)
          CALL write_db(slipring(i)%FRAM(j)%INTVAR_STR1, 8)
          CALL write_db(slipring(i)%FRAM(j)%INTVAR_STR2, 8)
C
        ENDDO
C
      ENDDO
C
      DO i = 1, nretractor
        CALL write_i_c(retractor(i)%ID, 1)
        CALL write_i_c(retractor(i)%IDG, 1)
        CALL write_i_c(retractor(i)%UPDATE, 1)
        CALL write_i_c(retractor(i)%ANCHOR_NODE, 1)
        CALL write_i_c(retractor(i)%NODE, 2)
        CALL write_i_c(retractor(i)%NODE_NEXT, 2)
        CALL write_i_c(retractor(i)%STRAND_DIRECTION, 1)
        CALL write_i_c(retractor(i)%IFUNC, 3)
        CALL write_i_c(retractor(i)%ISENS, 2)
        CALL write_i_c(retractor(i)%TENS_TYP, 1)
        CALL write_i_c(retractor(i)%LOCKED, 1)
        CALL write_i_c(retractor(i)%LOCKED_FREEZE, 1)
        CALL write_i_c(retractor(i)%PRETENS_ACTIV, 1)
        CALL write_i_c(retractor(i)%INACTI_NNOD, 1)
        CALL write_i_c(retractor(i)%INACTI_NNOD_MAX, 1)
        CALL write_i_c(retractor(i)%INACTI_NODE, retractor(i)%INACTI_NNOD)
        CALL write_i_c(retractor(i)%N_REMOTE_PROC, 1)
        CALL write_i_c(retractor(i)%S_TABLE, 2)
        CALL write_db(retractor(i)%VECTOR, 3)
        CALL write_db(retractor(i)%ELEMENT_SIZE, 1)
        CALL write_db(retractor(i)%FORCE, 1)
        CALL write_db(retractor(i)%MATERIAL_FLOW, 1)
        CALL write_db(retractor(i)%RESIDUAL_LENGTH, 1)
        CALL write_db(retractor(i)%FAC, 4)
        CALL write_db(retractor(i)%PULLOUT, 1)
        CALL write_db(retractor(i)%UNLOCK_FORCE, 1)
        CALL write_db(retractor(i)%LOCK_PULL, 1)
        CALL write_db(retractor(i)%LOCK_PULL_SAV, 1)
        CALL write_db(retractor(i)%LOCK_OFFSET, 1)
        CALL write_db(retractor(i)%LOCK_YIELD_FORCE, 1)
        CALL write_db(retractor(i)%RINGSLIP, 1)
        CALL write_db(retractor(i)%PRETENS_TIME, 1)
        CALL write_db(retractor(i)%PRETENS_PULL, 1)
        CALL write_db(retractor(i)%PRETENS_PULLMAX, 1)
        CALL write_db(retractor(i)%RET_FORCE, 1)
        DO j=1,2
          IF (retractor(i)%S_TABLE(j) > 0) THEN
            npt = retractor(i)%S_TABLE(j)
            CALL write_db(retractor(i)%TABLE(j)%X(1)%VALUES(1:npt),npt)
            CALL write_db(retractor(i)%TABLE(j)%Y%VALUES(1:npt),npt)
          ENDIF  
        ENDDO
      ENDDO
C
      IF (n_anchor_remote > 0) THEN
        CALL write_i_c(anchor_remote%ADD_PROC, nspmd+1)
        CALL write_i_c(anchor_remote%NODE, n_anchor_remote)
      ENDIF
C
      IF (n_anchor_remote_send > 0) THEN
        CALL write_i_c(anchor_remote_send%ADD_PROC, nspmd+1)
        CALL write_i_c(anchor_remote_send%NODE, n_anchor_remote_send)
      ENDIF
C
      IF ((nslipring_g + nretractor_g >0).AND.(ispmd == 0)) THEN
        CALL write_i_c(nseatbelt_th_proc, 1)
        IF ((nspmd > 1).AND.(nseatbelt_th_proc > 0)) THEN
          DO i=1,nseatbelt_th_proc
            CALL write_i_c(seatbelt_th_exch(i)%ID_PROC, 1)
            CALL write_i_c(seatbelt_th_exch(i)%ADD_PROC, 1)
            CALL write_i_c(seatbelt_th_exch(i)%NSLIPRING, 1)
            CALL write_i_c(seatbelt_th_exch(i)%NRETRACTOR, 1)
          ENDDO
        ENDIF
      ENDIF
C
C--------------------------------------------
C /H3D/?/TMAX part noda
C--------------------------------------------
      CALL write_db(tm_dis,lmax_dis*numnod)
      CALL write_db(tm_vel,lmax_vel*numnod)
      CALL write_db(tm_nsig1,lmax_nsig*numnod)
      CALL write_db(tm_nsig3,lmax_nsig*numnod)
      CALL write_db(tm_nstra1,lmax_nstra*numnod)
      CALL write_db(tm_nstra3,lmax_nstra*numnod)
C--------------------------------------
      IF (nconld > 0) THEN
        CALL write_db(dpl0cld,6*nconld)
        CALL write_db(vel0cld,6*nconld)
      ENDIF
C--------------------------------------
C   /DAMP/VREL
C--------------------------------------
      IF (ndamp_vrel > 0) THEN
        CALL write_i_c(id_damp_vrel,ndamp_vrel)
        CALL write_i_c(fr_damp_vrel,ndamp_vrel*(nspmd+2)) 
      ENDIF
C--------------------------------------
      IF (nflow>0) CALL nfwrest(iflow, rflow)
c     
      CALL fvwrest()  
c
      IF (impl_s>0) THEN
        CALL imp_trans(impbuf_tab%R_IMP)
        CALL impwrest(impl_s0)
      ENDIF
c
      IF(glob_therm%ITHERM_FE > 0 ) CALL thcwrest(mcp, temp)
C
      IF(nitsche > 0 )CALL nitschewrest(forneqs)
c
      CALL write_units(unitab)
c
      IF(irigid_mat > 0 )CALL rigmatwrest(rbym ,irbym ,lnrbym,weight_rm)
 
C thermal boundary
      IF (glob_therm%NUMCONV > 0)   THEN
        CALL convwrest(ibcv, fconv,glob_therm)
      END IF
      IF (glob_therm%NUMRADIA > 0)  THEN
        CALL radiawrest(ibcr, fradia,glob_therm)
      END IF
      IF (glob_therm%NFXFLUX > 0)  THEN
        CALL fxfluxwrest(ibfflux, fbfflux, glob_therm)
      END IF
      IF (glob_therm%NFXTEMP > 0)  THEN
        CALL fxtempwrest(ibftemp, fbftemp,glob_therm)
      END IF
!
c Ply XFEM
      IF (iplyxfem > 0)THEN
        CALL plyxfem_wrest(ms_ply,zi_ply,inod_pxfem,iel_pxfem,
     .                     icode_ply,iskew_ply,msz2)
        CALL plyxfem_wrestanim()
        CALL plyxfem_wravuply()
      ENDIF  
c
      IF (nloadc > 0) CALL write_db(cfield,lfacload*nloadc)
      IF (nloadp > 0) CALL write_db(loadp,lfacload*nloadp)
      IF (nintloadp > 0) CALL write_db(dgaploadint,ninter*nloadp_hyd)
C
C /INIVEL w/ T_start or senor_id
      IF (loads%NINIVELT>0) CALL write_inivel(loads%NINIVELT,loads%INIVELT) 
C                                                         
C xfem for layerd shell (cracks)
      IF (icrack3d > 0) THEN
        CALL crkxfem_wrest(inod_crkxfem,iel_crkxfem,nodlevxf)
        CALL crkxfem_wrestanim(crkedge,crksky,indx_crk,xedge4n,xedge3n)
      ENDIF
C
      IF(alefvm_param%IEnabled > 0) CALL write_db(alefvm_buffer%FCELL ,6*numels)
C foam + air
      IF(ialelag > 0 )CALL alelag_wrest()
C THoutput
      IF(srthbuf > 0) CALL rthbufwrest()
C Knot
      IF (sknot > 0) CALL write_db(knot,sknot)
      IF (sknotlocpc > 0) CALL write_db(knotlocpc,sknotlocpc)
      IF (sknotlocel > 0) CALL write_db(knotlocel,sknotlocel)
      IF (numelig3d > 0) CALL write_db(wige,numnod)
C
      IF(ipart_stack >0) CALL stack_wrest(stack%IGEO,stack%GEO,stack%PM )
C
      IF (ndrape > 0) CALL drape_wrest(drape_sh4n  , drape_sh3n,drapeg)
C
      IF (numply > 0) CALL ply_info_wrest(ply_info)
 
      ! ---------------------------
      ! write the starter + engine elapsed time
      CALL write_dpdb(global_comp_time%STARTER_TIME,1)
      CALL write_dpdb(global_comp_time%ENGINE_TIME,global_comp_time%RUN_NBR)
      ! ---------------------------
 
      ! restart file size - mist be before closing the file
      CALL  file_size(restsize)
 
      ! Closing the file
      CALL close_c
C
      IF(ispmd==0)THEN
        WRITE (iout,1000)  filnamg(1:leng)
        WRITE (istdo,1050) filnamg(1:leng)
      ENDIF      
C--------------------------------------
 1000 FORMAT (/4x,' RESTART FILES:',1x,a,' WRITTEN'/
     .         4x,' -------------'/)
 1050 FORMAT (4x,' RESTART FILES:',1x,a,' WRITTEN')
C-----------
      RETURN
      END