-// Copyright (C) 2007-2014 CEA/DEN, EDF R&D
+// Copyright (C) 2007-2020 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
#endif
#ifdef HAS_XDR
+#include <rpc/types.h>
#include <rpc/xdr.h>
#endif
using namespace SauvUtilities;
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
namespace
{
*/
struct TCellByIDCompare
{
- bool operator () (const Cell* i1, const Cell* i2)
+ bool operator () (const Cell* i1, const Cell* i2) const
{
return i1->_number < i2->_number;
}
isRelocated = ( c2oIt->second != newOrder );
if ( isRelocated )
- {
- grp->_relocTable.resize( cell2order.size() );
- for ( newOrder = 0, c2oIt = cell2order.begin(); c2oIt != c2oEnd; ++c2oIt, ++newOrder )
- grp->_relocTable[ c2oIt->second ] = newOrder;
- }
+ {
+ grp->_relocTable.resize( cell2order.size() );
+ for ( newOrder = 0, c2oIt = cell2order.begin(); c2oIt != c2oEnd; ++c2oIt, ++newOrder )
+ grp->_relocTable[ c2oIt->second ] = newOrder;
+ }
}
}
TInt GetNbRef() const { return myNbRef; }
- TCoordSlice GetCoord(TInt theRefId) { return &myRefCoord[0] + theRefId * myDim; }
+ TCoordSlice GetCoord(std::size_t theRefId) { return &myRefCoord[0] + theRefId * myDim; }
};
//---------------------------------------------------------------
/*!
* \param geomType - element geometry (EGeometrieElement or med_geometrie_element)
* \param nbPoints - nb gauss point
* \param variant - [1-3] to choose the variant of definition
- *
+ *
* Throws in case of invalid parameters
- * variant == 1 refers to "Fonctions de forme et points d'integration
+ * variant == 1 refers to "Fonctions de forme et points d'integration
* des elements finis" v7.4 by J. PELLET, X. DESROCHES, 15/09/05
* variant == 2 refers to the same doc v6.4 by J.P. LEFEBVRE, X. DESROCHES, 03/07/03
* variant == 3 refers to the same doc v6.4, second variant for 2D elements
TGaussDef(const int geomType, const int nbPoints, const int variant=1);
int dim() const { return SauvUtilities::getDimension( NormalizedCellType( myType )); }
- int nbPoints() const { return myWeights.capacity(); }
+ std::size_t nbPoints() const { return myWeights.capacity(); }
private:
void add(const double x, const double weight);
THexa20a::THexa20a(TInt theDim, TInt theNbRef):
TShapeFun(theDim,theNbRef)
{
- TInt aNbRef = myRefCoord.size();
- for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+ std::size_t aNbRef = myRefCoord.size();
+ for(std::size_t aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
case 0: aCoord[0] = -1.0; aCoord[1] = -1.0; aCoord[2] = -1.0; break;
THexa27a::THexa27a():
THexa20a(3,27)
{
- TInt aNbRef = myRefCoord.size();
- for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+ std::size_t aNbRef = myRefCoord.size();
+ for(std::size_t aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
case 20: aCoord[0] = 0.0; aCoord[1] = 0.0; aCoord[2] = -1.0; break;
THexa20b::THexa20b(TInt theDim, TInt theNbRef):
TShapeFun(theDim,theNbRef)
{
- TInt aNbRef = myRefCoord.size();
- for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+ std::size_t aNbRef = myRefCoord.size();
+ for(std::size_t aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
case 0: aCoord[0] = -1.0; aCoord[1] = -1.0; aCoord[2] = -1.0; break;
TPenta6a::TPenta6a():
TShapeFun(3,6)
{
- TInt aNbRef = myRefCoord.size();
- for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+ std::size_t aNbRef = myRefCoord.size();
+ for(std::size_t aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
case 0: aCoord[0] = -1.0; aCoord[1] = 1.0; aCoord[2] = 0.0; break;
TPenta6b::TPenta6b():
TShapeFun(3,6)
{
- TInt aNbRef = myRefCoord.size();
- for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+ std::size_t aNbRef = myRefCoord.size();
+ for(std::size_t aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
case 0: aCoord[0] = -1.0; aCoord[1] = 1.0; aCoord[2] = 0.0; break;
TPenta15a::TPenta15a():
TShapeFun(3,15)
{
- TInt aNbRef = myRefCoord.size();
- for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+ std::size_t aNbRef = myRefCoord.size();
+ for(std::size_t aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
case 0: aCoord[0] = -1.0; aCoord[1] = 1.0; aCoord[2] = 0.0; break;
TPenta15b::TPenta15b():
TShapeFun(3,15)
{
- TInt aNbRef = myRefCoord.size();
- for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+ std::size_t aNbRef = myRefCoord.size();
+ for(std::size_t aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
case 0: aCoord[0] = -1.0; aCoord[1] = 1.0; aCoord[2] = 0.0; break;
TPyra5a::TPyra5a():
TShapeFun(3,5)
{
- TInt aNbRef = myRefCoord.size();
- for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+ std::size_t aNbRef = myRefCoord.size();
+ for(std::size_t aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
case 0: aCoord[0] = 1.0; aCoord[1] = 0.0; aCoord[2] = 0.0; break;
TPyra5b::TPyra5b():
TShapeFun(3,5)
{
- TInt aNbRef = myRefCoord.size();
- for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+ std::size_t aNbRef = myRefCoord.size();
+ for(std::size_t aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
- switch(aRefId){
+ switch(aRefId){
case 0: aCoord[0] = 1.0; aCoord[1] = 0.0; aCoord[2] = 0.0; break;
case 3: aCoord[0] = 0.0; aCoord[1] = 1.0; aCoord[2] = 0.0; break;
case 2: aCoord[0] = -1.0; aCoord[1] = 0.0; aCoord[2] = 0.0; break;
TPyra13a::TPyra13a():
TShapeFun(3,13)
{
- TInt aNbRef = myRefCoord.size();
- for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+ std::size_t aNbRef = myRefCoord.size();
+ for(std::size_t aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
case 0: aCoord[0] = 1.0; aCoord[1] = 0.0; aCoord[2] = 0.0; break;
TPyra13b::TPyra13b():
TShapeFun(3,13)
{
- TInt aNbRef = myRefCoord.size();
- for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
+ std::size_t aNbRef = myRefCoord.size();
+ for(std::size_t aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
case 0: aCoord[0] = 1.0; aCoord[1] = 0.0; aCoord[2] = 0.0; break;
const double P1 = 1./1.8;
const double P2 = 1./1.125;
add( -a, P1 );
- add( 0, P2 );
+ add( 0, P2 );
add( a, P1 ); break;
}
case 4: {
const double P1 = 0.652145154862546, P2 = 0.347854845137454 ;
add( a, P1 );
add( -a, P1 );
- add( b, P2 );
+ add( b, P2 );
add( -b, P2 ); break;
}
default:
case 6: { // FPG6
const double P1 = 0.11169079483905, P2 = 0.0549758718227661;
const double a = 0.445948490915965, b = 0.091576213509771;
- add( b, b, P2 );
+ add( b, b, P2 );
add( 1-2*b, b, P2 );
add( b, 1-2*b, P2 );
add( a, 1-2*a, P1 );
- add( a, a, P1 );
+ add( a, a, P1 );
add( 1-2*a, a, P1 ); break;
}
case 7: { // FPG7
const double B = 0.101286507323456;
const double P1 = 0.066197076394253;
const double P2 = 0.062969590272413;
- add( 1/3., 1/3., 9/80. );
- add( A, A, P1 );
+ add( 1/3., 1/3., 9/80. );
+ add( A, A, P1 );
add( 1-2*A, A, P1 );
add( A, 1-2*A, P1 );
- add( B, B, P2 );
+ add( B, B, P2 );
add( 1-2*B, B, P2 );
add( B, 1-2*B, P2 ); break;
}
const double P1 = 0.025422453185103;
const double P2 = 0.058393137863189;
const double P3 = 0.041425537809187;
- add( A, A, P1 );
+ add( A, A, P1 );
add( 1-2*A, A, P1 );
add( A, 1-2*A, P1 );
- add( B, B, P2 );
+ add( B, B, P2 );
add( 1-2*B, B, P2 );
add( B, 1-2*B, P2 );
add( C, D, P3 );
}
default:
THROW_IK_EXCEPTION("TGaussDef: Invalid nb of gauss points for TRIA, variant 1: "
- <<nbGauss);
+ <<nbGauss);
}
}
else if ( variant == 2 ) {
case 6: {
const double P1 = 0.11169079483905, P2 = 0.0549758718227661;
const double A = 0.445948490915965, B = 0.091576213509771;
- add( 2*B-1, 1-4*B, 4*P2 );
+ add( 2*B-1, 1-4*B, 4*P2 );
add( 2*B-1, 2*B-1, 4*P2 );
add( 1-4*B, 2*B-1, 4*P2 );
add( 1-4*A, 2*A-1, 4*P1 );
- add( 2*A-1, 1-4*A, 4*P1 );
+ add( 2*A-1, 1-4*A, 4*P1 );
add( 2*A-1, 2*A-1, 4*P1 ); break;
}
default:
THROW_IK_EXCEPTION("TGaussDef: Invalid nb of gauss points for TRIA, variant 2: "
- <<nbGauss);
+ <<nbGauss);
}
}
else if ( variant == 3 ) {
}
default:
THROW_IK_EXCEPTION("TGaussDef: Invalid nb of gauss points for TRIA, variant 3: "
- <<nbGauss);
+ <<nbGauss);
}
}
break;
}
default:
THROW_IK_EXCEPTION("TGaussDef: Invalid nb of gauss points for QUAD, variant 1: "
- <<nbGauss);
+ <<nbGauss);
}
}
else if ( variant == 2 ) {
}
default:
THROW_IK_EXCEPTION("TGaussDef: Invalid nb of gauss points for QUAD, variant 1: "
- <<nbGauss);
+ <<nbGauss);
}
}
else if ( variant == 3 ) {
}
default:
THROW_IK_EXCEPTION("TGaussDef: Invalid nb of gauss points for QUAD, variant 3: "
- <<nbGauss);
+ <<nbGauss);
}
}
break;
add( 0., 0., h3, p3 ); break;
}
case 27: { // FPG27
- const double a1 = 0.788073483;
- const double b6 = 0.499369002;
- const double b1 = 0.848418011;
- const double c8 = 0.478508449;
- const double c1 = 0.652816472;
- const double d12 = 0.032303742;
+ const double a1 = 0.788073483;
+ const double b6 = 0.499369002;
+ const double b1 = 0.848418011;
+ const double c8 = 0.478508449;
+ const double c1 = 0.652816472;
+ const double d12 = 0.032303742;
const double d1 = 1.106412899;
double z = 1/2., fz = b1/2*(1 - z);
add( 0., 0., z, a1 ); // 1
THROW_IK_EXCEPTION("TGaussDef: Not all gauss points defined");
}
}
-
+
//================================================================================
/*!
* \brief Return dimension for the given cell type
static const int tria6 [] = {0,2,4, 1,3,5};
static const int seg3 [] = {0,2,1};
if ( conn.empty() )
- {
- conn.resize( MaxMedCellType + 1, 0 );
- conn[ NORM_HEXA20 ] = hexa20;
- conn[ NORM_PENTA15] = penta15;
- conn[ NORM_PYRA13 ] = pyra13;
- conn[ NORM_TETRA10] = tetra10;
- conn[ NORM_SEG3 ] = seg3;
- conn[ NORM_TRI6 ] = tria6;
- conn[ NORM_QUAD8 ] = quad8;
- }
+ {
+ conn.resize( MaxMedCellType + 1, 0 );
+ conn[ NORM_HEXA20 ] = hexa20;
+ conn[ NORM_PENTA15] = penta15;
+ conn[ NORM_PYRA13 ] = pyra13;
+ conn[ NORM_TETRA10] = tetra10;
+ conn[ NORM_SEG3 ] = seg3;
+ conn[ NORM_TRI6 ] = tria6;
+ conn[ NORM_QUAD8 ] = quad8;
+ }
return conn[ type ];
}
{
if ( ma._sortedNodeIDs )
{
- _sortedNodeIDs = new int[ _nodes.size() ];
+ _sortedNodeIDs = new TID[ _nodes.size() ];
std::copy( ma._sortedNodeIDs, ma._sortedNodeIDs + _nodes.size(), _sortedNodeIDs );
}
}
SauvUtilities::Link Cell::link(int i) const
{
- int i2 = ( i + 1 ) % _nodes.size();
+ std::size_t i2 = ( i + 1 ) % _nodes.size();
if ( _reverse )
return std::make_pair( _nodes[i2]->_number, _nodes[i]->_number );
else
const TID* Cell::getSortedNodes() const
{
if ( !_sortedNodeIDs )
- {
- size_t l=_nodes.size();
- _sortedNodeIDs = new int[ l ];
+ {
+ size_t l=_nodes.size();
+ _sortedNodeIDs = new TID[ l ];
- for (size_t i=0; i!=l; ++i)
- _sortedNodeIDs[i]=_nodes[i]->_number;
- std::sort( _sortedNodeIDs, _sortedNodeIDs + l );
- }
+ for (size_t i=0; i!=l; ++i)
+ _sortedNodeIDs[i]=_nodes[i]->_number;
+ std::sort( _sortedNodeIDs, _sortedNodeIDs + l );
+ }
return _sortedNodeIDs;
}
if ( _nodes.size() == 1 )
return _nodes[0] < ma._nodes[0];
- const int* v1 = getSortedNodes();
- const int* v2 = ma.getSortedNodes();
- for ( const int* vEnd = v1 + _nodes.size(); v1 < vEnd; ++v1, ++v2 )
+ const TID* v1 = getSortedNodes();
+ const TID* v2 = ma.getSortedNodes();
+ for ( const TID* vEnd = v1 + _nodes.size(); v1 < vEnd; ++v1, ++v2 )
if(*v1 != *v2)
return *v1 < *v2;
return false;
*/
//================================================================================
-int Group::size() const
+mcIdType Group::size() const
{
- int sizze = 0;
+ std::size_t sizze = 0;
if ( !_relocTable.empty() )
sizze = _relocTable.size();
else if ( _medGroup )
else
for ( size_t i = 0; i < _groups.size(); ++i )
sizze += _groups[i]->size();
- return sizze;
+ return ToIdType( sizze );
}
//================================================================================
bool aResult = true;
// Check the state of the buffer;
// if there is too little left, read the next portion of data
- int nBytesRest = _eptr - _ptr;
+ std::size_t nBytesRest = _eptr - _ptr;
if (nBytesRest < GIBI_MaxOutputLen)
{
if (nBytesRest > 0)
{
// move the remaining portion to the buffer beginning
- for ( int i = 0; i < nBytesRest; ++i )
+ for ( std::size_t i = 0; i < nBytesRest; ++i )
_start[i] = _ptr[i];
//memcpy (_tmpBuf, _ptr, nBytesRest);
//memcpy (_start, _tmpBuf, nBytesRest);
nBytesRest = 0;
}
_ptr = _start;
- const int nBytesRead = ::read (_file,
- &_start [nBytesRest],
- GIBI_BufferSize - nBytesRest);
+ const std::size_t nBytesRead = ::read (_file,
+ &_start [nBytesRest],
+ GIBI_BufferSize - nBytesRest);
nBytesRest += nBytesRead;
_eptr = &_start [nBytesRest];
}
{
_curPos = 0;
}
- _curLocale.clear();
}
//================================================================================
void ASCIIReader::initDoubleReading(int nbValues)
{
- init( nbValues, 3, 22 );
-
- // Correction 2 of getDouble(): set "C" numeric locale to read numbers
- // with dot decimal point separator, as it is in SAUVE files
- _curLocale = setlocale(LC_NUMERIC, "C");
+ init( nbValues, 3, 22 );
}
//================================================================================
else
{
_curPos = 0;
- if ( !_curLocale.empty() )
- {
- setlocale(LC_NUMERIC, _curLocale.c_str());
- _curLocale.clear();
- }
}
}
// 53619905 | 1 2 6 8
// 53619906 | SCALAIRE
// 53619907 | -63312600499 1 0 0 0 -2 0 2
- // where -63312600499 is actualy -633 and 12600499
+ // where -63312600499 is actually -633 and 12600499
char hold=_curPos[_width];
_curPos[_width] = '\0';
int result = atoi( _curPos );
float ASCIIReader::getFloat() const
{
- return getDouble();
+ return (float)getDouble();
}
//================================================================================
//0123456789012345678901234567890123456789012345678901234567890123456789
const size_t posE = 18;
std::string aStr (_curPos);
- if ( aStr.find('E') < 0 && aStr.find('e') < 0 )
+ if ( aStr.find('E') == std::string::npos && aStr.find('e') == std::string::npos )
{
if ( aStr.size() < posE+1 )
THROW_IK_EXCEPTION("No more doubles (line #" << lineNb() << ")");
XDRReader::~XDRReader()
{
-#ifdef HAS_XDR
+#ifdef HAS_XDR
if ( _xdrs_file )
{
xdr_destroy((XDR*)_xdrs);
#ifdef HAS_XDR
#ifdef WIN32
if ((_xdrs_file = ::fopen(_fileName.c_str(), "rb")))
-#else
- if ((_xdrs_file = ::fopen(_fileName.c_str(), "r")))
+#else
+ if ((_xdrs_file = ::fopen(_fileName.c_str(), "r")))
#endif
- {
- _xdrs = (XDR *)malloc(sizeof(XDR));
- xdrstdio_create((XDR*)_xdrs, _xdrs_file, XDR_DECODE);
+ {
+ _xdrs = (XDR *)malloc(sizeof(XDR));
+ xdrstdio_create((XDR*)_xdrs, _xdrs_file, XDR_DECODE);
- const int maxsize = 10;
- char icha[maxsize+1];
- char* icha2 = icha;
- if (( xdr_ok = xdr_string((XDR*)_xdrs, &icha2, maxsize)))
- {
- icha[maxsize] = '\0';
- xdr_ok = (strcmp(icha, "CASTEM XDR") == 0);
- }
- if ( !xdr_ok )
- {
- xdr_destroy((XDR*)_xdrs);
- free((XDR*)_xdrs);
- fclose(_xdrs_file);
- _xdrs_file = NULL;
- }
- }
+ const int maxsize = 10;
+ char icha[maxsize+1];
+ char* icha2 = icha;
+ if (( xdr_ok = xdr_string((XDR*)_xdrs, &icha2, maxsize)))
+ {
+ icha[maxsize] = '\0';
+ xdr_ok = (strcmp(icha, "CASTEM XDR") == 0);
+ }
+ if ( !xdr_ok )
+ {
+ xdr_destroy((XDR*)_xdrs);
+ free((XDR*)_xdrs);
+ fclose(_xdrs_file);
+ _xdrs_file = NULL;
+ }
+ }
#endif
return xdr_ok;
}
Group* IntermediateMED::addNewGroup(std::vector<SauvUtilities::Group*>* groupsToFix)
{
- if ( _groups.size() == _groups.capacity() ) // re-allocation would occure
+ if ( _groups.size() == _groups.capacity() ) // re-allocation would occur
{
std::vector<Group> newGroups( _groups.size() );
newGroups.push_back( Group() );
// correct pointers to sub-groups
for ( size_t j = 0; j < _groups[i]._groups.size(); ++j )
{
- int iG = _groups[i]._groups[j] - &_groups[0];
+ std::size_t iG = _groups[i]._groups[j] - &_groups[0];
newGroups[i]._groups[j] = & newGroups[ iG ];
}
}
for ( size_t i = 0; i < groupsToFix->size(); ++i )
if ( (*groupsToFix)[i] )
{
- int iG = (*groupsToFix)[i] - &_groups[0];
+ std::size_t iG = (*groupsToFix)[i] - &_groups[0];
(*groupsToFix)[i] = & newGroups[ iG ];
}
for ( size_t j = 0; j < fields[i]->_sub.size(); ++j )
if ( fields[i]->_sub[j]._support )
{
- int iG = fields[i]->_sub[j]._support - &_groups[0];
+ std::size_t iG = fields[i]->_sub[j]._support - &_groups[0];
fields[i]->_sub[j]._support = & newGroups[ iG ];
}
if ( fields[i]->_group )
{
- int iG = fields[i]->_group - &_groups[0];
+ std::size_t iG = fields[i]->_group - &_groups[0];
fields[i]->_group = & newGroups[ iG ];
}
}
//================================================================================
/*!
- * \brief Makes ParaMEDMEM::MEDFileData from self
+ * \brief Makes MEDCoupling::MEDFileData from self
*/
//================================================================================
-ParaMEDMEM::MEDFileData* IntermediateMED::convertInMEDFileDS()
+MEDCoupling::MEDFileData* IntermediateMED::convertInMEDFileDS()
{
- MEDCouplingAutoRefCountObjectPtr< MEDFileUMesh > mesh = makeMEDFileMesh();
- MEDCouplingAutoRefCountObjectPtr< MEDFileFields > fields = makeMEDFileFields(mesh);
+ MCAuto< MEDFileUMesh > mesh = makeMEDFileMesh();
+ MCAuto< MEDFileFields > fields = makeMEDFileFields(mesh);
- MEDCouplingAutoRefCountObjectPtr< MEDFileMeshes > meshes = MEDFileMeshes::New();
- MEDCouplingAutoRefCountObjectPtr< MEDFileData > medData = MEDFileData::New();
+ MCAuto< MEDFileMeshes > meshes = MEDFileMeshes::New();
+ MCAuto< MEDFileData > medData = MEDFileData::New();
meshes->pushMesh( mesh );
medData->setMeshes( meshes );
if ( fields ) medData->setFields( fields );
//================================================================================
/*!
- * \brief Creates ParaMEDMEM::MEDFileUMesh from its data
+ * \brief Creates MEDCoupling::MEDFileUMesh from its data
*/
//================================================================================
-ParaMEDMEM::MEDFileUMesh* IntermediateMED::makeMEDFileMesh()
+MEDCoupling::MEDFileUMesh* IntermediateMED::makeMEDFileMesh()
{
// check if all needed piles are present
checkDataAvailability();
- // set long names
+ decreaseHierarchicalDepthOfSubgroups();
+
+ // set long names (before orienting!)
setGroupLongNames();
// fix element orientation
orientElements3D();
// process groups
- decreaseHierarchicalDepthOfSubgroups();
eraseUselessGroups();
//detectMixDimGroups();
void IntermediateMED::setGroupLongNames()
{
+ if ( _listGIBItoMED_mail.empty() )
+ return;
+
+ // IMP 0023285: only keep the meshes named in the table MED_MAIL
+ // clear all group names
+ for ( size_t i = 0; i < _groups.size(); ++i )
+ if ( !_groups[i]._isProfile )
+ _groups[i]._name.clear();
+
+
// IMP 0020434: mapping GIBI names to MED names
// set med names to objects (mesh, fields, support, group or other)
grp._refNames.push_back( _mapStrings[ (*itGIBItoMED).med_id ]);
}
}
+
+ // IMP 0023285: only keep the meshes named in the table MED_MAIL
+ // remove all cells belonging to non-named groups only
+
+ // use Cell::_reverse to mark cells to keep
+ for ( size_t i = 0; i < _groups.size(); ++i )
+ {
+ SauvUtilities::Group & grp = _groups[i];
+ if ( grp._isProfile || !grp._name.empty() )
+ {
+ for ( size_t iC = 0; iC < grp._cells.size(); ++iC )
+ grp._cells[iC]->_reverse = true;
+
+ for (size_t j = 0; j < grp._groups.size(); ++j )
+ for ( size_t iC = 0; iC < grp._groups[j]->_cells.size(); ++iC )
+ grp._groups[j]->_cells[iC]->_reverse = true;
+ }
+ }
+ // remove non-marked cells (with _reverse == false)
+ CellsByDimIterator cellsIt( *this );
+ while ( cellsIt.nextType() )
+ {
+ std::set<Cell> & cells = _cellsByType[ cellsIt.type() ];
+ std::set<Cell>::iterator cIt = cells.begin();
+ while ( cIt != cells.end() )
+ if ( cIt->_reverse )
+ {
+ cIt->_reverse = false;
+ ++cIt;
+ }
+ else
+ {
+ cells.erase( cIt++ );
+ }
+ }
}
//================================================================================
if (medName.find( fields[ifi]->_name + "." ) == 0 )
{
std::vector<DoubleField::_Sub_data>& aSubDs = fields[ifi]->_sub;
- int nbSub = aSubDs.size();
- for (int isu = 0; isu < nbSub; isu++)
+ std::size_t nbSub = aSubDs.size();
+ for (std::size_t isu = 0; isu < nbSub; isu++)
for (int ico = 0; ico < aSubDs[isu].nbComponents(); ico++)
{
if (aSubDs[isu].compName(ico) == gibiName)
void IntermediateMED::decreaseHierarchicalDepthOfSubgroups()
{
for (size_t i=0; i!=_groups.size(); ++i)
- {
- Group& grp = _groups[i];
- for (size_t j = 0; j < grp._groups.size(); ++j )
{
- Group & sub_grp = *grp._groups[j];
- if ( !sub_grp._groups.empty() )
- {
- // replace j with its 1st subgroup
- grp._groups[j] = sub_grp._groups[0];
- // push back the rest subs
- grp._groups.insert( grp._groups.end(), ++sub_grp._groups.begin(), sub_grp._groups.end() );
- }
+ Group& grp = _groups[i];
+ for (size_t j = 0; j < grp._groups.size(); ++j )
+ {
+ Group & sub_grp = *grp._groups[j];
+ if ( !sub_grp._groups.empty() )
+ {
+ // replace j with its 1st subgroup
+ grp._groups[j] = sub_grp._groups[0];
+ // push back the rest subs
+ grp._groups.insert( grp._groups.end(), ++sub_grp._groups.begin(), sub_grp._groups.end() );
+ }
+ }
+ // remove empty sub-_groups
+ std::vector< Group* > newSubGroups;
+ newSubGroups.reserve( grp._groups.size() );
+ for (size_t j = 0; j < grp._groups.size(); ++j )
+ if ( !grp._groups[j]->empty() )
+ newSubGroups.push_back( grp._groups[j] );
+ if ( newSubGroups.size() < grp._groups.size() )
+ grp._groups.swap( newSubGroups );
}
- // remove empty sub-_groups
- std::vector< Group* > newSubGroups;
- newSubGroups.reserve( grp._groups.size() );
- for (size_t j = 0; j < grp._groups.size(); ++j )
- if ( !grp._groups[j]->empty() )
- newSubGroups.push_back( grp._groups[j] );
- if ( newSubGroups.size() < grp._groups.size() )
- grp._groups.swap( newSubGroups );
- }
}
//================================================================================
std::set<Group*> groups2convert;
// keep not named sub-groups of field supports
for (size_t i=0; i!=_groups.size(); ++i)
- {
- Group& grp = _groups[i];
- if ( grp._isProfile && !grp._groups.empty() )
- groups2convert.insert( grp._groups.begin(), grp._groups.end() );
- }
+ {
+ Group& grp = _groups[i];
+ if ( grp._isProfile && !grp._groups.empty() )
+ groups2convert.insert( grp._groups.begin(), grp._groups.end() );
+ }
// keep named groups and their subgroups
for (size_t i=0; i!=_groups.size(); ++i)
- {
- Group& grp = _groups[i];
- if ( !grp._name.empty() && !grp.empty() )
{
- groups2convert.insert( &grp );
- groups2convert.insert( grp._groups.begin(), grp._groups.end() );
+ Group& grp = _groups[i];
+ if ( !grp._name.empty() && !grp.empty() )
+ {
+ groups2convert.insert( &grp );
+ groups2convert.insert( grp._groups.begin(), grp._groups.end() );
+ }
}
- }
// erase groups that are not in groups2convert and not _isProfile
for (size_t i=0; i!=_groups.size(); ++i)
- {
- Group* grp = &_groups[i];
- if ( !grp->_isProfile && !groups2convert.count( grp ) )
{
- grp->_cells.clear();
- grp->_groups.clear();
+ Group* grp = &_groups[i];
+ if ( !grp->_isProfile && !groups2convert.count( grp ) )
+ {
+ grp->_cells.clear();
+ grp->_groups.clear();
+ }
}
- }
}
//================================================================================
{
//hasMixedCells = false;
for ( size_t i=0; i < _groups.size(); ++i )
- {
- Group& grp = _groups[i];
- if ( grp._groups.size() < 2 )
- continue;
-
- // check if sub-groups have different dimension
- unsigned dim1 = getDim( &grp );
- for ( size_t j = 1; j < grp._groups.size(); ++j )
{
- unsigned dim2 = getDim( grp._groups[j] );
- if ( dim1 != dim2 )
- {
- grp._cells.clear();
- grp._groups.clear();
- if ( !grp._name.empty() )
- std::cout << "Erase a group with elements of different dim |" << grp._name << "|"<< std::endl;
- break;
- }
+ Group& grp = _groups[i];
+ if ( grp._groups.size() < 2 )
+ continue;
+
+ // check if sub-groups have different dimension
+ unsigned dim1 = getDim( &grp );
+ for ( size_t j = 1; j < grp._groups.size(); ++j )
+ {
+ unsigned dim2 = getDim( grp._groups[j] );
+ if ( dim1 != dim2 )
+ {
+ grp._cells.clear();
+ grp._groups.clear();
+ if ( !grp._name.empty() )
+ std::cout << "Erase a group with elements of different dim |" << grp._name << "|"<< std::endl;
+ break;
+ }
+ }
}
- }
}
//================================================================================
// if (( x = nodeCoords( elemIt->_nodes[ iNode ])[ 0 ]) < minX )
// minX = x, iLeft = iNode;
- // // indeces of the nodes neighboring the most left one
+ // // indices of the nodes neighboring the most left one
// int iPrev = ( iLeft - 1 < 0 ) ? nbNodes - 1 : iLeft - 1;
// int iNext = ( iLeft + 1 == nbNodes ) ? 0 : iLeft + 1;
// // find components of prev-left and left-next vectors
std::vector< std::pair<int,int> > swapVec;
for ( int dim = 1; dim <= 3; ++dim )
- {
- CellsByDimIterator cellsIt( *this, dim );
- while ( const std::set<Cell > * elems = cellsIt.nextType() )
{
- TCellType cellType = cellsIt.type();
- bool isQuadratic = getGibi2MedQuadraticInterlace( cellType );
- getReverseVector( cellType, swapVec );
+ CellsByDimIterator cellsIt( *this, dim );
+ while ( const std::set<Cell > * elems = cellsIt.nextType() )
+ {
+ TCellType cellType = cellsIt.type();
+ bool isQuadratic = getGibi2MedQuadraticInterlace( cellType );
+ getReverseVector( cellType, swapVec );
- elemIt = elems->begin(), elemEnd = elems->end();
- for ( ; elemIt != elemEnd; elemIt++ )
- {
- // GIBI connectivity -> MED one
- if( isQuadratic )
- ConvertQuadratic( cellType, *elemIt );
+ elemIt = elems->begin(), elemEnd = elems->end();
+ for ( ; elemIt != elemEnd; elemIt++ )
+ {
+ // GIBI connectivity -> MED one
+ if( isQuadratic )
+ ConvertQuadratic( cellType, *elemIt );
- // reverse faces
- if ( elemIt->_reverse )
- reverse ( *elemIt, swapVec );
- }
+ // reverse faces
+ if ( elemIt->_reverse )
+ reverse ( *elemIt, swapVec );
+ }
+ }
}
- }
// COMMENTED for issue 0022612 note 17739
//orientVolumes();
for ( size_t j = 0; j < grp._cells.size(); ++j )
if ( faces.insert( grp._cells[j] ).second )
{
- for ( size_t k = 0; k < grp._cells[j]->_nodes.size(); ++k )
+ for ( unsigned int k = 0; k < grp._cells[j]->_nodes.size(); ++k )
linkFacesMap[ grp._cells[j]->link( k ) ].push_back( grp._cells[j] );
fgm.insert( std::make_pair( grp._cells[j], &grp ));
}
// Each oriented link must appear in one face only, else a face is reversed.
std::queue<const Cell*> faceQueue; /* the queue contains well oriented faces
- whose neighbors orientation is to be checked */
+ whose neighbors orientation is to be checked */
bool manifold = true;
while ( !linkFacesMap.empty() )
{
// check if re-numeration is needed (to try to keep elem oreder as in sauve file )
bool ok = true, renumEntity = false;
CellsByDimIterator cellsIt( *this, dim );
- int prevNbElems = 0;
+ mcIdType prevNbElems = 0;
while ( const std::set<Cell> * typeCells = cellsIt.nextType() )
{
TID minNumber = std::numeric_limits<TID>::max(), maxNumber = 0;
if ( elemIt->_number < minNumber ) minNumber = elemIt->_number;
if ( elemIt->_number > maxNumber ) maxNumber = elemIt->_number;
}
- TID typeSize = typeCells->size();
+ mcIdType typeSize = ToIdType( typeCells->size() );
if ( typeSize != maxNumber - minNumber + 1 )
ok = false;
- if ( prevNbElems != 0 ) {
- if ( minNumber == 1 )
- renumEntity = true;
- else if ( prevNbElems+1 != (int)minNumber )
- ok = false;
- }
+ if ( prevNbElems+1 != (int)minNumber )
+ ok = false;
+ if ( prevNbElems != 0 && minNumber == 1 )
+ renumEntity = true;
+
prevNbElems += typeSize;
}
if ( ok && renumEntity ) // each geom type was numerated separately
{
cellsIt.init( dim );
- prevNbElems = cellsIt.nextType()->size(); // no need to renumber the first type
+ prevNbElems = ToIdType( cellsIt.nextType()->size()); // no need to renumber the first type
while ( const std::set<Cell> * typeCells = cellsIt.nextType() )
{
for ( elemIt = typeCells->begin(), elemEnd = typeCells->end(); elemIt!=elemEnd; ++elemIt)
elemIt->_number += prevNbElems;
- prevNbElems += typeCells->size();
+ prevNbElems += ToIdType( typeCells->size() );
}
}
if ( !ok )
*/
//================================================================================
-ParaMEDMEM::DataArrayDouble * IntermediateMED::getCoords()
+MEDCoupling::DataArrayDouble * IntermediateMED::getCoords()
{
DataArrayDouble* coordArray = DataArrayDouble::New();
coordArray->alloc( _nbNodes, _spaceDim );
double * coordPrt = coordArray->getPointer();
- for ( int i = 0, nb = _points.size(); i < nb; ++i )
+ for ( unsigned int i = 0; i < _points.size(); ++i )
{
Node* n = getNode( i+1 );
if ( n->isUsed() )
*/
//================================================================================
-void IntermediateMED::setConnectivity( ParaMEDMEM::MEDFileUMesh* mesh,
- ParaMEDMEM::DataArrayDouble* coords )
+void IntermediateMED::setConnectivity( MEDCoupling::MEDFileUMesh* mesh,
+ MEDCoupling::DataArrayDouble* coords )
{
int meshDim = 0;
std::set<Cell>::const_iterator elemIt, elemEnd;
for ( int dim = 3; dim > 0; --dim )
- {
- CellsByDimIterator dimCells( *this, dim );
+ {
+ CellsByDimIterator dimCells( *this, dim );
- int nbOfCells = 0;
- while ( const std::set<Cell > * cells = dimCells.nextType() )
- nbOfCells += cells->size();
- if ( nbOfCells == 0 )
- continue;
+ mcIdType nbOfCells = 0;
+ while ( const std::set<Cell > * cells = dimCells.nextType() )
+ nbOfCells += ToIdType( cells->size() );
+ if ( nbOfCells == 0 )
+ continue;
- if ( !meshDim ) meshDim = dim;
+ if ( !meshDim ) meshDim = dim;
- MEDCouplingUMesh* dimMesh = MEDCouplingUMesh::New();
- dimMesh->setCoords( coords );
- dimMesh->setMeshDimension( dim );
- dimMesh->allocateCells( nbOfCells );
+ MEDCouplingUMesh* dimMesh = MEDCouplingUMesh::New();
+ dimMesh->setCoords( coords );
+ dimMesh->setMeshDimension( dim );
+ dimMesh->allocateCells( nbOfCells );
- int prevNbCells = 0;
- dimCells.init( dim );
- while ( const std::set<Cell > * cells = dimCells.nextType() )
- {
- // fill connectivity array to take into account order of elements in the sauv file
- const int nbCellNodes = cells->begin()->_nodes.size();
- std::vector< TID > connectivity( cells->size() * nbCellNodes );
- int * nodalConnOfCell;
- for ( elemIt = cells->begin(), elemEnd = cells->end(); elemIt != elemEnd; ++elemIt )
- {
- const Cell& cell = *elemIt;
- const int index = cell._number - 1 - prevNbCells;
- nodalConnOfCell = &connectivity[ index * nbCellNodes ];
- if ( cell._reverse )
- for ( int i = nbCellNodes-1; i >= 0; --i )
- *nodalConnOfCell++ = cell._nodes[i]->_number - 1;
- else
- for ( int i = 0; i < nbCellNodes; ++i )
- *nodalConnOfCell++ = cell._nodes[i]->_number - 1;
- }
- prevNbCells += cells->size();
+ mcIdType prevNbCells = 0;
+ dimCells.init( dim );
+ while ( const std::set<Cell > * cells = dimCells.nextType() )
+ {
+ // fill connectivity array to take into account order of elements in the sauv file
+ const mcIdType nbCellNodes = ToIdType( cells->begin()->_nodes.size() );
+ std::vector< TID > connectivity( cells->size() * nbCellNodes );
+ TID * nodalConnOfCell;
+ for ( elemIt = cells->begin(), elemEnd = cells->end(); elemIt != elemEnd; ++elemIt )
+ {
+ const Cell& cell = *elemIt;
+ const TID index = cell._number - 1 - prevNbCells;
+ nodalConnOfCell = &connectivity[ index * nbCellNodes ];
+ if ( cell._reverse )
+ for ( mcIdType i = nbCellNodes-1; i >= 0; --i )
+ *nodalConnOfCell++ = cell._nodes[i]->_number - 1;
+ else
+ for ( mcIdType i = 0; i < nbCellNodes; ++i )
+ *nodalConnOfCell++ = cell._nodes[i]->_number - 1;
+ }
+ prevNbCells += ToIdType( cells->size() );
- // fill dimMesh
- TCellType cellType = dimCells.type();
- nodalConnOfCell = &connectivity[0];
- for ( size_t i = 0; i < cells->size(); ++i, nodalConnOfCell += nbCellNodes )
- dimMesh->insertNextCell( cellType, nbCellNodes, nodalConnOfCell );
- }
- dimMesh->finishInsertingCells();
- mesh->setMeshAtLevel( dim - meshDim, dimMesh );
- dimMesh->decrRef();
- }
+ // fill dimMesh
+ TCellType cellType = dimCells.type();
+ nodalConnOfCell = &connectivity[0];
+ for ( size_t i = 0; i < cells->size(); ++i, nodalConnOfCell += nbCellNodes )
+ dimMesh->insertNextCell( cellType, nbCellNodes, nodalConnOfCell );
+ }
+ dimMesh->finishInsertingCells();
+ mesh->setMeshAtLevel( dim - meshDim, dimMesh );
+ dimMesh->decrRef();
+ }
}
//================================================================================
*/
//================================================================================
-void IntermediateMED::setGroups( ParaMEDMEM::MEDFileUMesh* mesh )
+void IntermediateMED::setGroups( MEDCoupling::MEDFileUMesh* mesh )
{
bool isMeshNameSet = false;
const int meshDim = mesh->getMeshDimension();
{
const int meshDimRelToMaxExt = ( dim == 0 ? 1 : dim - meshDim );
- std::vector<const DataArrayInt *> medGroups;
- std::vector<MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > refGroups;
+ std::vector<const DataArrayIdType *> medGroups;
+ std::vector<MCAuto<DataArrayIdType> > refGroups;
for ( size_t i = 0; i < _groups.size(); ++i )
{
Group& grp = _groups[i];
}
}
// create a med group
- grp._medGroup = DataArrayInt::New();
+ grp._medGroup = DataArrayIdType::New();
grp._medGroup->setName( grp._name.c_str() );
grp._medGroup->alloc( cell2order.size(), /*nbOfCompo=*/1 );
- int * idsPtr = grp._medGroup->getPointer();
+ TID * idsPtr = grp._medGroup->getPointer();
TCellToOrderMap::iterator cell2orderIt, cell2orderEnd = cell2order.end();
for ( cell2orderIt = cell2order.begin(); cell2orderIt != cell2orderEnd; ++cell2orderIt )
*idsPtr++ = (*cell2orderIt).first->_number - 1;
// Issue 0021311. Use case: a gibi group has references (recorded in pile 1)
// and several names (pile 27) refer (pile 10) to this group.
// We create a copy of this group per each named reference
+ std::set<std::string> uniqueNames;
+ uniqueNames.insert( grp._name );
for ( unsigned iRef = 0 ; iRef < grp._refNames.size(); ++iRef )
- if ( !grp._refNames[ iRef ].empty() )
+ if ( !grp._refNames[ iRef ].empty() &&
+ uniqueNames.insert( grp._refNames[ iRef ]).second ) // for name uniqueness (23155)
{
- refGroups.push_back( grp._medGroup->deepCpy() );
+ refGroups.push_back( grp._medGroup->deepCopy() );
refGroups.back()->setName( grp._refNames[ iRef ].c_str() );
medGroups.push_back( refGroups.back() );
}
{
int dim = getDim( grp );
- int nbElems = 0;
+ mcIdType nbElems = 0;
if ( dim == 0 )
{
nbElems = _nbNodes;
{
CellsByDimIterator dimCells( *this, dim );
while ( const std::set<Cell > * cells = dimCells.nextType() )
- nbElems += cells->size();
+ nbElems += ToIdType( cells->size() );
int meshDim = 3;
for ( ; meshDim > 0; --meshDim )
*/
//================================================================================
-ParaMEDMEM::MEDFileFields * IntermediateMED::makeMEDFileFields(ParaMEDMEM::MEDFileUMesh* mesh)
+MEDCoupling::MEDFileFields * IntermediateMED::makeMEDFileFields(MEDCoupling::MEDFileUMesh* mesh)
{
if ( _nodeFields.empty() && _cellFields.empty() ) return 0;
MEDFileFields* fields = MEDFileFields::New();
- for ( size_t i = 0; i < _nodeFields.size(); ++i )
+ for ( unsigned int i = 0; i < _nodeFields.size(); ++i )
setFields( _nodeFields[i], fields, mesh, i+1, usedFieldNames );
- for ( size_t i = 0; i < _cellFields.size(); ++i )
+ for ( unsigned int i = 0; i < _cellFields.size(); ++i )
setFields( _cellFields[i], fields, mesh, i+1, usedFieldNames );
return fields;
//================================================================================
void IntermediateMED::setFields( SauvUtilities::DoubleField* fld,
- ParaMEDMEM::MEDFileFields* medFields,
- ParaMEDMEM::MEDFileUMesh* mesh,
+ MEDCoupling::MEDFileFields* medFields,
+ MEDCoupling::MEDFileUMesh* mesh,
const TID castemID,
std::set< std::string >& usedFieldNames)
{
std::cout << "Castem field #" << castemID << " <" << fld->_name
<< "> is incompatible with MED format, so we split it into several fields:" << std::endl;
- for ( size_t iSub = 0; iSub < fld->_sub.size(); )
+ for ( unsigned int iSub = 0; iSub < fld->_sub.size(); )
{
// set field name
if ( !uniteSubs || fld->_name.empty() )
double * valPtr = values->getPointer();
if ( uniteSubs )
{
- int nbElems = fld->_group->size();
- for ( int elemShift = 0; elemShift < nbElems && iSub < fld->_sub.size(); )
+ mcIdType nbElems = fld->_group->size();
+ for ( mcIdType elemShift = 0; elemShift < nbElems && iSub < fld->_sub.size(); )
elemShift += fld->setValues( valPtr, iSub++, elemShift );
setTS( fld, values, medFields, mesh );
}
fld->setValues( valPtr, iSub );
setTS( fld, values, medFields, mesh, iSub++ );
- std::cout << fld->_name << " with compoments";
+ std::cout << fld->_name << " with components";
for ( size_t i = 0; i < (size_t)fld->_sub[iSub-1].nbComponents(); ++i )
std::cout << " " << fld->_sub[iSub-1]._comp_names[ i ];
std::cout << std::endl;
//================================================================================
void IntermediateMED::setTS( SauvUtilities::DoubleField* fld,
- ParaMEDMEM::DataArrayDouble* values,
- ParaMEDMEM::MEDFileFields* medFields,
- ParaMEDMEM::MEDFileUMesh* mesh,
+ MEDCoupling::DataArrayDouble* values,
+ MEDCoupling::MEDFileFields* medFields,
+ MEDCoupling::MEDFileUMesh* mesh,
const int iSub)
{
// treat a field support
// set the mesh
if ( onAll )
{
- MEDCouplingAutoRefCountObjectPtr
+ MCAuto
< MEDCouplingUMesh > dimMesh = mesh->getMeshAtLevel( dimRel );
timeStamp->setMesh( dimMesh );
}
- else if ( timeStamp->getTypeOfField() == ParaMEDMEM::ON_NODES )
+ else if ( timeStamp->getTypeOfField() == MEDCoupling::ON_NODES )
{
DataArrayDouble * coo = mesh->getCoords();
- MEDCouplingAutoRefCountObjectPtr
+ MCAuto
<DataArrayDouble> subCoo = coo->selectByTupleId(support->_medGroup->begin(),
support->_medGroup->end());
- MEDCouplingAutoRefCountObjectPtr< MEDCouplingUMesh > nodeSubMesh =
+ MCAuto< MEDCouplingUMesh > nodeSubMesh =
MEDCouplingUMesh::Build0DMeshFromCoords( subCoo );
timeStamp->setMesh( nodeSubMesh );
}
else
{
- MEDCouplingAutoRefCountObjectPtr
+ MCAuto
< MEDCouplingUMesh > dimMesh = mesh->getMeshAtLevel( dimRel );
- MEDCouplingAutoRefCountObjectPtr
+ MCAuto
<MEDCouplingMesh> subMesh = dimMesh->buildPart(support->_medGroup->begin(),
support->_medGroup->end());
timeStamp->setMesh( subMesh);
timeStamp->setArray( values );
values->decrRef();
// set gauss points
- if ( timeStamp->getTypeOfField() == ParaMEDMEM::ON_GAUSS_PT )
+ if ( timeStamp->getTypeOfField() == MEDCoupling::ON_GAUSS_PT )
{
TGaussDef gaussDef( fld->_sub[iSub]._support->_cellType,
fld->_sub[iSub].nbGauss() );
timeStamp->setOrder( nbTS );
// add the time-stamp
- timeStamp->checkCoherency();
+ timeStamp->checkConsistencyLight();
if ( onAll )
fld->_curMedField->appendFieldNoProfileSBT( timeStamp );
else
bool DoubleField::isMedCompatible(bool& sameNbGauss) const
{
- for ( size_t iSub = 0; iSub < _sub.size(); ++iSub )
+ for ( unsigned int iSub = 0; iSub < _sub.size(); ++iSub )
{
if ( !getSupport(iSub) || !getSupport(iSub)->_medGroup )
THROW_IK_EXCEPTION("SauvReader INTERNAL ERROR: NULL field support");
std::vector< _Sub_data >::const_iterator sub_data = _sub.begin();
const _Sub_data& first_sub_data = *sub_data;
for ( ++sub_data ; sub_data != _sub.end(); ++sub_data )
- {
- if ( first_sub_data._comp_names != sub_data->_comp_names )
- return false; // diff names of components
+ {
+ if ( first_sub_data._comp_names != sub_data->_comp_names )
+ return false; // diff names of components
- if ( first_sub_data._nb_gauss != sub_data->_nb_gauss &&
- first_sub_data._support->_cellType == sub_data->_support->_cellType)
- return false; // diff nb of gauss points on same cell type
- }
+ if ( first_sub_data._nb_gauss != sub_data->_nb_gauss &&
+ first_sub_data._support->_cellType == sub_data->_support->_cellType)
+ return false; // diff nb of gauss points on same cell type
+ }
return true;
}
*/
//================================================================================
-ParaMEDMEM::TypeOfField DoubleField::getMedType( const int iSub ) const
+MEDCoupling::TypeOfField DoubleField::getMedType( const int iSub ) const
{
using namespace INTERP_KERNEL;
*/
//================================================================================
-ParaMEDMEM::TypeOfTimeDiscretization DoubleField::getMedTimeDisc() const
+MEDCoupling::TypeOfTimeDiscretization DoubleField::getMedTimeDisc() const
{
return ONE_TIME;
// NO_TIME = 4,
*/
//================================================================================
-int DoubleField::getNbTuples( const int iSub ) const
+mcIdType DoubleField::getNbTuples( const int iSub ) const
{
- int nb = 0;
+ mcIdType nb = 0;
if ( hasCommonSupport() && !_group->_groups.empty() )
for ( size_t i = 0; i < _group->_groups.size(); ++i )
nb += _sub[i].nbGauss() * _sub[i]._support->size();
*/
//================================================================================
-int DoubleField::setValues( double * valPtr, const int iSub, const int elemShift ) const
+mcIdType DoubleField::setValues( double * valPtr, const int iSub, const mcIdType elemShift ) const
{
// find values for iSub
int iComp = 0;
// Set values
- const std::vector< unsigned >& relocTable = getSupport( iSub )->_relocTable;
+ const std::vector< mcIdType >& relocTable = getSupport( iSub )->_relocTable;
- const int nbElems = _sub[iSub]._support->size();
+ const mcIdType nbElems = _sub[iSub]._support->size();
const int nbGauss = _sub[iSub].nbGauss();
const int nbComponents = _sub[iSub].nbComponents();
const int nbValsByElem = nbComponents * nbGauss;
// check nb values
- int nbVals = 0;
+ mcIdType nbVals = 0;
for ( iComp = 0; iComp < nbComponents; ++iComp )
- nbVals += compValues[iComp].size();
+ nbVals += ToIdType( compValues[iComp].size() );
const bool isConstField = ( nbVals == nbComponents ); // one value per component (issue 22321)
if ( !isConstField && nbVals != nbElems * nbValsByElem )
THROW_IK_EXCEPTION("SauvMedConvertor.cxx: support size mismatches field size");
// compute nb values in previous subs
- int valsShift = 0;
- for ( int iS = iSub-1, shift = elemShift; shift > 0; --iS)
+ mcIdType valsShift = 0;
+ for ( mcIdType iS = iSub-1, shift = elemShift; shift > 0; --iS)
{
- int nbE = _sub[iS]._support->size();
+ mcIdType nbE = _sub[iS]._support->size();
shift -= nbE;
valsShift += nbE * _sub[iS].nbComponents() * _sub[iS].nbGauss();
}
if ( isConstField )
- for ( int iE = 0; iE < nbElems; ++iE )
+ for ( mcIdType iE = 0; iE < nbElems; ++iE )
{
- int iMed = valsShift + nbValsByElem * ( relocTable.empty() ? iE : relocTable[iE+elemShift]-elemShift );
+ mcIdType iMed = valsShift + nbValsByElem * ( relocTable.empty() ? iE : relocTable[iE+elemShift]-elemShift );
for ( iComp = 0; iComp < nbComponents; ++iComp )
valPtr[ iMed + iComp ] = compValues[iComp][ 0 ];
}
else
- for ( int iE = 0; iE < nbElems; ++iE )
+ for ( mcIdType iE = 0; iE < nbElems; ++iE )
{
- int iMed = valsShift + nbValsByElem * ( relocTable.empty() ? iE : relocTable[iE+elemShift]-elemShift );
+ mcIdType iMed = valsShift + nbValsByElem * ( relocTable.empty() ? iE : relocTable[iE+elemShift]-elemShift );
for ( iComp = 0; iComp < nbComponents; ++iComp )
for ( int iG = 0; iG < nbGauss; ++iG )
valPtr[ iMed + iG * nbComponents + iComp ] = compValues[iComp][ iE * nbGauss + iG ];
init( dimm );
}
/*!
- * \brief Initialize iteration on cells of given dimention
+ * \brief Initialize iteration on cells of given dimension
*/
void CellsByDimIterator::init(const int dimm)
{
return typp < myTypeEnd ? getDimension( TCellType( typp )) : 4;
}
// END CellsByDimIterator ========================================================
-
