From: nadir Date: Fri, 9 Apr 2004 08:47:32 +0000 (+0000) Subject: Building a version which will be tagged PreV2_0_0 working with KERNEL V1_4_0. X-Git-Tag: PreV2_1_0 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=3f97e534cb0fb5f06119b39177afa9b42cc72ea3;p=tools%2Fmedcoupling.git Building a version which will be tagged PreV2_0_0 working with KERNEL V1_4_0. --- diff --git a/doc/MEDMEM/FIELDcreate.cxx b/doc/MEDMEM/FIELDcreate.cxx new file mode 100644 index 000000000..e94b17b78 --- /dev/null +++ b/doc/MEDMEM/FIELDcreate.cxx @@ -0,0 +1,66 @@ +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 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 ; +} diff --git a/doc/MEDMEM/FIELDcreate.py b/doc/MEDMEM/FIELDcreate.py new file mode 100644 index 000000000..478d6dc56 --- /dev/null +++ b/doc/MEDMEM/FIELDcreate.py @@ -0,0 +1,56 @@ +###################################################################### +# # +# 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) diff --git a/doc/MEDMEM/FIELDgeneral.cxx b/doc/MEDMEM/FIELDgeneral.cxx new file mode 100644 index 000000000..120cef911 --- /dev/null +++ b/doc/MEDMEM/FIELDgeneral.cxx @@ -0,0 +1,61 @@ +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 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;igetNumberOfElements(MED_ALL_ELEMENTS); + // Value + const double * Value = myField.getValue(MED_FULL_INTERLACE); + for(int i=0; i inst_med ; + +Within MEDMEM_Object.cxx + // Add a similar line for your personnal driver (step 3) + static INSTANCE_DE 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 ! diff --git a/doc/MEDMEM/MEDMEM_InvokingDriverAtObjectCreationTime.cxx b/doc/MEDMEM/MEDMEM_InvokingDriverAtObjectCreationTime.cxx new file mode 100644 index 000000000..fca94088d --- /dev/null +++ b/doc/MEDMEM/MEDMEM_InvokingDriverAtObjectCreationTime.cxx @@ -0,0 +1,31 @@ +#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 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()) ; + } +} diff --git a/doc/MEDMEM/MEDMEM_InvokingDriverAtObjectCreationTime.py b/doc/MEDMEM/MEDMEM_InvokingDriverAtObjectCreationTime.py new file mode 100644 index 000000000..c13612fb8 --- /dev/null +++ b/doc/MEDMEM/MEDMEM_InvokingDriverAtObjectCreationTime.py @@ -0,0 +1,31 @@ +###################################################################### +# # +# 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 !!" diff --git a/doc/MEDMEM/MEDMEM_InvokingDriverByAttachingItToAnObject.cxx b/doc/MEDMEM/MEDMEM_InvokingDriverByAttachingItToAnObject.cxx new file mode 100644 index 000000000..b8c110ad2 --- /dev/null +++ b/doc/MEDMEM/MEDMEM_InvokingDriverByAttachingItToAnObject.cxx @@ -0,0 +1,81 @@ +#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 * myField = new FIELD(); + MED_FIELD_RDONLY_DRIVER 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 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()) ; + } +} diff --git a/doc/MEDMEM/MEDMEM_InvokingDriverByAttachingItToAnObject.py b/doc/MEDMEM/MEDMEM_InvokingDriverByAttachingItToAnObject.py new file mode 100644 index 000000000..beb217667 --- /dev/null +++ b/doc/MEDMEM/MEDMEM_InvokingDriverByAttachingItToAnObject.py @@ -0,0 +1,63 @@ +###################################################################### +# # +# 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 !!" diff --git a/doc/MEDMEM/MEDMEM_InvokingDriverFromStandardObjectMethod.cxx b/doc/MEDMEM/MEDMEM_InvokingDriverFromStandardObjectMethod.cxx new file mode 100644 index 000000000..87ed74393 --- /dev/null +++ b/doc/MEDMEM/MEDMEM_InvokingDriverFromStandardObjectMethod.cxx @@ -0,0 +1,45 @@ +#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 * myField = new FIELD(); + 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()) ; + } +} diff --git a/doc/MEDMEM/MEDMEM_InvokingDriverFromStandardObjectMethod.py b/doc/MEDMEM/MEDMEM_InvokingDriverFromStandardObjectMethod.py new file mode 100644 index 000000000..3ddef5fad --- /dev/null +++ b/doc/MEDMEM/MEDMEM_InvokingDriverFromStandardObjectMethod.py @@ -0,0 +1,35 @@ +###################################################################### +# # +# 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 !!" diff --git a/doc/MEDMEM/MEDMEM_MedAddingAnExistingObject.cxx b/doc/MEDMEM/MEDMEM_MedAddingAnExistingObject.cxx new file mode 100644 index 000000000..b137c94b0 --- /dev/null +++ b/doc/MEDMEM/MEDMEM_MedAddingAnExistingObject.cxx @@ -0,0 +1,37 @@ +#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()) ; + } +} diff --git a/doc/MEDMEM/MEDMEM_UML.dia b/doc/MEDMEM/MEDMEM_UML.dia new file mode 100644 index 000000000..13d59840c Binary files /dev/null and b/doc/MEDMEM/MEDMEM_UML.dia differ diff --git a/doc/MEDMEM/MEDMEM_UsersGuide.lyx b/doc/MEDMEM/MEDMEM_UsersGuide.lyx new file mode 100644 index 000000000..e0008ba8c --- /dev/null +++ b/doc/MEDMEM/MEDMEM_UsersGuide.lyx @@ -0,0 +1,1248 @@ +#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 + of type . +\layout Standard + +ex 1.1 : For a FIELD object, invoking FIELD myField(MED_DRIVER,fileName,f +ieldName) create a FIELD object and a driver which loads the mesh + from the MED file (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 from + the MED file . +\layout Standard + +ex 3 : For a MED object, invoking MED myMed(MED_DRIVER,fileName) create + a MED object to explore the MED file . +\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\SpecialChar ~ +*\SpecialChar ~ +myField1\SpecialChar ~ +=\SpecialChar ~ +new\SpecialChar ~ +FIELD +; then we add a driver with int myDriver1 = myField1->addDriver(driverTy +pe1, fileName1, fieldName1); for reading from file + with myField1->read(myDriver1); +\layout Standard + +ex2 : We add a new driver of type int myDriver2 = myField1->addDri +ver(driverType2, fileName2,fieldName2); in order to write myField1 in file + with 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\SpecialChar ~ +*\SpecialChar ~ +myField1\SpecialChar ~ +=\SpecialChar ~ +new + FIELD(); then we create a read-only driver MED_FIELD_RDONLY_DRIVER\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 of type given by the 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 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\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 diff --git a/doc/MEDMEM/MEDMEM_UsersGuide.tex.in b/doc/MEDMEM/MEDMEM_UsersGuide.tex.in new file mode 100644 index 000000000..65043f532 --- /dev/null +++ b/doc/MEDMEM/MEDMEM_UsersGuide.tex.in @@ -0,0 +1,773 @@ +%% 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 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 of type . + +ex 1.1 : For a FIELD object, invoking FIELD myField(MED\_DRIVER,fileName,fieldName) +create a FIELD object and a driver which loads the mesh +from the MED file (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 +from the MED file . + +ex 3 : For a MED object, invoking MED myMed(MED\_DRIVER,fileName) +create a MED object to explore the MED file . + +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~{*}~myField1~=~new~FIELD; +then we add a driver with int myDriver1 = myField1->addDriver(driverType1, +fileName1, fieldName1); for reading from file +with myField1->read(myDriver1); + +ex2 : We add a new driver of type int myDriver2 = myField1->addDriver(driverType2, +fileName2,fieldName2); in order to write myField1 in file +with 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~{*}~myField1~=~new +FIELD(); then we create a read-only driver MED\_FIELD\_RDONLY\_DRIVER~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 of type given by the +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 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~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} diff --git a/doc/MEDMEM/MESHINGexample.cxx b/doc/MEDMEM/MESHINGexample.cxx new file mode 100644 index 000000000..2ec7a16ee --- /dev/null +++ b/doc/MEDMEM/MESHINGexample.cxx @@ -0,0 +1,255 @@ +#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) ; + +} diff --git a/doc/MEDMEM/MESHconnectivities.cxx b/doc/MEDMEM/MESHconnectivities.cxx new file mode 100644 index 000000000..2964ff9f8 --- /dev/null +++ b/doc/MEDMEM/MESHconnectivities.cxx @@ -0,0 +1,132 @@ +#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; iMEDMEM_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* diff --git a/doc/MEDMEM/TODO Drivers.txt b/doc/MEDMEM/TODO Drivers.txt new file mode 100644 index 000000000..d6cd93c78 --- /dev/null +++ b/doc/MEDMEM/TODO Drivers.txt @@ -0,0 +1,4 @@ +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 ! diff --git a/doc/Makefile.in b/doc/Makefile.in index e224c161d..5f5e47a48 100644 --- a/doc/Makefile.in +++ b/doc/Makefile.in @@ -11,7 +11,7 @@ top_builddir=.. srcdir=@srcdir@ VPATH=.:@srcdir@ -SUBDIRS=html +SUBDIRS=html MEDMEM doc: @@SETX@; for d in $(SUBDIRS); do \ diff --git a/doc/html/INPUT/sources/bg_salomepro.gif b/doc/html/INPUT/sources/bg_salomepro.gif new file mode 100755 index 000000000..677b70468 Binary files /dev/null and b/doc/html/INPUT/sources/bg_salomepro.gif differ diff --git a/doc/html/INPUT/sources/doxygen.css b/doc/html/INPUT/sources/doxygen.css new file mode 100755 index 000000000..6e2c772fe --- /dev/null +++ b/doc/html/INPUT/sources/doxygen.css @@ -0,0 +1,49 @@ +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 } diff --git a/doc/html/INPUT/sources/static/tree.js b/doc/html/INPUT/sources/static/tree.js index 9f2fbf13f..761dcbf31 100755 --- a/doc/html/INPUT/sources/static/tree.js +++ b/doc/html/INPUT/sources/static/tree.js @@ -18,3 +18,6 @@ aux1 = insFld(foldersTree, gFld("TUI Reference Guide", "")) 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")) diff --git a/resources/pointe.med b/resources/pointe.med new file mode 100644 index 000000000..99ea55289 Binary files /dev/null and b/resources/pointe.med differ