MEDMEMTest Class Reference

#include <MEDMEMTest.hxx>

Inheritance diagram for MEDMEMTest:

Public Member Functions
void	setUp ()
void	tearDown ()
void	testArray ()
void	testArrayConvert ()
void	testAsciiFieldDriver ()
void	testConnectivity ()
void	testCoordinate ()
void	testDriverFactory ()
void	testException ()
void	testFamily ()
void	testField ()
void	testFieldConvert ()
void	testFormulae ()
void	testGaussLocalization ()
void	testGibiMeshDriver ()
void	testGrid ()
void	testGroup ()
void	testIndexCheckingPolicy ()
void	testInit ()
void	testMedFieldDriver ()
void	testReadFieldOnNodesAndCells ()
	0020582: [CEA 368] MEDMEM don't work with a same field on NODES and CELLS Before fixing the issue there was the error: RuntimeError: MED Exception in .../MED_SRC/src/MEDMEM/MEDMEM_MedFieldDriver22.hxx [503] : MED_FIELD_DRIVER<T>.createFieldSupportPart1(...) Field |field on NODEs and CELLs| with (ndt,or) = (-1,-1) must not be defined on different entity types
void	testMedFileBrowser ()
void	testMedMeshDriver ()
void	testMedVersion ()
void	testMeshAndMeshing ()
void	testModulusArray ()
void	testnArray ()
void	testPartialDescendingConnectivity ()
void	testPointerOf ()
void	testPorflowMeshDriver ()
void	testSkyLineArray ()
void	testSTRING ()
void	testSupport ()
void	testTopLevel ()
void	testTypeMeshDriver ()
void	testUnit ()
void	testVtkFieldDriver ()
void	testVtkMedDriver ()
void	testVtkMeshDriver ()
void	testExtractor ()
void	testMeshFuse ()
void	testDesactivateFacesComputation ()
void	testGetVolumeAbs ()
void	test_RemapperP0P0 ()
void	test_RemapperP1P1 ()
void	test_RemapperP1P0 ()
void	test_RemapperP0P1 ()
void	test_remapper4 ()
void	test_remapper5 ()
void	test_remapper6 ()
void	test_remapper7 ()
void	test_remapper3DTo1D ()
void	testGetGaussPointsCoordinates ()
	0021052: [CEA 431] Computation of Gauss point location
void	absField (MEDMEM::FIELD< double > &)
Private Member Functions
	CPPUNIT_TEST_SUITE (MEDMEMTest)
	CPPUNIT_TEST (testArray)
	CPPUNIT_TEST (testArrayConvert)
	CPPUNIT_TEST (testAsciiFieldDriver)
	CPPUNIT_TEST (testConnectivity)
	CPPUNIT_TEST (testCoordinate)
	CPPUNIT_TEST (testDriverFactory)
	CPPUNIT_TEST (testFamily)
	CPPUNIT_TEST (testField)
	CPPUNIT_TEST (testFieldConvert)
	CPPUNIT_TEST (testFormulae)
	CPPUNIT_TEST (testGaussLocalization)
	CPPUNIT_TEST (testGibiMeshDriver)
	CPPUNIT_TEST (testGroup)
	CPPUNIT_TEST (testIndexCheckingPolicy)
	CPPUNIT_TEST (testInit)
	CPPUNIT_TEST (testMedFieldDriver)
	CPPUNIT_TEST (testReadFieldOnNodesAndCells)
	CPPUNIT_TEST (testMedFileBrowser)
	CPPUNIT_TEST (testMedMeshDriver)
	CPPUNIT_TEST (testMedVersion)
	CPPUNIT_TEST (testMeshAndMeshing)
	CPPUNIT_TEST (testModulusArray)
	CPPUNIT_TEST (testnArray)
	CPPUNIT_TEST (testPartialDescendingConnectivity)
	CPPUNIT_TEST (testPointerOf)
	CPPUNIT_TEST (testPorflowMeshDriver)
	CPPUNIT_TEST (testSkyLineArray)
	CPPUNIT_TEST (testSTRING)
	CPPUNIT_TEST (testSupport)
	CPPUNIT_TEST (testUnit)
	CPPUNIT_TEST (testVtkFieldDriver)
	CPPUNIT_TEST (testVtkMedDriver)
	CPPUNIT_TEST (testVtkMeshDriver)
	CPPUNIT_TEST (testExtractor)
	CPPUNIT_TEST (testMeshFuse)
	CPPUNIT_TEST (testDesactivateFacesComputation)
	CPPUNIT_TEST (testGetVolumeAbs)
	CPPUNIT_TEST (test_remapper4)
	CPPUNIT_TEST (test_remapper5)
	CPPUNIT_TEST (test_remapper6)
	CPPUNIT_TEST (test_remapper7)
	CPPUNIT_TEST (test_remapper3DTo1D)
	CPPUNIT_TEST (test_RemapperP0P0)
	CPPUNIT_TEST (test_RemapperP1P1)
	CPPUNIT_TEST (test_RemapperP1P0)
	CPPUNIT_TEST (test_RemapperP0P1)
	CPPUNIT_TEST (testGetGaussPointsCoordinates)
	CPPUNIT_TEST_SUITE_END ()
double	sumAll (const std::vector< std::map< int, double > > &matrix)

---

Member Function Documentation

MEDMEMTest.CPPUNIT_TEST_SUITE

(

MEDMEMTest

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testArray

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testArrayConvert

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testAsciiFieldDriver

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testConnectivity

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testCoordinate

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testDriverFactory

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testFamily

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testField

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testFieldConvert

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testFormulae

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testGaussLocalization

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testGibiMeshDriver

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testGroup

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testIndexCheckingPolicy

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testInit

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testMedFieldDriver

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testReadFieldOnNodesAndCells

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testMedFileBrowser

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testMedMeshDriver

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testMedVersion

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testMeshAndMeshing

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testModulusArray

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testnArray

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testPartialDescendingConnectivity

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testPointerOf

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testPorflowMeshDriver

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testSkyLineArray

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testSTRING

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testSupport

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testUnit

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testVtkFieldDriver

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testVtkMedDriver

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testVtkMeshDriver

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testExtractor

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testMeshFuse

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testDesactivateFacesComputation

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testGetVolumeAbs

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

test_remapper4

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

test_remapper5

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

test_remapper6

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

test_remapper7

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

test_remapper3DTo1D

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

test_RemapperP0P0

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

test_RemapperP1P1

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

test_RemapperP1P0

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

test_RemapperP0P1

)

[private]

MEDMEMTest.CPPUNIT_TEST

(

testGetGaussPointsCoordinates

)

[private]

MEDMEMTest.CPPUNIT_TEST_SUITE_END

(

)

[private]

void MEDMEMTest::setUp

(

)

Set up the environment

void MEDMEMTest::tearDown

(

)

• delete

void MEDMEMTest::testArray

(

)

Check methods (20), defined in MEDMEM_Array.hxx: template <class t>=""> class MEDARRAY { (+) inline MEDARRAY(); (+) inline ~MEDARRAY(); (+) MEDARRAY (const int ld_values, const int length_values, const MED_EN.medModeSwitch mode=MED_EN::MED_FULL_INTERLACE); (+) MEDARRAY (T* values, const int ld_values, const int length_values, const MED_EN.medModeSwitch mode=MED_EN::MED_FULL_INTERLACE, bool shallowCopy=false, bool ownershipOfValues=false); (+) MEDARRAY (MEDARRAY const &m); (+) MEDARRAY (MEDARRAY const &m, bool copyOther); (+) MEDARRAY & operator = (const MEDARRAY & m); (+) MEDARRAY & shallowCopy(const MEDARRAY & m); (+) inline int getLeadingValue() const; (+) inline int getLengthValue() const; (+) const T * get (const MED_EN.medModeSwitch mode); (+) const T * getRow (const int i); (+) const T * getColumn (const int j); (+) const T getIJ (const int i, const int j) const; (+) inline MED_EN.medModeSwitch getMode() const; (+) void set (const MED_EN.medModeSwitch mode,const T* value); (+) void setI (const int i, const T* value); (+) void setJ (const int j, const T* value); (+) void setIJ (const int i, const int j, const T value); (+) void calculateOther(); (+) bool isOtherCalculated() const {return (const T*)_valuesOther != NULL;} (+) void clearOtherMode(); }

Use code of MEDMEM/tests/testUArray.cxx, MEDMEM/test_MEDMEM_Array.cxx

*shallowCopy=*/true, /*ownershipOfValues=*/true);

References MEDMEM.MEDARRAY< T >.calculateOther(), MEDMEM.MEDARRAY< T >.clearOtherMode(), MEDMEM.MEDARRAY< T >.get(), MEDMEM.MEDARRAY< T >.getColumn(), MEDMEM.MEDARRAY< T >.getIJ(), MEDMEM.MEDARRAY< T >.getLeadingValue(), MEDMEM.MEDARRAY< T >.getLengthValue(), MEDMEM.MEDARRAY< T >.getMode(), MEDMEM.MEDARRAY< T >.getRow(), MEDMEM.MEDARRAY< T >.isOtherCalculated(), med_test1.length, MED_EN.MED_FULL_INTERLACE, MED_EN.MED_NO_INTERLACE, MEDMEM.MEDARRAY< T >.set(), MEDMEM.MEDARRAY< T >.setI(), MEDMEM.MEDARRAY< T >.setIJ(), and MEDMEM.MEDARRAY< T >.setJ().

void MEDMEMTest::testArrayConvert

(

)

Check methods (4), defined in MEDMEM_ArrayConvert.hxx:

(+) Gauss NoInterlace->FullInterlace: template <class T, class CHECKING_POLICY > MEDMEM_Array<T, FullInterlaceGaussPolicy, CHECKING_POLICY> * ArrayConvert(const MEDMEM_Array< T, NoInterlaceGaussPolicy, CHECKING_POLICY > &array, T* values=0)

(+) Gauss FullInterlace->NoInterlace: template <class T, class CHECKING_POLICY> MEDMEM_Array<T, NoInterlaceGaussPolicy, CHECKING_POLICY> * ArrayConvert(const MEDMEM_Array< T, FullInterlaceGaussPolicy, CHECKING_POLICY > &array, T* values=0)

(+) NoGauss FullInterlace->NoInterlace: template <class T, class CHECKING_POLICY> MEDMEM_Array<T, NoInterlaceNoGaussPolicy, CHECKING_POLICY> * ArrayConvert(const MEDMEM_Array< T, FullInterlaceNoGaussPolicy, CHECKING_POLICY > &array, T* values=0)

(+) NoGauss NoInterlace->FullInterlace: template <class T, class CHECKING_POLICY> MEDMEM_Array<T, FullInterlaceNoGaussPolicy, CHECKING_POLICY> * ArrayConvert(const MEDMEM_Array< T, NoInterlaceNoGaussPolicy, CHECKING_POLICY > &array, T* values=0)

Use code of MEDMEM/test_MEDMEM_nArray.cxx

References MEDMEM.ArrayConvert(), MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.getIJ(), MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.getIJK(), MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.getPtr(), MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.setIJ(), and MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.setIJK().

void MEDMEMTest::testAsciiFieldDriver

(

)

Check methods (8), defined in MEDMEM_AsciiFieldDriver.hxx:

(+) template<int N,unsigned int CODE> void fill(double *a, const double *b) (+) template<int N> bool compare(const double* a, const double* b) (+) template<> void fill<-1,0x3>(double *a, const double *b); (+) template<> bool compare<-1>(const double *a, const double *b);

template <class T, int SPACEDIMENSION, unsigned int SORTSTRATEGY> class SDForSorting { (+) SDForSorting(const double *coords, const T* comp, int nbComponents); (+) SDForSorting(const SDForSorting& other); (+) ~SDForSorting(); (+) bool operator< (const SDForSorting<T,SPACEDIMENSION,SORTSTRATEGY>& other) const; (+) void writeLine(ofstream& file) const; }

template <class t>=""> class ASCII_FIELD_DRIVER : public GENDRIVER {

//MUST BE PRIVATE as there is no possibility to set _ptrField after this constructor usage (-) template <class interlacing_tag>=""> ASCII_FIELD_DRIVER();

(+) template <class interlacing_tag>=""> ASCII_FIELD_DRIVER(const string & fileName, FIELD<T,INTERLACING_TAG> * ptrField, MED_EN.med_sort_direc direction=MED_EN::ASCENDING, const char *priority=""); (+) ASCII_FIELD_DRIVER(const ASCII_FIELD_DRIVER<T>& other); (+) void open() throw (MEDEXCEPTION); (+) void close(); (+) void read (void) throw (MEDEXCEPTION); (+) void write(void) const throw (MEDEXCEPTION); (+) GENDRIVER* copy() const; }

References MED_EN.ASCENDING, MEDMEM.ASCII_FIELD_DRIVER< T >.close(), MEDMEM.compare<-1 >(), MEDMEM.ASCII_FIELD_DRIVER< T >.copy(), test_NonCoincidentDEC.filename, MEDMEM.GENDRIVER.getAccessMode(), MEDMEM.GENDRIVER.getFileName(), INTERP_TEST.getResourceFile(), MEDMEM.GMESH.getSpaceDimension(), MEDMEM.FIELD_.getSupport(), makeTmpFile(), MEDMEM.MED_DRIVER, test_MEDSPLITTER.meshname, MEDMEM.ASCII_FIELD_DRIVER< T >.open(), MEDMEM.ASCII_FIELD_DRIVER< T >.read(), MEDMEMTest_TmpFilesRemover.Register(), MEDMEM.RCBASE.removeReference(), MEDMEM.GENDRIVER.setFileName(), medClient_test.spaceDimension, MEDMEM.ASCII_FIELD_DRIVER< T >.write(), MEDMEM.SDForSorting< T, SPACEDIMENSION, SORTSTRATEGY >.writeLine(), and MED_EN.WRONLY.

void MEDMEMTest::testConnectivity

(

)

