; le format netcdf et IDL nous permet d''aller lire uniquement la partie de
; tableau qui nous interesse.
;
;  attention, qd il y a un shift il faut faire attention a ce que
;  l''on fait et en particulier arriver a positionner la boite
;  specifiee par premierx:dernierx par rapport au tableau contenu dans
;  le fichier NetCdf.
;  pour s''y reperer voici un petit dessin
;
;  dans le repere 0:jpi, avec le zoom definit par premierx:dernierx
;
;        0      j      key-1  key          i              jpi-1
;        |......|........|     |-----------|----------------|
;
;  si on veut savoir comment c''etait avant le shift:
;
;        0       i-key     jpi-key-1 jpi-key  jpi-key+j   jpi-1
;        |--------|--------------|      |........|..........|
;
; avant que l''on ajuste au zoom definit par ixminmesh,ixmaxmesh c''etait:
;
;   0   ixmin    i-key     jpi-key-1  jpi-key  jpi-key+j   jpi-1     jpidta
;              +ixmin        +ixmin  +ixmin     +ixmin     +ixmin
;   |,,,,|--------|--------------|      |........|..........|,,,,,,,,,,,|
;
;  apres il suffit de remplacer i et j par premierx ou dernierx qd on
;  ne fait pas de stride et par premierx*key_stride[0] ou
;  dernierx*key_stride[0] qd on fait un stride (dans ce cas il faut
;  aussi remplacer jpi par jpitotal)!
;
;
case 1 OF
;......................................................................
;......................................................................
   varcontient.ndims eq 2:BEGIN ;xy array
;......................................................................
;......................................................................
      case 1 OF
;,,,,,,,,,,,,,,,,,,,,,,,,
         keyword_set(key_shift) EQ 0 AND total(key_stride) EQ 3:BEGIN
; on ne shift pas et il n''y a pas de stride
;,,,,,,,,,,,,,,,,,,,,,,,,
            ncdf_varget,cdfid,name,res,offset=[premierx+ixminmesh-ixmindta $
                                               ,premiery+iyminmesh-iymindta] $
             ,count=[nx,ny], _extra = ex
         END
;,,,,,,,,,,,,,,,,,,,,,,,,
         keyword_set(key_shift) EQ 0 AND total(key_stride) NE 3:BEGIN
; on ne shift pas mais il y a un stride
;,,,,,,,,,,,,,,,,,,,,,,,,
            ncdf_varget,cdfid,name,res,offset=[premierx*key_stride[0]+ixminmesh-ixmindta $
                                               ,premiery*key_stride[1]+iyminmesh-iymindta] $
             ,count=[nx,ny], stride = key_stride[0:1], _extra = ex
         END
;,,,,,,,,,,,,,,,,,,,,,,,,
         keyword_set(key_shift) NE 0 AND total(key_stride) EQ 3:BEGIN
; on shift mais il n''y a pas de stride
;,,,,,,,,,,,,,,,,,,,,,,,,
            case 1 of
               premierx GE key:BEGIN ; on peut tout couper d''un coup
                  ncdf_varget,cdfid,name,res,offset=[ixmin-key+premierx $
                                                     ,premiery+iyminmesh-iymindta] $
                   ,count=[nx,ny], _extra = ex
               END
               dernierx LE key-1:BEGIN ; on peut tout couper d''un coup
                  ncdf_varget,cdfid,name,res,offset=[jpi-key+ixmin+premierx $
                                                     ,premiery+iyminmesh-iymindta] $
                   ,count=[nx,ny], _extra = ex
               END
               ELSE:BEGIN       ; Le tableau est separe en 2 morceaux...
                  ncdf_varget,cdfid,name,tab1,offset=[jpi-key+ixmin+premierx $
                                                      ,premiery+iyminmesh-iymindta] $
                   ,count=[key-1-premierx+1,ny], _extra = ex
                  ncdf_varget,cdfid,name,tab2,offset=[ixmin $
                                                      ,premiery+iyminmesh-iymindta] $
                   ,count=[dernierx-key+1,ny], _extra = ex
                  res = [temporary(tab1), temporary(tab2)]
               END
            ENDCASE
         END
;,,,,,,,,,,,,,,,,,,,,,,,,
         keyword_set(key_shift) NE 0 AND total(key_stride) NE 3:BEGIN
