{ this unit contains all the low level procedures which are used to             }
{ read various file formats                                                     }
{ Creation : 30/01/05                                                           }
unit FilesIO;

interface

uses sysutils,editdata,lectureTPAOptions, Dialogs, math;

{ lecture de fichiers 1D }
procedure ReadPNRfile(FileName,Basename:string);
{ lecture de fichiers 2D }
procedure LectureLAMPD17File(FileName,OutPutSpectra:string);
procedure LectureTPAFile(FileName,OutPutSpectra:string);
procedure LectureFichierHADAS(fileName:string);
procedure Read3columnsXYZ_SDMSfile(FileName,OutPutSpectrum:string);
procedure ReadFromMatlab(FileName,OutputSpectrum:string);
procedure ReadfreeXYZ(FileName,OutputSpectrum:string);
procedure ReadHADASglatt(FileName,OutputSpectrum:string);
procedure Read3columnsfileXYZ(FileName,OutputSpectrum:string);
procedure ReadIsGISAXSfile(FileName,OutputSpectrum:string);
procedure ReadOVFfile2D(FileName,OutputSpectrum:string);
procedure ReadOVFfile3D(FileName,OutputSpectrum:string);
procedure ReadReflexDat(FileName,OutputSpectrum:string);

implementation

{ lecture d'in fichier de data crée par PNR }
procedure ReadPNRfile(FileName,BaseName:string);
var f:textFile;
    i,npts,induu,inddd,indud,inddu:integer;
    s:string;
    valeurs:valuesVector;
begin
    AssignFile(F, FileName);{ Fichier sélectionné dans la boîte de dialogue }
    Reset(F);
    s:='';npts:=0;
    { lecture des data jusqu'au caractère & }
    repeat begin
           readln(F,s);
           inc(npts);
           end;
    until s='&';
    dec(npts);
    induu:=und.addspectre(basename+'_uu',Npts,1,1);
    inddd:=und.addspectre(basename+'_dd',Npts,1,1);
    indud:=und.addspectre(basename+'_ud',Npts,1,1);
    inddu:=und.addspectre(basename+'_du',Npts,1,1);

    { lecture des data proprement dit }
    reset(F);
    for i:=0 to Npts-1 do
    begin
      readln(F,s);
      valeurs:=ProcessString(s);
      und.spect[induu].data[i,0,0].x:=Valeurs[1];
      und.spect[induu].data[i,0,0].z:=Valeurs[2];
    end;
    readln(F,s);
    for i:=0 to Npts-1 do
    begin
      readln(F,s);
      valeurs:=ProcessString(s);
      und.spect[inddd].data[i,0,0].x:=Valeurs[1];
      und.spect[inddd].data[i,0,0].z:=Valeurs[2];
    end;
    readln(F,s);
    for i:=0 to Npts-1 do
    begin
      readln(F,s);
      valeurs:=ProcessString(s);
      und.spect[indud].data[i,0,0].x:=Valeurs[1];
      und.spect[indud].data[i,0,0].z:=Valeurs[2];
    end;
    readln(F,s);
    for i:=0 to Npts-1 do
    begin
      readln(F,s);
      valeurs:=ProcessString(s);
      und.spect[inddu].data[i,0,0].x:=Valeurs[1];
      und.spect[inddu].data[i,0,0].z:=Valeurs[2];
    end;

    CloseFile(F);
end;


{ lecture d'un spectre de format LAMP crée par D17 }
{ on lit les data uniquement : spectre de 143500 data }
{ 500 canaux de temps de vol et 287 canaux de position }
{ on laisse tomber le sinfor!mations sur le spectromètre }
{ INPUT : fileName on the hard drive                                }
{         string for the name of the outpput spectra in the program }
{ OUTPUT : the 2D is loaded (without any check                      }
procedure LectureLAMPD17File(FileName,OutPutSpectra:string);
var dataLAMP:array[1..143500] of integer;
    f:textFile;
    n,i,j,k,vind,indiceValeur,errorCode,aux:integer;
    s,s1:string;
    finchaine:boolean;
begin
    AssignFile(F, FileName);{ Fichier sélectionné dans la boîte de dialogue }
    Reset(F);
    s:='';aux:=0;
    { lecture de l'entete jusqu'au débuit des data }
    while aux<>143500 do begin readln(F,s);val(s,aux,ErrorCode); end;
    { il faut redimensionner le spectre 2D et allouer la memoire }
{    vind:=deuxd.addspectre(OutPutSpectra,287,500,1); { addspectre detruit automatiquement le spectre s'il existait deja }
    vind:=deuxd.addspectre(OutPutSpectra,286,500,1);
    deuxd.spect[vind].ExpCondNbr:=0;
    deuxd.spect[vind].typeX:='raw';deuxd.spect[vind].typeY:='raw';
    for k:=1 to 14350 do
    begin
        { on lit les data ligne par ligne et on remplit au fur et a mesure le tableau }
        readln(f,s);
        { traitement de la chaine pour en extraire les nombres }
        { il y a 10 valeurs par ligne et donc 14350 lignes }
        { il y a une serie d'espaces devant le premier chiffre }
        n:=1;while s[n]=' ' do inc(n); { on saute les espaces avant le premier chiffre }
        S1:='';finChaine:=false;indiceValeur:=1;
        while not FinChaine do
        begin
             s1:='';
             while (S[n]<>' ') and (n<=length(S)) do {#9 est un caractère tab , #10 est LF}
             begin s1:=s1+s[n];inc(n); end;
             if n>length(S) then FinChaine:=true;
             inc(n);while s[n]=' ' do inc(n); { on saute les espaces }
             dataLAMP[(k-1)*10+indiceValeur]:=StrToInt(s1);
             indiceValeur:=indiceValeur+1;
        end;
    end;
    { transfert des data dans le tableau à deux dimensions }
    i:=0;j:=0;
{    for k:=1 to 143500 do }
    for k:=1 to 143000 do
    begin
        deuxd.spect[vind].data[i,j,0].x:=i;
        deuxd.spect[vind].data[i,j,0].y:=j;
        deuxd.spect[vind].data[i,j,0].z:=dataLAMP[k];
        inc(i);if i=286 then begin i:=0;inc(j); end;
    end;
    CloseFile(F);
end;


{ INPUT : fileName on the hard drive                                }
{         string for the name of the outpput spectra in the program }
{ OUTPUT : the 2D is loaded (without any check                      }
procedure LectureTPAFile(FileName,OutPutSpectra:string);
type DataTPA1200 = array[0..1200,0..1199] of word;
     DataTPA1600 = array[0..1600,0..1599] of word;
     DataTPA2300 = array[0..2300,0..2299] of word;
     DataTPA2400 = array[0..2400,0..2399] of word;
var f1200:file of dataTPA1200;f1600:file of dataTPA1600;f2300:file of dataTPA2300;f2400:file of dataTPA2400;
    d:word;
    n,i,j,ii,k,l,vind,indiceValeur,errorCode,aux,imgSize:integer;
    s,s1:string;
    finchaine:boolean;
    MyData1200:^dataTPA1200;MyData1600:^dataTPA1600;MyData2300:^dataTPA2300;MyData2400:^dataTPA2400;
    MyData:pointer;
    xmin,xmax,ymin,ymax,sampling,sizex,sizey:integer;
begin
    xmin:=LectureTPAoptionsForm.xminImageTPA.value;
    xmax:=LectureTPAoptionsForm.xmaxImageTPA.value;
    ymin:=LectureTPAoptionsForm.yminImageTPA.value;
    ymax:=LectureTPAoptionsForm.ymaxImageTPA.value;
    sampling:=LectureTPAoptionsForm.SamplingImageTPA.value;
    ImgSize:=LectureTPAoptionsForm.ImageSize.value;
    sizex:=trunc((xmax-xmin+1)/sampling);
    sizey:=trunc((ymax-ymin+1)/sampling);

    case ImgSize of
    1200:begin AssignFile(f1200, FileName);reset(f1200);new(MyData1200);read(f1200,MyData1200^);MyData:=MyData1200;CloseFile(F1200) end;
    1600:begin AssignFile(f1600, FileName);reset(f1600);new(MyData1600);read(f1600,MyData1600^);MyData:=MyData1600;CloseFile(F1600) end;
    2300:begin AssignFile(f2300, FileName);reset(f2300);new(MyData2300);read(f2300,MyData2300^);MyData:=MyData2300;CloseFile(F2300) end;
    2400:begin AssignFile(f2400, FileName);reset(f2400);new(MyData2400);read(f2400,MyData2400^);MyData:=MyData2400;CloseFile(F2400) end;
    else begin MessageDlg('The image file does not have a standard size (1200, 1600, 2300 or 2400)', mtInformation,[mbOk], 0);exit end;   end;

    vind:=deuxd.addspectre(OutPutSpectra,sizeX,sizeY,1); { addspectre detruit automatiquement le spectre s'il existait deja }
    deuxd.spect[vind].ExpCondNbr:=0;
    deuxd.spect[vind].typeX:='raw';deuxd.spect[vind].typeY:='raw';
    { il faut sauter la premiere ligne qui contient probablement des informations }
    { faut-il sauter la première ligne ou la première colonne ? }
    { on fait une moyenne sur 16 points }
    for i:=0 to sizeX-1 do
      for j:=0 to sizeY-1 do
        begin
{            deuxd.spect[vind].data[i,sizeY-1-j,0].x:=xmin-1+sampling*i;
            deuxd.spect[vind].data[i,sizeY-1-j,0].y:=ymin-1+sampling*j; }
            deuxd.spect[vind].data[i,sizeY-1-j,0].x:=xmin+sampling*i;
            deuxd.spect[vind].data[i,sizeY-1-j,0].y:=ymin+sampling*j;
            aux:=0;
            for k:=0 to sampling-1 do { on fait une moyenne sur 4 points }
               for l:=0 to sampling-1 do { on fait une moyenne sur 4 points }
                  case ImgSize of
                  1200:aux:=MyData1200[xmin-1+sampling*i+k,ymin-1+sampling*j+l];
                  1600:aux:=MyData1600[xmin-1+sampling*i+k,ymin-1+sampling*j+l];
                  2300:aux:=MyData2300[xmin-1+sampling*i+k,ymin-1+sampling*j+l];
                  2400:aux:=MyData2400[xmin-1+sampling*i+k,ymin-1+sampling*j+l];
                  end;
            deuxd.spect[vind].data[i,sizeY-1-j,0].z:=aux;
        end;

end;

{ lecture d'un fichier HADAS }
{ INPUT: le nom du fichier COMPLET (avec chemin du répertoire ) }
{ OUTPUT: le fichier est chargé et rajouté dans la liste des fichiers }
procedure LectureFichierHADAS(fileName:string);
var
  i,j,k,l,errorcode:integer;
  nbrPointsExp:integer; { nombre de points expérimentaux }
  indiceValeur:integer; { indice de la valeur dans la ligne de texte }
  F: TextFile;
  S,S1: string[255];
  aux:double;
  valeurs:array[1..10] of double; { valeurs numériques lues sur la ligne }
  finChaine:boolean;
  X,Y,LT:integer;
  vind:integer;
  c:char;
  name,ext:string; { nom et extension du fichier }
begin
    AssignFile(F, FileName);{ Fichier sélectionné dans la boîte de dialogue }
    Reset(F);
    { il faut redimensionner le spectre 3D et réallouer la memoire }
    X:=256;Y:=256;LT:=1;
    { extraction du nom du fichier a partir du chemin complet }
    name:=ProcessFileName(filename);

    deuxd.addspectre(name,X,Y,LT); { addspectre detruit automatiquement le spectre s'il existait deja }
    vind:=deuxd.indexof(name);
    for i:=0 to X-1 do
    for j:=0 to Y-1 do
    for k:=0 to LT-1 do
    begin
         s:='';
        repeat
        Read(F, c);    { Lecture de la première ligne du fichier }
        if c<>#10 then s:=s+c;
        until c=#10;
        deuxd.spect[vind].data[j,i,k].x:=j;
        deuxd.spect[vind].data[j,i,k].y:=i;
        deuxd.spect[vind].data[j,i,k].lt:=0;
        deuxd.spect[vind].data[j,i,k].z:=StrToFloat(s);
    end;
    deuxd.spect[vind].typeX:='raw';deuxd.spect[vind].typeY:='raw';
    CloseFile(F);
end;

{ lecture des fichiers calculées par SMDS }
{ le probleme est qu'on a pas les tailles en X et Y                             }
{ solution "basique" : compter le nombres de lignes et prendre la racine carrée }
procedure Read3columnsXYZ_SDMSfile(FileName,OutputSpectrum:string);
var
  i,j,k,n,errorcode:integer;
  indiceValeur:integer; { indice de la valeur dans la ligne de texte }
  F: TextFile;
  S,S1: string[255];
  aux:double;
  valeurs:valuesVector; { valeurs numériques lues sur la ligne }
  finChaine:boolean;
  X,Y,LT,size:integer;
  comment:string;
  vind,l:integer;
begin
    AssignFile(F, FileName);{ Fichier sélectionné dans la boîte de dialogue }
    Reset(F);
    Size:=0;
    while not(EOF(F)) do begin readln(F,s);inc(size); end;
    X:=round(sqrt(size));  { ACHTUNG : hypothese que la matrice calculée est carrée !!! }
    Y:=round(sqrt(size));
    vind:=deuxd.addspectre(OutputSpectrum,X,Y,1); { addspectre detruit automatiquement le spectre s'il existait deja }
    deuxd.spect[vind].ExpCondNbr:=0;
    deuxd.spect[vind].comment:=comment;
    reset(F);
    k:=0;
    for j:=0 to Y-1 do
    for i:=0 to X-1 do
    begin
        Readln(F, S);    { Lecture de la première ligne du fichier }
        { traitement de la chaine pour en extraire les nombres }
        valeurs:=ProcessString(s);
        deuxd.spect[vind].data[i,j,k].x:=Valeurs[1];
        deuxd.spect[vind].data[i,j,k].y:=Valeurs[2];
        deuxd.spect[vind].data[i,j,k].lt:=0;
        deuxd.spect[vind].data[i,j,k].z:=power(10,Valeurs[3]);
    end;
    CloseFile(F);
    deuxd.spect[vind].ExpCondNbr:=0;
end;

{ lecture d'un fichier 3 colonnes (MATLAB                                       }
{ INPUT : fichier 3 colonnes X,Y,intensité                                      }
{ OUTPUT : on le stocke                                                         }
{ taille fixe à 256x256!!!                                                      }
procedure ReadFromMatlab(FileName,OutputSpectrum:string);
var
  i,j,k,n,errorcode:integer;
  indiceValeur:integer; { indice de la valeur dans la ligne de texte }
  F: TextFile;
  S,S1: string[255];
  aux:double;
  valeurs:valuesVector; { valeurs numériques lues sur la ligne }
  finChaine:boolean;
  X,Y,LT:integer;
  comment,nom,ext:string;
  vind,l,NbPts:integer;
begin
    AssignFile(F, FileName);{ Fichier sélectionné dans la boîte de dialogue }
    Reset(F);
    NbPts:=0;
    while Not(Eof(F)) do begin Readln(F,S);inc(NbPts); end;
    X:=round(Sqrt(NbPts));Y:=X;
    vind:=deuxd.addspectre(OutPutSpectrum,X,Y,1); { addspectre detruit automatiquement le spectre s'il existait deja }
    deuxd.spect[vind].ExpCondNbr:=0;
    deuxd.spect[vind].comment:=comment;
    reset(F);
    k:=0;
    for j:=0 to Y-1 do
    for i:=0 to X-1 do
    begin
        Readln(F, S);    { Lecture de la première ligne du fichier }
        { traitement de la chaine pour en extraire les nombres }
        valeurs:=ProcessString(s);
        deuxd.spect[vind].data[i,j,k].x:=Valeurs[1];
        deuxd.spect[vind].data[i,j,k].y:=Valeurs[2];
        deuxd.spect[vind].data[i,j,k].lt:=0;
        deuxd.spect[vind].data[i,j,k].z:=Valeurs[3];
    end;
    CloseFile(F);
end;

{ lecture de points (X,Y,Z) qu'on rentre dans une matrice                       }
{ particularité de la procédure : les points n'ont pas besoin d'être "rangé"    }
{ la matrice peut être creuse  !!                                               }
{ INPUT : ligne 1 : commentaire                                                 }
{         ligne 2 : xmin, xpas, xmax                                            }
{         ligne 3 : ymin, ypas, ymax                                            }
{         ligne 4 : les points peuvent commencer                                }
{ on remplit la matrice au fur et à mesure                                      }
{ on ne fait pas de remplissage dans les trous                                  }
procedure ReadfreeXYZ(FileName,OutputSpectrum:string);
var
  i,j,k:integer;
  F: TextFile;
  S,S1: string[255];
  aux:double;
  valeurs:valuesVector; { valeurs numériques lues sur la ligne }
  X,Y,LT:integer;
  comment:string;
  vind:integer;
  xmin,xpas,xmax,ymin,ypas,ymax:double;
begin
    AssignFile(F, FileName);{ Fichier sélectionné dans la boîte de dialogue }
    Reset(F);
    { lecture de l'entete }
    readln(F,comment);
    { lecture des tailles des bornes pour les échalles X, Y }
    readln(F,s);valeurs:=processString(s);xmin:=valeurs[1];xpas:=valeurs[2];xmax:=valeurs[3];
    readln(F,s);valeurs:=processString(s);ymin:=valeurs[1];ypas:=valeurs[2];ymax:=valeurs[3];
    X:=round((xmax-xmin)/xpas)+1;
    Y:=round((ymax-ymin)/ypas)+1;
    LT:=1;
    { il faut redimensionner le spectre 3D et réallouer la memoire }
    vind:=deuxd.addspectre(OutputSpectrum,X,Y,LT); { addspectre detruit automatiquement le spectre s'il existait deja }
    deuxd.spect[vind].ExpCondNbr:=0;
    deuxd.spect[vind].comment:=comment;

    { initialisation du tableau au cas ou toutes les cases ne seraient pas remplies }
    k:=0;
    for j:=0 to Y-1 do
    for i:=0 to X-1 do
    begin
        deuxd.spect[vind].data[i,j,k].x:=xmin+i*xpas;
        deuxd.spect[vind].data[i,j,k].y:=ymin+j*ypas;
        deuxd.spect[vind].data[i,j,k].lt:=0;
        deuxd.spect[vind].data[i,j,k].z:=0;
    end;

    while not(Eof(f)) do
    begin
        Readln(F, S);    { Lecture de la première ligne du fichier }
        valeurs:=ProcessString(s);
        if (valeurs[1]>=(xmin-0.00000001)) and (valeurs[1]<=(xmax+0.00000001)) and (valeurs[2]>=(ymin-0.00000001)) and (valeurs[2]<=(ymax+0.00000001))
        then begin
                i:=round((Valeurs[1]-xmin)/xpas);
                j:=round((Valeurs[2]-ymin)/ypas);
                k:=0;
                deuxd.spect[vind].data[i,j,k].x:=Valeurs[1];
                deuxd.spect[vind].data[i,j,k].y:=Valeurs[2];
                deuxd.spect[vind].data[i,j,k].lt:=0;
                deuxd.spect[vind].data[i,j,k].z:=Valeurs[3];
                end;
    end;
    CloseFile(F);
end;

{ lecture des feuilles Glatt des data de HADAS }
procedure ReadHADASglatt(FileName,OutputSpectrum:string);
var
  i,j,k,n,errorcode:integer;
  F: textfile;
  S,S1: string[255];
  aux:double;
  comment,nom,ext:string;
  vind,l:integer;
  Z:double;
  XX,YY:array[0..1024] of double;
  XXsize,YYsize:integer;
begin
    XXsize:=0;YYsize:=0;
    { lecture des abscisses }
    AssignFile(F, FileName+'.x'); { Fichier sélectionné dans la boîte de dialogue }
    Reset(F);
    while not(EOF(F)) do begin readln(F,s);XX[XXsize]:=strToFloat(s);inc(XXsize); end;
    CloseFile(F);
    AssignFile(F, FileName+'.y');{ Fichier sélectionné dans la boîte de dialogue }
    Reset(F);
    while not(EOF(F)) do begin readln(F,s);YY[YYsize]:=strToFloat(s);inc(YYsize); end;
    CloseFile(F);
    { creation du spectre de data }
    vind:=deuxd.addspectre(OutputSpectrum,XXsize,YYsize,1); { addspectre detruit automatiquement le spectre s'il existait deja }
    { lectrue de sdata proprement dites }
    AssignFile(F, FileName+'.logz');
    Reset(F);
    for j:=0 to YYsize-1 do
     for i:=0 to XXsize-1 do
       begin
          readln(F,s);Z:=strToFloat(s);
          deuxd.spect[vind].data[i,j,0].x:=XX[i];
          deuxd.spect[vind].data[i,j,0].y:=YY[j];
          deuxd.spect[vind].data[i,j,0].z:=power(10,Z);
       end;
    CloseFile(F);
end;

{ lecture d'un fichier 3 colonnes (EROS)                                       }
{ INPUT : fichier 3 colonnes X,Y,intensité                             }
{ OUTPUT : on le stocke                                                        }
{ REM : pour le moement on utilise une structure 3D spécifique                 }
{ a terme cette structure doit etre intégrée à spectre                         }
{ NB : il faut réféchier au problème du zonage                                 }
procedure Read3columnsfileXYZ(FileName,OutputSpectrum:string);
var
  i,j,k,n,errorcode:integer;
  indiceValeur:integer; { indice de la valeur dans la ligne de texte }
  F: TextFile;
  S,S1: string[255];
  aux:double;
  valeurs:valuesVector; { valeurs numériques lues sur la ligne }
  finChaine:boolean;
  X,Y,LT:integer;
  comment,nom,ext:string;
  vind,l:integer;
begin
    AssignFile(F, FileName);{ Fichier sélectionné dans la boîte de dialogue }
    Reset(F);
    { lecture de l'entete }
    readln(F,comment);
    { lecture des tailles X,Y,LT }
    readln(F,s);
    X:=strToInt(s);
    readln(F,s);
    Y:=strToInt(s);
    LT:=1;
    { il faut redimensionner le spectre 3D et réallouer la memoire }
    vind:=deuxd.addspectre(outputSpectrum,X,Y,LT); { addspectre detruit automatiquement le spectre s'il existait deja }
    deuxd.spect[vind].ExpCondNbr:=0;
    deuxd.spect[vind].comment:=comment;
    k:=0;
    for j:=0 to Y-1 do
    for i:=0 to X-1 do
    begin
        Readln(F, S);    { Lecture de la première ligne du fichier }
        { traitement de la chaine pour en extraire les nombres }
        valeurs:=ProcessString(s);
        deuxd.spect[vind].data[i,j,k].x:=Valeurs[1];
        deuxd.spect[vind].data[i,j,k].y:=Valeurs[2];
        deuxd.spect[vind].data[i,j,k].lt:=0;
        deuxd.spect[vind].data[i,j,k].z:=Valeurs[3];
    end;
    CloseFile(F);
    deuxd.spect[vind].ExpCondNbr:=0;
end;

{ lecture d'un fichier out de IsGISAXS                                         }
{ INPUT : fichier 3 colonnes X,Y,intensité                                     }
{ OUTPUT : on le stocke                                                        }
{ REM : pour le moement on utilise une structure 3D spécifique                 }
{ a terme cette structure doit etre intégrée à spectre                         }
{ NB : il faut réféchier au problème du zonage                                 }
procedure ReadIsGISAXSfile(FileName,OutputSpectrum:string);
var
  i,j:integer;
  F: TextFile;
  S: string[255];
  valeurs:valuesVector; { valeurs numériques lues sur la ligne }
  X,Y:integer;
  vind_SAS,vind_IF,vind_SF:integer;
begin
    AssignFile(F, FileName);{ Fichier sélectionné dans la boîte de dialogue }
    Reset(F);
    for i:=1 to 11 do readln(F,s); { on saute les 11 premières lignes }
    { lecture des tailles X,Y }
    readln(F,s);valeurs:=ProcessString(s);
    X:=round(valeurs[9]);Y:=round(valeurs[10]);
    { création des spectres de stockage }
    vind_SAS:=deuxd.addspectre(outputSpectrum+'_SAS',X,Y,1); { signal GISAXS }
    vind_IF:=deuxd.addspectre(outputSpectrum+'_IF',X,Y,1);          { interference function }
    vind_SF:=deuxd.addspectre(outputSpectrum+'_SF',X,Y,1);          { structure factor }
    for i:=1 to 61 do readln(F,s); { on saute les 11 premières lignes }
    for i:=0 to X-1 do
      for j:=0 to Y-1 do
      begin
        Readln(F, S);    { Lecture de la première ligne du fichier }
        valeurs:=ProcessString(s);
{        valeurs[1]:=arcsin(valeurs[1])*180/pi;valeurs[2]:=arcsin(valeurs[2])*180/pi; }
        deuxd.spect[vind_SAS].data[i,j,0].x:=Valeurs[4];deuxd.spect[vind_SAS].data[i,j,0].y:=Valeurs[5];deuxd.spect[vind_SAS].data[i,j,0].lt:=0;
        deuxd.spect[vind_IF].data[i,j,0].x:=Valeurs[4];deuxd.spect[vind_IF].data[i,j,0].y:=Valeurs[5];deuxd.spect[vind_IF].data[i,j,0].lt:=0;
        deuxd.spect[vind_SF].data[i,j,0].x:=Valeurs[4];deuxd.spect[vind_SF].data[i,j,0].y:=Valeurs[5];deuxd.spect[vind_SF].data[i,j,0].lt:=0;
        deuxd.spect[vind_SAS].data[i,j,0].z:=Valeurs[7];
        deuxd.spect[vind_IF].data[i,j,0].z:=Valeurs[8];
        deuxd.spect[vind_SF].data[i,j,0].z:=Valeurs[9];
      end;
    CloseFile(F);
end;

{ lecture de fichiers OVF (produits par OOMMF)                                  }
procedure ReadOVFfile2D(FileName,OutputSpectrum:string);
var i,j:integer;
  F: TextFile;
{  F:file; }
  s,s1,s2:string;
  valeurs:valuesVector; { valeurs numériques lues sur la ligne }
  Xmin,Ymin,Xstep,Ystep:double;
  Xsize,Ysize:integer;
  vind,vindX,vindY,vindZ:integer;
  errorcode:integer;
  x,y:double;
begin
    AssignFile(F, FileName);Reset(F); { Fichier sélectionné dans la boîte de dialogue }
    { lecture des paramètres de description du fichier OVF }
    s:='';readln(f,s);s1:=copy(s,1,11);
    while s1<>'# xstepsize' do begin readln(f,s);s1:=copy(s,1,11); end;
    s1:=copy(s,13,255);Xstep:=StrToFloat(s1)*1e9;
    s:='';readln(f,s);s1:=copy(s,1,11);
    while s1<>'# ystepsize' do begin readln(f,s);s1:=copy(s,1,11); end;
    s1:=copy(s,13,255);Ystep:=StrToFloat(s1)*1e9;
    s:='';readln(f,s);s1:=copy(s,1,8);
    while s1<>'# xnodes' do begin readln(f,s);s1:=copy(s,1,8); end;
    s1:=copy(s,10,255);Xsize:=StrToInt(s1);
    s:='';readln(f,s);s1:=copy(s,1,8);
    while s1<>'# ynodes' do begin readln(f,s);s1:=copy(s,1,8); end;
    s1:=copy(s,10,255);Ysize:=StrToInt(s1);
    s:='';readln(f,s);s1:=copy(s,1,6);
    while s1<>'# xmin' do begin readln(f,s);s1:=copy(s,1,6); end;
    s1:=copy(s,8,255);Xmin:=StrToFloat(s1)*1e9;
    s:='';readln(f,s);s1:=copy(s,1,6);
    while s1<>'# ymax' do begin readln(f,s);s1:=copy(s,1,6); end;
    s1:=copy(s,8,255);Ymin:=StrToFloat(s1)*1e9;
    { création des spectres de stockage }
    vind:=deuxd.addspectre(outputSpectrum+'_M',Xsize,Ysize,1);
    vindX:=deuxd.addspectre(outputSpectrum+'_Mx',Xsize,Ysize,1);
    vindY:=deuxd.addspectre(outputSpectrum+'_My',Xsize,Ysize,1);
    vindZ:=deuxd.addspectre(outputSpectrum+'_Mz',Xsize,Ysize,1);
    s:='';readln(f,s);s1:=copy(s,1,18);
    while s1<>'# Begin: Data Text' do begin readln(f,s);s1:=copy(s,1,18); end;
{    while s1<>'# Begin: Data Binary 4' do begin readln(f,s);s1:=copy(s,1,22); end; }

{    Read(f,Mx);    }
    for j:=0 to Ysize-1 do
     for i:=0 to Xsize-1 do
      begin
      x:=xmin+i*Xstep;y:=ymin+j*Ystep;
      deuxd.spect[vind].data[i,j,0].x:=x;deuxd.spect[vind].data[i,j,0].y:=y;
      deuxd.spect[vindX].data[i,j,0].x:=x;deuxd.spect[vindX].data[i,j,0].y:=y;
      deuxd.spect[vindY].data[i,j,0].x:=x;deuxd.spect[vindY].data[i,j,0].y:=y;
      deuxd.spect[vindZ].data[i,j,0].x:=x;deuxd.spect[vindZ].data[i,j,0].y:=y;
{      Read(f,Mx);Read(f,My);Read(f,Mz);
      deuxd.spect[vindX].data[i,j,0].z:=Mx;
      deuxd.spect[vindY].data[i,j,0].z:=My;
      deuxd.spect[vindZ].data[i,j,0].z:=Mz; }
      Readln(F,S);
      valeurs:=ProcessString(s);
      deuxd.spect[vindX].data[i,j,0].z:=Valeurs[1];
      deuxd.spect[vindY].data[i,j,0].z:=Valeurs[2];
      deuxd.spect[vindZ].data[i,j,0].z:=Valeurs[3];
      deuxd.spect[vind].data[i,j,0].z:=sqrt(sqr(Valeurs[1])+sqr(Valeurs[2])+sqr(Valeurs[3]));
      end;
    CloseFile(F);
end;

{ lecture de fichiers OVF (produits par OOMMF)                                  }
procedure ReadOVFfile3D(FileName,OutputSpectrum:string);
var i,j,k:integer;
  F: TextFile;
{  F:file; }
  s,s1,s2:string;
  valeurs:valuesVector; { valeurs numériques lues sur la ligne }
  Xmin,Ymin,Zmin,Xstep,Ystep,Zstep:double;
  Xsize,Ysize,Zsize:integer;
  vind,vindX,vindY,vindZ:integer;
  errorcode:integer;
  x,y,z:double;
begin
    AssignFile(F, FileName);Reset(F); { Fichier sélectionné dans la boîte de dialogue }
    { lecture des paramètres de description du fichier OVF }
    s:='';readln(f,s);s1:=copy(s,1,7);
    while s1<>'# xbase' do begin readln(f,s);s1:=copy(s,1,7); end;
    s1:=copy(s,9,255);Xmin:=StrToFloat(s1)*1e9;
    s:='';readln(f,s);s1:=copy(s,1,7);
    while s1<>'# ybase' do begin readln(f,s);s1:=copy(s,1,7); end;
    s1:=copy(s,9,255);Ymin:=StrToFloat(s1)*1e9;
    s:='';readln(f,s);s1:=copy(s,1,7);
    while s1<>'# zbase' do begin readln(f,s);s1:=copy(s,1,7); end;
    s1:=copy(s,9,255);Zmin:=StrToFloat(s1)*1e9;
    s:='';readln(f,s);s1:=copy(s,1,11);
    while s1<>'# xstepsize' do begin readln(f,s);s1:=copy(s,1,11); end;
    s1:=copy(s,13,255);Xstep:=StrToFloat(s1)*1e9;
    s:='';readln(f,s);s1:=copy(s,1,11);
    while s1<>'# ystepsize' do begin readln(f,s);s1:=copy(s,1,11); end;
    s1:=copy(s,13,255);Ystep:=StrToFloat(s1)*1e9;
    s:='';readln(f,s);s1:=copy(s,1,11);
    while s1<>'# zstepsize' do begin readln(f,s);s1:=copy(s,1,11); end;
    s1:=copy(s,13,255);Zstep:=StrToFloat(s1)*1e9;
    s:='';readln(f,s);s1:=copy(s,1,8);
    while s1<>'# xnodes' do begin readln(f,s);s1:=copy(s,1,8); end;
    s1:=copy(s,10,255);Xsize:=StrToInt(s1);
    s:='';readln(f,s);s1:=copy(s,1,8);
    while s1<>'# ynodes' do begin readln(f,s);s1:=copy(s,1,8); end;
    s1:=copy(s,10,255);Ysize:=StrToInt(s1);
    s:='';readln(f,s);s1:=copy(s,1,8);
    while s1<>'# znodes' do begin readln(f,s);s1:=copy(s,1,8); end;
    s1:=copy(s,10,255);Zsize:=StrToInt(s1);

    { création des spectres de stockage }
    vind:=troisd.addspectre(outputSpectrum+'_M',Xsize,Ysize,Zsize);
    vindX:=troisd.addspectre(outputSpectrum+'_Mx',Xsize,Ysize,Zsize);
    vindY:=troisd.addspectre(outputSpectrum+'_My',Xsize,Ysize,Zsize);
    vindZ:=troisd.addspectre(outputSpectrum+'_Mz',Xsize,Ysize,Zsize);
    s:='';readln(f,s);s1:=copy(s,1,18);
    while s1<>'# Begin: Data Text' do begin readln(f,s);s1:=copy(s,1,18); end;
{    while s1<>'# Begin: Data Binary 4' do begin readln(f,s);s1:=copy(s,1,22); end; }
{    Read(f,Mx);    }
    for k:=0 to Zsize-1 do
     for j:=0 to Ysize-1 do
      for i:=0 to Xsize-1 do
      begin
      x:=xmin+i*Xstep;y:=ymin+j*Ystep;z:=zmin+k*Zstep;
      troisd.spect[vind].data[i,j,k].x:=x;troisd.spect[vind].data[i,j,k].y:=y;troisd.spect[vind].data[i,j,k].lt:=z;
      troisd.spect[vindX].data[i,j,k].x:=x;troisd.spect[vindX].data[i,j,k].y:=y;troisd.spect[vindX].data[i,j,k].lt:=z;
      troisd.spect[vindY].data[i,j,k].x:=x;troisd.spect[vindY].data[i,j,k].y:=y;troisd.spect[vindY].data[i,j,k].lt:=z;
      troisd.spect[vindZ].data[i,j,k].x:=x;troisd.spect[vindZ].data[i,j,k].y:=y;troisd.spect[vindZ].data[i,j,k].lt:=z; 
{      Read(f,Mx);Read(f,My);Read(f,Mz);
      troisd.spect[vindX].data[i,j,0].z:=Mx;
      troisd.spect[vindY].data[i,j,0].z:=My;
      troisd.spect[vindZ].data[i,j,0].z:=Mz; }
      Readln(F,S);
      valeurs:=ProcessString(s);
      troisd.spect[vindX].data[i,j,k].z:=Valeurs[1];
      troisd.spect[vindY].data[i,j,k].z:=Valeurs[2];
      troisd.spect[vindZ].data[i,j,k].z:=Valeurs[3];
      troisd.spect[vind].data[i,j,k].z:=sqrt(sqr(Valeurs[1])+sqr(Valeurs[2])+sqr(Valeurs[3]));
      end;
    CloseFile(F);
end;

{ lecture des fichiers du reflectomètre Reflex à Dubna                 }
procedure ReadReflexDat(FileName,OutputSpectrum:string);
var i,j:integer;
  F:file of cardinal;
  valeur:cardinal;
  Xsize,Ysize:integer;
  vind:integer;
begin
    AssignFile(F, FileName);Reset(F); { Fichier sélectionné dans la boîte de dialogue }
    Xsize:=800;Ysize:=600;
    { création des spectres de stockage }
    vind:=deuxd.addspectre(outputSpectrum,Xsize,Ysize,1);
    for j:=0 to Ysize-1 do
     for i:=0 to Xsize-1 do
      begin
      deuxd.spect[vind].data[i,j,0].x:=i;deuxd.spect[vind].data[i,j,0].y:=j;
      Read(F,valeur);
      deuxd.spect[vind].data[i,j,0].z:=valeur;
      end;
    CloseFile(F);
end;

end.
