unit MainForm;
{ =========== preparation de la release 1.4 ============                        }
{ 23.07.02:FO: c'est le main form qui crée les différentes varfiables           }
{              c'est aussi le MainForm qui définit VecCacheSize                 }
{              * possiblité de plotter le profil de densite (en NP pour le moment) }
{              * utilisation JvFormPlace pour retenir la place des fenetres     }
{ 24.07.02:FO: * tracé des profils de SLD (nouveau menu "PLOT")                 }
{              * plot des distributions lambda et theta                         }
{                MAIS ne marche qu'avec les distributions "réelles"             }
{                pas avec les distributions calculées                           }
{              * reimplémentation des stability plots avec graph1D et graph2D   }
{ 27.07.02:FO: * tracé de la fonction d'onde dans la couche (1D et 2D)          }
{                module au carré et phase                                       }
{ 28.07.02:FO: * formulaire de conversion pour les neutrons                     }
{ 30.07.02:FO: * deux nouveaux bouttons SaveCurrentML et ReloadSavedML          }
{              * affichage de la différence avec et sans profiling smooth       }
{                dans le panneau fitting                                        }
{ 31.07.02:FO:* implémentation des profiles                                     }
{             * tracé des courbes de réflectivité et de transmission ds Graph1D }
{             * tracé des amplitudes R et T dans cahque couche (onglet diffuse) }
{ 06.07.02:FO:* nouvelles possibilités de convolution                           }
{               ConvolutionCalculation:='full';'QzGaussian';'QzFast';           }
{               Les gains en vitesse sont considérables, sans pertes de résolution pour le moment }
{               QzFast utilise parfois meme moins de points que la courbe expérimentale }
{ 22.08.02:FO:* debugging de QzFast en fixed wavemength et TOF                  }
{               problems de l'offset et des bornes résolus                      }
{               bien que pour les bornes on se donne un peu de marge            }
{               + on utilise un abs() pour eviter les points négatifs           }
{ 27.09.02:FO:* possibilité de preciser un fitting range                        }
{               ca evite de créer une multitude de fichiers textes              }
{ 26.10.02:FO:* la touche DEL est désactivée dans le tableau                    }
{               ca limite le risque de bousiller le systeme ML                  }
{             * le passage xrays - neutrons est mis au clair                    }
{ **** RELEASE 1.43 *******                                                     }
{ 23.02.03:FO:* nouvelle fiche 'dataBaseReading'                                }
{               permet la lecture des paramètres à partir de fichiers textes    }
{             * amélioration des feuilles de conversion                         }
{             * amélioration de l'affichage des en_tetes des colonnes           }
{ **** RELEASE 1.45 *******                                                     }
{ 19.04.03:FO:* amélioration de la gestion des couleurs des colonnes            }
{               possibilité de fitter des data avec des points manquants        }
{               les points expérimentaux manquants doivent contenir la valeur 0 }
{ 23.06..3:FO:* upgrade TMSGridPack V15 to V18                                  }
{               Note : il y a un message trial version qui appariat maintenant  }
{               c'est un peu ennuyeux...                                        }
{             * fenetre indiquant que la sauvegarde est en cours                }
{               (en attendant qu'on accélère la vitesse!)                       }
{             * data par défaut dans les lignes insérées                        }
{ 25.06.03:FO:* warning au démarrage si on utilise , au lieu de .               }
{ **** RELEASE 1.47 *******                                                     }
{ 09.07.03:FO:* possibilité d'utiliser la convolution QzFast pour les calculs   }
{               'with spin-flip'  Gain d'un facteur 8 en vitesse                }
{             * les calculs en 'with SF High field' sont à nouveau possibles    }
{               en "Full Convolution", "en Qz", et en "QzFast"                  }
{             * upgrade de la fonction STORE (4 courbes + pointillés)           }
{             * upgrade de CopyToClipBoard pour le cas High Field               }
{             * possiblité de fitter en SF_HF                                   }
{ 23.07.03:FO:* correction d'une fuite de mémoire dans le calcul                }
{               with SF high field                                              }
{               optimisation de la vitesse de calcul (un peu)                   }
{             * correction d'une deuxième fuite de mémoire                      }
{ **** RELEASE 1.48 *******                                                     }
{ 29.07.03:FO:* prise en compte de l'absorption dans le calcul 'with SF high-field' }
{ 14.08.03:FO:* sortie de toutes les procedures de minimisation Crawling dans   }
{               une unité séparée "Minimisation"                                }
{             * passage de quelques procédures en méthodes                      }
{             => programmation plus rigoureuse, plus de paramètyres implicites  }
{             * transfert d'une partie des fonctions WaveFunctions              }
{               dans une unité séparée                                          }
{ 16.08.03:FO:* utilisation de BringToFront pour retrouver les fenetres         }
{ 21.10.03:FO:* possibilité de fitter des data mesurés en non polarisés         }
{               sur un système magnétique                                       }
{               ATTENTION : on perd beaucoup la sensibilité au magnétisme       }
{ 26.10.03:FO:* nouvelle procedure d'I/O vers le format Excel                   }
{               gain très important en vitesse                                  }
{               En principe, la compatibilité avec les versions précédentes     }
{               est assurée                                                     }
{ **** RELEASE 1.5 ***********                                                  }
{ 26.10.03:FO:* amélioration de la robustesse du fichier "SimulReflec.par"      }
{               le programme supporte que les chemins n'existent pas            }
{               ca améliore fortement la portabilité                            }
{ 10.11.03:FO:* amélioration de la sauvegarde des noms des denriers fichiers    }
{             * verificatin des mots-clefs dans les fichiers de data            }
{               un message de warning averti l'utilisateur que son mot-clef est mauvais }
{             * correction d'un probleme avec les bCorr                         }
{ **** preparation V1.51  **************                                        }
{ 06.12.03:FO:* update des parametres par defaut lors de la creation d'une      }
{               nouvelle ligne dans le tableua des couches                      }
{             * augmentation du nombre max de couches à 199                     }
{               numértotation des lignes des fichiers de fits au-dela de 20!    }
{               la valeur 20 était ecrite explicitement?!                       }
{ 04.02.04:FO:* plot des courbes COS PHI et SIN²PHI                             }
{               possibilité de fitter sur ces courbes en mode SF                }
{             * lorsqu'on fait des calculs de différence, possibilité de préciser le "range" }
{             * possibilité de fitter sur la spin-asymmetrie                    }
{ 05.02.04:FO:* possibilité de faire les calculs et les difference en mode with SF high field }
{             * possibilté de fitter sur COS PHI et SIN PHI en SF HF            }
{ ============================================================================= }
{ A FAIRE                                                                       }
{ * le fit ne fonctionne pas en mode ToF                                        }
{ * modifier le calcul TOF pour les nouvelles résolutions                       }
{ * calcul de la différence e fonctionne pas en TOF                             }
{ * problèmes de fontes et de couleurs avec la table Excel                      }
{   fontes trop grandes; lignes de couleur grises -> lignes noires dans Excel !?}
{   il faut définit le fond en blanc                                            }
{ * etudier la diffeence entre les procédures GenerateAbscisses et generateQzAndAnglesAbscisses }
{ * probleme avec les notations scientifiques xEy                               }
{   la table Excel ne les reconnait pas!!!                                      }
{   dans la foulée, la fonte de la table Excel est pas top                      }
{ * bien séparer les situations avec DIfference2 et RMS (pour avoir le bon CHI) }
{   important à la sortie des calculs pour que ce soit le "bon" CHI qui sorte   }
{ * problème : le calcul en "spin flip" et "high field ne donne pas 100% la meme chose?     }
{   parce qu'il faut faire de calcul de Beff quelque part                       }
{ * BUG : fit en spin-flip avec des profils ne marche pas!!!                    }
{   CHI est anormalement grand                                                  }
{ * quelle est la difference entre .generateAbscisses et .generateQzAndAnglesAbscisses }
{   il semble qu'on n'utilise pas les 2 de la même manière                        }
{   il y a un problème d'initilaisation avec la premiere methode                }
{   c crée des ennuis lorsqu'on utilise le fitting range                        }
{ * BUG quand on passe de RX aux neutrons                                       }
{   CTRL+D repare le probleme                                                   }
{ * reprodcutibilité du fit / calcul                                            }
{ * PHI prennent des valeurs toutes seules ?!                                   }
{ * calcul s mulitcouches en polarisés simple                                   }
{ * rugosité en spin-flip                                                       }
{ * on ne peut pas passer de manière transparente de "poalrised" à "with spin-flip   }
{ * plot du profil de SLD dans les multiccouches                                       }
{ * with SF high-field -> problem Vec.length<>length                            }
{ * il y a des mélanges entre "with spin-flip" et "with SF high field           }
{ les valeurs de phi sont mal initialisées              }
{ PONDERATION smart entre up et DO                                              }
{ DISTRIBUER l'AIDE dasns le fichier ZIP d'installation!!                       }
{ ============================================================================= }
{ A FAIRE                                                                       }
{ * avec le nouveau tableua, les lignes insérées ne soint plus justifiées de la meme manière }
{   justufication à gauche ?                                                    }
{ * le programme ne plotte plus les T's (c'est du au fait que dans la convolution }
{   "optimisée" on evite de calculer la convolution sur les Ts                  }
{ * plot de la wavefunction en mode spin-flip                                   }
{ * dans les calculs, il semble qu'il y a pas mal d'overheads autres que le calcul lui-meme }
{   comme par exemple l'affichage graphique de la boucle de fit                 }
{   en QzFast la difference entre SF etSF_HF est peu perceptible (x2.5)         }
{   en Qz, facteur 5 entre SF et SF_HF                                          }
{ * Note : la rugosité est prise en compte dans SF_HF                           }
{ * les calculs "Polydoamins" en SF_HF ne sont pas implémentés à 100%           }
{ * implémenter la rugosité dans le calcul "with spin-flip"                     }
{ * automatiser le postionnement des fenetres au premier démarrage              }
{ * option QzFast, le nombre de points en Qz diminue très vite des qu'on n'utilise que 3 points dnas la convolution }
{   faire une révision de la génération du spectra QzFast                       }
{   proposer l'option de plot de la resoltuion en fonction de Qz                }
{   cas dQz vs Qz                                                               }
{   le pas de la sequence QzFast ne devrait pas dependre du nombre de points dans la convolution ??}
{   peut-etre que si?                                                           }
{   ecrire un petit mémo sur la convolution en QzFast !!!                       }
{   a mon usage personnel en priorité                                           }
{   les pas de la distribution Qzfast ne suivent pas parfaitment la résolution dQz?? }{WHY? }
{ * Comparer les calculs "sans" spin-flip et avec spin-flip et non polarised    }
{   il semble qu'on a des oscillations bizarres si nbrQz devient petit          }
{   "with spin-flip" se comporte bien quelles que soient les conditions?!       }
{   faire des comparaisons sans prendre en compte la résolution                 }
{ * La convolution QzFast se comporte un peu bizarrement pour des nombres de points en Qz faibles }
{   Etudier pourquoi il faut au moins 7 points pour le QzFast?!                 }
{ * le fitting range semble poser des problèmes                                 }
{ * pour les fits RX, les épaisseurs ne semblent pas bien se fitter             }
{ * problème si le milieu d'incidence n'est pas le vide                         }
{ * WF ne fonctionne pas bien                                                   }
{   selection de la couche ou on claucle les R et les T                         }
{ * ACHTUNG : le calcul GID est douteux : les intensités dépendent énormément   }
{               de l'épaisseur de la couche                                     }
{               faire des tests systématiques                                   }
{ * Cunning idea : utiliser les informations stockées dans les spectres 1D      }
{   pour mettre a jour les labels des plots                                     }
{ * mediter sur l'interaction rho et aimantation pour les profils               }
{ * problèmes avec les valeurs décimales dans la grille                         }
{ * use real distribution ne marche qu'avec "Full Convolution" et pas avec Qz ni avec QzFast }
{ * sortir les vecteurs T de la procedure "With Spin-FLip"                      }
{ * le fit sur "theta" dans l'option SF_HF se comporte de manière bizarre       }
{   il semble très sensible et part parfois à la dérive                          }
{ * les paramètres corrélés phi et Theta ne marchent pas !!                     }
{ ============================================================================= }
{ REMARQUES                                                                     }
{ * PROFILS : on suppose que les profils ne s'entrelacent pas                   }
{ * profilage doit etre indépendant des ML                                      }
{ * il y a un probleme Avec la mise a jour de la grille a partir d'une ML       }
{   on fait des hypothèses sur Y/N                                              }
{   entre autre que le nombre de cuoches est identique                          }
{ A NOTER !!!                                                                   }
{ * si les tailles des tableaux dépassent ce qui est definit dans cache Size    }
{   on perd les data qui sortent de la taille définie par CacheSize ...         }
{ * il faut absolument utiliser (dq/q)² = (dt/t)² + (dl/l)²                     }
{   les résultats sont alors satisfaisants                                      }
{ * quand on veut fitter du TdV, on ne verifie pas que les data sont en Qz      }
{ * quand on fait un calcul en QzFast, on peut avoir très peu de points         }
{   la courbe est moins "lisse" mais plus que convenable)                       }
{   ca ne marche cependant pas avec des courbes très oscillantes                }
{ * pour QzFast, il faut un nombre de points suffisants 11 points dans Qz       }
{   de telle sorte que le pas dans dQz Fast ne soit pas trop petit              }
{   sinon pour fitter 200 points, QzFast peut descendre à 30 points!            }
{ * pouvoir changer l'aspect ratio du graph2D                                   }
{ * accélerer la lecture des fichiers Excel                                     }
{ * pour sauvegarder les courbes précdentes pendant la procédure de fit         }
{   utiliser le boutton STORE; le store automatqiue n'est pas pratique          }
{ * sérieusement songer à se débarraszser des variables globales                }
{ ============================================================================= }
{ Utilisation des MDS                                                           }
{ 1°/ charger les dataSets                                                      }
{ 2°/ indiquer les paramètres libres = lettre 'L' dans la colonne fit           }
{     on utilise une seule couche descriptive (panneau principal Multilayer)    }
{ * il n'est pas possible de fitter la normalisation avec les MDS               }
{   parce qu'on n'a pas une normalisation pour chaque DataSet                   }
{   = faire passer la normalisation de MyExperimentalPra à MyMultiLayer         }
{ * il faut pouvoir laisser plus dun paramètre libre pour chaque MDS            }
{ * problème du stockage des résultats ?                                        }
{ => au bout de la feuille Excel?                                               }
{ = il faut correctemetn initialiser MyMultilayer probablement                  }
{ linker le spin edit du graph avec le spin edit du plot                        }
{ * initialisation des Rows et colones du tableau des parametre slibres         }
{ le multifit en polarisé ne fonctionne pas corrcetement                        }
{ * quand on est trop loin du fit, les paramètres ne bougent plus parfois       }
interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  Menus,editdata,xygraph, Db, Graph2D, Graph1D, StdCtrls, Spin,
  JclShell, JvComponent, JvHtmlParser, JvSysComp, dataReflec, MtxVec;

const
wm_fermeture=$400+wm_user;
wm_redessine=$403+wm_user;
wm_redessine_graph1D=$404+wm_user;
wm_reorganiser=$406+wm_user;

type
  Tprincipalform = class(TForm)
    MainMenu1: TMainMenu;
    nouvelle: TMenuItem;
    nouvelle1: TMenuItem;
    N1D1: TMenuItem;
    N1D2: TMenuItem;
    N1: TMenuItem;
    supprimer2: TMenuItem;
    OpenDialog1: TOpenDialog;
    Aide1: TMenuItem;
    Apropos1: TMenuItem;
    Utiliserlaide1: TMenuItem;
    Index1: TMenuItem;
    Main1: TMenuItem;
    Help1: TMenuItem;
    Parser1: TMenuItem;
    JvCreateProcess1: TJvCreateProcess;
    N3: TMenuItem;
    ConversionsFormvisibletrue1: TMenuItem;
    Graph2D1: TMenuItem;
    Reflectivities1: TMenuItem;
    Graph1D1: TMenuItem;
    SimulReflec1: TMenuItem;
    Neutronsconversions1: TMenuItem;
    Exit1: TMenuItem;
    N2: TMenuItem;
    Calculatereflectivity2: TMenuItem;
    Calculatedifference1: TMenuItem;
    Fitcrawling1: TMenuItem;
    NeutronsSLD1: TMenuItem;
    ConsulDatabase1: TMenuItem;
    Wavefunction1: TMenuItem;
    CONFIGURATION1: TMenuItem;
    N4: TMenuItem;
    Specularreflectivity1: TMenuItem;
    ILTOF1: TMenuItem;
    Wavefunction2: TMenuItem;
    Graph3D1: TMenuItem;
    procedure nouvelleClick(Sender: TObject);
    procedure supprimer1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure N1D1Click(Sender: TObject);
    {procedure editiondesmoteurs1Click(Sender: TObject);}
    {procedure Ajouter1Click(Sender: TObject);}
    procedure Index1Click(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
    procedure BUGREPORT1Click(Sender: TObject);
    procedure Apropos1Click(Sender: TObject);
    procedure Help1Click(Sender: TObject);
    procedure Parser1Click(Sender: TObject);
    procedure ConversionsFormvisibletrue1Click(Sender: TObject);
    procedure Graph2D1Click(Sender: TObject);
    procedure Reflectivities1Click(Sender: TObject);
    procedure Graph1D1Click(Sender: TObject);
    procedure SimulReflec1Click(Sender: TObject);
    procedure Neutronsconversions1Click(Sender: TObject);
    procedure Exit1Click(Sender: TObject);
    procedure Calculatedifference1Click(Sender: TObject);
    procedure Fitcrawling1Click(Sender: TObject);
    procedure Calculatereflectivity2Click(Sender: TObject);
    procedure NeutronsSLD1Click(Sender: TObject);
    procedure ConsulDatabase1Click(Sender: TObject);
    procedure Wavefunction1Click(Sender: TObject);
    procedure Specularreflectivity1Click(Sender: TObject);
    procedure Wavefunction2Click(Sender: TObject);
    procedure Graph3D1Click(Sender: TObject);

  private
    { Déclarations privées}
  protected
  public
    { Déclarations publiques}
    procedure redessiner;
    procedure redessiner_Graph1D;    
    procedure wmredessine(var msg:tmessage); message wm_redessine;
    procedure wmredessine_Graph1D(var msg:tmessage); message wm_redessine_graph1D;
  end;

var
  principalform: Tprincipalform;
  gr2d:array[1..4] of tGraph2Dform;
  gr1d:array[1..4] of tGraph1dform;

var
  MyDataExp,MyDataCalc,MyDataCalc2,MyDataCalc3:TDataReflectivity;
  MyDataExpFit:TDataReflectivity; { data which have been cut for the fit }
  MyMultiLayer,MyMultiLayer2,MyMultiLayerUndo,MyMultiLayerBeforeProfiling:TMultiLayer;
  MyExperimentalParameters:TExperimentalParameters;
  MyProfiles:TProfiles;
  MyMDS:array of TDataReflectivity; { MDS = Multiple Data Set }
  MyMDSfit:array of TDataReflectivity; { MDS = Multiple Data Set for use for the fits }
  MyMDS_EP:array of TExperimentalParameters; { MDS = Multiple Data Set associated Experimental parameters }
  MyMDS_ML:array of TMultiLayer; { MDS = Multiple Data Set associated MultiLayers }
  MyMDS_DataCalc:array of TDataReflectivity;

implementation

uses interpreteur, about, PilotageGraph2D, SimulReflecForm, XraysConvertForm,
  NeutronsConvertForm, dataBaseReading, EmailUnit, WaveFunctionForm,
  Graph2D3D, calculReflec;
{$R *.DFM}

procedure Tprincipalform.nouvelleClick(Sender: TObject);
var
tf:boolean;
i:integer;
begin
tf:=false;
i:=1;
while (not tf) and (i<=4) do
begin
   if gr2d[i]=nil then begin
                    gr2d[i]:=tGraph2dform.create(self,128,128);
                    tf:=true;
                    end;
   i:=i+1;
end;
end;

procedure Tprincipalform.supprimer1Click(Sender: TObject);
var
i:integer;
begin
for i:=1 to 4 do begin
if activemdichild=gr1d[i] then
sendmessage(gr1d[i].handle,wm_fermeture,0,0);{suppression}
if activemdichild=gr2d[i] then
sendmessage(gr2d[i].handle,wm_fermeture,0,0);{suppression}
end;
end;

procedure Tprincipalform.FormCreate(Sender: TObject);
var
ind:integer;
i,j,k:integer;
begin
  WindowState := wsMaximized;

  SetVecCacheSize(100,NbrPointsMax);
  SetMtxCacheSize(10,10);   { attention! data complexes }
  
{ with DataReflec do
 begin }
  MyDataExp:=TDataReflectivity.create;
  MyDataExpFit:=TDataReflectivity.create;
  MyDataCalc:=TDataReflectivity.create;
  MyDataCalc2:=TDataReflectivity.create;
  MyDataCalc3:=TDataReflectivity.create;  
  MyMultiLayer:=TMultiLayer.Create;
  MyMultiLayer2:=TMultiLayer.Create;
  MyMultiLayerUndo:=TMultiLayer.Create;
  MyMultiLayerBeforeProfiling:=TMultiLayer.Create;
  MyExperimentalParameters:=TExperimentalParameters.Create;
  MyProfiles:=TProfiles.Create;
  setlength(MyMDS,1);MyMDS[0]:=TDataReflectivity.create;
  setlength(MyMDS_EP,1);MyMDS_EP[0]:=TExperimentalParameters.create;
  setlength(MyMDS_ML,1);MyMDS_ML[0]:=TMultiLayer.create;
{ end; }

  SourceDirectory:=GetCurrentDir+'\';
{ création des listes des spectres 1D, 2D et 3D      }
troisd:=spectlist.create;
deuxd:=spectlist.create;
und:=spectlist.Create;
{ initialisation des spectres 2D }
ind:=deuxd.addspectre('ACUP',128,128,1);
deuxd.spect[ind].comment:='spectre upup';
deuxd.spect[ind].typex:='raw';
deuxd.spect[ind].typey:='raw';
for i:=0 to 127 do
  for j:=0 to 127 do
  begin
    deuxd.spect[ind].data[i,j,0].x:=i;
    deuxd.spect[ind].data[i,j,0].y:=j;
    deuxd.spect[ind].data[i,j,0].lt:=0;
    deuxd.spect[ind].data[i,j,0].z:=100*exp(-sqr(i-64)/10000)*exp(-sqr(j-64)/10000);
  end;

ind:=deuxd.addspectre('ACDOWN',128,128,1);
deuxd.spect[ind].comment:='spectre updown';
deuxd.spect[ind].typex:='raw';
deuxd.spect[ind].typey:='raw';
for i:=0 to 127 do
  for j:=0 to 127 do
  begin
    deuxd.spect[ind].data[i,j,0].x:=i;
    deuxd.spect[ind].data[i,j,0].y:=j;
    deuxd.spect[ind].data[i,j,0].lt:=0;
    deuxd.spect[ind].data[i,j,0].z:=40*exp(-sqr(i-128)/10000)*exp(-sqr(j-32)/10000);
  end;

{ creation des spectres 1D }
ind:=und.addspectre('C1H',512,1,1);
und.spect[ind].comment:='curseur 1, coupe horizontale';
und.spect[ind].typex:='reflec';
und.spect[ind].typey:='single';
for i:=0 to 511 do
und.spect[ind].data[i,0,0].z:=1E-5;
ind:=und.addspectre('C1V',512,1,1);
und.spect[ind].comment:='réflectivité downdown';
und.spect[ind].typex:='reflec';
und.spect[ind].typey:='single';
for i:=0 to 511 do
und.spect[ind].data[i,0,0].z:=1E-5;
ind:=und.addspectre('C2H',512,1,1);
und.spect[ind].comment:='réflectivité downdown';
und.spect[ind].typex:='reflec';
und.spect[ind].typey:='single';
for i:=0 to 511 do
und.spect[ind].data[i,0,0].z:=1E-5;

ind:=und.addspectre('C2V',512,1,1);
und.spect[ind].comment:='réflectivité downdown';
und.spect[ind].typex:='reflec';
und.spect[ind].typey:='single';
for i:=0 to 511 do
und.spect[ind].data[i,0,0].z:=1E-5;

ind:=und.addspectre('PH',512,1,1);
und.spect[ind].comment:='projection horizontale';
und.spect[ind].typex:='raw';
und.spect[ind].typey:='raw';
for i:=0 to 511 do
und.spect[ind].data[i,0,0].z:=1E-5;

ind:=und.addspectre('PV',512,1,1);
und.spect[ind].comment:='projection verticale';
und.spect[ind].typex:='raw';
und.spect[ind].typey:='raw';
for i:=0 to 511 do
und.spect[ind].data[i,0,0].z:=1E-5;



{ creation du spectre 3D  }
ind:=troisd.addspectre('data3D',32,64,8);
for i:=0 to 31 do
   for j:=0 to 63 do
       for k:=0 to 7 do
       begin
          troisd.spect[ind].data[i,j,k].x:=i;
          troisd.spect[ind].data[i,j,k].y:=j;
          troisd.spect[ind].data[i,j,k].z:=(k+1)*exp(-sqr(i-64)/10000)*exp(-sqr(j-64)/10000);
          troisd.spect[ind].data[i,j,k].lt:=k;
       end;
troisd.spect[ind].comment:='spectre updown';
troisd.spect[ind].typex:='raw';
troisd.spect[ind].typey:='raw';
troisd.spect[ind].typeLT:='lambda';

end;

procedure Tprincipalform.N1D1Click(Sender: TObject);
var
tf:boolean;
i:integer;
begin
tf:=false;
i:=1;
while (not tf) and (i<=4) do begin
if gr1d[i]=nil then begin
 gr1d[i]:=tgraph1dform.create(self);
 tf:=true;
end;
i:=i+1;
end;
end;


procedure Tprincipalform.wmredessine(var msg:tmessage);
begin
redessiner;
end;

procedure Tprincipalform.redessiner;
var
i:integer;
begin
for i := MDIChildCount-1 downto 0 do
sendmessage(mdichildren[i].handle,wm_redessiner,0,0);
end;

procedure Tprincipalform.wmredessine_Graph1D(var msg:tmessage);
begin
redessiner_graph1D;
end;

{ rafraichissement des fénétres 1D uniquement }
procedure Tprincipalform.redessiner_Graph1D;
var i:integer;
begin
  for i := MDIChildCount-1 downto 0 do
  begin
    if mdichildren[i].Caption='Graph1D' then sendmessage(mdichildren[i].handle,wm_redessiner,0,0);
  end
end;


procedure Tprincipalform.Index1Click(Sender: TObject);
begin
   Application.HelpFile := SourceDirectory+'\help\SimulReflec.HLP';
   Application.HelpCommand(HELP_FINDER, 0);
end;


procedure Tprincipalform.FormClose(Sender: TObject;
  var Action: TCloseAction);
var ButtonSelected:word;
begin
     ButtonSelected:=MessageDlg('DO YOU WANT TO QUIT THE PROGRAM ?',mtWarning,[mbNo,mbYes],0);
{     ButtonSelected:=MessageDlg('ARE YOU REALLY SURE THAT YOU ARE NOT QUITTING PCANYWHERE ?',mtConfirmation,[mbNo,mbYes],0); }
     if ButtonSelected=mrYes
     then begin
          action:=caFree;
          SimulReflecWindow.FormClose(Sender,Action);
          end
     else begin action:=caNone end;
end;

procedure Tprincipalform.BUGREPORT1Click(Sender: TObject);
begin
     SmtpForm.visible:=true;
end;

procedure Tprincipalform.Apropos1Click(Sender: TObject);
begin
     AboutBox.visible:=true;
end;

procedure Tprincipalform.Help1Click(Sender: TObject);
begin
  JvCreateProcess1.CommandLine:='explorer '+SourceDirectory+'SimulReflecHelp\SR_Manual.htm';
  JvCreateProcess1.Run;
end;

procedure Tprincipalform.Parser1Click(Sender: TObject);
begin
  JvCreateProcess1.CommandLine:='explorer '+SourceDirectory+'ParserHelp\parserManual.htm';
  JvCreateProcess1.Run;
end;

procedure Tprincipalform.ConversionsFormvisibletrue1Click(Sender: TObject);
begin
    with ConversionsXraysForm do
    begin Top:=200;Left:=200;Width:=297;Height:=137; end;
    ConversionsXraysForm.windowState:=wsNormal;
    ConversionsXraysForm.bringToFront;;
end;

procedure Tprincipalform.Graph2D1Click(Sender: TObject);
begin
    graph2DForm.windowState:=wsNormal;
    graph2DForm.bringToFront;
end;

procedure Tprincipalform.Reflectivities1Click(Sender: TObject);
begin
    SRgraph1DForm.windowState:=wsNormal;
    SRgraph1DForm.bringToFront;
end;

procedure Tprincipalform.Graph1D1Click(Sender: TObject);
begin
    graph1DForm.windowState:=wsNormal;
    graph1DForm.bringToFront;
end;

procedure Tprincipalform.SimulReflec1Click(Sender: TObject);
begin
    SimulReflecWindow.windowState:=wsNormal;
    SimulReflecWindow.bringToFront;
end;

procedure Tprincipalform.Neutronsconversions1Click(Sender: TObject);
begin
    with ConversionsNeutronsForm do
    begin Top:=200;Left:=200;Width:=303;Height:=156; end;
    ConversionsNeutronsForm.windowState:=wsNormal;
    ConversionsNeutronsForm.bringToFront;
end;

procedure Tprincipalform.Exit1Click(Sender: TObject);
begin
  close
end;

procedure Tprincipalform.Calculatedifference1Click(Sender: TObject);
begin
   SimulReflecWindow.CalculateDifference2Click(Sender);
end;

procedure Tprincipalform.Fitcrawling1Click(Sender: TObject);
begin
   SimulReflecWindow.FitCrawlingMenuClick(Sender);
end;

procedure Tprincipalform.Calculatereflectivity2Click(Sender: TObject);
begin
   SimulReflecWindow.CalculateReflectivity1Click(Sender);
end;

procedure Tprincipalform.NeutronsSLD1Click(Sender: TObject);
begin
  JvCreateProcess1.CommandLine:='Explorer '+SourceDirectory+'Help\NeutronsSLD.xls';
  JvCreateProcess1.Run;
end;

procedure Tprincipalform.ConsulDatabase1Click(Sender: TObject);
begin
    with dataBaseReadingForm do
    begin Top:=200;Left:=200;Width:=261;Height:=300; end;
    dataBaseReadingForm.windowState:=wsNormal;
    dataBaseReadingForm.bringToFront;
end;

procedure Tprincipalform.Wavefunction1Click(Sender: TObject);
begin
    WaveFunctionPlotting.windowState:=wsNormal;
    WaveFunctionPlotting.bringToFront;
end;

procedure Tprincipalform.Specularreflectivity1Click(Sender: TObject);
begin
  Graph2D3DForm.WindowState:=wsMinimized;
  Graph2DForm.WindowState:=wsMinimized;
  InterpreteurForm.WindowState:=wsMinimized;
  SimulReflecWindow.WindowState:=wsNormal;
  SRGraph1Dform.WindowState:=wsNormal;
end;

procedure Tprincipalform.Wavefunction2Click(Sender: TObject);
begin
  Graph2DForm.WindowState:=wsMinimized;
  Graph2D3DForm.WindowState:=wsNormal;
  InterpreteurForm.WindowState:=wsMinimized;
  SimulReflecWindow.WindowState:=wsMinimized;
  SRGraph1Dform.WindowState:=wsMinimized;
  WaveFunctionPlotting.WindowState:=wsNormal;
end;

procedure Tprincipalform.Graph3D1Click(Sender: TObject);
begin
  Graph2D3Dform.windowState:=wsNormal;
  Graph2D3Dform.bringToFront;
end;

end.


