1 %% LyX 1.1 created this file. For more info, see http://www.lyx.org/.
2 %% Do not edit unless you really know what you are doing.
3 \documentclass[11pt,a4paper,english]{report}
4 \usepackage[T1]{fontenc}
5 \usepackage[latin1]{inputenc}
7 \usepackage{graphicx} \setcounter{secnumdepth}{3}
8 \setcounter{tocdepth}{3}
9 \setlength\parskip{\medskipamount}
10 \setlength\parindent{0pt}
14 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% LyX specific LaTeX commands.
15 \providecommand{\LyX}{L\kern-.1667em\lower.25em\hbox{Y}\kern-.125emX\@}
17 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% User specified LaTeX commands.
19 %%\usepackage[french]{babel}
21 %\usepackage[dvips]{graphicx}
22 %\usepackage{fancyhdr}
25 %\usepackage[dvips,all,light]{draftcopy}
29 % ___________________________________________________________________________
32 % |___________________________________________________________________________|
33 %\draftcopyName{Projet}{200}
35 \setlength{\oddsidemargin}{0cm}
36 \setlength{\marginparsep}{0cm}
37 \setlength{\marginparwidth}{0cm}
39 \setlength{\textwidth}{16cm}
41 \setlength{\topmargin}{0cm}
42 \setlength{\headheight}{0cm}
43 \setlength{\headsep}{0cm}
45 \setlength{\textheight}{24cm}
47 % ___________________________________________________________________________
49 % | COMMANDES UTILISATEUR |
50 % |___________________________________________________________________________|
52 \newcommand{\method}[1]{method \mbox{\textbf{#1}}}
54 \newcommand{\myref}[1]{\ref{#1}, page \pageref{#1}}
56 \newcommand{\fileCxx}[1]{
57 \subsection{Full C++ example~: }
59 \verbatiminput{@srcdir@/#1}
62 \newcommand{\filePython}[1]{
63 \subsection{Full Python example~: }
65 \verbatiminput{@srcdir@/#1}
69 % ___________________________________________________________________________
72 % |___________________________________________________________________________|
74 \title{User's Guide Of Med Memory}
75 \author{Patrick Goldbronn \and Eric Fayolle \and Nadir Bouhamou \and Jerome Roy \and Nicolas Crouzet}
77 % ___________________________________________________________________________
79 % | DEBUT DU DOCUMENT |
80 % |___________________________________________________________________________|
90 % ___________________________________________________________________________
92 % | TABLE DES MATIERES |
93 % |___________________________________________________________________________|
98 % ___________________________________________________________________________
101 % |___________________________________________________________________________|
103 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
104 \chapter{Introduction}
105 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
111 \item Difference between local and global number~: when we talk about an
112 element number, we could see $i^{th}$ quadrangle ($i^{th}$ in quadrangles
113 array~: local numbering) or $j^{th}$ element ($j^{th}$ in all elements array~:
114 global numbering). This two numbering are equivalent only if we have one
117 \item All numbering begin at one (take care of array index !) ;
118 \item When you get a C type array with a \texttt{get...} method, you must
119 not replace some value of it. Access is in read only. Other use may
120 product an impredicable result. To modify a such array use method
122 \item Difference between local and global number~: when we talk about an
123 element number, we could see \( i^{th} \) quadrangle (\( i^{th} \)
124 in quadrangles array~: local numbering) or \( j^{th} \) element
125 (\( j^{th} \) in all elements array~: global numbering). This two
126 numbering are equivalent only if we have one geometric type.
127 \item They are many methods that have two syntax (one singular and one
128 plural). Plurals methods returns array and singulars methods returns one
129 particular value in this array (see \method{getCoordinate} and
130 \method{getCoordinates}).
134 \section{UML diagram}
136 \includegraphics[width=16cm]{MEDMEM_UML.eps}
138 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
139 \chapter{How to use MED object}
140 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
142 \section{General Information}
144 A typical use of this object is to mount in memory what is in a MED file (or
145 any type of driver in red or read/write mode) and it will manage its memory on
146 its own. Then from this object one can get some information such as~:
149 \item the number of meshes stored in this object using the
150 {\method{getNumberOfMeshes}}.
151 \item the number of fields stored in this object using the
152 {\method{getNumberOfFields}}.
153 \item a list of mesh names using the {\method{getMeshNames}}.
154 \item a list of field names using the {\method{getFieldNames}}.
155 \item a list of MESH object using the {\method{getMesh}}
156 \item a list of FIELD object using the {\method{getField}}
157 \item a list of SUPPORT object on all type of entities (node, cell,
158 face in 3d or edge on 2d) using the {\method{getSupport}}.
161 The destuctor of this object will destruct itself all FIELD, SUPPORT and MESH
162 objects; via its get method you will have a pointeur on this object and you
163 should never delete it.
165 One can add as well some MESH or FIELD object via the {\method{addMesh}} and
166 the {\method{addField}} respectively.
168 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
169 \chapter{How to use MESH object}
170 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
173 \section{General Information}
175 We could get some general information about a MESH object such as~:
178 \item name (\method{getName})
179 \item a description (\method{getDescription})
180 \item the space dimension (\method{getSpaceDimension})
181 \item the mesh dimension (\method{getMeshDimension})
183 \fileCxx{MESHgeneral.cxx}
185 \filePython{MESHgeneral.py}
187 \section{Information about nodes}
190 \item I want to get the number of nodes~: Realy simple, use \method{getNumberOfNodes}.
191 \item I want to get the coordinates components names~: use \method{getCoordinatesNames}
192 which return a string array (one string for each space dimension)
193 \item I want to get the coordinates components units~: use \method{getCoordinatesUnits}
194 which return a string array (one string for each space dimension)
195 \item I want to get the coordinates system~: use \method{getCoordinatesSystem}
196 which return a string (\verb+"CARTESIAN"+, \verb+"CYLINDRICAL"+ or \verb+"SPHERICAL"+).
197 \item I want to get the nodes coordinates~: use \method{getCoordinates}
198 which return a pointer to the coordinates array where values are interlace
199 or no. \textbf{Warning~:}
202 \item When we get coordinates in \verb+MED_NO_INTERLACE+ mode, we get an
203 array where values are ordered like (\verb+X1,X2,X..., Y1,Y..., Z1,Z...+).
204 \item When we get coordinates in \verb+MED_FULL_INTERLACE+ mode, we get
205 an array where values are ordered like (\verb+X1,Y1,Z1, X2,Y2,Z2, ...+).
207 \item I want to get one particular value of coordinate~: use \method{getCoordinate}
208 which return the value of \( i^{th} \) node and \( j^{th} \) axis.
210 \fileCxx{MESHcoordinates.cxx}
212 \filePython{MESHcoordinates.py}
214 \section{Information about cells}
217 \item I want to get the number of geometric type for a mesh entity~: use
218 \method{getNumberOfTypes}
221 \textbf{C++ Example~:}
223 \verb+int NumberOfCellsTypes = myMesh.getNumberOfTypes(MED_CELL);+
226 \item I want to get all geometric type for a mesh entity~: use
227 \method{getTypes} to get an array of \verb+medGeometryElement+
228 (to use directly in others methods) or \method{getCellsTypes} to get
229 an array of \verb+CELLMODEL+ (to ask mode information~: see \myref{CellModel}) .
231 \textbf{C++ Example~:}
233 \verb+const medGeometryElement * Types = myMesh.getTypes(MED_CELL);+
235 \verb+const CELLMODEL * CellsTypes = myMesh.getCellsTypes(MED_CELL);+
237 (each arrays are size \verb+NumberOfCellsTypes+)
239 \item I want to get the number of cells~: use \method{getNumberOfElements}
240 which return this information. You must give the mesh entity (\verb+MED_CELL+,
241 \verb+MED_FACE+, \verb+MED_EDGE+ or \verb+MED_NODE+) and a geometric
245 \textbf{C++ Example~:}
247 \verb+int NumberOfTriangle = myMesh.getNumberOfElements(MED_FACE,MED_TRIA3);+
249 \verb+int NumberOfFace = myMesh.getNumberOfElements(MED_FACE,MED_ALL_ELEMENT);+
251 \item I want to get the geometric type of one element~: use \method{getElementType}
252 which return a \verb+medGeometryElement+.
255 \textbf{C++ Example~:}
257 \verb+medGeometryElement myType = myMesh.getElementType(MED_FACE,10);+
259 Return the \verb+medGeometryElement+ of \( 10^{th} \) face.
261 \item I want to get a connectivity~: use \method{getConnectivity} which
262 return an array with connectivity values.
265 \label{getConnectivity}
267 \textbf{C++ Example~:}
270 int NumberOfTetrahedron = myMesh.getNumberOfElements(MED_CELL,MED_TETRA4);
271 const int * TetrahedronConnectivity =
272 myMesh.getConnectivity(MED_FULL_ENTERLACE,
277 \verb+TetrahedronConnectivity+ contain nodal connectivity
278 of tetrahedron in mesh. It is arranged in full enterlace mode and
279 its size is \verb+NumberOfTetrahedron x 4+.
281 If you want to get connectivity of all elements (with \verb+Type=MED_ALL_ELEMENTS+),
282 you must use the index array (return by \method{getConnectivityIndex})
283 to get connectivity for each elements (see example \myref{MESHconnectivities.cxx}).
285 \item I want to get an element number from a connectivity~: use \method{getElementNumber}
286 which return the global number of a given connectivity.
289 \textbf{C++ Example~:}
291 int * myElementConnectivity = {2,10,12,14};
292 int myNumber = myMesh.getElementNumber(MED_NODAL,MED_CELL,
293 myElementConnectivity);
297 \fileCxx{MESHconnectivities.cxx}
299 \filePython{MESHconnectivities.py}
301 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
302 \chapter{How to use MESHING object}
303 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
305 This class is a derivated class of MESH class to build a MESH object from
306 scratch (use of set methods).
308 All verifications are under user responsability : If arrays values or arrays
309 dimensions are wrongs, results are impredicable.
311 All arrays in arguments in set methods are duplicated in MESHING object.
313 \section{Build a MESHING}
317 \subsection{Coordinates}
319 First we must defined points coordinates of the mesh. We use
320 \method{setCoordinates}.
322 \textbf{C++ Example~:}
325 const int SpaceDimension=2;
326 const int NumberOfNodes=6;
327 int * Coordinates = new int[SpaceDimension*NumberOfNodes] ;
328 string System="CARTESIAN";
329 medModeSwitch MED_FULL_INTERLACE ;
330 myMeshing.setCoordinates(SpaceDimension,NumberOfNodes,Coordinates,System,Mode);
333 Then you could set the coordinates names and units (with
334 \method{setCoordinatesNames} and \method{setCoordinatesUnits}).
336 \subsection{Connectivities}
338 When coordinates are defined, we could defined connectivities.
340 First we must defined connectivity of MED\_CELL elements.
341 After, we could defined constituent connectivity if necesary
342 (MED\_FACE and/or MED\_EDGE).
344 For each connectivities, you could use some methods in the following order :
346 \item \method{setNumberOfTypes} to set the number of differents geometrics
347 types (3 for example). This method allocates all arrays which size is this
349 \item \method{setTypes} to set the differents geometrics types
350 ({MED\_TETRA4,MED\_PYRA5,MED\_HEXA8} for example). Types should be given
351 in increasing order of number of nodes for this type ;
352 \item \method{setNumberOfElements} to set the number of elements for
353 each geometric type. This method allocates connectivities array ;
354 \item \method{setConnectivity} to set the connectivity in MED\_FULL\_INTERLACE
355 mode for each geometric type ;
358 \textbf{C++ Example~:}
361 myMeshing.setCoordinates(SpaceDimension,NumberOfNodes,Coordinates,System,Mode);
363 myMeshing.setNumberOfTypes(2,MED_CELL);
364 myMeshing.setTypes({MED_TRIA3,MED_QUAD4},MED_CELL);
365 myMeshing.setNumberOfElements({3,2},MED_CELL); // 3 MED_TRIA3 and 2 MED_QUAD4
366 myMeshing.setConnectivity({1,2,3,6,8,9,4,5,6},MED_CELL,MED_TRIA3);
367 myMeshing.setConnectivity({1,3,4,5,4,5,7,8},MED_CELL,MED_QUAD4);
371 \section{Defined a GROUP object}
373 To add a group in a MESHING object, use \method{addGroup}.
375 This method duplicate the GROUP object in the MESH object.
377 To build this GROUP object, use SUPPORT methods \ref{CreateSupport} to set all attributes.
381 For instance, translation from GROUP objects to FAMILY objects are not completed !
383 You MUST set GROUP objects as if they are FAMILY objects.
385 This feature will be fully implemented in next release of med memory.
389 \fileCxx{MESHINGexample.cxx}
391 %\filePython{MESHINGexample.py}
393 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
394 \chapter{How to use SUPPORT object}
395 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
397 \section{Create a SUPPORT object}
399 \label{CreateSupport}
401 To create a SUPPORT object, you must give :
404 \item a reference to a MESH object
406 \item on which mesh entity it apply to
408 \textbf{C++ example~:}
410 \verb+SUPPORT mySupport(myMesh,"support on all faces",MED_FACE) ;+
411 By default, this support is defined on all elements of the given entity.
413 If you want a restricted SUPPORT, you must add manualy information
414 about what do you want~:
417 \item is not on all elements~: \verb+mySupport.setAll(false);+
418 \item on how many geometric type~:\\
419 \verb+mySupport.setNumberOfGeometricType(myNumberOfGeometricType);+
420 \item on which geometric type~:\\
421 \verb+mySupport.setGeometricType(myGeometricType);+
422 \item Temporary : the Gauss point number for each geometric type~:\\
423 \verb+mySupport.setNumberOfGaussPoint(myNumberOfGaussPoint);+
424 \item the number of elements for each geometric type~:\\
425 \verb+mySupport.setNumberOfEntities(myNumberOfEntities);+
426 \item the total number of elements~:\\
427 \verb+mySupport.setTotalNumberOfEntities(myTotalNumberOfEntities);+
428 \item the array which contains elements for each geometric type~:\\
429 \verb+mySupport.setNumber(myNumber);+
431 You could also use \method{setpartial} which set all you need.
434 \section{Use a SUPPORT object}
436 You could get all basic information (as you set them in \myref{CreateSupport})~:
439 \item \verb+getName()+
440 \item \verb+getDescription()+
441 \item \verb+getMesh()+
442 \item \verb+getEntity()+
443 \item \verb+isOnAllElements()+
444 \item \verb+getNumberOfTypes()+
445 \item \verb+getTypes()+
446 %\item \verb+getNumberOfGaussPoint()+
447 %\item \verb+getNumberOfGaussPoint(myGeometricType)+
448 \item \verb+getGeometricTypeNumber()+
449 \item \verb+getNumberOfElements(myGeometricType)+
450 \item \verb+getNumber(myGeometricType)+
451 \item \verb+getNumberIndex()+
453 For details about this methods, see the reference manual \cite{RefManual}.
455 The use of \method{getNumber} and \method{getNumberIndex} are the
456 same as \method{getConnectivity} and \method{getConnectivityIndex}
457 (see item \myref{getConnectivity}
459 There is another particular method to blend another SUPPORT object
465 SUPPORT myOtherSupport ;
467 mySupport.blending(myOtherSupport) ;
470 \verb+mySupport+ contain now all elements defined originally in it,
471 more those defined in \verb+myOtherSupport+.
474 \section{Case of FAMILY object}
476 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) :
478 \item \method{getIdentifier} return the family identifier (an integer)
480 \item \method{getNumberOfAttributes} return the number of attributes of this family
481 \item \method{getAttributesIdentifiers} and \method{getAttributeIdentifier} return an integer array or an integer that represent attribut identifier.
482 \item \method{getAttributesValues} and \method{getAttributeValue} return an integer array or an integer that represent attribut value.
483 \item \method{getAttributesDescriptions} and \method{getAttributeDescription} return a string array or a string that represent attribut description.
485 \item \method{getNumberOfGroups} return the number of groups which it belog to.
486 \item \method{getGroupsNames} and \method{getGroupName} return a string array or a string that represent the group name which it belog to.
490 \section{Case of GROUP object}
492 A GROUP is a SUPPORT with some additionnal methods to find FAMILY that make up it :
494 \item \method{getNumberOfFamilies} return the number of FAMILY that make up the GROUP ;
495 \item \method{getFamilies} and \method{getFamily} return a FAMILY array or a FAMILY that make up the GROUP.
498 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
499 \chapter{How to use Field}
500 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
502 \section{Introduction}
504 A field is characterized by its name (\method{getName}) and an optional description (\method{getDescription}).
506 It is also characterized by this calculating moment :
508 \item an iteration number (time step number)
509 \item an order number (use if there are internal iteration in a time step)
510 \item the time that correspond to this iteration number.
513 By default, there are no iteration and order number defined (value
514 MED\_NOPDT and MED\_NONOR).
516 A field contain values which apply on some nodes or elements (cell, face or edge).
518 We find these informations from a SUPPORT object (see \method{getSupport}).
520 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}).
522 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.
524 To get values of a FIELD, you could use \method{getValue}, \method{getValueI}
525 and \method{getValueIJ}~:
528 \item First return a reference to all values in the given mode (full or no
530 \item Second return a reference to $i^{th}$ element values or component values (in accordance with the given mode).
531 \item Third return the $j^{th}$ component of $i^{th}$ element.
534 \fileCxx{FIELDgeneral.cxx}
536 \filePython{FIELDgeneral.py}
538 \section{Create a Field}
540 It is simple to create a field object. You must know its SUPPORT and the number of components.
543 \verb+FILED<double> myField(mySupport,NumberOfComponents) ;+
545 You must now set a name (\method{setName}) and optionaly a description
546 (\method{setDescription}).
548 By default there are no iteration and order number (negative values) and
549 time is null. You could change this by using \method{setIterationNumber},
550 \method{setOrderNumber} and \method{setTime}.
552 You \textbf{SHOULD} also set unit of your components with \method{setMEDComponentUnit}
554 To set value, use \method{setValueIJ} to put new value of field.
556 \fileCxx{FIELDcreate.cxx}
558 \filePython{FIELDcreate.py}
560 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
561 \chapter{Other Classes}
562 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
565 \section{class CELLMODEL}
575 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
576 \chapter{Using drivers}
577 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
579 The generic driver mecanism gives users the possibility to write/read
580 the content of an object according to a specified file format. The
581 semantic remains the same whatever the object is (MESH, FIELD, MED).
582 By the way it allows using several file formats for writting an object.
585 \section{Invoking a driver}
588 \subsection{Invoking a driver at creation object time}
590 This is the simplest way of invoking a driver. The driver parameters
591 are given to the constructor of the object. Except for the MED object,
592 this way of invoking a driver assume you know exactly the name of
593 the MESH/FIELD you want read from a file <fileName> of type <driverType>.
595 ex 1.1 : For a FIELD object, invoking FIELD<double> myField(MED\_DRIVER,fileName,fieldName)
596 create a FIELD object and a driver which loads the mesh <fieldName>
597 from the MED file <fileName> (Not implemented yet !).
599 ex 1.2 : To remove the default driver previously created myField->rmDriver();
601 ex 2 : For a MESH object, invoking MESH myMesh(MED\_DRIVER,fileName,meshName)
602 create a MESH object and a driver which loads the mesh <meshName>
603 from the MED file <fileName>.
605 ex 3 : For a MED object, invoking MED myMed(MED\_DRIVER,fileName)
606 create a MED object to explore the MED file <fileName>.
608 rem 1 : ex1 is equivalent to \ref{sec:invoking_a_driver_from_the_std_drv_method}
611 rem 2 : Since the driver has read the object, the associated file
612 is closed. You can reread the object with the default driver by calling
613 the read() method : myObject.read().
615 \fileCxx{MEDMEM_InvokingDriverAtObjectCreationTime.cxx}
617 \filePython{MEDMEM_InvokingDriverAtObjectCreationTime.py}
619 \subsection{Invoking a driver from the standard driver method of an object\label{sec:invoking_a_driver_from_the_std_drv_method}}
621 This way of invoking a driver give the possiblility to add several
622 drivers to an exiting object.
624 ex1 : First we create a FIELD without any driver FIELD<double>~{*}~myField1~=~new~FIELD<double>;
625 then we add a driver with int myDriver1 = myField1->addDriver(driverType1,
626 fileName1, fieldName1); for reading <fieldName1> from file <fileName1>
627 with myField1->read(myDriver1);
629 ex2 : We add a new driver of type <driverType2> int myDriver2 = myField1->addDriver(driverType2,
630 fileName2,fieldName2); in order to write myField1 in file <fileName2>
631 with <fieldName2> name using command myField1->write(myDriver2);
633 rem 1 : Files are openned then closed each time you call read() or
636 rem 2 : If you use more than a driver you need to keep the driver
637 handlers (myDriverI ).
639 \fileCxx{MEDMEM_InvokingDriverFromStandardObjectMethod.cxx}
641 \filePython{MEDMEM_InvokingDriverFromStandardObjectMethod.py}
643 \subsection{Invoking a driver and attaching it to an existing object}
645 The methods exposed in the two previous sections always create drivers
646 in read/write access mode. Another way of creating a driver is to
647 create a driver with a specific access mode.
649 ex1 : First we create a FIELD without any driver FIELD<double>~{*}~myField1~=~new
650 FIELD<double>(); then we create a read-only driver MED\_FIELD\_RDONLY\_DRIVER<double>~myRdOnlyDriver(fileName1,myField1);
651 and attached it to myField1. Finally you must set the fieldName1 you
652 want to acess in fileName1 with myRdOnlyDriver->setFieldName(fieldName1);
653 in order to read the field with myRdOnlyDriver->open(); myRdOnlyDriver->read();
655 Don't forget to close the file with myRdOnlyDriver->close().
657 ToDo : By now when you create such specific drivers, the object doesn't
658 know anything about it.
660 \fileCxx{MEDMEM_InvokingDriverByAttachingItToAnObject.cxx}
662 \filePython{MEDMEM_InvokingDriverByAttachingItToAnObject.py}
664 \section{Using the MED driver}
666 The MED object provides the ability of :
669 \item \noindent Obtainning a reference on the whole structure contained
671 \item Obtainning the list of all the Meshes/Fields names contained in a
673 \item Obtainning a Mesh/Field reference using a name.
674 \item Writting a whole set of independent objects with a simple command.
677 \subsection{Exploring files}
679 In this first use case the user wants to explore the meshes \& fields
680 containned within a file <filename> of type given by the <drivertype>
683 ex 1 : Calling MED {*} myMed = new MED(driverType1, fileName1); create
684 a MED object which open fileName1, read all MESHes/FIELDs relations
687 This is equivalent to MED~{*}~myMed~=~new~MED(); myDriver~=~myMed->addDriver(driverType1,fileName1);
688 myMed->readFileStruct(myDriver);
690 ex 2 : To get the list of meshNames from a MED object, first ask the
691 object how many meshes it had by calling int numberOfMeshes~=~myMed->getNumberOfMeshes();
692 then get the list with myMeshNames~=~new string{[}getMeshNames{]};
693 myMed->getMeshNames(myMeshNames).
695 Note you can also use the deque<string> getMeshNames() method.
697 ex 3 : To get a list of fieldNames from a MED object, first ask the
698 object how many fields it had by calling int numberOfFields~=~myMed->getNumberOfFields();
699 then get the list with myFieldNames~=~new string{[}getFieldNames{]};
700 myMed->getFieldNames(myFieldNames).
702 ex 4 :To get a particular MESH use MESH {*} myMesh1 = myMED->getMesh(myMeshNames{[}0{]})
704 ex 5 :To get a particular FIELD you first need to know what (time
705 step, iteration number) list is used by calling deque<DT\_IT\_>~myField1DtIt~=~myMed->getFieldIteration(FieldName{[}0{]})
706 ; then you can ask for getting a specific FIELD with FIELD~{*}~myField1~=~myMED->getField(myFieldNames{[}0{]},myField1DtIt{[}0{]}.dt,myField1DtIt{[}0{]}.it).
708 ex2 : To write the whole content of a MED object first add a driver
709 myDriver2~=~myMed.addDriver(driverType2,~fileName2); then ask for
710 writing the object myMed->write(myDriver2); (not implemented yet !)
712 You can remove the driver with myMed->rmDriver(myDriver2);
714 rem 1 : It is possible to use multiple drivers to read a set of FIELDs
715 / MESHes from various file formats and writing the whole set through
716 a specific write.(not implemented yet !)
719 \subsubsection{Adding existing MESHes/FIELDs objects}
723 \section{Using the VTK driver}
725 This driver allow to save all MESH and FIELD objects in an ASCII file in
726 VTK format \cite{vtk}.
728 You could use this driver only from a MED object, because VTK file format
729 impose to write objects in particular order.
731 \textbf{C++ Example~:}
733 MED myMed(MED_DRIVER,"file.med");
735 int id = myMed.addDriver(VTK_DRIVER,"file.vtk");
739 \section{Using the GIBI driver}
741 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.
743 \textbf{C++ Example~:}
745 MESH * myMesh= new MESH() ;
746 GIBI_MESH_RDONLY_DRIVER myGibiMeshDriver("file.sauve", myMesh) ;
747 myGibiMeshDriver.open() ;
748 myGibiMeshDriver.read() ;
749 myGibiMeshDriver.close() ;
753 % ___________________________________________________________________________
756 % |___________________________________________________________________________|
759 %\thebibliography{biblio}
760 \begin{thebibliography}{1}
762 \addcontentsline{toc}{chapter}{\refname}
764 \addcontentsline{toc}{chapter}{Bibliography}
766 \bibitem{RefManual} Reference Manual~: \verb+http://www-drn2.cea.fr/MED/MEDMEM/DOC/html/index.html+
768 \bibitem{vtk} VTK home page~: \verb+http://public.kitware.com/VTK+
770 \end{thebibliography}