References TestMedCorba5.c1, TestMedCorba5.c2, MEDMEM.CONNECTIVITY.calculateConnectivity(), checkCopyConnectivity(), createOrCheck(), MEDMEM.CONNECTIVITY.existConnectivity(), MEDMEM.CONNECTIVITY.getConnectivity(), MEDMEM.CONNECTIVITY.getConnectivityIndex(), MEDMEM.CONNECTIVITY.getConnectivityOfAnElement(), MEDMEM.CONNECTIVITY.getEntity(), MEDMEM.CONNECTIVITY.getEntityDimension(), MEDMEM.CONNECTIVITY.getNumberOf(), MEDMEM.CONNECTIVITY.getNumberOfNodesInType(), MEDMEM.CONNECTIVITY.getNumberOfTypes(), MEDMEM.CONNECTIVITY.getPolyTypeRelativeTo(), MEDMEM.CONNECTIVITY.getReverseConnectivity(), MEDMEM.CONNECTIVITY.getReverseConnectivityIndex(), MEDMEM.CONNECTIVITY.invertConnectivityForAFace(), MED_EN.MED_ALL_ELEMENTS, MED_EN.MED_CELL, MED_EN.MED_DESCENDING, MED_EN.MED_EDGE, MED_EN.MED_FACE, MED_EN.MED_HEXA8, MED_EN.MED_NODAL, MED_EN.MED_NODE, MED_EN.MED_NONE, MED_EN.MED_POLYGON, MED_EN.MED_POLYHEDRA, MED_EN.MED_PYRA5, MED_EN.MED_QUAD4, MED_EN.MED_SEG2, MED_EN.MED_SEG3, MED_EN.MED_TRIA3, MED_EN.MED_TRIA6, MED_test2.mesh, MEDMEM.RCBASE.removeReference(), MEDMEM.MESH.setConnectivityptr(), MEDMEM.CONNECTIVITY.setConstituent(), MEDMEM.CONNECTIVITY.setCount(), MEDMEM.SUPPORT.setEntity(), MEDMEM.CONNECTIVITY.setEntityDimension(), MEDMEM.SUPPORT.setGeometricType(), MEDMEM.CONNECTIVITY.setGeometricTypes(), MEDMEM.SUPPORT.setMesh(), MEDMEM.SUPPORT.setMeshName(), MEDMEM.SUPPORT.setName(), MEDMEM.CONNECTIVITY.setNodal(), MEDMEM.SUPPORT.setNumber(), MEDMEM.SUPPORT.setNumberOfElements(), MEDMEM.SUPPORT.setNumberOfGeometricType(), MEDMEM.CONNECTIVITY.setNumberOfNodes(), medClient_test.types, and MEDMEM.CONNECTIVITY.updateFamily().

void MEDMEMTest::testCoordinate

(

)

Check methods (23), defined in MEDMEM_Coordinate.hxx: class COORDINATE { (+) COORDINATE(); (+) COORDINATE(int SpaceDimension, int NumberOfNodes, MED_EN.medModeSwitch Mode); (+) COORDINATE(int SpaceDimension,const string * CoordinateName, const string * CoordinateUnit); (+) COORDINATE(const COORDINATE & m); (+) virtual ~COORDINATE(); (+) void setCoordinates(MEDARRAY<double> *Coordinate,bool shallowCopy=false); (+) void setCoordinates(const MED_EN.medModeSwitch Mode, const double *Coordinate); (+) void setCoordinatesNames(const string * CoordinateName); (+) void setCoordinateName(const string CoordinateName, const int i); (+) void setCoordinatesUnits(const string * CoordinateUnit); (+) void setCoordinateUnit(const string CoordinateUnit, const int i); (+) void setCoordinatesSystem(const string CoordinateSystem); (+) void setNodesNumbers(const int * NodeNumber); (+) int getSpaceDimension() const; (+) int getNumberOfNodes() const; (+) virtual const int* getNodesNumbers() const; (+) string getCoordinatesSystem() const; (+) virtual const double * getCoordinates(MED_EN.medModeSwitch Mode); (+) virtual double getCoordinate(int Number,int Axis); (+) virtual const double * getCoordinateAxis(int Axis); (+) const string * getCoordinatesNames() const; (+) string getCoordinateName(int Axis) const; (+) const string * getCoordinatesUnits() const; (+) string getCoordinateUnit(int Axis) const; }

Use code of MEDMEM/tests/testUCoordinate.cxx MEDMEM/test_copie_coordinate.cxx

References TestMedCorba3.d, MEDMEM.COORDINATE.getCoordinate(), MEDMEM.COORDINATE.getCoordinateName(), MEDMEM.COORDINATE.getCoordinateUnit(), MEDMEM.MEDARRAY< T >.getLeadingValue(), MEDMEM.MEDARRAY< T >.getLengthValue(), MEDMEM.COORDINATE.getNodesNumbers(), MEDMEM.COORDINATE.getNumberOfNodes(), MEDMEM.COORDINATE.getSpaceDimension(), MED_EN.MED_FULL_INTERLACE, MED_EN.MED_NO_INTERLACE, med_test3.mode, pouieme, MEDMEM.COORDINATE.setCoordinateName(), MEDMEM.COORDINATE.setCoordinates(), MEDMEM.COORDINATE.setCoordinatesNames(), MEDMEM.COORDINATE.setCoordinatesUnits(), MEDMEM.COORDINATE.setCoordinateUnit(), MEDMEM.MEDARRAY< T >.setIJ(), MEDMEM.COORDINATE.setNodesNumbers(), and medClient_test.spaceDimension.

void MEDMEMTest::testDriverFactory

(

)

Check methods (7), defined in MEDMEM_DriverFactory.hxx: namespace DRIVERFACTORY { (+) driverTypes deduceDriverTypeFromFileName(const std.string & fileName);

(+) GENDRIVER * buildDriverForMesh (driverTypes driverType, const std.string & fileName, MESH *mesh, const string & driverName, MED_EN.med_mode_acces access); (+) template<class T, class INTERLACING_TAG> GENDRIVER * buildDriverForField(driverTypes driverType, const std.string & fileName, FIELD<T,INTERLACING_TAG> *fielde, MED_EN.med_mode_acces access);

(+) GENDRIVER * buildMeshDriverFromFile (const string & fileName, MESH * ptrMesh, MED_EN.med_mode_acces access); (+) template<class T, class INTERLACING_TAG> GENDRIVER * buildFieldDriverFromFile(const string & fileName, FIELD<T,INTERLACING_TAG> * ptrField, MED_EN.med_mode_acces access);

(+) GENDRIVER * buildConcreteMedDriverForMesh(const std.string & fileName, MESH *mesh, const string & driverName, MED_EN.med_mode_acces access, MED_EN.medFileVersion version); (+) template<class T, class INTERLACING_TAG> GENDRIVER * buildConcreteMedDriverForField(const std.string & fileName, FIELD<T,INTERLACING_TAG> *fielde, MED_EN.med_mode_acces access, MED_EN.medFileVersion version); }

References MEDMEM.ASCII_DRIVER, MEDMEM.DRIVERFACTORY.buildConcreteMedDriverForField(), MEDMEM.DRIVERFACTORY.buildConcreteMedDriverForMesh(), MEDMEM.DRIVERFACTORY.buildDriverForField(), MEDMEM.DRIVERFACTORY.buildDriverForMesh(), MEDMEM.DRIVERFACTORY.buildFieldDriverFromFile(), MEDMEM.DRIVERFACTORY.buildMeshDriverFromFile(), MEDMEM.DRIVERFACTORY.deduceDriverTypeFromFileName(), MED_test2.field, test_NonCoincidentDEC.filename, MEDMEM.GENDRIVER.getAccessMode(), MEDMEM.GENDRIVER.getFileName(), MEDMEM.getMedFileVersion(), INTERP_TEST.getResourceFile(), MEDMEM.FIELD_.getSupport(), MEDMEM.DRIVERFACTORY.getVtkBinaryFormatForWriting(), MEDMEM.GIBI_DRIVER, MEDMEM.MED_DRIVER, MED_EXCEPTION, MED_test2.mesh, test_MEDSPLITTER.meshname, MEDMEM.NO_DRIVER, MEDMEM.PORFLOW_DRIVER, MED_EN.RDONLY, MED_EN.RDWR, MEDMEM.RCBASE.removeReference(), MEDMEM.DRIVERFACTORY.setVtkBinaryFormatForWriting(), MED_EN.V21, MED_EN.V22, MEDMEM.VTK_DRIVER, and MED_EN.WRONLY.

void MEDMEMTest::testException

(

)

Check methods (not in spec), defined in MEDMEM_Exception.hxx: (+) #define LOCALIZED(message) static_cast<const char *> (message) , __FILE__ , __LINE__ class MEDEXCEPTION : public std.exception { (+) MEDEXCEPTION(const char *text, const char *fileName=0, const unsigned int lineNumber=0); (+) MEDEXCEPTION(const MEDEXCEPTION &ex); (+) ~MEDEXCEPTION() throw (); (+) friend ostream & operator<< (ostream &os, const MEDEXCEPTION &ex); (+) virtual const char *what(void) const throw (); } class MED_DRIVER_NOT_FOUND_EXCEPTION : public MEDEXCEPTION { (+) MED_DRIVER_NOT_FOUND_EXCEPTION(const char *text, const char *fileName=0, const unsigned int lineNumber=0); (+) MED_DRIVER_NOT_FOUND_EXCEPTION(const MED_DRIVER_NOT_FOUND_EXCEPTION &ex); (+) ~MED_DRIVER_NOT_FOUND_EXCEPTION() throw(); }

Use code of MEDMEM/tests/testUMedException.cxx

References testGaussLocalization.a, testGaussLocalization.b, TestMedCorba3.d, LOCALIZED, and MEDMEM.MEDEXCEPTION.what().

void MEDMEMTest::testFamily

(

)

References check_famille(), MEDMEM.MED_MESH_DRIVER.close(), MEDMEM.SUPPORT.deepCompare(), testDriverAscii.f1, test_NonCoincidentDEC.filename, MEDMEM.FAMILY.getAttributeDescription(), MEDMEM.FAMILY.getAttributeIdentifier(), MEDMEM.FAMILY.getAttributeValue(), MEDMEM.SUPPORT.getDescription(), MEDMEM.SUPPORT.getEntity(), MEDMEM.GMESH.getFamily(), MEDMEM.FAMILY.getGroupName(), MEDMEM.FAMILY.getIdentifier(), MEDMEM.SUPPORT.getName(), MEDMEM.FAMILY.getNumberOfAttributes(), MEDMEM.MESH.getNumberOfElements(), MEDMEM.SUPPORT.getNumberOfElements(), MEDMEM.FAMILY.getNumberOfGroups(), MEDMEM.SUPPORT.getNumberOfTypes(), INTERP_TEST.getResourceFile(), MEDMEM.SUPPORT.isOnAllElements(), MED_EN.MED_ALL_ELEMENTS, MED_EN.MED_FACE, MED_EN.MED_NODE, MEDMEMTest_createTestMesh(), test_MEDSPLITTER.meshname, MEDMEM.MED_MESH_DRIVER.open(), MEDMEM.MED_MESH_RDONLY_DRIVER.read(), MEDMEM.RCBASE.removeReference(), TestMedCorba3.s1, MEDMEM.MED_MESH_DRIVER.setMeshName(), and MEDMEM.GMESH.setName().

void MEDMEMTest::testField

(

)

References MEDMEM.FIELD< T, INTERLACING_TAG >.allocValue(), MEDMEM.FIELD< T, INTERLACING_TAG >.applyFunc(), MEDMEM.FIELD< T, INTERLACING_TAG >.applyPow(), med_test1.barycenter, checkField(), checkField_(), compareField_(), MEDMEM.GRID.convertInMESH(), MEDMEM.FIELD< T, INTERLACING_TAG >.deallocValue(), MEDMEM.FIELD< T, INTERLACING_TAG >.extract(), test_NonCoincidentDEC.filename, med_test_skin.GeometricType, MEDMEM.FIELD< T, INTERLACING_TAG >.getArray(), MEDMEM.FIELD< T, INTERLACING_TAG >.getArrayGauss(), MEDMEM.FIELD< T, INTERLACING_TAG >.getArrayNoGauss(), MEDMEM.FIELD< T, INTERLACING_TAG >.getColumn(), MEDMEM.FIELD_.getDescription(), MEDMEM.FIELD< T, INTERLACING_TAG >.getGaussLocalization(), MEDMEM.FIELD< T, INTERLACING_TAG >.getGaussLocalizationPtr(), MEDMEM.FIELD< T, INTERLACING_TAG >.getGaussPresence(), MEDMEM.FIELD< T, INTERLACING_TAG >.getGeometricTypes(), MEDMEM.GMESH.getGroup(), MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.getIJ(), MEDMEM.FIELD_.getName(), MEDMEM.FIELD< T, INTERLACING_TAG >.getNbGaussI(), MEDMEM.FIELD_.getNumberOfComponents(), MEDMEM.FIELD< T, INTERLACING_TAG >.getNumberOfElements(), MEDMEM.FIELD< T, INTERLACING_TAG >.getNumberOfGaussPoints(), MEDMEM.FIELD< T, INTERLACING_TAG >.getNumberOfGeometricTypes(), MEDMEM.FIELD_.getNumberOfValues(), INTERP_TEST.getResourceFile(), MEDMEM.FIELD< T, INTERLACING_TAG >.getRow(), MEDMEM.FIELD_.getSupport(), MEDMEM.GMESH.getSupportOnAll(), MEDMEM.MESH.getTypes(), MEDMEM.FIELD< T, INTERLACING_TAG >.getValue(), MEDMEM.FIELD< T, INTERLACING_TAG >.getValueIJ(), MEDMEM.FIELD< T, INTERLACING_TAG >.getValueIJK(), MEDMEM.FIELD< T, INTERLACING_TAG >.getValueLength(), MEDMEM.FIELD< T, INTERLACING_TAG >.getValueOnElement(), MEDMEM.FIELD< T, INTERLACING_TAG >.getValueOnPoint(), MEDMEM.FIELD< T, INTERLACING_TAG >.getValueOnPoints(), MEDMEM.FIELD< T, INTERLACING_TAG >.integral(), MEDMEM.FIELD< T, INTERLACING_TAG >.isOnAllElements(), MED_EN.MED_ALL_ELEMENTS, MED_EN.MED_CELL, MEDMEM.MED_DRIVER, MED_EN.MED_FACE, MED_EN.MED_NODAL, MED_EN.MED_NODE, MED_EN.MED_POINT1, MED_EN.MED_QUAD4, MED_EN.MED_TRIA3, MED_EN.MED_TRIA6, MED_EN.MED_UNDEFINED_INTERLACE, MED_EN.MED_UNDEFINED_TYPE, MEDMEMTest_createTestMesh(), MED_test2.mesh, test_MEDSPLITTER.meshname, med_test2.nbComp, med_test_skin.nbGeomTypes, med_test1.norm, MEDMEM.FIELD< T, INTERLACING_TAG >.norm2(), MEDMEM.FIELD< T, INTERLACING_TAG >.normL1(), MEDMEM.FIELD< T, INTERLACING_TAG >.normL2(), MEDMEM.FIELD< T, INTERLACING_TAG >.normMax(), plus13(), proj2d(), MEDMEM.RCBASE.removeReference(), MEDMEM.FIELD< T, INTERLACING_TAG >.setArray(), MEDMEM.FIELD< T, INTERLACING_TAG >.setColumn(), MEDMEM.FIELD_.setDescription(), MEDMEM.SUPPORT.setEntity(), MEDMEM.FIELD< T, INTERLACING_TAG >.setGaussLocalization(), MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.setIJ(), MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.setIJK(), MEDMEM.FIELD_.setMEDComponentUnit(), MEDMEM.SUPPORT.setMesh(), MEDMEM.FIELD_.setName(), MEDMEM.SUPPORT.setName(), MEDMEM.FIELD_.setNumberOfComponents(), MEDMEM.SUPPORT.setpartial(), MEDMEM.FIELD< T, INTERLACING_TAG >.setRow(), MEDMEM.FIELD< T, INTERLACING_TAG >.setValueIJ(), testDrivers(), batchmode_medcorba_test.value, and MEDMEM.MEDEXCEPTION.what().

