; ---------------------------------------------------------------------
;                                 rh_open
; ---------------------------------------------------------------------
; Ouvre un fichier RH et definit le common RH (cf rh_common.inc)
; Le keyword MONO ou SEL definit le mode de lecture.
; ---------------------------------------------------------------------
; 
; CALLING SEQUENCE: 
;       status = rh_open(fichier) 
; 
; INPUTS:
;	fichier : nom du fichier a ouvrir 
;
; OUTPUTS: 
;       status : = 1 lecture correcte
;	         = 0 erreur 
;                   !ERROR contient le code de l'erreur
;	            !SYSERR_STRING contient le message d'erreur
;
; KEYWORD:
;	MONO  : lecture acquisition par acquisition
;	        sinon par jeu de frequences
;	SEL   : lecture par jeu, mais selection d'une frequence 
;	        non polar ou polar
;	MALAX : initialise malax
;
; COMMON BLOCKS: 
;	common RH
; HISTORY
;       Mars 2002 : operation antennes anti_alias
;                   44 antennes ---> 48 antennes
;                   576 correlations ---> 576 + 4*18 = 648 correlations
; -----------------------------------------------------------------------------

FUNCTION rh_open, fichier, MONO = MONO, SEL=SEL, MALAX=MALAX

@rh_common.inc

ON_IOERROR, ERR
status = 0

; PREPARATION ANTIALIASING
; Selection du nombre d'antennes, du nombre de correlations
; Ajout de nbant, nbcorel a la fin de entFi

 typ=0
 val = 0
 openr, u, fichier, /Get_Lun
 point_lun, u, 10L
 readu, u, typ
 point_lun, u, 18L 
 readu, u, val
 IF typ GT 255 THEN val = swap_endian(val)
; print, val
 close, u
 free_lun,u
 IF val LE 576*4 THEN BEGIN
    nbant1 = 44L
    nbcorel1 = 576L
 ENDIF ELSE BEGIN
    nbant1 = 48L 	; = 44 + 4
    nbcorel1 = 648L	; = 576 + 4 x 18
 ENDELSE
;Structure de la tete du fichier

  entCOR=replicate({entCOR,$ 			; def table de correction
		frq:0,			$
		dat:intarr(3),		$
		ref:bytarr(6),		$
		coeff_gain:0,		$
		gain_np:intarr(nbant1),	$
		gain_p:intarr(nbant1),	$
		phase_np:intarr(nbant1),	$
		phase_p:intarr(nbant1) },10)

entFI = {entFI,				$ 	; def entete du fichier
		lgent:0L,		$
		filesize:0L,   	 	$
		lg:0,   	 	$
		typ:0,			$
		cod:0,	    		$
		rep:0,			$
		lgtet:0,		$
		nval:0,	       		$
		nval_2d:0,     		$
		nval_ew:0,     		$
		nval_ns:0,		$
		d_typ:bytarr(6),	$
		itg:0L, 		$
		dat:intarr(3),		$
		ref:bytarr(6),		$
		mer:intarr(4),		$
		dec:intarr(4),		$
		hg:0,			$
		hdeb:intarr(4),		$
		hfin:intarr(4),		$
		nf:0,	     		$
		frq:intarr(10),	        $
		trj:0,	       		$
		comp:0,			$
		cyclms:0,		$
		d_obs:bytarr(78),	$
		depew:0,		$
		dephew:0, 		$
		rotew:0,		$
		rotns:0,		$
		pxant:lonarr(nbant1),	$		
		pyant:lonarr(nbant1),	$
		corel:intarr(2,nbcorel1),	$	
		entCOR:entCOR,		$
		descrip:bytarr(80,2),   $
		activ:bytarr(80),	$
		pannes:bytarr(80,3),	$
		evenements:bytarr(80,15), $
		endian:0L,		$
		klumax:0L,              $
                dtu:0L,                 $
		nbant: 0L, 		$
		nbcorel: 0L, 		$
		libre:lonarr(54) $
                }
;Lecture de la tete du fichier

  openr, u, fichier, /Get_Lun
  readu, u, entFI
  IF entFI.typ GT 255 THEN BEGIN
	entfi = swap_endian(entfi)
	entfi.endian = 1
  ENDIF ELSE BEGIN
	entfi.endian = 0
    ENDELSE
	
; MODIF ANTIALIASING

  entFI.nbant = nbant1
  entFI.nbcorel = entFI.nval/4

   entfi.dat(2) = rh_date100(entfi.dat(2),/full)
   status = 1

;Remplissage de sFI

  sFI = {sFI,				$ 	
		unit:0L,		$
		name:'',		$
		mode:0 ,		$
		tFI:intarr(4,entfi.nbcorel)	$
      }
  s = fstat(u)	
;Mise a jour de la taille du fichier
  entfi.filesize = s.size

  sFI.unit = s.unit
  sFI.name = s.name
  sFI.mode = 1
  IF keyword_set(MONO) THEN sFI.mode = 0
  FOR k=0, entFI.nval/4-1 DO BEGIN
      sFI.tFI(*,k) = 2
      IF entFI.corel(0,k) LT 19 AND entFI.corel(1,k) LT 19 THEN sFI.tFI(*,k)=0
      IF (entFI.corel(0,k) GE 19 AND entFI.corel(0,k)LT 44 ) AND $
         (entFI.corel(1,k) GE 19 AND entFI.corel(1,k)LT 44) THEN sFI.tFI(*,k)=1
  ENDFOR
  
;Structure decrivant une acquisition decodee
  luFI={ g:intarr(entFI.typ+1), pt:fltarr(4, entfi.nval/4)}
  IF NOT KEYWORD_SET(MONO) THEN luFI = replicate(luFI, entFI.nf)
  IF KEYWORD_SET(SEL) THEN luFI = { g:intarr(entFI.typ+1), $
                                    pt:fltarr(2, entfi.nval/4)}

;Association de la variable aFI au numero logique u

;Structure decrivant une acquisition brute
  IF entFI.typ EQ 1 THEN bFI={ c:0, nof:0, h:intarr(4), g:intarr(2), $
                               pt:intarr(4, entfi.nval/4)}
  IF entFI.typ EQ 2 THEN bFI={ c:0, nof:0, h:intarr(4), g:intarr(3), nul0:0, $
                               pt:intarr(4,entfi.nval/4), $
                               nul1:intarr(entFI.lg/2-entFI.nval-entfi.lgtet)}
  IF NOT KEYWORD_SET(MONO) THEN bFI = replicate(bFI, entFI.nf)
  aFI = ASSOC(u, bFI, entFI.lgent) 

;Nombre max d'acq
  klu = long((entFI.filesize-entfi.lgent)/long(entfi.lg))
  entfi.klumax = klu
  IF NOT KEYWORD_SET(MONO) THEN entFI.klumax = klu/entFI.nf
  entFI.klumax = entFI.klumax-1L

;Heure de debut et de fin
  entfi.hdeb = rh_readh(0L)
  entfi.hfin = rh_readh(entFI.klumax)
        
; Init Malax pour le calcul d'image
  IF KEYWORD_SET(MALAX) THEN rh_init_malax_rh
  RETURN,status
ERR : 

   sFI = {sFI,                         $
               unit:0L,                $
               name:'',                $
               mode:0 ,                $
               tFI:intarr(4,entfi.nbcorel)       $
       }
  sFI.unit=u
  RETURN,status

END