From 3de0601b7c5bb32e31091e8b3c752ab370714c55 Mon Sep 17 00:00:00 2001 From: nadir Date: Fri, 14 Jan 2005 15:59:14 +0000 Subject: [PATCH] comitt of my first step of finalisation of the V2_2_0 version. This version come from my dev on the IntegrationForV2_2_0 branch. --- doc/salome/MEDMEM/FIELDcreate.cxx | 66 + doc/salome/MEDMEM/FIELDcreate.py | 56 + doc/salome/MEDMEM/FIELDgeneral.cxx | 61 + doc/salome/MEDMEM/FIELDgeneral.py | 43 + .../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/salome/MEDMEM/MEDMEM_UML.dia | Bin 0 -> 1846 bytes doc/salome/MEDMEM/MEDMEM_UsersGuide.lyx | 1248 +++++++++++++++++ doc/salome/MEDMEM/MEDMEM_UsersGuide.tex.in | 773 ++++++++++ doc/salome/MEDMEM/MESHINGexample.cxx | 255 ++++ doc/salome/MEDMEM/MESHconnectivities.cxx | 132 ++ doc/salome/MEDMEM/MESHconnectivities.py | 122 ++ doc/salome/MEDMEM/MESHcoordinates.cxx | 41 + doc/salome/MEDMEM/MESHcoordinates.py | 31 + doc/salome/MEDMEM/MESHgeneral.cxx | 30 + doc/salome/MEDMEM/MESHgeneral.py | 18 + doc/salome/MEDMEM/Makefile.in | 147 ++ doc/salome/MEDMEM/TODO Drivers.txt | 4 + resources/poly3D.med | Bin 0 -> 36864 bytes resources/polygones.med | Bin 0 -> 83884 bytes 26 files changed, 3390 insertions(+) create mode 100644 doc/salome/MEDMEM/FIELDcreate.cxx create mode 100644 doc/salome/MEDMEM/FIELDcreate.py create mode 100644 doc/salome/MEDMEM/FIELDgeneral.cxx create mode 100644 doc/salome/MEDMEM/FIELDgeneral.py create mode 100644 doc/salome/MEDMEM/HOWTO Create A New Driver.txt create mode 100644 doc/salome/MEDMEM/MEDMEM_InvokingDriverAtObjectCreationTime.cxx create mode 100644 doc/salome/MEDMEM/MEDMEM_InvokingDriverAtObjectCreationTime.py create mode 100644 doc/salome/MEDMEM/MEDMEM_InvokingDriverByAttachingItToAnObject.cxx create mode 100644 doc/salome/MEDMEM/MEDMEM_InvokingDriverByAttachingItToAnObject.py create mode 100644 doc/salome/MEDMEM/MEDMEM_InvokingDriverFromStandardObjectMethod.cxx create mode 100644 doc/salome/MEDMEM/MEDMEM_InvokingDriverFromStandardObjectMethod.py create mode 100644 doc/salome/MEDMEM/MEDMEM_MedAddingAnExistingObject.cxx create mode 100644 doc/salome/MEDMEM/MEDMEM_UML.dia create mode 100644 doc/salome/MEDMEM/MEDMEM_UsersGuide.lyx create mode 100644 doc/salome/MEDMEM/MEDMEM_UsersGuide.tex.in create mode 100644 doc/salome/MEDMEM/MESHINGexample.cxx create mode 100644 doc/salome/MEDMEM/MESHconnectivities.cxx create mode 100644 doc/salome/MEDMEM/MESHconnectivities.py create mode 100644 doc/salome/MEDMEM/MESHcoordinates.cxx create mode 100644 doc/salome/MEDMEM/MESHcoordinates.py create mode 100644 doc/salome/MEDMEM/MESHgeneral.cxx create mode 100644 doc/salome/MEDMEM/MESHgeneral.py create mode 100644 doc/salome/MEDMEM/Makefile.in create mode 100644 doc/salome/MEDMEM/TODO Drivers.txt create mode 100644 resources/poly3D.med create mode 100644 resources/polygones.med diff --git a/doc/salome/MEDMEM/FIELDcreate.cxx b/doc/salome/MEDMEM/FIELDcreate.cxx new file mode 100644 index 000000000..e94b17b78 --- /dev/null +++ b/doc/salome/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/salome/MEDMEM/FIELDcreate.py b/doc/salome/MEDMEM/FIELDcreate.py new file mode 100644 index 000000000..478d6dc56 --- /dev/null +++ b/doc/salome/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/salome/MEDMEM/FIELDgeneral.cxx b/doc/salome/MEDMEM/FIELDgeneral.cxx new file mode 100644 index 000000000..120cef911 --- /dev/null +++ b/doc/salome/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/salome/MEDMEM/MEDMEM_InvokingDriverAtObjectCreationTime.cxx b/doc/salome/MEDMEM/MEDMEM_InvokingDriverAtObjectCreationTime.cxx new file mode 100644 index 000000000..fca94088d --- /dev/null +++ b/doc/salome/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/salome/MEDMEM/MEDMEM_InvokingDriverAtObjectCreationTime.py b/doc/salome/MEDMEM/MEDMEM_InvokingDriverAtObjectCreationTime.py new file mode 100644 index 000000000..c13612fb8 --- /dev/null +++ b/doc/salome/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/salome/MEDMEM/MEDMEM_InvokingDriverByAttachingItToAnObject.cxx b/doc/salome/MEDMEM/MEDMEM_InvokingDriverByAttachingItToAnObject.cxx new file mode 100644 index 000000000..b8c110ad2 --- /dev/null +++ b/doc/salome/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/salome/MEDMEM/MEDMEM_InvokingDriverByAttachingItToAnObject.py b/doc/salome/MEDMEM/MEDMEM_InvokingDriverByAttachingItToAnObject.py new file mode 100644 index 000000000..beb217667 --- /dev/null +++ b/doc/salome/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/salome/MEDMEM/MEDMEM_InvokingDriverFromStandardObjectMethod.cxx b/doc/salome/MEDMEM/MEDMEM_InvokingDriverFromStandardObjectMethod.cxx new file mode 100644 index 000000000..87ed74393 --- /dev/null +++ b/doc/salome/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/salome/MEDMEM/MEDMEM_InvokingDriverFromStandardObjectMethod.py b/doc/salome/MEDMEM/MEDMEM_InvokingDriverFromStandardObjectMethod.py new file mode 100644 index 000000000..3ddef5fad --- /dev/null +++ b/doc/salome/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/salome/MEDMEM/MEDMEM_MedAddingAnExistingObject.cxx b/doc/salome/MEDMEM/MEDMEM_MedAddingAnExistingObject.cxx new file mode 100644 index 000000000..b137c94b0 --- /dev/null +++ b/doc/salome/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/salome/MEDMEM/MEDMEM_UML.dia b/doc/salome/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/salome/MEDMEM/MEDMEM_UsersGuide.lyx b/doc/salome/MEDMEM/MEDMEM_UsersGuide.lyx new file mode 100644 index 000000000..e0008ba8c --- /dev/null +++ b/doc/salome/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/salome/MEDMEM/MEDMEM_UsersGuide.tex.in b/doc/salome/MEDMEM/MEDMEM_UsersGuide.tex.in new file mode 100644 index 000000000..65043f532 --- /dev/null +++ b/doc/salome/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/salome/MEDMEM/MESHINGexample.cxx b/doc/salome/MEDMEM/MESHINGexample.cxx new file mode 100644 index 000000000..2ec7a16ee --- /dev/null +++ b/doc/salome/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/salome/MEDMEM/MESHconnectivities.cxx b/doc/salome/MEDMEM/MESHconnectivities.cxx new file mode 100644 index 000000000..2964ff9f8 --- /dev/null +++ b/doc/salome/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/salome/MEDMEM/TODO Drivers.txt b/doc/salome/MEDMEM/TODO Drivers.txt new file mode 100644 index 000000000..d6cd93c78 --- /dev/null +++ b/doc/salome/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/resources/poly3D.med b/resources/poly3D.med new file mode 100644 index 0000000000000000000000000000000000000000..cfe8a69006a9c441bc68efd2e1631e7c135f6acc GIT binary patch literal 36864 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 literal 0 HcmV?d00001 -- 2.39.2