; on shift et il y a un stride
;,,,,,,,,,,,,,,,,,,,,,,,,
            case 1 OF           ; case sur la facon de fire le champ
               premierx GE ceil(1.*key/key_stride[0]):BEGIN ; on peut tout coupe d''un coup
                  ncdf_varget,cdfid,name,res,offset=[ixmin-key+premierx*key_stride[0] $
                                                     ,premiery*key_stride[1]+iyminmesh-iymindta] $
                   ,count=[nx,ny], stride = key_stride[0:1], _extra = ex
               END
               dernierx LE (key-1)/key_stride[0]:BEGIN ; on peut tout coupe d''un coup
                  ncdf_varget,cdfid,name,res,offset=[jpitotal-key+ixmin+premierx*key_stride[0] $
                                                     ,premiery*key_stride[1]+iyminmesh-iymindta] $
                   ,count=[nx,ny], stride = key_stride[0:1], _extra = ex
               END
               ELSE:BEGIN       ; le tableau est separe en 2 morceaux...
                  ncdf_varget,cdfid,name,tab1,offset=[jpitotal-key+ixmin+premierx*key_stride[0] $
                                                      ,premiery*key_stride[1]+iyminmesh-iymindta] $
                   ,count=[(key-1-premierx*key_stride[0]+1)/key_stride[0],ny] $
                   , stride = key_stride[0:1], _extra = ex
; grosse blague de IDL qui sur un vecteur 0 1 2 3 4 5 6 7 8
; extrait pour offset = 0 ou 1 tjs 5 elements pour un stride de 2 par
; ex, soit le nombre d''elements/le stride. Il manque donc une colonne
; quand nombre d''elements-1 est un multiple de stride...CQFD
; il en manque un bout?
                  IF ( (key-1-premierx*key_stride[0]) MOD key_stride[0] ) EQ 0 then begin
                     ncdf_varget,cdfid,name,tab1bis,offset=[jpitotal-1+ixmin $
                                                            ,premiery*key_stride[1]+iyminmesh-iymindta] $
                      ,count=[1,ny] $
                      , stride = [1, key_stride[1]], _extra = ex
                     tab1bis = reform(tab1bis, 1, ny, /over)
                     tab1 = [temporary(tab1), temporary(tab1bis)]
                  ENDIF
; 2eme bout...
                  ncdf_varget,cdfid,name,tab2,offset=[ceil(1.*key/key_stride[0])*key_stride[0]-key+ixmin $
                                                      ,premiery*key_stride[1]+iyminmesh-iymindta] $
                   ,count=[(dernierx*key_stride[0]-key+1)/key_stride[0],ny] $
                   , stride = key_stride[0:1], _extra = ex
; on recolle le tout
                  res = [temporary(tab1), temporary(tab2)]
               END
            ENDCASE             ; case sur la facon de fire le champ
         END
      ENDCASE                   ; differentes possibilites de key_shift et key_performance
   END
;......................................................................
;......................................................................
   varcontient.ndims eq 3 AND (where(varcontient.dim EQ contient.recdim))[0] EQ -1:BEGIN ;xyz array
;......................................................................
;......................................................................
      case 1 of
;,,,,,,,,,,,,,,,,,,,,,,,,
         keyword_set(key_shift) EQ 0 AND total(key_stride) EQ 3:BEGIN
; on ne shift pas et il n''y a pas de stride
;,,,,,,,,,,,,,,,,,,,,,,,,
            ncdf_varget,cdfid,name,res,offset=[premierx+ixminmesh-ixmindta $
                                               ,premiery+iyminmesh-iymindta $
                                               ,premierz+izminmesh-izmindta] $
             ,count=[nx,ny,nz], _extra = ex
         END
;,,,,,,,,,,,,,,,,,,,,,,,,
         keyword_set(key_shift) EQ 0 AND total(key_stride) NE 3:BEGIN
; on ne shift pas mais il y a un stride
;,,,,,,,,,,,,,,,,,,,,,,,,
            ncdf_varget,cdfid,name,res,offset=[premierx*key_stride[0]+ixminmesh-ixmindta $
                                               ,premiery*key_stride[1]+iyminmesh-iymindta $
                                               ,premierz*key_stride[2]+izminmesh-izmindta] $
             ,count=[nx,ny,nz], stride = key_stride[0:2], _extra = ex
         END