void MEDMEMTest::testFieldConvert

(

)

Check methods (2), defined in MEDMEM_FieldConvert.hxx: (+) template <class t>=""> FIELD<T,FullInterlace> * FieldConvert(const FIELD<T,NoInterlace> & field); (+) template <class t>=""> FIELD<T,NoInterlace> * FieldConvert(const FIELD<T,FullInterlace> & field);

References MEDMEM.FieldConvert(), MEDMEM.FIELD_.getComponentsUnits(), MEDMEM.FIELD_.getComponentUnit(), MEDMEM.UNIT.getName(), MEDMEM.FIELD< T, INTERLACING_TAG >.getValue(), MEDMEM.RCBASE.removeReference(), MEDMEM.FIELD< T, INTERLACING_TAG >.setArray(), MEDMEM.FIELD_.setComponentsDescriptions(), MEDMEM.FIELD_.setComponentsNames(), MEDMEM.FIELD_.setComponentsUnits(), MEDMEM.FIELD_.setDescription(), MEDMEM.FIELD_.setMEDComponentsUnits(), MEDMEM.FIELD_.setName(), MEDMEM.FIELD_.setNumberOfComponents(), and MEDMEM.FIELD_.setNumberOfValues().

void MEDMEMTest::testFormulae

(

)

Check methods (13), defined in MEDMEM_Formulae.hxx:

(+) inline void CalculateBarycenterDyn(const double **pts, int nbPts, int dim, double *bary);

(+) inline double CalculateAreaForPolyg(const double **coords, int nbOfPtsInPolygs, int spaceDim); (+) inline double CalculateAreaForTria(const double *p1, const double *p2, const double *p3, int spaceDim); (+) inline double CalculateAreaForQuad(const double *p1, const double *p2, const double *p3, const double *p4, int spaceDim);

(+) inline void CalculateNormalForTria(const double *p1, const double *p2, const double *p3, double *normal); (+) inline void CalculateNormalForQuad(const double *p1, const double *p2, const double *p3, const double *p4, double *normal); (+) inline void CalculateNormalForPolyg(const double **coords, int nbOfPtsInPolygs, double *normal);

(+) inline double CalculateVolumeForTetra(const double *p1, const double *p2, const double *p3, const double *p4); (+) inline double CalculateVolumeForPyra(const double *p1, const double *p2, const double *p3, const double *p4, const double *p5); (+) inline double CalculateVolumeForPenta(const double *p1, const double *p2, const double *p3, const double *p4, const double *p5, const double *p6); (+) inline double CalculateVolumeForHexa(const double *pt1, const double *pt2, const double *pt3, const double *pt4, const double *pt5, const double *pt6, const double *pt7, const double *pt8); (+) inline double CalculateVolumeForPolyh(const double ***pts, const int *nbOfNodesPerFaces, int nbOfFaces, const double *bary);

(+) template<int N> inline double addComponentsOfVec(const double **pts, int rk); (+) template<> inline double addComponentsOfVec<1>(const double **pts, int rk);

(+) template<int N, int DIM> inline void CalculateBarycenter(const double **pts, double *bary); (-) template<> inline void CalculateBarycenter<2,0>(const double **pts, double *bary); (-) template<> inline void CalculateBarycenter<3,0>(const double **pts, double *bary); (-) template<> inline void CalculateBarycenter<4,0>(const double **pts, double *bary); (-) template<> inline void CalculateBarycenter<5,0>(const double **pts, double *bary); (-) template<> inline void CalculateBarycenter<6,0>(const double **pts, double *bary); (-) template<> inline void CalculateBarycenter<7,0>(const double **pts, double *bary); (-) template<> inline void CalculateBarycenter<8,0>(const double **pts, double *bary);

References INTERP_KERNEL.addComponentsOfVec< 1 >(), INTERP_KERNEL.calculateAreaForPolyg(), INTERP_KERNEL.calculateAreaForQuad(), INTERP_KERNEL.calculateAreaForTria(), INTERP_KERNEL.calculateBarycenterDyn(), INTERP_KERNEL.calculateNormalForPolyg(), INTERP_KERNEL.calculateNormalForQuad(), INTERP_KERNEL.calculateNormalForTria(), INTERP_KERNEL.calculateVolumeForHexa(), INTERP_KERNEL.calculateVolumeForPenta(), INTERP_KERNEL.calculateVolumeForPolyh(), INTERP_KERNEL.calculateVolumeForPyra(), INTERP_KERNEL.calculateVolumeForTetra(), nodes, and med_test_grid.xy2.

void MEDMEMTest::testGaussLocalization

(

)

Check methods (13), defined in MEDMEM_GaussLocalization.hxx: class GAUSS_LOCALIZATION_ { (+) virtual MED_EN.medModeSwitch getInterlacingType() const; (+) virtual ~GAUSS_LOCALIZATION_(); } (+) template <class interlacing_tag="FullInterlace"> class GAUSS_LOCALIZATION;

(+) template <class interlacing_tag>=""> ostream & operator<< (ostream &os, const GAUSS_LOCALIZATION<INTERLACING_TAG> &loc);

template <class interlacing_tag>=""> class GAUSS_LOCALIZATION : public GAUSS_LOCALIZATION_ { (+) GAUSS_LOCALIZATION() throw (MEDEXCEPTION); (+) GAUSS_LOCALIZATION(const string & locName, const MED_EN.medGeometryElement typeGeo, const int nGauss, const ArrayNoGauss & cooRef, const ArrayNoGauss & cooGauss, const vector<double> & wg) throw (MEDEXCEPTION); (+) GAUSS_LOCALIZATION(const string & locName, const MED_EN.medGeometryElement typeGeo, const int nGauss, const double * const cooRef, const double * const cooGauss, const double * const wg) throw (MEDEXCEPTION); (+) virtual ~GAUSS_LOCALIZATION();

(+) GAUSS_LOCALIZATION & operator=(const GAUSS_LOCALIZATION & gaussLoc); (+) bool operator == (const GAUSS_LOCALIZATION &loc) const;

(+) string getName() const; (+) MED_EN.medGeometryElement getType() const;

(+) int getNbGauss() const; (+) ArrayNoGauss getRefCoo () const; (+) ArrayNoGauss getGsCoo () const; (+) vector <double> getWeight () const;

(+) inline MED_EN.medModeSwitch getInterlacingType() const; }

References MEDMEM.GAUSS_LOCALIZATION< INTERLACING_TAG >.getGsCoo(), MEDMEM.GAUSS_LOCALIZATION< INTERLACING_TAG >.getInterlacingType(), MEDMEM.GAUSS_LOCALIZATION_.getInterlacingType(), MEDMEM.GAUSS_LOCALIZATION< INTERLACING_TAG >.getName(), MEDMEM.GAUSS_LOCALIZATION< INTERLACING_TAG >.getNbGauss(), MEDMEM.GAUSS_LOCALIZATION< INTERLACING_TAG >.getRefCoo(), MEDMEM.GAUSS_LOCALIZATION< INTERLACING_TAG >.getType(), MEDMEM.GAUSS_LOCALIZATION< INTERLACING_TAG >.getWeight(), MED_EN.MED_FULL_INTERLACE, MED_EN.MED_NO_INTERLACE, MED_EN.MED_QUAD4, MED_EN.MED_TRIA3, and MED_EN.MED_UNDEFINED_INTERLACE.

void MEDMEMTest::testGibiMeshDriver

(

)

Check methods (31), defined in MEDMEM_GibiMeshDriver.hxx: class GIBI_MESH_DRIVER : public GENDRIVER { (+) GIBI_MESH_DRIVER(); (+) GIBI_MESH_DRIVER(const string & fileName, MESH * ptrMesh, MED_EN.med_mode_acces accessMode); (+) GIBI_MESH_DRIVER(const GIBI_MESH_DRIVER & driver); (+) virtual ~GIBI_MESH_DRIVER(); (+) virtual void write(void) const = 0; (+) virtual void read (void) = 0; (+) void setMeshName(const string & meshName); (+) string getMeshName() const; (+) static MED_EN.medGeometryElement gibi2medGeom(size_t gibiTypeNb); (+) static int med2gibiGeom(MED_EN.medGeometryElement medGeomType); } class GIBI_MESH_RDONLY_DRIVER : public virtual GIBI_MESH_DRIVER { (+) GIBI_MESH_RDONLY_DRIVER(); (+) GIBI_MESH_RDONLY_DRIVER(const string & fileName, MESH * ptrMesh); (+) GIBI_MESH_RDONLY_DRIVER(const GIBI_MESH_RDONLY_DRIVER & driver); (+) virtual ~GIBI_MESH_RDONLY_DRIVER(); (+) void write(void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); (+) void open(); (+) void close(); } class GIBI_MESH_WRONLY_DRIVER : public virtual GIBI_MESH_DRIVER { (+) GIBI_MESH_WRONLY_DRIVER(); (+) GIBI_MESH_WRONLY_DRIVER(const string & fileName, MESH * ptrMesh); (+) GIBI_MESH_WRONLY_DRIVER(const GIBI_MESH_WRONLY_DRIVER & driver); (+) virtual ~GIBI_MESH_WRONLY_DRIVER(); (+) void write(void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); (+) void open(); (+) void close(); } class GIBI_MESH_RDWR_DRIVER : public GIBI_MESH_RDONLY_DRIVER, public GIBI_MESH_WRONLY_DRIVER { (+) GIBI_MESH_RDWR_DRIVER(); (+) GIBI_MESH_RDWR_DRIVER(const string & fileName, MESH * ptrMesh); (+) GIBI_MESH_RDWR_DRIVER(const GIBI_MESH_RDWR_DRIVER & driver); (+) ~GIBI_MESH_RDWR_DRIVER(); (+) void write(void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); (+) void open(); (+) void close(); } class GIBI_MED_RDONLY_DRIVER : public GIBI_MESH_RDONLY_DRIVER { (+) GIBI_MED_RDONLY_DRIVER(); (+) GIBI_MED_RDONLY_DRIVER(const string & fileName, MED * ptrMed); (+) GIBI_MED_RDONLY_DRIVER(const GIBI_MED_RDONLY_DRIVER & driver); (+) virtual ~GIBI_MED_RDONLY_DRIVER(); (+) void read (void) throw (MEDEXCEPTION); } class GIBI_MED_WRONLY_DRIVER : public GIBI_MESH_WRONLY_DRIVER { (+) GIBI_MED_WRONLY_DRIVER(); (+) GIBI_MED_WRONLY_DRIVER(const string & fileName, MED * ptrMed, MESH * ptrMesh); (+) GIBI_MED_WRONLY_DRIVER(const GIBI_MED_WRONLY_DRIVER & driver); (+) virtual ~GIBI_MED_WRONLY_DRIVER(); (+) void write(void) const throw (MEDEXCEPTION); }

References MEDMEM.GIBI_MESH_RDWR_DRIVER.close(), MEDMEM.GIBI_MESH_WRONLY_DRIVER.close(), MEDMEM.GIBI_MESH_RDONLY_DRIVER.close(), test_MEDSPLITTER.filename_rd, MEDMEM.GIBI_MESH_DRIVER.getMeshName(), INTERP_TEST.getResourceFile(), makeTmpFile(), MED_EN.MED_PENTA15, test_MEDSPLITTER.meshname, MEDMEM.GIBI_MESH_RDWR_DRIVER.open(), MEDMEM.GIBI_MESH_WRONLY_DRIVER.open(), MEDMEM.GIBI_MESH_RDONLY_DRIVER.open(), MEDMEM.GIBI_MED_RDONLY_DRIVER.read(), MEDMEM.GIBI_MESH_RDWR_DRIVER.read(), MEDMEM.GIBI_MESH_WRONLY_DRIVER.read(), MEDMEM.GIBI_MESH_RDONLY_DRIVER.read(), MEDMEMTest_TmpFilesRemover.Register(), MEDMEM.RCBASE.removeReference(), MEDMEM.GIBI_MESH_DRIVER.setMeshName(), MEDMEM.GIBI_MED_WRONLY_DRIVER.write(), MEDMEM.GIBI_MESH_RDWR_DRIVER.write(), MEDMEM.GIBI_MESH_WRONLY_DRIVER.write(), and MEDMEM.GIBI_MESH_RDONLY_DRIVER.write().

void MEDMEMTest::testGrid

(

)

Check methods (23), defined in MEDMEM_Grid.hxx: class GRID: public MESH { (+) GRID(); (+) GRID(const MED_EN.med_grid_type type); (BUG:operator=() not implemented but init() not called) GRID(const GRID &m); (+) GRID(driverTypes driverType, const string & fileName="",const string & meshName=""); (+) GRID(const std.vector<std.vector<double> >& xyz_array, const std.vector<std.string>& coord_name, const std.vector<std.string>& coord_unit, const MED_EN.med_grid_type type=MED_EN::MED_CARTESIAN); (NOT IMPLEMENTED) GRID & operator=(const GRID &m); (+) virtual ~GRID(); (+) virtual void init(); (+) virtual const MESH * convertInMESH() const (+) inline int getNodeNumber(const int i, const int j=0, const int k=0) const; (+) inline int getCellNumber(const int i, const int j=0, const int k=0) const; (+) int getEdgeNumber (const int Axis, const int i, const int j=0, const int k=0) const throw (MEDEXCEPTION); (+) int getFaceNumber (const int Axis, const int i, const int j=0, const int k=0) const throw (MEDEXCEPTION); (+) void getNodePosition(const int Number, int& i, int& j, int& k) const throw (MEDEXCEPTION); (+) void getCellPosition(const int Number, int& i, int& j, int& k) const throw (MEDEXCEPTION); (+) void getEdgePosition (const int Number, int& Axis, int& i, int& j, int& k) const throw (MEDEXCEPTION); (+) void getFacePosition (const int Number, int& Axis, int& i, int& j, int& k) const throw (MEDEXCEPTION); (+) inline MED_EN.med_grid_type getGridType() const; (+) int getArrayLength(const int Axis) const throw (MEDEXCEPTION); (+) const double getArrayValue (const int Axis, const int i) const throw (MEDEXCEPTION); (+) inline int getNumberOfTypes(MED_EN.medEntityMesh Entity) const; (+) inline const MED_EN.medGeometryElement * getTypes(MED_EN.medEntityMesh Entity) const; (+) inline int getNumberOfElements (MED_EN.medEntityMesh Entity, MED_EN.medGeometryElement Type) const; (+) inline MED_EN.medGeometryElement getElementType (MED_EN.medEntityMesh Entity, int Number) const; (+) inline void setGridType(MED_EN.med_grid_type gridType); }

