unit WaveFunction;

interface

uses DataReflec;

procedure CalculateWaveFunction1D(s:string;var MyML:TMultiLayer;var MyEP:TExperimentalParameters);
procedure CalculateWaveFunction2D_V10(s:string;var MyML:TMultiLayer;var MyEP:TExperimentalParameters);
procedure CalculateWaveFunction2D(var DataCalc:TDataReflectivity;s:string;var MyML:TMultiLayer;var MyEP:TExperimentalParameters);

implementation

uses forms,constants,math387,MtxVec,SimulReflecForm,Editdata,CalculReflec;

{ calcul de la fonction d'onde a une dimension                                  }
{ en fonction de la profondeur                                                  }
{ INPUT : s une chaine donnant l'extension des spectres 1D : NP ou UP ou DO     }
procedure CalculateWaveFunction1D(s:string;var MyML:TMultiLayer;var MyEP:TExperimentalParameters);
var indM,indP,indMR,indMT:integer; { indices des spectres pour le module et la phase et les modules de R et T }
    i,j,nbrLayers,zint,z1int,nbPts,Zidx:integer;
    kz,AR,AT:Tvec;
    Qz,z,zCrt,zAbsolute:double;
    zz0,auxT,auxR,aux:Tcplx;
    depthStep:double;
begin
   depthStep:=SimulReflecWindow.depthStep.Value;
{   indM:=-1;indP:=-1; }
   nbrLayers:=MyML.nbrLayers;
   createIt(kz,AR,AT);
   kz.Size(nbrLayers,true);AR.Size(nbrLayers,true);AT.Size(nbrLayers,true);
   z:=0;
   for i:=0 to nbrLayers-1 do z:=z+MyML.z[i]*1e9;
   { pour le substrat et le milieu d'incidence on prend le quart de l'épaisseur totale }
   { on passe en angtroms }
   zint:=round(z/depthStep);
   if zint<>0 then z1int:=zint div 2 else z1int:=round(400*depthStep); { cas ou il n'y a qu'un dioptre }
   nbPts:=zint+2*z1int;
{ demande d'un tracé à une dimension seulement }
{ pour la profondeur on fait des steps de 0.1nm; c'est modulable en fonction des besoins }
{ on fixe le zero des "z" a la surface de la multicouche        }
      Qz:=4*Pi/MyEP.lambda*sin(SimulReflecWindow.WFThetaMin.value*Deg);
      indM:=und.addspectre('WFmodule'+s,nbPts,1,1);
      indMT:=und.addspectre('WFmoduleT_'+s,nbPts,1,1);
      indMR:=und.addspectre('WFmoduleR_'+s,nbPts,1,1);
      indP:=und.addspectre('WFphase'+s,nbPts,1,1);
      if s='NP' then CalculReflecNPamplitudes(-Qz,MyML.z,MyML.V,MyML.Vi,MyML.sigma,kz,AR,AT);
      if s='UP' then CalculReflecNPamplitudes(-Qz,MyML.z,MyML.Vup,MyML.Vi,MyML.sigma,kz,AR,AT);
      if s='DO' then CalculReflecNPamplitudes(-Qz,MyML.z,MyML.Vdo,MyML.Vi,MyML.sigma,kz,AR,AT);
      Zidx:=-1;
      for i:=0 to z1int-1 do { substrat; cas particulier, l'interface "virtuelle" 0 est "collée à l'interface 0}
                             { il faut partir avec des z négatifs                                              }
      begin
        inc(Zidx);zcrt:=depthStep*(i-z1int)*1e-9;
        zAbsolute:=depthStep*(Zidx-z1int-zint);
        und.spect[indM].data[zidx,0,0].x:=zAbsolute;
        und.spect[indMT].data[zidx,0,0].x:=zAbsolute;
        und.spect[indMR].data[zidx,0,0].x:=zAbsolute;
        und.spect[indP].data[zidx,0,0].x:=zAbsolute;
        zz0:=Cplx(zcrt,0);      { passage en complexe pour faire les multiplications }
        auxT:=Cmul(AT.Cvalues[0],exp(Cmul(C_I,Cmul(kz.Cvalues[0],zz0))));
        auxR:=Cmul(AR.Cvalues[0],exp(Cmul(C_I,Cmul(Neg(kz.Cvalues[0]),zz0))));
        aux:=Cadd(auxT,auxR);
        und.spect[indM].data[zidx,0,0].z:=sqr(Cabs(aux));
        und.spect[indMT].data[zidx,0,0].z:=sqr(Cabs(auxT));
        und.spect[indMR].data[zidx,0,0].z:=sqr(Cabs(auxR));
        und.spect[indP].data[zidx,0,0].z:=Arg(aux)
      end;
      und.spect[indM].data[zidx,0,0].z:=0;und.spect[indMT].data[zidx,0,0].z:=0;
      und.spect[indMR].data[zidx,0,0].z:=0;und.spect[indP].data[zidx,0,0].z:=0;
      for j:=1 to nbrLayers-2 do
      begin
        for i:=0 to round(MyML.z[j]*1e9/depthStep)-1 do
        begin
          inc(Zidx);zcrt:=depthStep*i*1e-9; {zcrt:=(Zidx-z1int-zint)/10*1e-9; }
          zAbsolute:=depthStep*(Zidx-z1int-zint);
                und.spect[indM].data[zidx,0,0].x:=zAbsolute;
                und.spect[indMT].data[zidx,0,0].x:=zAbsolute;
                und.spect[indMR].data[zidx,0,0].x:=zAbsolute;
                und.spect[indP].data[zidx,0,0].x:=zAbsolute;
                zz0:=Cplx(zcrt,0);      { passage en complexe pour faire les multiplications }
                auxT:=Cmul(AT.Cvalues[j],exp(Cmul(C_I,Cmul(kz.Cvalues[j],zz0))));
                auxR:=Cmul(AR.Cvalues[j],exp(Cmul(C_I,Cmul(Neg(kz.Cvalues[j]),zz0))));
                aux:=Cadd(auxT,auxR);
                und.spect[indM].data[zidx,0,0].z:=sqr(Cabs(aux));
                und.spect[indMT].data[zidx,0,0].z:=sqr(Cabs(auxT));
                und.spect[indMR].data[zidx,0,0].z:=sqr(Cabs(auxR));
                und.spect[indP].data[zidx,0,0].z:=Arg(aux)
        end;
      und.spect[indM].data[zidx,0,0].z:=0;und.spect[indMT].data[zidx,0,0].z:=0;
      und.spect[indMR].data[zidx,0,0].z:=0;und.spect[indP].data[zidx,0,0].z:=0;
      end;
      for i:=0 to z1int-1 do { milieu d'incidence }
      begin
        inc(Zidx);{ zcrt:=depthStep*i*1e-9;{zcrt:=(Zidx-z1int-zint)/10*1e-9; }
        zAbsolute:=depthStep*(Zidx-z1int-zint);
                und.spect[indM].data[zidx,0,0].x:=zAbsolute;
                und.spect[indMT].data[zidx,0,0].x:=zAbsolute;
                und.spect[indMR].data[zidx,0,0].x:=zAbsolute;
                und.spect[indP].data[zidx,0,0].x:=zAbsolute;
                zz0:=Cplx(zcrt,0);      { passage en complexe pour faire les multiplications }
                auxT:=Cmul(AT.Cvalues[nbrLayers-1],exp(Cmul(C_I,Cmul(kz.Cvalues[nbrLayers-1],zz0))));
                auxR:=Cmul(AR.Cvalues[nbrLayers-1],exp(Cmul(C_I,Cmul(Neg(kz.Cvalues[nbrLayers-1]),zz0))));
                aux:=Cadd(auxT,auxR);
                und.spect[indM].data[zidx,0,0].z:=sqr(Cabs(aux));
                und.spect[indMT].data[zidx,0,0].z:=sqr(Cabs(auxT));
                und.spect[indMR].data[zidx,0,0].z:=sqr(Cabs(auxR));
                und.spect[indP].data[zidx,0,0].z:=Arg(aux);
      end;
   freeIt(kz,AR,AT);
end;

{ calcul de la foncion d'onde a une dimentsion                                  }
{ INPUT : s une chaine donnant l'expension des spectres 1D : NP ou UP ou DO     }
procedure CalculateWaveFunction2D_V10(s:string;var MyML:TMultiLayer;var MyEP:TExperimentalParameters);
var indM,indMR,indMT,indP:integer; { indices des spectres pour le module et la phase et les modules de R et T }
    i,j,k,nbrLayers,zint,z1int,nbPts,Zidx,nbYpts:integer;
    kz,AR,AT:Tvec;
    Qz,z,zCrt,zAbsolute,YWF:double;
    zz0,auxT,auxR,aux:Tcplx;
    depthStep:double;
begin
   depthStep:=SimulReflecWindow.DepthStep.value;
{   indM:=-1;indP:=-1; }
   nbrLayers:=MyML.nbrLayers;
   createIt(kz,AR,AT);
   kz.Size(nbrLayers,true);AR.Size(nbrLayers,true);AT.Size(nbrLayers,true);
   z:=0;
   for i:=0 to nbrLayers-1 do z:=z+MyML.z[i]*1e9;
   { pour le substrat et le milieu d'incidence on prend le quart de l'épaisseur totale }
   { on passe en angtroms }
   zint:=round(z/depthStep);
   if zint<>0 then z1int:=zint div 2 else z1int:=round(400*depthStep); { cas ou il n'y a qu'un dioptre }
   nbPts:=zint+2*z1int;
   if SimulReflecWindow.TofCheckBox.Checked=false
   then nbYpts:=round((SimulReflecWindow.WFthetaMax.value-SimulReflecWindow.WFthetaMin.value)/SimulReflecWindow.WFthetaStep.value+1)
   else nbYpts:=round((SimulReflecWindow.WFlambdaMax.value-SimulReflecWindow.WFlambdaMin.value)/SimulReflecWindow.WFlambdaStep.value+1);
   indM:=deuxd.addspectre('WFmodule'+s,nbPts,nbYPts,1);
   indMT:=deuxd.addspectre('WFmoduleT_'+s,nbPts,nbYPts,1);
   indMR:=deuxd.addspectre('WFmoduleR_'+s,nbPts,nbYPts,1);
   indP:=deuxd.addspectre('WFphase'+s,nbPts,nbYPts,1);

   StopFittingFlag:=false;

   for k:=0 to nbYpts-1 do
      begin
      if SimulReflecWindow.TofCheckBox.Checked=false then
        begin
        YWF:=SimulReflecWindow.WFthetaMin.value+k*SimulReflecWindow.WFthetaStep.value;
        Qz:=4*Pi/MyEP.lambda*sin(YWF*Deg);
        end
        else
        begin
        YWF:=SimulReflecWindow.WFlambdaMin.value+k*SimulReflecWindow.WFlambdaStep.value;
        Qz:=4*Pi/(YWF*1e-9)*sin(SimulReflecWindow.ThetaBox.value*Deg);
        end;

      if s='NP' then CalculReflecNPamplitudes(-Qz,MyML.z,MyML.V,MyML.Vi,MyML.sigma,kz,AR,AT);
      if s='UP' then CalculReflecNPamplitudes(-Qz,MyML.z,MyML.Vup,MyML.Vi,MyML.sigma,kz,AR,AT);
      if s='DO' then CalculReflecNPamplitudes(-Qz,MyML.z,MyML.Vdo,MyML.Vi,MyML.sigma,kz,AR,AT);

      Zidx:=-1;{ Zcrt:=-1; }
      for i:=0 to z1int-1 do { substrat; cas particilier, l'interface "virtuelle" 0 est "collée à l'interface 0}
                             { il faut partir avec des z négatifs                                              }
      begin
        inc(Zidx);zcrt:=depthStep*(i-z1int)*1e-9;
        zAbsolute:=depthStep*(Zidx-z1int-zint);
        deuxd.spect[indM].data[zidx,k,0].x:=zAbsolute;deuxd.spect[indP].data[zidx,k,0].x:=zAbsolute;
        deuxd.spect[indMT].data[zidx,k,0].x:=zAbsolute;deuxd.spect[indMR].data[zidx,k,0].x:=zAbsolute;
        deuxd.spect[indM].data[zidx,k,0].y:=YWF;deuxd.spect[indP].data[zidx,k,0].y:=YWF;
        deuxd.spect[indMT].data[zidx,k,0].y:=YWF;deuxd.spect[indMR].data[zidx,k,0].y:=YWF;
        zz0:=Cplx(zcrt,0);      { passage en complexe pour faire les multiplications }
        auxT:=Cmul(AT.Cvalues[0],exp(Cmul(C_I,Cmul(kz.Cvalues[0],zz0))));
        auxR:=Cmul(AR.Cvalues[0],exp(Cmul(C_I,Cmul(Neg(kz.Cvalues[0]),zz0))));
        aux:=Cadd(auxT,auxR);
        deuxd.spect[indM].data[zidx,k,0].z:=Sqr(Cabs(aux));deuxd.spect[indP].data[zidx,k,0].z:=Arg(aux);
        deuxd.spect[indMT].data[zidx,k,0].z:=Sqr(Cabs(auxT));deuxd.spect[indMR].data[zidx,k,0].z:=Sqr(Cabs(auxR));
        Application.processMessages; { l'utilisateur a-t-il appuyé sur le boutton ? }
        if StopFittingFlag=true then exit; { on sort du calcul }
      end;
      { separation entre substrat et couches }
      deuxd.spect[indM].data[zidx,k,0].z:=0;deuxd.spect[indMT].data[zidx,k,0].z:=0;
      deuxd.spect[indMR].data[zidx,k,0].z:=0;deuxd.spect[indP].data[zidx,k,0].z:=0;
      for j:=1 to nbrLayers-2 do
      begin
        for i:=0 to round(MyML.z[j]*1e9/depthStep)-1 do
        begin
          inc(Zidx);zcrt:=depthStep*i*1e-9; {zcrt:=(Zidx-z1int-zint)/10*1e-9; }
          zAbsolute:=depthStep*(Zidx-z1int-zint);
          deuxd.spect[indM].data[zidx,k,0].x:=zAbsolute;deuxd.spect[indP].data[zidx,k,0].x:=zAbsolute;
          deuxd.spect[indMT].data[zidx,k,0].x:=zAbsolute;deuxd.spect[indMR].data[zidx,k,0].x:=zAbsolute;
          deuxd.spect[indM].data[zidx,k,0].y:=YWF;deuxd.spect[indP].data[zidx,k,0].y:=YWF;
          deuxd.spect[indMT].data[zidx,k,0].y:=YWF;deuxd.spect[indMR].data[zidx,k,0].y:=YWF;
          zz0:=Cplx(zcrt,0);      { passage en complexe pour faire les multiplications }
          auxT:=Cmul(AT.Cvalues[j],exp(Cmul(C_I,Cmul(kz.Cvalues[j],zz0))));
          auxR:=Cmul(AR.Cvalues[j],exp(Cmul(C_I,Cmul(Neg(kz.Cvalues[j]),zz0))));
          aux:=Cadd(auxT,auxR);
          deuxd.spect[indM].data[zidx,k,0].z:=Sqr(Cabs(aux));deuxd.spect[indP].data[zidx,k,0].z:=Arg(aux);
          deuxd.spect[indMT].data[zidx,k,0].z:=Sqr(Cabs(auxT));deuxd.spect[indMR].data[zidx,k,0].z:=Sqr(Cabs(auxR));
          Application.processMessages; { l'utilisateur a-t-il appuyé sur le boutton ? }
          if StopFittingFlag=true then exit; { on sort du calcul }
        end;
      deuxd.spect[indM].data[zidx,k,0].z:=0;deuxd.spect[indMT].data[zidx,k,0].z:=0;
      deuxd.spect[indMR].data[zidx,k,0].z:=0;deuxd.spect[indP].data[zidx,k,0].z:=0;
      end;
      for i:=0 to z1int-1 do { milieu d'incidence }
      begin
        inc(Zidx);zcrt:=depthStep*i*1e-9;{zcrt:=(Zidx-z1int-zint)/10*1e-9; }
        zAbsolute:=depthStep*(Zidx-z1int-zint);
        deuxd.spect[indM].data[zidx,k,0].x:=zAbsolute;deuxd.spect[indP].data[zidx,k,0].x:=zAbsolute;
        deuxd.spect[indMT].data[zidx,k,0].x:=zAbsolute;deuxd.spect[indMR].data[zidx,k,0].x:=zAbsolute;
        deuxd.spect[indM].data[zidx,k,0].y:=YWF;deuxd.spect[indP].data[zidx,k,0].y:=YWF;
        deuxd.spect[indMT].data[zidx,k,0].y:=YWF;deuxd.spect[indMR].data[zidx,k,0].y:=YWF;
        zz0:=Cplx(zcrt,0);      { passage en complexe pour faire les multiplications }
        auxT:=Cmul(AT.Cvalues[nbrLayers-1],exp(Cmul(C_I,Cmul(kz.Cvalues[nbrLayers-1],zz0))));
        auxR:=Cmul(AR.Cvalues[nbrLayers-1],exp(Cmul(C_I,Cmul(Neg(kz.Cvalues[nbrLayers-1]),zz0))));
        aux:=Cadd(auxT,auxR);
        deuxd.spect[indM].data[zidx,k,0].z:=sqr(Cabs(aux));deuxd.spect[indP].data[zidx,k,0].z:=Arg(aux);
        deuxd.spect[indMT].data[zidx,k,0].z:=sqr(Cabs(auxT));deuxd.spect[indMR].data[zidx,k,0].z:=sqr(Cabs(auxR));
        Application.processMessages; { l'utilisateur a-t-il appuyé sur le boutton ? }
        if StopFittingFlag=true then exit; { on sort du calcul }
      end;
   end;
   freeIt(kz,AR,AT);
end;

{ calcul de la foncion d'onde a une dimentsion                                  }
{ on rajoute la convolution par la résolution expérimentale                     }
{ on supprime la possibilité d'utiliser l'option temps de vol                   }
{ INPUT : s une chaine donnant l'expension des spectres 1D : NP ou UP ou DO     }
procedure CalculateWaveFunction2D(var DataCalc:TDataReflectivity;s:string;var MyML:TMultiLayer;var MyEP:TExperimentalParameters);
var indM,indMR,indMT,indP:integer; { indices des spectres pour le module et la phase et les modules de R et T }
    i,j,iT,jL,k,nbrLayers,zint,z1int,nbPts,Zidx,nbYpts:integer;
    kz,AR,AT,Raux,Taux:Tvec;
    Qz,z,zCrt,zAbsolute,YWF:double;
    zz0,auxT,auxR,aux:Tcplx;
    depthStep,dtheta,l:double;
begin
   depthStep:=SimulReflecWindow.DepthStep.value;
{   indM:=-1;indP:=-1; }
   nbrLayers:=MyML.nbrLayers;
   CreateIt(Raux,Taux);
   createIt(kz,AR,AT);
   Raux.size(nbrLayers,true);Taux.size(nbrLayers,true);
   kz.Size(nbrLayers,true);AR.Size(nbrLayers,true);AT.Size(nbrLayers,true);
   z:=0;
   for i:=0 to nbrLayers-1 do z:=z+MyML.z[i]*1e9;
   { pour le substrat et le milieu d'incidence on prend le quart de l'épaisseur totale }
   { on passe en angtroms }
   zint:=round(z/depthStep);
   if zint<>0 then z1int:=zint div 2 else z1int:=round(400*depthStep); { cas ou il n'y a qu'un dioptre }
   nbPts:=zint+2*z1int;
   if SimulReflecWindow.TofCheckBox.Checked=false
   then nbYpts:=round((SimulReflecWindow.WFthetaMax.value-SimulReflecWindow.WFthetaMin.value)/SimulReflecWindow.WFthetaStep.value+1)
   else nbYpts:=round((SimulReflecWindow.WFlambdaMax.value-SimulReflecWindow.WFlambdaMin.value)/SimulReflecWindow.WFlambdaStep.value+1);
   indM:=deuxd.addspectre('WFmodule'+s,nbPts,nbYPts,1);
   indMT:=deuxd.addspectre('WFmoduleT_'+s,nbPts,nbYPts,1);
   indMR:=deuxd.addspectre('WFmoduleR_'+s,nbPts,nbYPts,1);
   indP:=deuxd.addspectre('WFphase'+s,nbPts,nbYPts,1);
  { reset des data }
  for i:=0 to nbPts-1 do
    for j:=0 to nbYPts-1 do
      begin
        deuxd.spect[indM].data[i,j,0].z:=0;
        deuxd.spect[indP].data[i,j,0].z:=0;
        deuxd.spect[indMT].data[i,j,0].z:=0;
        deuxd.spect[indMR].data[i,j,0].z:=0;
      end;

   StopFittingFlag:=false;

if SimulReflecWindow.TofCheckBox.Checked=false
then for k:=0 to nbYpts-1 do
  begin
    for iT:=0 to DataCalc.thetaSpectrum.length-1 do
    begin
      dTheta:=dataCalc.thetaSpectrum.values[iT]*180/pi;
      YWF:=SimulReflecWindow.WFthetaMin.value+k*SimulReflecWindow.WFthetaStep.value;
      for jL:=0 to DataCalc.lambdaSpectrum.length-1 do
      begin
        l:=DataCalc.lambdaSpectrum.values[jL];
        Qz:=4*Pi/l*sin((YWF+dTheta)*Deg);
        if s='NP' then CalculReflecNPamplitudes(-Qz,MyML.z,MyML.V,MyML.Vi,MyML.sigma,kz,AR,AT);
        if s='UP' then CalculReflecNPamplitudes(-Qz,MyML.z,MyML.Vup,MyML.Vi,MyML.sigma,kz,AR,AT);
        if s='DO' then CalculReflecNPamplitudes(-Qz,MyML.z,MyML.Vdo,MyML.Vi,MyML.sigma,kz,AR,AT);
        AR.scale(sqrt(DataCalc.lambdaIntensity.values[jL]));
        AT.scale(sqrt(DataCalc.lambdaIntensity.values[jL]));
        AR.scale(sqrt(DataCalc.thetaIntensity.values[iT]));
        AT.scale(sqrt(DataCalc.thetaIntensity.values[iT]));

      Zidx:=-1;{ Zcrt:=-1; }
      for i:=0 to z1int-1 do { substrat; cas particilier, l'interface "virtuelle" 0 est "collée à l'interface 0}
                             { il faut partir avec des z négatifs                                              }
      begin
        inc(Zidx);zcrt:=depthStep*(i-z1int)*1e-9;
        zAbsolute:=depthStep*(Zidx-z1int-zint);
        deuxd.spect[indM].data[zidx,k,0].x:=zAbsolute;deuxd.spect[indP].data[zidx,k,0].x:=zAbsolute;
        deuxd.spect[indMT].data[zidx,k,0].x:=zAbsolute;deuxd.spect[indMR].data[zidx,k,0].x:=zAbsolute;
        deuxd.spect[indM].data[zidx,k,0].y:=YWF;deuxd.spect[indP].data[zidx,k,0].y:=YWF;
        deuxd.spect[indMT].data[zidx,k,0].y:=YWF;deuxd.spect[indMR].data[zidx,k,0].y:=YWF;
        zz0:=Cplx(zcrt,0);      { passage en complexe pour faire les multiplications }
        auxT:=Cmul(AT.Cvalues[0],exp(Cmul(C_I,Cmul(kz.Cvalues[0],zz0))));
        auxR:=Cmul(AR.Cvalues[0],exp(Cmul(C_I,Cmul(Neg(kz.Cvalues[0]),zz0))));
        aux:=Cadd(auxT,auxR);
        deuxd.spect[indM].data[zidx,k,0].z:=deuxd.spect[indM].data[zidx,k,0].z+Sqr(Cabs(aux));
        deuxd.spect[indP].data[zidx,k,0].z:=deuxd.spect[indP].data[zidx,k,0].z+Arg(aux);
        deuxd.spect[indMT].data[zidx,k,0].z:=deuxd.spect[indMT].data[zidx,k,0].z+Sqr(Cabs(auxT));
        deuxd.spect[indMR].data[zidx,k,0].z:=deuxd.spect[indMR].data[zidx,k,0].z+Sqr(Cabs(auxR));
        Application.processMessages; { l'utilisateur a-t-il appuyé sur le boutton ? }
        if StopFittingFlag=true then break; { on sort du calcul }
      end;
      { separation entre substrat et couches }
      deuxd.spect[indM].data[zidx,k,0].z:=0;deuxd.spect[indMT].data[zidx,k,0].z:=0;
      deuxd.spect[indMR].data[zidx,k,0].z:=0;deuxd.spect[indP].data[zidx,k,0].z:=0;
      for j:=1 to nbrLayers-2 do
      begin
        for i:=0 to round(MyML.z[j]*1e9/depthStep)-1 do
        begin
          inc(Zidx);zcrt:=depthStep*i*1e-9; {zcrt:=(Zidx-z1int-zint)/10*1e-9; }
          zAbsolute:=depthStep*(Zidx-z1int-zint);
          deuxd.spect[indM].data[zidx,k,0].x:=zAbsolute;deuxd.spect[indP].data[zidx,k,0].x:=zAbsolute;
          deuxd.spect[indMT].data[zidx,k,0].x:=zAbsolute;deuxd.spect[indMR].data[zidx,k,0].x:=zAbsolute;
          deuxd.spect[indM].data[zidx,k,0].y:=YWF;deuxd.spect[indP].data[zidx,k,0].y:=YWF;
          deuxd.spect[indMT].data[zidx,k,0].y:=YWF;deuxd.spect[indMR].data[zidx,k,0].y:=YWF;
          zz0:=Cplx(zcrt,0);      { passage en complexe pour faire les multiplications }
          auxT:=Cmul(AT.Cvalues[j],exp(Cmul(C_I,Cmul(kz.Cvalues[j],zz0))));
          auxR:=Cmul(AR.Cvalues[j],exp(Cmul(C_I,Cmul(Neg(kz.Cvalues[j]),zz0))));
          aux:=Cadd(auxT,auxR);
          deuxd.spect[indM].data[zidx,k,0].z:=deuxd.spect[indM].data[zidx,k,0].z+Sqr(Cabs(aux));
          deuxd.spect[indP].data[zidx,k,0].z:=deuxd.spect[indP].data[zidx,k,0].z+Arg(aux);
          deuxd.spect[indMT].data[zidx,k,0].z:=deuxd.spect[indMT].data[zidx,k,0].z+Sqr(Cabs(auxT));
          deuxd.spect[indMR].data[zidx,k,0].z:=deuxd.spect[indMR].data[zidx,k,0].z+Sqr(Cabs(auxR));
          Application.processMessages; { l'utilisateur a-t-il appuyé sur le boutton ? }
          if StopFittingFlag=true then break; { on sort du calcul }
        end;
      deuxd.spect[indM].data[zidx,k,0].z:=0;deuxd.spect[indMT].data[zidx,k,0].z:=0;
      deuxd.spect[indMR].data[zidx,k,0].z:=0;deuxd.spect[indP].data[zidx,k,0].z:=0;
      end;
      for i:=0 to z1int-1 do { milieu d'incidence }
      begin
        inc(Zidx);zcrt:=depthStep*i*1e-9;{zcrt:=(Zidx-z1int-zint)/10*1e-9; }
        zAbsolute:=depthStep*(Zidx-z1int-zint);
        deuxd.spect[indM].data[zidx,k,0].x:=zAbsolute;deuxd.spect[indP].data[zidx,k,0].x:=zAbsolute;
        deuxd.spect[indMT].data[zidx,k,0].x:=zAbsolute;deuxd.spect[indMR].data[zidx,k,0].x:=zAbsolute;
        deuxd.spect[indM].data[zidx,k,0].y:=YWF;deuxd.spect[indP].data[zidx,k,0].y:=YWF;
        deuxd.spect[indMT].data[zidx,k,0].y:=YWF;deuxd.spect[indMR].data[zidx,k,0].y:=YWF;
        zz0:=Cplx(zcrt,0);      { passage en complexe pour faire les multiplications }
        auxT:=Cmul(AT.Cvalues[nbrLayers-1],exp(Cmul(C_I,Cmul(kz.Cvalues[nbrLayers-1],zz0))));
        auxR:=Cmul(AR.Cvalues[nbrLayers-1],exp(Cmul(C_I,Cmul(Neg(kz.Cvalues[nbrLayers-1]),zz0))));
        aux:=Cadd(auxT,auxR);
        deuxd.spect[indM].data[zidx,k,0].z:=deuxd.spect[indM].data[zidx,k,0].z+sqr(Cabs(aux));
        deuxd.spect[indP].data[zidx,k,0].z:=deuxd.spect[indP].data[zidx,k,0].z+Arg(aux);
        deuxd.spect[indMT].data[zidx,k,0].z:=deuxd.spect[indMT].data[zidx,k,0].z+sqr(Cabs(auxT));
        deuxd.spect[indMR].data[zidx,k,0].z:=deuxd.spect[indMR].data[zidx,k,0].z+sqr(Cabs(auxR));
        Application.processMessages; { l'utilisateur a-t-il appuyé sur le boutton ? }
        if StopFittingFlag=true then break; { on sort du calcul }
      end;
      end; { fin boucle jL }
      end; { fin boucle iT }
   end { fin boucle k }
else begin { cas du temps de vol } { il n'y a pas la convolution avec la résolution }
   for k:=0 to nbYpts-1 do
   begin
     YWF:=SimulReflecWindow.WFlambdaMin.value+k*SimulReflecWindow.WFlambdaStep.value;
     Qz:=4*Pi/(YWF*1e-9)*sin(SimulReflecWindow.ThetaBox.value*Deg);
     if s='NP' then CalculReflecNPamplitudes(-Qz,MyML.z,MyML.V,MyML.Vi,MyML.sigma,kz,AR,AT);
     if s='UP' then CalculReflecNPamplitudes(-Qz,MyML.z,MyML.Vup,MyML.Vi,MyML.sigma,kz,AR,AT);
     if s='DO' then CalculReflecNPamplitudes(-Qz,MyML.z,MyML.Vdo,MyML.Vi,MyML.sigma,kz,AR,AT);

      Zidx:=-1;{ Zcrt:=-1; }
      for i:=0 to z1int-1 do { substrat; cas particilier, l'interface "virtuelle" 0 est "collée à l'interface 0}
                             { il faut partir avec des z négatifs                                              }
      begin
        inc(Zidx);zcrt:=depthStep*(i-z1int)*1e-9;
        zAbsolute:=depthStep*(Zidx-z1int-zint);
        deuxd.spect[indM].data[zidx,k,0].x:=zAbsolute;deuxd.spect[indP].data[zidx,k,0].x:=zAbsolute;
        deuxd.spect[indMT].data[zidx,k,0].x:=zAbsolute;deuxd.spect[indMR].data[zidx,k,0].x:=zAbsolute;
        deuxd.spect[indM].data[zidx,k,0].y:=YWF;deuxd.spect[indP].data[zidx,k,0].y:=YWF;
        deuxd.spect[indMT].data[zidx,k,0].y:=YWF;deuxd.spect[indMR].data[zidx,k,0].y:=YWF;
        zz0:=Cplx(zcrt,0);      { passage en complexe pour faire les multiplications }
        auxT:=Cmul(AT.Cvalues[0],exp(Cmul(C_I,Cmul(kz.Cvalues[0],zz0))));
        auxR:=Cmul(AR.Cvalues[0],exp(Cmul(C_I,Cmul(Neg(kz.Cvalues[0]),zz0))));
        aux:=Cadd(auxT,auxR);
        deuxd.spect[indM].data[zidx,k,0].z:=Sqr(Cabs(aux));deuxd.spect[indP].data[zidx,k,0].z:=Arg(aux);
        deuxd.spect[indMT].data[zidx,k,0].z:=Sqr(Cabs(auxT));deuxd.spect[indMR].data[zidx,k,0].z:=Sqr(Cabs(auxR));
        Application.processMessages; { l'utilisateur a-t-il appuyé sur le boutton ? }
        if StopFittingFlag=true then exit; { on sort du calcul }
      end;
      { separation entre substrat et couches }
      deuxd.spect[indM].data[zidx,k,0].z:=0;deuxd.spect[indMT].data[zidx,k,0].z:=0;
      deuxd.spect[indMR].data[zidx,k,0].z:=0;deuxd.spect[indP].data[zidx,k,0].z:=0;
      for j:=1 to nbrLayers-2 do
      begin
        for i:=0 to round(MyML.z[j]*1e9/depthStep)-1 do
        begin
          inc(Zidx);zcrt:=depthStep*i*1e-9; {zcrt:=(Zidx-z1int-zint)/10*1e-9; }
          zAbsolute:=depthStep*(Zidx-z1int-zint);
          deuxd.spect[indM].data[zidx,k,0].x:=zAbsolute;deuxd.spect[indP].data[zidx,k,0].x:=zAbsolute;
          deuxd.spect[indMT].data[zidx,k,0].x:=zAbsolute;deuxd.spect[indMR].data[zidx,k,0].x:=zAbsolute;
          deuxd.spect[indM].data[zidx,k,0].y:=YWF;deuxd.spect[indP].data[zidx,k,0].y:=YWF;
          deuxd.spect[indMT].data[zidx,k,0].y:=YWF;deuxd.spect[indMR].data[zidx,k,0].y:=YWF;
          zz0:=Cplx(zcrt,0);      { passage en complexe pour faire les multiplications }
          auxT:=Cmul(AT.Cvalues[j],exp(Cmul(C_I,Cmul(kz.Cvalues[j],zz0))));
          auxR:=Cmul(AR.Cvalues[j],exp(Cmul(C_I,Cmul(Neg(kz.Cvalues[j]),zz0))));
          aux:=Cadd(auxT,auxR);
          deuxd.spect[indM].data[zidx,k,0].z:=Sqr(Cabs(aux));deuxd.spect[indP].data[zidx,k,0].z:=Arg(aux);
          deuxd.spect[indMT].data[zidx,k,0].z:=Sqr(Cabs(auxT));deuxd.spect[indMR].data[zidx,k,0].z:=Sqr(Cabs(auxR));
          Application.processMessages; { l'utilisateur a-t-il appuyé sur le boutton ? }
          if StopFittingFlag=true then exit; { on sort du calcul }
        end;
      deuxd.spect[indM].data[zidx,k,0].z:=0;deuxd.spect[indMT].data[zidx,k,0].z:=0;
      deuxd.spect[indMR].data[zidx,k,0].z:=0;deuxd.spect[indP].data[zidx,k,0].z:=0;
      end;
      for i:=0 to z1int-1 do { milieu d'incidence }
      begin
        inc(Zidx);zcrt:=depthStep*i*1e-9;{zcrt:=(Zidx-z1int-zint)/10*1e-9; }
        zAbsolute:=depthStep*(Zidx-z1int-zint);
        deuxd.spect[indM].data[zidx,k,0].x:=zAbsolute;deuxd.spect[indP].data[zidx,k,0].x:=zAbsolute;
        deuxd.spect[indMT].data[zidx,k,0].x:=zAbsolute;deuxd.spect[indMR].data[zidx,k,0].x:=zAbsolute;
        deuxd.spect[indM].data[zidx,k,0].y:=YWF;deuxd.spect[indP].data[zidx,k,0].y:=YWF;
        deuxd.spect[indMT].data[zidx,k,0].y:=YWF;deuxd.spect[indMR].data[zidx,k,0].y:=YWF;
        zz0:=Cplx(zcrt,0);      { passage en complexe pour faire les multiplications }
        auxT:=Cmul(AT.Cvalues[nbrLayers-1],exp(Cmul(C_I,Cmul(kz.Cvalues[nbrLayers-1],zz0))));
        auxR:=Cmul(AR.Cvalues[nbrLayers-1],exp(Cmul(C_I,Cmul(Neg(kz.Cvalues[nbrLayers-1]),zz0))));
        aux:=Cadd(auxT,auxR);
        deuxd.spect[indM].data[zidx,k,0].z:=sqr(Cabs(aux));deuxd.spect[indP].data[zidx,k,0].z:=Arg(aux);
        deuxd.spect[indMT].data[zidx,k,0].z:=sqr(Cabs(auxT));deuxd.spect[indMR].data[zidx,k,0].z:=sqr(Cabs(auxR));
        Application.processMessages; { l'utilisateur a-t-il appuyé sur le boutton ? }
        if StopFittingFlag=true then exit; { on sort du calcul }
      end;
   end;
   end;

   freeIt(Raux,Taux);
   freeIt(kz,AR,AT);
end;

end.


