Lecture, Êcriture d'un fichier MED grâce à l'API basique de MEDLoader
---------------------------------------------------------------------

L'API basique de MEDLoader est contenue dans la classe ``MEDLoader``.
Toutes les mÊthodes de cette classe sont *statiques* (elles ne dÊpendent pas d'une instance particulière de la
classe), leurs noms commencent par une majuscule. 
L'ensemble des lectures/ĂŠcritures sont exĂŠcutĂŠes Ă  chaque appel de mĂŠthode et aucun ĂŠtat interne Ă  la classe n'est
enregistrĂŠ.

Objectif
~~~~~~~~

Ecrire un maillage et un champ Ă  partir de rien, les relire et comparer les rĂŠsultats.

Points abordĂŠs: en utilisant l'API basique de ``MEDLoader``

* Ecrire un fichier
* Lire un fichier

DĂŠbut d'implĂŠmentation
~~~~~~~~~~~~~~~~~~~~~~

Cet exercice repose comme tous les autres sur le language de script Python. On charge 
le module Python ``MEDLoader``.

Pour information, le module ``MEDCoupling`` complet est inclus dans ``MEDLoader``. Pas besoin de l'importer
si ``MEDLoader`` a ĂŠtĂŠ chargĂŠ. ::

	import MEDLoader as ml

Lecture, ĂŠcriture d'un maillage
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Tout d'abord crĂŠons un maillage ``targetMesh`` composĂŠ de plusieurs types gĂŠomĂŠtriques. ::

	targetCoords = [-0.3,-0.3, 0.2,-0.3, 0.7,-0.3, -0.3,0.2, 0.2,0.2, 0.7,0.2, -0.3,0.7, 0.2,0.7, 0.7,0.7 ]
	targetConn = [0,3,4,1, 1,4,2, 4,5,2, 6,7,4,3, 7,8,5,4]
	targetMesh = ml.MEDCouplingUMesh("MyMesh",2)
	targetMesh.allocateCells(5)
	targetMesh.insertNextCell(ml.NORM_TRI3,3,targetConn[4:7])
	targetMesh.insertNextCell(ml.NORM_TRI3,3,targetConn[7:10])
	targetMesh.insertNextCell(ml.NORM_QUAD4,4,targetConn[0:4])
	targetMesh.insertNextCell(ml.NORM_QUAD4,4,targetConn[10:14])
	targetMesh.insertNextCell(ml.NORM_QUAD4,4,targetConn[14:18])
	myCoords = ml.DataArrayDouble(targetCoords,9,2)
	myCoords.setInfoOnComponents(["X [km]","YY [mm]"])
	targetMesh.setCoords(myCoords)

.. note:: Le maillage ``targetMesh`` est ordonnĂŠ par type gĂŠomĂŠtrique.

Le maillage peut alors directement ĂŞtre ĂŠcrit ... ::

	ml.WriteUMesh("TargetMesh.med",targetMesh,True)  # True means 'from scratch'

... et relu. ::

	meshRead = ml.ReadUMeshFromFile("TargetMesh.med",targetMesh.getName(),0)
	print "Is the read mesh equal to 'targetMesh' ?", meshRead.isEqual(targetMesh,1e-12)

Lire/Ecrire un champ sur un pas de temps
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Nous crĂŠons maintenant un champ de vecteurs ``f`` aux cellules (P0) avec ``targetMesh`` comme support. 
Ce champ correspond par exemple au temps physique 5.6, repĂŠrĂŠ par l'itĂŠration 7 et la sous-itĂŠration 8. 
Nous en profitons pour rappeler
que dans les champs MEDCoupling, le temps physique est donnĂŠ pour information seulement, le stockage et la plupart des
fonctions de l'API se basent sur les deux derniers entiers. ::

	f = ml.MEDCouplingFieldDouble.New(ml.ON_CELLS, ml.ONE_TIME)
	f.setTime(5.6,7,8)                              # Declare the timestep associated to the field 
	f.setArray(targetMesh.computeCellCenterOfMass())
	f.setMesh(targetMesh)
	f.setName("AFieldName")
	ml.WriteField("MyFirstField.med",f,True)

Question subsidiaire : Ă  quoi correspond le champ ainsi crĂŠĂŠ ?

.. note:: Le maillage **et** le champ sont ĂŠcrits d'un seul coup dans le fichier "MyFirstField.med".

Nous relisons ensuite MyFirstField.med : ::

	f2 = ml.ReadFieldCell("MyFirstField.med", f.getMesh().getName(), 0, f.getName(), 7, 8)
	print "Is the read field identical to 'f' ?", f2.isEqual(f,1e-12,1e-12)
	
.. note:: Lors de la lecture du champ, on doit donc connaĂŽtre: son nom, le nom de sa mesh de support
	et le pas de temps voulu. Des fonctions du type ``MEDFileFields.getFieldsNames()`` ou encore 
	``MEDFileMeshes.getMeshesNames()`` aident Ă  cela.
	
.. note:: Le nom ``ReadFieldCell()`` rappelle que le champ doit ĂŞtre lu aux cellules. Souvenez-vous que suivant la 
	norme MED fichier, un mĂŞme champ peut avoir une partie de ses donnĂŠes stockĂŠes aux cellules, mais aussi 
	simultanĂŠment aux noeuds, aux points de Gauss, etc ... mĂŞme si ce genre de mĂŠlange exotique n'est gĂŠnĂŠralement
	pas conseillĂŠ.

Lire/Ecrire un champ sur plusieurs pas de temps
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Ici contrairement au cas prĂŠcĂŠdent, nous ĂŠcrivons en plusieurs fois dans le *mĂŞme* fichier MED.
Ecrivons tout d'abord le maillage. ::

	ml.WriteUMesh("MySecondField.med",f.getMesh(),True)
	
Ensuite, nous ĂŠcrivons seulement les informations relatives au champ (principalement son tableau de valeurs en fait
). ::

	ml.WriteFieldUsingAlreadyWrittenMesh("MySecondField.med",f)   # mesh is not re-written
	
Nous rajoutons ensuite un second pas de temps sur le *mĂŞme* maillage. ::

	f2 = f.clone(True)         # 'True' means that we need a deep copy  
	f2.getArray()[:] = 2.0
	f2.setTime(7.8,9,10)
	ml.WriteFieldUsingAlreadyWrittenMesh("MySecondField.med",f2)

Maintenant le fichier "MySecondField.med" contient le maillage et un champ Ă  deux pas de temps portĂŠ par ce maillage.

Nous pouvons relire tout cela avec des mĂŠthodes similaires Ă  ce qui a ĂŠtĂŠ vu prĂŠcĂŠdemment : ::

	f3 = ml.ReadFieldCell("MySecondField.med",f.getMesh().getName(),0,f.getName(),7,8)
	print "Is the field read in file equals to 'f' ?", f.isEqual(f3,1e-12,1e-12)
	f4 = ml.ReadFieldCell("MySecondField.med",f.getMesh().getName(),0,f.getName(),9,10)
	print "Is the field read in file equals to 'f2' ?", f2.isEqual(f4,1e-12,1e-12)

Solution
~~~~~~~~

:ref:`python_testMEDLoaderBasicAPI1_solution`