References MEDMEM.GMESH.addDriver(), MEDMEM.MESH.calculateConnectivity(), testRenumbering.conn, med_test1.Connectivity, MEDMEM.GRID.convertInMESH(), medClient_test.coordinates, coords, medMeshing_test.driver, MEDMEM.CONNECTIVITY.existConnectivity(), MEDMEM.MESH.existConnectivity(), test_NonCoincidentDEC.filename, MEDMEM.GRID.getArrayLength(), MEDMEM.GRID.getArrayValue(), MEDMEM.MESH.getCellsTypes(), MEDMEM.MESH.getConnectivity(), MEDMEM.MESH.getConnectivityIndex(), MEDMEM.MESH.getConnectivityptr(), MEDMEM.COORDINATE.getCoordinate(), MEDMEM.MESH.getCoordinate(), MEDMEM.MESH.getCoordinateptr(), MEDMEM.MESH.getCoordinates(), MEDMEM.CONNECTIVITY.getElementType(), MEDMEM.MEDFILEBROWSER.getFileName(), MEDMEM.CONNECTIVITY.getGlobalNumberingIndex(), MEDMEM.MESH.getGlobalNumberingIndex(), MEDMEM.GRID.getGridType(), MEDMEM.GRID.getIsAGrid(), MEDMEM.GMESH.getIsAGrid(), MEDMEM.MEDFILEBROWSER.getMeshNames(), MEDMEM.GRID.getNumberOfElements(), MEDMEM.MEDFILEBROWSER.getNumberOfMeshes(), MEDMEM.GRID.getNumberOfNodes(), MEDMEM.GRID.getNumberOfTypes(), INTERP_TEST.getResourceFile(), MEDMEM.MESH.getReverseConnectivity(), MEDMEM.MESH.getReverseConnectivityIndex(), MEDMEM.GMESH.getSpaceDimension(), MEDMEM.GRID.getTypes(), med_test_grid.grid_type, med_test_grid.I, MEDMEM.GRID.init(), MEDMEM.MEDFILEBROWSER.isStructuredMesh(), Med_Gen_test.it, med_test_grid.J, med_test_grid.K, makeTmpFile(), MED_EN.MED_ALL_ELEMENTS, MED_EN.MED_BODY_FITTED, MED_EN.MED_CARTESIAN, MED_EN.MED_CELL, MED_EN.MED_DESCENDING, MEDMEM.MED_DRIVER, MED_EN.MED_EDGE, MED_EN.MED_FACE, MED_EN.MED_FULL_INTERLACE, MED_EN.MED_HEXA8, MED_EN.MED_NODAL, MED_EN.MED_POLAR, MED_EN.MED_QUAD4, MED_EN.MED_SEG2, MED_test2.mesh, med_test1.nbEdge, batchmode_medcorba_test.nbMeshes, batchmode_medcorba_test.nbNodes, medClient_test.nbTypesCell, MEDMEM.GMESH.read(), MEDMEMTest_TmpFilesRemover.Register(), MEDMEM.RCBASE.removeReference(), med_test1.ReverseConnectivityIndex, MEDMEM.GRID.setGridType(), MEDMEM.MED_MESH_DRIVER.setMeshName(), MEDMEM.GMESH.setName(), medClient_test.types, MEDMEM.MEDEXCEPTION.what(), and MEDMEM.GMESH.write().

void MEDMEMTest::testGroup

(

)

Check methods (10), defined in MEDMEM_Group.hxx: class GROUP : virtual public SUPPORT { (+) GROUP(); (+) GROUP(const string & name, const list<FAMILY*> & family) throw (MEDEXCEPTION); (+) GROUP(const GROUP & m); (+) virtual ~GROUP(); (+) GROUP & operator=(const GROUP &group); (+) friend ostream & operator<<(ostream &os, GROUP &my); (+) inline void setNumberOfFamilies(int numberOfFamilies); (+) inline void setFamilies(vector<FAMILY*> Family); (+) inline int getNumberOfFamilies() const; (+) inline vector<FAMILY*> getFamilies() const; (+) inline FAMILY * getFamily(int i) const; }

References MEDMEM.MED_MESH_DRIVER.close(), test_NonCoincidentDEC.filename, MEDMEM.GROUP.getFamilies(), MEDMEM.GROUP.getFamily(), MEDMEM.GMESH.getGroup(), MEDMEM.SUPPORT.getName(), MEDMEM.GROUP.getNumberOfFamilies(), INTERP_TEST.getResourceFile(), MED_EN.MED_NODE, test_MEDSPLITTER.meshname, medMeshing_test.myGroup, MEDMEM.MED_MESH_DRIVER.open(), MEDMEM.MED_MESH_RDONLY_DRIVER.read(), MEDMEM.RCBASE.removeReference(), MEDMEM.GROUP.setFamilies(), MEDMEM.MED_MESH_DRIVER.setMeshName(), MEDMEM.GMESH.setName(), and MEDMEM.GROUP.setNumberOfFamilies().

void MEDMEMTest::testIndexCheckingPolicy

(

)

Check methods (4), defined in MEDMEM_IndexCheckingPolicy.hxx: class IndexCheckPolicy { (+) void checkMoreThanZero(const std.string & classname, int index) const; (+) void checkLessOrEqualThan(const std.string & classname, int max, int index) const; (+) void checkInInclusiveRange(const std.string & classname, int min, int max, int index) const; (+) void checkEquality(const std.string & classname, int a, int b) const; } class NoIndexCheckPolicy { (+) void checkMoreThanZero(const string &classname, int index) const; (+) void checkLessOrEqualThan(const std.string & classname, int max, int index) const; (+) void checkInInclusiveRange(const std.string & classname, int min, int max, int index) const; (+) void checkEquality(const std.string & classname, int a, int b) const; }

References MEDMEM.NoIndexCheckPolicy.checkEquality(), MEDMEM.IndexCheckPolicy.checkEquality(), MEDMEM.NoIndexCheckPolicy.checkInInclusiveRange(), MEDMEM.IndexCheckPolicy.checkInInclusiveRange(), MEDMEM.NoIndexCheckPolicy.checkLessOrEqualThan(), MEDMEM.IndexCheckPolicy.checkLessOrEqualThan(), MEDMEM.NoIndexCheckPolicy.checkMoreThanZero(), and MEDMEM.IndexCheckPolicy.checkMoreThanZero().

void MEDMEMTest::testInit

(

)

Check initialization, done in MEDMEM_Init.cxx: (-) MEDMEM.INIT init;

void MEDMEMTest::testMedFieldDriver

(

)

Check methods (17), defined in MEDMEM_MedFieldDriver22.hxx: template <class t>=""> class MED_FIELD_DRIVER22 : public virtual MED_FIELD_DRIVER<T> { (+) MED_FIELD_DRIVER22(); (+) template <class interlacing_tag>=""> MED_FIELD_DRIVER22(const string & fileName, FIELD<T, INTERLACING_TAG> * ptrField, MED_EN.med_mode_acces accessMode); (+) MED_FIELD_DRIVER22(const MED_FIELD_DRIVER22 & fieldDriver); (+) virtual ~MED_FIELD_DRIVER22(); (+) void open() throw (MEDEXCEPTION); (+) void close(); } template <class t>=""> class MED_FIELD_RDONLY_DRIVER : public virtual MED_FIELD_DRIVER22<T>, public virtual IMED_FIELD_RDONLY_DRIVER<T> { (+) MED_FIELD_RDONLY_DRIVER(); (+) template <class interlacing_tag>=""> MED_FIELD_RDONLY_DRIVER (const string & fileName, FIELD<T, INTERLACING_TAG> * ptrField); (+) MED_FIELD_RDONLY_DRIVER(const MED_FIELD_RDONLY_DRIVER & fieldDriver); (+) virtual ~MED_FIELD_RDONLY_DRIVER(); (+) void write(void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); } template <class t>=""> class MED_FIELD_WRONLY_DRIVER : public virtual MED_FIELD_DRIVER22<T>, public virtual IMED_FIELD_WRONLY_DRIVER<T> { (+) MED_FIELD_WRONLY_DRIVER(); (+) template <class interlacing_tag>=""> MED_FIELD_WRONLY_DRIVER (const string & fileName, FIELD<T, INTERLACING_TAG> * ptrField); (+) MED_FIELD_WRONLY_DRIVER(const MED_FIELD_WRONLY_DRIVER & fieldDriver); (+) virtual ~MED_FIELD_WRONLY_DRIVER(); (+) void write(void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); } template <class t>=""> class MED_FIELD_RDWR_DRIVER22 : public MED_FIELD_RDONLY_DRIVER<T>, public MED_FIELD_WRONLY_DRIVER<T>, public IMED_FIELD_RDWR_DRIVER<T> { (+) MED_FIELD_RDWR_DRIVER22(); (+) template <class interlacing_tag>=""> MED_FIELD_RDWR_DRIVER22 (const string & fileName, FIELD<T, INTERLACING_TAG> * ptrField); (+) MED_FIELD_RDWR_DRIVER22(const MED_FIELD_RDWR_DRIVER22 & fieldDriver); (+) ~MED_FIELD_RDWR_DRIVER22(); (+) void write(void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); }

References med_opsupp_test.family, Med_Gen_test.familyName, MED_test2.field, test_MEDSPLITTER.filename_rd, INTERP_TEST.getResourceFile(), MEDMEM.healName(), makeTmpFile(), MED_EN.MED_ALL_ELEMENTS, MEDMEM.MED_DRIVER, MED_EN.MED_EDGE, MED_test2.mesh, MEDMEMTest_TmpFilesRemover.Register(), and med_opsupp_test.support2.

void MEDMEMTest::testReadFieldOnNodesAndCells

(

)

0020582: [CEA 368] MEDMEM don't work with a same field on NODES and CELLS Before fixing the issue there was the error: RuntimeError: MED Exception in .../MED_SRC/src/MEDMEM/MEDMEM_MedFieldDriver22.hxx [503] : MED_FIELD_DRIVER<T>.createFieldSupportPart1(...) Field |field on NODEs and CELLs| with (ndt,or) = (-1,-1) must not be defined on different entity types

References Med_Gen_test.fieldName, makeTmpFile(), MED_EN.MED_ALL_ELEMENTS, MED_EN.MED_CELL, MEDMEM.MED_DRIVER, MED_EN.MED_NODE, MEDMEMTest_createTestMesh(), MED_test2.mesh, medMeshing_test.numberOfCells, medClient_test.numberOfNodes, MEDMEMTest_TmpFilesRemover.Register(), MEDMEM.RCBASE.removeReference(), MEDMEM.FIELD_.setName(), medMeshing_test.supportOnCells, and medMeshing_test.supportOnNodes.

void MEDMEMTest::testMedFileBrowser

(

)

References test_NonCoincidentDEC.filename, MEDMEM.MEDFILEBROWSER.getFieldIteration(), MEDMEM.MEDFILEBROWSER.getFieldNames(), MEDMEM.MEDFILEBROWSER.getFieldType(), MEDMEM.MEDFILEBROWSER.getFileName(), MEDMEM.MEDFILEBROWSER.getMeshName(), MEDMEM.MEDFILEBROWSER.getMeshNames(), MEDMEM.MEDFILEBROWSER.getNumberOfFields(), MEDMEM.MEDFILEBROWSER.getNumberOfMeshes(), INTERP_TEST.getResourceFile(), MEDMEM.MEDFILEBROWSER.isStructuredMesh(), MED_EN.MED_INT32, MED_EN.MED_REEL64, batchmode_medcorba_test.nbFields, batchmode_medcorba_test.nbMeshes, and MEDMEM.MEDFILEBROWSER.readFileStruct().

void MEDMEMTest::testMedMeshDriver

(

)

Check methods (13), defined in MEDMEM_MedMeshDriver.hxx: class MED_MESH_DRIVER { (+) MED_MESH_DRIVER(); (+) MED_MESH_DRIVER(const string & fileName, MESH * ptrMesh, MED_EN.med_mode_acces accessMode); (+) MED_MESH_DRIVER(const MED_MESH_DRIVER22 & driver); (+) virtual ~MED_MESH_DRIVER(); (+) void open(); (+) void close(); } class MED_MESH_RDONLY_DRIVER : public virtual MED_MESH_DRIVER, { (+) MED_MESH_RDONLY_DRIVER(); (+) MED_MESH_RDONLY_DRIVER(const string & fileName, MESH * ptrMesh); (+) MED_MESH_RDONLY_DRIVER(const MED_MESH_RDONLY_DRIVER & driver); (+) virtual ~MED_MESH_RDONLY_DRIVER(); (+) void read (void); } class MED_MESH_WRONLY_DRIVER : public virtual MED_MESH_DRIVER { (+) MED_MESH_WRONLY_DRIVER(); (+) MED_MESH_WRONLY_DRIVER(const string & fileName, MESH * ptrMesh); (+) MED_MESH_WRONLY_DRIVER(const MED_MESH_WRONLY_DRIVER & driver); (+) virtual ~MED_MESH_WRONLY_DRIVER(); (+) void write(void) const; } class MED_MESH_RDWR_DRIVER : public MED_MESH_RDONLY_DRIVER, public MED_MESH_WRONLY_DRIVER { (+) MED_MESH_RDWR_DRIVER(); (+) MED_MESH_RDWR_DRIVER(const string & fileName, MESH * ptrMesh); (+) MED_MESH_RDWR_DRIVER(const MED_MESH_RDWR_DRIVER & driver); (+) ~MED_MESH_RDWR_DRIVER(); (+) void write(void) const; (+) void read (void); }

References MEDMEM.MED_MESH_DRIVER.close(), test_MEDSPLITTER.filename_rd, MEDMEM.MED_MESH_DRIVER.getMeshName(), INTERP_TEST.getResourceFile(), makeTmpFile(), test_MEDSPLITTER.meshname, MEDMEM.MED_MESH_DRIVER.open(), MEDMEM.MED_MESH_RDWR_DRIVER.read(), MEDMEM.MED_MESH_WRONLY_DRIVER.read(), MEDMEM.MED_MESH_RDONLY_DRIVER.read(), MEDMEMTest_TmpFilesRemover.Register(), MEDMEM.RCBASE.removeReference(), MEDMEM.MED_MESH_DRIVER.setMeshName(), MEDMEM.GMESH.setName(), MEDMEM.MEDEXCEPTION.what(), MEDMEM.MED_MESH_RDWR_DRIVER.write(), and MEDMEM.MED_MESH_WRONLY_DRIVER.write().

void MEDMEMTest::testMedVersion

(

)

Check methods (not in spec), defined in MEDMEM_MedVersion.hxx: (+) MED_EN.medFileVersion getMedFileVersion(const string & fileName) throw (MEDEXCEPTION); (+) int getMedAccessMode(MED_EN.med_mode_acces mode, MED_EN.medFileVersion medVersion) throw (MEDEXCEPTION);

References test_NonCoincidentDEC.filename, MEDMEM.getMedFileVersion(), INTERP_TEST.getResourceFile(), and MED_EN.V21.

void MEDMEMTest::testMeshAndMeshing

(

)

Check methods (12), defined in MEDMEM_Meshing.hxx: class MESHING: public MESH { (+) MESHING(); (+) ~MESHING(); (+) void setCoordinates (const int SpaceDimension, const int NumberOfNodes, const double * Coordinates, const string System, const MED_EN.medModeSwitch Mode); (+) void setCoordinatesNames (const string * names); (+) void setCoordinateName (const string name, const int i); (+) void setCoordinatesUnits (const string * units); (+) void setCoordinateUnit (const string unit, const int i); (+) void setNumberOfTypes (const int NumberOfTypes, const MED_EN.medEntityMesh Entity) throw (MEDEXCEPTION); (+) void setTypes (const MED_EN.medGeometryElement * Types, const MED_EN.medEntityMesh Entity) throw (MEDEXCEPTION); (+) void setNumberOfElements (const int * NumberOfElements, const MED_EN.medEntityMesh Entity) throw (MEDEXCEPTION); (+) void setConnectivity (const int * Connectivity, const MED_EN.medEntityMesh Entity, const MED_EN.medGeometryElement Type, const int * PolyConnectivityIndex=0) throw (MEDEXCEPTION); (+) void addGroup (const GROUP & Group) throw (MEDEXCEPTION);

}

Check methods (67), defined in MEDMEM_Mesh.hxx: class MESH : public RCBASE { (+) void init(); (+) MESH(); (+) MESH(MESH &m); (+) MESH & operator=(const MESH &m); (+) virtual bool operator==(const MESH& other) const; (+) virtual bool deepCompare(const MESH& other) const; (+) MESH(driverTypes driverType, const string & fileName="", const string & meshName="") throw (MEDEXCEPTION); (+) virtual ~MESH(); (+) friend ostream & operator<<(ostream &os, const MESH &my); (+) int addDriver(driverTypes driverType, const string & fileName="Default File Name.med", const string & driverName="Default Mesh Name", MED_EN.med_mode_acces access=MED_EN::MED_REMP); (+) int addDriver(GENDRIVER & driver); (+) void rmDriver(int index=0); (+) virtual void read(int index=0); (+) inline void read(const GENDRIVER & genDriver); (+) inline void write(int index=0); (+) inline void write(const GENDRIVER & genDriver, MED_EN.med_mode_acces medMode=MED_EN::WRONLY); (+) inline void write(driverTypes driverType, const std.string& filename, const std.string& meshname="", MED_EN.med_mode_acces medMode=MED_EN::WRONLY) const; (+) inline void setName(string name); (+) inline void setDescription(string description); (+) inline string getName() const; (+) inline string getDescription() const; (+) inline int getSpaceDimension() const; (+) inline int getMeshDimension() const; (+) inline bool getIsAGrid(); (+) inline int getNumberOfNodes() const; (+) virtual inline const COORDINATE * getCoordinateptr() const; (+) inline string getCoordinatesSystem() const; (+) virtual inline const double * getCoordinates(MED_EN.medModeSwitch Mode) const; (+) virtual inline const double getCoordinate(int Number,int Axis) const; (+) inline const string * getCoordinatesNames() const; (+) inline const string * getCoordinatesUnits() const; (+) virtual inline int getNumberOfTypes(MED_EN.medEntityMesh Entity) const; (+) virtual inline const MED_EN.medGeometryElement * getTypes(MED_EN.medEntityMesh Entity) const; (+) virtual inline const CELLMODEL * getCellsTypes(MED_EN.medEntityMesh Entity) const; (+) virtual inline string * getCellTypeNames(MED_EN.medEntityMesh Entity) const; (+) virtual const int * getGlobalNumberingIndex(MED_EN.medEntityMesh Entity) const; (+) virtual inline int getNumberOfElements(MED_EN.medEntityMesh Entity, MED_EN.medGeometryElement Type) const; (+) virtual inline bool existConnectivity(MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity) const; (+) virtual inline MED_EN.medGeometryElement getElementType (MED_EN.medEntityMesh Entity, int Number) const; (+) virtual inline void calculateConnectivity(MED_EN.medModeSwitch Mode, MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity) const; (+) virtual inline int getConnectivityLength(MED_EN.medModeSwitch Mode, MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity, MED_EN.medGeometryElement Type) const; (+) virtual inline const int * getConnectivity(MED_EN.medModeSwitch Mode, MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity, MED_EN.medGeometryElement Type) const; (+) virtual inline const int * getConnectivityIndex (MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity) const; (+) virtual int getElementNumber(MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity, MED_EN.medGeometryElement Type, int * connectivity) const; (+) virtual inline int getReverseConnectivityLength (MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity=MED_EN::MED_CELL) const; (+) virtual inline const int * getReverseConnectivity (MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity=MED_EN::MED_CELL) const; (+) virtual inline int getReverseConnectivityIndexLength (MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity=MED_EN::MED_CELL) const; (+) virtual inline const int * getReverseConnectivityIndex (MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity=MED_EN::MED_CELL) const; (+) virtual int getNumberOfFamilies(MED_EN.medEntityMesh Entity) const; (+) virtual inline const vector<FAMILY*> getFamilies(MED_EN.medEntityMesh Entity) const; (+) virtual inline const FAMILY* getFamily(MED_EN.medEntityMesh Entity,int i) const; (+) virtual int getNumberOfGroups(MED_EN.medEntityMesh Entity) const; (+) virtual inline const vector<GROUP*> getGroups(MED_EN.medEntityMesh Entity) const; (+) virtual inline const GROUP* getGroup(MED_EN.medEntityMesh Entity,int i) const; (+) virtual inline const CONNECTIVITY* getConnectivityptr() const; (+) virtual SUPPORT * getBoundaryElements(MED_EN.medEntityMesh Entity) throw (MEDEXCEPTION); (+) SUPPORT * getSkin(const SUPPORT * Support3D) throw (MEDEXCEPTION); (+) virtual FIELD<double>* getVolume (const SUPPORT * Support) const throw (MEDEXCEPTION); (+) virtual FIELD<double>* getArea (const SUPPORT * Support) const throw (MEDEXCEPTION); (+) virtual FIELD<double>* getLength (const SUPPORT * Support) const throw (MEDEXCEPTION); (+) virtual FIELD<double>* getNormal (const SUPPORT * Support) const throw (MEDEXCEPTION); (+) virtual FIELD<double>* getBarycenter (const SUPPORT * Support) const throw (MEDEXCEPTION); (+) static SUPPORT * mergeSupports(const vector<SUPPORT *> Supports) throw (MEDEXCEPTION); (+) static SUPPORT * intersectSupports(const vector<SUPPORT *> Supports) throw (MEDEXCEPTION); (+) void createFamilies(); (+) SUPPORT *buildSupportOnNodeFromElementList (const list<int>& listOfElt, MED_EN.medEntityMesh entity) const throw (MEDEXCEPTION); (do the same thing as buildSupportOnNodeFromElementList except that a SUPPORT is not created) void fillSupportOnNodeFromElementList (const list<int>& listOfElt, SUPPORT *supportToFill) const throw (MEDEXCEPTION); (+) SUPPORT *buildSupportOnElementsFromElementList (const list<int>& listOfElt, MED_EN.medEntityMesh entity) const throw (MEDEXCEPTION); (+) int getElementContainingPoint(const double *coord); (+) vector< vector<double> > getBoundingBox() const; (+) template<class T> static FIELD<T> * mergeFields(const vector< FIELD<T> * > & others, bool meshCompare=false); (Presently disconnected in C++) virtual void addReference() const; (Presently disconnected in C++) virtual void removeReference() const;

}

References MEDMEM.FIELD< T, INTERLACING_TAG >.addDriver(), MEDMEM.GMESH.addDriver(), MEDMEM.MESHING.addGroup(), addMedFacesGroup(), med_test1.area, med_test1.barycenter, bottom, bottomIndex, bottomNbOfElts, bottomTypes, MEDMEM.GMESH.buildSupportOnElementsFromElementList(), MEDMEM.MESH.buildSupportOnNodeFromElementList(), MEDMEM.MESH.calculateConnectivity(), testRenumbering.conn, medClient_test.connectivity, coords, TestMedCorba3.d, MEDMEM.SUPPORT.deepCompare(), MEDMEM.MESH.deepCompare(), MEDMEM.MED_MESH_RDONLY_DRIVER.desactivateFacesComputation(), medMeshing_test.driver, med_opsupp_test.entity, MEDMEM.MESH.existConnectivity(), MEDCouplingCorbaSwigTestClt.f, med_opsupp_test.family, MED_test2.field, test_NonCoincidentDEC.filename, MEDMEM.MESH.getArea(), MEDMEM.MESH.getBarycenter(), MEDMEM.MESH.getBoundaryElements(), MEDMEM.MESH.getBoundingBox(), MEDMEM.MESH.getConnectivity(), MEDMEM.MESH.getConnectivityIndex(), MEDMEM.MESH.getConnectivityLength(), MEDMEM.MESH.getConnectivityptr(), MEDMEM.MESH.getCoordinateptr(), MEDMEM.MESH.getElementContainingPoint(), MEDMEM.MESH.getElementType(), MEDMEM.SUPPORT.getEntity(), MEDMEM.CONNECTIVITY.getEntity(), MEDMEM.GMESH.getFamilies(), MEDMEM.GMESH.getFamily(), MEDMEM.GMESH.getGroups(), MEDMEM.MESH.getIsAGrid(), MEDMEM.MESH.getLength(), MEDMEM.MESH.getMeshDimension(), MEDMEM.FIELD_.getName(), MEDMEM.GMESH.getName(), MEDMEM.SUPPORT.getName(), MEDMEM.MESH.getNormal(), MEDMEM.SUPPORT.getNumber(), MEDMEM.FIELD_.getNumberOfComponents(), MEDMEM.MESH.getNumberOfElements(), MEDMEM.GMESH.getNumberOfFamilies(), MEDMEM.MESH.getNumberOfNodes(), MEDMEM.SUPPORT.getNumberOfTypes(), MEDMEM.MESH.getNumberOfTypes(), MEDMEM.CONNECTIVITY.getNumberOfTypes(), MEDMEM.FIELD_.getNumberOfValues(), INTERP_TEST.getResourceFile(), MEDMEM.MESH.getReverseConnectivity(), MEDMEM.MESH.getReverseConnectivityIndex(), MEDMEM.MESH.getReverseConnectivityIndexLength(), MEDMEM.MESH.getReverseConnectivityLength(), MEDMEM.MESH.getSkin(), MEDMEM.GMESH.getSpaceDimension(), MEDMEM.FIELD_.getSupport(), MEDMEM.GMESH.getSupportOnAll(), MEDMEM.MESH.getTypes(), MEDMEM.SUPPORT.getValIndFromGlobalNumber(), MEDMEM.FIELD< T, INTERLACING_TAG >.getValue(), MEDMEM.FIELD< T, INTERLACING_TAG >.getValueIJ(), MEDMEM.MESH.getVolume(), med_test1.group, medClient_test.index, MEDMEM.MESH.init(), MEDMEM.GMESH.intersectSupports(), MEDMEM.SUPPORT.isOnAllElements(), med_test1.length, TestMedCorba2.m, makeTmpFile(), MED_EN.MED_ALL_ELEMENTS, MED_EN.MED_ALL_ENTITIES, MED_EN.MED_CELL, MED_EN.MED_DESCENDING, MEDMEM.MED_DRIVER, MED_EN.MED_EDGE, MED_EN.MED_FACE, MED_EN.MED_FULL_INTERLACE, MED_EN.MED_HEXA8, MED_EN.MED_INVALID, MED_EN.MED_NODAL, MED_EN.MED_NODE, MED_EN.MED_NONE, MED_EN.MED_POLYGON, MED_EN.MED_POLYHEDRA, MED_EN.MED_PYRA5, MED_EN.MED_QUAD4, MED_EN.MED_SEG2, MED_EN.MED_TETRA4, MED_EN.MED_TRIA3, MEDMEMTest_createTestMesh(), MEDMEM.GMESH.mergeFields(), MEDMEM.GMESH.mergeSupports(), MED_test2.mesh, test_gibi.mesh1, medClient_test.meshDimension, test_MEDSPLITTER.meshname, medMeshing_test.myGroup, medMeshing_test.myMeshing, medMeshing_test.myNumberOfElements, medMeshing_test.myTypes, batchmode_medcorba_test.nbNodes, med_test1.normal, MED_EN.RDONLY, MED_EN.RDWR, MEDMEM.FIELD< T, INTERLACING_TAG >.read(), MEDMEM.GMESH.read(), MEDMEMTest_TmpFilesRemover.Register(), MEDMEM.RCBASE.removeReference(), MEDMEM.GMESH.rmDriver(), MEDMEM.FIELD_.setComponentName(), MEDMEM.MESHING.setConnectivity(), MEDMEM.MESHING.setCoordinateName(), MEDMEM.MESHING.setCoordinates(), MEDMEM.MESHING.setCoordinatesNames(), MEDMEM.MESHING.setCoordinatesUnits(), MEDMEM.MESHING.setCoordinateUnit(), MEDMEM.SUPPORT.setEntity(), MEDMEM.SUPPORT.setGeometricType(), MEDMEM.FIELD_.setIterationNumber(), MEDMEM.FIELD_.setMEDComponentUnit(), MEDMEM.SUPPORT.setMesh(), MEDMEM.MED_MESH_DRIVER.setMeshName(), MEDMEM.FIELD_.setName(), MEDMEM.SUPPORT.setName(), MEDMEM.GMESH.setName(), MEDMEM.SUPPORT.setNumber(), MEDMEM.SUPPORT.setNumberOfElements(), MEDMEM.MESHING.setNumberOfElements(), MEDMEM.SUPPORT.setNumberOfGeometricType(), MEDMEM.CONNECTIVITY.setNumberOfNodes(), MEDMEM.MESHING.setNumberOfTypes(), MEDMEM.FIELD_.setOrderNumber(), MEDMEM.SUPPORT.setpartial(), MEDMEM.FIELD_.setTime(), MEDMEM.MESHING.setTypes(), test_NonCoincidentDEC.size, batchmode_medcorba_test.spaceDim, dumpMEDMEM.tab, medClient_test.type, batchmode_medcorba_test.value, med_test1.volume, MEDMEM.VTK_DRIVER, MEDMEM.MEDEXCEPTION.what(), MEDMEM.FIELD< T, INTERLACING_TAG >.write(), and MEDMEM.GMESH.write().

void MEDMEMTest::testModulusArray

(

)

