MESSAGE(FATAL_ERROR "We absolutely need the MEDCoupling tool, please define MEDCOUPLING_ROOT_DIR !")
ENDIF(EXISTS ${MEDCOUPLING_ROOT_DIR})
-IF(MEDCOUPLING_USE_64BIT_IDS)
- ADD_DEFINITIONS("-DMEDCOUPLING_USE_64BIT_IDS")
-ENDIF(MEDCOUPLING_USE_64BIT_IDS)
-
#
# Set list of prerequisites
# =========================
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%
- Documentation du module FIELDS
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+Documentation du module FIELDS
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Le module SALOME FIELDS (pour Modèle d'Echange de Données) fournit la
bibliothèque MEDCoupling (bibliothèque C++ dédiée à la manipulation de
.. include:: medcalc-definitions.rst
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Module FIELDS: Guide de développement du composant MEDCalc
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Le composant logiciel MEDCalc est un élément du module FIELDS. Il fournit
une interface utilisateur pour la manipulation de maillages et de
.. include:: medcalc-definitions.rst
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Module FIELDS: Spécifications fonctionnelles et techniques
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Ce texte présente les spécifications informatiques pour le
développement d'un module de manipulation de champs qui répond à
* Effectuer les contrôles visuel et les diagnostics en ligne de
commandes python (cf. :ref:`Spécification des fonctions de
- visualisation<specification_visualisation>`)::
+ visualisation<specification_visualisation-fr>`)::
>>> view(r)
l'utilisateur peut visualiser les ligne de commandes nécessaires à
taper pour exécuter sa requête.
-.. _specification_visualisation:
+.. _specification_visualisation-fr:
Spécification des fonctions de visualisation
============================================
.. include:: medcalc-definitions.rst
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Module FIELDS: Guide d'utilisation de l'interface graphique
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Ce document est un guide rapide pour l'utilisation de l'interface
graphique du module FIELDS. Il montre comment utiliser le module sur la
:backlinks: none
Présentation générale du module FIELDS
-===================================
+======================================
L'ergonomie générale d'utilisation du module de manipulation de champs
est inspirée des logiciels comme octave ou scilab. Elle associe une
Tour rapide des fonctions du module FIELDS
-=======================================
+==========================================
Cette section présente des exemples d'utilisation du module XMED sous
la forme de "storyboard", et illustre au passage les fonctions mises à
.. _xmed.userguide.tui-fr:
Utilisation de l'interface textuelle du module FIELDS (TUI)
-========================================================
+===========================================================
Toutes les opérations menées au moyen de l'interface graphique peuvent
être réalisées (avec plus ou moins de facilité) avec l'interface
-%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Documentation of FIELDS module
-%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
The SALOME FIELDS module provides MEDCoupling library (a C++ library dedicated of
mesh and field manipulation consistent with MED model), as well as a Graphical
.. include:: medcalc-definitions.rst
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Module FIELDS: Guide de développement du composant MEDCalc
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Le composant logiciel MEDCalc est un élément du module FIELDS. Il fournit
une interface utilisateur pour la manipulation de maillages et de
.. include:: medcalc-definitions.rst
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Module FIELDS: Spécifications fonctionnelles et techniques
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Ce texte présente les spécifications informatiques pour le
développement d'un module de manipulation de champs qui répond à
.. include:: medcalc-definitions.rst
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
FIELDS module: User guide for graphical interface
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
This document is a quick guide for Graphical User Interface of FIELDS module. It
shows how to use this module on the basis of a few reference examples, built
look-and-feel may thus be slightly different.
General presentation of FIELDS module
-==================================
+=====================================
The overall ergonomics of FIELDS module for field manipulation is inspired by
software such as octave or scilab. It combines a graphical interface (GUI) to
Quick tour on functions available in FIELDS module
-===============================================
+==================================================
This section presents some use examples of FIELDS module like a "storyboard",
illustrating the functions proposed by the module.
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+#ifndef SRC_MEDCALC_CMP_MEDCALCCONSTANTS_HXX_
+
// This constant strings are used to specify an attribute name for
// AttributeParameter attributes associated to a SObject
#define IS_IN_WORKSPACE "isInWorkspace"
#define IS_PRESENTATION "isPresentation"
#define PRESENTATION_TYPE "presentationType"
-static const int NB_TYPE_OF_FIELDS = 4;
-static const char* mapTypeOfFieldLabel[NB_TYPE_OF_FIELDS] =
+const int NB_TYPE_OF_FIELDS = 4;
+const char* const mapTypeOfFieldLabel[NB_TYPE_OF_FIELDS] =
{"ON_CELLS", "ON_NODES", "ON_GAUSS_PT", "ON_GAUSS_NE" };
+#endif
// set exception handler to catch unexpected CORBA exceptions
Unexpect aCatch(SALOME_SalomeException);
- MED_ORB::PresentationsList* presList = new MED_ORB::PresentationsList;
+ //MED_ORB::PresentationsList* presList = new MED_ORB::PresentationsList; // todo: unused
SALOMEDS::Study_var aStudy = KERNEL::getStudyServant();
SALOMEDS::StudyBuilder_var studyBuilder = aStudy->NewBuilder();
Engines::TMPFile*
-MED::DumpPython(CORBA::Boolean isPublished,
- CORBA::Boolean isMultiFile,
+MED::DumpPython(CORBA::Boolean /*isPublished*/,
+ CORBA::Boolean /*isMultiFile*/,
CORBA::Boolean& isValidScript)
{
SALOMEDS::SObject_var aSO = KERNEL::getStudyServant()->FindComponent("FIELDS");
try {
field_result = field->clone(true);
if ( (nbResComponents == MEDCALC::NBCOMP_DEFAULT ) ||
- (nbResComponents < 1) || (nbResComponents > field_result->getNumberOfComponents()) ) {
+ (nbResComponents < 1) || (nbResComponents > (int)field_result->getNumberOfComponents()) ) {
field_result->applyFunc(function);
}
else {
MEDCALC::FieldIdList fieldIdList;
fieldIdList.length(listId.size());
- for (int i=0; i<listId.size(); i++) {
+ for (int i=0; i<(int)listId.size(); i++) {
fieldIdList[i] = CORBA::Long(listId[i]);
}
const char * meshSourceUri = (_datasourceHandlerMap[sourceid])->uri;
std::string fileName(source_to_file(meshSourceUri));
const char * fieldName = fieldHandler->fieldname;
- const char * meshName = _meshHandlerMap[meshHandlerId]->name;
+ //const char * meshName = _meshHandlerMap[meshHandlerId]->name; // todo: unused
timestamp = GetTimeAttachedOnFieldIteration(fileName.c_str(), fieldName, fieldHandler->iteration, fieldHandler->order);
LOG("timestamp in med file is " << timestamp);
}
// MEDCouplingField). As a consequence, the values of these
// variables are updated by this function call. This is the means to
// retrieve the iteration and order of the field.
- double timestamp = fieldDouble->getTime(iteration, order);
+ /*double timestamp = */fieldDouble->getTime(iteration, order); // todo: unused
// For the fields that are created in memory (by operations for
// example), the convention for the source attribute is to specify
LOG("Size = "<<_fieldHandlerMap.size());
FieldHandlerMapIterator fhmIt;
for ( fhmIt = _fieldHandlerMap.begin(); fhmIt != _fieldHandlerMap.end(); fhmIt++) {
- long id = fhmIt->first;
- LOG("------------------------------------- id = "<<ToString(id));
+ LOG("------------------------------------- id = "<<ToString(fhmIt->first));
LOG("- id \t= "<<fhmIt->second->id);
LOG("- fieldname \t= "<<fhmIt->second->fieldname);
LOG("- meshname \t= "<<fhmIt->second->meshname);
LOG("Size = "<<_fieldDoubleMap.size());
FieldDoubleMapIterator fdmIt;
for ( fdmIt = _fieldDoubleMap.begin(); fdmIt != _fieldDoubleMap.end(); fdmIt++) {
- long id = (*fdmIt).first;
- MEDCouplingFieldDouble * fieldDouble = (*fdmIt).second;
- LOG("------------------------------------- id = "<<ToString(id));
- LOG("- fieldname \t= "<<fieldDouble->getName());
- LOG("- meshname \t= "<<fieldDouble->getMesh()->getName());
+ LOG("------------------------------------- id = "<<ToString(fdmIt->first));
+ LOG("- fieldname \t= "<<fdmIt->second->getName());
+ LOG("- meshname \t= "<<fdmIt->second->getMesh()->getName());
}
}
const MEDCALC::ViewModeType viewMode,
const MEDCALC::ColorMapType colorMap,
const MEDCALC::ScalarBarRangeType sbRange)
- : _handlerId(handlerId), _propertiesStr(),
+ : _meshName(""), _fileName(""), _fieldName(""),
_mcFieldType(MEDCoupling::ON_CELLS),
- _pvFieldType(""), _meshName(""), _fieldName(""), _fileName(""),
+ _pvFieldType(""),
+ _handlerId(handlerId),
_selectedComponentIndex(-1),
_viewMode(viewMode),
_colorMap(colorMap),
MEDCALC::MEDDataManager_ptr dataManager(MEDFactoryClient::getDataManager());
MEDCALC::FieldHandler* fieldHandler = dataManager->getFieldHandler(_handlerId);
MEDCALC::MeshHandler* meshHandler = dataManager->getMeshHandler(fieldHandler->meshid);
- MEDCALC::DatasourceHandler* dataSHandler = dataManager->getDatasourceHandlerFromID(meshHandler->sourceid);
+ //MEDCALC::DatasourceHandler* dataSHandler = dataManager->getDatasourceHandlerFromID(meshHandler->sourceid); // todo: unused
// get the file name of the field (or its memory information)
extractFileName(std::string(fieldHandler->source));
STDLOG("MEDPresentation::extractFileName('" << name << "')");
_fileName = name;
if (_fileName.substr(0, 7) != std::string("file://")) {
- const char* msg = "MEDPresentation(): Data source is in memory! Saving it in tmp file.";
- STDLOG(msg);
+ STDLOG("MEDPresentation(): Data source is in memory! Saving it in tmp file.");
// export a med file with this field
// we could instead use CORBA to transfer the field to PARAVIS like in MEDCalculatorDBFieldReal::display()
_fileName = std::tmpnam(NULL);
} else if (_viewMode == MEDCALC::VIEW_MODE_NEW_LAYOUT) {
oss2 << "nbLayouts = len(pvs.GetLayouts());";
pushAndExecPyLine(oss2.str()); oss2.str("");
- oss2 << "__layout1 = pvs.CreateLayout('Layout #\%i'%(nbLayouts+1));";
+ oss2 << "__layout1 = pvs.CreateLayout('Layout #%i'%(nbLayouts+1));";
pushAndExecPyLine(oss2.str()); oss2.str("");
oss2 << view << " = pvs.CreateView('RenderView');";
pushAndExecPyLine(oss2.str()); oss2.str("");
MEDCALC::MeshViewParameters
MEDPresentationManager_i::getMeshViewParameters(MEDPresentation::TypeID presentationID)
{
- MEDCALC::MeshViewParameters p;
- _getParameters<MEDPresentationMeshView>(presentationID, p);
- return p;
+ MEDCALC::MeshViewParameters* p = new MEDCALC::MeshViewParameters();
+ _getParameters<MEDPresentationMeshView>(presentationID, *p);
+ MEDCALC::MeshViewParameters_var tmp(p);
+ return tmp._retn();
}
MEDCALC::ContourParameters
MEDPresentationManager_i::getContourParameters(MEDPresentation::TypeID presentationID)
{
- MEDCALC::ContourParameters p;
- _getParameters<MEDPresentationContour>(presentationID, p);
- return p;
+ MEDCALC::ContourParameters* p = new MEDCALC::ContourParameters();
+ _getParameters<MEDPresentationContour>(presentationID, *p);
+ MEDCALC::ContourParameters_var tmp(p);
+ return tmp._retn();
}
MEDCALC::SlicesParameters*
MEDCALC::VectorFieldParameters
MEDPresentationManager_i::getVectorFieldParameters(MEDPresentation::TypeID presentationID)
{
- MEDCALC::VectorFieldParameters p;
- _getParameters<MEDPresentationVectorField>(presentationID, p);
- return p;
+ MEDCALC::VectorFieldParameters* p = new MEDCALC::VectorFieldParameters();
+ _getParameters<MEDPresentationVectorField>(presentationID, *p);
+ MEDCALC::VectorFieldParameters_var tmp(p);
+ return tmp._retn();
}
MEDCALC::PointSpriteParameters*
MEDCALC::DeflectionShapeParameters
MEDPresentationManager_i::getDeflectionShapeParameters(MEDPresentation::TypeID presentationID)
{
- MEDCALC::DeflectionShapeParameters p;
- _getParameters<MEDPresentationDeflectionShape>(presentationID, p);
- return p;
+ MEDCALC::DeflectionShapeParameters* p = new MEDCALC::DeflectionShapeParameters();
+ _getParameters<MEDPresentationDeflectionShape>(presentationID, *p);
+ MEDCALC::DeflectionShapeParameters_var tmp(p);
+ return tmp._retn();
}
// Populate internal array of available components:
fillAvailableFieldComponents();
- int nbCompo = getIntProperty(MEDPresentation::PROP_NB_COMPONENTS);
+ //int nbCompo = getIntProperty(MEDPresentation::PROP_NB_COMPONENTS); // todo: unused
// Point sprite needs point data:
applyCellToPointIfNeeded();
*/
~MEDPyLockWrapper()
{
- PyThreadState* _currState = PyGILState_GetThisThreadState();
#ifdef _DEBUG_
- if (_currState != _state)
+ if (PyGILState_GetThisThreadState() != _state)
{
std::cout << "!!!!!!!!! MEDPyLockWrapper inconsistency - now entering infinite loop for debugging\n";
while(1);
// Get the selected objects in the study (SObject)
SALOME_StudyEditor::SObjectList* listOfSObject = _studyEditor->getSelectedObjects();
- for (int i=0; i<listOfSObject->size(); i++) {
+ for (int i=0; i<(int)listOfSObject->size(); i++) {
SALOMEDS::SObject_var soFieldseries = listOfSObject->at(i);
std::string name(_studyEditor->getName(soFieldseries));
if (soFieldseries->_is_nil() || name == "MEDCalc")
else {
// In this case, we don't ask the user to specify an alias for
// each item, we just import the whole set of items.
- for (int i=0; i<listOfSObject->size(); i++) {
+ for (int i=0; i<(int)listOfSObject->size(); i++) {
SALOMEDS::SObject_var soField = listOfSObject->at(i);
if (soField->_is_nil())
continue;
if ( CORBA::is_nil( _MED_engine ) ) {
Engines::EngineComponent_var comp =
SalomeApp_Application::lcc()->FindOrLoad_Component( "FactoryServer", "FIELDS" );
- if (CORBA::is_nil( comp ))
- STDLOG("Could not FindOrLoad_Component FIELDS");
+ if (CORBA::is_nil( comp )) {
+ STDLOG("Could not FindOrLoad_Component FIELDS");
+ }
_MED_engine = MED_ORB::MED_Gen::_narrow( comp );
- if (CORBA::is_nil( _MED_engine ))
- STDLOG("Could not narrow FIELDS engine");
+ if (CORBA::is_nil( _MED_engine )) {
+ STDLOG("Could not narrow FIELDS engine");
+ }
}
}
}
void
-MEDModule::onClick(const QModelIndex & index)
+MEDModule::onClick(const QModelIndex & /*index*/)
{
int presId;
std::string name, type;
}
void
-MEDModule::onDblClick(const QModelIndex& index)
+MEDModule::onDblClick(const QModelIndex& /*index*/)
{
int presId;
std::string name, type;
MEDWidgetHelper::MEDWidgetHelper(const PresentationController * presController,
MEDCALC::MEDPresentationManager_ptr presManager, int presId,
const std::string & presName, WidgetPresentationParameters * paramWidget):
- _presController(presController),
_presManager(presManager),
+ _presController(presController),
_presId(presId),
_presName(presName),
_paramWidget(paramWidget)
emit presentationUpdateSignal(event); // --> PresentationController::processPresentationEvent
}
-void MEDWidgetHelper::onColorMapChanged(int idx)
+void MEDWidgetHelper::onColorMapChanged(int /*idx*/)
{
STDLOG("MEDWidgetHelper::onColorMapChanged");
PresentationEvent* event = new PresentationEvent();
QObject::disconnect( _paramWidget, SIGNAL(comboMeshIndexChanged(int)), this, SLOT(onMeshModeChanged(int)) );
}
-void MEDWidgetHelperMeshView::onMeshModeChanged(int meshMode)
+void MEDWidgetHelperMeshView::onMeshModeChanged(int /*meshMode*/)
{
STDLOG("MEDWidgetHelperMeshView::onMeshModeChanged");
PresentationEvent* event = new PresentationEvent();
}
-void MEDWidgetHelperSlices::onSliceOrientationChanged(int sliceOrient)
+void MEDWidgetHelperSlices::onSliceOrientationChanged(int /*sliceOrient*/)
{
STDLOG("MEDWidgetHelperSlices::onSliceOrientationChanged");
PresentationEvent* event = new PresentationEvent();
// For each object, emit a signal to the workspace to request a
// visualisation using the tui command (so that the user can see how
// to make a view of an object from the tui console).
- for (int i=0; i<listOfSObject->size(); i++) {
+ for (int i=0; i<(int)listOfSObject->size(); i++) {
SALOMEDS::SObject_var soObj = listOfSObject->at(i);
std::string name(_studyEditor->getName(soObj));
if (soObj->_is_nil() || name == "MEDCalc")
SALOME_StudyEditor::SObjectList* listOfSObject = _studyEditor->getSelectedObjects();
// For each object, emit a signal to the workspace to request pres deletion
- for (int i=0; i<listOfSObject->size(); i++) {
+ for (int i=0; i<(int)listOfSObject->size(); i++) {
SALOMEDS::SObject_var soPres = listOfSObject->at(i);
std::string name(_studyEditor->getName(soPres));
if (soPres->_is_nil() || name == "MEDCalc")
}
MEDWidgetHelper *
-PresentationController::findOrCreateWidgetHelper(MEDCALC::MEDPresentationManager_ptr presManager,
+PresentationController::findOrCreateWidgetHelper(MEDCALC::MEDPresentationManager_ptr /*presManager*/, // todo: unused
int presId, const std::string& type, const std::string& name )
{
std::map<int, MEDWidgetHelper *>::const_iterator it =_presHelperMap.find(presId);
wh = new MEDWidgetHelperDeflectionShape(this, _presManager, presId, name, _widgetPresentationParameters);
else
{
- const char * msg ="findOrCreateWidgetHelper(): NOT IMPLEMENTED !!!";
- STDLOG(msg);
+ STDLOG("findOrCreateWidgetHelper(): NOT IMPLEMENTED !!!");
return wh;
}
_presHelperMap[presId] = wh;
SALOME_StudyEditor::SObjectList* listOfSObject = _studyEditor->getSelectedObjects();
// For the first object only, request the dump
- for (int i=0; i<listOfSObject->size(); i++) {
+ for (int i=0; i<(int)listOfSObject->size(); i++) {
SALOMEDS::SObject_var soPres = listOfSObject->at(i);
std::string name(_studyEditor->getName(soPres));
if (soPres->_is_nil() || name == "MEDCalc")
if ( fieldSeriesId < 0)
return;
MEDCALC::FieldHandlerList* fieldHandlerList = MEDFactoryClient::getDataManager()->getFieldListInFieldseries(fieldSeriesId);
+ /* todo: always false!
if (fieldHandlerList->length() < 0)
return;
+ */
// For a field series, get the first real field entry:
MEDCALC::FieldHandler fieldHandler = (*fieldHandlerList)[0];
fieldId = fieldHandler.id;
if ( fieldSeriesId < 0)
return;
MEDCALC::FieldHandlerList* fieldHandlerList = MEDFactoryClient::getDataManager()->getFieldListInFieldseries(fieldSeriesId);
+ /* todo: always false!
if (fieldHandlerList->length() < 0)
return;
+ */
// For a field series, get the first real field entry:
MEDCALC::FieldHandler fieldHandler = (*fieldHandlerList)[0];
fieldId = fieldHandler.id;
class QAction;
namespace MEDCALC {
class MedEvent;
-};
+}
class TestController: public QObject {
Q_OBJECT
* connected slots.
*/
void WorkspaceController::createActions() {
- QWidget* dsk = _salomeModule->getApp()->desktop();
- SUIT_ResourceMgr* resMgr = _salomeModule->getApp()->resourceMgr();
+ // QWidget* dsk = _salomeModule->getApp()->desktop(); // todo: unused
+ // SUIT_ResourceMgr* resMgr = _salomeModule->getApp()->resourceMgr(); // todo: unused
int toolbarId = _salomeModule->createTool("Workspace", "WorkspaceToolbar");
QString label = tr("LAB_SAVE_WORKSPACE");
std::string msg(event->msg);
QMessageBox::warning(_salomeModule->getApp()->desktop(), "Error", QString::fromStdString(msg));
}
- else
+ else {
STDLOG("WorkspaceController::processMedEvent(): Unhandled event!!!");
+ }
}
/*!
LOG("WorkspaceController: WARN! No data object associated to the item "<<itemNameId);
return;
}
- MEDCALC::FieldHandler* fieldHandler = dataObject->getFieldHandler();
QStringList commands;
/*
+ MEDCALC::FieldHandler* fieldHandler = dataObject->getFieldHandler(); // todo: unused
commands+=QString("from xmed.driver_pvis import pvis_scalarmap");
commands+=QString("pvis_scalarmap('%1','%2','%3',%4,%5)")
.arg(tmpfilename)
// Then, we can request this data object to obtain the associated
// FieldHandler.
- MEDCALC::FieldHandler* fieldHandler = dataObject->getFieldHandler();
+ //MEDCALC::FieldHandler* fieldHandler = dataObject->getFieldHandler(); // todo: unused
// And finally, we can create the set of medcalc instructions to
// generate the scalar map on this field.
MEDCALC::MEDCommandsHistoryManager_ptr history = MEDFactoryClient::getCommandsHistoryManager();
QStringListIterator it(commands);
- int i = 0;
while (it.hasNext()) {
const QString& command = it.next();
_pyConsole->exec(command);
class MEDCALCGUI_EXPORT XmedDataProcessor : public DataProcessor {
public:
XmedDataProcessor(DataModel * dataModel):DataProcessor(dataModel) {};
+ virtual ~XmedDataProcessor() {};
MEDCALC::FieldHandlerList * getResultingFieldHandlerList();
MEDCALC::FieldIdList * getResultingFieldIdList();
{
_blockSig = true;
- int idx;
+ int idx = -1;
if (sbrange == MEDCALC::SCALAR_BAR_ALL_TIMESTEPS)
idx = _ui.comboBoxScalarBarRange->findText(tr("LAB_ALL_TIMESTEPS"));
else if (sbrange == MEDCALC::SCALAR_BAR_CURRENT_TIMESTEP)
idx = _ui.comboBoxScalarBarRange->findText(tr("LAB_CURRENT_TIMESTEP"));
if (idx >= 0)
- _ui.comboBoxScalarBarRange->setCurrentIndex(idx);
+ {
+ _ui.comboBoxScalarBarRange->setCurrentIndex(idx);
+ }
else
+ {
STDLOG("Strange!! No matching found - unable to set scalar bar range in GUI.");
+ }
_blockSig = false;
}
idx = _ui.comboBoxColorMap->findText(tr("LAB_COOL_TO_WARM"));
if (idx >= 0)
- _ui.comboBoxColorMap->setCurrentIndex(idx);
+ {
+ _ui.comboBoxColorMap->setCurrentIndex(idx);
+ }
else
+ {
STDLOG("Strange!! No matching found - unable to set color map in GUI.");
+ }
_blockSig = false;
}
idx = -1;
}
if (idx >= 0)
- _ui.comboBoxMesh->setCurrentIndex(idx);
+ {
+ _ui.comboBoxMesh->setCurrentIndex(idx);
+ }
else
+ {
STDLOG("Strange!! No matching found - unable to set mesh mode in GUI.");
+ }
_blockSig = false;
}
idx = -1;
}
if (idx >= 0)
+ {
_ui.comboBoxSliceOrient->setCurrentIndex(idx);
+ }
else
+ {
STDLOG("Strange!! No matching found - unable to set slice orientation in GUI.");
+ }
_blockSig = false;
}
* This method returns a restriction of this containing only selected TimeSteps.
* This methods throws an exception if multiple meshes exists in selected time steps.
*/
-MEDCalculatorBrowserField MEDCalculatorBrowserField::getSelectedTimeSteps() const throw(INTERP_KERNEL::Exception)
+MEDCalculatorBrowserField MEDCalculatorBrowserField::getSelectedTimeSteps() const
{
int nbOfTs=std::count(_steps.begin(),_steps.end(),true);
std::vector<MEDCalculatorBrowserStep> ts(nbOfTs);
void setComponentName(int,const std::string&);// Change the name of a component
bool isAnySelection() const;
void setMeshName(const std::string& m);
- MEDCalculatorBrowserField getSelectedTimeSteps() const throw(INTERP_KERNEL::Exception);
+ MEDCalculatorBrowserField getSelectedTimeSteps() const;
private:
std::string _name;// field name
std::string _file_name;// file name
return std::vector<const BigMemoryObject *>();
}
-MEDCalculatorDBField *MEDCalculatorDBField::operator+(double val) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBField::operator+(double val) const
{
MCAuto<MEDCalculatorDBFieldCst> par2=new MEDCalculatorDBFieldCst(val);
return (*this)+(*par2);
}
-MEDCalculatorDBField *MEDCalculatorDBField::operator-(double val) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBField::operator-(double val) const
{
MCAuto<MEDCalculatorDBFieldCst> par2=new MEDCalculatorDBFieldCst(val);
return (*this)-(*par2);
}
-MEDCalculatorDBField *MEDCalculatorDBField::operator*(double val) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBField::operator*(double val) const
{
MCAuto<MEDCalculatorDBFieldCst> par2=new MEDCalculatorDBFieldCst(val);
return (*this)*(*par2);
}
-MEDCalculatorDBField *MEDCalculatorDBField::operator/(double val) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBField::operator/(double val) const
{
MCAuto<MEDCalculatorDBFieldCst> par2=new MEDCalculatorDBFieldCst(val);
return (*this)/(*par2);
}
-MEDCalculatorDBFieldReal *MEDCalculatorDBFieldReal::operator()(const MEDCalculatorDBRangeSelection& t, const MEDCalculatorDBRangeSelection& p, const MEDCalculatorDBRangeSelection& c) throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBFieldReal *MEDCalculatorDBFieldReal::operator()(const MEDCalculatorDBRangeSelection& t, const MEDCalculatorDBRangeSelection& p, const MEDCalculatorDBRangeSelection& c)
{
MEDCalculatorDBFieldReal *ret=new MEDCalculatorDBFieldReal(*this);
ret->_t=t;
_time_steps[*iter]->setDescription(descr);*/
}
-void MEDCalculatorDBFieldReal::write(const char *fName, bool writeFromScratch) const throw(INTERP_KERNEL::Exception)
+void MEDCalculatorDBFieldReal::write(const char *fName, bool writeFromScratch) const
{
fetchData();
std::vector<std::size_t> ids=_t.getIds(_time_steps.size());
_time_steps[*iter]->write(fName,_name,_description);
}
-void MEDCalculatorDBFieldReal::display() const throw(INTERP_KERNEL::Exception)
+void MEDCalculatorDBFieldReal::display() const
{
fetchData();
std::vector<std::size_t> ids=_t.getIds(_time_steps.size());
}
}
-const MEDCalculatorDBFieldReal& MEDCalculatorDBFieldReal::operator=(const MEDCalculatorDBFieldReal& other) throw(INTERP_KERNEL::Exception)
+const MEDCalculatorDBFieldReal& MEDCalculatorDBFieldReal::operator=(const MEDCalculatorDBFieldReal& other)
{
checkConsistencyLight(other);
std::vector<std::size_t> ids=_t.getIds(_time_steps.size());
return *this;
}
-const MEDCalculatorDBFieldReal& MEDCalculatorDBFieldReal::operator=(double val) throw(INTERP_KERNEL::Exception)
+const MEDCalculatorDBFieldReal& MEDCalculatorDBFieldReal::operator=(double val)
{
MCAuto<MEDCalculatorDBFieldReal> other=buildCstFieldFromThis(val);
return (*this)=*other;
}
-MEDCalculatorDBField *MEDCalculatorDBFieldReal::operator+(const MEDCalculatorDBField& other) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBFieldReal::operator+(const MEDCalculatorDBField& other) const
{
const MEDCalculatorDBField *other2=&other;
const MEDCalculatorDBFieldReal *otherr=dynamic_cast<const MEDCalculatorDBFieldReal *>(other2);
}
}
-MEDCalculatorDBField *MEDCalculatorDBFieldReal::add(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBFieldReal::add(const MEDCalculatorDBFieldReal& other) const
{
checkConsistencyLight(other);
MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
return true;
}
-MEDCalculatorDBField *MEDCalculatorDBFieldReal::operator-(const MEDCalculatorDBField& other) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBFieldReal::operator-(const MEDCalculatorDBField& other) const
{
const MEDCalculatorDBField *other2=&other;
const MEDCalculatorDBFieldReal *otherr=dynamic_cast<const MEDCalculatorDBFieldReal *>(other2);
}
}
-MEDCalculatorDBField *MEDCalculatorDBFieldReal::substract(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBFieldReal::substract(const MEDCalculatorDBFieldReal& other) const
{
checkConsistencyLight(other);
MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
return ret;
}
-MEDCalculatorDBField *MEDCalculatorDBFieldReal::operator*(const MEDCalculatorDBField& other) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBFieldReal::operator*(const MEDCalculatorDBField& other) const
{
const MEDCalculatorDBField *other2=&other;
const MEDCalculatorDBFieldReal *otherr=dynamic_cast<const MEDCalculatorDBFieldReal *>(other2);
}
}
-MEDCalculatorDBField *MEDCalculatorDBFieldReal::multiply(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBFieldReal::multiply(const MEDCalculatorDBFieldReal& other) const
{
checkConsistencyLight(other);
MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
return ret;
}
-MEDCalculatorDBField *MEDCalculatorDBFieldReal::operator/(const MEDCalculatorDBField& other) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBFieldReal::operator/(const MEDCalculatorDBField& other) const
{
const MEDCalculatorDBField *other2=&other;
const MEDCalculatorDBFieldReal *otherr=dynamic_cast<const MEDCalculatorDBFieldReal *>(other2);
}
}
-MEDCalculatorDBField *MEDCalculatorDBFieldReal::divide(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBFieldReal::divide(const MEDCalculatorDBFieldReal& other) const
{
checkConsistencyLight(other);
MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
return ret;
}
-MEDCalculatorDBField *MEDCalculatorDBFieldReal::operator^(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBFieldReal::operator^(const MEDCalculatorDBFieldReal& other) const
{
return crossProduct(other);
}
-MEDCalculatorDBField *MEDCalculatorDBFieldReal::dot(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBFieldReal::dot(const MEDCalculatorDBFieldReal& other) const
{
checkConsistencyLight(other);
MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
return ret;
}
-MEDCalculatorDBField *MEDCalculatorDBFieldReal::crossProduct(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBFieldReal::crossProduct(const MEDCalculatorDBFieldReal& other) const
{
checkConsistencyLight(other);
MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
return ret;
}
-MEDCalculatorDBField *MEDCalculatorDBFieldReal::doublyContractedProduct() const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBFieldReal::doublyContractedProduct() const
{
MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
fetchData();
return ret;
}
-MEDCalculatorDBField *MEDCalculatorDBFieldReal::determinant() const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBFieldReal::determinant() const
{
MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
fetchData();
return ret;
}
-MEDCalculatorDBField *MEDCalculatorDBFieldReal::eigenValues() const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBFieldReal::eigenValues() const
{
MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
fetchData();
return ret;
}
-MEDCalculatorDBField *MEDCalculatorDBFieldReal::eigenVectors() const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBFieldReal::eigenVectors() const
{
MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
fetchData();
return ret;
}
-MEDCalculatorDBField *MEDCalculatorDBFieldReal::inverse() const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBFieldReal::inverse() const
{
MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
fetchData();
return ret;
}
-MEDCalculatorDBField *MEDCalculatorDBFieldReal::trace() const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBFieldReal::trace() const
{
MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
fetchData();
return ret;
}
-MEDCalculatorDBField *MEDCalculatorDBFieldReal::deviator() const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBFieldReal::deviator() const
{
MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
fetchData();
return ret;
}
-MEDCalculatorDBField *MEDCalculatorDBFieldReal::magnitude() const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBFieldReal::magnitude() const
{
MCAuto<MEDCalculatorDBFieldReal> ret=new MEDCalculatorDBFieldReal(_type);
fetchData();
return ret;
}
-void MEDCalculatorDBFieldReal::applyFunc(const char *func) throw(INTERP_KERNEL::Exception)
+void MEDCalculatorDBFieldReal::applyFunc(const char *func)
{
fetchData();
std::vector<std::size_t> ids=_t.getIds(_time_steps.size());
return ret;
}
-void MEDCalculatorDBFieldReal::checkConsistencyLight(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception)
+void MEDCalculatorDBFieldReal::checkConsistencyLight(const MEDCalculatorDBFieldReal& other) const
{
if(_type!=other._type)
throw INTERP_KERNEL::Exception("Types of field mismatch !");
throw INTERP_KERNEL::Exception("Components mismatch !");
}
-void MEDCalculatorDBFieldReal::fetchData() const throw(INTERP_KERNEL::Exception)
+void MEDCalculatorDBFieldReal::fetchData() const
{
std::vector<std::pair<int,int> > idstoFetch;
std::vector<std::size_t> ids=_t.getIds(_time_steps.size());
/*!
* WARNING the caller has the ownership of all of instances in returned vector.
*/
-std::vector<MEDCouplingFieldDouble *> MEDCalculatorDBFieldReal::getFields() const throw(INTERP_KERNEL::Exception)
+std::vector<MEDCouplingFieldDouble *> MEDCalculatorDBFieldReal::getFields() const
{
fetchData();
std::vector<std::size_t> ids=_t.getIds(_time_steps.size());
return ret;
}
-std::string MEDCalculatorDBFieldReal::getInfoOnComponent(int i) const throw(INTERP_KERNEL::Exception)
+std::string MEDCalculatorDBFieldReal::getInfoOnComponent(int i) const
{
if(i>=(int)_c_labels.size())
throw INTERP_KERNEL::Exception("MEDCalculatorDBFieldReal::getInfoOnComponent : specified id >= number of component !");
return _c_labels[i];
}
-void MEDCalculatorDBFieldReal::setInfoOnComponent(int i, const char *info) throw(INTERP_KERNEL::Exception)
+void MEDCalculatorDBFieldReal::setInfoOnComponent(int i, const char *info)
{
if(i>=(int)_c_labels.size())
throw INTERP_KERNEL::Exception("MEDCalculatorDBFieldReal::setInfoOnComponent : specified id >= number of component !");
{
}
-MEDCalculatorDBField *MEDCalculatorDBFieldCst::operator+(const MEDCalculatorDBField& other) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBFieldCst::operator+(const MEDCalculatorDBField& other) const
{
const MEDCalculatorDBField *other2=&other;
const MEDCalculatorDBFieldCst *otherc=dynamic_cast<const MEDCalculatorDBFieldCst *>(other2);
}
}
-MEDCalculatorDBField *MEDCalculatorDBFieldCst::operator-(const MEDCalculatorDBField& other) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBFieldCst::operator-(const MEDCalculatorDBField& other) const
{
const MEDCalculatorDBField *other2=&other;
const MEDCalculatorDBFieldCst *otherc=dynamic_cast<const MEDCalculatorDBFieldCst *>(other2);
}
}
-MEDCalculatorDBField *MEDCalculatorDBFieldCst::operator*(const MEDCalculatorDBField& other) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBFieldCst::operator*(const MEDCalculatorDBField& other) const
{
const MEDCalculatorDBField *other2=&other;
const MEDCalculatorDBFieldCst *otherc=dynamic_cast<const MEDCalculatorDBFieldCst *>(other2);
}
}
-MEDCalculatorDBField *MEDCalculatorDBFieldCst::operator/(const MEDCalculatorDBField& other) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBField *MEDCalculatorDBFieldCst::operator/(const MEDCalculatorDBField& other) const
{
const MEDCalculatorDBField *other2=&other;
const MEDCalculatorDBFieldCst *otherc=dynamic_cast<const MEDCalculatorDBFieldCst *>(other2);
static MEDCalculatorDBFieldCst *New(double val);
std::size_t getHeapMemorySizeWithoutChildren() const;
std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- virtual MEDCalculatorDBField *operator+(const MEDCalculatorDBField& other) const throw(INTERP_KERNEL::Exception) = 0;
- MEDCalculatorDBField *operator+(double val) const throw(INTERP_KERNEL::Exception);
- virtual MEDCalculatorDBField *operator-(const MEDCalculatorDBField& other) const throw(INTERP_KERNEL::Exception) = 0;
- MEDCalculatorDBField *operator-(double val) const throw(INTERP_KERNEL::Exception);
- virtual MEDCalculatorDBField *operator*(const MEDCalculatorDBField& other) const throw(INTERP_KERNEL::Exception) = 0;
- MEDCalculatorDBField *operator*(double val) const throw(INTERP_KERNEL::Exception);
- virtual MEDCalculatorDBField *operator/(const MEDCalculatorDBField& other) const throw(INTERP_KERNEL::Exception) = 0;
- MEDCalculatorDBField *operator/(double val) const throw(INTERP_KERNEL::Exception);
+ virtual MEDCalculatorDBField *operator+(const MEDCalculatorDBField& other) const = 0;
+ MEDCalculatorDBField *operator+(double val) const;
+ virtual MEDCalculatorDBField *operator-(const MEDCalculatorDBField& other) const = 0;
+ MEDCalculatorDBField *operator-(double val) const;
+ virtual MEDCalculatorDBField *operator*(const MEDCalculatorDBField& other) const = 0;
+ MEDCalculatorDBField *operator*(double val) const;
+ virtual MEDCalculatorDBField *operator/(const MEDCalculatorDBField& other) const = 0;
+ MEDCalculatorDBField *operator/(double val) const;
virtual bool isEqual(const MEDCalculatorDBField& other, double precM, double precF) const = 0;
};
~MEDCalculatorDBFieldReal();
void setName(const char *name);
void setDescription(const char *descr);
- void write(const char *fName, bool writeFromScratch) const throw(INTERP_KERNEL::Exception);
- void display() const throw(INTERP_KERNEL::Exception);
+ void write(const char *fName, bool writeFromScratch) const;
+ void display() const;
std::string simpleRepr() const;
- MEDCalculatorDBFieldReal *operator()(const MEDCalculatorDBRangeSelection& t, const MEDCalculatorDBRangeSelection& p, const MEDCalculatorDBRangeSelection& c) throw(INTERP_KERNEL::Exception);
- const MEDCalculatorDBFieldReal& operator=(const MEDCalculatorDBFieldReal& other) throw(INTERP_KERNEL::Exception);
- const MEDCalculatorDBFieldReal& operator=(double val) throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBField *operator+(const MEDCalculatorDBField& other) const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBField *add(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBField *operator-(const MEDCalculatorDBField& other) const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBField *substract(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBField *operator*(const MEDCalculatorDBField& other) const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBField *multiply(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBField *operator/(const MEDCalculatorDBField& other) const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBField *divide(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBField *operator^(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBField *dot(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBField *crossProduct(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBField *doublyContractedProduct() const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBField *determinant() const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBField *eigenValues() const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBField *eigenVectors() const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBField *inverse() const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBField *trace() const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBField *deviator() const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBField *magnitude() const throw(INTERP_KERNEL::Exception);
- void applyFunc(const char *func) throw(INTERP_KERNEL::Exception);
+ MEDCalculatorDBFieldReal *operator()(const MEDCalculatorDBRangeSelection& t, const MEDCalculatorDBRangeSelection& p, const MEDCalculatorDBRangeSelection& c);
+ const MEDCalculatorDBFieldReal& operator=(const MEDCalculatorDBFieldReal& other);
+ const MEDCalculatorDBFieldReal& operator=(double val);
+ MEDCalculatorDBField *operator+(const MEDCalculatorDBField& other) const;
+ MEDCalculatorDBField *add(const MEDCalculatorDBFieldReal& other) const;
+ MEDCalculatorDBField *operator-(const MEDCalculatorDBField& other) const;
+ MEDCalculatorDBField *substract(const MEDCalculatorDBFieldReal& other) const;
+ MEDCalculatorDBField *operator*(const MEDCalculatorDBField& other) const;
+ MEDCalculatorDBField *multiply(const MEDCalculatorDBFieldReal& other) const;
+ MEDCalculatorDBField *operator/(const MEDCalculatorDBField& other) const;
+ MEDCalculatorDBField *divide(const MEDCalculatorDBFieldReal& other) const;
+ MEDCalculatorDBField *operator^(const MEDCalculatorDBFieldReal& other) const;
+ MEDCalculatorDBField *dot(const MEDCalculatorDBFieldReal& other) const;
+ MEDCalculatorDBField *crossProduct(const MEDCalculatorDBFieldReal& other) const;
+ MEDCalculatorDBField *doublyContractedProduct() const;
+ MEDCalculatorDBField *determinant() const;
+ MEDCalculatorDBField *eigenValues() const;
+ MEDCalculatorDBField *eigenVectors() const;
+ MEDCalculatorDBField *inverse() const;
+ MEDCalculatorDBField *trace() const;
+ MEDCalculatorDBField *deviator() const;
+ MEDCalculatorDBField *magnitude() const;
+ void applyFunc(const char *func);
bool isEqual(const MEDCalculatorDBField& other, double precM, double precF) const;
bool isEqualSameType(const MEDCalculatorDBFieldReal& other, double precM, double precF) const;
MEDCalculatorDBFieldReal *buildCstFieldFromThis(double val) const;
- void checkConsistencyLight(const MEDCalculatorDBFieldReal& other) const throw(INTERP_KERNEL::Exception);
- void fetchData() const throw(INTERP_KERNEL::Exception);
+ void checkConsistencyLight(const MEDCalculatorDBFieldReal& other) const;
+ void fetchData() const;
TypeOfField getType() const { return _type; }
int getNumberOfSteps() const;
int getNumberOfFetchedSteps() const;
int getNumberOfComponents() const;
- std::vector<MEDCouplingFieldDouble *> getFields() const throw(INTERP_KERNEL::Exception);
- std::string getInfoOnComponent(int i) const throw(INTERP_KERNEL::Exception);
- void setInfoOnComponent(int i, const char *info) throw(INTERP_KERNEL::Exception);
+ std::vector<MEDCouplingFieldDouble *> getFields() const;
+ std::string getInfoOnComponent(int i) const;
+ void setInfoOnComponent(int i, const char *info);
private:
MEDCalculatorDBFieldReal(TypeOfField type);
private:
{
public:
MEDCalculatorDBFieldCst(double val);
- MEDCalculatorDBField *operator+(const MEDCalculatorDBField& other) const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBField *operator-(const MEDCalculatorDBField& other) const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBField *operator*(const MEDCalculatorDBField& other) const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBField *operator/(const MEDCalculatorDBField& other) const throw(INTERP_KERNEL::Exception);
+ MEDCalculatorDBField *operator+(const MEDCalculatorDBField& other) const;
+ MEDCalculatorDBField *operator-(const MEDCalculatorDBField& other) const;
+ MEDCalculatorDBField *operator*(const MEDCalculatorDBField& other) const;
+ MEDCalculatorDBField *operator/(const MEDCalculatorDBField& other) const;
bool isEqual(const MEDCalculatorDBField& other, double precM, double precF) const;
MEDCalculatorDBFieldReal *convertIntoReal(const MEDCalculatorDBFieldReal& ref) const;
double getValue() const { return _val; }
const char MEDCalculatorDBRangeSelection::ALL_ELTS[]=":";
-MEDCalculatorDBRangeSelection::MEDCalculatorDBRangeSelection(const char *v) throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBRangeSelection::MEDCalculatorDBRangeSelection(const char *v)
try
{
setValue(v);
_end=TraducePyVal(val);
}
-std::vector<std::size_t> MEDCalculatorDBRangeSelection::getIds(int lgth) const throw(INTERP_KERNEL::Exception)
+std::vector<std::size_t> MEDCalculatorDBRangeSelection::getIds(int lgth) const
{
if(_start>=lgth || _start<0)
{
return ret;
}
-int MEDCalculatorDBRangeSelection::getSize(int lgth) const throw(INTERP_KERNEL::Exception)
+int MEDCalculatorDBRangeSelection::getSize(int lgth) const
{
return getIds(lgth).size();
}
_end=std::numeric_limits<int>::max();
}
-MEDCalculatorDBRangeSelection& MEDCalculatorDBRangeSelection::operator=(const char *v) throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBRangeSelection& MEDCalculatorDBRangeSelection::operator=(const char *v)
{
setValue(v);
return *this;
}
-MEDCalculatorDBRangeSelection& MEDCalculatorDBRangeSelection::operator=(int v) throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBRangeSelection& MEDCalculatorDBRangeSelection::operator=(int v)
{
setValue(v);
return *this;
}
-void MEDCalculatorDBRangeSelection::setValue(const char *v) throw(INTERP_KERNEL::Exception)
+void MEDCalculatorDBRangeSelection::setValue(const char *v)
{
try
{
}
}
-void MEDCalculatorDBRangeSelection::setValue(int v) throw(INTERP_KERNEL::Exception)
+void MEDCalculatorDBRangeSelection::setValue(int v)
{
_start=v;
_end=v+1;
class MEDCALCULATOR_EXPORT MEDCalculatorDBRangeSelection
{
public:
- MEDCalculatorDBRangeSelection(const char *v) throw(INTERP_KERNEL::Exception);
+ MEDCalculatorDBRangeSelection(const char *v);
MEDCalculatorDBRangeSelection(int v);
MEDCalculatorDBRangeSelection();
void setPyStart(int val);
void setPyEnd(int val);
- MEDCalculatorDBRangeSelection& operator=(const char *v) throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBRangeSelection& operator=(int v) throw(INTERP_KERNEL::Exception);
- std::vector<std::size_t> getIds(int lgth) const throw(INTERP_KERNEL::Exception);
- int getSize(int lgth) const throw(INTERP_KERNEL::Exception);
+ MEDCalculatorDBRangeSelection& operator=(const char *v);
+ MEDCalculatorDBRangeSelection& operator=(int v);
+ std::vector<std::size_t> getIds(int lgth) const;
+ int getSize(int lgth) const;
bool isAll() const;
void setAll();
private:
- void setValue(const char *v) throw(INTERP_KERNEL::Exception);
- void setValue(int v) throw(INTERP_KERNEL::Exception);
+ void setValue(const char *v);
+ void setValue(int v);
static int TraducePyVal(int val);
private:
static const char SEPARATOR=':';
_field->setDescription(descr);
}
-void MEDCalculatorDBSliceField::write(const char *fName, const std::string& n, const std::string& d) const throw(INTERP_KERNEL::Exception)
+void MEDCalculatorDBSliceField::write(const char *fName, const std::string& n, const std::string& d) const
{
std::string kn=_field->getName();
std::string kd=_field->getDescription();
return new MEDCalculatorDBSliceField(f3);
}
-MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::doublyContractedProduct(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::doublyContractedProduct(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const
{
std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
return new MEDCalculatorDBSliceField(f2);
}
-MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::determinant(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::determinant(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const
{
std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
return new MEDCalculatorDBSliceField(f2);
}
-MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::eigenValues(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::eigenValues(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const
{
std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
return new MEDCalculatorDBSliceField(f2);
}
-MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::eigenVectors(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::eigenVectors(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const
{
std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
return new MEDCalculatorDBSliceField(f2);
}
-MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::inverse(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::inverse(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const
{
std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
return new MEDCalculatorDBSliceField(f2);
}
-MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::trace(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::trace(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const
{
std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
return new MEDCalculatorDBSliceField(f2);
}
-MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::deviator(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::deviator(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const
{
std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
return new MEDCalculatorDBSliceField(f2);
}
-MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::magnitude(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception)
+MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::magnitude(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const
{
std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
void setField(MEDCouplingFieldDouble *f) const;
void setName(const char *name);
void setDescription(const char *descr);
- void write(const char *fName, const std::string& n, const std::string& d) const throw(INTERP_KERNEL::Exception);
+ void write(const char *fName, const std::string& n, const std::string& d) const;
const MEDCouplingMesh *getMesh(TypeOfField type, const std::string& fname, const std::string& mname, const std::string& fieldName) const;
MEDCouplingFieldDouble *getField(TypeOfField type, const std::string& fname, const std::string& mname, const std::string& fieldName) const;
MEDCouplingFieldDouble *getFieldWithoutQuestion(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const;
MEDCalculatorDBSliceField *crossProduct(const MEDCalculatorDBSliceField* other,
int sizeCThis, const MEDCalculatorDBRangeSelection& thisC,
int sizeCOther, const MEDCalculatorDBRangeSelection& otherC) const;
- MEDCalculatorDBSliceField *doublyContractedProduct(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBSliceField *determinant(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBSliceField *eigenValues(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBSliceField *eigenVectors(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBSliceField *inverse(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBSliceField *trace(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBSliceField *deviator(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception);
- MEDCalculatorDBSliceField *magnitude(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception);
+ MEDCalculatorDBSliceField *doublyContractedProduct(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const;
+ MEDCalculatorDBSliceField *determinant(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const;
+ MEDCalculatorDBSliceField *eigenValues(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const;
+ MEDCalculatorDBSliceField *eigenVectors(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const;
+ MEDCalculatorDBSliceField *inverse(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const;
+ MEDCalculatorDBSliceField *trace(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const;
+ MEDCalculatorDBSliceField *deviator(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const;
+ MEDCalculatorDBSliceField *magnitude(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const;
void applyFunc(const char *func, int sizeCThis, const MEDCalculatorDBRangeSelection& thisC);
bool isEqual(const MEDCalculatorDBSliceField* other, const DataArrayIdType *cc, const DataArrayIdType *nc,
int sizeCThis, const MEDCalculatorDBRangeSelection& thisC,
int curLev=0;
std::size_t i=0;
std::size_t len=s.length();
- bool found=false;
+ //bool found=false; // todo: unused
if(parLev==0)
{
_content=s;
std::size_t end=s.find_first_of(')',i);
end=end!=std::string::npos?end-i:std::string::npos;
_content=s.substr(i,end);
- found=true;
+ //found=true; // todo: unused
break;
}
}
return ret;
}
-CORBA::Boolean DataArrayDoubleServant::ExportDataAs(const char *format, SALOME::GenericObj_out exporter)
+CORBA::Boolean DataArrayDoubleServant::ExportDataAs(const char * /*format*/, SALOME::GenericObj_out exporter)
{
exporter=SALOME::GenericObj::_nil();
return false;
return ret;
}
-CORBA::Boolean DataArrayIntServant::ExportDataAs(const char *format, SALOME::GenericObj_out exporter)
+CORBA::Boolean DataArrayIntServant::ExportDataAs(const char * /*format*/, SALOME::GenericObj_out exporter)
{
exporter=SALOME::GenericObj::_nil();
return false;
BCastIOR(orb,pobj,false);
}
-void MPIMEDCouplingFieldDoubleServant::getDataByMPI(const char* coupling) throw(SALOME::SALOME_Exception)
+void MPIMEDCouplingFieldDoubleServant::getDataByMPI(const char* coupling)
{
except_st *est;
void *ret_th;
- pthread_t *th;
+ pthread_t *th = 0;
if(_numproc == 0)
{
{
public:
MPIMEDCouplingFieldDoubleServant(CORBA::ORB_ptr orb,PortableServer::POA_ptr poa,ParaMEDMEMComponent_i *pcompo,MEDCouplingFieldDouble* field);
- void getDataByMPI(const char* coupling) throw(SALOME::SALOME_Exception);
+ void getDataByMPI(const char* coupling);
char* getRef();
// only for coupling one component with itself
CORBA::LongLong getImplementation() {return (CORBA::LongLong)_field;}
pthread_mutex_destroy (&m2);
}
-void ParaMEDMEMComponent_i::initializeCoupling(const char * coupling, const char * ior) throw(SALOME::SALOME_Exception)
+void ParaMEDMEMComponent_i::initializeCoupling(const char * coupling, const char * ior)
{
int gsize, grank;
except_st *est;
void *ret_th;
- pthread_t *th;
+ pthread_t *th = 0;
ostringstream msg;
pthread_mutex_lock(&m1);
}
}
-void ParaMEDMEMComponent_i::terminateCoupling(const char * coupling) throw(SALOME::SALOME_Exception)
+void ParaMEDMEMComponent_i::terminateCoupling(const char * coupling)
{
except_st *est;
void *ret_th;
- pthread_t *th;
+ pthread_t *th = 0;
ostringstream msg;
pthread_mutex_lock(&m2);
CORBA::Double max_distance_for_3Dsurf_intersect,
CORBA::Long orientation,
CORBA::Boolean measure_abs,
- const char * splitting_policy) throw(SALOME::SALOME_Exception)
+ const char * splitting_policy)
{
except_st *est;
void *ret_th;
- pthread_t *th;
+ pthread_t *th = 0;
ostringstream msg;
if(_numproc == 0)
CORBA::Double max_distance_for_3Dsurf_intersect,
CORBA::Long orientation,
CORBA::Boolean measure_abs,
- const char * splitting_policy ) throw(SALOME::SALOME_Exception);
- virtual void initializeCoupling(const char * coupling, const char * ior) throw(SALOME::SALOME_Exception);
- virtual void terminateCoupling(const char * coupling) throw(SALOME::SALOME_Exception);
+ const char * splitting_policy );
+ virtual void initializeCoupling(const char * coupling, const char * ior);
+ virtual void terminateCoupling(const char * coupling);
virtual void _getOutputField(const char * coupling, MEDCouplingFieldDouble* field);
protected:
