From f430523a5997f72a8f6da47c4d5322b168fabb54 Mon Sep 17 00:00:00 2001 From: nadir Date: Fri, 9 Apr 2004 08:47:32 +0000 Subject: [PATCH] Building a version which will be tagged PreV2_0_0 working with KERNEL V1_4_0. --- doc/MEDMEM/FIELDcreate.cxx | 66 + doc/MEDMEM/FIELDcreate.py | 56 + doc/MEDMEM/FIELDgeneral.cxx | 61 + doc/MEDMEM/FIELDgeneral.py | 43 + doc/MEDMEM/HOWTO Create A New Driver.txt | 40 + ...MEM_InvokingDriverAtObjectCreationTime.cxx | 31 + ...DMEM_InvokingDriverAtObjectCreationTime.py | 31 + ..._InvokingDriverByAttachingItToAnObject.cxx | 81 ++ ...M_InvokingDriverByAttachingItToAnObject.py | 63 + ...InvokingDriverFromStandardObjectMethod.cxx | 45 + ..._InvokingDriverFromStandardObjectMethod.py | 35 + .../MEDMEM_MedAddingAnExistingObject.cxx | 37 + doc/MEDMEM/MEDMEM_UML.dia | Bin 0 -> 1846 bytes doc/MEDMEM/MEDMEM_UsersGuide.lyx | 1248 +++++++++++++++++ doc/MEDMEM/MEDMEM_UsersGuide.tex.in | 773 ++++++++++ doc/MEDMEM/MESHINGexample.cxx | 255 ++++ doc/MEDMEM/MESHconnectivities.cxx | 132 ++ doc/MEDMEM/MESHconnectivities.py | 122 ++ doc/MEDMEM/MESHcoordinates.cxx | 41 + doc/MEDMEM/MESHcoordinates.py | 31 + doc/MEDMEM/MESHgeneral.cxx | 30 + doc/MEDMEM/MESHgeneral.py | 18 + doc/MEDMEM/Makefile.in | 147 ++ doc/MEDMEM/TODO Drivers.txt | 4 + doc/Makefile.in | 2 +- doc/html/INPUT/sources/bg_salomepro.gif | Bin 0 -> 17294 bytes doc/html/INPUT/sources/doxygen.css | 49 + doc/html/INPUT/sources/static/tree.js | 3 + resources/pointe.med | Bin 0 -> 75776 bytes 29 files changed, 3443 insertions(+), 1 deletion(-) create mode 100644 doc/MEDMEM/FIELDcreate.cxx create mode 100644 doc/MEDMEM/FIELDcreate.py create mode 100644 doc/MEDMEM/FIELDgeneral.cxx create mode 100644 doc/MEDMEM/FIELDgeneral.py create mode 100644 doc/MEDMEM/HOWTO Create A New Driver.txt create mode 100644 doc/MEDMEM/MEDMEM_InvokingDriverAtObjectCreationTime.cxx create mode 100644 doc/MEDMEM/MEDMEM_InvokingDriverAtObjectCreationTime.py create mode 100644 doc/MEDMEM/MEDMEM_InvokingDriverByAttachingItToAnObject.cxx create mode 100644 doc/MEDMEM/MEDMEM_InvokingDriverByAttachingItToAnObject.py create mode 100644 doc/MEDMEM/MEDMEM_InvokingDriverFromStandardObjectMethod.cxx create mode 100644 doc/MEDMEM/MEDMEM_InvokingDriverFromStandardObjectMethod.py create mode 100644 doc/MEDMEM/MEDMEM_MedAddingAnExistingObject.cxx create mode 100644 doc/MEDMEM/MEDMEM_UML.dia create mode 100644 doc/MEDMEM/MEDMEM_UsersGuide.lyx create mode 100644 doc/MEDMEM/MEDMEM_UsersGuide.tex.in create mode 100644 doc/MEDMEM/MESHINGexample.cxx create mode 100644 doc/MEDMEM/MESHconnectivities.cxx create mode 100644 doc/MEDMEM/MESHconnectivities.py create mode 100644 doc/MEDMEM/MESHcoordinates.cxx create mode 100644 doc/MEDMEM/MESHcoordinates.py create mode 100644 doc/MEDMEM/MESHgeneral.cxx create mode 100644 doc/MEDMEM/MESHgeneral.py create mode 100644 doc/MEDMEM/Makefile.in create mode 100644 doc/MEDMEM/TODO Drivers.txt create mode 100755 doc/html/INPUT/sources/bg_salomepro.gif create mode 100755 doc/html/INPUT/sources/doxygen.css create mode 100644 resources/pointe.med 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 0000000000000000000000000000000000000000..13d59840cd73f06b95f5382e0a8e643b29809aae GIT binary patch literal 1846 zcmV-62g&#!iwFP!000001MOW~liD^Ee&1igkhcyiTe2nFS#~pN)25k8CYf9w`m`g! z%epl-Bb#iu5B=?x3@jLAYzsMoM*F}F==gAib-wRhB=7LW-?O;)HDpeV)&sTh_zF1Bf3pnx_oJ(E?w-5=5MUsIMYl1YCl!DYs2oU-0m8ejLH-4%a*YjwHxbbW=s zIh}`WTh(lyW)UCGALo0+lIz9m);O2QxIi+!dG^wMHndi6HrMYOBvqQvD4Rw}SuYD| zyqqKgK3dPPxzbS=O5-k+vM!WH+3h@KIipctRy<16IHbu^_Z^M1u)XqZOk;kZt1O1? zHQq&eo*rrF(0W?VQg;|yJN`C|>0`)N7W};NwBFY!i$<|nnQXCM?!$ESXE@GRj`HQ* z+umjGmzZW*e*+43zZXre`|s_IhwV<3YvDI0+xD?}8YTJamvaa1W|p!!%Jhv!+v*s% zk|xtQT&Z+GfCu8`3VMJ9J{k~!aJz2_<8XF6PFYe$hodYnbUs9r{Jw1cdKEcik{T zI`~R$Ox5@5e^{K4UM*d#^Ut~5r)PgwR_@tXki-PS9;L#zc zijJ>8zW?&UfTICN1CCN~d>wMEpmFq1VXy=xv3jcx*w{q{jOlOLAzP?Mz~OKSMG1xn zm~9IgDa-F~3ya&$p+W{%N$`;L;9%=uTiBhlC`?M25+;k8tiQbZ+^+Z>>cCp-n}F*$ zO%lEsgmabB#r3DXdzwr{XPU3yJS`e3z0K%#pOk(A$#rmbom0N9bc^b?e95|4zo=y7xD?@;W7ddzoeFII40sPdW52g555Bjk6fBvCpG(;Bj9g z0DBk>_@~;PO*#j;2<9$VDdX@#VQ>>6&dxUe;k<4VvE{Pu*BRO-Desxqhzz)wfjSSe%a!>;zj+ud3ypH5jgEl1vmR+d`b`qb_T zJokHItKAbVoVLSF-jUo?Rgm(PLqPrYsI8qpE+-`4?`Y$X_G**^JlpqAwH)<|Mf|p# zdX%Y0nR=8$+#V<+q*rW~7CXCj=g0&=v1i;Z!giM@%3hH$yZV!4*&O5|J_uYC1P2mf z1pS6mt*OPt?PnRcTjv-RqW@o{ZktG5JyN$TBlT9*CwOFp|0)<>mC~(o>k=-Rr=sz z-`%M=<4%1S9^Iya`kOQm4{+hOE(nT#4eYW<1M508LAAiaF=Bl7%)32}eb(0Nvxl=r zh>kgKteQJh7u}amVyFqYkhMsuwVs;g8bMfoGkNm?Y68i3gHIrzvUq zdXvN&(sEAhpd$o`tU}8xo}f9!mODo`ZS5N`8OMN!nUx|4cn~!da+GFZILvUE;V{Et z-;u+R-tDP1T%>+f1{Y`N^q(gzx7|FkcMgl)azy)XImry<5;g6#hP^rUPNiX{b7iI< z6bMZ(^b|q_Ep)VVS^_E70lV5+2k{XtH-B*H0BAcH>F>FDxKNI{@++Q<_yh)nOL3B^ z^|v+HYo|Vy`b~E>gu&@PiqJen#_YH=JMNT1fAw=|;#`P$uByx9S>4EqgzihRSD`>o z4?sUa15xs6|7G>96!}bKLU7lD9U%uali?f?2$(i!X3UuxlLMHF;de|2j%E<$!%Rn=s z@wa>|08~DKxqNz;4@i6NsDHq4k?FYW8j)Qz-cbi6C7*;$2Dk@#2LjSa<`M#1p{{1Q k$s{=@$uaRlM@i1mD*o-!&BfFIL%O;64|Jd9hTUuc0L?p?&j0`b literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..677b70468f798fe4fbc20fac3d706e61179ff12b GIT binary patch literal 17294 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 literal 0 HcmV?d00001 -- 2.39.2