Check methods (4), defined in MEDMEM_ModulusArray.hxx: class MEDMODULUSARRAY { (+) MEDMODULUSARRAY(int length, const int * array); (+) MEDMODULUSARRAY(int vertexLength, int totalLength, const int * array); (+) ~MEDMODULUSARRAY(); (+) const int operator[](const int &i) const; (+) int compare(const MEDMODULUSARRAY &modulusArray) const; }

References MEDMEM.MEDMODULUSARRAY.compare(), and testMEDMEM.ret.

void MEDMEMTest::testnArray

(

)

Check methods (21), defined in MEDMEM_nArray.hxx: class MEDMEM_Array_ { (-) virtual bool getGaussPresence() const { return false; } (-) virtual MED_EN.medModeSwitch getInterlacingType() const {return MED_EN.MED_UNDEFINED_INTERLACE;} (+) ~MEDMEM_Array_() {}; } template<class ARRAY_ELEMENT_TYPE, class INTERLACING_POLICY=FullInterlaceNoGaussPolicy, class CHECKING_POLICY=IndexCheckPolicy> class MEDMEM_Array : public INTERLACING_POLICY, public CHECKING_POLICY, public MEDMEM_Array_ { (+) MEDMEM_Array(); (+) ~MEDMEM_Array(); (+) inline MEDMEM_Array(int dim, int nbelem); (+) inline MEDMEM_Array(ElementType * values, int dim, int nbelem, bool shallowCopy=false, bool ownershipOfValues=false); (+) inline MEDMEM_Array(int dim, int nbelem, int nbtypegeo, const int * const nbelgeoc, const int * const nbgaussgeo); (+) inline MEDMEM_Array(ElementType * values, int dim, int nbelem, int nbtypegeo, const int * const nbelgeoc, const int * const nbgaussgeo, bool shallowCopy=false, bool ownershipOfValues=false); (+) inline MEDMEM_Array(const MEDMEM_Array & array, bool shallowCopy=false); (+) inline MEDMEM_Array<ElementType,InterlacingPolicy,CheckingPolicy> & operator=(const MEDMEM_Array & array); (+) MED_EN.medModeSwitch getInterlacingType() const; (+) bool getGaussPresence() const; (+) ElementType * getPtr(); (+) void setPtr(ElementType * values, bool shallowCopy=false, bool ownershipOfValues=false); (+) inline const ElementType * getRow(int i) const; (+) void setRow(int i,const ElementType * const value); (+) inline const ElementType * getColumn(int j) const; (+) void setColumn(int j, const ElementType * const value); (+) inline const ElementType & getIJ(int i, int j) const; (+) inline const ElementType & getIJK(int i, int j, int k) const; (+) inline void setIJ(int i, int j, const ElementType & value); (+) inline void setIJK(int i, int j, int k, const ElementType & value); (+) bool operator == (const MEDMEM_Array & array) const; (+) friend ostream & operator<<(ostream & os, const MEDMEM_Array & array); }

References MEDMEM.ArrayConvert(), MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.getColumn(), MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.getGaussPresence(), MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.getIJ(), MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.getIJK(), MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.getInterlacingType(), MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.getPtr(), MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.getRow(), TestMedCorba2.m, MED_EN.MED_UNDEFINED_INTERLACE, MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.setColumn(), MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.setIJ(), MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.setIJK(), MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.setPtr(), MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.setRow(), and MEDMEM.MEDEXCEPTION.what().

void MEDMEMTest::testPartialDescendingConnectivity

(

)

References connNodalCellClassical, connNodalFaceClassical, coords, MED_EN.MED_ALL_ELEMENTS, MED_EN.MED_CELL, MED_EN.MED_DESCENDING, MED_EN.MED_EDGE, MED_EN.MED_FACE, MED_EN.MED_FULL_INTERLACE, MED_EN.MED_HEXA8, MED_EN.MED_NODAL, MED_EN.MED_QUAD4, and MED_EN.MED_SEG2.

void MEDMEMTest::testPointerOf

(

)

Check methods (12), defined in MEDMEM_PointerOf.hxx: template <typename t>=""> class PointerOf { (+) PointerOf(); (+) ~PointerOf(); (+) PointerOf(const int &size); (+) PointerOf(const T *pointer); (+) PointerOf(const int &size, const T *pointer); (+) PointerOf(const PointerOf<T> & pointerOf); (NOT COMPILABLE!!!) PointerOf(const int &size, const PointerOf<T> & pointerOf); (+) operator T*(); (+) operator const T*() const; (+) void set(const int &size); (+) void set(const T *pointer); (+) void set(const int &size, const T *pointer); (+) void setShallowAndOwnership(const T *pointer); (+) PointerOf<T>& operator=(const PointerOf<T> &pointer); }

References SCRUTE_MED, MEDMEM.PointerOf< T >.set(), MEDMEM.PointerOf< T >.setShallowAndOwnership(), and test_NonCoincidentDEC.size.

void MEDMEMTest::testPorflowMeshDriver

(

)

Check methods (18), defined in MEDMEM_PorflowMeshDriver.hxx: class PORFLOW_MESH_DRIVER : public GENDRIVER { (+) PORFLOW_MESH_DRIVER(); (+) PORFLOW_MESH_DRIVER(const string & fileName, MESH * ptrMesh, MED_EN.med_mode_acces accessMode); (+) PORFLOW_MESH_DRIVER(const PORFLOW_MESH_DRIVER & driver); (+) virtual ~PORFLOW_MESH_DRIVER(); (+) void open() throw (MEDEXCEPTION); (+) void close() throw (MEDEXCEPTION); (-) virtual void write(void) const = 0; (+) virtual void read (void) = 0; (+) void setMeshName(const string & meshName); (+) string getMeshName() const; } class PORFLOW_MESH_RDONLY_DRIVER : public virtual PORFLOW_MESH_DRIVER { (+) PORFLOW_MESH_RDONLY_DRIVER(); (+) PORFLOW_MESH_RDONLY_DRIVER(const string & fileName, MESH * ptrMesh); (+) PORFLOW_MESH_RDONLY_DRIVER(const PORFLOW_MESH_RDONLY_DRIVER & driver); (+) virtual ~PORFLOW_MESH_RDONLY_DRIVER(); (+) void write(void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); } class PORFLOW_MESH_WRONLY_DRIVER : public virtual PORFLOW_MESH_DRIVER { (+) PORFLOW_MESH_WRONLY_DRIVER(); (+) PORFLOW_MESH_WRONLY_DRIVER(const string & fileName, MESH * ptrMesh); (+) PORFLOW_MESH_WRONLY_DRIVER(const PORFLOW_MESH_WRONLY_DRIVER & driver); (+) virtual ~PORFLOW_MESH_WRONLY_DRIVER(); (NOT IMPLEMENTED!!!) void write(void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); } class PORFLOW_MESH_RDWR_DRIVER : public PORFLOW_MESH_RDONLY_DRIVER, public PORFLOW_MESH_WRONLY_DRIVER { (+) PORFLOW_MESH_RDWR_DRIVER(); (+) PORFLOW_MESH_RDWR_DRIVER(const string & fileName, MESH * ptrMesh); (+) PORFLOW_MESH_RDWR_DRIVER(const PORFLOW_MESH_RDWR_DRIVER & driver); (+) ~PORFLOW_MESH_RDWR_DRIVER(); (CALLS PORFLOW_MESH_WRONLY_DRIVER.write()) void write(void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); }

References MEDMEM.PORFLOW_MESH_DRIVER.close(), test_MEDSPLITTER.filename_rd, MEDMEM.PORFLOW_MESH_DRIVER.getMeshName(), INTERP_TEST.getResourceFile(), makeTmpFile(), test_MEDSPLITTER.meshname, MEDMEM.PORFLOW_MESH_DRIVER.open(), MEDMEM.PORFLOW_MESH_RDWR_DRIVER.read(), MEDMEM.PORFLOW_MESH_WRONLY_DRIVER.read(), MEDMEM.PORFLOW_MESH_RDONLY_DRIVER.read(), MEDMEMTest_TmpFilesRemover.Register(), MEDMEM.RCBASE.removeReference(), MEDMEM.PORFLOW_MESH_DRIVER.setMeshName(), ensightMedEnsight_test.tmpFile, MEDMEM.PORFLOW_MESH_RDWR_DRIVER.write(), MEDMEM.PORFLOW_MESH_WRONLY_DRIVER.write(), and MEDMEM.PORFLOW_MESH_RDONLY_DRIVER.write().

void MEDMEMTest::testSkyLineArray

(

)

Check methods (17), defined in MEDMEM_SkyLineArray.hxx: class MEDSKYLINEARRAY { (+) MEDSKYLINEARRAY(); (+) MEDSKYLINEARRAY(const MEDSKYLINEARRAY &myArray); (+) MEDSKYLINEARRAY(const int count, const int length); (+) MEDSKYLINEARRAY(const int count, const int length, const int* index, const int* value, bool shallowCopy=false); (+) ~MEDSKYLINEARRAY(); (+) inline int getNumberOf() const; (+) inline int getLength() const; (+) inline const int* getIndex() const; (+) inline const int* getValue() const; (+) inline int getNumberOfI(int i) const throw (MEDEXCEPTION); (+) inline const int* getI(int i) const throw (MEDEXCEPTION); (+) inline int getIJ(int i, int j) const throw (MEDEXCEPTION); (+) inline int getIndexValue(int i) const throw (MEDEXCEPTION); (+) inline void setIndex(const int* index); (+) inline void setI(const int i, const int* values) throw (MEDEXCEPTION); (+) inline void setIJ(int i, int j, int value) throw (MEDEXCEPTION); (+) inline void setIndexValue(int i, int value) throw (MEDEXCEPTION); (+) friend ostream& operator<<(ostream &os, const MEDSKYLINEARRAY &sky); }

References MEDMEM.MEDSKYLINEARRAY.getI(), MEDMEM.MEDSKYLINEARRAY.getIJ(), MEDMEM.MEDSKYLINEARRAY.getIndex(), MEDMEM.MEDSKYLINEARRAY.getIndexValue(), MEDMEM.MEDSKYLINEARRAY.getLength(), MEDMEM.MEDSKYLINEARRAY.getNumberOf(), MEDMEM.MEDSKYLINEARRAY.getNumberOfI(), MEDMEM.MEDSKYLINEARRAY.getValue(), medClient_test.index, MEDMEM.MEDSKYLINEARRAY.setI(), MEDMEM.MEDSKYLINEARRAY.setIJ(), MEDMEM.MEDSKYLINEARRAY.setIndex(), MEDMEM.MEDSKYLINEARRAY.setIndexValue(), and batchmode_medcorba_test.value.

void MEDMEMTest::testSTRING

(

)

Check methods (not in spec), defined in MEDMEM_InterlacingPolicy.hxx:

Check methods (not in spec), defined in MEDMEM_InterlacingTraits.hxx:

Check methods (not in spec), defined in MEDMEM_MedFieldDriver.hxx:

Check methods (not in spec), defined in MEDMEM_MEDMEMchampLire.hxx:

Check methods (not in spec), defined in MEDMEM_MEDMEMgaussEcr.hxx:

Check methods (not in spec), defined in MEDMEM_MEDMEMprofilEcr.hxx:

Check methods (not in spec), defined in MEDMEM_MedMeshDriver.hxx:

Check methods (not in spec), defined in MEDMEM_RCBase.hxx: class RCBASE { (reference counter presently disconnected in C++) virtual void addReference() const = 0; (reference counter presently disconnected in C++) virtual void removeReference() const = 0; }

Check methods (not in spec), defined in MEDMEM_SetInterlacingType.hxx:

Check methods (2), defined in MEDMEM_STRING.hxx: class STRING : public string { (+) STRING() (+) ~STRING() (+) operator const char * () const (+) template <class t>=""> STRING(const T &valeur) (+) template <class t>=""> STRING & operator<<(const T &valeur) }

References MEDMEMTest_createTestMesh().

void MEDMEMTest::testSupport

(

)

Check methods (48), defined in MEDMEM_Support.hxx: class SUPPORT : public RCBASE { (+) SUPPORT(); (+) SUPPORT(MESH* Mesh, string Name="", MED_EN.medEntityMesh Entity=MED_EN::MED_CELL); (+) SUPPORT(const SUPPORT & m); (+) virtual ~SUPPORT();

(+) friend ostream & operator<<(ostream &os,const SUPPORT &my); (+) SUPPORT& operator=(const SUPPORT &support); (+) bool operator == (const SUPPORT &support) const; (+) bool deepCompare(const SUPPORT &support) const;

(+) void update();

(+) inline void setName(string Name); (+) inline void setDescription(string Description); (+) void setMesh(MESH *Mesh) const; (+) inline void setMeshName(const string & meshName); (+) inline void setAll(bool All); (+) inline void setEntity(MED_EN.medEntityMesh Entity);

(+) inline void setNumberOfGeometricType(int NumberOfGeometricType); (+) inline void setGeometricType(const MED_EN.medGeometryElement *GeometricType); (+) inline void setNumberOfElements(const int *NumberOfElements); (+) inline void setTotalNumberOfElements(int TotalNumberOfElements); (+) inline void setNumber(MEDSKYLINEARRAY * Number); (+) inline void setNumber(const int * index, const int* value, bool shallowCopy=false);

(+) inline string getName() const; (+) inline string getDescription() const; (+) virtual inline MESH * getMesh() const; (+) string getMeshName() const; (+) inline MED_EN.medEntityMesh getEntity() const; (+) inline bool isOnAllElements() const;

(+) inline int getNumberOfTypes() const; (+) inline const MED_EN.medGeometryElement* getTypes() const; (+) inline int getNumberOfElements (MED_EN.medGeometryElement GeometricType) const throw (MEDEXCEPTION); (+) inline const int * getNumberOfElements() const throw (MEDEXCEPTION); (+) virtual inline MEDSKYLINEARRAY * getnumber() const throw (MEDEXCEPTION); (NO METHOD IN THIS BRANCH) virtual inline MEDSKYLINEARRAY * getnumberFromFile() const throw (MEDEXCEPTION); (+) virtual inline const int * getNumber (MED_EN.medGeometryElement GeometricType) const throw (MEDEXCEPTION); (NO METHOD IN THIS BRANCH) virtual inline const int * getNumberFromFile (MED_EN.medGeometryElement GeometricType) const throw (MEDEXCEPTION); (+) virtual inline const int * getNumberIndex() const throw (MEDEXCEPTION); (+) virtual int getValIndFromGlobalNumber(const int number) const throw (MEDEXCEPTION);

(+) void blending(SUPPORT * mySupport) throw (MEDEXCEPTION);

(+) void setpartial(string Description, int NumberOfGeometricType, int TotalNumberOfEntity, MED_EN.medGeometryElement *GeometricType, int *NumberOfEntity, int *NumberValue); (+) void setpartial(MEDSKYLINEARRAY * number, bool shallowCopy=false) throw (MEDEXCEPTION); (NO METHOD IN THIS BRANCH) void setpartial_fromfile(MEDSKYLINEARRAY * number, bool shallowCopy=false) throw (MEDEXCEPTION);

(+) void setProfilNames(vector<string> profilNames) throw (MEDEXCEPTION); (+) vector<string> getProfilNames() const throw (MEDEXCEPTION);

(+) void getBoundaryElements() throw (MEDEXCEPTION);

(+) void changeElementsNbs(MED_EN.medEntityMesh entity, const int *renumberingFromOldToNew, int limitNbClassicPoly, const int *renumberingFromOldToNewPoly=0); (+) void intersecting(SUPPORT * mySupport) throw (MEDEXCEPTION); (+) bool belongsTo(const SUPPORT& other, bool deepCompare=false) const;

(+) SUPPORT *getComplement() const; (+) SUPPORT *substract(const SUPPORT& other) const throw (MEDEXCEPTION);

(+) SUPPORT *getBoundaryElements(MED_EN.medEntityMesh Entity) const throw (MEDEXCEPTION);

(+) void fillFromNodeList(const list<int>& listOfNode) throw (MEDEXCEPTION); (+) void fillFromElementList(const list<int>& listOfElt) throw (MEDEXCEPTION);

(+) void clearDataOnNumbers();

(reference counter presently disconnected in C++) virtual void addReference() const; (reference counter presently disconnected in C++) virtual void removeReference() const;

}