;,,,,,,,,,,,,,,,,,,,,,,,,
         keyword_set(key_shift) NE 0 AND total(key_stride) EQ 3:BEGIN
; on shift mais il n''y a pas de stride
;,,,,,,,,,,,,,,,,,,,,,,,,
            case 1 of
               premierx GE key:BEGIN ; on peut tout couper d''un coup
                  ncdf_varget,cdfid,name,res,offset=[ixmin-key+premierx $
                                                     ,premiery+iyminmesh-iymindta $
                                                     ,premierz+izminmesh-izmindta] $
                   ,count=[nx,ny,nz], _extra = ex
               END
               dernierx LE key-1:BEGIN ; on peut tout couper d''un coup
                  ncdf_varget,cdfid,name,res,offset=[jpi-key+ixmin+premierx $
                                                     ,premiery+iyminmesh-iymindta $
                                                     ,premierz+izminmesh-izmindta] $
                   ,count=[nx,ny,nz], _extra = ex
               END
               ELSE:BEGIN       ; Le tableau est separe en 2 morceaux...
                  ncdf_varget,cdfid,name,tab1,offset=[jpi-key+ixmin+premierx $
                                                      ,premiery+iyminmesh-iymindta $
                                                      ,premierz+izminmesh-izmindta] $
                   ,count=[key-1-premierx+1,ny,nz], _extra = ex
                  ncdf_varget,cdfid,name,tab2,offset=[ixmin $
                                                      ,premiery+iyminmesh-iymindta $
                                                      ,premierz+izminmesh-izmindta] $
                   ,count=[dernierx-key+1,ny,nz], _extra = ex
                  res = [temporary(tab1), temporary(tab2)]
               END
            ENDCASE
         END
;,,,,,,,,,,,,,,,,,,,,,,,,
         keyword_set(key_shift) NE 0 AND total(key_stride) NE 3:BEGIN
; on shift et il y a un stride
;,,,,,,,,,,,,,,,,,,,,,,,,
            case 1 OF           ; case sur la facon de fire le champ
               premierx GE ceil(1.*key/key_stride[0]):BEGIN ; on peut tout coupe d''un coup
                  ncdf_varget,cdfid,name,res,offset=[ixmin-key+premierx*key_stride[0] $
                                                     ,premiery*key_stride[1]+iyminmesh-iymindta $
                                                     ,premierz*key_stride[2]+izminmesh-izmindta] $
                   ,count=[nx,ny,nz], stride = key_stride[0:2], _extra = ex
               END
               dernierx LE (key-1)/key_stride[0]:BEGIN ; on peut tout coupe d''un coup
                  ncdf_varget,cdfid,name,res,offset=[jpitotal-key+ixmin+premierx*key_stride[0] $
                                                     ,premiery*key_stride[1]+iyminmesh-iymindta $
                                                     ,premierz*key_stride[2]+izminmesh-izmindta] $
                   ,count=[nx,ny,nz], stride = key_stride[0:2], _extra = ex
               END
               ELSE:BEGIN       ; le tableau est separe en 2 morceaux...
                  ncdf_varget,cdfid,name,tab1,offset=[jpitotal-key+ixmin+premierx*key_stride[0] $
                                                      ,premiery*key_stride[1]+iyminmesh-iymindta $
                                                      ,premierz*key_stride[2]+izminmesh-izmindta] $
                   ,count=[(key-1-premierx*key_stride[0]+1)/key_stride[0],ny,nz] $
                   , stride = key_stride[0:2], _extra = ex
; il en manque un bout?
                  IF ( (key-1-premierx*key_stride[0]) MOD key_stride[0] ) EQ 0 then begin
                     ncdf_varget,cdfid,name,tab1bis,offset=[jpitotal-1+ixmin $
                                                            ,premiery*key_stride[1]+iyminmesh-iymindta $
                                                            ,premierz*key_stride[2]+izminmesh-izmindta] $
                      ,count=[1,ny,nz] $
                      , stride = [1, key_stride[1:2]], _extra = ex
                     tab1bis = reform(tab1bis, 1, ny, nz, /over)
                     tab1 = [temporary(tab1), temporary(tab1bis)]
                  ENDIF
; 2eme bout...
                  ncdf_varget,cdfid,name,tab2,offset=[ceil(1.*key/key_stride[0])*key_stride[0]-key+ixmin $
                                                      ,premiery*key_stride[1]+iyminmesh-iymindta $
                                                      ,premierz*key_stride[2]+izminmesh-izmindta] $
                   ,count=[(dernierx*key_stride[0]-key+1)/key_stride[0],ny,nz] $
                   , stride = key_stride[0:2], _extra = ex
