# Project name, upper case
STRING(TOUPPER ${PROJECT_NAME} PROJECT_NAME_UC)
-SET(${PROJECT_NAME_UC}_MAJOR_VERSION 7)
-SET(${PROJECT_NAME_UC}_MINOR_VERSION 8)
+SET(${PROJECT_NAME_UC}_MAJOR_VERSION 8)
+SET(${PROJECT_NAME_UC}_MINOR_VERSION 0)
SET(${PROJECT_NAME_UC}_PATCH_VERSION 0)
SET(${PROJECT_NAME_UC}_VERSION
${${PROJECT_NAME_UC}_MAJOR_VERSION}.${${PROJECT_NAME_UC}_MINOR_VERSION}.${${PROJECT_NAME_UC}_PATCH_VERSION})
-SET(${PROJECT_NAME_UC}_VERSION_DEV 0)
+SET(${PROJECT_NAME_UC}_VERSION_DEV 1)
# Find KERNEL
# ===========
## From GUI
##
-FIND_PACKAGE(SalomeQt4 REQUIRED COMPONENTS QtCore QtGui QtXml QtHelp)
+IF (NOT SALOME_GUI_BUILD_WITH_QT5)
+ FIND_PACKAGE(SalomeQt4 REQUIRED COMPONENTS QtCore QtGui QtXml QtHelp)
+ELSE()
+ FIND_PACKAGE(SalomeQt5 REQUIRED)
+ENDIF()
##
## Specific to ParaViS:
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-INCLUDE(UseQt4Ext)
+INCLUDE(UseQtExt)
# --- options ---
resources/pqCustomSettingsWidget.ui
)
-QT4_WRAP_UI(_ui_FORMS_HEADERS ${_ui_files})
+QT_WRAP_UIC(_ui_FORMS_HEADERS ${_ui_files})
# header files / to be processed by moc
SET(_moc_HEADERS
# --- sources ---
# sources / rcc wrappings
-QT4_ADD_RESOURCES(_rcc_SOURCES ${_rcc_RESOURCES})
+QT_ADD_RESOURCES(_rcc_SOURCES ${_rcc_RESOURCES})
# sources / moc wrappings
-QT4_WRAP_CPP(_moc_SOURCES ${_moc_HEADERS})
+QT_WRAP_MOC(_moc_SOURCES ${_moc_HEADERS})
# sources / static
SET(_other_SOURCES
# --- header and resources installation ---
INSTALL(FILES ${PVGUI_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})
-QT4_INSTALL_TS_RESOURCES("${_ts_RESOURCES}" "${SALOME_PARAVIS_INSTALL_RES_DATA}")
+QT_INSTALL_TS_RESOURCES("${_ts_RESOURCES}" "${SALOME_PARAVIS_INSTALL_RES_DATA}")
INSTALL(FILES ${_other_RESOURCES} DESTINATION ${SALOME_PARAVIS_INSTALL_RES_DATA})
{
QApplication::restoreOverrideCursor();
}
-
+#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
/*!
\brief Handler method for the output of messages.
*/
break;
}
}
-
+#else
+/*!
+ \brief Handler method for the output of messages.
+*/
+static void ParavisMessageOutput(QtMsgType type, const QMessageLogContext &context, const QString &msg)
+{
+ switch(type)
+ {
+ case QtDebugMsg:
+ vtkOutputWindow::GetInstance()->DisplayText(msg.toLatin1().constData());
+ break;
+ case QtWarningMsg:
+ vtkOutputWindow::GetInstance()->DisplayErrorText(msg.toLatin1().constData());
+ break;
+ case QtCriticalMsg:
+ vtkOutputWindow::GetInstance()->DisplayErrorText(msg.toLatin1().constData());
+ break;
+ case QtFatalMsg:
+ vtkOutputWindow::GetInstance()->DisplayErrorText(msg.toLatin1().constData());
+ break;
+ }
+}
+#endif
/*!
\brief Activate module.
\param study current study
*/
bool PVGUI_Module::activateModule( SUIT_Study* study )
{
+#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
myOldMsgHandler = qInstallMsgHandler(ParavisMessageOutput);
-
+#else
+ myOldMsgHandler = qInstallMessageHandler(ParavisMessageOutput);
+#endif
SUIT_ExceptionHandler::addCleanUpRoutine( paravisCleanUp );
storeCommonWindowsState();
SUIT_ExceptionHandler::removeCleanUpRoutine( paravisCleanUp );
if (myOldMsgHandler)
+#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
qInstallMsgHandler(myOldMsgHandler);
-
+#else
+ qInstallMessageHandler(myOldMsgHandler);
+#endif
restoreCommonWindowsState();
return LightApp_Module::deactivateModule( study );
typedef QMap<int, bool> DockWindowMap;
DockWindowMap myCommonMap;
-
+#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
QtMsgHandler myOldMsgHandler;
-
+#else
+ QtMessageHandler myOldMsgHandler;
+#endif
vtkEventQtSlotConnect* VTKConnect;
pqPythonScriptEditor* myTraceWindow;
cmake_minimum_required(VERSION 2.8)
+INCLUDE(UseQtExt)
FIND_PACKAGE(ParaView REQUIRED)
INCLUDE(${PARAVIEW_USE_FILE})
SET (outifaces)
SET (outsrcs)
-QT4_WRAP_CPP(moc_srcs pqArraysEditorPropertyWidget.h pqEditComponents.h)
+QT_WRAP_MOC(moc_srcs pqArraysEditorPropertyWidget.h pqEditComponents.h)
ADD_PARAVIEW_PROPERTY_GROUP_WIDGET(outifaces outsrcs
TYPE "custom_arrays_editor"
QTableView* componentsTable = new QTableView( this );
componentsTable->setModel( model );
aCompsLayout->addWidget( componentsTable );
+#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
componentsTable->horizontalHeader()->setResizeMode( pqComponentsModel::COMPONENT_NAME, QHeaderView::Stretch );
componentsTable->horizontalHeader()->setResizeMode( pqComponentsModel::NEW_COMPONENT_NAME, QHeaderView::Stretch );
-
+#else
+ componentsTable->horizontalHeader()->setSectionResizeMode( pqComponentsModel::COMPONENT_NAME, QHeaderView::Stretch );
+ componentsTable->horizontalHeader()->setSectionResizeMode( pqComponentsModel::NEW_COMPONENT_NAME, QHeaderView::Stretch );
+#endif
/// Parameters
QVBoxLayout *aParamsLayout = new QVBoxLayout( aParams );
myRenameAllComps = new QCheckBox( "Rename all similar Components", aParams );
// Layout
QVBoxLayout* lay = new QVBoxLayout(this);
lay->addWidget(myArraysTable);
+#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
myArraysTable->horizontalHeader()->setResizeMode( pqArraysModel::PROCESSING, QHeaderView::ResizeToContents );
myArraysTable->horizontalHeader()->setResizeMode( pqArraysModel::NAME, QHeaderView::Stretch);
myArraysTable->horizontalHeader()->setResizeMode( pqArraysModel::NEW_NAME, QHeaderView::Stretch );
myArraysTable->horizontalHeader()->setResizeMode( pqArraysModel::COMPONENTS, QHeaderView::ResizeToContents );
+#else
+ myArraysTable->horizontalHeader()->setSectionResizeMode( pqArraysModel::PROCESSING, QHeaderView::ResizeToContents );
+ myArraysTable->horizontalHeader()->setSectionResizeMode( pqArraysModel::NAME, QHeaderView::Stretch);
+ myArraysTable->horizontalHeader()->setSectionResizeMode( pqArraysModel::NEW_NAME, QHeaderView::Stretch );
+ myArraysTable->horizontalHeader()->setSectionResizeMode( pqArraysModel::COMPONENTS, QHeaderView::ResizeToContents );
+#endif
myArraysTable->resizeColumnsToContents();
// Connections
#include "vtkMutableDirectedGraph.h"
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
const char MEDFileFieldRepresentationLeavesArrays::ZE_SEP[]="@@][@@";
const char MEDFileFieldRepresentationLeavesArrays::NUM_ID_NODE_NAME[]="NumIdNode";
+const char MEDFileFieldRepresentationLeavesArrays::GLOBAL_NODE_ID_NAME[]="GlobalNodeIds";// WARNING DO NOT CHANGE IT BEFORE HAVING CHECKED IN PV SOURCES !
+
const char MEDFileFieldRepresentationTree::ROOT_OF_GRPS_IN_TREE[]="zeGrps";
const char MEDFileFieldRepresentationTree::ROOT_OF_FAM_IDS_IN_TREE[]="zeFamIds";
const char MEDFileFieldRepresentationTree::COMPO_STR_TO_LOCATE_MESH_DA[]="-@?|*_";
-vtkIdTypeArray *ELGACmp::findOrCreate(const ParaMEDMEM::MEDFileFieldGlobsReal *globs, const std::vector<std::string>& locsReallyUsed, vtkDoubleArray *vtkd, vtkDataSet *ds, bool& isNew) const
+vtkIdTypeArray *ELGACmp::findOrCreate(const MEDCoupling::MEDFileFieldGlobsReal *globs, const std::vector<std::string>& locsReallyUsed, vtkDoubleArray *vtkd, vtkDataSet *ds, bool& isNew) const
{
vtkIdTypeArray *try0(isExisting(locsReallyUsed,vtkd));
if(try0)
return ret;
}
-vtkIdTypeArray *ELGACmp::createNew(const ParaMEDMEM::MEDFileFieldGlobsReal *globs, const std::vector<std::string>& locsReallyUsed, vtkDoubleArray *vtkd, vtkDataSet *ds) const
+vtkIdTypeArray *ELGACmp::createNew(const MEDCoupling::MEDFileFieldGlobsReal *globs, const std::vector<std::string>& locsReallyUsed, vtkDoubleArray *vtkd, vtkDataSet *ds) const
{
const int VTK_DATA_ARRAY_DELETE=vtkDataArrayTemplate<double>::VTK_DATA_ARRAY_DELETE;
std::vector< std::vector<std::string> > locNames(_loc_names);
//=
+template<class T>
+class MEDFileVTKTraits
+{
+public:
+ typedef void VtkType;
+ typedef void MCType;
+};
+
+template<>
+class MEDFileVTKTraits<int>
+{
+public:
+ typedef vtkIntArray VtkType;
+ typedef MEDCoupling::DataArrayInt MCType;
+};
+
+template<>
+class MEDFileVTKTraits<double>
+{
+public:
+ typedef vtkDoubleArray VtkType;
+ typedef MEDCoupling::DataArrayDouble MCType;
+};
+
+template<class T>
+void AssignDataPointerToVTK(typename MEDFileVTKTraits<T>::VtkType *vtkTab, typename MEDFileVTKTraits<T>::MCType *mcTab, bool noCpyNumNodes)
+{
+ if(noCpyNumNodes)
+ vtkTab->SetArray(mcTab->getPointer(),mcTab->getNbOfElems(),1,vtkDataArrayTemplate<T>::VTK_DATA_ARRAY_FREE);
+ else
+ { vtkTab->SetArray(mcTab->getPointer(),mcTab->getNbOfElems(),0,vtkDataArrayTemplate<T>::VTK_DATA_ARRAY_FREE); mcTab->accessToMemArray().setSpecificDeallocator(0); }
+}
+
+// here copy is always assumed.
+template<class VTKT, class MCT>
+void AssignDataPointerOther(VTKT *vtkTab, MCT *mcTab, int nbElems)
+{
+ vtkTab->SetVoidArray(reinterpret_cast<unsigned char *>(mcTab->getPointer()),nbElems,0,VTKT::VTK_DATA_ARRAY_FREE);
+ mcTab->accessToMemArray().setSpecificDeallocator(0);
+}
+
+//=
+
MEDFileFieldRepresentationLeavesArrays::MEDFileFieldRepresentationLeavesArrays():_id(-1)
{
}
-MEDFileFieldRepresentationLeavesArrays::MEDFileFieldRepresentationLeavesArrays(const ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileAnyTypeFieldMultiTS>& arr):ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileAnyTypeFieldMultiTS>(arr),_activated(false),_id(-1)
+MEDFileFieldRepresentationLeavesArrays::MEDFileFieldRepresentationLeavesArrays(const MEDCoupling::MCAuto<MEDCoupling::MEDFileAnyTypeFieldMultiTS>& arr):MEDCoupling::MCAuto<MEDCoupling::MEDFileAnyTypeFieldMultiTS>(arr),_activated(false),_id(-1)
{
- std::vector< std::vector<ParaMEDMEM::TypeOfField> > typs((operator->())->getTypesOfFieldAvailable());
+ std::vector< std::vector<MEDCoupling::TypeOfField> > typs((operator->())->getTypesOfFieldAvailable());
if(typs.size()<1)
throw INTERP_KERNEL::Exception("There is a big internal problem in MEDLoader ! The field time spitting has failed ! A CRASH will occur soon !");
if(typs[0].size()!=1)
throw INTERP_KERNEL::Exception("There is a big internal problem in MEDLoader ! The field spitting by spatial discretization has failed ! A CRASH will occur soon !");
- ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDCouplingFieldDiscretization> fd(MEDCouplingFieldDiscretization::New(typs[0][0]));
+ MEDCoupling::MCAuto<MEDCoupling::MEDCouplingFieldDiscretization> fd(MEDCouplingFieldDiscretization::New(typs[0][0]));
std::ostringstream oss2; oss2 << (operator->())->getName() << ZE_SEP << fd->getRepr();
_ze_name=oss2.str();
}
MEDFileFieldRepresentationLeavesArrays& MEDFileFieldRepresentationLeavesArrays::operator=(const MEDFileFieldRepresentationLeavesArrays& other)
{
- ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileAnyTypeFieldMultiTS>::operator=(other);
+ MEDCoupling::MCAuto<MEDCoupling::MEDFileAnyTypeFieldMultiTS>::operator=(other);
_id=-1;
_activated=false;
_ze_name=other._ze_name;
return ret;
}
-void MEDFileFieldRepresentationLeavesArrays::appendFields(const MEDTimeReq *tr, const ParaMEDMEM::MEDFileFieldGlobsReal *globs, const ParaMEDMEM::MEDMeshMultiLev *mml, const ParaMEDMEM::MEDFileMeshStruct *mst, vtkDataSet *ds) const
+void MEDFileFieldRepresentationLeavesArrays::appendFields(const MEDTimeReq *tr, const MEDCoupling::MEDFileFieldGlobsReal *globs, const MEDCoupling::MEDMeshMultiLev *mml, const MEDCoupling::MEDFileMeshStruct *mst, vtkDataSet *ds) const
{
- const int VTK_DATA_ARRAY_FREE=vtkDataArrayTemplate<double>::VTK_DATA_ARRAY_FREE;
const int VTK_DATA_ARRAY_DELETE=vtkDataArrayTemplate<double>::VTK_DATA_ARRAY_DELETE;
tr->setNumberOfTS((operator->())->getNumberOfTS());
tr->initIterator();
for(int timeStepId=0;timeStepId<tr->size();timeStepId++,++(*tr))
{
- MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> f1ts((operator->())->getTimeStepAtPos(tr->getCurrent()));
+ MCAuto<MEDFileAnyTypeField1TS> f1ts((operator->())->getTimeStepAtPos(tr->getCurrent()));
MEDFileAnyTypeField1TS *f1tsPtr(f1ts);
MEDFileField1TS *f1tsPtrDbl(dynamic_cast<MEDFileField1TS *>(f1tsPtr));
MEDFileIntField1TS *f1tsPtrInt(dynamic_cast<MEDFileIntField1TS *>(f1tsPtr));
throw INTERP_KERNEL::Exception("MEDFileFieldRepresentationLeavesArrays::appendFields : only FLOAT64 and INT32 fields are dealt for the moment !");
MEDFileField1TSStructItem fsst(MEDFileField1TSStructItem::BuildItemFrom(f1ts,mst));
f1ts->loadArraysIfNecessary();
- MEDCouplingAutoRefCountObjectPtr<DataArray> v(mml->buildDataArray(fsst,globs,crudeArr));
+ MCAuto<DataArray> v(mml->buildDataArray(fsst,globs,crudeArr));
postProcessedArr=v;
//
std::vector<TypeOfField> discs(f1ts->getTypesOfFieldAvailable());
vtkd->SetNumberOfComponents(vd->getNumberOfComponents());
for(int i=0;i<vd->getNumberOfComponents();i++)
vtkd->SetComponentName(i,vd->getInfoOnComponent(i).c_str());
- if(postProcessedArr!=crudeArr)
- {
- vtkd->SetArray(vd->getPointer(),vd->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); vd->accessToMemArray().setSpecificDeallocator(0);
- }
- else
- {
- vtkd->SetArray(vd->getPointer(),vd->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
- }
+ AssignDataPointerToVTK<double>(vtkd,vd,postProcessedArr==crudeArr);
std::string name(tr->buildName(f1ts->getName()));
vtkd->SetName(name.c_str());
att->AddArray(vtkd);
vtkd->SetNumberOfComponents(vi->getNumberOfComponents());
for(int i=0;i<vi->getNumberOfComponents();i++)
vtkd->SetComponentName(i,vi->getVarOnComponent(i).c_str());
- if(postProcessedArr!=crudeArr)
- {
- vtkd->SetArray(vi->getPointer(),vi->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); vi->accessToMemArray().setSpecificDeallocator(0);
- }
- else
- {
- vtkd->SetArray(vi->getPointer(),vi->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
- }
+ AssignDataPointerToVTK<int>(vtkd,vi,postProcessedArr==crudeArr);
std::string name(tr->buildName(f1ts->getName()));
vtkd->SetName(name.c_str());
att->AddArray(vtkd);
{
}
-MEDFileFieldRepresentationLeaves::MEDFileFieldRepresentationLeaves(const std::vector< ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileAnyTypeFieldMultiTS> >& arr,
- const ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileFastCellSupportComparator>& fsp):_arrays(arr.size()),_fsp(fsp),_cached_ds(0)
+MEDFileFieldRepresentationLeaves::MEDFileFieldRepresentationLeaves(const std::vector< MEDCoupling::MCAuto<MEDCoupling::MEDFileAnyTypeFieldMultiTS> >& arr,
+ const MEDCoupling::MCAuto<MEDCoupling::MEDFileFastCellSupportComparator>& fsp):_arrays(arr.size()),_fsp(fsp),_cached_ds(0)
{
for(std::size_t i=0;i<arr.size();i++)
_arrays[i]=MEDFileFieldRepresentationLeavesArrays(arr[i]);
/*!
* \param [in] ms is the meshes pointer. It can be used only for information of geometric types. No special processing will be requested on ms.
*/
-void MEDFileFieldRepresentationLeaves::feedSIL(const ParaMEDMEM::MEDFileMeshes *ms, const std::string& meshName, vtkMutableDirectedGraph* sil, vtkIdType root, vtkVariantArray *edge, std::vector<std::string>& names) const
+void MEDFileFieldRepresentationLeaves::feedSIL(const MEDCoupling::MEDFileMeshes *ms, const std::string& meshName, vtkMutableDirectedGraph* sil, vtkIdType root, vtkVariantArray *edge, std::vector<std::string>& names) const
{
vtkIdType root2(sil->AddChild(root,edge));
names.push_back(std::string("Arrs"));
//
vtkIdType root3(sil->AddChild(root,edge));
names.push_back(std::string("InfoOnGeoType"));
- const ParaMEDMEM::MEDFileMesh *m(0);
+ const MEDCoupling::MEDFileMesh *m(0);
if(ms)
m=ms->getMeshWithName(meshName);
- const ParaMEDMEM::MEDFileFastCellSupportComparator *fsp(_fsp);
+ const MEDCoupling::MEDFileFastCellSupportComparator *fsp(_fsp);
if(!fsp || fsp->getNumberOfTS()==0)
return ;
std::vector< INTERP_KERNEL::NormalizedCellType > gts(fsp->getGeoTypesAt(0,m));
return oss.str();
}
-void MEDFileFieldRepresentationLeaves::appendFields(const MEDTimeReq *tr, const ParaMEDMEM::MEDFileFieldGlobsReal *globs, const ParaMEDMEM::MEDMeshMultiLev *mml, const ParaMEDMEM::MEDFileMeshes *meshes, vtkDataSet *ds) const
+void MEDFileFieldRepresentationLeaves::appendFields(const MEDTimeReq *tr, const MEDCoupling::MEDFileFieldGlobsReal *globs, const MEDCoupling::MEDMeshMultiLev *mml, const MEDCoupling::MEDFileMeshes *meshes, vtkDataSet *ds) const
{
if(_arrays.size()<1)
throw INTERP_KERNEL::Exception("MEDFileFieldRepresentationLeaves::appendFields : internal error !");
- MEDCouplingAutoRefCountObjectPtr<MEDFileMeshStruct> mst(MEDFileMeshStruct::New(meshes->getMeshWithName(_arrays[0]->getMeshName().c_str())));
+ MCAuto<MEDFileMeshStruct> mst(MEDFileMeshStruct::New(meshes->getMeshWithName(_arrays[0]->getMeshName().c_str())));
for(std::vector<MEDFileFieldRepresentationLeavesArrays>::const_iterator it=_arrays.begin();it!=_arrays.end();it++)
if((*it).getStatus())
{
vtkUnstructuredGrid *MEDFileFieldRepresentationLeaves::buildVTKInstanceNoTimeInterpolationUnstructured(MEDUMeshMultiLev *mm) const
{
- const int VTK_DATA_ARRAY_FREE=vtkDataArrayTemplate<double>::VTK_DATA_ARRAY_FREE;
DataArrayDouble *coordsMC(0);
DataArrayByte *typesMC(0);
DataArrayInt *cellLocationsMC(0),*cellsMC(0),*faceLocationsMC(0),*facesMC(0);
bool statusOfCoords(mm->buildVTUArrays(coordsMC,typesMC,cellLocationsMC,cellsMC,faceLocationsMC,facesMC));
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> coordsSafe(coordsMC);
- MEDCouplingAutoRefCountObjectPtr<DataArrayByte> typesSafe(typesMC);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cellLocationsSafe(cellLocationsMC),cellsSafe(cellsMC),faceLocationsSafe(faceLocationsMC),facesSafe(facesMC);
+ MCAuto<DataArrayDouble> coordsSafe(coordsMC);
+ MCAuto<DataArrayByte> typesSafe(typesMC);
+ MCAuto<DataArrayInt> cellLocationsSafe(cellLocationsMC),cellsSafe(cellsMC),faceLocationsSafe(faceLocationsMC),facesSafe(facesMC);
//
int nbOfCells(typesSafe->getNbOfElems());
vtkUnstructuredGrid *ret(vtkUnstructuredGrid::New());
vtkUnsignedCharArray *cellTypes(vtkUnsignedCharArray::New());
- cellTypes->SetArray(reinterpret_cast<unsigned char *>(typesSafe->getPointer()),nbOfCells,0,VTK_DATA_ARRAY_FREE); typesSafe->accessToMemArray().setSpecificDeallocator(0);
+ AssignDataPointerOther<vtkUnsignedCharArray,DataArrayByte>(cellTypes,typesSafe,nbOfCells);
vtkIdTypeArray *cellLocations(vtkIdTypeArray::New());
- cellLocations->SetVoidArray(cellLocationsSafe->getPointer(),nbOfCells,0,VTK_DATA_ARRAY_FREE); cellLocationsSafe->accessToMemArray().setSpecificDeallocator(0);
+ AssignDataPointerOther<vtkIdTypeArray,DataArrayInt>(cellLocations,cellLocationsSafe,nbOfCells);
vtkCellArray *cells(vtkCellArray::New());
vtkIdTypeArray *cells2(vtkIdTypeArray::New());
- cells2->SetVoidArray(cellsSafe->getPointer(),cellsSafe->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); cellsSafe->accessToMemArray().setSpecificDeallocator(0);
+ AssignDataPointerOther<vtkIdTypeArray,DataArrayInt>(cells2,cellsSafe,cellsSafe->getNbOfElems());
cells->SetCells(nbOfCells,cells2);
cells2->Delete();
if(faceLocationsMC!=0 && facesMC!=0)
{
vtkIdTypeArray *faces(vtkIdTypeArray::New());
- faces->SetVoidArray(facesSafe->getPointer(),facesSafe->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); facesSafe->accessToMemArray().setSpecificDeallocator(0);
+ AssignDataPointerOther<vtkIdTypeArray,DataArrayInt>(faces,facesSafe,facesSafe->getNbOfElems());
vtkIdTypeArray *faceLocations(vtkIdTypeArray::New());
- faceLocations->SetVoidArray(faceLocationsSafe->getPointer(),faceLocationsSafe->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); faceLocationsSafe->accessToMemArray().setSpecificDeallocator(0);
+ AssignDataPointerOther<vtkIdTypeArray,DataArrayInt>(faceLocations,faceLocationsSafe,faceLocationsSafe->getNbOfElems());
ret->SetCells(cellTypes,cellLocations,cells,faceLocations,faces);
faceLocations->Delete();
faces->Delete();
vtkPoints *pts(vtkPoints::New());
vtkDoubleArray *pts2(vtkDoubleArray::New());
pts2->SetNumberOfComponents(3);
- if(!statusOfCoords)
- {
- pts2->SetArray(coordsSafe->getPointer(),coordsSafe->getNbOfElems(),0,VTK_DATA_ARRAY_FREE);
- coordsSafe->accessToMemArray().setSpecificDeallocator(0);
- }
- else
- pts2->SetArray(coordsSafe->getPointer(),coordsSafe->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
+ AssignDataPointerToVTK<double>(pts2,coordsSafe,statusOfCoords);
pts->SetData(pts2);
pts2->Delete();
ret->SetPoints(pts);
return ret;
}
-vtkRectilinearGrid *MEDFileFieldRepresentationLeaves::buildVTKInstanceNoTimeInterpolationCartesian(ParaMEDMEM::MEDCMeshMultiLev *mm) const
+vtkRectilinearGrid *MEDFileFieldRepresentationLeaves::buildVTKInstanceNoTimeInterpolationCartesian(MEDCoupling::MEDCMeshMultiLev *mm) const
{
- const int VTK_DATA_ARRAY_FREE=vtkDataArrayTemplate<double>::VTK_DATA_ARRAY_FREE;
bool isInternal;
std::vector< DataArrayDouble * > arrs(mm->buildVTUArrays(isInternal));
vtkDoubleArray *vtkTmp(0);
ret->SetDimensions(sizePerAxe[0],sizePerAxe[1],sizePerAxe[2]);
vtkTmp=vtkDoubleArray::New();
vtkTmp->SetNumberOfComponents(1);
- if(isInternal)
- vtkTmp->SetArray(arrs[0]->getPointer(),arrs[0]->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
- else
- { vtkTmp->SetArray(arrs[0]->getPointer(),arrs[0]->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); arrs[0]->accessToMemArray().setSpecificDeallocator(0); }
+ AssignDataPointerToVTK<double>(vtkTmp,arrs[0],isInternal);
ret->SetXCoordinates(vtkTmp);
vtkTmp->Delete();
arrs[0]->decrRef();
{
vtkTmp=vtkDoubleArray::New();
vtkTmp->SetNumberOfComponents(1);
- if(isInternal)
- vtkTmp->SetArray(arrs[1]->getPointer(),arrs[1]->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
- else
- { vtkTmp->SetArray(arrs[1]->getPointer(),arrs[1]->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); arrs[1]->accessToMemArray().setSpecificDeallocator(0); }
+ AssignDataPointerToVTK<double>(vtkTmp,arrs[1],isInternal);
ret->SetYCoordinates(vtkTmp);
vtkTmp->Delete();
arrs[1]->decrRef();
{
vtkTmp=vtkDoubleArray::New();
vtkTmp->SetNumberOfComponents(1);
- if(isInternal)
- vtkTmp->SetArray(arrs[2]->getPointer(),arrs[2]->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
- else
- { vtkTmp->SetArray(arrs[2]->getPointer(),arrs[2]->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); arrs[2]->accessToMemArray().setSpecificDeallocator(0); }
+ AssignDataPointerToVTK<double>(vtkTmp,arrs[2],isInternal);
ret->SetZCoordinates(vtkTmp);
vtkTmp->Delete();
arrs[2]->decrRef();
return ret;
}
-vtkStructuredGrid *MEDFileFieldRepresentationLeaves::buildVTKInstanceNoTimeInterpolationCurveLinear(ParaMEDMEM::MEDCurveLinearMeshMultiLev *mm) const
+vtkStructuredGrid *MEDFileFieldRepresentationLeaves::buildVTKInstanceNoTimeInterpolationCurveLinear(MEDCoupling::MEDCurveLinearMeshMultiLev *mm) const
{
- const int VTK_DATA_ARRAY_FREE=vtkDataArrayTemplate<double>::VTK_DATA_ARRAY_FREE;
int meshStr[3]={1,1,1};
DataArrayDouble *coords(0);
std::vector<int> nodeStrct;
vtkDoubleArray *da(vtkDoubleArray::New());
da->SetNumberOfComponents(3);
if(coords->getNumberOfComponents()==3)
- {
- if(isInternal)
- da->SetArray(coords->getPointer(),coords->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);//VTK has not the ownership of double * because MEDLoader main struct has it !
- else
- { da->SetArray(coords->getPointer(),coords->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); coords->accessToMemArray().setSpecificDeallocator(0); }
- }
+ AssignDataPointerToVTK<double>(da,coords,isInternal);//if isIntenal==True VTK has not the ownership of double * because MEDLoader main struct has it !
else
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> coords2(coords->changeNbOfComponents(3,0.));
- da->SetArray(coords2->getPointer(),coords2->getNbOfElems(),0,VTK_DATA_ARRAY_FREE);//let VTK deal with double *
- coords2->accessToMemArray().setSpecificDeallocator(0);
+ MCAuto<DataArrayDouble> coords2(coords->changeNbOfComponents(3,0.));
+ AssignDataPointerToVTK<double>(da,coords2,false);//let VTK deal with double *
}
coords->decrRef();
vtkPoints *points=vtkPoints::New();
return ret;
}
-vtkDataSet *MEDFileFieldRepresentationLeaves::buildVTKInstanceNoTimeInterpolation(const MEDTimeReq *tr, const MEDFileFieldGlobsReal *globs, const ParaMEDMEM::MEDFileMeshes *meshes) const
+vtkDataSet *MEDFileFieldRepresentationLeaves::buildVTKInstanceNoTimeInterpolation(const MEDTimeReq *tr, const MEDFileFieldGlobsReal *globs, const MEDCoupling::MEDFileMeshes *meshes) const
{
- const int VTK_DATA_ARRAY_FREE=vtkDataArrayTemplate<double>::VTK_DATA_ARRAY_FREE;
vtkDataSet *ret(0);
//_fsp->isDataSetSupportEqualToThePreviousOne(i,globs);
- MEDCouplingAutoRefCountObjectPtr<MEDMeshMultiLev> mml(_fsp->buildFromScratchDataSetSupport(0,globs));//0=timestep Id. Make the hypothesis that support does not change
- MEDCouplingAutoRefCountObjectPtr<MEDMeshMultiLev> mml2(mml->prepare());
+ MCAuto<MEDMeshMultiLev> mml(_fsp->buildFromScratchDataSetSupport(0,globs));//0=timestep Id. Make the hypothesis that support does not change
+ MCAuto<MEDMeshMultiLev> mml2(mml->prepare());
MEDMeshMultiLev *ptMML2(mml2);
if(!_cached_ds)
{
vtkIntArray *vtkTab(vtkIntArray::New());
vtkTab->SetNumberOfComponents(1);
vtkTab->SetName(MEDFileFieldRepresentationLeavesArrays::FAMILY_ID_CELL_NAME);
- if(noCpyFamCells)
- vtkTab->SetArray(famCells->getPointer(),famCells->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
- else
- { vtkTab->SetArray(famCells->getPointer(),famCells->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); famCells->accessToMemArray().setSpecificDeallocator(0); }
+ AssignDataPointerToVTK<int>(vtkTab,famCells,noCpyFamCells);
ret->GetCellData()->AddArray(vtkTab);
vtkTab->Delete();
famCells->decrRef();
vtkIntArray *vtkTab(vtkIntArray::New());
vtkTab->SetNumberOfComponents(1);
vtkTab->SetName(MEDFileFieldRepresentationLeavesArrays::NUM_ID_CELL_NAME);
- if(noCpyNumCells)
- vtkTab->SetArray(numCells->getPointer(),numCells->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
- else
- { vtkTab->SetArray(numCells->getPointer(),numCells->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); numCells->accessToMemArray().setSpecificDeallocator(0); }
+ AssignDataPointerToVTK<int>(vtkTab,numCells,noCpyNumCells);
ret->GetCellData()->AddArray(vtkTab);
vtkTab->Delete();
numCells->decrRef();
vtkIntArray *vtkTab(vtkIntArray::New());
vtkTab->SetNumberOfComponents(1);
vtkTab->SetName(MEDFileFieldRepresentationLeavesArrays::FAMILY_ID_NODE_NAME);
- if(noCpyFamNodes)
- vtkTab->SetArray(famNodes->getPointer(),famNodes->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
- else
- { vtkTab->SetArray(famNodes->getPointer(),famNodes->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); famNodes->accessToMemArray().setSpecificDeallocator(0); }
+ AssignDataPointerToVTK<int>(vtkTab,famNodes,noCpyFamNodes);
ret->GetPointData()->AddArray(vtkTab);
vtkTab->Delete();
famNodes->decrRef();
vtkIntArray *vtkTab(vtkIntArray::New());
vtkTab->SetNumberOfComponents(1);
vtkTab->SetName(MEDFileFieldRepresentationLeavesArrays::NUM_ID_NODE_NAME);
- if(noCpyNumNodes)
- vtkTab->SetArray(numNodes->getPointer(),numNodes->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
- else
- { vtkTab->SetArray(numNodes->getPointer(),numNodes->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); numNodes->accessToMemArray().setSpecificDeallocator(0); }
+ AssignDataPointerToVTK<int>(vtkTab,numNodes,noCpyNumNodes);
ret->GetPointData()->AddArray(vtkTab);
vtkTab->Delete();
numNodes->decrRef();
}
+ // Global Node Ids if any ! (In // mode)
+ DataArrayInt *gni(ptMML2->retrieveGlobalNodeIdsIfAny());
+ if(gni)
+ {
+ vtkIntArray *vtkTab(vtkIntArray::New());
+ vtkTab->SetNumberOfComponents(1);
+ vtkTab->SetName(MEDFileFieldRepresentationLeavesArrays::GLOBAL_NODE_ID_NAME);
+ AssignDataPointerToVTK<int>(vtkTab,gni,false);
+ ret->GetPointData()->AddArray(vtkTab);
+ vtkTab->Delete();
+ gni->decrRef();
+ }
return ret;
}
int nbMeshes(_ms->getNumberOfMeshes());
for(int i=0;i<nbMeshes;i++)
{
- ParaMEDMEM::MEDFileMesh *tmp(_ms->getMeshAtPos(i));
- ParaMEDMEM::MEDFileUMesh *tmp2(dynamic_cast<ParaMEDMEM::MEDFileUMesh *>(tmp));
+ MEDCoupling::MEDFileMesh *tmp(_ms->getMeshAtPos(i));
+ MEDCoupling::MEDFileUMesh *tmp2(dynamic_cast<MEDCoupling::MEDFileUMesh *>(tmp));
if(tmp2)
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp3(tmp2->zipCoords());
+ MCAuto<DataArrayInt> tmp3(tmp2->zipCoords());
}
_fields=MEDFileFields::LoadPartOf(fileName,false,_ms);//false is important to not read the values
#else
}
else
{
- MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::SauvReader> sr(ParaMEDMEM::SauvReader::New(fileName));
- MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileData> mfd(sr->loadInMEDFileDS());
+ MCAuto<MEDCoupling::SauvReader> sr(MEDCoupling::SauvReader::New(fileName));
+ MCAuto<MEDCoupling::MEDFileData> mfd(sr->loadInMEDFileDS());
_ms=mfd->getMeshes(); _ms->incrRef();
int nbMeshes(_ms->getNumberOfMeshes());
for(int i=0;i<nbMeshes;i++)
{
- ParaMEDMEM::MEDFileMesh *tmp(_ms->getMeshAtPos(i));
- ParaMEDMEM::MEDFileUMesh *tmp2(dynamic_cast<ParaMEDMEM::MEDFileUMesh *>(tmp));
+ MEDCoupling::MEDFileMesh *tmp(_ms->getMeshAtPos(i));
+ MEDCoupling::MEDFileUMesh *tmp2(dynamic_cast<MEDCoupling::MEDFileUMesh *>(tmp));
if(tmp2)
tmp2->forceComputationOfParts();
}
_fields=mfd->getFields();
- if((ParaMEDMEM::MEDFileFields *)_fields)
+ if((MEDCoupling::MEDFileFields *)_fields)
_fields->incrRef();
}
- if(!((ParaMEDMEM::MEDFileFields *)_fields))
+ if(!((MEDCoupling::MEDFileFields *)_fields))
{
_fields=BuildFieldFromMeshes(_ms);
}
_ms->cartesianizeMe();
_fields->removeFieldsWithoutAnyTimeStep();
std::vector<std::string> meshNames(_ms->getMeshesNames());
- std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFields> > fields_per_mesh(meshNames.size());
+ std::vector< MCAuto<MEDFileFields> > fields_per_mesh(meshNames.size());
for(std::size_t i=0;i<meshNames.size();i++)
{
fields_per_mesh[i]=_fields->partOfThisLyingOnSpecifiedMeshName(meshNames[i].c_str());
}
- std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS > > allFMTSLeavesToDisplaySafe;
+ std::vector< MCAuto<MEDFileAnyTypeFieldMultiTS > > allFMTSLeavesToDisplaySafe;
std::size_t k(0);
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFields> >::const_iterator fields=fields_per_mesh.begin();fields!=fields_per_mesh.end();fields++)
+ for(std::vector< MCAuto<MEDFileFields> >::const_iterator fields=fields_per_mesh.begin();fields!=fields_per_mesh.end();fields++)
{
for(int j=0;j<(*fields)->getNumberOfFields();j++)
{
- MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> fmts((*fields)->getFieldAtPos((int)j));
- std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > tmp(fmts->splitDiscretizations());
+ MCAuto<MEDFileAnyTypeFieldMultiTS> fmts((*fields)->getFieldAtPos((int)j));
+ std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > > tmp(fmts->splitDiscretizations());
// EDF 8655
- for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > >::const_iterator it=tmp.begin();it!=tmp.end();it++)
+ for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > >::const_iterator it=tmp.begin();it!=tmp.end();it++)
{
if(!(*it)->presenceOfMultiDiscPerGeoType())
allFMTSLeavesToDisplaySafe.push_back(*it);
else
{// The case of some parts of field have more than one discretization per geo type.
- std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > subTmp((*it)->splitMultiDiscrPerGeoTypes());
+ std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > > subTmp((*it)->splitMultiDiscrPerGeoTypes());
std::size_t it0Cnt(0);
- for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > >::iterator it0=subTmp.begin();it0!=subTmp.end();it0++,it0Cnt++)//not const because setName
+ for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > >::iterator it0=subTmp.begin();it0!=subTmp.end();it0++,it0Cnt++)//not const because setName
{
std::ostringstream oss; oss << (*it0)->getName() << "_" << std::setfill('M') << std::setw(3) << it0Cnt;
(*it0)->setName(oss.str());
}
std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > allFMTSLeavesPerTimeSeries(MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries(allFMTSLeavesToDisplay));
// memory safety part
- std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> > > allFMTSLeavesPerTimeSeriesSafe(allFMTSLeavesPerTimeSeries.size());
+ std::vector< std::vector< MCAuto<MEDFileAnyTypeFieldMultiTS> > > allFMTSLeavesPerTimeSeriesSafe(allFMTSLeavesPerTimeSeries.size());
for(std::size_t j=0;j<allFMTSLeavesPerTimeSeries.size();j++)
{
allFMTSLeavesPerTimeSeriesSafe[j].resize(allFMTSLeavesPerTimeSeries[j].size());
for(std::size_t i=0;i<allFMTSLeavesPerTimeSeriesSafe.size();i++)
{
std::vector< std::string > meshNamesLoc;
- std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> > > splitByMeshName;
+ std::vector< std::vector< MCAuto<MEDFileAnyTypeFieldMultiTS> > > splitByMeshName;
for(std::size_t j=0;j<allFMTSLeavesPerTimeSeriesSafe[i].size();j++)
{
std::string meshName(allFMTSLeavesPerTimeSeriesSafe[i][j]->getMeshName());
_data_structure[i].resize(meshNamesLoc.size());
for(std::size_t j=0;j<splitByMeshName.size();j++)
{
- std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFastCellSupportComparator> > fsp;
+ std::vector< MCAuto<MEDFileFastCellSupportComparator> > fsp;
std::vector< MEDFileAnyTypeFieldMultiTS *> sbmn(splitByMeshName[j].size());
for(std::size_t k=0;k<splitByMeshName[j].size();k++)
sbmn[k]=splitByMeshName[j][k];
//getMeshWithName does not return a newly allocated object ! It is a true get* method !
std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > commonSupSplit(MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport(sbmn,_ms->getMeshWithName(meshNamesLoc[j].c_str()),fsp));
- std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> > > commonSupSplitSafe(commonSupSplit.size());
+ std::vector< std::vector< MCAuto<MEDFileAnyTypeFieldMultiTS> > > commonSupSplitSafe(commonSupSplit.size());
this->_data_structure[i][j].resize(commonSupSplit.size());
for(std::size_t k=0;k<commonSupSplit.size();k++)
{
return ret;
}
-void MEDFileFieldRepresentationTree::AppendFieldFromMeshes(const ParaMEDMEM::MEDFileMeshes *ms, ParaMEDMEM::MEDFileFields *ret)
+void MEDFileFieldRepresentationTree::AppendFieldFromMeshes(const MEDCoupling::MEDFileMeshes *ms, MEDCoupling::MEDFileFields *ret)
{
if(!ret)
throw INTERP_KERNEL::Exception("MEDFileFieldRepresentationTree::AppendFieldFromMeshes : internal error ! NULL ret !");
{
MEDFileMesh *mm(ms->getMeshAtPos(i));
std::vector<int> levs(mm->getNonEmptyLevels());
- ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileField1TS> f1tsMultiLev(ParaMEDMEM::MEDFileField1TS::New());
+ MEDCoupling::MCAuto<MEDCoupling::MEDFileField1TS> f1tsMultiLev(MEDCoupling::MEDFileField1TS::New());
MEDFileUMesh *mmu(dynamic_cast<MEDFileUMesh *>(mm));
if(mmu)
{
std::vector<INTERP_KERNEL::NormalizedCellType> gts(mmu->getGeoTypesAtLevel(*it));
for(std::vector<INTERP_KERNEL::NormalizedCellType>::const_iterator gt=gts.begin();gt!=gts.end();gt++)
{
- ParaMEDMEM::MEDCouplingMesh *m(mmu->getDirectUndergroundSingleGeoTypeMesh(*gt));
- ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDCouplingFieldDouble> f(ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS));
+ MEDCoupling::MEDCouplingMesh *m(mmu->getDirectUndergroundSingleGeoTypeMesh(*gt));
+ MEDCoupling::MCAuto<MEDCoupling::MEDCouplingFieldDouble> f(MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_CELLS));
f->setMesh(m);
- ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::DataArrayDouble> arr(ParaMEDMEM::DataArrayDouble::New()); arr->alloc(f->getNumberOfTuplesExpected());
+ MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> arr(MEDCoupling::DataArrayDouble::New()); arr->alloc(f->getNumberOfTuplesExpected());
arr->setInfoOnComponent(0,std::string(COMPO_STR_TO_LOCATE_MESH_DA));
arr->iota();
f->setArray(arr);
std::vector<int> levsExt(mm->getNonEmptyLevelsExt());
if(levsExt.size()==levs.size()+1)
{
- ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDCouplingMesh> m(mm->getMeshAtLevel(1));
- ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDCouplingFieldDouble> f(ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_NODES));
+ MEDCoupling::MCAuto<MEDCoupling::MEDCouplingMesh> m(mm->getMeshAtLevel(1));
+ MEDCoupling::MCAuto<MEDCoupling::MEDCouplingFieldDouble> f(MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_NODES));
f->setMesh(m);
- ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::DataArrayDouble> arr(ParaMEDMEM::DataArrayDouble::New()); arr->alloc(m->getNumberOfNodes());
+ MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> arr(MEDCoupling::DataArrayDouble::New()); arr->alloc(m->getNumberOfNodes());
arr->setInfoOnComponent(0,std::string(COMPO_STR_TO_LOCATE_MESH_DA));
arr->iota(); f->setArray(arr);
f->setName(BuildAUniqueArrayNameForMesh(mm->getName(),ret));
}
else
{
- ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDCouplingMesh> m(mm->getMeshAtLevel(0));
- ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDCouplingFieldDouble> f(ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS));
+ MEDCoupling::MCAuto<MEDCoupling::MEDCouplingMesh> m(mm->getMeshAtLevel(0));
+ MEDCoupling::MCAuto<MEDCoupling::MEDCouplingFieldDouble> f(MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_CELLS));
f->setMesh(m);
- ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::DataArrayDouble> arr(ParaMEDMEM::DataArrayDouble::New()); arr->alloc(f->getNumberOfTuplesExpected());
+ MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> arr(MEDCoupling::DataArrayDouble::New()); arr->alloc(f->getNumberOfTuplesExpected());
arr->setInfoOnComponent(0,std::string(COMPO_STR_TO_LOCATE_MESH_DA));
arr->iota();
f->setArray(arr);
f1tsMultiLev->setFieldNoProfileSBT(f);
}
//
- ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileFieldMultiTS> fmtsMultiLev(ParaMEDMEM::MEDFileFieldMultiTS::New());
+ MEDCoupling::MCAuto<MEDCoupling::MEDFileFieldMultiTS> fmtsMultiLev(MEDCoupling::MEDFileFieldMultiTS::New());
fmtsMultiLev->pushBackTimeStep(f1tsMultiLev);
ret->pushField(fmtsMultiLev);
}
}
-std::string MEDFileFieldRepresentationTree::BuildAUniqueArrayNameForMesh(const std::string& meshName, const ParaMEDMEM::MEDFileFields *ret)
+std::string MEDFileFieldRepresentationTree::BuildAUniqueArrayNameForMesh(const std::string& meshName, const MEDCoupling::MEDFileFields *ret)
{
const char KEY_STR_TO_AVOID_COLLIDE[]="MESH@";
if(!ret)
return tmpName;
}
-ParaMEDMEM::MEDFileFields *MEDFileFieldRepresentationTree::BuildFieldFromMeshes(const ParaMEDMEM::MEDFileMeshes *ms)
+MEDCoupling::MEDFileFields *MEDFileFieldRepresentationTree::BuildFieldFromMeshes(const MEDCoupling::MEDFileMeshes *ms)
{
- ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileFields> ret(ParaMEDMEM::MEDFileFields::New());
+ MEDCoupling::MCAuto<MEDCoupling::MEDFileFields> ret(MEDCoupling::MEDFileFields::New());
AppendFieldFromMeshes(ms,ret);
return ret.retn();
}
class ELGACmp
{
public:
- vtkIdTypeArray *findOrCreate(const ParaMEDMEM::MEDFileFieldGlobsReal *globs, const std::vector<std::string>& locsReallyUsed, vtkDoubleArray *vtkd, vtkDataSet *ds, bool& isNew) const;
+ vtkIdTypeArray *findOrCreate(const MEDCoupling::MEDFileFieldGlobsReal *globs, const std::vector<std::string>& locsReallyUsed, vtkDoubleArray *vtkd, vtkDataSet *ds, bool& isNew) const;
void appendELGAIfAny(vtkDataSet *ds) const;
~ELGACmp();
private:
vtkIdTypeArray *isExisting(const std::vector<std::string>& locsReallyUsed, vtkDoubleArray *vtkd) const;
- vtkIdTypeArray *createNew(const ParaMEDMEM::MEDFileFieldGlobsReal *globs, const std::vector<std::string>& locsReallyUsed, vtkDoubleArray *vtkd, vtkDataSet *ds) const;
+ vtkIdTypeArray *createNew(const MEDCoupling::MEDFileFieldGlobsReal *globs, const std::vector<std::string>& locsReallyUsed, vtkDoubleArray *vtkd, vtkDataSet *ds) const;
private:
//! size of _loc_names is equal to _elgas.
mutable std::vector< std::vector<std::string> > _loc_names;
mutable std::vector< std::vector< std::pair< vtkQuadratureSchemeDefinition *, unsigned char > > > _defs;
};
-class MEDLOADERFORPV_EXPORT MEDFileFieldRepresentationLeavesArrays : public ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileAnyTypeFieldMultiTS>
+class MEDLOADERFORPV_EXPORT MEDFileFieldRepresentationLeavesArrays : public MEDCoupling::MCAuto<MEDCoupling::MEDFileAnyTypeFieldMultiTS>
{
public:
MEDFileFieldRepresentationLeavesArrays();
- MEDFileFieldRepresentationLeavesArrays(const ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileAnyTypeFieldMultiTS>& arr);
+ MEDFileFieldRepresentationLeavesArrays(const MEDCoupling::MCAuto<MEDCoupling::MEDFileAnyTypeFieldMultiTS>& arr);
MEDFileFieldRepresentationLeavesArrays& operator=(const MEDFileFieldRepresentationLeavesArrays& other);
int getId() const;
void setId(int& id) const;
bool setStatus(bool status) const;
std::string getZeName() const;
const char *getZeNameC() const;
- void appendFields(const MEDTimeReq *tr, const ParaMEDMEM::MEDFileFieldGlobsReal *globs, const ParaMEDMEM::MEDMeshMultiLev *mml, const ParaMEDMEM::MEDFileMeshStruct *mst, vtkDataSet *ds) const;
+ void appendFields(const MEDTimeReq *tr, const MEDCoupling::MEDFileFieldGlobsReal *globs, const MEDCoupling::MEDMeshMultiLev *mml, const MEDCoupling::MEDFileMeshStruct *mst, vtkDataSet *ds) const;
void appendELGAIfAny(vtkDataSet *ds) const;
public:
static const char ZE_SEP[];
static const char NUM_ID_CELL_NAME[];
static const char FAMILY_ID_NODE_NAME[];
static const char NUM_ID_NODE_NAME[];
+ static const char GLOBAL_NODE_ID_NAME[];
private:
mutable bool _activated;
mutable int _id;
{
public:
MEDFileFieldRepresentationLeaves();
- MEDFileFieldRepresentationLeaves(const std::vector< ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileAnyTypeFieldMultiTS> >& arr,
- const ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileFastCellSupportComparator>& fsp);
+ MEDFileFieldRepresentationLeaves(const std::vector< MEDCoupling::MCAuto<MEDCoupling::MEDFileAnyTypeFieldMultiTS> >& arr,
+ const MEDCoupling::MCAuto<MEDCoupling::MEDFileFastCellSupportComparator>& fsp);
~MEDFileFieldRepresentationLeaves();
bool empty() const;
void setId(int& id) const;
std::string getMeshName() const;
int getNumberOfArrays() const;
int getNumberOfTS() const;
- void feedSIL(const ParaMEDMEM::MEDFileMeshes *ms, const std::string& meshName, vtkMutableDirectedGraph* sil, vtkIdType root, vtkVariantArray *edge, std::vector<std::string>& names) const;
+ void feedSIL(const MEDCoupling::MEDFileMeshes *ms, const std::string& meshName, vtkMutableDirectedGraph* sil, vtkIdType root, vtkVariantArray *edge, std::vector<std::string>& names) const;
void computeFullNameInLeaves(const std::string& tsName, const std::string& meshName, const std::string& comSupStr) const;
bool containId(int id) const;
bool containZeName(const char *name, int& id) const;
std::vector<double> getTimeSteps(const TimeKeeper& tk) const;
std::vector< std::pair<int,int> > getTimeStepsInCoarseMEDFileFormat(std::vector<double>& ts) const;
std::string getHumanReadableOverviewOfTS() const;
- vtkDataSet *buildVTKInstanceNoTimeInterpolation(const MEDTimeReq *tr, const ParaMEDMEM::MEDFileFieldGlobsReal *globs, const ParaMEDMEM::MEDFileMeshes *meshes) const;
+ vtkDataSet *buildVTKInstanceNoTimeInterpolation(const MEDTimeReq *tr, const MEDCoupling::MEDFileFieldGlobsReal *globs, const MEDCoupling::MEDFileMeshes *meshes) const;
private:
- vtkUnstructuredGrid *buildVTKInstanceNoTimeInterpolationUnstructured(ParaMEDMEM::MEDUMeshMultiLev *mm) const;
- vtkRectilinearGrid *buildVTKInstanceNoTimeInterpolationCartesian(ParaMEDMEM::MEDCMeshMultiLev *mm) const;
- vtkStructuredGrid *buildVTKInstanceNoTimeInterpolationCurveLinear(ParaMEDMEM::MEDCurveLinearMeshMultiLev *mm) const;
- void appendFields(const MEDTimeReq *tr, const ParaMEDMEM::MEDFileFieldGlobsReal *globs, const ParaMEDMEM::MEDMeshMultiLev *mml, const ParaMEDMEM::MEDFileMeshes *meshes, vtkDataSet *ds) const;
+ vtkUnstructuredGrid *buildVTKInstanceNoTimeInterpolationUnstructured(MEDCoupling::MEDUMeshMultiLev *mm) const;
+ vtkRectilinearGrid *buildVTKInstanceNoTimeInterpolationCartesian(MEDCoupling::MEDCMeshMultiLev *mm) const;
+ vtkStructuredGrid *buildVTKInstanceNoTimeInterpolationCurveLinear(MEDCoupling::MEDCurveLinearMeshMultiLev *mm) const;
+ void appendFields(const MEDTimeReq *tr, const MEDCoupling::MEDFileFieldGlobsReal *globs, const MEDCoupling::MEDMeshMultiLev *mml, const MEDCoupling::MEDFileMeshes *meshes, vtkDataSet *ds) const;
private:
std::vector<MEDFileFieldRepresentationLeavesArrays> _arrays;
- ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileFastCellSupportComparator> _fsp;
+ MEDCoupling::MCAuto<MEDCoupling::MEDFileFastCellSupportComparator> _fsp;
mutable vtkDataSet *_cached_ds;
};
private:
const MEDFileFieldRepresentationLeavesArrays& getLeafArr(int id) const;
const MEDFileFieldRepresentationLeaves& getTheSingleActivated(int& lev0, int& lev1, int& lev2) const;
- static ParaMEDMEM::MEDFileFields *BuildFieldFromMeshes(const ParaMEDMEM::MEDFileMeshes *ms);
- static void AppendFieldFromMeshes(const ParaMEDMEM::MEDFileMeshes *ms, ParaMEDMEM::MEDFileFields *ret);
- static std::string BuildAUniqueArrayNameForMesh(const std::string& meshName, const ParaMEDMEM::MEDFileFields *ret);
+ static MEDCoupling::MEDFileFields *BuildFieldFromMeshes(const MEDCoupling::MEDFileMeshes *ms);
+ static void AppendFieldFromMeshes(const MEDCoupling::MEDFileMeshes *ms, MEDCoupling::MEDFileFields *ret);
+ static std::string BuildAUniqueArrayNameForMesh(const std::string& meshName, const MEDCoupling::MEDFileFields *ret);
static std::vector<std::string> SplitFieldNameIntoParts(const std::string& fullFieldName, char sep);
private:
// 1st : timesteps, 2nd : meshName, 3rd : common support
std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > > _data_structure;
- ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileMeshes> _ms;
- ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileFields> _fields;
+ MEDCoupling::MCAuto<MEDCoupling::MEDFileMeshes> _ms;
+ MEDCoupling::MCAuto<MEDCoupling::MEDFileFields> _fields;
};
class MEDLOADERFORPV_EXPORT TimeKeeper
const std::map<int,INTERP_KERNEL::NormalizedCellType>::const_iterator it(m.find(vtkCt));
if(it==m.end())
{
- const unsigned char *pos(std::find(ParaMEDMEM::MEDMeshMultiLev::PARAMEDMEM_2_VTKTYPE,ParaMEDMEM::MEDMeshMultiLev::PARAMEDMEM_2_VTKTYPE+ParaMEDMEM::MEDMeshMultiLev::PARAMEDMEM_2_VTKTYPE_LGTH,vtkCt));
- if(pos==ParaMEDMEM::MEDMeshMultiLev::PARAMEDMEM_2_VTKTYPE+ParaMEDMEM::MEDMeshMultiLev::PARAMEDMEM_2_VTKTYPE_LGTH)
+ const unsigned char *pos(std::find(MEDCoupling::MEDMeshMultiLev::PARAMEDMEM_2_VTKTYPE,MEDCoupling::MEDMeshMultiLev::PARAMEDMEM_2_VTKTYPE+MEDCoupling::MEDMeshMultiLev::PARAMEDMEM_2_VTKTYPE_LGTH,vtkCt));
+ if(pos==MEDCoupling::MEDMeshMultiLev::PARAMEDMEM_2_VTKTYPE+MEDCoupling::MEDMeshMultiLev::PARAMEDMEM_2_VTKTYPE_LGTH)
{
vtkDebugMacro("vtkExtractCellType::RequestInformation : cell #" << cellId << " has unrecognized type !");
return 0;
}
- m[vtkCt]=(INTERP_KERNEL::NormalizedCellType)std::distance(ParaMEDMEM::MEDMeshMultiLev::PARAMEDMEM_2_VTKTYPE,pos);
+ m[vtkCt]=(INTERP_KERNEL::NormalizedCellType)std::distance(MEDCoupling::MEDMeshMultiLev::PARAMEDMEM_2_VTKTYPE,pos);
}
}
this->Internal->loadFrom(m);
{
static const char ZE_KEY[]="vtkMEDReader::META_DATA";
vtkInformationDataObjectMetaDataKey *ret(vtkMEDReader_META_DATA);
- ParaMEDMEM::GlobalDict *gd(ParaMEDMEM::GlobalDict::GetInstance());
+ MEDCoupling::GlobalDict *gd(MEDCoupling::GlobalDict::GetInstance());
if(!gd->hasKey(ZE_KEY))
{// here META_DATA is put on global var to be exchanged with other filters without dependancy of MEDReader. Please do not change ZE_KEY !
std::ostringstream oss; oss << ret;
IF(PARAVIEW_BUILD_QT_GUI)
- QT4_WRAP_UI(CLIENT_UI_SRCS
+ QT_WRAP_UIC(CLIENT_UI_SRCS
Resources/UI/MEDReaderVectorsWidget.ui
Resources/UI/MEDReaderTimeModeWidget.ui)
pqMEDReaderTimesFlagsWidget.cxx
pqMEDReaderFieldsWidget.cxx)
- QT4_WRAP_CPP(MOC_SRCS
+ QT_WRAP_MOC(MOC_SRCS
pqExtractGroupFieldsWidget.h
pqAbstractFieldsWidget.h
VectBoolSpreadSheet.h
this->verticalHeader()->setMinimumSectionSize(2);
this->verticalHeader()->setDefaultSectionSize(2);
this->setItemDelegate(_delegate);
+#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
this->verticalHeader()->setResizeMode(QHeaderView::ResizeToContents);
this->horizontalHeader()->setResizeMode(QHeaderView::ResizeToContents);
+#else
+ this->verticalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
+ this->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
+#endif
this->resizeColumnsToContents();
this->resizeRowsToContents();
//this->verticalHeader()->hide();
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-SET(TEST_NUMBERS 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20)
+SET(TEST_NUMBERS 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21)
SET(TEST_INSTALL_DIRECTORY ${SALOME_INSTALL_SCRIPT_SCRIPTS}/test/MEDReader)
+SET(BASELINES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Baselines")
IF(KW_TESTING_PLATFORM)
-FOREACH(tfile ${TEST_NUMBERS})
- INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/testMEDReader${tfile}.py
- DESTINATION ${TEST_INSTALL_DIRECTORY})
-ENDFOREACH()
-
- INSTALL(FILES CTestTestfileInstall.cmake
- DESTINATION ${TEST_INSTALL_DIRECTORY}
- RENAME CTestTestfile.cmake)
-
cmake_minimum_required(VERSION 2.7)
find_package(ParaView REQUIRED)
set(PARAVIEW_SERVER "${PARAVIEW_BIN_DIR}/pvserver")
set(PVPYTHON "${PARAVIEW_BIN_DIR}/pvpython")
-set(BASELINES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Baselines")
set(PYTHON_SCRIPTS_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
set(TEMP_DIR "${CMAKE_CURRENT_BINARY_DIR}/Testing/Temporary")
-# Application tests
-SET(TEST_INSTALL_DIRECTORY ${SALOME_INSTALL_SCRIPT_SCRIPTS}/test/MEDReader)
-
if(NOT EXISTS ${TEMP_DIR})
file(MAKE_DIRECTORY ${TEMP_DIR})
endif()
SALOME_GENERATE_TESTS_ENVIRONMENT(tests_env)
FOREACH(tfile ${TEST_NUMBERS})
- ADD_TEST(testMEDReader${tfile} ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/testMEDReader${tfile}.py -B ${CMAKE_CURRENT_SOURCE_DIR}/Baselines )
+ ADD_TEST(testMEDReader${tfile} ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/testMEDReader${tfile}.py -B ${BASELINES_DIR} )
SET_TESTS_PROPERTIES(testMEDReader${tfile} PROPERTIES ENVIRONMENT "${tests_env}")
ENDFOREACH()
ENDIF(KW_TESTING_PLATFORM)
+
+# Application tests
+FOREACH(tfile ${TEST_NUMBERS})
+ INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/testMEDReader${tfile}.py
+ DESTINATION ${TEST_INSTALL_DIRECTORY})
+ENDFOREACH()
+
+FILE(GLOB BASELINE_FILES "${BASELINES_DIR}/*")
+FOREACH(baseline_file ${BASELINE_FILES})
+ INSTALL(FILES ${baseline_file} DESTINATION ${TEST_INSTALL_DIRECTORY}/Baselines)
+ENDFOREACH()
+
INSTALL(FILES CTestTestfileInstall.cmake
DESTINATION ${TEST_INSTALL_DIRECTORY}
RENAME CTestTestfile.cmake)
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-SET(SALOME_TEST_DRIVER "$ENV{ABSOLUTE_APPLI_PATH}/bin/salome/appliskel/salome_test_driver.py")
SET(COMPONENT_NAME MEDREADER)
-SET(TIMEOUT 30)
+SET(TIMEOUT 60)
-SET(TEST_NUMBERS 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18)
+SET(TEST_NUMBERS 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20)
+set(BASELINES_DIR "Baselines")
FOREACH(tfile ${TEST_NUMBERS})
SET(TEST_NAME MEDREADER_${tfile})
- ADD_TEST(${TEST_NAME} python testMEDReader${tfile}.py)
- #ADD_TEST(${TEST_NAME} python ${SALOME_TEST_DRIVER} ${TIMEOUT} testMEDReader${tfile}.py)
- SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
+ ADD_TEST(${TEST_NAME} python testMEDReader${tfile}.py -B ${BASELINES_DIR})
+ SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}" TIMEOUT ${TIMEOUT})
ENDFOREACH()
f0z.setArray(arr0)
f0z.setGaussLocalizationOnType(NORM_QUAD9,[-1,-1,1,-1,1,1,-1,1,0,-1,1,0,0,1,-1,0,0,0],[-0.774597,-0.774597,0.774597,-0.774597,0.774597,0.774597,-0.774597,0.774597,0,-0.774597,0.774597,0,0,0.774597,-0.774597,0,0,0,-0.774597,-0.774597,0.774597,-0.774597,0.774597,0.774597,-0.774597,0.774597,0,-0.774597,0.774597,0,0,0.774597,-0.774597,0,0,0,-0.774597,-0.774597,0.774597,-0.774597,0.774597,0.774597,-0.774597,0.774597,0,-0.774597,0.774597,0,0,0.774597,-0.774597,0,0,0],[0.308642,0.308642,0.308642,0.308642,0.493827,0.493827,0.493827,0.493827,0.790123,0.308642,0.308642,0.308642,0.308642,0.493827,0.493827,0.493827,0.493827,0.790123,0.308642,0.308642,0.308642,0.308642,0.493827,0.493827,0.493827,0.493827,0.790123])
f0z.setName("SolutionSIEF_ELGA")
-f0z.checkCoherency()
+f0z.checkConsistencyLight()
ff0z=MEDFileField1TS()
ff0z.setFieldNoProfileSBT(f0z)
#
f1z=MEDCouplingFieldDouble(ON_GAUSS_NE) ; f1z.setName("SolutionSIEQ_ELNO")
f1z.setArray(arr1)
f1z.setMesh(mz)
-f1z.checkCoherency()
+f1z.checkConsistencyLight()
ff1z=MEDFileField1TS()
ff1z.setFieldNoProfileSBT(f1z)
#
arr2.setInfoOnComponents(['DRX','DRZ'])
f2z=MEDCouplingFieldDouble(ON_NODES) ; f2z.setName("SolutionDEPL") ; f2z.setArray(arr2)
f2z.setMesh(mz)
-f2z.checkCoherency()
+f2z.checkConsistencyLight()
ff2z=MEDFileField1TS()
ff2z.setFieldNoProfileSBT(f2z)
#
m.insertNextCell(NORM_QUAD4,[0,5,3,2])
m.insertNextCell(NORM_QUAD4,[4,2,3,1])
m.finishInsertingCells()
-MEDLoader.WriteMesh(fname,m,True)
+WriteMesh(fname,m,True)
#
f0=MEDCouplingFieldDouble(ON_GAUSS_NE) ; f0.setMesh(m) ; f0.setTimeUnit("ms")
f0.setTime(1.1,1,1)
f0.setName("myELNOField")
arr=DataArrayDouble([7,5,3,1,5,3,1,7]) ; arr.setInfoOnComponent(0,"Comp0")
f0.setArray(arr)
-MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f0)
+WriteFieldUsingAlreadyWrittenMesh(fname,f0)
#
f0.setTime(2.2,2,1)
arr=DataArrayDouble([1,7,5,3,7,5,3,1]) ; arr.setInfoOnComponent(0,"Comp0")
f0.setArray(arr)
-MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f0)
+WriteFieldUsingAlreadyWrittenMesh(fname,f0)
#
f0.setTime(3.3,3,1)
arr=DataArrayDouble([3,1,7,5,1,7,5,3]) ; arr.setInfoOnComponent(0,"Comp0")
f0.setArray(arr)
-MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f0)
+WriteFieldUsingAlreadyWrittenMesh(fname,f0)
#
f0.setTime(4.4,4,1)
arr=DataArrayDouble([5,3,1,7,3,1,7,5]) ; arr.setInfoOnComponent(0,"Comp0")
f0.setArray(arr)
-MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f0)
+WriteFieldUsingAlreadyWrittenMesh(fname,f0)
arr.setInfoOnComponents(["1st","2nd","3rd","4th"])
f3.setArray(arr)
#
-MEDLoader.WriteMesh(fname,m,True)
-MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f0)
-MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f1)
-MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f2)
-MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f3)
+WriteMesh(fname,m,True)
+WriteFieldUsingAlreadyWrittenMesh(fname,f0)
+WriteFieldUsingAlreadyWrittenMesh(fname,f1)
+WriteFieldUsingAlreadyWrittenMesh(fname,f2)
+WriteFieldUsingAlreadyWrittenMesh(fname,f3)
################### MED write is done -> Go to MEDReader
from paraview.simple import *
f1ts0=MEDFileField1TS()
f=MEDCouplingFieldDouble(ON_CELLS) ; f.setName(name) ; f.setTime(ft,dt,it) ; f.setMesh(sup)
f.setArray(arrs[its])
- f.checkCoherency()
+ f.checkConsistencyLight()
f1ts0.setFieldProfile(f,mm,0,pfl0)
fmts0.pushBackTimeStep(f1ts0)
pass
f=MEDCouplingFieldDouble(ON_GAUSS_NE) ; f.setName("fieldELNO") ; f.setMesh(m)
arr=DataArrayDouble([0.2,1.1,0.7,0.5,-0.3,0.4])
f.setArray(DataArrayDouble.Meld(4*[arr]))
-f.checkCoherency()
-MEDLoader.WriteField(fname,f,True)
+f.checkConsistencyLight()
+WriteField(fname,f,True)
################### MED write is done -> Go to MEDReader
fNode.setGaussLocalizationOnCells(DataArrayInt.Range(0,12,1),[0.,0.,1.,0.,0.,1.],[0.1,0.1,0.8,0.1,0.1,0.8],3*[0.16666666666666666])
fNode.setGaussLocalizationOnCells(DataArrayInt.Range(12,24,1),[-1.,-1.,1.,-1.,1.,1.,-1.,1.],[-0.577350,-0.577350,0.577350,-0.577350,0.577350,0.577350,-0.577350,0.577350],4*[1.])
arr=DataArrayDouble(2*(12*3+12*4)) ; arr.iota(0+1000*i) ; arr.rearrange(2)
- fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"]) ; fNode.checkCoherency()
+ fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"]) ; fNode.checkConsistencyLight()
fNode.setName(fieldName0)
f.setFieldProfile(fNode,mm,0,zePfl0)
#
fNode.setGaussLocalizationOnCells(DataArrayInt.Range(4,10,1),[-1.,1.],[-0.5,0.,0.5],[1.,1.,1.])
fNode.setGaussLocalizationOnCells(DataArrayInt.Range(10,14,1),[-1.,1.],[-0.6,-0.2,0.2,0.6],[1.,1.,1.,1.])
arr=DataArrayDouble(2*(4*2+6*3+4*4)) ; arr.iota(100+1000*i) ; arr.rearrange(2)
- fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"]) ; fNode.checkCoherency()
+ fNode.setArray(arr) ; arr.setInfoOnComponents(["Comp1_2 [m]","Com2_2 [s^2]"]) ; fNode.checkConsistencyLight()
fNode.setName(fieldName0)
f.setFieldProfile(fNode,mm,-1,zePfl1)
fs0.pushBackTimeStep(f)
fNode.setGaussLocalizationOnCells(DataArrayInt.Range(0,4,1),[-1.,1.],[-0.6,-0.2,0.2,0.6],[1.,1.,1.,1.])
fNode.setGaussLocalizationOnCells(DataArrayInt.Range(4,10,1),[-1.,1.],[-0.6666666666666667,-0.33333333333333337,0.,0.33333333333333337,0.6666666666666667],[1.,1.,1.,1.,1.])
arr=DataArrayDouble(2*(4*4+6*5)) ; arr.iota(500+1000*i) ; arr.rearrange(2)
- fNode.setArray(arr) ; arr.setInfoOnComponents(["C1 [m]","C2 [s^2]"]) ; fNode.checkCoherency()
+ fNode.setArray(arr) ; arr.setInfoOnComponents(["C1 [m]","C2 [s^2]"]) ; fNode.checkConsistencyLight()
f.setFieldProfile(fNode,mm,-1,zePfl2)
fs1.pushBackTimeStep(f)
#
f.setArray(DataArrayDouble([(-1.,1.,0.),(0.,1.,0.),(1.,1.,0.)]))
tmp=MEDCouplingUMesh.Build0DMeshFromCoords(m.getCoords()) ; tmp.setName(zeName)
f.setMesh(tmp)
-MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f)
+WriteFieldUsingAlreadyWrittenMesh(fname,f)
#
from paraview.simple import *
mm.setGroupsAtLevel(0,[grp0,grp1,grp2,grp3])
f=MEDCouplingFieldDouble(ON_GAUSS_NE) ; f.setMesh(m) ; f.setName("MyField") ; f.setTime(0.,0,0)
arr2=DataArrayDouble(4*4*2) ; arr2.iota() ; arr2.rearrange(2) ; arr2.setInfoOnComponents(["aa","bbb"])
-f.setArray(arr2) ; arr2+=0.1 ; f.checkCoherency()
+f.setArray(arr2) ; arr2+=0.1 ; f.checkConsistencyLight()
mm.write(fname,2)
-MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f)
+WriteFieldUsingAlreadyWrittenMesh(fname,f)
#
from paraview.simple import *
from paraview import servermanager
mm.setGroupsAtLevel(0,[grp0,grp1,grp2,grp3])
f=MEDCouplingFieldDouble(ON_GAUSS_NE) ; f.setMesh(m) ; f.setName("MyField") ; f.setTime(0.,0,0)
arr2=DataArrayDouble(4*4*2) ; arr2.iota() ; arr2.rearrange(2) ; arr2.setInfoOnComponents(["aa","bbb"])
-f.setArray(arr2) ; arr2+=0.1 ; f.checkCoherency()
+f.setArray(arr2) ; arr2+=0.1 ; f.checkConsistencyLight()
mm.write(fname,2)
-MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fname,f)
+WriteFieldUsingAlreadyWrittenMesh(fname,f)
#
from paraview.simple import *
from paraview import servermanager
pfl=DataArrayInt([7,8,9,10,13,14,15,16,19,20,21,22,25,26,27,28]) ; pfl.setName("pfl")
f=MEDCouplingFieldDouble(ON_CELLS) ; f.setName("ACellField")
arr=DataArrayDouble(16) ; arr.iota()
-arr2=arr.deepCpy() ; arr2.reverse()
+arr2=arr.deepCopy() ; arr2.reverse()
arr=DataArrayDouble.Meld(arr,arr2) ; arr.setInfoOnComponents(["aa","bbb"])
f.setArray(arr)
f1ts=MEDFileField1TS()
# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2015-2016 CEA/DEN, EDF R&D
+# Copyright (C) 2016 CEA/DEN, EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
#
# Author : Anthony Geay (EDF R&D)
-from paraview.simple import *
+# non regression test that emulates https://ageay@git.salome-platform.org/gitpub/samples/datafiles.git Med/ResOK_0000.med
+# This test point error during commit efd9331a9455785d0f04b75 in PARAVIS
from MEDLoader import *
-
-""" This is a non regression EDF12599"""
fname="testMEDReader20.med"
-imgName="testMEDReader20.png"
-fieldName="MyField"
-meshName="mesh"
-m=MEDFileUMesh()
-m0=MEDCouplingUMesh(meshName,1)
-m0.setCoords(DataArrayDouble([(0.,0.,0),(1.,0.,0.),(2.,0.,0.)]))
-m0.allocateCells()
-m0.insertNextCell(NORM_SEG2,[0,1])
-m0.insertNextCell(NORM_SEG2,[1,2])
-m[0]=m0
+png="testMEDReader20.png"
+nb=10
+arrX=DataArrayDouble(nb+1) ; arrX.iota()
+arrY=DataArrayDouble([0.,1.])
+m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY) ; m=m.buildUnstructured(); m.setName("mesh") ; m.simplexize(0)
+mm=MEDFileUMesh() ; mm[0]=m
+m1=m.computeSkin() ; mm[-1]=m1
#
-f=MEDCouplingFieldDouble(ON_GAUSS_NE) ; f.setName(fieldName)
-f.setMesh(m0) ; f.setArray(DataArrayDouble([1.,7.,3.,2.]))
-MEDLoader.WriteField(fname,f,True)
-########
-testTotomed = MEDReader(FileName=fname)
-testTotomed.AllArrays = ['TS0/%s/ComSup0/%s@@][@@GSSNE'%(meshName,fieldName)]
-testTotomed.AllTimeSteps = ['0000']
+f0=DataArrayInt(m1.getNumberOfCells()) ; f0.iota() ; mm.setFamilyFieldArr(-1,f0)
+f1=DataArrayInt(m1.getNumberOfNodes()) ; f1.iota() ; mm.setFamilyFieldArr(1,f1) # <- very important the bug can be shown here
+#
+nbCells=m1.getNumberOfCells() ; nbNodes=m.getNumberOfNodes()
+mm.write(fname,2)
+for i in range(5):
+ f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(m)
+ f.setName("Field")
+ arr=DataArrayInt(2*nb) ; arr.iota(i) ; arr%=nb ; arr=arr.convertToDblArr()
+ f.setArray(arr) ; f.setTime(float(i),i,0)
+ WriteFieldUsingAlreadyWrittenMesh(fname,f)
+ #
+ f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(m1)
+ f.setName("Field")
+ arr=DataArrayInt(nbCells) ; arr.iota(i) ; arr%=nbCells ; arr=arr.convertToDblArr()
+ f.setArray(arr) ; f.setTime(float(i),i,0)
+ WriteFieldUsingAlreadyWrittenMesh(fname,f)
+ #
+ f=MEDCouplingFieldDouble(ON_NODES) ; f.setMesh(m)
+ f.setName("FieldNode")
+ arr=DataArrayDouble(nbNodes) ; arr[:]=float(i)
+ f.setArray(arr) ; f.setTime(float(i),i,0)
+ WriteFieldUsingAlreadyWrittenMesh(fname,f)
+ pass
+#####################
+from paraview.simple import *
+#### disable automatic camera reset on 'Show'
+paraview.simple._DisableFirstRenderCameraReset()
+
+# create a new 'MED Reader'
+testMEDReader20med = MEDReader(FileName=fname)
+testMEDReader20med.AllArrays = ['TS0/mesh/ComSup0/Field@@][@@P0']
+testMEDReader20med.AllTimeSteps = ['0000', '0001', '0002', '0003', '0004']
+
+# get animation scene
+animationScene1 = GetAnimationScene()
+
+# update animation scene based on data timesteps
+animationScene1.UpdateAnimationUsingDataTimeSteps()
+
# get active view
renderView1 = GetActiveViewOrCreate('RenderView')
# uncomment following to set a specific view size
-# renderView1.ViewSize = [739, 503]
+# renderView1.ViewSize = [610, 477]
# show data in view
-testTotomedDisplay = Show(testTotomed, renderView1)
+testMEDReader20medDisplay = Show(testMEDReader20med, renderView1)
# trace defaults for the display properties.
-testTotomedDisplay.ColorArrayName = [None, '']
-testTotomedDisplay.GlyphType = 'Arrow'
-testTotomedDisplay.ScalarOpacityUnitDistance = 1.5874010519681994
-testTotomedDisplay.SelectUncertaintyArray = [None, '']
-testTotomedDisplay.UncertaintyTransferFunction = 'PiecewiseFunction'
-testTotomedDisplay.OpacityArray = [None, '']
-testTotomedDisplay.RadiusArray = [None, '']
-testTotomedDisplay.RadiusRange = [0.0, 2.0]
-testTotomedDisplay.ConstantRadius = 2.0
-testTotomedDisplay.PointSpriteDefaultsInitialized = 1
-testTotomedDisplay.SelectInputVectors = [None, '']
-testTotomedDisplay.WriteLog = ''
+testMEDReader20medDisplay.ColorArrayName = [None, '']
+testMEDReader20medDisplay.GlyphType = 'Arrow'
+testMEDReader20medDisplay.ScalarOpacityUnitDistance = 4.664739046219201
+testMEDReader20medDisplay.SelectUncertaintyArray = [None, '']
+testMEDReader20medDisplay.UncertaintyTransferFunction = 'PiecewiseFunction'
+testMEDReader20medDisplay.OpacityArray = [None, '']
+testMEDReader20medDisplay.RadiusArray = [None, '']
+testMEDReader20medDisplay.RadiusRange = [0.0, 10.0]
+testMEDReader20medDisplay.ConstantRadius = 10.0
+testMEDReader20medDisplay.PointSpriteDefaultsInitialized = 1
+testMEDReader20medDisplay.SelectInputVectors = [None, '']
+testMEDReader20medDisplay.WriteLog = ''
# reset view to fit data
renderView1.ResetCamera()
#changing interaction mode based on data extents
renderView1.InteractionMode = '2D'
-renderView1.CameraPosition = [1.0, 10000.0, 10000.0]
-renderView1.CameraFocalPoint = [1.0, 0.0, 0.0]
-renderView1.CameraViewUp = [1.0, 1.0, 0.0]
+renderView1.CameraPosition = [5.0, 0.5, 10000.0]
+renderView1.CameraFocalPoint = [5.0, 0.5, 0.0]
# set scalar coloring
-ColorBy(testTotomedDisplay, ('FIELD', 'vtkBlockColors'))
+ColorBy(testMEDReader20medDisplay, ('FIELD', 'vtkBlockColors'))
# show color bar/color legend
-testTotomedDisplay.SetScalarBarVisibility(renderView1, True)
+testMEDReader20medDisplay.SetScalarBarVisibility(renderView1, True)
# get color transfer function/color map for 'vtkBlockColors'
vtkBlockColorsLUT = GetColorTransferFunction('vtkBlockColors')
# get opacity transfer function/opacity map for 'vtkBlockColors'
vtkBlockColorsPWF = GetOpacityTransferFunction('vtkBlockColors')
-# create a new 'ELNO Mesh'
-eLNOMesh1 = ELNOMesh(Input=testTotomed)
-
-# Properties modified on eLNOMesh1
-eLNOMesh1.ShrinkFactor = 0.5 # <- test is here !!!!!!!!
-
-# show data in view
-eLNOMesh1Display = Show(eLNOMesh1, renderView1)
-# trace defaults for the display properties.
-eLNOMesh1Display.ColorArrayName = [None, '']
-eLNOMesh1Display.GlyphType = 'Arrow'
-eLNOMesh1Display.ScalarOpacityUnitDistance = 1.1905507889761495
-eLNOMesh1Display.SelectUncertaintyArray = ['POINTS', 'MyField']
-eLNOMesh1Display.UncertaintyTransferFunction = 'PiecewiseFunction'
-eLNOMesh1Display.OpacityArray = [None, '']
-eLNOMesh1Display.RadiusArray = [None, '']
-eLNOMesh1Display.RadiusRange = [0.25, 1.75]
-eLNOMesh1Display.ConstantRadius = 1.75
-eLNOMesh1Display.PointSpriteDefaultsInitialized = 1
-eLNOMesh1Display.SelectInputVectors = [None, '']
-eLNOMesh1Display.WriteLog = ''
-
-# hide data in view
-Hide(testTotomed, renderView1)
-
# set scalar coloring
-ColorBy(eLNOMesh1Display, ('FIELD', 'vtkBlockColors'))
-
-# show color bar/color legend
-eLNOMesh1Display.SetScalarBarVisibility(renderView1, False)
-
-# set scalar coloring
-ColorBy(eLNOMesh1Display, ('POINTS', 'MyField'))
+ColorBy(testMEDReader20medDisplay, ('CELLS', 'Field'))
# rescale color and/or opacity maps used to include current data range
-eLNOMesh1Display.RescaleTransferFunctionToDataRange(True)
+testMEDReader20medDisplay.RescaleTransferFunctionToDataRange(True)
# show color bar/color legend
-eLNOMesh1Display.SetScalarBarVisibility(renderView1, False)
+testMEDReader20medDisplay.SetScalarBarVisibility(renderView1, True)
-# get color transfer function/color map for 'MyField'
-myFieldLUT = GetColorTransferFunction('MyField')
+# get color transfer function/color map for 'Field'
+fieldLUT = GetColorTransferFunction('Field')
-# get opacity transfer function/opacity map for 'MyField'
-myFieldPWF = GetOpacityTransferFunction('MyField')
+# get opacity transfer function/opacity map for 'Field'
+fieldPWF = GetOpacityTransferFunction('Field')
-# hide color bar/color legend
-eLNOMesh1Display.SetScalarBarVisibility(renderView1, False)
+animationScene1.GoToNext() # <- very important to see the bug play with time steps...
+animationScene1.GoToNext()
+animationScene1.GoToNext()
+animationScene1.GoToNext()
+animationScene1.GoToPrevious()
+animationScene1.GoToPrevious()
-# create a new 'Glyph'
-glyph1 = Glyph(Input=eLNOMesh1,
- GlyphType='Arrow')
-glyph1.Scalars = ['POINTS', 'MyField']
-glyph1.Vectors = ['POINTS', 'None']
-glyph1.ScaleFactor = 0.15000000000000002
-glyph1.GlyphTransform = 'Transform2'
-
-# Properties modified on glyph1
-glyph1.GlyphType = 'Sphere'
-glyph1.ScaleFactor = 0.15
+# current camera placement for renderView1
+renderView1.InteractionMode = '2D'
+renderView1.CameraPosition = [5.0, 0.5, 10000.0]
+renderView1.CameraFocalPoint = [5.0, 0.5, 0.0]
+renderView1.CameraParallelScale = 5.024937810560445
-# show data in view
-glyph1Display = Show(glyph1, renderView1)
-# trace defaults for the display properties.
-glyph1Display.ColorArrayName = ['POINTS', 'MyField']
-glyph1Display.LookupTable = myFieldLUT
-glyph1Display.GlyphType = 'Arrow'
-glyph1Display.SelectUncertaintyArray = ['POINTS', 'MyField']
-glyph1Display.UncertaintyTransferFunction = 'PiecewiseFunction'
-glyph1Display.OpacityArray = [None, '']
-glyph1Display.RadiusArray = [None, '']
-glyph1Display.RadiusRange = [0.17688040435314178, 1.8231196403503418]
-glyph1Display.ConstantRadius = 1.8231196403503418
-glyph1Display.PointSpriteDefaultsInitialized = 1
-glyph1Display.SelectInputVectors = ['POINTS', 'Normals']
-glyph1Display.WriteLog = ''
+#
-# show color bar/color legend
-glyph1Display.SetScalarBarVisibility(renderView1, True)
+renderView1.ViewSize =[300,300]
+Render()
+#WriteImage(png)
#### saving camera placements for all active views
# current camera placement for renderView1
renderView1.InteractionMode = '2D'
-renderView1.CameraPosition = [0.9999999999999908, 9999.999999999995, 9999.999999999993]
-renderView1.CameraFocalPoint = [1.0, 0.0, 0.0]
-renderView1.CameraViewUp = [0.6331899945158901, 0.547298104713038, -0.5472981047130381]
-renderView1.CameraParallelScale = 0.6930835077290218
-renderView1.ViewSize = [739,503]
-
+renderView1.CameraPosition = [5.0, 0.5, 10000.0]
+renderView1.CameraFocalPoint = [5.0, 0.5, 0.0]
+renderView1.CameraParallelScale = 5.024937810560445
+# compare with baseline image
import os
import sys
try:
except:
print "Could not get baseline directory. Test failed."
exit(1)
-baseline_file = os.path.join(baselinePath, imgName)
+baseline_file = os.path.join(baselinePath,png)
import vtk.test.Testing
vtk.test.Testing.VTK_TEMP_DIR = vtk.util.misc.vtkGetTempDir()
vtk.test.Testing.compareImage(GetActiveView().GetRenderWindow(), baseline_file, threshold=25)
vtk.test.Testing.interact()
-
--- /dev/null
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2015-2016 CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+# Author : Anthony Geay (EDF R&D)
+
+from paraview.simple import *
+
+from MEDLoader import *
+
+""" This is a non regression EDF12599"""
+fname="testMEDReader21.med"
+imgName="testMEDReader21.png"
+fieldName="MyField"
+meshName="mesh"
+m=MEDFileUMesh()
+m0=MEDCouplingUMesh(meshName,1)
+m0.setCoords(DataArrayDouble([(0.,0.,0),(1.,0.,0.),(2.,0.,0.)]))
+m0.allocateCells()
+m0.insertNextCell(NORM_SEG2,[0,1])
+m0.insertNextCell(NORM_SEG2,[1,2])
+m[0]=m0
+#
+f=MEDCouplingFieldDouble(ON_GAUSS_NE) ; f.setName(fieldName)
+f.setMesh(m0) ; f.setArray(DataArrayDouble([1.,7.,3.,2.]))
+WriteField(fname,f,True)
+########
+testTotomed = MEDReader(FileName=fname)
+testTotomed.AllArrays = ['TS0/%s/ComSup0/%s@@][@@GSSNE'%(meshName,fieldName)]
+testTotomed.AllTimeSteps = ['0000']
+# get active view
+renderView1 = GetActiveViewOrCreate('RenderView')
+# uncomment following to set a specific view size
+# renderView1.ViewSize = [739, 503]
+
+# show data in view
+testTotomedDisplay = Show(testTotomed, renderView1)
+# trace defaults for the display properties.
+testTotomedDisplay.ColorArrayName = [None, '']
+testTotomedDisplay.GlyphType = 'Arrow'
+testTotomedDisplay.ScalarOpacityUnitDistance = 1.5874010519681994
+testTotomedDisplay.SelectUncertaintyArray = [None, '']
+testTotomedDisplay.UncertaintyTransferFunction = 'PiecewiseFunction'
+testTotomedDisplay.OpacityArray = [None, '']
+testTotomedDisplay.RadiusArray = [None, '']
+testTotomedDisplay.RadiusRange = [0.0, 2.0]
+testTotomedDisplay.ConstantRadius = 2.0
+testTotomedDisplay.PointSpriteDefaultsInitialized = 1
+testTotomedDisplay.SelectInputVectors = [None, '']
+testTotomedDisplay.WriteLog = ''
+
+# reset view to fit data
+renderView1.ResetCamera()
+
+#changing interaction mode based on data extents
+renderView1.InteractionMode = '2D'
+renderView1.CameraPosition = [1.0, 10000.0, 10000.0]
+renderView1.CameraFocalPoint = [1.0, 0.0, 0.0]
+renderView1.CameraViewUp = [1.0, 1.0, 0.0]
+
+# set scalar coloring
+ColorBy(testTotomedDisplay, ('FIELD', 'vtkBlockColors'))
+
+# show color bar/color legend
+testTotomedDisplay.SetScalarBarVisibility(renderView1, True)
+
+# get color transfer function/color map for 'vtkBlockColors'
+vtkBlockColorsLUT = GetColorTransferFunction('vtkBlockColors')
+
+# get opacity transfer function/opacity map for 'vtkBlockColors'
+vtkBlockColorsPWF = GetOpacityTransferFunction('vtkBlockColors')
+
+# create a new 'ELNO Mesh'
+eLNOMesh1 = ELNOMesh(Input=testTotomed)
+
+# Properties modified on eLNOMesh1
+eLNOMesh1.ShrinkFactor = 0.5 # <- test is here !!!!!!!!
+
+# show data in view
+eLNOMesh1Display = Show(eLNOMesh1, renderView1)
+# trace defaults for the display properties.
+eLNOMesh1Display.ColorArrayName = [None, '']
+eLNOMesh1Display.GlyphType = 'Arrow'
+eLNOMesh1Display.ScalarOpacityUnitDistance = 1.1905507889761495
+eLNOMesh1Display.SelectUncertaintyArray = ['POINTS', 'MyField']
+eLNOMesh1Display.UncertaintyTransferFunction = 'PiecewiseFunction'
+eLNOMesh1Display.OpacityArray = [None, '']
+eLNOMesh1Display.RadiusArray = [None, '']
+eLNOMesh1Display.RadiusRange = [0.25, 1.75]
+eLNOMesh1Display.ConstantRadius = 1.75
+eLNOMesh1Display.PointSpriteDefaultsInitialized = 1
+eLNOMesh1Display.SelectInputVectors = [None, '']
+eLNOMesh1Display.WriteLog = ''
+
+# hide data in view
+Hide(testTotomed, renderView1)
+
+# set scalar coloring
+ColorBy(eLNOMesh1Display, ('FIELD', 'vtkBlockColors'))
+
+# show color bar/color legend
+eLNOMesh1Display.SetScalarBarVisibility(renderView1, False)
+
+# set scalar coloring
+ColorBy(eLNOMesh1Display, ('POINTS', 'MyField'))
+
+# rescale color and/or opacity maps used to include current data range
+eLNOMesh1Display.RescaleTransferFunctionToDataRange(True)
+
+# show color bar/color legend
+eLNOMesh1Display.SetScalarBarVisibility(renderView1, False)
+
+# get color transfer function/color map for 'MyField'
+myFieldLUT = GetColorTransferFunction('MyField')
+
+# get opacity transfer function/opacity map for 'MyField'
+myFieldPWF = GetOpacityTransferFunction('MyField')
+
+# hide color bar/color legend
+eLNOMesh1Display.SetScalarBarVisibility(renderView1, False)
+
+# create a new 'Glyph'
+glyph1 = Glyph(Input=eLNOMesh1,
+ GlyphType='Arrow')
+glyph1.Scalars = ['POINTS', 'MyField']
+glyph1.Vectors = ['POINTS', 'None']
+glyph1.ScaleFactor = 0.15000000000000002
+glyph1.GlyphTransform = 'Transform2'
+
+# Properties modified on glyph1
+glyph1.GlyphType = 'Sphere'
+glyph1.ScaleFactor = 0.15
+
+# show data in view
+glyph1Display = Show(glyph1, renderView1)
+# trace defaults for the display properties.
+glyph1Display.ColorArrayName = ['POINTS', 'MyField']
+glyph1Display.LookupTable = myFieldLUT
+glyph1Display.GlyphType = 'Arrow'
+glyph1Display.SelectUncertaintyArray = ['POINTS', 'MyField']
+glyph1Display.UncertaintyTransferFunction = 'PiecewiseFunction'
+glyph1Display.OpacityArray = [None, '']
+glyph1Display.RadiusArray = [None, '']
+glyph1Display.RadiusRange = [0.17688040435314178, 1.8231196403503418]
+glyph1Display.ConstantRadius = 1.8231196403503418
+glyph1Display.PointSpriteDefaultsInitialized = 1
+glyph1Display.SelectInputVectors = ['POINTS', 'Normals']
+glyph1Display.WriteLog = ''
+
+# show color bar/color legend
+glyph1Display.SetScalarBarVisibility(renderView1, True)
+
+#### saving camera placements for all active views
+
+# current camera placement for renderView1
+renderView1.InteractionMode = '2D'
+renderView1.CameraPosition = [0.9999999999999908, 9999.999999999995, 9999.999999999993]
+renderView1.CameraFocalPoint = [1.0, 0.0, 0.0]
+renderView1.CameraViewUp = [0.6331899945158901, 0.547298104713038, -0.5472981047130381]
+renderView1.CameraParallelScale = 0.6930835077290218
+renderView1.ViewSize = [739,503]
+
+import os
+import sys
+try:
+ baselineIndex = sys.argv.index('-B')+1
+ baselinePath = sys.argv[baselineIndex]
+except:
+ print "Could not get baseline directory. Test failed."
+ exit(1)
+baseline_file = os.path.join(baselinePath, imgName)
+import vtk.test.Testing
+vtk.test.Testing.VTK_TEMP_DIR = vtk.util.misc.vtkGetTempDir()
+vtk.test.Testing.compareImage(GetActiveView().GetRenderWindow(), baseline_file, threshold=25)
+vtk.test.Testing.interact()
+
f0=MEDCouplingFieldDouble(ON_NODES) ; f0.setMesh(m0) ; f0.setName("f0NoPfl")
arr0=DataArrayDouble([0.,1.,2.,3.,1.,1.5,2.2,3.1,2.,2.2,3.,3.1,3.,3.1,3.5,4.])
f0.setArray(arr0)
-f0.checkCoherency()
+f0.checkConsistencyLight()
f1ts0.setFieldNoProfileSBT(f0)
#
pfl1=DataArrayInt([0,1,2,3,4,5,6,8,9,12]) ; pfl1.setName("pfl1")
c=MEDCouplingCMesh("mesh")
c.setCoords(arr,arr,arr)
m=c.buildUnstructured()
-mbis=m.deepCpy() ; mbis.translate([5,0,0]) ; mbis.tetrahedrize(PLANAR_FACE_5)
+mbis=m.deepCopy() ; mbis.translate([5,0,0]) ; mbis.tetrahedrize(PLANAR_FACE_5)
m=MEDCouplingUMesh.MergeUMeshes([mbis,m]) ; m.setName(c.getName())
mm=MEDFileUMesh()
mm.setMeshAtLevel(0,m)
fGauss.setGaussLocalizationOnType(NORM_QUAD4,[-1.,-1.,1.,-1.,1.,1.,-1.,1.],[-0.9,-0.9,0.,0.,0.9,0.9],[0.2,0.3,0.5])
fGauss.setArray(DataArrayDouble([0.9,1.3,0.22,1.3,1.62,2.21,1.62,2.72,2.95,2.54,2.25,2.16,1.58,1.05,3.13,2.91,2.82,1.41,1.58,1.95,3.59,3.53,3.59,2.82,2.91,3.13,2.25,2.54,2.95]))
fGauss.getArray().setInfoOnComponent(0,"C0")
-fGauss.checkCoherency()
+fGauss.checkConsistencyLight()
#
f1ts=MEDFileField1TS()
f1ts.setFieldNoProfileSBT(fGauss)
#include "MEDFileData.hxx"
#include "MEDCouplingMemArray.hxx"
#include "MEDCouplingFieldDouble.hxx"
-#include "MEDCouplingAutoRefCountObjectPtr.hxx"
+#include "MEDCouplingRefCountObject.hxx"
#include <map>
#include <deque>
#include <sstream>
-using ParaMEDMEM::MEDFileData;
-using ParaMEDMEM::MEDFileMesh;
-using ParaMEDMEM::MEDFileCMesh;
-using ParaMEDMEM::MEDFileUMesh;
-using ParaMEDMEM::MEDFileFields;
-using ParaMEDMEM::MEDFileMeshes;
+using MEDCoupling::MEDFileData;
+using MEDCoupling::MEDFileMesh;
+using MEDCoupling::MEDFileCMesh;
+using MEDCoupling::MEDFileUMesh;
+using MEDCoupling::MEDFileFields;
+using MEDCoupling::MEDFileMeshes;
-using ParaMEDMEM::MEDFileIntField1TS;
-using ParaMEDMEM::MEDFileField1TS;
-using ParaMEDMEM::MEDFileIntFieldMultiTS;
-using ParaMEDMEM::MEDFileFieldMultiTS;
-using ParaMEDMEM::MEDFileAnyTypeFieldMultiTS;
-using ParaMEDMEM::DataArray;
-using ParaMEDMEM::DataArrayInt;
-using ParaMEDMEM::DataArrayDouble;
-using ParaMEDMEM::MEDCouplingMesh;
-using ParaMEDMEM::MEDCouplingUMesh;
-using ParaMEDMEM::MEDCouplingCMesh;
-using ParaMEDMEM::MEDCouplingFieldDouble;
-using ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr;
+using MEDCoupling::MEDFileIntField1TS;
+using MEDCoupling::MEDFileField1TS;
+using MEDCoupling::MEDFileIntFieldMultiTS;
+using MEDCoupling::MEDFileFieldMultiTS;
+using MEDCoupling::MEDFileAnyTypeFieldMultiTS;
+using MEDCoupling::DataArray;
+using MEDCoupling::DataArrayInt;
+using MEDCoupling::DataArrayDouble;
+using MEDCoupling::MEDCouplingMesh;
+using MEDCoupling::MEDCouplingUMesh;
+using MEDCoupling::MEDCouplingCMesh;
+using MEDCoupling::MEDCouplingFieldDouble;
+using MEDCoupling::MCAuto;
vtkStandardNewMacro(vtkMEDWriter);
std::map<int,int> ComputeMapOfType()
{
std::map<int,int> ret;
- int nbOfTypesInMC(sizeof(MEDCouplingUMesh::PARAMEDMEM2VTKTYPETRADUCER)/sizeof(int));
+ int nbOfTypesInMC(sizeof(MEDCouplingUMesh::MEDCOUPLING2VTKTYPETRADUCER)/sizeof(int));
for(int i=0;i<nbOfTypesInMC;i++)
{
- int vtkId(MEDCouplingUMesh::PARAMEDMEM2VTKTYPETRADUCER[i]);
+ int vtkId(MEDCouplingUMesh::MEDCOUPLING2VTKTYPETRADUCER[i]);
if(vtkId!=-1)
ret[vtkId]=i;
}
throw MZCException("ConvertVTKArrayToMCArrayInt : internal error !");
int nbTuples(data->GetNumberOfTuples()),nbComp(data->GetNumberOfComponents());
std::size_t nbElts(nbTuples*nbComp);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
+ MCAuto<DataArrayInt> ret(DataArrayInt::New());
ret->alloc(nbTuples,nbComp);
for(int i=0;i<nbComp;i++)
{
throw MZCException("ConvertVTKArrayToMCArrayDouble : internal error !");
int nbTuples(data->GetNumberOfTuples()),nbComp(data->GetNumberOfComponents());
std::size_t nbElts(nbTuples*nbComp);
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret(DataArrayDouble::New());
+ MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
ret->alloc(nbTuples,nbComp);
for(int i=0;i<nbComp;i++)
{
MEDCouplingUMesh *BuildMeshFromCellArray(vtkCellArray *ca, DataArrayDouble *coords, int meshDim, INTERP_KERNEL::NormalizedCellType type)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> subMesh(MEDCouplingUMesh::New("",meshDim));
+ MCAuto<MEDCouplingUMesh> subMesh(MEDCouplingUMesh::New("",meshDim));
subMesh->setCoords(coords); subMesh->allocateCells();
int nbCells(ca->GetNumberOfCells());
if(nbCells==0)
return subMesh.retn();
}
-MEDCouplingUMesh *BuildMeshFromCellArrayTriangleStrip(vtkCellArray *ca, DataArrayDouble *coords, MEDCouplingAutoRefCountObjectPtr<DataArrayInt>& ids)
+MEDCouplingUMesh *BuildMeshFromCellArrayTriangleStrip(vtkCellArray *ca, DataArrayDouble *coords, MCAuto<DataArrayInt>& ids)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> subMesh(MEDCouplingUMesh::New("",2));
+ MCAuto<MEDCouplingUMesh> subMesh(MEDCouplingUMesh::New("",2));
subMesh->setCoords(coords); subMesh->allocateCells();
int nbCells(ca->GetNumberOfCells());
if(nbCells==0)
class MicroField
{
public:
- MicroField(const MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh>& m, const std::vector<MEDCouplingAutoRefCountObjectPtr<DataArray> >& cellFs):_m(m),_cellFs(cellFs) { }
+ MicroField(const MCAuto<MEDCouplingUMesh>& m, const std::vector<MCAuto<DataArray> >& cellFs):_m(m),_cellFs(cellFs) { }
MicroField(const std::vector< MicroField >& vs);
- void setNodeFields(const std::vector<MEDCouplingAutoRefCountObjectPtr<DataArray> >& nf) { _nodeFs=nf; }
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> getMesh() const { return _m; }
- std::vector<MEDCouplingAutoRefCountObjectPtr<DataArray> > getCellFields() const { return _cellFs; }
+ void setNodeFields(const std::vector<MCAuto<DataArray> >& nf) { _nodeFs=nf; }
+ MCAuto<MEDCouplingUMesh> getMesh() const { return _m; }
+ std::vector<MCAuto<DataArray> > getCellFields() const { return _cellFs; }
private:
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> _m;
- std::vector<MEDCouplingAutoRefCountObjectPtr<DataArray> > _cellFs;
- std::vector<MEDCouplingAutoRefCountObjectPtr<DataArray> > _nodeFs;
+ MCAuto<MEDCouplingUMesh> _m;
+ std::vector<MCAuto<DataArray> > _cellFs;
+ std::vector<MCAuto<DataArray> > _nodeFs;
};
MicroField::MicroField(const std::vector< MicroField >& vs)
{
std::size_t sz(vs.size());
std::vector<const MEDCouplingUMesh *> vs2(sz);
- std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<DataArray> > > arrs2(sz);
+ std::vector< std::vector< MCAuto<DataArray> > > arrs2(sz);
int nbElts(-1);
for(std::size_t ii=0;ii<sz;ii++)
{
_m=MEDCouplingUMesh::MergeUMeshesOnSameCoords(vs2);
}
-void AppendMCFieldFrom(ParaMEDMEM::TypeOfField tf, MEDCouplingMesh *mesh, MEDFileData *mfd, MEDCouplingAutoRefCountObjectPtr<DataArray> da, const DataArrayInt *n2oPtr)
+void AppendMCFieldFrom(MEDCoupling::TypeOfField tf, MEDCouplingMesh *mesh, MEDFileData *mfd, MCAuto<DataArray> da, const DataArrayInt *n2oPtr)
{
static const char FAMFIELD_FOR_CELLS[]="FamilyIdCell";
static const char FAMFIELD_FOR_NODES[]="FamilyIdNode";
MEDFileMeshes *ms(mfd->getMeshes());
if(!fs || !ms)
throw MZCException("AppendMCFieldFrom : internal error 2 !");
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> dad(ParaMEDMEM::DynamicCast<DataArray,DataArrayDouble>(da));
+ MCAuto<DataArrayDouble> dad(MEDCoupling::DynamicCast<DataArray,DataArrayDouble>(da));
DataArrayDouble *dadPtr(dad);
std::string fieldName;
if(dadPtr)
{
fieldName=dadPtr->getName();
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f(MEDCouplingFieldDouble::New(tf));
+ MCAuto<MEDCouplingFieldDouble> f(MEDCouplingFieldDouble::New(tf));
f->setName(fieldName);
if(!n2oPtr)
f->setArray(dadPtr);
else
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> dad2(dadPtr->selectByTupleId(n2oPtr->begin(),n2oPtr->end()));
+ MCAuto<DataArrayDouble> dad2(dadPtr->selectByTupleId(n2oPtr->begin(),n2oPtr->end()));
f->setArray(dad2);
}
f->setMesh(mesh);
- MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> fmts(MEDFileFieldMultiTS::New());
- MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> f1ts(MEDFileField1TS::New());
+ MCAuto<MEDFileFieldMultiTS> fmts(MEDFileFieldMultiTS::New());
+ MCAuto<MEDFileField1TS> f1ts(MEDFileField1TS::New());
f1ts->setFieldNoProfileSBT(f);
fmts->pushBackTimeStep(f1ts);
fs->pushField(fmts);
return ;
}
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> dai(ParaMEDMEM::DynamicCast<DataArray,DataArrayInt>(da));
+ MCAuto<DataArrayInt> dai(MEDCoupling::DynamicCast<DataArray,DataArrayInt>(da));
DataArrayInt *daiPtr(dai);
if(daiPtr)
{
fieldName=daiPtr->getName();
- if((fieldName!=FAMFIELD_FOR_CELLS || tf!=ParaMEDMEM::ON_CELLS) && (fieldName!=FAMFIELD_FOR_NODES || tf!=ParaMEDMEM::ON_NODES))
+ if((fieldName!=FAMFIELD_FOR_CELLS || tf!=MEDCoupling::ON_CELLS) && (fieldName!=FAMFIELD_FOR_NODES || tf!=MEDCoupling::ON_NODES))
{
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> f(MEDCouplingFieldDouble::New(tf));
+ MCAuto<MEDCouplingFieldDouble> f(MEDCouplingFieldDouble::New(tf));
f->setName(fieldName);
f->setMesh(mesh);
- MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> fmts(MEDFileIntFieldMultiTS::New());
- MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> f1ts(MEDFileIntField1TS::New());
+ MCAuto<MEDFileIntFieldMultiTS> fmts(MEDFileIntFieldMultiTS::New());
+ MCAuto<MEDFileIntField1TS> f1ts(MEDFileIntField1TS::New());
if(!n2oPtr)
f1ts->setFieldNoProfileSBT(f,daiPtr);
else
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> dai2(daiPtr->selectByTupleId(n2oPtr->begin(),n2oPtr->end()));
+ MCAuto<DataArrayInt> dai2(daiPtr->selectByTupleId(n2oPtr->begin(),n2oPtr->end()));
f1ts->setFieldNoProfileSBT(f,dai2);
}
fmts->pushBackTimeStep(f1ts);
fs->pushField(fmts);
return ;
}
- else if(fieldName==FAMFIELD_FOR_CELLS && tf==ParaMEDMEM::ON_CELLS)
+ else if(fieldName==FAMFIELD_FOR_CELLS && tf==MEDCoupling::ON_CELLS)
{
MEDFileMesh *mm(ms->getMeshWithName(mesh->getName()));
if(!mm)
mm->setFamilyFieldArr(mesh->getMeshDimension()-mm->getMeshDimension(),daiPtr);
else
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> dai2(daiPtr->selectByTupleId(n2oPtr->begin(),n2oPtr->end()));
+ MCAuto<DataArrayInt> dai2(daiPtr->selectByTupleId(n2oPtr->begin(),n2oPtr->end()));
mm->setFamilyFieldArr(mesh->getMeshDimension()-mm->getMeshDimension(),dai2);
}
}
- else if(fieldName==FAMFIELD_FOR_NODES || tf==ParaMEDMEM::ON_NODES)
+ else if(fieldName==FAMFIELD_FOR_NODES || tf==MEDCoupling::ON_NODES)
{
MEDFileMesh *mm(ms->getMeshWithName(mesh->getName()));
if(!mm)
mm->setFamilyFieldArr(1,daiPtr);
else
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> dai2(daiPtr->selectByTupleId(n2oPtr->begin(),n2oPtr->end()));
+ MCAuto<DataArrayInt> dai2(daiPtr->selectByTupleId(n2oPtr->begin(),n2oPtr->end()));
mm->setFamilyFieldArr(1,dai2);
}
}
MEDFileUMesh *mmu(dynamic_cast<MEDFileUMesh *>(mm));
if(!mmu)
throw MZCException("PutAtLevelDealOrder : internal error 2 !");
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> mesh(mf.getMesh());
+ MCAuto<MEDCouplingUMesh> mesh(mf.getMesh());
mesh->setName(mfd->getMeshes()->getMeshAtPos(0)->getName());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> o2n(mesh->sortCellsInMEDFileFrmt());
+ MCAuto<DataArrayInt> o2n(mesh->sortCellsInMEDFileFrmt());
const DataArrayInt *o2nPtr(o2n);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> n2o;
+ MCAuto<DataArrayInt> n2o;
mmu->setMeshAtLevel(meshDimRel,mesh);
const DataArrayInt *n2oPtr(0);
if(o2n)
{
n2o=o2n->invertArrayO2N2N2O(mesh->getNumberOfCells());
n2oPtr=n2o;
- if(n2oPtr && n2oPtr->isIdentity2(mesh->getNumberOfCells()))
+ if(n2oPtr && n2oPtr->isIota(mesh->getNumberOfCells()))
n2oPtr=0;
if(n2oPtr)
mm->setRenumFieldArr(meshDimRel,n2o);
}
//
- std::vector<MEDCouplingAutoRefCountObjectPtr<DataArray> > cells(mf.getCellFields());
- for(std::vector<MEDCouplingAutoRefCountObjectPtr<DataArray> >::const_iterator it=cells.begin();it!=cells.end();it++)
+ std::vector<MCAuto<DataArray> > cells(mf.getCellFields());
+ for(std::vector<MCAuto<DataArray> >::const_iterator it=cells.begin();it!=cells.end();it++)
{
- MEDCouplingAutoRefCountObjectPtr<DataArray> da(*it);
- AppendMCFieldFrom(ParaMEDMEM::ON_CELLS,mesh,mfd,da,n2oPtr);
+ MCAuto<DataArray> da(*it);
+ AppendMCFieldFrom(MEDCoupling::ON_CELLS,mesh,mfd,da,n2oPtr);
}
}
vtkDataArray *data(pts->GetData());
if(!data)
throw MZCException("BuildCoordsFrom : internal error 3 !");
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> coords(ConvertVTKArrayToMCArrayDouble(data));
+ MCAuto<DataArrayDouble> coords(ConvertVTKArrayToMCArrayDouble(data));
return coords.retn();
}
MEDFileUMesh *mmu(dynamic_cast<MEDFileUMesh *>(mm));
if(!mmu)
throw MZCException("AddNodeFields : internal error 2 !");
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> mesh(mmu->getMeshAtLevel(0));
+ MCAuto<MEDCouplingUMesh> mesh(mmu->getMeshAtLevel(0));
int nba(dsa->GetNumberOfArrays());
for(int i=0;i<nba;i++)
{
const char *name(arr->GetName());
if(!arr)
continue;
- MEDCouplingAutoRefCountObjectPtr<DataArray> da(ConvertVTKArrayToMCArray(arr));
+ MCAuto<DataArray> da(ConvertVTKArrayToMCArray(arr));
da->setName(name);
- AppendMCFieldFrom(ParaMEDMEM::ON_NODES,mesh,mfd,da,0);
+ AppendMCFieldFrom(MEDCoupling::ON_NODES,mesh,mfd,da,0);
}
}
-std::vector<MEDCouplingAutoRefCountObjectPtr<DataArray> > AddPartFields(const DataArrayInt *part, vtkDataSetAttributes *dsa)
+std::vector<MCAuto<DataArray> > AddPartFields(const DataArrayInt *part, vtkDataSetAttributes *dsa)
{
- std::vector< MEDCouplingAutoRefCountObjectPtr<DataArray> > ret;
+ std::vector< MCAuto<DataArray> > ret;
if(!dsa)
return ret;
int nba(dsa->GetNumberOfArrays());
const char *name(arr->GetName());
int nbCompo(arr->GetNumberOfComponents());
vtkIdType nbTuples(arr->GetNumberOfTuples());
- MEDCouplingAutoRefCountObjectPtr<DataArray> mcarr(ConvertVTKArrayToMCArray(arr));
+ MCAuto<DataArray> mcarr(ConvertVTKArrayToMCArray(arr));
if(part)
mcarr=mcarr->selectByTupleId(part->begin(),part->end());
mcarr->setName(name);
return ret;
}
-std::vector<MEDCouplingAutoRefCountObjectPtr<DataArray> > AddPartFields2(int bg, int end, vtkDataSetAttributes *dsa)
+std::vector<MCAuto<DataArray> > AddPartFields2(int bg, int end, vtkDataSetAttributes *dsa)
{
- std::vector< MEDCouplingAutoRefCountObjectPtr<DataArray> > ret;
+ std::vector< MCAuto<DataArray> > ret;
if(!dsa)
return ret;
int nba(dsa->GetNumberOfArrays());
const char *name(arr->GetName());
int nbCompo(arr->GetNumberOfComponents());
vtkIdType nbTuples(arr->GetNumberOfTuples());
- MEDCouplingAutoRefCountObjectPtr<DataArray> mcarr(ConvertVTKArrayToMCArray(arr));
- mcarr=mcarr->selectByTupleId2(bg,end,1);
+ MCAuto<DataArray> mcarr(ConvertVTKArrayToMCArray(arr));
+ mcarr=mcarr->selectByTupleIdSafeSlice(bg,end,1);
mcarr->setName(name);
ret.push_back(mcarr);
}
if(!ds || !ret)
throw MZCException("ConvertFromRectilinearGrid : internal error !");
//
- MEDCouplingAutoRefCountObjectPtr<MEDFileMeshes> meshes(MEDFileMeshes::New());
+ MCAuto<MEDFileMeshes> meshes(MEDFileMeshes::New());
ret->setMeshes(meshes);
- MEDCouplingAutoRefCountObjectPtr<MEDFileFields> fields(MEDFileFields::New());
+ MCAuto<MEDFileFields> fields(MEDFileFields::New());
ret->setFields(fields);
//
- MEDCouplingAutoRefCountObjectPtr<MEDFileCMesh> cmesh(MEDFileCMesh::New());
+ MCAuto<MEDFileCMesh> cmesh(MEDFileCMesh::New());
meshes->pushMesh(cmesh);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingCMesh> cmeshmc(MEDCouplingCMesh::New());
+ MCAuto<MEDCouplingCMesh> cmeshmc(MEDCouplingCMesh::New());
vtkDataArray *cx(ds->GetXCoordinates()),*cy(ds->GetYCoordinates()),*cz(ds->GetZCoordinates());
if(cx)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr(ConvertVTKArrayToMCArrayDouble(cx));
+ MCAuto<DataArrayDouble> arr(ConvertVTKArrayToMCArrayDouble(cx));
cmeshmc->setCoordsAt(0,arr);
}
if(cy)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr(ConvertVTKArrayToMCArrayDouble(cy));
+ MCAuto<DataArrayDouble> arr(ConvertVTKArrayToMCArrayDouble(cy));
cmeshmc->setCoordsAt(1,arr);
}
if(cz)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr(ConvertVTKArrayToMCArrayDouble(cz));
+ MCAuto<DataArrayDouble> arr(ConvertVTKArrayToMCArrayDouble(cz));
cmeshmc->setCoordsAt(2,arr);
}
std::string meshName(GetMeshNameWithContext(context));
cmeshmc->setName(meshName);
cmesh->setMesh(cmeshmc);
- std::vector<MEDCouplingAutoRefCountObjectPtr<DataArray> > cellFs(AddPartFields(0,ds->GetCellData()));
- for(std::vector<MEDCouplingAutoRefCountObjectPtr<DataArray> >::const_iterator it=cellFs.begin();it!=cellFs.end();it++)
+ std::vector<MCAuto<DataArray> > cellFs(AddPartFields(0,ds->GetCellData()));
+ for(std::vector<MCAuto<DataArray> >::const_iterator it=cellFs.begin();it!=cellFs.end();it++)
{
- MEDCouplingAutoRefCountObjectPtr<DataArray> da(*it);
- AppendMCFieldFrom(ParaMEDMEM::ON_CELLS,cmeshmc,ret,da,0);
+ MCAuto<DataArray> da(*it);
+ AppendMCFieldFrom(MEDCoupling::ON_CELLS,cmeshmc,ret,da,0);
}
- std::vector<MEDCouplingAutoRefCountObjectPtr<DataArray> > nodeFs(AddPartFields(0,ds->GetPointData()));
- for(std::vector<MEDCouplingAutoRefCountObjectPtr<DataArray> >::const_iterator it=nodeFs.begin();it!=nodeFs.end();it++)
+ std::vector<MCAuto<DataArray> > nodeFs(AddPartFields(0,ds->GetPointData()));
+ for(std::vector<MCAuto<DataArray> >::const_iterator it=nodeFs.begin();it!=nodeFs.end();it++)
{
- MEDCouplingAutoRefCountObjectPtr<DataArray> da(*it);
- AppendMCFieldFrom(ParaMEDMEM::ON_NODES,cmeshmc,ret,da,0);
+ MCAuto<DataArray> da(*it);
+ AppendMCFieldFrom(MEDCoupling::ON_NODES,cmeshmc,ret,da,0);
}
}
if(!ds || !ret)
throw MZCException("ConvertFromPolyData : internal error !");
//
- MEDCouplingAutoRefCountObjectPtr<MEDFileMeshes> meshes(MEDFileMeshes::New());
+ MCAuto<MEDFileMeshes> meshes(MEDFileMeshes::New());
ret->setMeshes(meshes);
- MEDCouplingAutoRefCountObjectPtr<MEDFileFields> fields(MEDFileFields::New());
+ MCAuto<MEDFileFields> fields(MEDFileFields::New());
ret->setFields(fields);
//
- MEDCouplingAutoRefCountObjectPtr<MEDFileUMesh> umesh(MEDFileUMesh::New());
+ MCAuto<MEDFileUMesh> umesh(MEDFileUMesh::New());
meshes->pushMesh(umesh);
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> coords(BuildCoordsFrom(ds));
+ MCAuto<DataArrayDouble> coords(BuildCoordsFrom(ds));
umesh->setCoords(coords);
umesh->setName(GetMeshNameWithContext(context));
//
vtkCellArray *cd(ds->GetVerts());
if(cd)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> subMesh(BuildMeshFromCellArray(cd,coords,0,INTERP_KERNEL::NORM_POINT1));
+ MCAuto<MEDCouplingUMesh> subMesh(BuildMeshFromCellArray(cd,coords,0,INTERP_KERNEL::NORM_POINT1));
if((const MEDCouplingUMesh *)subMesh)
{
- std::vector<MEDCouplingAutoRefCountObjectPtr<DataArray> > cellFs(AddPartFields2(offset,offset+subMesh->getNumberOfCells(),ds->GetCellData()));
+ std::vector<MCAuto<DataArray> > cellFs(AddPartFields2(offset,offset+subMesh->getNumberOfCells(),ds->GetCellData()));
offset+=subMesh->getNumberOfCells();
ms.push_back(MicroField(subMesh,cellFs));
}
vtkCellArray *cc(ds->GetLines());
if(cc)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> subMesh(BuildMeshFromCellArray(cc,coords,1,INTERP_KERNEL::NORM_SEG2));
+ MCAuto<MEDCouplingUMesh> subMesh(BuildMeshFromCellArray(cc,coords,1,INTERP_KERNEL::NORM_SEG2));
if((const MEDCouplingUMesh *)subMesh)
{
- std::vector<MEDCouplingAutoRefCountObjectPtr<DataArray> > cellFs(AddPartFields2(offset,offset+subMesh->getNumberOfCells(),ds->GetCellData()));
+ std::vector<MCAuto<DataArray> > cellFs(AddPartFields2(offset,offset+subMesh->getNumberOfCells(),ds->GetCellData()));
offset+=subMesh->getNumberOfCells();
ms.push_back(MicroField(subMesh,cellFs));
}
vtkCellArray *cb(ds->GetPolys());
if(cb)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> subMesh(BuildMeshFromCellArray(cb,coords,2,INTERP_KERNEL::NORM_POLYGON));
+ MCAuto<MEDCouplingUMesh> subMesh(BuildMeshFromCellArray(cb,coords,2,INTERP_KERNEL::NORM_POLYGON));
if((const MEDCouplingUMesh *)subMesh)
{
- std::vector<MEDCouplingAutoRefCountObjectPtr<DataArray> > cellFs(AddPartFields2(offset,offset+subMesh->getNumberOfCells(),ds->GetCellData()));
+ std::vector<MCAuto<DataArray> > cellFs(AddPartFields2(offset,offset+subMesh->getNumberOfCells(),ds->GetCellData()));
offset+=subMesh->getNumberOfCells();
ms.push_back(MicroField(subMesh,cellFs));
}
vtkCellArray *ca(ds->GetStrips());
if(ca)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids;
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> subMesh(BuildMeshFromCellArrayTriangleStrip(ca,coords,ids));
+ MCAuto<DataArrayInt> ids;
+ MCAuto<MEDCouplingUMesh> subMesh(BuildMeshFromCellArrayTriangleStrip(ca,coords,ids));
if((const MEDCouplingUMesh *)subMesh)
{
- std::vector<MEDCouplingAutoRefCountObjectPtr<DataArray> > cellFs(AddPartFields(ids,ds->GetCellData()));
+ std::vector<MCAuto<DataArray> > cellFs(AddPartFields(ids,ds->GetCellData()));
offset+=subMesh->getNumberOfCells();
ms.push_back(MicroField(subMesh,cellFs));
}
if(!ds || !ret)
throw MZCException("ConvertFromUnstructuredGrid : internal error !");
//
- MEDCouplingAutoRefCountObjectPtr<MEDFileMeshes> meshes(MEDFileMeshes::New());
+ MCAuto<MEDFileMeshes> meshes(MEDFileMeshes::New());
ret->setMeshes(meshes);
- MEDCouplingAutoRefCountObjectPtr<MEDFileFields> fields(MEDFileFields::New());
+ MCAuto<MEDFileFields> fields(MEDFileFields::New());
ret->setFields(fields);
//
- MEDCouplingAutoRefCountObjectPtr<MEDFileUMesh> umesh(MEDFileUMesh::New());
+ MCAuto<MEDFileUMesh> umesh(MEDFileUMesh::New());
meshes->pushMesh(umesh);
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> coords(BuildCoordsFrom(ds));
+ MCAuto<DataArrayDouble> coords(BuildCoordsFrom(ds));
umesh->setCoords(coords);
umesh->setName(GetMeshNameWithContext(context));
vtkIdType nbCells(ds->GetNumberOfCells());
throw MZCException("ConvertFromUnstructuredGrid : internal error 2");
const unsigned char *ctPtr(ct->GetPointer(0));
std::map<int,int> m(ComputeMapOfType());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> lev(DataArrayInt::New()) ; lev->alloc(nbCells,1);
+ MCAuto<DataArrayInt> lev(DataArrayInt::New()) ; lev->alloc(nbCells,1);
int *levPtr(lev->getPointer());
for(vtkIdType i=0;i<nbCells;i++)
{
}
int dummy(0);
int meshDim(lev->getMaxValue(dummy));
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> levs(lev->getDifferentValues());
+ MCAuto<DataArrayInt> levs(lev->getDifferentValues());
std::vector< MicroField > ms;
vtkIdTypeArray *faces(ds->GetFaces()),*faceLoc(ds->GetFaceLocations());
for(const int *curLev=levs->begin();curLev!=levs->end();curLev++)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> m0(MEDCouplingUMesh::New("",*curLev));
+ MCAuto<MEDCouplingUMesh> m0(MEDCouplingUMesh::New("",*curLev));
m0->setCoords(coords); m0->allocateCells();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cellIdsCurLev(lev->getIdsEqual(*curLev));
+ MCAuto<DataArrayInt> cellIdsCurLev(lev->findIdsEqual(*curLev));
for(const int *cellId=cellIdsCurLev->begin();cellId!=cellIdsCurLev->end();cellId++)
{
std::map<int,int>::iterator it(m.find(ctPtr[*cellId]));
m0->insertNextCell(ct,conn.size(),&conn[0]);
}
}
- std::vector<MEDCouplingAutoRefCountObjectPtr<DataArray> > cellFs(AddPartFields(cellIdsCurLev,ds->GetCellData()));
+ std::vector<MCAuto<DataArray> > cellFs(AddPartFields(cellIdsCurLev,ds->GetCellData()));
ms.push_back(MicroField(m0,cellFs));
}
AssignSingleGTMeshes(ret,ms);
vtkInformationDataObjectMetaDataKey *GetMEDReaderMetaDataIfAny()
{
static const char ZE_KEY[]="vtkMEDReader::META_DATA";
- ParaMEDMEM::GlobalDict *gd(ParaMEDMEM::GlobalDict::GetInstance());
+ MEDCoupling::GlobalDict *gd(MEDCoupling::GlobalDict::GetInstance());
if(!gd->hasKey(ZE_KEY))
return 0;
std::string ptSt(gd->value(ZE_KEY));
vtkDataObject *input(vtkDataObject::SafeDownCast(inputInfo->Get(vtkDataObject::DATA_OBJECT())));
if(!input)
throw MZCException("Not recognized data object in input of the MEDWriter ! Maybe not implemented yet !");
- MEDCouplingAutoRefCountObjectPtr<MEDFileData> mfd(MEDFileData::New());
+ MCAuto<MEDFileData> mfd(MEDFileData::New());
WriteMEDFileFromVTKGDS(mfd,input);
PutFamGrpInfoIfAny(mfd,meshName,groups,fams);
mfd->write(this->FileName,this->IsTouched?0:2); this->IsTouched=true;
fs2=ml.MEDFileFields(fname3)
assert(len(fs2)==2)
assert(mm2.getSpaceDimension()==3) ; assert(mm2.getCoords()[:,2].isUniform(0.,0.))
-m2_0=mm2[0].deepCpy() ; m2_0.changeSpaceDimension(2,0.) ; m2_0.getCoords().setInfoOnComponents(mm[0].getCoords().getInfoOnComponents())
+m2_0=mm2[0].deepCopy() ; m2_0.changeSpaceDimension(2,0.) ; m2_0.getCoords().setInfoOnComponents(mm[0].getCoords().getInfoOnComponents())
assert(m2_0.isEqual(mm[0],1e-12))
-m2_1=mm2[-1].deepCpy() ; m2_1.changeSpaceDimension(2,0.) ; m2_1.getCoords().setInfoOnComponents(mm[0].getCoords().getInfoOnComponents())
+m2_1=mm2[-1].deepCopy() ; m2_1.changeSpaceDimension(2,0.) ; m2_1.getCoords().setInfoOnComponents(mm[0].getCoords().getInfoOnComponents())
assert(m2_1.isEqual(mm[-1],1e-12))
f2_0=mfd2.getFields()[fieldName0][0].getFieldOnMeshAtLevel(ml.ON_CELLS,0,mm2) ; f2_0.setMesh(m2_0)
assert(f1ts0.getFieldOnMeshAtLevel(ml.ON_CELLS,0,mm).isEqual(f2_0,1e-12,1e-12))
SaveData(fname5,proxy=test4vtp,WriteAllTimeSteps=1)
### test content of fname5
mfd5=ml.MEDFileData(fname5)
-m5=mfd5.getMeshes()[0][0].deepCpy()
+m5=mfd5.getMeshes()[0][0].deepCopy()
assert(m5.getSpaceDimension()==3) #
m5.setName(mm.getName()) ; m5.changeSpaceDimension(2,0.) ; m5.getCoords().setInfoOnComponents(mm[0].getCoords().getInfoOnComponents())
-bary5=m5.getBarycenterAndOwner()
-bary=mm[0].getBarycenterAndOwner()
+bary5=m5.computeCellCenterOfMass()
+bary=mm[0].computeCellCenterOfMass()
a,b=bary5.areIncludedInMe(bary,1e-12) ; assert(a)
a,c=mm[0].getCoords().areIncludedInMe(m5.getCoords(),1e-12) ; assert(a)
m5.renumberNodes(c,len(c))#c.invertArrayO2N2N2O(len(c)))
m10.setCoordsAt(2,ml.DataArrayDouble([3,5,6,7,8]))
f10=ml.MEDCouplingFieldDouble(ml.ON_CELLS) ; f10.setMesh(m10)
f10.setName(FieldName10)
-f10.setArray(ml.DataArrayInt.Range(0,m10.getNumberOfCells(),1).convertToDblArr()) ; f10.checkCoherency()
+f10.setArray(ml.DataArrayInt.Range(0,m10.getNumberOfCells(),1).convertToDblArr()) ; f10.checkConsistencyLight()
f10_n=ml.MEDCouplingFieldDouble(ml.ON_NODES) ; f10_n.setMesh(m10)
f10_n.setName(FieldName10_n)
-f10_n.setArray(ml.DataArrayInt.Range(0,m10.getNumberOfNodes(),1).convertToDblArr()) ; f10_n.checkCoherency()
+f10_n.setArray(ml.DataArrayInt.Range(0,m10.getNumberOfNodes(),1).convertToDblArr()) ; f10_n.checkConsistencyLight()
ml.MEDCouplingFieldDouble.WriteVTK(fname8_vtr,[f10,f10_n])
test10vtr=XMLRectilinearGridReader(FileName=[fname8_vtr])
SaveData(fname8,proxy=test10vtr,WriteAllTimeSteps=1)
IF(PARAVIEW_BUILD_QT_GUI)
+ INCLUDE(UseQtExt)
# Custom object panel for the reader and
# custom display panel for line chart view
- QT4_WRAP_UI(CLIENT_UI_SRCS
+ QT_WRAP_UIC(CLIENT_UI_SRCS
Resources/UI/TableReaderPanel.ui
Resources/UI/CustomXYChartDisplayPanel.ui
)
- QT4_WRAP_CPP(MOC_SRCS
+ QT_WRAP_MOC(MOC_SRCS
pqTableReaderPanel.h
pqTableTo3DPanel.h
pqCustomChartDisplayPanelImplementation.h
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+INCLUDE(UseQtExt)
+
# create a plugin with a custom view that shows up in ParaView's multi-view
# manager. this plugin also contains a custom display panel
# moc the Qt based .h files
-QT4_WRAP_CPP(MOC_SRCS MyView.h MyDisplay.h MyViewActiveOptions.h MyViewOptions.h)
+QT_WRAP_MOC(MOC_SRCS MyView.h MyDisplay.h MyViewActiveOptions.h MyViewOptions.h)
# invoke macro to create sources for our custom view and display panel
ADD_PARAVIEW_VIEW_MODULE(
SET(TEST_NAMES A0 A1)
FOREACH(tfile ${TEST_NAMES})
- SET(TEST_NAME 2DVIEWER_${tfile})
+ SET(TEST_NAME ${COMPONENT_NAME}_2DVIEWER_${tfile})
ADD_TEST(${TEST_NAME} python ${SALOME_TEST_DRIVER} ${TIMEOUT} ${tfile}.py)
SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
ENDFOREACH()
SET(TEST_NAMES A1 A2 A3 A4 A5 A6 A7 A8 A9 B0 B1 B2)
FOREACH(tfile ${TEST_NAMES})
- SET(TEST_NAME 3DVIEWER_${tfile})
+ SET(TEST_NAME ${COMPONENT_NAME}_3DVIEWER_${tfile})
ADD_TEST(${TEST_NAME} python ${SALOME_TEST_DRIVER} ${TIMEOUT} ${tfile}.py)
SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
ENDFOREACH()
E0 E4 E7 E8 F2 F5 F6 G0 G3 G4 G8 H1 H2)
FOREACH(tfile ${TEST_NAMES})
- SET(TEST_NAME ANIMATION_${tfile})
+ SET(TEST_NAME ${COMPONENT_NAME}_ANIMATION_${tfile})
ADD_TEST(${TEST_NAME} python ${SALOME_TEST_DRIVER} ${TIMEOUT} ${tfile}.py)
SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
ENDFOREACH()
SET(TEST_NAMES A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 B0 B1 B2
E0 E1 E2 E3 E4 E5 E6 E7 E8 E9
- F1 F2 F3 F4 F5 F6 F7 F8 F9 G0 G1 G2)
+ F1 F2 F3 F4 F5 F6 F8 F9 G0 G1 G2)
FOREACH(tfile ${TEST_NAMES})
- SET(TEST_NAME CUTLINES_${tfile})
+ SET(TEST_NAME ${COMPONENT_NAME}_CUTLINES_${tfile})
ADD_TEST(${TEST_NAME} python ${SALOME_TEST_DRIVER} ${TIMEOUT} ${tfile}.py)
SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
ENDFOREACH()
SET(TEST_NAMES A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 B0 B1 B2 B3
E0 E1 E2 E3 E4 E5 E6 E7 E8 E9
- F1 F2 F3 F4 F5 F6 F7 F8 F9 G0 G1 G2)
+ F1 F2 F3 F4 F5 F6 F8 F9 G0 G1 G2)
FOREACH(tfile ${TEST_NAMES})
- SET(TEST_NAME CUTPLANES_${tfile})
+ SET(TEST_NAME ${COMPONENT_NAME}_CUTPLANES_${tfile})
ADD_TEST(${TEST_NAME} python ${SALOME_TEST_DRIVER} ${TIMEOUT} ${tfile}.py)
SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
ENDFOREACH()
#
SET(TEST_NAMES A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 B0 B1 B2 B3 B4
- E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 F1 F2 F3 F4 F5 F6 F7 F8 F9)
+ E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 F1 F2 F3 F4 F5 F6 F8 F9)
FOREACH(tfile ${TEST_NAMES})
- SET(TEST_NAME DEFORMEDSHAPE_${tfile})
+ SET(TEST_NAME ${COMPONENT_NAME}_DEFORMEDSHAPE_${tfile})
ADD_TEST(${TEST_NAME} python ${SALOME_TEST_DRIVER} ${TIMEOUT} ${tfile}.py)
SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
ENDFOREACH()
#
SET(TEST_NAMES A0 A1 A3 A4 A5 A6 A7 A9 B0 B1 B2 B3 B4 B5 B6 B7 B8 B9
- C0 C1 C2 C3 C4 C5 C6 C7 C8 C9)
+ C0 C1 C2 C3 C4 C6 C7 C8 C9)
FOREACH(tfile ${TEST_NAMES})
- SET(TEST_NAME GAUSSPOINTS_${tfile})
+ SET(TEST_NAME ${COMPONENT_NAME}_GAUSSPOINTS_${tfile})
ADD_TEST(${TEST_NAME} python ${SALOME_TEST_DRIVER} ${TIMEOUT} ${tfile}.py)
SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
ENDFOREACH()
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-SET(TEST_NAMES A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 B0 B1 B2 B3 B4 B5 B6 B7 B8 B9 C0 C1 C2)
+SET(TEST_NAMES A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 B0 B1 B2 B4 B5 B6 B7 B8 B9 C0 C1 C2)
FOREACH(tfile ${TEST_NAMES})
- SET(TEST_NAME IMPORTMEDFIELD_${tfile})
+ SET(TEST_NAME ${COMPONENT_NAME}_IMPORTMEDFIELD_${tfile})
ADD_TEST(${TEST_NAME} python ${SALOME_TEST_DRIVER} ${TIMEOUT} ${tfile}.py)
SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
ENDFOREACH()
#
SET(TEST_NAMES A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 B0 B1 B2
- E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 F1 F2 F3 F4 F5 F6 F7 F8 F9 G0 G1 G2)
+ E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 F1 F2 F3 F4 F5 F6 F8 F9 G0 G1 G2)
FOREACH(tfile ${TEST_NAMES})
- SET(TEST_NAME ISOSURFACES_${tfile})
+ SET(TEST_NAME ${COMPONENT_NAME}_ISOSURFACES_${tfile})
ADD_TEST(${TEST_NAME} python ${SALOME_TEST_DRIVER} ${TIMEOUT} ${tfile}.py)
SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
ENDFOREACH()
#
SET(TEST_NAMES A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 B0 B1 B2 E0 E1 E2 E3 E4 E5 E6 E7 E8 E9
- F1 F2 F3 F4 F5 F6 F7 F8 F9 G0 G1 G3 G4 G5 G6 G7 G8 G9
+ F1 F2 F3 F4 F5 F6 F8 F9 G0 G1 G3 G4 G5 G6 G7 G8 G9
H0 H1 H2 H3 H4 H5 H6 H7 H8 H9 I0 I1 I2 I3 I4 I5 I6 I7 I8 I9
J0 J1 J2 J3 J4 J5 J6 J7 J8 J9 K0 K1 K2 K3 K4 K5 K6 K7 K8 K9 L0 L1)
FOREACH(tfile ${TEST_NAMES})
- SET(TEST_NAME MESH_${tfile})
+ SET(TEST_NAME ${COMPONENT_NAME}_MESH_${tfile})
ADD_TEST(${TEST_NAME} python ${SALOME_TEST_DRIVER} ${TIMEOUT} ${tfile}.py)
SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
ENDFOREACH()
#
SET(TEST_NAMES A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 B0 B1 B2 E0 E1 E2 E3 E4 E5 E6 E7 E8 E9
- F1 F2 F3 F4 F5 F6 F7 F8 F9 G0 G1 G2)
+ F1 F2 F3 F4 F5 F6 F8 F9 G0 G1 G2)
FOREACH(tfile ${TEST_NAMES})
- SET(TEST_NAME PLOT3D_${tfile})
+ SET(TEST_NAME ${COMPONENT_NAME}_PLOT3D_${tfile})
ADD_TEST(${TEST_NAME} python ${SALOME_TEST_DRIVER} ${TIMEOUT} ${tfile}.py)
SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
ENDFOREACH()
SET(TEST_NAMES A1 A3 A4 A5 A6 A7 A8 A9 B0 B1 B4 B5 B6 B7 B8 B9 C3 C6 C7)
FOREACH(tfile ${TEST_NAMES})
- SET(TEST_NAME SWIGSCRIPTS_${tfile})
+ SET(TEST_NAME ${COMPONENT_NAME}_SWIGSCRIPTS_${tfile})
ADD_TEST(${TEST_NAME} python ${SALOME_TEST_DRIVER} ${TIMEOUT} ${tfile}.py)
SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
ENDFOREACH()
#
SET(TEST_NAMES A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 B0 B1 B2 B3 E0 E1 E2 E3 E4 E5 E6 E7 E8 E9
- F1 F2 F3 F4 F5 F6 F7 F8 F9 G0 G1 G2)
+ F1 F2 F3 F4 F5 F6 F8 F9 G0 G1 G2)
FOREACH(tfile ${TEST_NAMES})
- SET(TEST_NAME SCALARMAP_${tfile})
+ SET(TEST_NAME ${COMPONENT_NAME}_SCALARMAP_${tfile})
ADD_TEST(${TEST_NAME} python ${SALOME_TEST_DRIVER} ${TIMEOUT} ${tfile}.py)
SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
ENDFOREACH()
#
SET(TEST_NAMES A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 B0 B1 B2 B3 E0 E1 E2 E3 E4 E5 E6 E7 E8 E9
- F1 F2 F3 F4 F5 F6 F7 F8)
+ F1 F2 F3 F4 F5 F6 F8)
FOREACH(tfile ${TEST_NAMES})
- SET(TEST_NAME DEFORMEDSHAPESCALARMAP_${tfile})
+ SET(TEST_NAME ${COMPONENT_NAME}_DEFORMEDSHAPESCALARMAP_${tfile})
ADD_TEST(${TEST_NAME} python ${SALOME_TEST_DRIVER} ${TIMEOUT} ${tfile}.py)
SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
ENDFOREACH()
#
SET(TEST_NAMES A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 B0 B1 B2 B3 B4
- E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 F1 F2 F3 F4 F5 F6 F7 F8 F9 G0)
+ E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 F1 F2 F3 F4 F5 F6 F8 F9 G0)
FOREACH(tfile ${TEST_NAMES})
- SET(TEST_NAME STREAMLINES_${tfile})
+ SET(TEST_NAME ${COMPONENT_NAME}_STREAMLINES_${tfile})
ADD_TEST(${TEST_NAME} python ${SALOME_TEST_DRIVER} ${TIMEOUT} ${tfile}.py)
SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
ENDFOREACH()
SET(TEST_NAMES A0 A2)
FOREACH(tfile ${TEST_NAMES})
- SET(TEST_NAME TABLES_${tfile})
+ SET(TEST_NAME ${COMPONENT_NAME}_TABLES_${tfile})
ADD_TEST(${TEST_NAME} python ${SALOME_TEST_DRIVER} ${TIMEOUT} ${tfile}.py)
SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
ENDFOREACH()
#
SET(TEST_NAMES A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 B0 B1 B2 B3 E0 E1 E2 E3 E4 E5 E6 E7 E8 E9
- F1 F2 F3 F4 F5 F6 F7 F8 F9)
+ F1 F2 F3 F4 F5 F6 F8 F9)
FOREACH(tfile ${TEST_NAMES})
- SET(TEST_NAME VECTORS_${tfile})
+ SET(TEST_NAME ${COMPONENT_NAME}_VECTORS_${tfile})
ADD_TEST(${TEST_NAME} python ${SALOME_TEST_DRIVER} ${TIMEOUT} ${tfile}.py)
SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
ENDFOREACH()
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-SET(TEST_NAMES A0 A1 A2 A3 A4 A5 A6 A7 A9 B1 C3 C4 C5 C6 C7 C8 C9
- D0 D1 D3 D5 D6 D7 E0)
+SET(TEST_NAMES A0 A1 A2 A3 A4 A5 A6 A7 A9 B1 C3 C5 C6 C9
+ D1 D3 D6 D7 E0)
FOREACH(tfile ${TEST_NAMES})
- SET(TEST_NAME BUGS_${tfile})
+ SET(TEST_NAME ${COMPONENT_NAME}_BUGS_${tfile})
ADD_TEST(${TEST_NAME} python ${SALOME_TEST_DRIVER} ${TIMEOUT} ${tfile}.py)
SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
ENDFOREACH()
SET(TEST_NAMES A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 B0 B1 B3 B4 B5)
FOREACH(tfile ${TEST_NAMES})
- SET(TEST_NAME DUMPSTUDY_${tfile})
+ SET(TEST_NAME ${COMPONENT_NAME}_DUMPSTUDY_${tfile})
ADD_TEST(${TEST_NAME} python ${SALOME_TEST_DRIVER} ${TIMEOUT} ${tfile}.py)
SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
ENDFOREACH()
SET(TEST_NAMES A1 A2 A3 A4 A6 A9 B1 B2)
FOREACH(tfile ${TEST_NAMES})
- SET(TEST_NAME IMPS_${tfile})
+ SET(TEST_NAME ${COMPONENT_NAME}_IMPS_${tfile})
ADD_TEST(${TEST_NAME} python ${SALOME_TEST_DRIVER} ${TIMEOUT} ${tfile}.py)
SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
ENDFOREACH()
SET(TEST_NAMES A1 A2 A4 A5 B0)
FOREACH(tfile ${TEST_NAMES})
- SET(TEST_NAME UNITED_${tfile})
+ SET(TEST_NAME ${COMPONENT_NAME}_UNITED_${tfile})
ADD_TEST(${TEST_NAME} python ${SALOME_TEST_DRIVER} ${TIMEOUT} ${tfile}.py)
SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
ENDFOREACH()
OPTION(LIGHTPARAVIS_WITH_GUI "Build GUI test app" ON)
# Package detection
-FIND_PACKAGE(Qt4 REQUIRED)
+IF (NOT SALOME_GUI_BUILD_WITH_QT5)
+ FIND_PACKAGE(Qt4 REQUIRED)
+ELSE()
+ FIND_PACKAGE(Qt5Core)
+ FIND_PACKAGE(Qt5Gui)
+ENDIF()
LIST(APPEND CMAKE_PREFIX_PATH "$ENV{PARAVIEW_ROOT_DIR}")
FIND_PACKAGE(ParaView REQUIRED)
#
# Author: Adrien Bruneton (CEA)
+INCLUDE(UseQtExt)
+
SET(pl_HEADERS
PLMainWindow.hxx
PLViewTab.hxx
INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
INCLUDE_DIRECTORIES(${PARAVIEW_INCLUDE_DIRS})
-INCLUDE(${QT_USE_FILE})
ADD_DEFINITIONS(${QT_DEFINITIONS})
# Generate resources that will embedded
"/LightPara/Configuration"
"${PROJECT_SOURCE_DIR}/gui/xml/ParaViewReaders.xml")
-QT4_ADD_RESOURCES(rcs_sources
+QT_ADD_RESOURCES(rcs_sources
${ui_resources}
)
-QT4_WRAP_UI(pl_FORMS_HEADERS ${pl_FORMS})
-QT4_WRAP_CPP(pl_HEADERS_MOC ${pl_HEADERS})
+QT_WRAP_UIC(pl_FORMS_HEADERS ${pl_FORMS})
+QT_WRAP_MOC(pl_HEADERS_MOC ${pl_HEADERS})
ADD_EXECUTABLE(paraLight
${pl_SOURCES}