References MEDMEM.SUPPORT.belongsTo(), MEDMEM.SUPPORT.blending(), MEDMEM.SUPPORT.buildSupportOnNode(), MEDMEM.SUPPORT.changeElementsNbs(), MEDMEM.SUPPORT.clearDataOnNumbers(), MEDMEM.MED_MESH_DRIVER.close(), testRenumbering.conn, coords, MEDMEM.SUPPORT.deepCompare(), MEDMEM.MED_MESH_RDONLY_DRIVER.desactivateFacesComputation(), med_opsupp_test.entity, MEDMEM.MESH.existConnectivity(), MEDMEM.SUPPORT.fillFromElementList(), MEDMEM.SUPPORT.fillFromNodeList(), MEDMEM.SUPPORT.getBoundaryElements(), MEDMEM.MESH.getCellsTypes(), MEDMEM.SUPPORT.getComplement(), MEDMEM.MESH.getConnectivity(), MEDMEM.MESH.getConnectivityLength(), MEDMEM.MESH.getCoordinates(), MEDMEM.SUPPORT.getDescription(), MEDMEM.SUPPORT.getEntity(), MEDMEM.MEDSKYLINEARRAY.getIndex(), MEDMEM.MEDSKYLINEARRAY.getLength(), MEDMEM.SUPPORT.getMesh(), MEDMEM.MESH.getMeshDimension(), MEDMEM.SUPPORT.getMeshName(), MEDMEM.SUPPORT.getnumber(), MEDMEM.SUPPORT.getNumber(), MEDMEM.MEDSKYLINEARRAY.getNumberOf(), MEDMEM.MESH.getNumberOfElements(), MEDMEM.SUPPORT.getNumberOfElements(), MEDMEM.CELLMODEL.getNumberOfNodes(), MEDMEM.MESH.getNumberOfNodes(), MEDMEM.SUPPORT.getNumberOfTypes(), MEDMEM.SUPPORT.getProfilNames(), INTERP_TEST.getResourceFile(), MEDMEM.GMESH.getSpaceDimension(), MEDMEM.GMESH.getSupportOnAll(), MEDMEM.SUPPORT.getTypes(), MEDMEM.SUPPORT.getValIndFromGlobalNumber(), MEDMEM.MEDSKYLINEARRAY.getValue(), medClient_test.index, MEDMEM.SUPPORT.intersecting(), MEDMEM.SUPPORT.isOnAllElements(), MEDMEM.SUPPORT.makeMesh(), MED_EN.MED_ALL_ELEMENTS, MED_EN.MED_ALL_ENTITIES, MED_EN.MED_CELL, MED_EN.MED_FACE, MED_EN.MED_FULL_INTERLACE, MED_EN.MED_HEXA8, MED_EN.MED_NODAL, MED_EN.MED_NODE, MED_EN.MED_NONE, MED_EN.MED_PENTA15, MED_EN.MED_POINT1, MED_EN.MED_POLYGON, MED_EN.MED_POLYHEDRA, MED_EN.MED_PYRA5, MED_EN.MED_QUAD4, MED_EN.MED_QUAD8, MED_EN.MED_TETRA4, MED_EN.MED_TRIA3, MED_EN.MED_TRIA6, MEDMEMTest_createTestMesh(), medClient_test.meshDimension, batchmode_medcorba_test.nbNodes, nodes, MEDMEM.MED_MESH_DRIVER.open(), MEDMEM.MED_MESH_RDONLY_DRIVER.read(), MEDMEM.RCBASE.removeReference(), TestMedCorba7.s, TestMedCorba3.s2, MEDMEM.SUPPORT.setAll(), MEDMEM.SUPPORT.setDescription(), MEDMEM.SUPPORT.setEntity(), MEDMEM.SUPPORT.setGeometricType(), MEDMEM.SUPPORT.setMesh(), MEDMEM.MED_MESH_DRIVER.setMeshName(), MEDMEM.SUPPORT.setMeshName(), MEDMEM.SUPPORT.setName(), MEDMEM.SUPPORT.setNumber(), MEDMEM.SUPPORT.setNumberOfElements(), MEDMEM.SUPPORT.setNumberOfGeometricType(), MEDMEM.SUPPORT.setpartial(), MEDMEM.SUPPORT.setProfilNames(), medClient_test.spaceDimension, MEDMEM.SUPPORT.substract(), medClient_test.types, and MEDMEM.SUPPORT.update().

void MEDMEMTest::testTopLevel

(

)

Check methods (6), defined in MEDMEM_TopLevel.hxx: (+) MESH *readMeshInFile(const std.string& fileName, const std.string& meshName); (+) template<class T> FIELD<T> *readFieldInFile (const std.string& fileName, const std.string& fieldName); (+) void writeMeshToFile(const MESH *meshObj, const std.string& fileName); (-) template<class T> void writeFieldToFile(const FIELD<T> *fieldObj, const std.string& fileName);

References test_MEDSPLITTER.filename_rd, INTERP_TEST.getResourceFile(), makeTmpFile(), MEDMEMTest_createTestMesh(), test_MEDSPLITTER.meshname, MEDMEM.FIELD< T, INTERLACING_TAG >.read(), MEDMEM.readMeshInFile(), MEDMEMTest_TmpFilesRemover.Register(), MEDMEM.RCBASE.removeReference(), MEDMEM.GMESH.setName(), and MEDMEM.writeMeshToFile().

void MEDMEMTest::testTypeMeshDriver

(

)

Check methods (not in spec), defined in MEDMEM_Tags.hxx:

Check methods (15), defined in MEDMEM_TypeMeshDriver.hxx: class TYPE_MESH_DRIVER : public GENDRIVER { (-) TYPE_MESH_DRIVER(); (-) TYPE_MESH_DRIVER(const string & fileName, MESH * ptrMesh, med_mode_acces accessMode); (-) TYPE_MESH_DRIVER(const TYPE_MESH_DRIVER & driver); (-) virtual ~TYPE_MESH_DRIVER(); (-) void open() throw (MEDEXCEPTION); (-) void close() throw (MEDEXCEPTION); (-) virtual void write(void) const = 0; (-) virtual void read (void) = 0; (-) void setMeshName(const string & meshName); (-) string getMeshName() const; } class TYPE_MESH_RDONLY_DRIVER : public virtual TYPE_MESH_DRIVER { (-) TYPE_MESH_RDONLY_DRIVER(); (-) TYPE_MESH_RDONLY_DRIVER(const string & fileName, MESH * ptrMesh); (-) TYPE_MESH_RDONLY_DRIVER(const TYPE_MESH_RDONLY_DRIVER & driver); (-) virtual ~TYPE_MESH_RDONLY_DRIVER(); (-) void write(void) const throw (MEDEXCEPTION); (-) void read (void) throw (MEDEXCEPTION); } class TYPE_MESH_WRONLY_DRIVER : public virtual TYPE_MESH_DRIVER { (-) TYPE_MESH_WRONLY_DRIVER(); (-) TYPE_MESH_WRONLY_DRIVER(const string & fileName, MESH * ptrMesh); (-) TYPE_MESH_WRONLY_DRIVER(const TYPE_MESH_WRONLY_DRIVER & driver); (-) virtual ~TYPE_MESH_WRONLY_DRIVER(); (-) void write(void) const throw (MEDEXCEPTION); (-) void read (void) throw (MEDEXCEPTION); } class TYPE_MESH_RDWR_DRIVER : public TYPE_MESH_RDONLY_DRIVER, public TYPE_MESH_WRONLY_DRIVER { (-) TYPE_MESH_RDWR_DRIVER(); (-) TYPE_MESH_RDWR_DRIVER(const string & fileName, MESH * ptrMesh); (-) TYPE_MESH_RDWR_DRIVER(const TYPE_MESH_RDWR_DRIVER & driver); (-) ~TYPE_MESH_RDWR_DRIVER(); (-) void write(void) const throw (MEDEXCEPTION); (-) void read (void) throw (MEDEXCEPTION); }

void MEDMEMTest::testUnit

(

)

Check methods (18), defined in MEDMEM_Unit.hxx: class UNIT { (+) UNIT(); (+) UNIT(string Name, string Description); (+) ~UNIT(); (+) UNIT & operator=(const UNIT &unit); (+) inline void setName(string Name); (+) inline void setDescription(string Description); (+) inline void setMasse(int Masse); (+) inline void setLength(int Length); (+) inline void setTime(int Time); (+) inline void setTemperature(int Temperature); (+) inline void setMatterQuantity(int MatterQuantity); (+) void setCurrentStrength(int CurrentStrength); (+) inline void setLightIntensity(int LightIntensity);

(+) inline string getName() const; (+) inline string getDescription() const; (+) inline int getMasse() const; (+) inline int getLength() const; (+) inline int getTime() const; (+) inline int getTemperature() const; (+) inline int getMatterQuantity() const; (+) inline int getCurrentStrength() const; (+) inline int getLightIntensity() const; }

Used code of MEDMEM/tests/testUUnit.cxx

References MEDMEM.UNIT.getCurrentStrength(), MEDMEM.UNIT.getDescription(), MEDMEM.UNIT.getLength(), MEDMEM.UNIT.getLightIntensity(), MEDMEM.UNIT.getMasse(), MEDMEM.UNIT.getMatterQuantity(), MEDMEM.UNIT.getName(), MEDMEM.UNIT.getTemperature(), MEDMEM.UNIT.getTime(), MEDMEM.UNIT.setCurrentStrength(), MEDMEM.UNIT.setDescription(), MEDMEM.UNIT.setLength(), MEDMEM.UNIT.setLightIntensity(), MEDMEM.UNIT.setMasse(), MEDMEM.UNIT.setMatterQuantity(), MEDMEM.UNIT.setName(), MEDMEM.UNIT.setTemperature(), and MEDMEM.UNIT.setTime().

void MEDMEMTest::testVtkFieldDriver

(

)