; on recolle le tout
                  res = [temporary(tab1), temporary(tab2)]
               END
            ENDCASE             ; case sur la facon de fire le champ
         END
      ENDCASE                   ; differentes possibilites de key_shift et key_performance
   END
;......................................................................
;......................................................................
   varcontient.ndims eq 3 AND (where(varcontient.dim EQ contient.recdim))[0] NE -1:BEGIN ;xyt array
;......................................................................
;......................................................................
      case 1 of
;,,,,,,,,,,,,,,,,,,,,,,,,
         keyword_set(key_shift) EQ 0 AND total(key_stride) EQ 3:BEGIN
; on ne shift pas et il n''y a pas de stride
;,,,,,,,,,,,,,,,,,,,,,,,,
            ncdf_varget,cdfid,name,res,offset=[premierx+ixminmesh-ixmindta $
                                               ,premiery+iyminmesh-iymindta $
                                               ,premiertps] $
             ,count=[nx,ny,jpt], _extra = ex
         END
;,,,,,,,,,,,,,,,,,,,,,,,,
         keyword_set(key_shift) EQ 0 AND total(key_stride) NE 3:BEGIN
; on ne shift pas mais il y a un stride
;,,,,,,,,,,,,,,,,,,,,,,,,
            ncdf_varget,cdfid,name,res,offset=[premierx*key_stride[0]+ixminmesh-ixmindta $
                                               ,premiery*key_stride[1]+iyminmesh-iymindta $
                                               ,premiertps] $
             ,count=[nx,ny,jpt], stride = [key_stride[0:1], 1], _extra = ex
         END
;,,,,,,,,,,,,,,,,,,,,,,,,
         keyword_set(key_shift) NE 0 AND total(key_stride) EQ 3:BEGIN
; on shift mais il n''y a pas de stride
;,,,,,,,,,,,,,,,,,,,,,,,,
            case 1 of
               premierx GE key:BEGIN ; on peut tout couper d''un coup
                  ncdf_varget,cdfid,name,res,offset=[ixmin-key+premierx $
                                                     ,premiery+iyminmesh-iymindta $
                                                     ,premiertps] $
                   ,count=[nx,ny,jpt], _extra = ex
               END
               dernierx LE key-1:BEGIN ; on peut tout couper d''un coup
                  ncdf_varget,cdfid,name,res,offset=[jpi-key+ixmin+premierx $
                                                     ,premiery+iyminmesh-iymindta $
                                                     ,premiertps] $
                   ,count=[nx,ny,jpt], _extra = ex
               END
               ELSE:BEGIN       ; Le tableau est separe en 2 morceaux...
                  ncdf_varget,cdfid,name,tab1,offset=[jpi-key+ixmin+premierx $
                                                      ,premiery+iyminmesh-iymindta $
                                                      ,premiertps] $
                   ,count=[key-1-premierx+1,ny,jpt], _extra = ex
                  ncdf_varget,cdfid,name,tab2,offset=[ixmin $
                                                      ,premiery+iyminmesh-iymindta $
                                                      ,premiertps] $
                   ,count=[dernierx-key+1,ny,jpt], _extra = ex
                  res = [temporary(tab1), temporary(tab2)]
               END
            ENDCASE
         END
;,,,,,,,,,,,,,,,,,,,,,,,,
         keyword_set(key_shift) NE 0 AND total(key_stride) NE 3:BEGIN
; on shift et il y a un stride
;,,,,,,,,,,,,,,,,,,,,,,,,
            case 1 OF           ; case sur la facon de fire le champ
               premierx GE ceil(1.*key/key_stride[0]):BEGIN ; on peut tout coupe d''un coup
                  ncdf_varget,cdfid,name,res,offset=[ixmin-key+premierx*key_stride[0] $
                                                     ,premiery*key_stride[1]+iyminmesh-iymindta $
                                                     ,premiertps] $
                   ,count=[nx,ny,jpt], stride = [key_stride[0:1], 1], _extra = ex
               END
               dernierx LE (key-1)/key_stride[0]:BEGIN ; on peut tout coupe d''un coup
                  ncdf_varget,cdfid,name,res,offset=[jpitotal-key+ixmin+premierx*key_stride[0] $
                                                     ,premiery*key_stride[1]+iyminmesh-iymindta $
                                                     ,premiertps] $
                   ,count=[nx,ny,jpt], stride = [key_stride[0:1], 1], _extra = ex
               END
               ELSE:BEGIN       ; le tableau est separe en 2 morceaux...
                  ncdf_varget,cdfid,name,tab1,offset=[jpitotal-key+ixmin+premierx*key_stride[0] $
                                                      ,premiery*key_stride[1]+iyminmesh-iymindta $
                                                      ,premiertps] $
                   ,count=[(key-1-premierx*key_stride[0]+1)/key_stride[0],ny,jpt] $
                   , stride = [key_stride[0:1], 1], _extra = ex
; il en manque un bout?
                  IF ( (key-1-premierx*key_stride[0]) MOD key_stride[0] ) EQ 0 then begin
                     ncdf_varget,cdfid,name,tab1bis,offset=[jpitotal-1+ixmin $
                                                            ,premiery*key_stride[1]+iyminmesh-iymindta $
                                                            ,premiertps] $
                      ,count=[1,ny,jpt] $
                      , stride = [1, key_stride[1:1], 1], _extra = ex
                     tab1bis = reform(tab1bis, 1, ny, jpt, /over)
                     tab1 = [temporary(tab1), temporary(tab1bis)]
                  ENDIF
; 2eme bout...
                  ncdf_varget,cdfid,name,tab2,offset=[ceil(1.*key/key_stride[0])*key_stride[0]-key+ixmin $
                                                      ,premiery*key_stride[1]+iyminmesh-iymindta $
                                                      ,premiertps] $
                   ,count=[(dernierx*key_stride[0]-key+1)/key_stride[0],ny,jpt] $
                   , stride = [key_stride[0:1], 1], _extra = ex
; on recolle le tout
                  res = [temporary(tab1), temporary(tab2)]
               END
            ENDCASE             ; case sur la facon de fire le champ
         END
      endcase
   END
;......................................................................
;......................................................................
   varcontient.ndims eq 4:BEGIN ;xyzt array
;......................................................................
;......................................................................
      case 1 of
;,,,,,,,,,,,,,,,,,,,,,,,,
         keyword_set(key_shift) EQ 0 AND total(key_stride) EQ 3:BEGIN
; on ne shift pas et il n''y a pas de stride
;,,,,,,,,,,,,,,,,,,,,,,,,
            ncdf_varget,cdfid,name,res,offset=[premierx+ixminmesh-ixmindta $
                                               ,premiery+iyminmesh-iymindta $
                                                      ,premierz+izminmesh-izmindta $
                                               ,premiertps] $
             ,count=[nx,ny,nz,jpt], _extra = ex
         END
;,,,,,,,,,,,,,,,,,,,,,,,,
         keyword_set(key_shift) EQ 0 AND total(key_stride) NE 3:BEGIN
; on ne shift pas mais il y a un stride
;,,,,,,,,,,,,,,,,,,,,,,,,
            ncdf_varget,cdfid,name,res,offset=[premierx*key_stride[0]+ixminmesh-ixmindta $
                                               ,premiery*key_stride[1]+iyminmesh-iymindta $
                                               ,premierz*key_stride[2]+izminmesh-izmindta $
                                               ,premiertps] $
             ,count=[nx,ny,nz,jpt], stride = [key_stride[0:2], 1], _extra = ex
         END
;,,,,,,,,,,,,,,,,,,,,,,,,
         keyword_set(key_shift) NE 0 AND total(key_stride) EQ 3:BEGIN
; on shift mais il n''y a pas de stride
;,,,,,,,,,,,,,,,,,,,,,,,,
            case 1 of
               premierx GE key:BEGIN ; on peut tout couper d''un coup
                  ncdf_varget,cdfid,name,res,offset=[ixmin-key+premierx $
                                                     ,premiery+iyminmesh-iymindta $
                                                     ,premierz+izminmesh-izmindta $
                                                     ,premiertps] $
                   ,count=[nx,ny,nz,jpt], _extra = ex
               END
               dernierx LE key-1:BEGIN ; on peut tout couper d''un coup
                  ncdf_varget,cdfid,name,res,offset=[jpi-key+ixmin+premierx $
                                                     ,premiery+iyminmesh-iymindta $
                                                     ,premierz+izminmesh-izmindta $
                                                     ,premiertps] $
                   ,count=[nx,ny,nz,jpt], _extra = ex
               END
               ELSE:BEGIN       ; Le tableau est separe en 2 morceaux...
                  ncdf_varget,cdfid,name,tab1,offset=[jpi-key+ixmin+premierx $
                                                      ,premiery+iyminmesh-iymindta $
                                                      ,premierz+izminmesh-izmindta $
                                                      ,premiertps] $
                   ,count=[key-1-premierx+1,ny,nz,jpt], _extra = ex
                  ncdf_varget,cdfid,name,tab2,offset=[ixmin $
                                                      ,premiery+iyminmesh-iymindta $
                                                      ,premierz+izminmesh-izmindta $
                                                      ,premiertps] $
                   ,count=[dernierx-key+1,ny,nz,jpt], _extra = ex
                  res = [temporary(tab1), temporary(tab2)]
               END
            ENDCASE
         END
;,,,,,,,,,,,,,,,,,,,,,,,,
         keyword_set(key_shift) NE 0 AND total(key_stride) NE 3:BEGIN
; on shift et il y a un stride
;,,,,,,,,,,,,,,,,,,,,,,,,
            case 1 OF           ; case sur la facon de fire le champ
               premierx GE ceil(1.*key/key_stride[0]):BEGIN ; on peut tout coupe d''un coup
                  ncdf_varget,cdfid,name,res,offset=[ixmin-key+premierx*key_stride[0] $
                                                     ,premiery*key_stride[1]+iyminmesh-iymindta $
                                                     ,premierz*key_stride[2]+izminmesh-izmindta $
                                                     ,premiertps] $
                   ,count=[nx,ny,nz,jpt], stride = [key_stride[0:2], 1], _extra = ex
               END
               dernierx LE (key-1)/key_stride[0]:BEGIN ; on peut tout coupe d''un coup
                  ncdf_varget,cdfid,name,res,offset=[jpitotal-key+ixmin+premierx*key_stride[0] $
                                                     ,premiery*key_stride[1]+iyminmesh-iymindta $
                                                     ,premierz*key_stride[2]+izminmesh-izmindta $
                                                     ,premiertps] $
                   ,count=[nx,ny,nz,jpt], stride = [key_stride[0:2], 1], _extra = ex
               END
               ELSE:BEGIN       ; le tableau est separe en 2 morceaux...
                  ncdf_varget,cdfid,name,tab1,offset=[jpitotal-key+ixmin+premierx*key_stride[0] $
                                                      ,premiery*key_stride[1]+iyminmesh-iymindta $
                                                     ,premierz*key_stride[2]+izminmesh-izmindta $
                                                      ,premiertps] $
                   ,count=[(key-1-premierx*key_stride[0]+1)/key_stride[0],ny,nz,jpt] $
                   , stride = [key_stride[0:2], 1], _extra = ex
; il en manque un bout?
                  IF ( (key-1-premierx*key_stride[0]) MOD key_stride[0] ) EQ 0 then begin
                     ncdf_varget,cdfid,name,tab1bis,offset=[jpitotal-1+ixmin $
                                                            ,premiery*key_stride[1]+iyminmesh-iymindta $
                                                     ,premierz*key_stride[2]+izminmesh-izmindta $
                                                            ,premiertps] $
                      ,count=[1,ny,nz,jpt] $
                      , stride = [1, key_stride[1:2], 1], _extra = ex
                     tab1bis = reform(tab1bis, 1, ny, nz, jpt, /over)
                     tab1 = [temporary(tab1), temporary(tab1bis)]
                  ENDIF
; 2eme bout...
                  ncdf_varget,cdfid,name,tab2,offset=[ceil(1.*key/key_stride[0])*key_stride[0]-key+ixmin $
                                                      ,premiery*key_stride[1]+iyminmesh-iymindta $
                                                     ,premierz*key_stride[2]+izminmesh-izmindta $
                                                      ,premiertps] $
                   ,count=[(dernierx*key_stride[0]-key+1)/key_stride[0],ny,nz,jpt] $
                   , stride = [key_stride[0:2], 1], _extra = ex
; on recolle le tout
                  res = [temporary(tab1), temporary(tab2)]
               END
            ENDCASE             ; case sur la facon de fire le champ
         END
      endcase
   END
endcase