Utilisation du mode EXTERNE =========================== Avertissement ------------- Nous attirons l’attention sur le fait que ce mode de fonctionnement est à réserver à un usage avancé. La plupart des cas devraient être traités avec les algorithmes fournis dans la commande MACR_RECAL, et notamment l’algorithme Levenberg-Marquardt, qui est le plus adapté aux problèmes de recalage de paramètres. Ce mode de fonctionnement nécessite un logiciel externe pour effectuer l’optimisation (code Python, Matlab, Scilab, logiciel type boite noire, etc.). De plus, il est nécessaire d’avoir quelques compétences Python. **Enfin, l’utilisation du mode EXTERNE sort du périmètre AQ d’Aster** , et ne devrait pas être utilisé pour des études IPS. Méthodologie ------------ Principe ~~~~~~~~ Dans ce mode d’utilisation, *Code_Aster* est uniquement utilisé pour l’évaluation de la fonctionnelle pour un logiciel d’optimisation qui est complètement externe à *Code_Aster* . .. image:: images/10000000000004350000010FAD02ED26C44BAC83.png :width: 6.3374in :height: 1.5945in .. _RefImage_10000000000004350000010FAD02ED26C44BAC83.png: **Figure** 7.2.1-a **:** MACR_RECAL **«Algorithme externe»** Généralement, les logiciels d’optimisation demandent que l’utilisateur écrive une procédure pour le calcul de la fonctionnelle: f = F(param). Si le logiciel autorise la lecture/écriture de fichiers et l’exécution de code externe (commande «system» ou autres), alors il est potentiellement utilisable avec MACR_RECAL. On va encapsuler l’appel à la procédure Python **recal.py** ainsi que l’écriture du fichier des paramètres et la relecture du fichier de la valeur de la fonctionnelle dans la routine de calcul de F. .. image:: images/1000000000000469000001B4C28F438388EBCB2C.png :width: 6.3374in :height: 2.4472in .. _RefImage_1000000000000469000001B4C28F438388EBCB2C.png: **Figure** 7.2.1-b **:** MACR_RECAL **«Principe du mode EXTERNE», exemple** Matlab Le logiciel d’optimisation lance *Code_Aster* à chaque évaluation de la fonctionnelle. La routine d’évaluation de la fonctionnelle passe par des fichiers textes pour envoyer à *Code_Aster* les paramètres à utiliser et pour récupérer la valeur de la fonctionnelle. La routine Pythonrecal.py est donc appelable indépendamment d’Aster et fait le lien entre le logiciel d’optimisation et *Code_Aster* (récupération du fichier des paramètres, remise en forme du fichier esclave, lancement d’Aster, récupération de la fonctionnelle). En pratique, il faut disposer d’un profil Astk classique de l'étude esclave (et non pas le profil de l l'une utilisation de MACR_RECAL). Ce profil doit être complètement fonctionnel. Sous ce mode EXTERNE, le mode de fonctionnements est le suivant : la routine recal.py se charge de récupérer les paramètres depuis la ligne de commande ou depuis un fichier input.txt, va aller remplacer ces paramètres dans le profil esclave, puis va lancer l'exécution de l'étude esclave pour les nouveau paramètres, et enfin va renvoyer dans une fichier texte output.txt les valeurs de la fonctionnelle. A ce jour, ce mode de fonctionnement a été testé avec plusieurs logiciels d’optimisation (la *toolbox* d’optimisation de Matlab, la *toolbox* Tomlab pour Matlab, et le module d’optimisation de Python-Scipy) mais il est possible d’utiliser à peu près n’importe quel logiciel à partir du moment où ce logiciel autorise l’exécution externe d’un script. On pense notamment à Zopt (Zebulon), SiDoLo. Utilisation du fichier de lancement externe recal.py ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Le fichier recal.py peut s’exécuter de manière autonome avec quelques paramètres optionnels sur la ligne de commande: Usage: /aster/NEW10/bibpyt/Macro/recal.py fichier_export [options] Options: -h, --help show this help message and exit --input=INPUT Chaine de texte contenant les parametres --input_step=INPUT_STEP Chaine de texte contenant les pas de discretisation des differences finies --input_file=INPUT_FILE Fichier contenant les parametres --input_step_file=INPUT_STEP_FILE Fichier contenant les pas de discretisation des differences finies --output=OUTPUT fichier contenant la fonctionnelle --output_grad=OUTPUT_GRAD fichier contenant le gradient --aster_root=ASTER_ROOT Chemin d'installation d'Aster --as_run=as_runChemin vers as_run --resudir=RESUDIR Chemin par defaut des executions temporaires d'Aster --noclean Erase temporary Code_Aster execution directory --info=INFO niveau de message (0, 1, 2) --sources_root=SOURCES_ROOT Chemin par defaut des surcharges Python --objective=OBJECTIVE Fonctionnelle ([fcalc]/[error]) --objective_type=OBJECTIVE_TYPE type de la fonctionnelle (float/[vector]) --gradient_type=GRADIENT_TYPE calcul du gradient par *Code_Aster* ([no]/normal/adim) --mr_parameters=MR_PARAMETERS Fichier de parametres de MACR_RECAL : parametres, calcul, experience --study_parameters=STUDY_PARAMETERS Fichier de parametre de l'etude : export --parameters=PARAMETERS Fichier de parametres Cette procédure a besoin: 1. du fichier .export de l’étude Astk définie précédemment (l’étude standard de MACR_RECAL) 2. d’un fichier texte contenant la liste des paramètres A partir de ces deux fichiers, elle lance un calcul *Code_Aster* pour les paramètres spécifiés (ou deux calculs *Code_Aster* , voir plus haut) et génère un fichier texte contenant uniquement la valeur de la fonctionnelle (scalaire ou vectorielle). Cette procédure peut être lancée sans argument. Elle va alors chercher **dans le répertoire courant** des fichiers par défaut: 1. s’il n’y a qu’un seul fichier .export dans le répertoire courant, celui-ci sera utilisé (dans le cas contraire la procédure s’arrête en erreur) 2. le fichier d’entrée par défaut sera cherché sous le nom «input.txt» 3. le fichier de sortie sera généré avec le nom «output.txt» Les arguments –i (--input) et -o (--output) permettent de préciser les fichiers. L’argument –g (--output_grad): permet de préciser le fichier texte dans lequel sera écrit le gradient, si celui-ci est demandé (argument -G). D’autres arguments sont disponibles: 1. --info: défini le niveau de message; 0=muet, 1 ou 2; 2. --objective: permet de préciser si la fonctionnelle doit être retournée sous la forme vectorielle ou scalaire; 3. --gradient: permet de préciser si on ne veut pas qu’Aster calcule et renvoie les gradient (no), et si on veut les gradients, de préciser si on les veut adimensionné ou non; Par défaut, un fichier *Code_Aster* .output est crée dans le répertoire d’exécution de la procédure, permettant d’avoir accès à l’output du dernier calcul *Code_Aster* . Enfin, il faut configurer la variable d’environnement ASTER_ROOT (le chemin de base d’Aster) pour pouvoir lancer en Python le fichier recal.py ou aors utiliser l'argument --aster_root. Le bon fonctionnement de la procédure recal.py peut être vérifié manuellement, en générant un fichier d’entrée avec des valeurs de paramètres et en lançant manuellement la procédure. Exemple sur la machine *Code_Aster* : cd repertoire export ASTER_ROOT=/aster echo “10., 20., 30. ” >input.txt Python $ASTER_ROOT/NEW10/bibpyt/Macro/recal.py etude.export –-info=2 cat ouput.txt Le calcul *Code_Aster* devrait se lancer et terminer convenablement. Un fichier output.txt doit être généré dans le répertoire courant. Le cas-test zzzz159f illustre l’utilisation externe de MACR_RECAL: dans ce test *Code_Aster* , on définit une fonction f et on rappelle une fois *Code_Aster* pour simuler une itération de recalage. Exemple : module d’optimisation de Matlab© ------------------------------------------ Si on reprend le principe et qu’on l’applique à un algorithme d’optimisation qui serait écrit sous Matlab, on doit écrire deux fichiers go.m et fonction.m qui effectuent les actions décrites ci-dessous: .. image:: images/1000000000000473000001B239F3CF50B8EEDE7A.png :width: 6.3374in :height: 2.4146in .. _RefImage_1000000000000473000001B239F3CF50B8EEDE7A.png: **Figure** 7.3-a **:** MACR_RECAL **«Principe du mode EXTERNE» appliqué à** Matlab© L’exemple suivant utilise le module d’optimisation de Matlab et effectue les calculs *Code_Aster* sur le serveur local. **Fichier go.m** (initialisation et lancement de l’optimisation) .. code-block:: text clear all; format long; system('rm -f fort.91'); options = optimset('Display', 'iter', 'LevenbergMarquardt', 'on', 'TolFun', 1e-8, 'MaxFunEvals', 1000, 'MaxIter', 100); % Params : DSDE__, SIGY__, YOUN__ x0 = [:ref:` 1000., 30., 100000. < 1000., 30., 100000. >`]; lb = [:ref:` 500., 5., 50000. < 500., 5., 50000. >`]; ub = [:ref:` 10000., 500., 500000. < 10000., 500., 500000. >`]; % vecteur [x,resnorm,residual,exitflag,output,lambda,jacobian] = lsqnonlin(@fonction,x0,lb,ub,options) % scalaire %[x,fval,exitflag,output] = fmincon(@fonction,x0,[],[],[],[],lb,ub,[],options) **Fichier fonction.m** (calcul de F(param)) / version Linux .. code-block:: text function f = fonction(x) system('rm -f input.txt'); system('rm -f output.txt'); % Ecriture des parametres dlmwrite('input.txt', x, 'precision', '%.20f'); % Local iret = system('export ASTER_ROOT=/opt/aster ; Python $ASTER_ROOT/NEW10/bibpyt/Macro/recal.py **etude.export** --objective_type=vector'); f = dlmread('output.txt', ',', 0, 0); % relit un scalaire ou un vecteur Dans go.m, on donne deux exemples d’algorithmes. L’algorithme lsqnonlin minimise une fonctionnelle vectorielle et il faut donc décommenter la première ligne «iret=». Cet algorithme est basé sur Levenberg-Marquardt à contraintes actives, et est donc similaire à celui implanté dans *Code_Aster* . **Remarque:** *Il est important de noter la présence de la commande* *format longet de l’argument* *precisionpour la commande* *dlmwrite. Ceci permet de travailler avec un nombre suffisant de chiffres significatifs et de ne pas s’arrêter si la tolérance sur la fonction n’est plus respectée.* **Remarque 2:** *Lorsque le logiciel d’optimisation n’est pas capable de gérer les codes retour de l’exécution externe, il faut faire attention à arrêter proprement la procédure en cas d’arrêt anormal du calcul Code_Aster. C’est la raison pour laquelle on efface les fichiers* *input.txtet* *output.txtjuste après leur utilisation, afin de ne pas tomber dans des boucles sans fin.*