Check methods (14), defined in MEDMEM_VtkFieldDriver.hxx: template <class t>=""> class VTK_FIELD_DRIVER : public GENDRIVER { //MUST BE PRIVATE, because it is impossible to set _ptrField after this constructor. //AND cannot compile, so maybe it is specially implemented to prevent usage of it. (!) template <class interlacing_tag>=""> VTK_FIELD_DRIVER(); (+) template <class interlacing_tag>=""> VTK_FIELD_DRIVER (const string & fileName, FIELD<T, INTERLACING_TAG> * ptrField) (+) VTK_FIELD_DRIVER(const VTK_FIELD_DRIVER & fieldDriver) (+) ~VTK_FIELD_DRIVER() (+) void openConst() const throw (MEDEXCEPTION) (+) void openConstAppend() const throw (MEDEXCEPTION) (+) void open() throw (MEDEXCEPTION) (+) void openAppend() throw (MEDEXCEPTION) (+) void closeConst() const throw (MEDEXCEPTION) (+) void close() (+) void setFieldName(const string & fieldName); (+) string getFieldName() const; (+) void read (void) throw (MEDEXCEPTION); (+) void write(void) const throw (MEDEXCEPTION); (+) void writeAppend(void) const throw (MEDEXCEPTION); }

References MEDMEM.MED_FIELD_DRIVER< T >.close(), MEDMEM.VTK_FIELD_DRIVER< T >.close(), test_MEDSPLITTER.filename_rd, MEDMEM.VTK_FIELD_DRIVER< T >.getFieldName(), INTERP_TEST.getResourceFile(), MEDMEM.FIELD_.getSupport(), makeTmpFile(), MEDMEM.MED_DRIVER, MED_test2.mesh, MEDMEM.MED_FIELD_DRIVER< T >.open(), MEDMEM.VTK_FIELD_DRIVER< T >.open(), MEDMEM.VTK_FIELD_DRIVER< T >.openAppend(), MEDMEM.VTK_FIELD_DRIVER< T >.openConst(), MEDMEM.VTK_FIELD_DRIVER< T >.openConstAppend(), MEDMEM.MED_FIELD_RDONLY_DRIVER< T >.read(), MEDMEM.VTK_FIELD_DRIVER< T >.read(), MEDMEMTest_TmpFilesRemover.Register(), MEDMEM.RCBASE.removeReference(), MEDMEM.MED_FIELD_DRIVER< T >.setFieldName(), MEDMEM.VTK_FIELD_DRIVER< T >.setFieldName(), MEDMEM.SUPPORT.setMesh(), MEDMEM.DRIVERFACTORY.setVtkBinaryFormatForWriting(), MEDMEM.MEDEXCEPTION.what(), MEDMEM.VTK_FIELD_DRIVER< T >.write(), and MEDMEM.VTK_FIELD_DRIVER< T >.writeAppend().

void MEDMEMTest::testVtkMedDriver

(

)

Check methods (5), defined in MEDMEM_VtkMedDriver.hxx: class VTK_MED_DRIVER : public GENDRIVER { (+) VTK_MED_DRIVER(const string & fileName, MED * const ptrMed); (+) VTK_MED_DRIVER(const VTK_MED_DRIVER & driver); (+) ~VTK_MED_DRIVER(); (+) void write (void) const; (-) virtual void read (void) {}; (+) GENDRIVER * copy (void) const; }

References MEDMEM.VTK_MED_DRIVER.copy(), Med_Gen_test.dt, ensightMedEnsight_test.fields, test_MEDSPLITTER.filename_rd, MEDMEM.MEDFILEBROWSER.getFieldIteration(), MEDMEM.MEDFILEBROWSER.getFieldNames(), MEDMEM.MEDFILEBROWSER.getFieldType(), MEDMEM.MEDFILEBROWSER.getFileName(), MEDMEM.MEDFILEBROWSER.getMeshNames(), INTERP_TEST.getResourceFile(), Med_Gen_test.it, makeTmpFile(), MEDMEM.MED_DRIVER, MED_EN.MED_REEL64, MED_test2.mesh, MEDMEM.MEDFILEBROWSER.readFileStruct(), MEDMEMTest_TmpFilesRemover.Register(), and MEDMEM.DRIVERFACTORY.setVtkBinaryFormatForWriting().

void MEDMEMTest::testVtkMeshDriver

(

)

Check methods (11), defined in MEDMEM_VtkMeshDriver.hxx: class VTK_MESH_DRIVER : public GENDRIVER { (+) VTK_MESH_DRIVER(); (+) VTK_MESH_DRIVER(const string & fileName, MESH * ptrMesh); (+) VTK_MESH_DRIVER(const VTK_MESH_DRIVER & driver); (+) ~VTK_MESH_DRIVER(); (+) void open(); (+) void close(); (+) void openConst() const throw (MEDEXCEPTION); (+) void closeConst() const throw (MEDEXCEPTION); (+) void write(void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); (+) void setMeshName(const string & meshName); (+) string getMeshName() const; }

References MEDMEM.VTK_MESH_DRIVER.close(), MEDMEM.VTK_MESH_DRIVER.closeConst(), test_NonCoincidentDEC.filename, test_MEDSPLITTER.filename_rd, MEDMEM.VTK_MESH_DRIVER.getMeshName(), INTERP_TEST.getResourceFile(), makeTmpFile(), test_MEDSPLITTER.meshname, MEDMEM.MED_MESH_DRIVER.open(), MEDMEM.VTK_MESH_DRIVER.open(), MEDMEM.VTK_MESH_DRIVER.openConst(), MEDMEM.MED_MESH_RDONLY_DRIVER.read(), MEDMEM.VTK_MESH_DRIVER.read(), MEDMEMTest_TmpFilesRemover.Register(), MEDMEM.RCBASE.removeReference(), MEDMEM.VTK_MESH_DRIVER.setMeshName(), MEDMEM.MED_MESH_DRIVER.setMeshName(), and MEDMEM.VTK_MESH_DRIVER.write().

void MEDMEMTest::testExtractor

(

)

References MEDMEM.GMESH.addDriver(), MEDMEM.FIELD< T, INTERLACING_TAG >.addDriver(), MEDMEM.FIELD< T, INTERLACING_TAG >.allocValue(), coords, MEDMEM.Extractor.extractLine(), MEDMEM.Extractor.extractPlane(), test_NonCoincidentDEC.filename, MEDMEM.SUPPORT.getMesh(), MEDMEM.SUPPORT.getMeshName(), MEDMEM.GMESH.getName(), MEDMEM.FIELD_.getName(), MEDMEM.SUPPORT.getNumberOfElements(), MEDMEM.FIELD< T, INTERLACING_TAG >.getNumberOfElements(), MEDMEM.GMESH.getNumberOfNodes(), INTERP_TEST.getResourceFile(), MEDMEM.FIELD_.getSupport(), MEDMEM.GMESH.getSupportOnAll(), MEDMEM.FIELD< T, INTERLACING_TAG >.getValue(), makeTmpFile(), MED_EN.MED_ALL_ELEMENTS, MED_EN.MED_CELL, MEDMEM.MED_DRIVER, MED_EN.MED_FULL_INTERLACE, MED_EN.MED_HEXA8, MED_EN.MED_QUAD4, MED_EN.MED_TRIA3, MED_test2.mesh, test_MEDSPLITTER.meshname, medMeshing_test.myMeshing, med_test1.normal, MEDMEMTest_TmpFilesRemover.Register(), MEDMEM.RCBASE.removeReference(), MEDMEM.FIELD_.setComponentsDescriptions(), MEDMEM.FIELD_.setComponentsNames(), MEDMEM.MESHING.setConnectivity(), MEDMEM.MESHING.setCoordinates(), MEDMEM.MESHING.setCoordinatesNames(), MEDMEM.MESHING.setCoordinatesUnits(), MEDMEM.FIELD_.setDescription(), MEDMEM.FIELD_.setMEDComponentsUnits(), MEDMEM.SUPPORT.setMesh(), MEDMEM.FIELD_.setName(), MEDMEM.GMESH.setName(), MEDMEM.MESHING.setNumberOfElements(), MEDMEM.MESHING.setNumberOfTypes(), MEDMEM.FIELD_.setSupport(), MEDMEM.MESHING.setTypes(), MEDMEM.FIELD< T, INTERLACING_TAG >.setValue(), test_extractLine(), batchmode_medcorba_test.value, MEDMEM.FIELD< T, INTERLACING_TAG >.write(), and MEDMEM.GMESH.write().

void MEDMEMTest::testMeshFuse

(

)

References MEDMEM.MeshFuse.concatenate(), MEDMEM.GRID.convertInMESH(), MEDMEM.GMESH.getFamilies(), MEDMEM.GMESH.getGroup(), MEDMEM.GRID.getNodeNumber(), MEDMEM.SUPPORT.getNumberOfElements(), MEDMEM.MESH.getNumberOfElements(), MEDMEM.GRID.getNumberOfElements(), MEDMEM.GMESH.getNumberOfFamilies(), MEDMEM.MESH.getNumberOfNodes(), MEDMEM.GRID.getNumberOfNodes(), makeGrid(), MED_EN.MED_ALL_ELEMENTS, MED_EN.MED_CELL, MED_EN.MED_EDGE, MED_EN.MED_FACE, MED_EN.MED_QUAD4, TestMedCorba2.n, and MEDMEM.RCBASE.removeReference().

void MEDMEMTest::testDesactivateFacesComputation

(

)

References MEDMEM.GMESH.addDriver(), addMedFacesGroup2(), bottom, bottomIndex, bottomNbOfElts, bottomTypes, connNodalCellClassical, connNodalFaceClassical, coords, MEDMEM.MED_MESH_RDONLY_DRIVER.desactivateFacesComputation(), medMeshing_test.driver, MEDMEM.GMESH.getName(), MEDMEM.MESH.getNumberOfTypes(), getTmpDirectory(), MED_EN.MED_CELL, MEDMEM.MED_DRIVER, MED_EN.MED_EDGE, MED_EN.MED_FACE, MED_EN.MED_HEXA8, MED_EN.MED_NO_INTERLACE, MED_EN.MED_QUAD4, MED_test2.mesh, batchmode_medcorba_test.nbOfTypes, MEDMEM.GMESH.read(), MEDMEMTest_TmpFilesRemover.Register(), MEDMEM.RCBASE.removeReference(), MEDMEM.MESHING.setConnectivity(), MEDMEM.MESHING.setCoordinates(), MEDMEM.MESHING.setCoordinatesNames(), MEDMEM.MESHING.setCoordinatesUnits(), MEDMEM.GMESH.setName(), MEDMEM.MESHING.setNumberOfElements(), MEDMEM.MESHING.setNumberOfTypes(), MEDMEM.MESHING.setTypes(), side, sideIndex, sideNbOfElts, sideTypes, test_NonCoincidentDEC.tmp_dir, top, topIndex, topNbOfElts, topTypes, and MEDMEM.GMESH.write().

void MEDMEMTest::testGetVolumeAbs

(

)

References connNodalCellClassical, coords, MEDMEM.GMESH.getSupportOnAll(), MEDMEM.FIELD< T, INTERLACING_TAG >.getValue(), MEDMEM.MESH.getVolume(), MED_EN.MED_CELL, MED_EN.MED_FULL_INTERLACE, MED_EN.MED_PENTA6, MED_EN.MED_POLYHEDRA, polyHedraConn, polyHedraInd, MEDMEM.RCBASE.removeReference(), MEDMEM.MESHING.setConnectivity(), MEDMEM.MESHING.setCoordinates(), MEDMEM.MESHING.setCoordinatesNames(), MEDMEM.MESHING.setCoordinatesUnits(), MEDMEM.GMESH.setName(), MEDMEM.MESHING.setNumberOfElements(), MEDMEM.MESHING.setNumberOfTypes(), and MEDMEM.MESHING.setTypes().

void MEDMEMTest::test_RemapperP0P0

(

)

References MEDMEM.MESH.getArea(), MEDMEM.FIELD< T, INTERLACING_TAG >.getNumberOfElements(), INTERP_TEST.getResourceFile(), MEDMEM.GMESH.getSupportOnAll(), MEDMEM.FIELD< T, INTERLACING_TAG >.getValue(), MED_EN.MED_ALL_ELEMENTS, MED_EN.MED_CELL, MEDMEM.MED_DRIVER, MEDMEM.FIELD< T, INTERLACING_TAG >.normL2(), MEDMEM_REMAPPER.prepare(), MEDMEM.RCBASE.removeReference(), MEDMEM_REMAPPER.reverseTransfer(), MEDMEM_REMAPPER.reverseTransferField(), MEDMEM_REMAPPER.setOptionDouble(), MEDMEM_REMAPPER.setOptionInt(), MEDMEM_REMAPPER.setOptionString(), test_NonCoincidentDEC.source_mesh, test_NonCoincidentDEC.target_mesh, MEDMEM_REMAPPER.transfer(), and MEDMEM_REMAPPER.transferField().

void MEDMEMTest::test_RemapperP1P1

(

)

References MEDMEM.FIELD< T, INTERLACING_TAG >.getNumberOfElements(), INTERP_TEST.getResourceFile(), MEDMEM.GMESH.getSupportOnAll(), MEDMEM.FIELD< T, INTERLACING_TAG >.getValue(), MED_EN.MED_ALL_ELEMENTS, MEDMEM.MED_DRIVER, MED_EN.MED_NODE, MEDMEM_REMAPPER.prepare(), MEDMEM.RCBASE.removeReference(), MEDMEM_REMAPPER.reverseTransfer(), test_NonCoincidentDEC.source_mesh, test_NonCoincidentDEC.target_mesh, and MEDMEM_REMAPPER.transfer().

void MEDMEMTest::test_RemapperP1P0

(

)

References MEDMEM.FIELD< T, INTERLACING_TAG >.getNumberOfElements(), INTERP_TEST.getResourceFile(), MEDMEM.GMESH.getSupportOnAll(), MEDMEM.FIELD< T, INTERLACING_TAG >.getValue(), MED_EN.MED_ALL_ELEMENTS, MED_EN.MED_CELL, MEDMEM.MED_DRIVER, MED_EN.MED_NODE, MEDMEM_REMAPPER.prepare(), MEDMEM.RCBASE.removeReference(), MEDMEM_REMAPPER.reverseTransfer(), test_NonCoincidentDEC.source_mesh, test_NonCoincidentDEC.target_mesh, and MEDMEM_REMAPPER.transfer().

void MEDMEMTest::test_RemapperP0P1

(

)

References MEDMEM.FIELD< T, INTERLACING_TAG >.getNumberOfElements(), INTERP_TEST.getResourceFile(), MEDMEM.GMESH.getSupportOnAll(), MEDMEM.FIELD< T, INTERLACING_TAG >.getValue(), MED_EN.MED_ALL_ELEMENTS, MED_EN.MED_CELL, MEDMEM.MED_DRIVER, MED_EN.MED_NODE, MEDMEM_REMAPPER.prepare(), MEDMEM.RCBASE.removeReference(), MEDMEM_REMAPPER.reverseTransfer(), test_NonCoincidentDEC.source_mesh, test_NonCoincidentDEC.target_mesh, and MEDMEM_REMAPPER.transfer().

void MEDMEMTest::test_remapper4

(

)

References testDriverAscii.f1, and MED_EN.MED_NODE.

void MEDMEMTest::test_remapper5

(

)

References INTERP_KERNEL.Interpolation3D.interpolateMeshes(), INTERP_KERNEL.PointLocator, INTERP_KERNEL.InterpolationOptions.setIntersectionType(), INTERP_KERNEL.InterpolationOptions.setPrecision(), and sumAll().

void MEDMEMTest::test_remapper6

(

)

References INTERP_KERNEL.Interpolation3D.interpolateMeshes(), INTERP_KERNEL.PointLocator, INTERP_KERNEL.InterpolationOptions.setIntersectionType(), INTERP_KERNEL.InterpolationOptions.setPrecision(), and sumAll().

void MEDMEMTest::test_remapper7

(

)

References INTERP_KERNEL.Interpolation3D.interpolateMeshes(), INTERP_KERNEL.PointLocator, INTERP_KERNEL.InterpolationOptions.setIntersectionType(), INTERP_KERNEL.InterpolationOptions.setPrecision(), and sumAll().

void MEDMEMTest::test_remapper3DTo1D

(

)

References INTERP_KERNEL.Interpolation3D.interpolateMeshes(), INTERP_KERNEL.PointLocator, INTERP_KERNEL.InterpolationOptions.setIntersectionType(), INTERP_KERNEL.InterpolationOptions.setPrecision(), and sumAll().

void MEDMEMTest::testGetGaussPointsCoordinates

(

)

0021052: [CEA 431] Computation of Gauss point location

Check method GetGaussPointsCoordinates() defined in MEDMEM_Field.hxx:

References medClient_test.coordinates, MEDMEM.FIELD< T, INTERLACING_TAG >.getGaussPointsCoordinates(), MEDMEM.GMESH.getSupportOnAll(), MEDMEM.FIELD< T, INTERLACING_TAG >.getValueIJK(), MED_EN.MED_CELL, MED_EN.MED_FULL_INTERLACE, MED_EN.MED_HEXA20, MED_EN.MED_HEXA8, MED_EN.MED_PENTA15, MED_EN.MED_PENTA6, MED_EN.MED_PYRA13, MED_EN.MED_PYRA5, MED_EN.MED_QUAD4, MED_EN.MED_QUAD8, MED_EN.MED_SEG2, MED_EN.MED_SEG3, MED_EN.MED_TETRA10, MED_EN.MED_TETRA4, MED_EN.MED_TRIA3, MED_EN.MED_TRIA6, MED_test2.mesh, medMeshing_test.numberOfCells, medClient_test.numberOfNodes, MEDMEM.RCBASE.removeReference(), MEDMEM.MESHING.setConnectivity(), MEDMEM.MESHING.setCoordinates(), MEDMEM.MESHING.setCoordinatesNames(), MEDMEM.MESHING.setCoordinatesUnits(), MEDMEM.FIELD< T, INTERLACING_TAG >.setGaussLocalization(), MEDMEM.MESHING.setNumberOfElements(), MEDMEM.MESHING.setNumberOfTypes(), MEDMEM.MESHING.setTypes(), and medClient_test.spaceDimension.

void MEDMEMTest::absField

(

MEDMEM::FIELD< double > &

field

)

References MEDMEM.FIELD_.getNumberOfValues(), and MEDMEM.FIELD< T, INTERLACING_TAG >.getValue().

double MEDMEMTest::sumAll

(

const std::vector< std::map< int, double > > &

matrix

)

[private]

References testMEDMEM.ret.