--- /dev/null
+using namespace std;
+#include "MEDMEM_Mesh.hxx"
+#include "MEDMEM_Field.hxx"
+
+using namespace MEDMEM;
+
+int main (int argc, char ** argv) {
+
+ const string MedFile = "pointe.med" ;
+ const string MeshName = "maa1" ;
+
+ /* read MESH */
+ MESH * myMesh = new MESH(MED_DRIVER,MedFile,MeshName) ;
+ // myMesh->read() ;
+
+ // we need a support :
+ SUPPORT * mySupport = new SUPPORT(myMesh,"Support on all CELLs",MED_CELL);
+
+ /* create FIELD on mySupport, with 3 components */
+ int NumberOfCompoennts = 3 ;
+ FIELD<double> myField(mySupport,NumberOfCompoennts) ;
+ const string FieldName = "fieldcelldouble" ;
+ myField.setName(FieldName) ;
+
+ // Components information
+ string * ComponentsNames = new string[NumberOfCompoennts] ;
+ ComponentsNames[0] = "Vx" ;
+ ComponentsNames[1] = "Vy" ;
+ ComponentsNames[2] = "Vz" ;
+ myField.setComponentsNames(ComponentsNames) ;
+
+ string * ComponentsDescriptions = new string[NumberOfCompoennts] ;
+ ComponentsDescriptions[0] = "vitesse selon x" ;
+ ComponentsDescriptions[1] = "vitesse selon y" ;
+ ComponentsDescriptions[2] = "vitesse selon z" ;
+ myField.setComponentsDescriptions(ComponentsDescriptions) ;
+
+ string * ComponentsUnits = new string[NumberOfCompoennts] ;
+ ComponentsUnits[0] = "m.s-1" ;
+ ComponentsUnits[1] = "m.s-1" ;
+ ComponentsUnits[2] = "m.s-1" ;
+ myField.setMEDComponentsUnits(ComponentsUnits) ;
+
+ // Iteration information :
+ int IterationNumber = 10 ; // set value to MED_NOPDT if undefined (default)
+ myField.setIterationNumber(IterationNumber) ;
+
+ int OrderNumber = 1 ; // set value to MED_NONOR if undefined (default)
+ myField.setOrderNumber(OrderNumber) ;
+
+ double Time = 3.435678 ; // in second
+ myField.setTime(Time) ;
+
+ // Value :
+ int NumberOfValue = mySupport->getNumberOfElements(MED_ALL_ELEMENTS);
+ for(int i=1; i<=NumberOfValue; i++) // i^th element
+ for (int j=1; j<=NumberOfCompoennts; j++) { // j^th component
+ double myValue = (i+j) * 0.1 ;
+ myField.setValueIJ(i,j,myValue);
+ }
+
+ // save this new field
+ int id = myField.addDriver(MED_DRIVER) ;
+
+ return 0 ;
+}
--- /dev/null
+######################################################################
+# #
+# This Python script should be executed when the shared library is #
+# generated using SWIG 1.3 (or higher) due to the fact that older #
+# version could not handle the wrapping of several class constructor #
+# #
+######################################################################
+from libMEDMEM_Swig import *
+
+MedFile = "pointe.med"
+meshName = "maa1"
+
+myMesh = MESH(MED_DRIVER,MedFile,meshName)
+
+mySupport = SUPPORT(myMesh,"Support on all CELLs",MED_CELL)
+
+numberOfComponents = 3
+myField = FIELDDOUBLE(mySupport,numberOfComponents)
+fieldName = "fieldcelldouble"
+myField.setName(fieldName)
+
+for i in range(numberOfComponents):
+ if (i == 0):
+ name = "Vx"
+ desc = "vitesse selon x"
+ elif (i == 1):
+ name = "Vy"
+ desc = "vitesse selon y"
+ else:
+ name = "Vz"
+ desc = "vitesse selon z"
+ unit = "m. s-1"
+ ip1 = i+1
+ myField.setComponentName(ip1,name)
+ myField.setComponentDescription(ip1,desc)
+ myField.setMEDComponentUnit(ip1,unit)
+
+iterationNumber = 10
+myField.setIterationNumber(iterationNumber)
+
+orderNumber = 1
+myField.setOrderNumber(orderNumber)
+
+time = 3.435678
+myField.setTime(time)
+
+numberOfValue = mySupport.getNumberOfElements(MED_ALL_ELEMENTS)
+
+for i in range(numberOfValue):
+ ip1 = i+1
+ for j in range(numberOfComponents):
+ jp1 = j+1
+ value = (ip1+jp1)*0.1
+ myField.setValueIJ(ip1,jp1,value)
+
+id = myField.addDriver(MED_DRIVER)
--- /dev/null
+using namespace std;
+#include "MEDMEM_Mesh.hxx"
+#include "MEDMEM_Field.hxx"
+
+using namespace MEDMEM;
+
+int main (int argc, char ** argv) {
+
+ const string MedFile = "pointe.med" ;
+ const string MeshName = "maa1" ;
+ const string FieldName = "fieldcelldoublevector" ;
+
+ /* read MESH */
+ MESH * myMesh = new MESH(MED_DRIVER,MedFile,MeshName) ;
+ // myMesh->read() ;
+
+ /* read FIELD */
+ // we need a support :
+ SUPPORT * mySupport = new SUPPORT(myMesh,"Support on all Cells",MED_CELL);
+ FIELD<double> myField(mySupport,MED_DRIVER,MedFile,FieldName) ;
+ // myField.read() ;
+
+ /* what in Field ? */
+ // How many components
+ int NumberOfCompoennts = myField.getNumberOfComponents() ;
+
+ const string * ComponentsNames = myField.getComponentsNames();
+ const string * ComponentsDescriptions = myField.getComponentsDescriptions();
+ const string * ComponentsUnits = myField.getMEDComponentsUnits();
+
+ for(int i=0;i<NumberOfCompoennts; i++) {
+ cout << "Component " << i << " :" <<endl ;
+ cout << " - name : " << ComponentsNames[i] << endl ;
+ cout << " - description : " << ComponentsDescriptions[i] << endl ;
+ cout << " - unit : " << ComponentsUnits[i] << endl ;
+ }
+
+ // Which iteration :
+ int IterationNumber = myField.getIterationNumber() ; // negative mean undefined
+ int OrderNumber = myField.getOrderNumber() ;
+ // internal iteration at this time iteration, negative mean undefined
+ double Time = myField.getTime() ;
+
+ cout << "Iteration " << IterationNumber << " at time " << Time <<
+ " (and order number " << OrderNumber << ")" << endl ;
+
+ // How many Value :
+ int NumberOfValue = mySupport->getNumberOfElements(MED_ALL_ELEMENTS);
+ // Value
+ const double * Value = myField.getValue(MED_FULL_INTERLACE);
+ for(int i=0; i<NumberOfValue; i++) {
+ for(int j=0; j<NumberOfCompoennts; j++)
+ cout << Value[i*NumberOfCompoennts+j] << " " ;
+ cout << endl ;
+ }
+
+ delete mySupport;
+ delete myMesh;
+
+ return 0 ;
+}
--- /dev/null
+######################################################################
+# #
+# This Python script should be executed when the shared library is #
+# generated using SWIG 1.3 (or higher) due to the fact that older #
+# version could not handle the wrapping of several class constructor #
+# #
+######################################################################
+from libMEDMEM_Swig import *
+
+MedFile = "pointe.med"
+meshName = "maa1"
+fieldName = "fieldcelldouble"
+
+myMesh = MESH(MED_DRIVER,MedFile,meshName)
+
+mySupport = SUPPORT(myMesh,"Support on CELLs",MED_CELL)
+
+myField = FIELDDOUBLE(mySupport,MED_DRIVER,MedFile,fieldName)
+
+numberOfComponents = myField.getNumberOfComponents()
+
+for i in range(numberOfComponents):
+ ip1 = i+1
+ name = myField.getComponentName(ip1)
+ desc = myField.getComponentDescription(ip1)
+ unit = myField.getMEDComponentUnit(ip1)
+
+ print "Component ",ip1
+ print " - name : ",name
+ print " - decription : ",desc
+ print " - unit : ", unit
+
+iterationNumber = myField.getIterationNumber()
+orderNumber = myField.getOrderNumber()
+time = myField.getTime()
+print "Iteration ",iterationNumber," at time ",time,\
+ " (and order number ",orderNumber,")"
+
+numberOfValue = mySupport.getNumberOfElements(MED_ALL_ELEMENTS)
+value = myField.getValue(MED_FULL_INTERLACE)
+
+for i in range(numberOfValue):
+ print " * ",value[i*numberOfComponents:(i+1)*numberOfComponents]
--- /dev/null
+Within MEDMEM_GenDriver.hxx :
+ /* Modify the following line to add a new driver type (step 1) */
+ typedef enum { MED_DRIVER = 0, GIBI_DRIVER = 1, VTK_DRIVER = 254, NO_DRIVER = 255 } driverTypes;
+
+Note : MED Drivers with no Mesh or Field drivers must have a number of 255-i !
+
+Within MEDMEM_Object.hxx
+ // Add your personnal driver header & line (step 2)
+ // At least one line must exist
+ // You have to respect the syntax.
+ #include "MEDMEM_TypeObjectDriver.hxx"
+
+ friend class MED_OBJECT_RDONLY_DRIVER;
+ friend class MED_OBJECT_WRONLY_DRIVER;
+ friend class MED_OBJECT_RDWR_DRIVER;
+
+ // Add a similar line for your personnal driver (step 3)
+ static INSTANCE_DE<MED_OBJECT_RDWR_DRIVER> inst_med ;
+
+Within MEDMEM_Object.cxx
+ // Add a similar line for your personnal driver (step 3)
+ static INSTANCE_DE<MED_OBJECT_RDWR_DRIVER> inst_med ;
+
+ // Add your own driver in the driver list (step 4)
+ // Note the list must be coherent with the driver type list defined in MEDMEM_DRIVER.hxx.
+ const OBJECT::INSTANCE * const OBJECT::instances[] = { &OBJECT::inst_med } ;
+
+Within MEDMEM_TypeObjectDriver.hxx (ypu can use MEDMEM_TypeObjectDriver.hxx as a pattern for your driver !)
+
+ // Faux : you have to create at least create a TYPE_OBJECT_RDWR_DRIVER even if it only throw an exception
+ // Faux : because RDONLY or WRONLY doesn't exists.
+
+ Whatever is your driver : RDONLY,WRONLY,RDWR, you must inplement the write & read methods ( even if it only throw an exception)
+
+TODO :
+
+Gerer l'appartenance d'un driver type 3 Within l'objet
+
+Within les méthodes addDriver :
+ driver = instances[driverType]->run(fileName, this) ; --> Il faut vérifier que le numéro auquel on accède existe !
--- /dev/null
+#include "MEDMEM_Exception.hxx"
+#include "MEDMEM_define.hxx"
+
+#include "MEDMEM_Field.hxx"
+#include "MEDMEM_Mesh.hxx"
+#include "MEDMEM_Med.hxx"
+
+main () {
+
+ const char * fileName = "pointe.med";
+ const char * fieldName = "fieldcelldouble";
+ const char * meshName = "maa1";
+
+ try {
+
+ // Test creation of drivers at object Creation time
+
+ //This test failed due to inadequate Support implementation
+ // FIELD<double> myField (MED_DRIVER,fileName,fieldName);
+ MESH myMesh (MED_DRIVER,fileName,meshName);
+ MED myMed (MED_DRIVER,fileName);
+
+ // Test removal of drivers
+ //myField.rmDriver();
+ myMesh.rmDriver ();
+ myMed.rmDriver ();
+
+ } catch (MEDEXCEPTION& ex){
+ MESSAGE(ex.what()) ;
+ }
+}
--- /dev/null
+######################################################################
+# #
+# This Python script should be executed when the shared library is #
+# generated using SWIG 1.3 (or higher) due to the fact that older #
+# version could not handle the wrapping of several class constructor #
+# #
+######################################################################
+from libMEDMEM_Swig import *
+
+medFile = "pointe.med"
+fieldName = "fieldcelldouble"
+meshName = "maa1"
+
+try:
+ print "Creation of MESH object"
+ myMesh = MESH(MED_DRIVER,medFile,meshName)
+
+ print "Creation of MED object"
+ myMed = MED(MED_DRIVER,medFile)
+
+ print "Test the driver removal dor MESH"
+ myMesh.rmDriver()
+
+ print "Test the driver removal dor MED"
+ myMed.rmDriver()
+
+ print "End of Python script"
+
+except:
+ print "There is a problem somewhere !!"
+ print "Consult the error standart output of the python execution !!"
--- /dev/null
+#include "MEDMEM_Exception.hxx"
+#include "MEDMEM_define.hxx"
+
+#include "MEDMEM_Field.hxx"
+#include "MEDMEM_Mesh.hxx"
+#include "MEDMEM_Med.hxx"
+
+main () {
+
+ const char * fileName = "pointe.med";
+ const char * fileName2 = "Field&MeshGeneratedPointe.med";
+ const char * fileName3 = "MedGeneratedPointe.med";
+ const char * fieldName = "fieldcelldouble";
+ const char * meshName = "maa1";
+
+ try {
+ // Test creation of drivers from the standard driver method of an object
+ {
+ FIELD<double> * myField = new FIELD<double>();
+ MED_FIELD_RDONLY_DRIVER<double> myRdOnlyDriver(fileName,myField);
+ myRdOnlyDriver.setFieldName(fieldName);
+ myRdOnlyDriver.open();
+ //This test failed due to inadequate Support implementation
+ // myRdOnlyDriver.read();
+ // try { myRdOnlyDriver.write(); } catch (MEDEXCEPTION& ex)
+ // { MESSAGE(ex.what()); }
+ MED_FIELD_WRONLY_DRIVER<double> myWrOnlyDriver(fileName2,myField);
+ myWrOnlyDriver.open();
+ //This test failed due to inadequate Support implementation
+ // myWrOnlyDriver.write();
+ // try myWrOnlyDriver.read(); catch (MEDEXCEPTION& ex)
+ // { MESSAGE(ex.what()); }
+ myRdOnlyDriver.close();
+ myWrOnlyDriver.close();
+ delete myField;
+ }
+
+ {
+ MESH * myMesh = new MESH();
+ MED_MESH_RDONLY_DRIVER myRdOnlyDriver(fileName,myMesh);
+ myRdOnlyDriver.setMeshName(meshName);
+ myRdOnlyDriver.open();
+ myRdOnlyDriver.read();
+ myRdOnlyDriver.close();
+ // try { myRdOnlyDriver.write(); } catch (MEDEXCEPTION& ex)
+ // { MESSAGE(ex.what()); }
+ MED_MESH_WRONLY_DRIVER myWrOnlyDriver(fileName2,myMesh);
+ myWrOnlyDriver.setMeshName(meshName);
+ myWrOnlyDriver.open();
+ myWrOnlyDriver.write();
+ // try myWrOnlyDriver.read(); catch (MEDEXCEPTION& ex)
+ // { MESSAGE(ex.what()); }
+ // myRdOnlyDriver.close();
+ //While we use H5close() in the MESH/FIELD drivers, the next
+ //line will fail, because all files are previously closed !
+ myWrOnlyDriver.close();
+ delete myMesh;
+ }
+
+ {
+ MED * myMed = new MED();
+ MED_MED_RDONLY_DRIVER myRdOnlyDriver(fileName,myMed);
+ myRdOnlyDriver.open();
+ myRdOnlyDriver.readFileStruct();
+ myRdOnlyDriver.close();
+ myMed->updateSupport(); // DOIT ETRE SUPPRIMEE
+ // myRdOnlyDriver.read();
+ // try { myRdOnlyDriver.write(); } catch (MEDEXCEPTION& ex)
+ // { MESSAGE(ex.what()); }
+ //MED_MED_WRONLY_DRIVER myWrOnlyDriver(fileName3,myMed);
+ //myWrOnlyDriver.open();
+ //myWrOnlyDriver.write(); // Not implemented yet.
+ //myWrOnlyDriver.close();
+ delete myMed;
+ }
+
+ } catch (MEDEXCEPTION& ex){
+ cout << "MAIN BLOCK EXCEPTION" << endl;
+ MESSAGE(ex.what()) ;
+ }
+}
--- /dev/null
+######################################################################
+# #
+# This Python script should be executed when the shared library is #
+# generated using SWIG 1.3 (or higher) due to the fact that older #
+# version could not handle the wrapping of several class constructor #
+# #
+######################################################################
+from libMEDMEM_Swig import *
+
+medFile = "pointe.med"
+medFile2 = "Field&MeshGeneratedPointe.med"
+fieldName = "fieldcelldouble"
+meshName = "maa1"
+
+try:
+ myField = FIELDDOUBLE()
+ myRdOnlyDriver = MED_FIELDDOUBLE_RDONLY_DRIVER(medFile,myField)
+ myRdOnlyDriver.setFieldName(fieldName)
+ myRdOnlyDriver.open()
+
+ myWrOnlyDriver = MED_FIELDDOUBLE_WRONLY_DRIVER(medFile2,myField)
+ myWrOnlyDriver.open()
+
+ myRdOnlyDriver.close()
+ myWrOnlyDriver.close()
+
+ print "Invoking field drivers OK"
+except :
+ print "there is a problem in invoking field drivers !!"
+ print "Please consult the error standart output of the python execution !!"
+
+try:
+ myMesh = MESH()
+ myRdOnlyDriver = MED_MESH_RDONLY_DRIVER(medFile,myMesh)
+ myRdOnlyDriver.setMeshName(meshName)
+ myRdOnlyDriver.open()
+ myRdOnlyDriver.read()
+ myRdOnlyDriver.close()
+
+ myWrOnlyDriver = MED_MESH_WRONLY_DRIVER(medFile,myMesh)
+ myWrOnlyDriver.setMeshName(meshName)
+ myWrOnlyDriver.open()
+ myWrOnlyDriver.write()
+
+ myWrOnlyDriver.close()
+
+ print "Invoking mesh drivers OK"
+except :
+ print "there is a problem in invoking mesh drivers !!"
+ print "Please consult the error standart output of the python execution !!"
+
+try:
+ myMed = MED()
+ myRdOnlyDriver = MED_MED_RDONLY_DRIVER(medFile,myMed)
+ myRdOnlyDriver.open()
+ myRdOnlyDriver.readFileStruct()
+ myRdOnlyDriver.close()
+ myMed.updateSupport()
+
+ print "Invoking Med drivers OK"
+except :
+ print "There is a problem in invoking MED drivers !!"
+ print "Please consult the error standart output of the python execution !!"
--- /dev/null
+#include "MEDMEM_Exception.hxx"
+#include "MEDMEM_define.hxx"
+
+#include "MEDMEM_Field.hxx"
+#include "MEDMEM_Mesh.hxx"
+#include "MEDMEM_Med.hxx"
+
+main () {
+
+ const char * fileName = "pointe.med";
+ const char * fileName2 = "fieldCellDoubleOfpointe.med";
+ const char * fieldName = "fieldcelldouble";
+ const char * meshName = "maa1";
+
+ try {
+ // Test creation of drivers from the standard driver method of an object
+ FIELD<double> * myField = new FIELD<double>();
+ int myDriver1 = myField->addDriver(MED_DRIVER, fileName, fieldName);
+ //myField->read();
+ //This test failed due to inadequate Support implementation
+ myField->rmDriver(); // TESTER LA VALIDITE DE myDriver2 !!!!
+
+ int myDriver2 = myField->addDriver(MED_DRIVER, fileName2, fieldName);
+ //myField->write(myDriver2);
+ //This test failed due to inadequate Support implementation
+ myField->rmDriver(myDriver2);
+
+ MESH * myMesh = new MESH();
+ int myDriver3 = myMesh->addDriver(MED_DRIVER, fileName, meshName);
+ myMesh->read();
+ myMesh->rmDriver();
+
+ MED * myMed = new MED();
+ int myDriver4 = myMed->addDriver(MED_DRIVER, fileName);
+ myMed->readFileStruct();
+ myMed->rmDriver();
+
+ delete myField;
+ delete myMesh;
+ delete myMed;
+
+ } catch (MEDEXCEPTION& ex){
+ MESSAGE(ex.what()) ;
+ }
+}
--- /dev/null
+######################################################################
+# #
+# This Python script should be executed when the shared library is #
+# generated using SWIG 1.3 (or higher) due to the fact that older #
+# version could not handle the wrapping of several class constructor #
+# #
+######################################################################
+from libMEDMEM_Swig import *
+
+medFile = "pointe.med"
+medFile2 = "fieldCellDoubleOfpointe.me"
+fieldName = "fieldcelldouble"
+meshName = "maa1"
+
+try:
+ myField = FIEDLDOUBLE()
+
+ myDriver1 = myField->addDriver(MED_DRIVER,medFile,fieldName)
+ myField.rmDriver()
+
+ myDriver2 = myField->addDriver(MED_DRIVER,medFile2,fieldName)
+ myField.rmDriver(myDriver2)
+
+ myMesh = MESH()
+ myDriver3 = myMesh->addDriver(MED_DRIVER,medFile,meshName)
+ myMesh.read()
+ myMesh.rmDriver()
+
+ myMed = MED()
+ myMed.readFileStruct()
+ myMed.rmDriver()
+
+except:
+ print "There is a problem somewhere !!"
+ print "Please consult the error standart output of the python execution !!"
--- /dev/null
+#include "MEDMEM_Exception.hxx"
+#include "MEDMEM_define.hxx"
+
+#include "MEDMEM_Field.hxx"
+#include "MEDMEM_Mesh.hxx"
+#include "MEDMEM_Med.hxx"
+
+main () {
+
+ const char * fileName = "pointe.med";
+ const char * fileName2 = "Field&MeshGeneratedPointe.med";
+ const char * fileName3 = "MedGeneratedPointe.med";
+ const char * fieldName1 = "fieldcelldouble";
+ const char * fieldName2 = "fieldcelldoublebis";
+ const char * meshName1 = "maa1";
+ const char * meshName2 = "maa1bis";
+
+ try {
+
+ // FAIRE LE TEST AVEC LES CHAMPS AUSSI !.
+
+ MESH myMesh(MED_DRIVER,fileName,meshName1);
+ myMesh.setName(meshName2);
+ myMesh.rmDriver();
+
+ MED myMed(MED_DRIVER,fileName);
+ myMed.read();
+ myMed.addMesh(&myMesh);
+ int myMedDriver = myMed.addDriver(MED_DRIVER,fileName3);
+ myMed.write(myMedDriver);
+
+ // FAIRE LE TEST AVEC LES CHAMPS AUSSI !.
+
+ } catch (MEDEXCEPTION& ex){
+ MESSAGE(ex.what()) ;
+ }
+}
--- /dev/null
+#LyX 1.1 created this file. For more info see http://www.lyx.org/
+\lyxformat 218
+\textclass report
+\begin_preamble
+% Packages
+%%\usepackage[french]{babel}
+%\usepackage[T1]{fontenc}
+%\usepackage{epsf}
+%\usepackage[dvips]{graphicx}
+%\usepackage{fancyhdr}
+%\usepackage{pslatex}
+
+\usepackage[dvips,all,light]{draftcopy}
+
+\usepackage{verbatim}
+
+% ____________________________________________________________________________
+% | |
+% | MISE EN PAGE |
+% |____________________________________________________________________________|
+
+\draftcopyName{Projet}{200}
+
+\setlength{\oddsidemargin}{0cm}
+\setlength{\marginparsep}{0cm}
+\setlength{\marginparwidth}{0cm}
+
+\setlength{\textwidth}{15cm}
+
+\setlength{\topmargin}{0cm}
+\setlength{\headheight}{0cm}
+\setlength{\headsep}{0cm}
+
+\setlength{\textheight}{23cm}
+
+% ____________________________________________________________________________
+% | |
+% | COMMANDES UTILISATEUR |
+% |____________________________________________________________________________|
+
+\newcommand{\method}[1]{method \mbox{\textbf{#1}}}
+
+\newcommand{\myref}[1]{\ref{#1}, page \pageref{#1}}
+
+\newcommand{\fileCxx}[1]{
+ \subsection{Full C++ example~: }
+ \label{#1}
+ \verbatiminput{#1}
+}
+
+\newcommand{\filePython}[1]{
+ \subsection{Full Python example~: }
+ \label{#1}
+ \verbatiminput{#1}
+}
+
+% ____________________________________________________________________________
+% | |
+% | LE DOCUMENT |
+% |____________________________________________________________________________|
+%
+\title{User's Guide Of Med Memory}
+\author{Patrick GOLDBRONN \and Eric Fayolle \and Nadir Bouhamou}
+
+% ____________________________________________________________________________
+% | |
+% | DEBUT DU DOCUMENT |
+% |____________________________________________________________________________|
+%
+\end_preamble
+\language english
+\inputencoding auto
+\fontscheme default
+\graphics default
+\paperfontsize 11
+\spacing single
+\papersize a4paper
+\paperpackage a4
+\use_geometry 0
+\use_amsmath 0
+\paperorientation portrait
+\secnumdepth 3
+\tocdepth 3
+\paragraph_separation skip
+\defskip medskip
+\quotes_language english
+\quotes_times 2
+\papercolumns 1
+\papersides 1
+\paperpagestyle default
+
+\layout Standard
+
+
+\latex latex
+
+\backslash
+sloppy
+\layout Standard
+
+
+\latex latex
+
+\backslash
+cleardoublepage
+\newline
+
+\latex default
+
+\begin_inset LatexCommand \tableofcontents{}
+
+\end_inset
+
+
+\layout Chapter
+
+Convention
+\layout Itemize
+
+All numbering begin at one (take care of array index !) ;
+\layout Itemize
+
+When you get a C type array with a
+\family typewriter
+get...
+
+\family default
+ method, you must not replace some value of it.
+ Access is in read only.
+ Other use may product an impredicable result.
+ To modify a such array use method
+\family typewriter
+set...
+\family default
+.
+
+\layout Itemize
+
+Difference between local and global number\SpecialChar ~
+: when we talk about an element
+ number, we could see
+\begin_inset Formula \( i^{th} \)
+\end_inset
+
+ quadrangle (
+\begin_inset Formula \( i^{th} \)
+\end_inset
+
+ in quadrangles array\SpecialChar ~
+: local numbering) or
+\begin_inset Formula \( j^{th} \)
+\end_inset
+
+ element (
+\begin_inset Formula \( j^{th} \)
+\end_inset
+
+ in all elements array\SpecialChar ~
+: global numbering).
+ This two numbering are equivalent only if we have one geometric type.
+\layout Chapter
+
+How to use MESH object
+\layout Section
+
+General Information
+\layout Standard
+
+We could get some general information about a MESH object such as\SpecialChar ~
+:
+\layout Itemize
+
+name (
+\latex latex
+
+\backslash
+method{getName}
+\latex default
+)
+\layout Itemize
+
+a description (
+\latex latex
+
+\backslash
+method{getDescription}
+\latex default
+)
+\layout Itemize
+
+the space dimension (
+\latex latex
+
+\backslash
+method{getSpaceDimension}
+\latex default
+)
+\layout Itemize
+
+the mesh dimension (
+\latex latex
+
+\backslash
+method{getMeshDimension}
+\latex default
+)
+\layout Standard
+
+
+\latex latex
+
+\backslash
+fileCxx{MESHgeneral.cxx}
+
+\backslash
+filePython{MESHgeneral.py}
+\layout Section
+
+Information about nodes
+\layout Enumerate
+
+I want to get the number of nodes\SpecialChar ~
+: Realy simple, use
+\latex latex
+
+\backslash
+method{getNumberOfNodes}
+\latex default
+.
+
+\layout Enumerate
+
+I want to get the coordinates components names\SpecialChar ~
+: use
+\latex latex
+
+\backslash
+method{getCoordinatesNames}
+\latex default
+ which return a string array (one string for each space dimension)
+\layout Enumerate
+
+I want to get the coordinates components units\SpecialChar ~
+: use
+\latex latex
+
+\backslash
+method{getCoordinatesUnits}
+\latex default
+ which return a string array (one string for each space dimension)
+\layout Enumerate
+
+I want to get the coordinates system\SpecialChar ~
+: use
+\latex latex
+
+\backslash
+method{getCoordinatesSystem}
+\latex default
+ which return a string (
+\latex latex
+
+\backslash
+verb+CARTESIAN+
+\latex default
+,
+\latex latex
+
+\backslash
+verb+CYLINDRICAL+
+\latex default
+ or
+\latex latex
+
+\backslash
+verb+SPHERICAL+
+\latex default
+).
+
+\layout Enumerate
+
+I want to get the nodes coordinates\SpecialChar ~
+: use
+\latex latex
+
+\backslash
+method{getCoordinates}
+\latex default
+ which return a pointer to the coordinates array where values are interlace
+ or no.
+
+\series bold
+Warning\SpecialChar ~
+:
+\begin_deeper
+\layout Itemize
+
+When we get coordinates in
+\latex latex
+
+\backslash
+verb+MED_NO_INTERLACE+
+\latex default
+ mode, we get an array where values are ordered like (
+\latex latex
+
+\backslash
+verb+X1,X2,X..., Y1,Y..., Z1,Z...+
+\latex default
+).
+
+\layout Itemize
+
+When we get coordinates in
+\latex latex
+
+\backslash
+verb+MED_FULL_INTERLACE+
+\latex default
+ mode, we get an array where values are ordered like (
+\latex latex
+
+\backslash
+verb+X1,Y1,Z1, X2,Y2,Z2, ...+
+\latex default
+).
+
+\end_deeper
+\layout Enumerate
+
+I want to get one particular value of coordinate\SpecialChar ~
+: use
+\latex latex
+
+\backslash
+method{getCoordinate}
+\latex default
+ which return the value of
+\begin_inset Formula \( i^{th} \)
+\end_inset
+
+ node and
+\begin_inset Formula \( j^{th} \)
+\end_inset
+
+ axis.
+\layout Standard
+
+
+\latex latex
+
+\backslash
+fileCxx{MESHcoordinates.cxx}
+
+\backslash
+filePython{MESHcoordinates.py}
+\layout Section
+
+Information about cells
+\layout Enumerate
+
+I want to get the number of geometric type for a mesh entity\SpecialChar ~
+: use
+\latex latex
+
+\backslash
+method{getNumberOfTypes}
+\begin_deeper
+\layout Standard
+
+
+\series bold
+C++ Example\SpecialChar ~
+:
+\layout Standard
+
+
+\latex latex
+
+\backslash
+verb+int NumberOfCellsTypes = myMesh.getNumberOfTypes(MED_CELL);+
+\end_deeper
+\layout Enumerate
+
+I want to get all geometric type for a mesh entity\SpecialChar ~
+: use
+\latex latex
+
+\backslash
+method{getTypes}
+\latex default
+ to get an array of
+\latex latex
+
+\backslash
+verb+medGeometryElement+
+\latex default
+ (to use directly in others methods) or
+\latex latex
+
+\backslash
+method{getCellsTypes}
+\latex default
+ to get an array of
+\latex latex
+
+\backslash
+verb+CELLMODEL+
+\latex default
+ (to ask mode information\SpecialChar ~
+: see CellModel) .
+\begin_deeper
+\layout Standard
+
+
+\series bold
+C++ Example\SpecialChar ~
+:
+\layout Standard
+
+
+\latex latex
+
+\backslash
+verb+medGeometryElement * Types = myMesh.getTypes(MED_CELL);+
+\layout Standard
+
+
+\latex latex
+
+\backslash
+verb+CELLMODEL * CellsTypes = myMesh.getCellsTypes(MED_CELL);+
+\layout Standard
+
+(each arrays are size
+\latex latex
+
+\backslash
+verb+NumberOfCellsTypes+
+\latex default
+)
+\end_deeper
+\layout Enumerate
+
+I want to get the number of cells\SpecialChar ~
+: use
+\latex latex
+
+\backslash
+method{getNumberOfElements}
+\latex default
+ which return this information.
+ You must give the mesh entity (
+\latex latex
+
+\backslash
+verb+MED_CELL+
+\latex default
+,
+\latex latex
+
+\backslash
+verb+MED_FACE+
+\latex default
+,
+\latex latex
+
+\backslash
+verb+MED_EDGE+
+\latex default
+ or
+\latex latex
+
+\backslash
+verb+MED_NODE+
+\latex default
+) and a geometric type of this entity.
+\begin_deeper
+\layout Standard
+
+
+\series bold
+C++ Example\SpecialChar ~
+:
+\layout Standard
+
+
+\latex latex
+
+\backslash
+verb+int NumberOfTriangle = myMesh.getNumberOfElements(MED_FACE,MED_TRIA3);+
+\layout Standard
+
+
+\latex latex
+
+\backslash
+verb+int NumberOfFace = myMesh.getNumberOfElements(MED_FACE,MED_ALL_ELEMENT);+
+\end_deeper
+\layout Enumerate
+
+I want to get the geometric type of one element\SpecialChar ~
+: use
+\latex latex
+
+\backslash
+method{getElementType}
+\latex default
+ which return a
+\latex latex
+
+\backslash
+verb+medGeometryElement+
+\latex default
+.
+\begin_deeper
+\layout Standard
+
+
+\series bold
+C++ Example\SpecialChar ~
+:
+\layout Standard
+
+
+\latex latex
+
+\backslash
+verb+medGeometryElement myType = myMesh.getElementType(MED_FACE,10);+
+\layout Standard
+
+Return the
+\latex latex
+
+\backslash
+verb+medGeometryElement+
+\latex default
+ of
+\begin_inset Formula \( 10^{th} \)
+\end_inset
+
+ face.
+\end_deeper
+\layout Enumerate
+
+I want to get a connectivity\SpecialChar ~
+: use
+\latex latex
+
+\backslash
+method{getConnectivity}
+\latex default
+ which return an array with connectivity values.
+\begin_deeper
+\layout Standard
+
+
+\begin_inset LatexCommand \label{getConnectivity}
+
+\end_inset
+
+
+\layout Standard
+
+
+\series bold
+C++ Example\SpecialChar ~
+:
+\layout Standard
+
+
+\latex latex
+
+\backslash
+begin{verbatim}
+\newline
+int NumberOfTetrahedron = myMesh.getNumberOfElements(MED_CELL,MED_TETRA4);
+\newline
+int * TetrahedronConnectivity =
+\newline
+ myMesh.getConnectivity(MED_FULL_ENTERLACE,
+\newline
+ MED_NODAL,
+\newline
+ MED_CELL,
+\newline
+ MED_TETRA4);
+\newline
+
+\backslash
+end{verbatim}
+\backslash
+verb+TetrahedronConnectivity+
+\latex default
+ contain nodal connectivity of tetrahedron in mesh.
+ It is arranged in full enterlace mode and its size is
+\latex latex
+
+\backslash
+verb+NumberOfTetrahedron x 4+
+\latex default
+.
+\layout Standard
+
+If you want to get connectivity of all elements (with
+\latex latex
+
+\backslash
+verb+Type=MED_ALL_ELEMENTS+
+\latex default
+), you must use the index array (return by
+\latex latex
+
+\backslash
+method{getConnectivityIndex}
+\latex default
+) to get connectivity for each elements (see example
+\latex latex
+
+\backslash
+myref{MESHconnectivities.cxx}
+\latex default
+).
+\end_deeper
+\layout Enumerate
+
+I want to get an element number from a connectivity\SpecialChar ~
+: use
+\latex latex
+
+\backslash
+method{getElementNumber}
+\latex default
+ which return the global number of a given connectivity.
+\begin_deeper
+\layout Standard
+
+
+\series bold
+C++ Example\SpecialChar ~
+:
+\layout Standard
+
+
+\latex latex
+
+\backslash
+verb+int * myElementConnectivity = {2,10,12,14};+
+\layout Standard
+
+
+\latex latex
+
+\backslash
+verb+int myNumber = myMesh.getElementNumber(MED_NODAL,MED_CELL,myElementConnectiv
+ity);+
+\end_deeper
+\layout Standard
+
+
+\latex latex
+
+\backslash
+fileCxx{MESHconnectivities.cxx}
+
+\backslash
+filePyhton{MESHconnectivities.py}
+\layout Chapter
+
+How to use SUPPORT object
+\layout Section
+
+Create a SUPPORT object
+\layout Standard
+
+
+\begin_inset LatexCommand \label{CreateSupport}
+
+\end_inset
+
+
+\layout Standard
+
+To create a SUPPORT object, you must give :
+\layout Itemize
+
+a reference to a MESH object
+\layout Itemize
+
+its name
+\layout Itemize
+
+on which mesh entity it apply to
+\layout Standard
+
+
+\series bold
+C++ example\SpecialChar ~
+:
+\layout Standard
+
+
+\latex latex
+
+\backslash
+verb+SUPPORT mySupport(myMesh,''support sur toute les faces'',MED_FACE)
+ ;+
+\latex default
+ By default, this support is defined on all element of the given entity.
+\layout Standard
+
+If you want a restricted SUPPORT, you must add manualy information about
+ what do you want\SpecialChar ~
+:
+\layout Itemize
+
+is not on all elements\SpecialChar ~
+:
+\latex latex
+
+\backslash
+verb+mySupport.setAll(false);+
+\layout Itemize
+
+on how many geometric type\SpecialChar ~
+:
+\newline
+
+\latex latex
+
+\backslash
+verb+mySupport.setNumberOfGeometricType(myNumberOfGeometricType);+
+\layout Itemize
+
+on which geometric type\SpecialChar ~
+:
+\newline
+
+\latex latex
+
+\backslash
+verb+mySupport.setGeometricType(myGeometricType);+
+\layout Itemize
+
+Temporary : the Gauss point number for each geometric type\SpecialChar ~
+:
+\newline
+
+\latex latex
+
+\backslash
+verb+mySupport.setNumberOfGaussPoint(myNumberOfGaussPoint);+
+\layout Itemize
+
+the number of elements for each geometric type\SpecialChar ~
+:
+\newline
+
+\latex latex
+
+\backslash
+verb+mySupport.setNumberOfEntities(myNumberOfEntities);+
+\layout Itemize
+
+the total number of elements\SpecialChar ~
+:
+\newline
+
+\latex latex
+
+\backslash
+verb+mySupport.setTotalNumberOfEntities(myTotalNumberOfEntities);+
+\layout Itemize
+
+the array which contains elements for each geometric type\SpecialChar ~
+:
+\newline
+
+\latex latex
+
+\backslash
+verb+mySupport.setNumber(myNumber);+
+\layout Standard
+
+You could also use
+\latex latex
+
+\backslash
+method{setpartial}
+\latex default
+ which set all you need.
+\layout Section
+
+Use a SUPPORT object
+\layout Standard
+
+You could get all basic information (as you set them in
+\latex latex
+
+\backslash
+myref{CreateSupport}
+\latex default
+)\SpecialChar ~
+:
+\layout Itemize
+
+
+\latex latex
+
+\backslash
+verb+getName()+
+\layout Itemize
+
+
+\latex latex
+
+\backslash
+verb+getDescription()+
+\layout Itemize
+
+
+\latex latex
+
+\backslash
+verb+getMesh()+
+\layout Itemize
+
+
+\latex latex
+
+\backslash
+verb+getEntity()+
+\layout Itemize
+
+
+\latex latex
+
+\backslash
+verb+isOnAllElements()+
+\layout Itemize
+
+
+\latex latex
+
+\backslash
+verb+getNumberOfTypes()+
+\layout Itemize
+
+
+\latex latex
+
+\backslash
+verb+getTypes()+
+\layout Itemize
+
+
+\latex latex
+
+\backslash
+verb+getNumberOfGaussPoint()+
+\layout Itemize
+
+
+\latex latex
+
+\backslash
+verb+getNumberOfGaussPoint(myGeometricType)+
+\layout Itemize
+
+
+\latex latex
+
+\backslash
+verb+getGeometricTypeNumber()+
+\layout Itemize
+
+
+\latex latex
+
+\backslash
+verb+getNumberOfElements(myGeometricType)+
+\layout Itemize
+
+
+\latex latex
+
+\backslash
+verb+getNumber(myGeometricType)+
+\layout Itemize
+
+
+\latex latex
+
+\backslash
+verb+getNumberIndex()+
+\layout Standard
+
+For details about this methods, see the reference manual
+\begin_inset LatexCommand \ref{RefManual}
+
+\end_inset
+
+.
+\layout Standard
+
+The use of
+\latex latex
+
+\backslash
+method{getNumber}
+\latex default
+ and
+\latex latex
+
+\backslash
+method{getNumberIndex}
+\latex default
+ are the same as
+\latex latex
+
+\backslash
+method{getConnectivity}
+\latex default
+ and
+\latex latex
+
+\backslash
+method{getConnectivityIndex}
+\latex default
+ (see item
+\latex latex
+
+\backslash
+myref{getConnectivity}
+\layout Standard
+
+There is another particular method to blend another SUPPORT object into
+ it.
+\layout Standard
+
+For exemple in C++ :
+\latex latex
+
+\backslash
+begin{verbatim}
+\newline
+SUPPORT mySupport ;
+\newline
+SUPPORT myOtherSupport ;
+\newline
+...
+\newline
+mySupport.blending(myOtherSupport) ;
+\newline
+
+\backslash
+end{verbatim}
+\layout Standard
+
+
+\latex latex
+
+\backslash
+verb+mySupport+
+\latex default
+ contain now all elements defined originally in it, more those defined in
+
+\latex latex
+
+\backslash
+verb+myOtherSupport+
+\latex default
+.
+\layout Section
+
+Case of FAMILY object
+\layout Section
+
+Case of GROUP object
+\layout Chapter
+
+How to use Field
+\layout Standard
+
+
+\latex latex
+
+\backslash
+newpage
+\newline
+%
+\backslash
+thebibliography{biblio}
+\layout Standard
+\bibitem {RefManual}
+
+Reference Manual\SpecialChar ~
+:
+\latex latex
+http://www-drn2.cea.fr/MED/MEDMEM/DOC/html/index.html
+\layout Chapter
+
+Using drivers
+\layout Standard
+
+The generic driver mecanism gives users the possibility to write/read the
+ content of an object according to a specified file format.
+ The semantic remains the same whatever the object is (MESH, FIELD, MED).
+ By the way it allows using several file formats for writting an object.
+\layout Section
+
+Invoking a driver
+\layout Subsection
+
+Invoking a driver at creation object time
+\layout Standard
+
+This is the simplest way of invoking a driver.
+ The driver parameters are given to the constructor of the object.
+ Except for the MED object, this way of invoking a driver assume you know
+ exactly the name of the MESH/FIELD you want read from a file <fileName>
+ of type <driverType>.
+\layout Standard
+
+ex 1.1 : For a FIELD object, invoking FIELD<double> myField(MED_DRIVER,fileName,f
+ieldName) create a FIELD object and a driver which loads the mesh <fieldName>
+ from the MED file <fileName> (Not implemented yet !).
+\layout Standard
+
+ex 1.2 : To remove the default driver previously created myField->rmDriver();
+\layout Standard
+
+ex 2 : For a MESH object, invoking MESH myMesh(MED_DRIVER,fileName,meshName)
+ create a MESH object and a driver which loads the mesh <meshName> from
+ the MED file <fileName>.
+\layout Standard
+
+ex 3 : For a MED object, invoking MED myMed(MED_DRIVER,fileName) create
+ a MED object to explore the MED file <fileName>.
+\layout Standard
+
+rem 1 : ex1 is equivalent to
+\begin_inset LatexCommand \ref{sec:invoking_a_driver_from_the_std_drv_method}
+
+\end_inset
+
+ ex1.
+\layout Standard
+
+rem 2 : Since the driver has read the object, the associated file is closed.
+ You can reread the object with the default driver by calling the read()
+ method : myObject.read().
+\layout Standard
+
+
+\latex latex
+
+\backslash
+fileCxx{MEDMEM_InvokingDriverAtObjectCreationTime.cxx}
+\layout Subsection
+
+Invoking a driver from the standard driver method of an object
+\begin_inset LatexCommand \label{sec:invoking_a_driver_from_the_std_drv_method}
+
+\end_inset
+
+
+\layout Standard
+
+This way of invoking a driver give the possiblility to add several drivers
+ to an exiting object.
+\layout Standard
+
+ex1 : First we create a FIELD without any driver FIELD<double>\SpecialChar ~
+*\SpecialChar ~
+myField1\SpecialChar ~
+=\SpecialChar ~
+new\SpecialChar ~
+FIELD
+<double>; then we add a driver with int myDriver1 = myField1->addDriver(driverTy
+pe1, fileName1, fieldName1); for reading <fieldName1> from file <fileName1>
+ with myField1->read(myDriver1);
+\layout Standard
+
+ex2 : We add a new driver of type <driverType2> int myDriver2 = myField1->addDri
+ver(driverType2, fileName2,fieldName2); in order to write myField1 in file
+ <fileName2> with <fieldName2> name using command myField1->write(myDriver2);
+\layout Standard
+
+rem 1 : Files are openned then closed each time you call read() or write()
+ methods.
+\layout Standard
+
+rem 2 : If you use more than a driver you need to keep the driver handlers
+ (myDriverI ).
+\layout Standard
+
+
+\latex latex
+
+\backslash
+fileCxx{MEDMEM_InvokingDriverFromStandardObjectMethod.cxx}
+\layout Subsection
+
+Invoking a driver and attaching it to an existing object
+\layout Standard
+
+The methods exposed in the two previous sections always create drivers in
+ read/write access mode.
+ Another way of creating a driver is to create a driver with a specific
+ access mode.
+\layout Standard
+
+ex1 : First we create a FIELD without any driver FIELD<double>\SpecialChar ~
+*\SpecialChar ~
+myField1\SpecialChar ~
+=\SpecialChar ~
+new
+ FIELD<double>(); then we create a read-only driver MED_FIELD_RDONLY_DRIVER<doub
+le>\SpecialChar ~
+myRdOnlyDriver(fileName1,myField1); and attached it to myField1.
+ Finally you must set the fieldName1 you want to acess in fileName1 with
+ myRdOnlyDriver->setFieldName(fieldName1); in order to read the field with
+ myRdOnlyDriver->open(); myRdOnlyDriver->read();
+\layout Standard
+
+Don't forget to close the file with myRdOnlyDriver->close().
+\layout Standard
+
+ToDo : By now when you create such specific drivers, the object doesn't
+ know anything about it.
+
+\layout Standard
+
+
+\latex latex
+
+\backslash
+fileCxx{MEDMEM_InvokingDriverByAttachingItToAnObject.cxx}
+\layout Section
+
+Using the MED driver
+\layout Standard
+
+The MED object provides the ability of :
+\layout Enumerate
+\noindent
+Obtainning a reference on the whole structure contained in a file.
+\layout Enumerate
+
+Obtainning the list of all the Meshes/Fields names contained in a file.
+\layout Enumerate
+
+Obtainning a Mesh/Field reference using a name.
+\layout Enumerate
+
+Writting a whole set of independent objects with a simple command.
+
+\layout Subsection
+
+Exploring files
+\layout Standard
+
+In this first use case the user wants to explore the meshes & fields containned
+ within a file <filename> of type given by the <drivertype> parameter.
+\layout Standard
+
+ex 1 : Calling MED * myMed = new MED(driverType1, fileName1); create a MED
+ object which open fileName1, read all MESHes/FIELDs relations then close
+ the file.
+
+\layout Standard
+
+This is equivalent to MED\SpecialChar ~
+*\SpecialChar ~
+myMed\SpecialChar ~
+=\SpecialChar ~
+new\SpecialChar ~
+MED(); myDriver\SpecialChar ~
+=\SpecialChar ~
+myMed->addDriver(driverType1,
+fileName1); myMed->readFileStruct(myDriver);
+\layout Standard
+
+ex 2 : To get the list of meshNames from a MED object, first ask the object
+ how many meshes it had by calling int numberOfMeshes\SpecialChar ~
+=\SpecialChar ~
+myMed->getNumberOfMeshes()
+; then get the list with myMeshNames\SpecialChar ~
+=\SpecialChar ~
+new string[getMeshNames]; myMed->getMeshNam
+es(myMeshNames).
+
+\layout Standard
+
+Note you can also use the deque<string> getMeshNames() method.
+
+\layout Standard
+
+ex 3 : To get a list of fieldNames from a MED object, first ask the object
+ how many fields it had by calling int numberOfFields\SpecialChar ~
+=\SpecialChar ~
+myMed->getNumberOfFields()
+; then get the list with myFieldNames\SpecialChar ~
+=\SpecialChar ~
+new string[getFieldNames]; myMed->getField
+Names(myFieldNames).
+\layout Standard
+
+ex 4 :To get a particular MESH use MESH * myMesh1 = myMED->getMesh(myMeshNames[0
+])
+\layout Standard
+
+ex 5 :To get a particular FIELD you first need to know what (time step,
+ iteration number) list is used by calling deque<DT_IT_>\SpecialChar ~
+myField1DtIt\SpecialChar ~
+=\SpecialChar ~
+myMed->getF
+ieldIteration(FieldName[0]) ; then you can ask for getting a specific FIELD
+ with FIELD\SpecialChar ~
+*\SpecialChar ~
+myField1\SpecialChar ~
+=\SpecialChar ~
+myMED->getField(myFieldNames[0],myField1DtIt[0].dt,myField1D
+tIt[0].it).
+\layout Standard
+
+ex2 : To write the whole content of a MED object first add a driver myDriver2\SpecialChar ~
+=\SpecialChar ~
+my
+Med.addDriver(driverType2,\SpecialChar ~
+fileName2); then ask for writing the object myMed->writ
+e(myDriver2); (not implemented yet !)
+\layout Standard
+
+You can remove the driver with myMed->rmDriver(myDriver2);
+\layout Standard
+
+rem 1 : It is possible to use multiple drivers to read a set of FIELDs /
+ MESHes from various file formats and writing the whole set through a specific
+ write.(not implemented yet !)
+\layout Subsubsection
+
+Adding existing MESHes/FIELDs objects
+\layout Standard
+
+Not yet implemented.
+\the_end
--- /dev/null
+%% LyX 1.1 created this file. For more info, see http://www.lyx.org/.
+%% Do not edit unless you really know what you are doing.
+\documentclass[11pt,a4paper,english]{report}
+\usepackage[T1]{fontenc}
+\usepackage[latin1]{inputenc}
+\usepackage{babel}
+\usepackage{graphicx} \setcounter{secnumdepth}{3}
+\setcounter{tocdepth}{3}
+\setlength\parskip{\medskipamount}
+\setlength\parindent{0pt}
+
+\makeatletter
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% LyX specific LaTeX commands.
+\providecommand{\LyX}{L\kern-.1667em\lower.25em\hbox{Y}\kern-.125emX\@}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% User specified LaTeX commands.
+% Packages
+%%\usepackage[french]{babel}
+%\usepackage{epsf}
+%\usepackage[dvips]{graphicx}
+%\usepackage{fancyhdr}
+%\usepackage{pslatex}
+
+%\usepackage[dvips,all,light]{draftcopy}
+
+\usepackage{verbatim}
+
+% ___________________________________________________________________________
+% | |
+% | MISE EN PAGE |
+% |___________________________________________________________________________|
+%\draftcopyName{Projet}{200}
+
+\setlength{\oddsidemargin}{0cm}
+\setlength{\marginparsep}{0cm}
+\setlength{\marginparwidth}{0cm}
+
+\setlength{\textwidth}{16cm}
+
+\setlength{\topmargin}{0cm}
+\setlength{\headheight}{0cm}
+\setlength{\headsep}{0cm}
+
+\setlength{\textheight}{24cm}
+
+% ___________________________________________________________________________
+% | |
+% | COMMANDES UTILISATEUR |
+% |___________________________________________________________________________|
+
+\newcommand{\method}[1]{method \mbox{\textbf{#1}}}
+
+\newcommand{\myref}[1]{\ref{#1}, page \pageref{#1}}
+
+\newcommand{\fileCxx}[1]{
+ \subsection{Full C++ example~: }
+ \label{#1}
+ \verbatiminput{@srcdir@/#1}
+}
+
+\newcommand{\filePython}[1]{
+ \subsection{Full Python example~: }
+ \label{#1}
+ \verbatiminput{@srcdir@/#1}
+}
+
+
+% ___________________________________________________________________________
+% | |
+% | LE DOCUMENT |
+% |___________________________________________________________________________|
+%
+\title{User's Guide Of Med Memory}
+\author{Patrick Goldbronn \and Eric Fayolle \and Nadir Bouhamou \and Jerome Roy \and Nicolas Crouzet}
+
+% ___________________________________________________________________________
+% | |
+% | DEBUT DU DOCUMENT |
+% |___________________________________________________________________________|
+%
+
+\makeatother
+\begin{document}
+\sloppy
+
+\maketitle
+
+
+% ___________________________________________________________________________
+% | |
+% | TABLE DES MATIERES |
+% |___________________________________________________________________________|
+%
+%\newpage
+\cleardoublepage
+\tableofcontents
+% ___________________________________________________________________________
+% | |
+% | DEBUT DU TEXTE |
+% |___________________________________________________________________________|
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\chapter{Introduction}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\section{Convention}
+
+\begin{itemize}
+
+\item Difference between local and global number~: when we talk about an
+element number, we could see $i^{th}$ quadrangle ($i^{th}$ in quadrangles
+array~: local numbering) or $j^{th}$ element ($j^{th}$ in all elements array~:
+global numbering). This two numbering are equivalent only if we have one
+geometric type ;
+
+\item All numbering begin at one (take care of array index !) ;
+\item When you get a C type array with a \texttt{get...} method, you must
+not replace some value of it. Access is in read only. Other use may
+product an impredicable result. To modify a such array use method
+\texttt{set...} ;
+\item Difference between local and global number~: when we talk about an
+element number, we could see \( i^{th} \) quadrangle (\( i^{th} \)
+in quadrangles array~: local numbering) or \( j^{th} \) element
+(\( j^{th} \) in all elements array~: global numbering). This two
+numbering are equivalent only if we have one geometric type.
+\item They are many methods that have two syntax (one singular and one
+plural). Plurals methods returns array and singulars methods returns one
+particular value in this array (see \method{getCoordinate} and
+\method{getCoordinates}).
+
+\end{itemize}
+
+\section{UML diagram}
+
+\includegraphics[width=16cm]{MEDMEM_UML.eps}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\chapter{How to use MED object}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\section{General Information}
+
+A typical use of this object is to mount in memory what is in a MED file (or
+any type of driver in red or read/write mode) and it will manage its memory on
+its own. Then from this object one can get some information such as~:
+
+\begin{itemize}
+\item the number of meshes stored in this object using the
+{\method{getNumberOfMeshes}}.
+\item the number of fields stored in this object using the
+{\method{getNumberOfFields}}.
+\item a list of mesh names using the {\method{getMeshNames}}.
+\item a list of field names using the {\method{getFieldNames}}.
+\item a list of MESH object using the {\method{getMesh}}
+\item a list of FIELD object using the {\method{getField}}
+\item a list of SUPPORT object on all type of entities (node, cell,
+ face in 3d or edge on 2d) using the {\method{getSupport}}.
+\end{itemize}
+
+The destuctor of this object will destruct itself all FIELD, SUPPORT and MESH
+objects; via its get method you will have a pointeur on this object and you
+should never delete it.
+
+One can add as well some MESH or FIELD object via the {\method{addMesh}} and
+the {\method{addField}} respectively.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\chapter{How to use MESH object}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
+\section{General Information}
+
+We could get some general information about a MESH object such as~:
+
+\begin{itemize}
+\item name (\method{getName})
+\item a description (\method{getDescription})
+\item the space dimension (\method{getSpaceDimension})
+\item the mesh dimension (\method{getMeshDimension})
+\end{itemize}
+\fileCxx{MESHgeneral.cxx}
+
+\filePython{MESHgeneral.py}
+
+\section{Information about nodes}
+
+\begin{enumerate}
+\item I want to get the number of nodes~: Realy simple, use \method{getNumberOfNodes}.
+\item I want to get the coordinates components names~: use \method{getCoordinatesNames}
+which return a string array (one string for each space dimension)
+\item I want to get the coordinates components units~: use \method{getCoordinatesUnits}
+which return a string array (one string for each space dimension)
+\item I want to get the coordinates system~: use \method{getCoordinatesSystem}
+which return a string (\verb+"CARTESIAN"+, \verb+"CYLINDRICAL"+ or \verb+"SPHERICAL"+).
+\item I want to get the nodes coordinates~: use \method{getCoordinates}
+which return a pointer to the coordinates array where values are interlace
+or no. \textbf{Warning~:}
+
+\begin{itemize}
+\item When we get coordinates in \verb+MED_NO_INTERLACE+ mode, we get an
+array where values are ordered like (\verb+X1,X2,X..., Y1,Y..., Z1,Z...+).
+\item When we get coordinates in \verb+MED_FULL_INTERLACE+ mode, we get
+an array where values are ordered like (\verb+X1,Y1,Z1, X2,Y2,Z2, ...+).
+\end{itemize}
+\item I want to get one particular value of coordinate~: use \method{getCoordinate}
+which return the value of \( i^{th} \) node and \( j^{th} \) axis.
+\end{enumerate}
+\fileCxx{MESHcoordinates.cxx}
+
+\filePython{MESHcoordinates.py}
+
+\section{Information about cells}
+
+\begin{enumerate}
+\item I want to get the number of geometric type for a mesh entity~: use
+\method{getNumberOfTypes}
+
+
+\textbf{C++ Example~:}
+
+\verb+int NumberOfCellsTypes = myMesh.getNumberOfTypes(MED_CELL);+
+
+%%%%%%%%%%%%%%%%%
+\item I want to get all geometric type for a mesh entity~: use
+\method{getTypes} to get an array of \verb+medGeometryElement+
+(to use directly in others methods) or \method{getCellsTypes} to get
+an array of \verb+CELLMODEL+ (to ask mode information~: see \myref{CellModel}) .
+
+\textbf{C++ Example~:}
+
+\verb+const medGeometryElement * Types = myMesh.getTypes(MED_CELL);+
+
+\verb+const CELLMODEL * CellsTypes = myMesh.getCellsTypes(MED_CELL);+
+
+(each arrays are size \verb+NumberOfCellsTypes+)
+
+\item I want to get the number of cells~: use \method{getNumberOfElements}
+which return this information. You must give the mesh entity (\verb+MED_CELL+,
+\verb+MED_FACE+, \verb+MED_EDGE+ or \verb+MED_NODE+) and a geometric
+type of this entity.
+
+
+\textbf{C++ Example~:}
+
+\verb+int NumberOfTriangle = myMesh.getNumberOfElements(MED_FACE,MED_TRIA3);+
+
+\verb+int NumberOfFace = myMesh.getNumberOfElements(MED_FACE,MED_ALL_ELEMENT);+
+
+\item I want to get the geometric type of one element~: use \method{getElementType}
+which return a \verb+medGeometryElement+.
+
+
+\textbf{C++ Example~:}
+
+\verb+medGeometryElement myType = myMesh.getElementType(MED_FACE,10);+
+
+Return the \verb+medGeometryElement+ of \( 10^{th} \) face.
+
+\item I want to get a connectivity~: use \method{getConnectivity} which
+return an array with connectivity values.
+
+
+\label{getConnectivity}
+
+\textbf{C++ Example~:}
+
+\begin{verbatim}
+int NumberOfTetrahedron = myMesh.getNumberOfElements(MED_CELL,MED_TETRA4);
+const int * TetrahedronConnectivity =
+ myMesh.getConnectivity(MED_FULL_ENTERLACE,
+ MED_NODAL,
+ MED_CELL,
+ MED_TETRA4);
+\end{verbatim}
+\verb+TetrahedronConnectivity+ contain nodal connectivity
+of tetrahedron in mesh. It is arranged in full enterlace mode and
+its size is \verb+NumberOfTetrahedron x 4+.
+
+If you want to get connectivity of all elements (with \verb+Type=MED_ALL_ELEMENTS+),
+you must use the index array (return by \method{getConnectivityIndex})
+to get connectivity for each elements (see example \myref{MESHconnectivities.cxx}).
+
+\item I want to get an element number from a connectivity~: use \method{getElementNumber}
+which return the global number of a given connectivity.
+
+
+\textbf{C++ Example~:}
+\begin{verbatim}
+int * myElementConnectivity = {2,10,12,14};
+int myNumber = myMesh.getElementNumber(MED_NODAL,MED_CELL,
+ myElementConnectivity);
+\end{verbatim}
+
+\end{enumerate}
+\fileCxx{MESHconnectivities.cxx}
+
+\filePython{MESHconnectivities.py}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\chapter{How to use MESHING object}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+This class is a derivated class of MESH class to build a MESH object from
+scratch (use of set methods).
+
+All verifications are under user responsability : If arrays values or arrays
+dimensions are wrongs, results are impredicable.
+
+All arrays in arguments in set methods are duplicated in MESHING object.
+
+\section{Build a MESHING}
+
+\label{BuildMeshing}
+
+\subsection{Coordinates}
+
+First we must defined points coordinates of the mesh. We use
+\method{setCoordinates}.
+
+\textbf{C++ Example~:}
+\begin{verbatim}
+MESHING myMeshing ;
+const int SpaceDimension=2;
+const int NumberOfNodes=6;
+int * Coordinates = new int[SpaceDimension*NumberOfNodes] ;
+string System="CARTESIAN";
+medModeSwitch MED_FULL_INTERLACE ;
+myMeshing.setCoordinates(SpaceDimension,NumberOfNodes,Coordinates,System,Mode);
+\end{verbatim}
+
+Then you could set the coordinates names and units (with
+\method{setCoordinatesNames} and \method{setCoordinatesUnits}).
+
+\subsection{Connectivities}
+
+When coordinates are defined, we could defined connectivities.
+
+First we must defined connectivity of MED\_CELL elements.
+After, we could defined constituent connectivity if necesary
+(MED\_FACE and/or MED\_EDGE).
+
+For each connectivities, you could use some methods in the following order :
+\begin{itemize}
+\item \method{setNumberOfTypes} to set the number of differents geometrics
+types (3 for example). This method allocates all arrays which size is this
+number ;
+\item \method{setTypes} to set the differents geometrics types
+({MED\_TETRA4,MED\_PYRA5,MED\_HEXA8} for example). Types should be given
+in increasing order of number of nodes for this type ;
+\item \method{setNumberOfElements} to set the number of elements for
+each geometric type. This method allocates connectivities array ;
+\item \method{setConnectivity} to set the connectivity in MED\_FULL\_INTERLACE
+mode for each geometric type ;
+\end{itemize}
+
+\textbf{C++ Example~:}
+\begin{verbatim}
+MESHING myMeshing ;
+myMeshing.setCoordinates(SpaceDimension,NumberOfNodes,Coordinates,System,Mode);
+
+myMeshing.setNumberOfTypes(2,MED_CELL);
+myMeshing.setTypes({MED_TRIA3,MED_QUAD4},MED_CELL);
+myMeshing.setNumberOfElements({3,2},MED_CELL); // 3 MED_TRIA3 and 2 MED_QUAD4
+myMeshing.setConnectivity({1,2,3,6,8,9,4,5,6},MED_CELL,MED_TRIA3);
+myMeshing.setConnectivity({1,3,4,5,4,5,7,8},MED_CELL,MED_QUAD4);
+\end{verbatim}
+
+
+\section{Defined a GROUP object}
+
+To add a group in a MESHING object, use \method{addGroup}.
+
+This method duplicate the GROUP object in the MESH object.
+
+To build this GROUP object, use SUPPORT methods \ref{CreateSupport} to set all attributes.
+
+\subsection{WARNING}
+
+For instance, translation from GROUP objects to FAMILY objects are not completed !
+
+You MUST set GROUP objects as if they are FAMILY objects.
+
+This feature will be fully implemented in next release of med memory.
+
+\section{Example}
+
+\fileCxx{MESHINGexample.cxx}
+
+%\filePython{MESHINGexample.py}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\chapter{How to use SUPPORT object}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\section{Create a SUPPORT object}
+
+\label{CreateSupport}
+
+To create a SUPPORT object, you must give :
+
+\begin{itemize}
+\item a reference to a MESH object
+\item its name
+\item on which mesh entity it apply to
+\end{itemize}
+\textbf{C++ example~:}
+
+\verb+SUPPORT mySupport(myMesh,"support on all faces",MED_FACE) ;+
+By default, this support is defined on all elements of the given entity.
+
+If you want a restricted SUPPORT, you must add manualy information
+about what do you want~:
+
+\begin{itemize}
+\item is not on all elements~: \verb+mySupport.setAll(false);+
+\item on how many geometric type~:\\
+ \verb+mySupport.setNumberOfGeometricType(myNumberOfGeometricType);+
+\item on which geometric type~:\\
+ \verb+mySupport.setGeometricType(myGeometricType);+
+\item Temporary : the Gauss point number for each geometric type~:\\
+ \verb+mySupport.setNumberOfGaussPoint(myNumberOfGaussPoint);+
+\item the number of elements for each geometric type~:\\
+ \verb+mySupport.setNumberOfEntities(myNumberOfEntities);+
+\item the total number of elements~:\\
+ \verb+mySupport.setTotalNumberOfEntities(myTotalNumberOfEntities);+
+\item the array which contains elements for each geometric type~:\\
+ \verb+mySupport.setNumber(myNumber);+
+\end{itemize}
+You could also use \method{setpartial} which set all you need.
+
+
+\section{Use a SUPPORT object}
+
+You could get all basic information (as you set them in \myref{CreateSupport})~:
+
+\begin{itemize}
+\item \verb+getName()+
+\item \verb+getDescription()+
+\item \verb+getMesh()+
+\item \verb+getEntity()+
+\item \verb+isOnAllElements()+
+\item \verb+getNumberOfTypes()+
+\item \verb+getTypes()+
+%\item \verb+getNumberOfGaussPoint()+
+%\item \verb+getNumberOfGaussPoint(myGeometricType)+
+\item \verb+getGeometricTypeNumber()+
+\item \verb+getNumberOfElements(myGeometricType)+
+\item \verb+getNumber(myGeometricType)+
+\item \verb+getNumberIndex()+
+\end{itemize}
+For details about this methods, see the reference manual \cite{RefManual}.
+
+The use of \method{getNumber} and \method{getNumberIndex} are the
+same as \method{getConnectivity} and \method{getConnectivityIndex}
+(see item \myref{getConnectivity}
+
+There is another particular method to blend another SUPPORT object
+into it.
+
+For example in C++ :
+\begin{verbatim}
+SUPPORT mySupport ;
+SUPPORT myOtherSupport ;
+...
+mySupport.blending(myOtherSupport) ;
+\end{verbatim}
+
+\verb+mySupport+ contain now all elements defined originally in it,
+more those defined in \verb+myOtherSupport+.
+
+
+\section{Case of FAMILY object}
+
+A FAMILY is a SUPPORT with some additionnal methods that concern some optional attribut (we could have none) and group (we could also have none) :
+\begin{itemize}
+\item \method{getIdentifier} return the family identifier (an integer)
+
+\item \method{getNumberOfAttributes} return the number of attributes of this family
+\item \method{getAttributesIdentifiers} and \method{getAttributeIdentifier} return an integer array or an integer that represent attribut identifier.
+\item \method{getAttributesValues} and \method{getAttributeValue} return an integer array or an integer that represent attribut value.
+\item \method{getAttributesDescriptions} and \method{getAttributeDescription} return a string array or a string that represent attribut description.
+
+\item \method{getNumberOfGroups} return the number of groups which it belog to.
+\item \method{getGroupsNames} and \method{getGroupName} return a string array or a string that represent the group name which it belog to.
+
+\end{itemize}
+
+\section{Case of GROUP object}
+
+A GROUP is a SUPPORT with some additionnal methods to find FAMILY that make up it :
+\begin{itemize}
+\item \method{getNumberOfFamilies} return the number of FAMILY that make up the GROUP ;
+\item \method{getFamilies} and \method{getFamily} return a FAMILY array or a FAMILY that make up the GROUP.
+\end{itemize}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\chapter{How to use Field}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\section{Introduction}
+
+A field is characterized by its name (\method{getName}) and an optional description (\method{getDescription}).
+
+It is also characterized by this calculating moment :
+\begin{itemize}
+\item an iteration number (time step number)
+\item an order number (use if there are internal iteration in a time step)
+\item the time that correspond to this iteration number.
+\end{itemize}
+
+By default, there are no iteration and order number defined (value
+MED\_NOPDT and MED\_NONOR).
+
+A field contain values which apply on some nodes or elements (cell, face or edge).
+
+We find these informations from a SUPPORT object (see \method{getSupport}).
+
+Each field have a number of components (\method getNumberOfComponents) and all these components have a name (\method{getComponentsNames} and \method{getComponentName}), a description (\method{getComponentsDescriptions} and \method{getComponentDescription}) and an unit (\method{getMEDComponentsUnits} and \method{getMEDComponentUnit}).
+
+For unit you could use later UNIT (\myref{Unit}) objet to make a more general control on it. But the use of this class must be specified.
+
+To get values of a FIELD, you could use \method{getValue}, \method{getValueI}
+and \method{getValueIJ}~:
+
+\begin{itemize}
+\item First return a reference to all values in the given mode (full or no
+interlace).
+\item Second return a reference to $i^{th}$ element values or component values (in accordance with the given mode).
+\item Third return the $j^{th}$ component of $i^{th}$ element.
+\end{itemize}
+
+\fileCxx{FIELDgeneral.cxx}
+
+\filePython{FIELDgeneral.py}
+
+\section{Create a Field}
+
+It is simple to create a field object. You must know its SUPPORT and the number of components.
+
+\textbf{Example :}
+\verb+FILED<double> myField(mySupport,NumberOfComponents) ;+
+
+You must now set a name (\method{setName}) and optionaly a description
+(\method{setDescription}).
+
+By default there are no iteration and order number (negative values) and
+time is null. You could change this by using \method{setIterationNumber},
+\method{setOrderNumber} and \method{setTime}.
+
+You \textbf{SHOULD} also set unit of your components with \method{setMEDComponentUnit}
+
+To set value, use \method{setValueIJ} to put new value of field.
+
+\fileCxx{FIELDcreate.cxx}
+
+\filePython{FIELDcreate.py}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\chapter{Other Classes}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
+\section{class CELLMODEL}
+\label{CellModel}
+
+To do
+
+\section{class UNIT}
+\label{Unit}
+
+To do
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\chapter{Using drivers}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+The generic driver mecanism gives users the possibility to write/read
+the content of an object according to a specified file format. The
+semantic remains the same whatever the object is (MESH, FIELD, MED).
+By the way it allows using several file formats for writting an object.
+
+
+\section{Invoking a driver}
+
+
+\subsection{Invoking a driver at creation object time}
+
+This is the simplest way of invoking a driver. The driver parameters
+are given to the constructor of the object. Except for the MED object,
+this way of invoking a driver assume you know exactly the name of
+the MESH/FIELD you want read from a file <fileName> of type <driverType>.
+
+ex 1.1 : For a FIELD object, invoking FIELD<double> myField(MED\_DRIVER,fileName,fieldName)
+create a FIELD object and a driver which loads the mesh <fieldName>
+from the MED file <fileName> (Not implemented yet !).
+
+ex 1.2 : To remove the default driver previously created myField->rmDriver();
+
+ex 2 : For a MESH object, invoking MESH myMesh(MED\_DRIVER,fileName,meshName)
+create a MESH object and a driver which loads the mesh <meshName>
+from the MED file <fileName>.
+
+ex 3 : For a MED object, invoking MED myMed(MED\_DRIVER,fileName)
+create a MED object to explore the MED file <fileName>.
+
+rem 1 : ex1 is equivalent to \ref{sec:invoking_a_driver_from_the_std_drv_method}
+ex1.
+
+rem 2 : Since the driver has read the object, the associated file
+is closed. You can reread the object with the default driver by calling
+the read() method : myObject.read().
+
+\fileCxx{MEDMEM_InvokingDriverAtObjectCreationTime.cxx}
+
+\filePython{MEDMEM_InvokingDriverAtObjectCreationTime.py}
+
+\subsection{Invoking a driver from the standard driver method of an object\label{sec:invoking_a_driver_from_the_std_drv_method}}
+
+This way of invoking a driver give the possiblility to add several
+drivers to an exiting object.
+
+ex1 : First we create a FIELD without any driver FIELD<double>~{*}~myField1~=~new~FIELD<double>;
+then we add a driver with int myDriver1 = myField1->addDriver(driverType1,
+fileName1, fieldName1); for reading <fieldName1> from file <fileName1>
+with myField1->read(myDriver1);
+
+ex2 : We add a new driver of type <driverType2> int myDriver2 = myField1->addDriver(driverType2,
+fileName2,fieldName2); in order to write myField1 in file <fileName2>
+with <fieldName2> name using command myField1->write(myDriver2);
+
+rem 1 : Files are openned then closed each time you call read() or
+write() methods.
+
+rem 2 : If you use more than a driver you need to keep the driver
+handlers (myDriverI ).
+
+\fileCxx{MEDMEM_InvokingDriverFromStandardObjectMethod.cxx}
+
+\filePython{MEDMEM_InvokingDriverFromStandardObjectMethod.py}
+
+\subsection{Invoking a driver and attaching it to an existing object}
+
+The methods exposed in the two previous sections always create drivers
+in read/write access mode. Another way of creating a driver is to
+create a driver with a specific access mode.
+
+ex1 : First we create a FIELD without any driver FIELD<double>~{*}~myField1~=~new
+FIELD<double>(); then we create a read-only driver MED\_FIELD\_RDONLY\_DRIVER<double>~myRdOnlyDriver(fileName1,myField1);
+and attached it to myField1. Finally you must set the fieldName1 you
+want to acess in fileName1 with myRdOnlyDriver->setFieldName(fieldName1);
+in order to read the field with myRdOnlyDriver->open(); myRdOnlyDriver->read();
+
+Don't forget to close the file with myRdOnlyDriver->close().
+
+ToDo : By now when you create such specific drivers, the object doesn't
+know anything about it.
+
+\fileCxx{MEDMEM_InvokingDriverByAttachingItToAnObject.cxx}
+
+\filePython{MEDMEM_InvokingDriverByAttachingItToAnObject.py}
+
+\section{Using the MED driver}
+
+The MED object provides the ability of :
+
+\begin{enumerate}
+\item \noindent Obtainning a reference on the whole structure contained
+in a file.
+\item Obtainning the list of all the Meshes/Fields names contained in a
+file.
+\item Obtainning a Mesh/Field reference using a name.
+\item Writting a whole set of independent objects with a simple command.
+\end{enumerate}
+
+\subsection{Exploring files}
+
+In this first use case the user wants to explore the meshes \& fields
+containned within a file <filename> of type given by the <drivertype>
+parameter.
+
+ex 1 : Calling MED {*} myMed = new MED(driverType1, fileName1); create
+a MED object which open fileName1, read all MESHes/FIELDs relations
+then close the file.
+
+This is equivalent to MED~{*}~myMed~=~new~MED(); myDriver~=~myMed->addDriver(driverType1,fileName1);
+myMed->readFileStruct(myDriver);
+
+ex 2 : To get the list of meshNames from a MED object, first ask the
+object how many meshes it had by calling int numberOfMeshes~=~myMed->getNumberOfMeshes();
+then get the list with myMeshNames~=~new string{[}getMeshNames{]};
+myMed->getMeshNames(myMeshNames).
+
+Note you can also use the deque<string> getMeshNames() method.
+
+ex 3 : To get a list of fieldNames from a MED object, first ask the
+object how many fields it had by calling int numberOfFields~=~myMed->getNumberOfFields();
+then get the list with myFieldNames~=~new string{[}getFieldNames{]};
+myMed->getFieldNames(myFieldNames).
+
+ex 4 :To get a particular MESH use MESH {*} myMesh1 = myMED->getMesh(myMeshNames{[}0{]})
+
+ex 5 :To get a particular FIELD you first need to know what (time
+step, iteration number) list is used by calling deque<DT\_IT\_>~myField1DtIt~=~myMed->getFieldIteration(FieldName{[}0{]})
+; then you can ask for getting a specific FIELD with FIELD~{*}~myField1~=~myMED->getField(myFieldNames{[}0{]},myField1DtIt{[}0{]}.dt,myField1DtIt{[}0{]}.it).
+
+ex2 : To write the whole content of a MED object first add a driver
+myDriver2~=~myMed.addDriver(driverType2,~fileName2); then ask for
+writing the object myMed->write(myDriver2); (not implemented yet !)
+
+You can remove the driver with myMed->rmDriver(myDriver2);
+
+rem 1 : It is possible to use multiple drivers to read a set of FIELDs
+/ MESHes from various file formats and writing the whole set through
+a specific write.(not implemented yet !)
+
+
+\subsubsection{Adding existing MESHes/FIELDs objects}
+
+Not yet implemented.
+
+\section{Using the VTK driver}
+
+This driver allow to save all MESH and FIELD objects in an ASCII file in
+VTK format \cite{vtk}.
+
+You could use this driver only from a MED object, because VTK file format
+impose to write objects in particular order.
+
+\textbf{C++ Example~:}
+\begin{verbatim}
+MED myMed(MED_DRIVER,"file.med");
+myMed.read();
+int id = myMed.addDriver(VTK_DRIVER,"file.vtk");
+myMed.write(id) ;
+\end{verbatim}
+
+\section{Using the GIBI driver}
+
+This driver allow to load a mesh from a GIBI file (ASCII file with the extension '.sauve'), puting the mesh into a MESH object of MED. It's a read only driver and is applicable only to a MESH object.
+
+\textbf{C++ Example~:}
+\begin{verbatim}
+MESH * myMesh= new MESH() ;
+GIBI_MESH_RDONLY_DRIVER myGibiMeshDriver("file.sauve", myMesh) ;
+myGibiMeshDriver.open() ;
+myGibiMeshDriver.read() ;
+myGibiMeshDriver.close() ;
+\end{verbatim}
+
+
+% ___________________________________________________________________________
+% | |
+% | REFERENCES |
+% |___________________________________________________________________________|
+%
+\newpage
+%\thebibliography{biblio}
+\begin{thebibliography}{1}
+
+\addcontentsline{toc}{chapter}{\refname}
+
+\addcontentsline{toc}{chapter}{Bibliography}
+
+\bibitem{RefManual} Reference Manual~: \verb+http://www-drn2.cea.fr/MED/MEDMEM/DOC/html/index.html+
+
+\bibitem{vtk} VTK home page~: \verb+http://public.kitware.com/VTK+
+
+\end{thebibliography}
+
+
+\end{document}
--- /dev/null
+#include "MEDMEM_Meshing.hxx"
+#include "MEDMEM_Group.hxx"
+
+using namespace std;
+
+int main (int argc, char ** argv) {
+
+ // filename to save the generated MESH
+ string filename = "meshing.med" ;
+
+ MESHING myMeshing ;
+ myMeshing.setName("meshing") ;
+
+ // define coordinates
+
+ int SpaceDimension = 3 ;
+ int NumberOfNodes = 19 ;
+ double Coordinates[57] = {
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 1.0,
+ 2.0, 0.0, 1.0,
+ 0.0, 2.0, 1.0,
+ -2.0, 0.0, 1.0,
+ 0.0, -2.0, 1.0,
+ 1.0, 1.0, 2.0,
+ -1.0, 1.0, 2.0,
+ -1.0, -1.0, 2.0,
+ 1.0, -1.0, 2.0,
+ 1.0, 1.0, 3.0,
+ -1.0, 1.0, 3.0,
+ -1.0, -1.0, 3.0,
+ 1.0, -1.0, 3.0,
+ 1.0, 1.0, 4.0,
+ -1.0, 1.0, 4.0,
+ -1.0, -1.0, 4.0,
+ 1.0, -1.0, 4.0,
+ 0.0, 0.0, 5.0
+ };
+
+ myMeshing.setCoordinates(SpaceDimension,NumberOfNodes,Coordinates,"CARTESIAN",MED_FULL_INTERLACE);
+
+ string Names[3] = { "X","Y","Z" } ;
+ myMeshing.setCoordinatesNames(Names);
+
+ string Units[3] = { "cm","cm","cm" } ;
+ myMeshing.setCoordinatesUnits(Units) ;
+
+ // define conectivities
+
+ // cell part
+
+ const int NumberOfTypes = 3 ;
+ medGeometryElement Types[NumberOfTypes] = {MED_TETRA4,MED_PYRA5,MED_HEXA8} ;
+ const int NumberOfElements[NumberOfTypes] = {12,2,2} ;
+
+ myMeshing.setNumberOfTypes(NumberOfTypes,MED_CELL);
+ myMeshing.setTypes(Types,MED_CELL);
+ myMeshing.setNumberOfElements(NumberOfElements,MED_CELL);
+
+ const int sizeTetra = 12*4 ;
+ int ConnectivityTetra[sizeTetra]=
+ {
+ 1,2,3,6,
+ 1,2,4,3,
+ 1,2,5,4,
+ 1,2,6,5,
+ 2,7,4,3,
+ 2,8,5,4,
+ 2,9,6,5,
+ 2,10,3,6,
+ 2,7,3,10,
+ 2,8,4,7,
+ 2,9,5,8,
+ 2,10,6,9
+ };
+
+ myMeshing.setConnectivity(ConnectivityTetra,MED_CELL,MED_TETRA4);
+
+ int ConnectivityPyra[2*5]=
+ {
+ 7,8,9,10,2,
+ 15,18,17,16,19
+ };
+
+ myMeshing.setConnectivity(ConnectivityPyra,MED_CELL,MED_PYRA5);
+
+ int ConnectivityHexa[2*8]=
+ {
+ 11,12,13,14,7,8,9,10,
+ 15,16,17,18,11,12,13,14
+ };
+
+ myMeshing.setConnectivity(ConnectivityHexa,MED_CELL,MED_HEXA8);
+
+ // face part
+
+ const int NumberOfFacesTypes = 2 ;
+ medGeometryElement FacesTypes[NumberOfFacesTypes] = {MED_TRIA3,MED_QUAD4} ;
+ const int NumberOfFacesElements[NumberOfFacesTypes] = {4,4} ;
+
+ myMeshing.setNumberOfTypes(NumberOfFacesTypes,MED_FACE);
+ myMeshing.setTypes(FacesTypes,MED_FACE);
+ myMeshing.setNumberOfElements(NumberOfFacesElements,MED_FACE);
+
+ const int sizeTria = 3*4 ;
+ int ConnectivityTria[sizeTria]=
+ {
+ 1,4,3,
+ 1,5,4,
+ 1,6,5,
+ 1,3,6
+ };
+
+ myMeshing.setConnectivity(ConnectivityTria,MED_FACE,MED_TRIA3);
+
+ int ConnectivityQua[4*4]=
+ {
+ 7,8,9,10,
+ 11,12,13,14,
+ 11,7,8,12,
+ 12,8,9,13
+ };
+
+ myMeshing.setConnectivity(ConnectivityQua,MED_FACE,MED_QUAD4);
+
+ // edge part
+
+ // not yet implemented : if set, results are unpredictable.
+
+ // Some groups :
+
+ // Node :
+ {
+ GROUP myGroup ;
+ myGroup.setName("SomeNodes");
+ myGroup.setMesh(&myMeshing);
+ myGroup.setEntity(MED_NODE);
+ myGroup.setNumberOfGeometricType(1);
+ medGeometryElement myTypes[1] = {MED_NONE};
+ myGroup.setGeometricType(myTypes);
+ const int myNumberOfElements[1] = {4} ;
+ myGroup.setNumberOfElements(myNumberOfElements);
+ const int index[1+1] = {1,5} ;
+ const int value[4]= { 1,4,5,7} ;
+ myGroup.setNumber(index,value);
+
+ myMeshing.addGroup(myGroup);
+ }
+ {
+ GROUP myGroup ;
+ myGroup.setName("OtherNodes");
+ myGroup.setMesh(&myMeshing);
+ myGroup.setEntity(MED_NODE);
+ myGroup.setNumberOfGeometricType(1);
+ medGeometryElement myTypes[1] = {MED_NONE};
+ myGroup.setGeometricType(myTypes);
+ const int myNumberOfElements[1] = {3} ;
+ myGroup.setNumberOfElements(myNumberOfElements);
+ const int index[1+1] = {1,4} ;
+ const int value[3]= { 2,3,6} ;
+ myGroup.setNumber(index,value);
+
+ myMeshing.addGroup(myGroup);
+ }
+
+ // Cell :
+ {
+ GROUP myGroup ;
+ myGroup.setName("SomeCells");
+ myGroup.setMesh(&myMeshing);
+ myGroup.setEntity(MED_CELL);
+ myGroup.setNumberOfGeometricType(3);
+ medGeometryElement myTypes[3] = {MED_TETRA4,MED_PYRA5,MED_HEXA8};
+ myGroup.setGeometricType(myTypes);
+ const int myNumberOfElements[3] = {4,1,2} ;
+ myGroup.setNumberOfElements(myNumberOfElements);
+ const int index[3+1] = {1,5,6,8} ;
+ const int value[4+1+2]=
+ {
+ 2,7,8,12,
+ 13,
+ 15,16
+ };
+ myGroup.setNumber(index,value);
+
+ myMeshing.addGroup(myGroup);
+ }
+ {
+ GROUP myGroup ;
+ myGroup.setName("OtherCells");
+ myGroup.setMesh(&myMeshing);
+ myGroup.setEntity(MED_CELL);
+ myGroup.setNumberOfGeometricType(2);
+ medGeometryElement myTypes[] = {MED_TETRA4,MED_PYRA5};
+ myGroup.setGeometricType(myTypes);
+ const int myNumberOfElements[] = {4,1} ;
+ myGroup.setNumberOfElements(myNumberOfElements);
+ const int index[3+1] = {1,5,6} ;
+ const int value[4+1]=
+ {
+ 3,4,5,9,
+ 14
+ };
+ myGroup.setNumber(index,value);
+
+ myMeshing.addGroup(myGroup);
+ }
+
+ // Face :
+ {
+ GROUP myGroup ;
+ myGroup.setName("SomeFaces");
+ myGroup.setMesh(&myMeshing);
+ myGroup.setEntity(MED_FACE);
+ myGroup.setNumberOfGeometricType(2);
+ medGeometryElement myTypes[2] = {MED_TRIA3,MED_QUAD4};
+ myGroup.setGeometricType(myTypes);
+ const int myNumberOfElements[2] = {2,3} ;
+ myGroup.setNumberOfElements(myNumberOfElements);
+ const int index[2+1] = {1,3,6} ;
+ const int value[2+3]=
+ {
+ 2,4,
+ 5,6,8
+ } ;
+ myGroup.setNumber(index,value);
+
+ myMeshing.addGroup(myGroup);
+ }
+ {
+ GROUP myGroup ;
+ myGroup.setName("OtherFaces");
+ myGroup.setMesh(&myMeshing);
+ myGroup.setEntity(MED_FACE);
+ myGroup.setNumberOfGeometricType(1);
+ medGeometryElement myTypes[1] = {MED_TRIA3};
+ myGroup.setGeometricType(myTypes);
+ const int myNumberOfElements[1] = {2} ;
+ myGroup.setNumberOfElements(myNumberOfElements);
+ const int index[1+1] = {1,3} ;
+ const int value[2]=
+ {
+ 1,3
+ } ;
+ myGroup.setNumber(index,value);
+
+ myMeshing.addGroup(myGroup);
+ }
+
+ // all rigtht, we save it !
+
+ int id = myMeshing.addDriver(MED_DRIVER,filename,myMeshing.getName());
+ myMeshing.write(id) ;
+
+}
--- /dev/null
+#include "MEDMEM_Mesh.hxx"
+#include "MEDMEM_CellModel.hxx"
+
+int main (int argc, char ** argv) {
+
+ const string MedFile = "pointe.med" ;
+ const string MeshName = "maa1" ;
+ MESH myMesh(MED_DRIVER,MedFile,MeshName) ;
+ myMesh.read() ;
+
+ cout << "Mesh name : " << myMesh.getName() << endl << endl ;
+
+ // we get all type for cell entity :
+ int NumberOfTypes = myMesh.getNumberOfTypes(MED_CELL) ;
+ const CELLMODEL * Types = myMesh.getCellsTypes(MED_CELL) ;
+
+ cout << "Show Connectivity (Nodal) :" << endl ;
+ // this example use access with a specified medGeometryElement through
+ // CELLMODEL class
+ for (int i=0; i<NumberOfTypes; i++) {
+ cout << "For type " << Types[i].getName() << " : " << endl ;
+ medGeometryElement myType = Types[i].getType() ;
+ int NumberOfElements = myMesh.getNumberOfElements(MED_CELL,myType);
+ int NomberOfNodesPerCell = Types[i].getNumberOfNodes() ;
+ const int * Connectivity =
+ myMesh.getConnectivity(MED_FULL_INTERLACE,
+ MED_NODAL,
+ MED_CELL,
+ myType);
+ for (int j=0; j<NumberOfElements; j++){
+ cout << "Element "<< j+1 <<" : " ;
+ for (int k=0; k<NomberOfNodesPerCell; k++)
+ cout << Connectivity[j*NomberOfNodesPerCell+k]<<" ";
+ cout << endl ;
+ }
+ }
+ cout << "Show Reverse Nodal Connectivity :" << endl ;
+ // this example use global access with index array
+ int NumberOfNodes = myMesh.getNumberOfNodes() ;
+ const int * ReverseNodalConnectivity =
+ myMesh.getReverseConnectivity(MED_NODAL) ;
+ const int * ReverseNodalConnectivityIndex =
+ myMesh.getReverseConnectivityIndex(MED_NODAL) ;
+ for (int i=0; i<NumberOfNodes; i++) {
+ cout << "Node "<<i+1<<" : " ;
+ int IndexBegin = ReverseNodalConnectivityIndex[i] ;
+ int IndexEnd = ReverseNodalConnectivityIndex[i+1] ;
+ for (int j=IndexBegin; j<IndexEnd; j++)
+ // Index value begin at 1 so use j-1
+ cout << ReverseNodalConnectivity[j-1] << " " ;
+ cout << endl ;
+ }
+
+ cout << "Show Connectivity (Descending) :" << endl ;
+ // this example use global access with index array
+ int NumberOfElements = myMesh.getNumberOfElements(MED_CELL,MED_ALL_ELEMENTS);
+ const int * DescendingConnectivity =
+ myMesh.getConnectivity(MED_FULL_INTERLACE,
+ MED_DESCENDING,
+ MED_CELL,
+ MED_ALL_ELEMENTS);
+ const int * DescendingConnectivityIndex =
+ myMesh.getConnectivityIndex(MED_DESCENDING,MED_CELL);
+ for (int i=0; i<NumberOfElements; i++) {
+ cout << "Element "<<i+1<<" : " ;
+ int IndexBegin = DescendingConnectivityIndex[i] ;
+ int IndexEnd = DescendingConnectivityIndex[i+1] ;
+ for (int j=IndexBegin; j<IndexEnd; j++)
+ // Index value begin at 1 so use j-1
+ cout << DescendingConnectivity[j-1] << " " ;
+ cout << endl ;
+ }
+
+ cout << "Show Reverse Descending Connectivity :" << endl ;
+ // this example use global access with Index array
+ const int * ReverseDescendingConnectivity =
+ myMesh.getReverseConnectivity(MED_DESCENDING) ;
+ const int * ReverseDescendingConnectivityIndex =
+ myMesh.getReverseConnectivityIndex(MED_DESCENDING) ;
+
+ int MeshDimension = myMesh.getMeshDimension() ;
+ int NumberOfConstituents = 0;
+ string Constituent ;
+ medEntityMesh ConstituentEntity ;
+ // test if we have face (3D) or edge (2D)
+ if (MeshDimension==3) {
+ Constituent = "Face" ;
+ ConstituentEntity = MED_FACE ;
+ }
+ if (MeshDimension==2) {
+ Constituent = "Edge" ;
+ ConstituentEntity = MED_EDGE ;
+ }
+
+ NumberOfConstituents =
+ myMesh.getNumberOfElements(ConstituentEntity,MED_ALL_ELEMENTS);
+
+ if (MeshDimension==1) {
+ MESSAGE("ERROR : MeshDimension = 1 !");
+ MESSAGE("We could not see Reverse Descending Connectivity.") ;
+ } else {
+ for (int i=0; i<NumberOfConstituents; i++) {
+ cout << Constituent << " " << i+1 << " : " ;
+ int IndexBegin = ReverseDescendingConnectivityIndex[i] ;
+ int IndexEnd = ReverseDescendingConnectivityIndex[i+1] ;
+ for (int j=IndexBegin;j<IndexEnd;j++)
+ // Index value begin at 1 so use j-1
+ cout << ReverseDescendingConnectivity[j-1] << " " ;
+ cout << endl ;
+ }
+ }
+ cout << "Show "<< Constituent <<" Connectivity (Nodal) :" << endl ;
+ // this example use global access with index array
+ const int * ConstituentConnectivity =
+ myMesh.getConnectivity(MED_FULL_INTERLACE,
+ MED_NODAL,
+ ConstituentEntity,
+ MED_ALL_ELEMENTS);
+ const int * ConstituentConnectivityIndex =
+ myMesh.getConnectivityIndex(MED_NODAL,ConstituentEntity);
+ for (int i=0; i<NumberOfConstituents; i++) {
+ cout << Constituent << " " << i+1 << " : " ;
+ int IndexBegin = ConstituentConnectivityIndex[i] ;
+ int IndexEnd = ConstituentConnectivityIndex[i+1] ;
+ for (int j=IndexBegin; j<IndexEnd; j++)
+ // Index value begin at 1 so use j-1
+ cout << ConstituentConnectivity[j-1]<<" ";
+ cout << endl ;
+ }
+
+ return 0 ;
+}
--- /dev/null
+from libMEDMEM_Swig import *
+
+MedFile = "pointe.med"
+#MedFile = "carre_quad4_3.med"
+meshName = "maa1"
+#meshName = "CARRE_EN_QUAD4"
+
+myMesh = MESH(MED_DRIVER,MedFile,meshName)
+myMesh.read()
+
+nameMesh = myMesh.getName()
+
+print "Mesh name : ",nameMesh
+
+numberOfTypes = myMesh.getNumberOfTypes(MED_CELL)
+print "Show Connectivity (Nodal) : "
+
+# This example use access with a specified medGeometryElement through
+# CELLMODEL class
+
+for i in range(numberOfTypes):
+ cellType = myMesh.getCellType(MED_CELL,i)
+ nameType = cellType.getName()
+ type = cellType.getType()
+ numberOfElements = myMesh.getNumberOfElements(MED_CELL,type)
+ numberOfNodesPerCell = cellType.getNumberOfNodes()
+ connectivity = myMesh.getConnectivity(MED_FULL_INTERLACE,
+ MED_NODAL,MED_CELL,type)
+ print "For Type ",nameType," : "
+ for j in range(numberOfElements):
+ print "Element ",(j+1)," : ",connectivity[j*numberOfNodesPerCell:
+ (j+1)*numberOfNodesPerCell]
+
+print "Show Reverse Nodal Connectivity :"
+
+# This example use global access with index array
+
+numberOfNodes = myMesh.getNumberOfNodes()
+
+reverseNodalConnectivity = myMesh.getReverseConnectivity(MED_NODAL)
+reverseNodalConnectivityIndex = myMesh.getReverseConnectivityIndex(MED_NODAL)
+
+for i in range(numberOfNodes):
+ indexBegin = reverseNodalConnectivityIndex[i]
+ indexEnd = reverseNodalConnectivityIndex[i+1]
+
+ # Index value begin at 1 so (index-1) is in fact used here
+
+ print "Node ",(i+1)," : ",reverseNodalConnectivity[(indexBegin-1):
+ (indexEnd-1)]
+
+print "Show Connectivity (Descending) :"
+
+# This example use global access with index array
+
+numberOfElements = myMesh.getNumberOfElements(MED_CELL,MED_ALL_ELEMENTS)
+descendingConnectivity = myMesh.getConnectivity(MED_FULL_INTERLACE,
+ MED_DESCENDING,MED_CELL,
+ MED_ALL_ELEMENTS)
+descendingConnectivityIndex = myMesh.getConnectivityIndex(MED_DESCENDING,
+ MED_CELL)
+
+for i in range(numberOfElements):
+ indexBegin = descendingConnectivityIndex[i]
+ indexEnd = descendingConnectivityIndex[i+1]
+
+ # Index value begin at 1 so (index-1) is in fact used here
+
+ print "Element ",(i+1)," : ",descendingConnectivity[(indexBegin-1):
+ (indexEnd-1)]
+
+print "Show Reverse Descending Connectivity :"
+
+# This example use global access with index array
+
+meshDimension = myMesh.getMeshDimension()
+
+if (meshDimension == 1):
+ print "ERROR : Mesh Dimension = 1"
+ print "Then the Reverse Descending Connectivity could not be seen"
+else:
+ if (meshDimension == 2):
+ constituent = "Edge"
+ constituentEntity = MED_EDGE
+
+ if (meshDimension == 3):
+ constituent = "Face"
+ constituentEntity = MED_FACE
+
+ numberOfConstituents = myMesh.getNumberOfElements(constituentEntity,
+ MED_ALL_ELEMENTS)
+ reverseDescendingConnectivity = myMesh.getReverseConnectivity(
+ MED_DESCENDING)
+ reverseDescendingConnectivityIndex = myMesh.getReverseConnectivityIndex(
+ MED_DESCENDING)
+
+ for i in range(numberOfConstituents):
+ indexBegin = reverseDescendingConnectivityIndex[i]
+ indexEnd = reverseDescendingConnectivityIndex[i+1]
+
+ # Index value begin at 1 so (index-1) is in fact used here
+
+ print constituent," : ",(i+1)," : ",reverseDescendingConnectivity[
+ (indexBegin-1):(indexEnd-1)]
+
+ print "Show ",constituent," Connectivity (Nodal) :"
+
+ constituentConnectivity = myMesh.getConnectivity(MED_FULL_INTERLACE,
+ MED_NODAL,
+ constituentEntity,
+ MED_ALL_ELEMENTS)
+ constituentConnectivityIndex = myMesh.getConnectivityIndex(MED_NODAL,
+ constituentEntity)
+
+ for i in range(numberOfConstituents):
+ indexBegin = constituentConnectivityIndex[i]
+ indexEnd = constituentConnectivityIndex[i+1]
+
+ # Index value begin at 1 so (index-1) is in fact used here
+
+ print constituent," : ",(i+1)," : ",constituentConnectivity[
+ (indexBegin-1):(indexEnd-1)]
--- /dev/null
+#include "MEDMEM_Mesh.hxx"
+
+int main (int argc, char ** argv) {
+
+ const string MedFile = "pointe.med" ;
+ const string MeshName = "maa1" ;
+ MESH myMesh(MED_DRIVER,MedFile,MeshName) ;
+
+ cout << "Mesh name : " << myMesh.getName() << endl << endl ;
+
+ int SpaceDimension = myMesh.getSpaceDimension() ;
+ int NumberOfNodes = myMesh.getNumberOfNodes() ;
+ cout << "Space dimension : " << SpaceDimension << endl << endl ;
+ cout << "Number of nodes : " << NumberOfNodes << endl << endl ;
+
+ cout << "Show Nodes Coordinates : " << endl ;
+
+ // coordinates names :
+ cout << "Name :" << endl ;
+ const string * CoordinatesNames = myMesh.getCoordinatesNames() ;
+ for(int i=0; i<SpaceDimension ; i++) {
+ cout << " - " << CoordinatesNames[i] << endl ;
+ }
+ // coordinates unit :
+ cout << "Unit :" << endl ;
+ const string * CoordinatesUnits = myMesh.getCoordinatesUnits() ;
+ for(int i=0; i<SpaceDimension ; i++) {
+ cout << " - " << CoordinatesUnits[i] << endl ;
+ }
+ // coordinates value
+ const double * Coordinates =
+ myMesh.getCoordinates(MED_FULL_INTERLACE) ;
+ for(int i=0; i<NumberOfNodes ; i++) {
+ cout << "Nodes " << i+1 << " : " ;
+ for (int j=0; j<SpaceDimension ; j++)
+ cout << Coordinates[i*SpaceDimension+j] << " " ;
+ cout << endl ;
+ }
+
+ return 0 ;
+}
--- /dev/null
+from libMEDMEM_Swig import *
+
+MedFile = "pointe.med"
+meshName = "maa1"
+
+myMesh = MESH(MED_DRIVER,MedFile,meshName)
+
+name = myMesh.getName()
+
+print "Mesh name : ",name
+spaceDimension = myMesh.getSpaceDimension()
+numberOfNodes = myMesh.getNumberOfNodes()
+print "Space Dimension : ",spaceDimension
+print "Number of Nodes : ",numberOfNodes
+
+print "Show Nodes Coordinates :"
+print "Name :"
+coordinatesNames = myMesh.getCoordinatesNames()
+for i in range(spaceDimension):
+ coordinateName = coordinatesNames[i]
+ print " - ",coordinateName
+
+print "Unit :"
+coordinatesUnits = myMesh.getCoordinatesUnits()
+for i in range(spaceDimension):
+ coordinateUnit = coordinatesUnits[i]
+ print " - ",coordinateUnit
+
+coordinates = myMesh.getCoordinates(MED_FULL_INTERLACE)
+for i in range(numberOfNodes):
+ print "Node ",(i+1)," : ",coordinates[i*spaceDimension:(i+1)*spaceDimension]
--- /dev/null
+using namespace std;
+#include "MEDMEM_Mesh.hxx"
+
+using namespace MEDMEM ;
+
+int main (int argc, char ** argv) {
+
+ const string MedFile = "pointe.med" ;
+ const string MeshName = "maa1" ;
+
+ // create a MESH object by reading it on file :
+ MESH myMesh(MED_DRIVER,MedFile,MeshName) ;
+
+ string Name = myMesh.getName() ;
+ if (Name != MeshName) {
+ cout << "Error when reading mesh name : We ask for mesh #"
+ << MeshName <<"# and we get mesh #"<< Name <<"#"<< endl << endl ;
+ return -1;
+ }
+
+ cout << "Mesh name : " << Name << endl << endl ;
+
+ int SpaceDimension = myMesh.getSpaceDimension() ;
+ int MeshDimension = myMesh.getMeshDimension() ;
+
+ cout << "Space Dimension : " << SpaceDimension << endl << endl ;
+ cout << "Mesh Dimension : " << MeshDimension << endl << endl ;
+
+ return 0 ;
+}
--- /dev/null
+from libMEDMEM_Swig import *
+
+MedFile = "pointe.med"
+meshName = "maa1"
+
+myMesh = MESH(MED_DRIVER,MedFile,meshName)
+
+name = myMesh.getName()
+
+if (name != meshName) :
+ print "Error when reading mesh name : We ask for mesh #",meshName,"#"
+ print "and we get mesh #",name
+else :
+ print "Mesh name : ",name
+ spaceDimension = myMesh.getSpaceDimension()
+ meshDimension = myMesh.getMeshDimension()
+ print "Space Dimension : ",spaceDimension
+ print "Mesh Dimension : ",meshDimension
--- /dev/null
+# -* Makefile *-
+#
+# Author : Nadir BOUHAMOU (CEA)
+#
+
+# source path
+top_srcdir=@top_srcdir@
+top_builddir=../..
+srcdir=@srcdir@
+VPATH=.:@srcdir@
+doxygen=@DOXYGEN@
+
+@COMMENCE@
+
+# Executables targets
+BIN = MESHgeneral MESHcoordinates MESHconnectivities MESHINGexample FIELDcreate FIELDgeneral MEDMEM_InvokingDriverByAttachingItToAnObject MEDMEM_InvokingDriverFromStandardObjectMethod MEDMEM_InvokingDriverAtObjectCreationTime
+
+CPPFLAGS+=$(MED2_INCLUDES) $(HDF5_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome
+
+CXXFLAGS+=-ftemplate-depth-42 -I${KERNEL_ROOT_DIR}/include/salome
+
+# change motivated by the bug KERNEL4778.
+#LDFLAGS+=$(MED2_LIBS) $(HDF5_LIBS) -lSalomeLoggerServer -L${KERNEL_ROOT_DIR}/lib/salome
+LDFLAGS+=$(MED2_LIBS) $(HDF5_LIBS) -L${KERNEL_ROOT_DIR}/lib/salome
+
+#LDFLAGSFORBIN+=$(MED2_LIBS) $(HDF5_LIBS) -lSalomeLoggerServer -L${KERNEL_ROOT_DIR}/lib/salome -lmedmem
+LDFLAGSFORBIN+=$(MED2_LIBS) $(HDF5_LIBS) -lSALOMELocalTrace -L${KERNEL_ROOT_DIR}/lib/salome -lmedmem
+
+LIBSFORBIN=
+
+LDFLAGS=
+
+LIBS=
+
+@CONCLUDE@
+
+doc: .doxygen_user .doxygen_devel ps
+
+ps: .doxygen_user .doxygen_devel MedMemory_user.ps MedMemory_devel.ps MEDMEM_UsersGuide.ps
+
+ps_2on1: .doxygen_user .doxygen_devel MedMemory_user_2on1.ps MedMemory_devel_2on1.ps MEDMEM_UsersGuide_2on1.ps
+
+pdf: .doxygen_user .doxygen_devel MedMemory_user.pdf MedMemory_devel.pdf MEDMEM_UsersGuide.pdf
+
+pdf_2on1: .doxygen_user .doxygen_devel MedMemory_user_2on1.pdf MedMemory_devel_2on1.pdf MEDMEM_UsersGuide_2on1.pdf
+
+# user doc :
+
+.doxygen_user: $(top_srcdir)/src/MEDMEM/Doxyfile_med_user.in
+ cd $(top_builddir) ; ./config.status
+ cd $(top_builddir)/src/MEDMEM && $(doxygen) Doxyfile_med_user
+ touch $@
+ $(RM) -r doc_ref_user
+ ln -s $(top_builddir)/src/MEDMEM/doc_ref_user doc_ref_user
+
+MedMemory_user.ps:
+ cd ./doc_ref_user/latex && $(MAKE) ps
+ cp -f ./doc_ref_user/latex/refman.ps $@
+
+MedMemory_user_2on1.ps:
+ cd ./doc_ref_user/latex && $(MAKE) ps_2on1
+ cp -f ./doc_ref_user/latex/refman_2on1.ps $@
+
+MedMemory_user.pdf:
+ cd ./doc_ref_user/latex && $(MAKE) pdf
+ cp -f ./doc_ref_user/latex/refman.pdf $@
+
+MedMemory_user_2on1.pdf:
+ cd ./doc_ref_user/latex && $(MAKE) pdf_2on1
+ cp -f ./doc_ref_user/latex/refman_2on1.pdf $@
+
+# developper doc
+
+.doxygen_devel: $(top_srcdir)/src/MEDMEM/Doxyfile_med_devel.in
+ cd $(top_builddir) ; ./config.status
+ cd $(top_builddir)/src/MEDMEM && $(doxygen) Doxyfile_med_devel
+ touch $@
+ $(RM) -r doc_ref_devel
+ ln -s $(top_builddir)/src/MEDMEM/doc_ref_devel doc_ref_devel
+
+MedMemory_devel.ps:
+ cd ./doc_ref_devel/latex && $(MAKE) ps
+ cp -f ./doc_ref_devel/latex/refman.ps $@
+
+MedMemory_devel_2on1.ps:
+ cd ./doc_ref_devel/latex && $(MAKE) ps_2on1
+ cp -f ./doc_ref_devel/latex/refman_2on1.ps $@
+
+MedMemory_devel.pdf:
+ cd ./doc_ref_devel/latex && $(MAKE) pdf
+ cp -f ./doc_ref_devel/latex/refman.pdf $@
+
+MedMemory_devel_2on1.pdf:
+ cd ./doc_ref_devel/latex && $(MAKE) pdf_2on1
+ cp -f ./doc_ref_devel/latex/refman_2on1.pdf $@
+
+# User Guide
+
+MEDMEM_UsersGuide.ps: MEDMEM_UsersGuide.dvi
+ dvips -o MEDMEM_UsersGuide.ps MEDMEM_UsersGuide.dvi
+
+MEDMEM_UsersGuide.pdf: MEDMEM_UsersGuide.ps
+ ps2pdf MEDMEM_UsersGuide.ps MEDMEM_UsersGuide.pdf
+
+MEDMEM_UsersGuide_2on1.ps: MEDMEM_UsersGuide.ps
+ psnup -2 MEDMEM_UsersGuide.ps >MEDMEM_UsersGuide_2on1.ps
+
+MEDMEM_UsersGuide_2on1.pdf: MEDMEM_UsersGuide_2on1.ps
+ ps2pdf MEDMEM_UsersGuide_2on1.ps MEDMEM_UsersGuide_2on1.pdf
+
+
+MEDMEM_UML.eps:MEDMEM_UML.dia
+ dia -e $@ $<
+
+MEDMEM_UsersGuide.dvi: MEDMEM_UsersGuide.tex MEDMEM_UML.eps
+ echo "Running latex..."
+ latex $<
+ #echo "Running makeindex..."
+ #makeindex MEDMEM_UsersGuide.idx
+ echo "Rerunning latex...."
+ latex $<
+ latex_count=5
+ while egrep -s 'Rerun (LaTeX|to get cross-references right)' MEDMEM_UsersGuide.log && [ $latex_count -gt 0 ] ;\
+ do \
+ echo "Rerunning latex...." ;\
+ latex $< ;\
+ latex_count=`expr $latex_count - 1` ;\
+ done
+
+MEDMEM_UsersGuide.tex:MEDMEM_UsersGuide.tex.in
+ cd $(top_builddir) && CONFIG_FILES=./doc/MEDMEM/MEDMEM_UsersGuide.tex ./config.status
+
+# install procedure
+
+install: $(datadir)/doc ps_2on1 pdf_2on1
+ $(RM) -r $(datadir)/doc/html_ref_user $(datadir)/doc/html_ref_devel $(datadir)/doc/*.ps $(datadir)/doc/*.pdf
+ cp -rf ./doc_ref_user/html $(datadir)/doc/html_ref_user
+ cp -rf ./doc_ref_devel/html $(datadir)/doc/html_ref_devel
+ cp -f MedMemory_user_2on1.ps MedMemory_user_2on1.pdf $(datadir)/doc
+ cp -f MEDMEM_UsersGuide_2on1.ps MEDMEM_UsersGuide_2on1.pdf $(datadir)/doc
+ cp -f MedMemory_devel_2on1.ps MedMemory_devel_2on1.pdf $(datadir)/doc
+
+$(datadir)/doc:
+ $(INSTALL) -d $@ && chmod 755 $@
+
+cleandoc:
+ -$(RM) -r *pdf *ps doc_ref_* $(top_builddir)/src/MEDMEM/doc_ref_* .dep*
--- /dev/null
+1- Gerer l'appartenance d'un driver type 3 Within l'objet
+
+2- Within les méthodes addDriver :
+ driver = instances[driverType]->run(fileName, this) ; --> Il faut vérifier que le numéro auquel on accède existe !
srcdir=@srcdir@
VPATH=.:@srcdir@
-SUBDIRS=html
+SUBDIRS=html MEDMEM
doc:
@@SETX@; for d in $(SUBDIRS); do \
--- /dev/null
+H1 { text-align: center; }
+CAPTION { font-weight: bold }
+A.qindex {}
+A.qindexRef {}
+A.el { text-decoration: none; font-weight: bold }
+A.elRef { font-weight: bold }
+A.code { text-decoration: none; font-weight: normal; color: #4444ee }
+A.codeRef { font-weight: normal; color: #4444ee }
+A:hover { text-decoration: none; background-color: lightblue }
+DL.el { margin-left: -1cm }
+DIV.fragment { width: 100%; border: none; background-color: #CCCCCC }
+DIV.ah { background-color: #CCCCCC; font-weight: bold; color: #ffffff; margin-bottom: 3px; margin-top: 3px }
+TD.md { background-color: lightblue; font-weight: bold; }
+TD.mdname1 { background-color: lightblue; font-weight: bold; color: #602020; }
+TD.mdname { background-color: lightblue; font-weight: bold; color: #602020; width: 600px; }
+DIV.groupHeader { margin-left: 16px; margin-top: 12px; margin-bottom: 6px; font-weight: bold }
+DIV.groupText { margin-left: 16px; font-style: italic; font-size: smaller }
+BODY { background: url(sources/bg_salomepro.gif) }
+TD.indexkey {
+ background-color: #CCCCCC;
+ font-weight: bold;
+ padding-right : 10px;
+ padding-top : 2px;
+ padding-left : 10px;
+ padding-bottom : 2px;
+ margin-left : 0px;
+ margin-right : 0px;
+ margin-top : 2px;
+ margin-bottom : 2px
+}
+TD.indexvalue {
+ background-color: #CCCCCC;
+ font-style: italic;
+ padding-right : 10px;
+ padding-top : 2px;
+ padding-left : 10px;
+ padding-bottom : 2px;
+ margin-left : 0px;
+ margin-right : 0px;
+ margin-top : 2px;
+ margin-bottom : 2px
+}
+span.keyword { color: #008000 }
+span.keywordtype { color: #604020 }
+span.keywordflow { color: #e08000 }
+span.comment { color: #800000 }
+span.preprocessor { color: #806020 }
+span.stringliteral { color: #002080 }
+span.charliteral { color: #008080 }
aux1 = insFld(foldersTree, gFld("IDL/Python mapping", ""))
insDoc(aux1, gLnk("Mapping of MED IDL definitions to Python language", "", "page2.html"))
+aux1 = insFld(foldersTree, gFld("Med Memory Documentations", ""))
+ insDoc(aux1, gLnk("Users documentation", "", "../html_ref_user/index.html"))
+ insDoc(aux1, gLnk("Developpers documentation", "", "../html_ref_devel/index.html"))
