# - Config file for the @PROJECT_NAME@ package
# It defines the following variables.
-# Specific to the pacakge @PROJECT_NAME@ itself:
+# Specific to the package @PROJECT_NAME@ itself:
# @PROJECT_NAME_UC@_ROOT_DIR_EXP - the root path of the installation providing this CMake file
#
SALOME MED module. Keep in mind that the MEDMEM library is designed to
be a self-consistent library with very few third party softwares (only
med-file, glibc and mpi typically). In particular, it is strictly
-independant from the SALOME framework even if it distributed with
+independent from the SALOME framework even if it distributed with
SALOME for convenience reasons.
Components of the MEDMEM library
We make the hypothesis here that the MEDMEM library is installed using
the SALOME procedure and then is located in the MED module
installation directory. In addition to the MED library, the third
-party softwares required for executing the examples are: python, hdf5
+party software required for executing the examples are: python, hdf5
and med-fichier. Then, you should prepare your shell environment
with a set of instructions that looks like::
We suggest to work with a simple list concept to store the metadata
for each mesh entry and each field entry. Note that a mesh entry is
characterized by the mesh name only, while a field entry is
-charaterized by the following attributes:
+characterized by the following attributes:
* :tt:`fieldName`: the name of the field
* :tt:`meshName`: the name of the mesh that supports the field
* :tt:`iteration`: a couple of integers :tt:`(iter,order)` that
characterizes the step in a serie (timeseries or spectrum).
-By default, we suggest to work with a simple map concept (dictionnary in a
+By default, we suggest to work with a simple map concept (dictionary in a
python context, map in a C++ context) to register the meshes and
fields loaded from the med file for each metadata entry.
case, for performance reasons. For example, the following code
illustrates how to dispatch the metadata in a tree data structure
where leaves are the physical data (field objects). We first have to
-define a tree structure (basic definition in htis simple case, but it
+define a tree structure (basic definition in this simple case, but it
works fine):
.. include:: ../../../tut/medloader/manage.py
:start-after: # _T3A
:end-before: # _T3B
-Exemple 05: Compare fields load from different files
+Example 05: Compare fields load from different files
----------------------------------------------------
:objectives: Illustrates the usage of the function
changeUnderlyingMesh
-Exemple 06: Create a field from scratch on a spatial domain
+Example 06: Create a field from scratch on a spatial domain
-----------------------------------------------------------
:objectives: Illustrates the applyFunc method of fields
-Exemple 07: Manipulate structured mesh
+Example 07: Manipulate structured mesh
--------------------------------------
:objectives: Illustrates the basic usage of the advanced interface of
:start-after: # _T3A
:end-before: # _T3B
-Exemple 08: Make a projection of a field
+Example 08: Make a projection of a field
----------------------------------------
:objectives: Make the projection of a field from a source mesh to a
.. image:: ../images/medop_projection_result.png
:align: center
-Exemple 09: Make a partition of a mesh using a field
+Example 09: Make a partition of a mesh using a field
----------------------------------------------------
:objective: This illustrates how to make a mesh partition using the
(dataArray) and to manipulate the advanced concepts of the MEDMEM
library.
-.. Exemple 01: Create a field from an image
+.. Example 01: Create a field from an image
.. ----------------------------------------
We make the hypothesis here that the MEDMEM library is installed using
the SALOME procedure and then is located in the MED module
installation directory. In addition to the MED library, the third
-party softwares required for executing the examples are: python, hdf5
+party software required for executing the examples are: python, hdf5
and med-fichier. Then, you should prepare your shell environment
with a set of instructions that looks like::
:start-after: # _T3A
:end-before: # _T3B
-Exemple 05: Compare fields load from different files
+Example 05: Compare fields load from different files
----------------------------------------------------
:objectives: Illustrates the usage of the function
changeUnderlyingMesh
-Exemple 06: Create a field from scratch on a spatial domain
+Example 06: Create a field from scratch on a spatial domain
-----------------------------------------------------------
:objectives: Illustrates the applyFunc method of fields
-Exemple 07: Manipulate structured mesh
+Example 07: Manipulate structured mesh
--------------------------------------
:objectives: Illustrates the basic usage of the advanced interface of
:start-after: # _T3A
:end-before: # _T3B
-Exemple 08: Make a projection of a field
+Example 08: Make a projection of a field
----------------------------------------
:objectives: Make the projection of a field from a source mesh to a
.. image:: images/medop_projection_result.png
:align: center
-Exemple 09: Make a partition of a mesh using a field
+Example 09: Make a partition of a mesh using a field
----------------------------------------------------
:objective: This illustrates how to make a mesh partition using the
(dataArray) and to manipulate the advanced concepts of the MEDMEM
library.
-.. Exemple 01: Create a field from an image
+.. Example 01: Create a field from an image
.. ----------------------------------------
==================================
The overall ergonomics of MED module for field manipulation is inspired by
-softwares such as octave or scilab. It combines a graphical interface (GUI) to
+software such as octave or scilab. It combines a graphical interface (GUI) to
select and prepare data, with a textual interface (the python console, TUI)
for actual work on data.
* mapper sur une image
-Improvments:
+Improvements:
* MEDLoader::Write should raise an exception if the filepath is not writable
* MEDDataManager: développer une classe chapeau sur MEDCoupling et
# Get a grayscale version
imgbw=ImageOps.grayscale(img)
- # Save the image (optionnal)
+ # Save the image (optional)
imgbw.save(fp="testsbw.pgm")
# Get the data
/*!
* This function loads the meta-data from the specified med file and
* returns the associated datasource handler. The data source handler
- * is a key to retrieve all informations concerning the data (meshes,
+ * is a key to retrieve all information concerning the data (meshes,
* fields).
*/
MEDCALC::DatasourceHandler * MEDDataManager_i::loadDatasource(const char *filepath) {
// one case where we can arrive here with no previous call to
// loadDataSource: for example the field handler list can be obtained
// from a call to addFieldsFromFile instead of loadDataSource (see
- // for exemple the getFieldRepresentation service of the
+ // for example the getFieldRepresentation service of the
// dataManager, that comes here and then calls getUMesh where we
// need a map initialized only in loadDataSource) <<<<
long meshid = fieldHandler->meshid;
throw KERNEL::createSalomeException(mes);
}
- setOrCreateRenderView(); // instanciate __viewXXX, needs to be after the exception above otherwise previous elements in the view will be hidden.
+ setOrCreateRenderView(); // instantiate __viewXXX, needs to be after the exception above otherwise previous elements in the view will be hidden.
// Contour needs point data:
applyCellToPointIfNeeded();
MEDPyLockWrapper lock;
- setOrCreateRenderView(); // instanciate __viewXXX
+ setOrCreateRenderView(); // instantiate __viewXXX
createSource();
// Populate internal array of available components:
MEDPyLockWrapper lock;
- setOrCreateRenderView(); // instanciate __viewXXX
+ setOrCreateRenderView(); // instantiate __viewXXX
createSource();
// Populate internal array of available components:
throw KERNEL::createSalomeException(mes);
}
- setOrCreateRenderView(); // instanciate __viewXXX
+ setOrCreateRenderView(); // instantiate __viewXXX
// Now create the initial slices list
oss << _sliceListVar << " = [];";
throw KERNEL::createSalomeException(msg);
}
- setOrCreateRenderView(); // instanciate __viewXXX, needs to be after the exception above otherwise previous elements in the view will be hidden.
+ setOrCreateRenderView(); // instantiate __viewXXX, needs to be after the exception above otherwise previous elements in the view will be hidden.
std::ostringstream oss;
oss << _objVar << " = pvs.Glyph(Input=" << _srcObjVar << ", GlyphType='Arrow');";
* Utility class wrapping the Python GIL acquisition. This makes use of the high level
* API (PyGILState_Ensure and PyGILState_Release), and is hence compatible with only
* one running Python interpreter (no call to Py_NewInterpreter()).
- * When the class is instanciated the lock is acquired. It is released at destruction time.
+ * When the class is instantiated the lock is acquired. It is released at destruction time.
* Copy construction (and hence assignation) is forbidden.
*/
class MEDPyLockWrapper
* This function adds the specified MED file as a datasource in the
* dataspace. Technically speaking, the engine loads the
* meta-information concerning med data from the file, gives this
- * informations to the GUI, and the GUI creates a tree view of these
+ * information to the GUI, and the GUI creates a tree view of these
* data in the study object browser.
*/
// This function emits a signal that will be caught by workspace to delegate command (datasource creation) to python console.
void presentationUpdateSignal(const PresentationEvent *);
protected:
- // Only child classes to be instanciated:
+ // Only child classes to be instantiated:
MEDWidgetHelper(const PresentationController* presController,
MEDCALC::MEDPresentationManager_ptr presManager, int presId, const std::string & presName,
WidgetPresentationParameters * paramWidget);
// We need a studyEditor updated on the active study
_studyEditor->updateActiveStudy();
- // Get the selected objects in the study (SObject). In cas of a
+ // Get the selected objects in the study (SObject). In case of a
// multiple selection, we consider only the first item. At least one
// item must be selected.
SALOME_StudyEditor::SObjectList* listOfSObject = _studyEditor->getSelectedObjects();
effectiveAlias = new QString(alias);
}
- // We can propose to the user to specify some additionnal
- // informations concerning what must be imported.
+ // We can propose to the user to specify some additional
+ // information concerning what must be imported.
//
// In this version, we just ask the alias the field will be
// manipulated with. The default alias is the field name. This alias
# The factory is not the main CORBA component of the SALOME module MED
# (i.e. the engine associated to the active study), but the CORBA
# entry point for MED fields operations (i.e. a CORBA component
-# reachable throught the LifeCycleCORBA). This entry point is used to
+# reachable through the LifeCycleCORBA). This entry point is used to
# get the other SALOME CORBA components required for MED field
# operations, in particular the dataManager and the calculator
// Constructor with parameters :
// - f, full file name with path
// - n, file name (file.med)
-// Read the med file to get meshes and fields informations
+// Read the med file to get meshes and fields information
// Fill meshes vector with meshes names
// Fill fields vector creating using field constructor with MED and fieldname parameters
MEDCalculatorBrowserLiteStruct::MEDCalculatorBrowserLiteStruct(const char *f) : _file(f), _any_selection(false)
public :
MEDCalculatorBrowserLiteStruct();
~MEDCalculatorBrowserLiteStruct();
- MEDCalculatorBrowserLiteStruct(const char *);// Constructor with a complet file name (with path) and simplified file name as parameters
+ MEDCalculatorBrowserLiteStruct(const char *);// Constructor with a complete file name (with path) and simplified file name as parameters
bool operator==(const std::string&);// Equal to string operator, compare simplified name to input
std::string str();// Return a std::string corresponding to x/o (selected or not) File filename \n meshes \n fields
void setSelected(bool);// Set selection to input bool
MEDCoupling::MEDCouplingUMesh *targetMesh=MEDCoupling::MEDCouplingUMesh::New();
targetMesh->setMeshDimension(0);
targetMesh->allocateCells(8);
- targetMesh->setName("Wonderfull 0D mesh");
+ targetMesh->setName("Wonderful 0D mesh");
targetMesh->setDescription("build0DMesh");
targetMesh->insertNextCell(INTERP_KERNEL::NORM_POINT1,1,targetConn);
targetMesh->insertNextCell(INTERP_KERNEL::NORM_POINT1,1,targetConn+1);
MEDCoupling::MEDCouplingUMesh *MEDCouplingCorbaServBasicsTest::buildM1DMesh()
{
- MEDCoupling::MEDCouplingUMesh *meshM1D=MEDCoupling::MEDCouplingUMesh::New("wonderfull -1 D mesh",-1);
+ MEDCoupling::MEDCouplingUMesh *meshM1D=MEDCoupling::MEDCouplingUMesh::New("wonderful -1 D mesh",-1);
meshM1D->setDescription("buildM1DMesh");
meshM1D->checkConsistencyLight();
return meshM1D;
targetMesh=MEDCouplingUMesh.New();
targetMesh.setMeshDimension(0);
targetMesh.allocateCells(8);
- targetMesh.setName("Wonderfull 0D mesh");
+ targetMesh.setName("Wonderful 0D mesh");
targetMesh.setDescription("build0DMesh");
targetConn=[]
targetMesh.insertNextCell(NORM_POINT1,1,[0]);
return targetMesh;
def buildM1DMesh(self):
- meshM1D=MEDCouplingUMesh.New("wonderfull -1 D mesh",-1);
+ meshM1D=MEDCouplingUMesh.New("wonderful -1 D mesh",-1);
meshM1D.setDescription("buildM1DMesh");
meshM1D.checkConsistencyLight();
return meshM1D;
// Connect buttons to actions, close statement is already connect in the .ui file
// Set QTreeWidgets parameters : header labels, selection mode
// Connect QTreeWidget itemClicked signal to meshes and fieldsStateChange
-// Put mouse tracking on, so this class received mouse positions informations when mouse is above treewidget
+// Put mouse tracking on, so this class received mouse positions information when mouse is above treewidget
// Add contextual menu to treewidget's items with the call to selectCompoPopup and selStepPopup
// Connect those actions to corresponding signals
MEDGUIFileContentDial::MEDGUIFileContentDial(MEDGUIDataBaseDockWidget* db, QWidget* parent):
// Then, after checking if the name already exist
// - if yes, try to add "_#" where # begin at 2
// - if not, continue
-// Create a new MEDGUILiteStruct with the complet file name and the simplified file name as parameters
+// Create a new MEDGUILiteStruct with the complete file name and the simplified file name as parameters
// Add items to the two QTreeWidget get information from the new MEDGUILiteStruct
void MEDGUIFileContentDial::openFile()
{
// This class is implemented to provide a dialog box for selecting fields components and/or setting components names
// The basic graphic part was made with QtDesigner4 and is in MedGUI_FileContentDial.ui file
-// It use a MedGUI_LiteStruct object to get components informations
+// It use a MedGUI_LiteStruct object to get components information
// If one field is selected (call made from a step or a field), the box will only display components from this field
// If all fields are selected (call made on MED file), the box will display all the components for each field
