--- /dev/null
+---
+Checks: -*,clang-diagnostic-*,-clang-diagnostic-sign-conversion,clang-analyzer-*,modernize-use-override,modernize-use-nullptr,modernize-use-default-member-init,modernize-loop-convert,modernize-use-auto,modernize-redundant-void-arg,modernize-type-traits,modernize-use-bool-literals,modernize-use-equals-default,modernize-use-equals-delete,misc-const-correctness,misc-unused-parameters,misc-definitions-in-headers,misc-header-include-cycle,misc-redundant-expression,misc-static-assert
+WarningsAsErrors: ''
+HeaderFileExtensions:
+ - ''
+ - h
+ - hh
+ - hpp
+ - hxx
+ - txx
+ImplementationFileExtensions:
+ - c
+ - cc
+ - cpp
+ - cxx
+HeaderFilterRegex: ''
+FormatStyle: none
+CheckOptions:
+ cert-dcl16-c.NewSuffixes: L;LL;LU;LLU
+ cert-err33-c.AllowCastToVoid: 'true'
+ cert-err33-c.CheckedFunctions: ::aligned_alloc;::asctime_s;::at_quick_exit;::atexit;::bsearch;::bsearch_s;::btowc;::c16rtomb;::c32rtomb;::calloc;::clock;::cnd_broadcast;::cnd_init;::cnd_signal;::cnd_timedwait;::cnd_wait;::ctime_s;::fclose;::fflush;::fgetc;::fgetpos;::fgets;::fgetwc;::fopen;::fopen_s;::fprintf;::fprintf_s;::fputc;::fputs;::fputwc;::fputws;::fread;::freopen;::freopen_s;::fscanf;::fscanf_s;::fseek;::fsetpos;::ftell;::fwprintf;::fwprintf_s;::fwrite;::fwscanf;::fwscanf_s;::getc;::getchar;::getenv;::getenv_s;::gets_s;::getwc;::getwchar;::gmtime;::gmtime_s;::localtime;::localtime_s;::malloc;::mbrtoc16;::mbrtoc32;::mbsrtowcs;::mbsrtowcs_s;::mbstowcs;::mbstowcs_s;::memchr;::mktime;::mtx_init;::mtx_lock;::mtx_timedlock;::mtx_trylock;::mtx_unlock;::printf_s;::putc;::putwc;::raise;::realloc;::remove;::rename;::scanf;::scanf_s;::setlocale;::setvbuf;::signal;::snprintf;::snprintf_s;::sprintf;::sprintf_s;::sscanf;::sscanf_s;::strchr;::strerror_s;::strftime;::strpbrk;::strrchr;::strstr;::strtod;::strtof;::strtoimax;::strtok;::strtok_s;::strtol;::strtold;::strtoll;::strtoul;::strtoull;::strtoumax;::strxfrm;::swprintf;::swprintf_s;::swscanf;::swscanf_s;::thrd_create;::thrd_detach;::thrd_join;::thrd_sleep;::time;::timespec_get;::tmpfile;::tmpfile_s;::tmpnam;::tmpnam_s;::tss_create;::tss_get;::tss_set;::ungetc;::ungetwc;::vfprintf;::vfprintf_s;::vfscanf;::vfscanf_s;::vfwprintf;::vfwprintf_s;::vfwscanf;::vfwscanf_s;::vprintf_s;::vscanf;::vscanf_s;::vsnprintf;::vsnprintf_s;::vsprintf;::vsprintf_s;::vsscanf;::vsscanf_s;::vswprintf;::vswprintf_s;::vswscanf;::vswscanf_s;::vwprintf_s;::vwscanf;::vwscanf_s;::wcrtomb;::wcschr;::wcsftime;::wcspbrk;::wcsrchr;::wcsrtombs;::wcsrtombs_s;::wcsstr;::wcstod;::wcstof;::wcstoimax;::wcstok;::wcstok_s;::wcstol;::wcstold;::wcstoll;::wcstombs;::wcstombs_s;::wcstoul;::wcstoull;::wcstoumax;::wcsxfrm;::wctob;::wctrans;::wctype;::wmemchr;::wprintf_s;::wscanf;::wscanf_s;
+ cert-oop54-cpp.WarnOnlyIfThisHasSuspiciousField: 'false'
+ cert-str34-c.DiagnoseSignedUnsignedCharComparisons: 'false'
+ cppcoreguidelines-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic: 'true'
+ google-readability-braces-around-statements.ShortStatementLines: '1'
+ google-readability-function-size.StatementThreshold: '800'
+ google-readability-namespace-comments.ShortNamespaceLines: '10'
+ google-readability-namespace-comments.SpacesBeforeComments: '2'
+ llvm-else-after-return.WarnOnConditionVariables: 'false'
+ llvm-else-after-return.WarnOnUnfixable: 'false'
+ llvm-qualified-auto.AddConstToQualified: 'false'
+SystemHeaders: false
namespace ICoCo
{
- MEDDoubleField::MEDDoubleField() : _field(0) {}
+ MEDDoubleField::MEDDoubleField() : _field(nullptr) {}
MEDDoubleField::MEDDoubleField(MEDCoupling::MEDCouplingFieldDouble *field):_field(field)
{
#define ICoCoMEDDoubleField_included
#include "ICoCoField.hxx"
+#include "ICoCo_DeclSpec.hxx"
namespace MEDCoupling
{
/*! @brief Destructor.
*/
- virtual ~MEDDoubleField();
+ ~MEDDoubleField() override;
/*! @brief Get the internal MEDCoupling field object.
* @return a pointer to the MEDCouplingField object detained by this instance. Note that the corresponding
//
#include "ICoCoMEDIntField.h"
+#include "ICoCoMEDIntField.hxx"
#include "MEDCouplingFieldInt32.hxx"
namespace ICoCo
{
- MEDIntField::MEDIntField() : _field(0) {}
+ MEDIntField::MEDIntField() : _field(nullptr) {}
/*! Constructor directly attaching a MEDCouplingFieldInt
the object does not take the control the objects pointed by
#define ICoCoMEDIntField_included
#include "ICoCoField.hxx"
+#include "ICoCo_DeclSpec.hxx"
namespace MEDCoupling
{
/*! @brief Destructor.
*/
- virtual ~MEDIntField();
+ ~MEDIntField() override;
/*! @brief Get the internal MEDCoupling field object.
* @return a pointer to the MEDCouplingField object detained by this instance. Note that the corresponding
#include <vector>
#include <algorithm>
-#include <iostream>
#include <memory>
#include <limits>
#include <cmath>
#ifndef __BBTREEDST_TXX__
#define __BBTREEDST_TXX__
-#include <vector>
#include <algorithm>
+#include <vector>
-#include <iostream>
#include <limits>
#include <cmath>
+#include "MCIdType.hxx"
+
template <int dim>
class BBTreeDst
{
double _min_right;
const double *_bb;
std::vector<mcIdType> _elems;
- double *_terminal;
+ double *_terminal{nullptr};
mcIdType _nbelems;
static const int MIN_NB_ELEMS=15;
static const int MAX_LEVEL=20;
public:
BBTreeDst(const double* bbs, mcIdType* elems, int level, mcIdType nbelems):
- _left(0),_right(0),_level(level),_bb(bbs),_terminal(0),_nbelems(nbelems)
+ _left(0),_right(0),_level(level),_bb(bbs),_nbelems(nbelems)
{
if((nbelems < MIN_NB_ELEMS || level> MAX_LEVEL))
_terminal=new double[2*dim];
fillBBoxTerminal(bbs);
return ;
}
- double *nodes=new double[nbelems];
+ auto *nodes=new double[nbelems];
for (mcIdType i=0; i<nbelems; i++)
nodes[i]=bbs[_elems[i]*dim*2+(level%dim)*2];
std::nth_element<double*>(nodes, nodes+nbelems/2, nodes+nbelems);
- double median = *(nodes+nbelems/2);
+ double const median = *(nodes+nbelems/2);
delete [] nodes;
std::vector<mcIdType> new_elems_left;
std::vector<mcIdType> new_elems_right;
for(mcIdType i=0; i<nbelems;i++)
{
mcIdType elem;
- if (elems!=0)
+ if (elems!=nullptr)
elem= elems[i];
else
elem=i;
_max_left=max_left;
_min_right=min_right;
mcIdType *tmp;
- tmp=0;
+ tmp=nullptr;
if(!new_elems_left.empty())
tmp=&(new_elems_left[0]);
_left=new BBTreeDst(bbs, tmp, level+1, ToIdType(new_elems_left.size()));
- tmp=0;
+ tmp=nullptr;
if(!new_elems_right.empty())
tmp=&(new_elems_right[0]);
_right=new BBTreeDst(bbs, tmp, level+1, ToIdType(new_elems_right.size()));
}
else
{
- double minOfMaxDsts=sqrt(minOfMaxDstsSq);
+ double const minOfMaxDsts=sqrt(minOfMaxDstsSq);
if(_min_right-pt[_level%dim]>minOfMaxDsts)
{ _left->getElemsWhoseMinDistanceToPtSmallerThan(pt,minOfMaxDstsSq,elems); return ; }
if(pt[_level%dim]-_max_left>minOfMaxDsts)
}
else
{
- double minOfMaxDsts=sqrt(minOfMaxDstsSq);
+ double const minOfMaxDsts=sqrt(minOfMaxDstsSq);
if(_min_right-pt[_level%dim]>minOfMaxDsts)
{ _left->getMinDistanceOfMax(pt,minOfMaxDstsSq); return ; }
if(pt[_level%dim]-_max_left>minOfMaxDsts)
for (int idim=0; idim<dim; idim++)
{
double val1=pt[idim]-bbox[idim*2],val2=pt[idim]-bbox[idim*2+1];
- double x=std::max(fabs(val1),fabs(val2));
+ double const x=std::max(fabs(val1),fabs(val2));
zeRes+=x*x;
}
return zeRes;
for (int idim=0; idim<dim; idim++)
{
double val1=pt[idim]-bbox[idim*2],val2=pt[idim]-bbox[idim*2+1];
- char pos=static_cast<char>((( (0.<val1)-(val1<0.) )+( (0.<val2)-(val2<0.) ))/2);// sign(val) = (0.<val)-(val<0.)
+ char const pos=static_cast<char>((( (0.<val1)-(val1<0.) )+( (0.<val2)-(val2<0.) ))/2);// sign(val) = (0.<val)-(val<0.)
if(pos!=0)
{
- double x=pos==1?val2:val1;
+ double const x=pos==1?val2:val1;
zeRes+=x*x;
}
}
#include <vector>
#include <algorithm>
-#include <iostream>
#include <limits>
#include <cmath>
BBTreePts(const double *pts, const ConnType *elems, int level, ConnType nbelems, double epsilon=1e-12):
_left(0),_right(0),_level(level),_pts(pts),_terminal(nbelems < MIN_NB_ELEMS || level> MAX_LEVEL),_nbelems(nbelems),_epsilon(std::abs(epsilon))
{
- double *nodes=new double[nbelems];
+ auto *nodes=new double[nbelems];
_elems.resize(nbelems);
for (ConnType i=0;i<nbelems;i++)
{
#include "BBTree.txx"
#include <memory>
+#include <utility>
+#include <vector>
/*!
* Wrapper over BBTree to deal with ownership of bbox double array.
#include "Intersector3DP1P1.hxx"
#include "NormalizedUnstructuredMesh.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
public:
static const int SPACEDIM=MyMeshType::MY_SPACEDIM;
static const int MESHDIM=MyMeshType::MY_MESHDIM;
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
public:
Barycentric3DIntersectorP1P1(const MyMeshType& targetMesh, const MyMeshType& srcMesh, double precision);
#include "Barycentric3DIntersectorP1P1.hxx"
#include "Intersector3DP1P1.txx"
-#include "MeshUtils.hxx"
+#include "InterpolationUtils.hxx"
+#include "InterpKernelUtilities.hxx"
+#include <vector>
+#include <cstddef>
+#include "NormalizedGeometricTypes"
+#include <cmath>
+#include "CellModel.hxx"
+#include "PointLocatorAlgos.txx"
namespace INTERP_KERNEL
{
template<class MyMeshType, class MyMatrix>
Barycentric3DIntersectorP1P1<MyMeshType,MyMatrix>::~Barycentric3DIntersectorP1P1()
- {
- }
+ = default;
/**
* @param targetCell in C mode.
#ifndef __INTERPKERNELASSERT_HXX__
#define __INTERPKERNELASSERT_HXX__
-#include "InterpKernelException.hxx"
-#include <sstream>
#define IKAssert(a) { bool verdict(a); \
if(!verdict) { std::ostringstream osszz; osszz << "Assertion \"" << #a << "\" failed into " << __FILE__ << " at line " << __LINE__ << " !"; throw INTERP_KERNEL::Exception(osszz.str()); } }
{
}
-INTERP_KERNEL::Exception::Exception(const char *reason, const char *file, int line):_reason(reason)
+INTERP_KERNEL::Exception::Exception(const char *reason, const char * /*file*/, int /*line*/):_reason(reason)
{
}
INTERP_KERNEL::Exception::~Exception() noexcept(true)
-{
-}
+= default;
const char *INTERP_KERNEL::Exception::what() const noexcept(true)
{
INTERPKERNEL_EXPORT Exception(const char *reason);
INTERPKERNEL_EXPORT Exception(const std::string& reason);
INTERPKERNEL_EXPORT Exception(const char *reason, const char *file, int line);
- INTERPKERNEL_EXPORT ~Exception() noexcept(true);
- INTERPKERNEL_EXPORT const char *what() const noexcept(true);
+ INTERPKERNEL_EXPORT ~Exception() noexcept(true) override;
+ INTERPKERNEL_EXPORT const char *what() const noexcept(true) override;
protected:
std::string _reason;
};
#ifndef __INTERPKERNELHASHMAP__
#define __INTERPKERNELHASHMAP__
+#include "InterpKernelHashFun.hxx"
#include "InterpKernelStlExt.hxx"
#include "InterpKernelHashTable.hxx"
+#include <functional>
+#include <memory>
+#include <utility>
+#include <iterator>
namespace INTERP_KERNEL
{
class HashMap
{
private:
- typedef hashtable<std::pair<const _Key, _Tp>,_Key, _HashFn,
- STLEXT::Select1st<std::pair<const _Key, _Tp> >,
- _EqualKey, _Alloc> _Ht;
+ using _Ht = hashtable<std::pair<const _Key, _Tp>, _Key, _HashFn, STLEXT::Select1st<std::pair<const _Key, _Tp>>, _EqualKey, _Alloc>;
_Ht _M_ht;
public:
- typedef typename _Ht::key_type key_type;
- typedef _Tp data_type;
- typedef _Tp mapped_type;
- typedef typename _Ht::value_type value_type;
- typedef typename _Ht::hasher hasher;
- typedef typename _Ht::key_equal key_equal;
-
- typedef typename _Ht::size_type size_type;
- typedef typename _Ht::difference_type difference_type;
- typedef typename _Ht::pointer pointer;
- typedef typename _Ht::const_pointer const_pointer;
- typedef typename _Ht::reference reference;
- typedef typename _Ht::const_reference const_reference;
-
- typedef typename _Ht::iterator iterator;
- typedef typename _Ht::const_iterator const_iterator;
-
- typedef typename _Ht::allocator_type allocator_type;
+ using key_type = typename _Ht::key_type;
+ using data_type = _Tp;
+ using mapped_type = _Tp;
+ using value_type = typename _Ht::value_type;
+ using hasher = typename _Ht::hasher;
+ using key_equal = typename _Ht::key_equal;
+
+ using size_type = typename _Ht::size_type;
+ using difference_type = typename _Ht::difference_type;
+ using pointer = typename _Ht::pointer;
+ using const_pointer = typename _Ht::const_pointer;
+ using reference = typename _Ht::reference;
+ using const_reference = typename _Ht::const_reference;
+
+ using iterator = typename _Ht::iterator;
+ using const_iterator = typename _Ht::const_iterator;
+
+ using allocator_type = typename _Ht::allocator_type;
hasher hash_funct() const { return _M_ht.hash_funct(); }
class HashMultiMap
{
private:
- typedef hashtable<std::pair<const _Key, _Tp>, _Key, _HashFn,
- STLEXT::Select1st<std::pair<const _Key, _Tp> >, _EqualKey, _Alloc>
- _Ht;
+ using _Ht = hashtable<std::pair<const _Key, _Tp>, _Key, _HashFn, STLEXT::Select1st<std::pair<const _Key, _Tp>>, _EqualKey, _Alloc>;
_Ht _M_ht;
public:
- typedef typename _Ht::key_type key_type;
- typedef _Tp data_type;
- typedef _Tp mapped_type;
- typedef typename _Ht::value_type value_type;
- typedef typename _Ht::hasher hasher;
- typedef typename _Ht::key_equal key_equal;
-
- typedef typename _Ht::size_type size_type;
- typedef typename _Ht::difference_type difference_type;
- typedef typename _Ht::pointer pointer;
- typedef typename _Ht::const_pointer const_pointer;
- typedef typename _Ht::reference reference;
- typedef typename _Ht::const_reference const_reference;
-
- typedef typename _Ht::iterator iterator;
- typedef typename _Ht::const_iterator const_iterator;
-
- typedef typename _Ht::allocator_type allocator_type;
+ using key_type = typename _Ht::key_type;
+ using data_type = _Tp;
+ using mapped_type = _Tp;
+ using value_type = typename _Ht::value_type;
+ using hasher = typename _Ht::hasher;
+ using key_equal = typename _Ht::key_equal;
+
+ using size_type = typename _Ht::size_type;
+ using difference_type = typename _Ht::difference_type;
+ using pointer = typename _Ht::pointer;
+ using const_pointer = typename _Ht::const_pointer;
+ using reference = typename _Ht::reference;
+ using const_reference = typename _Ht::const_reference;
+
+ using iterator = typename _Ht::iterator;
+ using const_iterator = typename _Ht::const_iterator;
+
+ using allocator_type = typename _Ht::allocator_type;
hasher hash_funct() const { return _M_ht.hash_funct(); }
_EqKey, _Alloc> >
{
protected:
- typedef INTERP_KERNEL::HashMap<_Key, _Tp, _HashFn, _EqKey, _Alloc>
- _Container;
+ using _Container = INTERP_KERNEL::HashMap<_Key, _Tp, _HashFn, _EqKey, _Alloc>;
_Container* container;
public:
- typedef _Container container_type;
- typedef output_iterator_tag iterator_category;
- typedef void value_type;
- typedef void difference_type;
- typedef void pointer;
- typedef void reference;
+ using container_type = _Container;
+ using iterator_category = output_iterator_tag;
+ using value_type = void;
+ using difference_type = void;
+ using pointer = void;
+ using reference = void;
insert_iterator(_Container& __x) : container(&__x) {}
_EqKey, _Alloc> >
{
protected:
- typedef INTERP_KERNEL::HashMultiMap<_Key, _Tp, _HashFn, _EqKey, _Alloc>
- _Container;
+ using _Container = INTERP_KERNEL::HashMultiMap<_Key, _Tp, _HashFn, _EqKey, _Alloc>;
_Container* container;
typename _Container::iterator iter;
public:
- typedef _Container container_type;
- typedef output_iterator_tag iterator_category;
- typedef void value_type;
- typedef void difference_type;
- typedef void pointer;
- typedef void reference;
+ using container_type = _Container;
+ using iterator_category = output_iterator_tag;
+ using value_type = void;
+ using difference_type = void;
+ using pointer = void;
+ using reference = void;
insert_iterator(_Container& __x) : container(&__x) {}
#ifndef __INTERPKERNELHASHTABLE_HXX__
#define __INTERPKERNELHASHTABLE_HXX__
-#include "InterpKernelStlExt.hxx"
-#include "InterpKernelHashFun.hxx"
+#include <memory>
+#include <cstddef>
+#include <utility>
#include <vector>
#include <iterator>
#include <algorithm>
-#include <functional>
namespace INTERP_KERNEL
{
class _ExtractKey, class _EqualKey, class _Alloc>
struct _Hashtable_iterator
{
- typedef hashtable<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc>
- _Hashtable;
- typedef _Hashtable_iterator<_Val, _Key, _HashFcn,
- _ExtractKey, _EqualKey, _Alloc>
- iterator;
- typedef _Hashtable_const_iterator<_Val, _Key, _HashFcn,
- _ExtractKey, _EqualKey, _Alloc>
- const_iterator;
- typedef _Hashtable_node<_Val> _Node;
- typedef std::forward_iterator_tag iterator_category;
- typedef _Val value_type;
- typedef std::ptrdiff_t difference_type;
- typedef std::size_t size_type;
- typedef _Val& reference;
- typedef _Val* pointer;
+ using _Hashtable = hashtable<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc>;
+ using iterator = _Hashtable_iterator<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc>;
+ using const_iterator = _Hashtable_const_iterator<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc>;
+ using _Node = _Hashtable_node<_Val>;
+ using iterator_category = std::forward_iterator_tag;
+ using value_type = _Val;
+ using difference_type = std::ptrdiff_t;
+ using size_type = std::size_t;
+ using reference = _Val &;
+ using pointer = _Val *;
_Node* _M_cur;
_Hashtable* _M_ht;
_Hashtable_iterator(_Node* __n, _Hashtable* __tab)
: _M_cur(__n), _M_ht(__tab) { }
- _Hashtable_iterator() { }
+ _Hashtable_iterator() = default;
reference
operator*() const
class _ExtractKey, class _EqualKey, class _Alloc>
struct _Hashtable_const_iterator
{
- typedef hashtable<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc>
- _Hashtable;
- typedef _Hashtable_iterator<_Val,_Key,_HashFcn,
- _ExtractKey,_EqualKey,_Alloc>
- iterator;
- typedef _Hashtable_const_iterator<_Val, _Key, _HashFcn,
- _ExtractKey, _EqualKey, _Alloc>
- const_iterator;
- typedef _Hashtable_node<_Val> _Node;
-
- typedef std::forward_iterator_tag iterator_category;
- typedef _Val value_type;
- typedef std::ptrdiff_t difference_type;
- typedef std::size_t size_type;
- typedef const _Val& reference;
- typedef const _Val* pointer;
+ using _Hashtable = hashtable<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc>;
+ using iterator = _Hashtable_iterator<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc>;
+ using const_iterator = _Hashtable_const_iterator<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc>;
+ using _Node = _Hashtable_node<_Val>;
+
+ using iterator_category = std::forward_iterator_tag;
+ using value_type = _Val;
+ using difference_type = std::ptrdiff_t;
+ using size_type = std::size_t;
+ using reference = const _Val &;
+ using pointer = const _Val *;
const _Node* _M_cur;
const _Hashtable* _M_ht;
_Hashtable_const_iterator(const _Node* __n, const _Hashtable* __tab)
: _M_cur(__n), _M_ht(__tab) { }
- _Hashtable_const_iterator() { }
+ _Hashtable_const_iterator() = default;
_Hashtable_const_iterator(const iterator& __it)
: _M_cur(__it._M_cur), _M_ht(__it._M_ht) { }
class hashtable
{
public:
- typedef _Key key_type;
- typedef _Val value_type;
- typedef _HashFcn hasher;
- typedef _EqualKey key_equal;
-
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
- typedef value_type* pointer;
- typedef const value_type* const_pointer;
- typedef value_type& reference;
- typedef const value_type& const_reference;
+ using key_type = _Key;
+ using value_type = _Val;
+ using hasher = _HashFcn;
+ using key_equal = _EqualKey;
+
+ using size_type = std::size_t;
+ using difference_type = std::ptrdiff_t;
+ using pointer = value_type *;
+ using const_pointer = const value_type *;
+ using reference = value_type &;
+ using const_reference = const value_type &;
hasher hash_funct() const { return _M_hash; }
key_equal key_eq() const { return _M_equals; }
private:
- typedef _Hashtable_node<_Val> _Node;
+ using _Node = _Hashtable_node<_Val>;
public:
- typedef typename _Alloc::template rebind<value_type>::other allocator_type;
+ using allocator_type = typename _Alloc::template rebind<value_type>::other;
allocator_type get_allocator() const { return _M_node_allocator; }
private:
- typedef typename _Alloc::template rebind<_Node>::other _Node_Alloc;
- typedef typename _Alloc::template rebind<_Node*>::other _Nodeptr_Alloc;
- typedef std::vector<_Node*, _Nodeptr_Alloc> _Vector_type;
+ using _Node_Alloc = typename _Alloc::template rebind<_Node>::other;
+ using _Nodeptr_Alloc = typename _Alloc::template rebind<_Node *>::other;
+ using _Vector_type = std::vector<_Node *, _Nodeptr_Alloc>;
_Node_Alloc _M_node_allocator;
size_type _M_num_elements;
public:
- typedef _Hashtable_iterator<_Val, _Key, _HashFcn, _ExtractKey,
- _EqualKey, _Alloc>
- iterator;
- typedef _Hashtable_const_iterator<_Val, _Key, _HashFcn, _ExtractKey,
- _EqualKey, _Alloc>
- const_iterator;
+ using iterator = _Hashtable_iterator<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc>;
+ using const_iterator = _Hashtable_const_iterator<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc>;
friend struct
_Hashtable_iterator<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc>;
#ifndef __INTERPKERNELSTLEXT_HXX__
#define __INTERPKERNELSTLEXT_HXX__
-#include <functional>
namespace INTERP_KERNEL
{
#ifndef __NORMALIZEDUNSTRUCTUREDMESH_HXX__
#define __NORMALIZEDUNSTRUCTUREDMESH_HXX__
-#include "NormalizedGeometricTypes"
namespace INTERP_KERNEL
{
/// Enumeration representing the six coordinates that define the bounding box
enum BoxCoord { XMIN = 0, YMIN = 1, ZMIN = 2, XMAX = 3, YMAX = 4, ZMAX = 5 };
- BoundingBox() { }
+ BoundingBox() = default;
BoundingBox(const double** pts, const unsigned numPts);
BoundingBox(const BoundingBox& box1, const BoundingBox& box2);
- ~BoundingBox() { }
+ ~BoundingBox() = default;
void fillInXMinXmaxYminYmaxZminZmaxFormat(double data[6]) const;
#include "BoxSplittingOptions.hxx"
+#include <ostream>
#include <sstream>
+#include <string>
const double INTERP_KERNEL::BoxSplittingOptions::DFT_EFFICIENCY_GOAL=0.5;
#include "InterpKernelException.hxx"
#include "DiameterCalculator.hxx"
+#include "NormalizedGeometricTypes"
+#include "MCIdType.hxx"
#include "OrientationInverter.hxx"
#include <algorithm>
+#include <map>
+#include <cstddef>
+#include <iterator>
#include <sstream>
+#include <utility>
#include <vector>
#include <limits>
*/
unsigned CellModel::getNumberOfMicroEdges() const
{
- unsigned mul(isQuadratic()?2:1);
+ unsigned const mul(isQuadratic()?2:1);
if(!isDynamic())
{
switch(getDimension())
*/
unsigned CellModel::fillSonCellNodalConnectivity(int sonId, const mcIdType *nodalConn, mcIdType *sonNodalConn) const
{
- unsigned nbOfTurnLoop=_nb_of_sons_con[sonId];
+ unsigned const nbOfTurnLoop=_nb_of_sons_con[sonId];
const unsigned *sonConn=_sons_con[sonId];
for(unsigned i=0;i<nbOfTurnLoop;i++)
sonNodalConn[i]=nodalConn[sonConn[i]];
return fillSonCellNodalConnectivity2(sonId,nodalConn,lgth,sonNodalConn,typeOfSon);
}
- unsigned CellModel::fillSonEdgesNodalConnectivity3D(int sonId, const mcIdType *nodalConn, mcIdType lgth, mcIdType *sonNodalConn, NormalizedCellType& typeOfSon) const
+ unsigned CellModel::fillSonEdgesNodalConnectivity3D(int sonId, const mcIdType *nodalConn, mcIdType /*lgth*/, mcIdType *sonNodalConn, NormalizedCellType& typeOfSon) const
{
if(!isDynamic())
{
{
int edgeId(sonId/2),subEdgeId(sonId%2);
typeOfSon=NORM_SEG2;
- const unsigned *sonConn(0);
+ const unsigned *sonConn(nullptr);
switch(getDimension())
{
case 2:
}
else
{
- unsigned int sz2(sz/2);
+ unsigned int const sz2(sz/2);
std::vector<mcIdType> tmp0(sz2-1),tmp1(sz2);
std::copy(nodalConn+1,nodalConn+sz2,tmp0.rbegin());
std::copy(nodalConn+sz2,nodalConn+sz,tmp1.rbegin());
if(!_quadratic)
{
std::vector<mcIdType> tmp(2*lgth);
- std::vector<mcIdType>::iterator it=std::copy(conn1,conn1+lgth,tmp.begin());
+ auto it=std::copy(conn1,conn1+lgth,tmp.begin());
std::copy(conn1,conn1+lgth,it);
it=std::search(tmp.begin(),tmp.end(),conn2,conn2+lgth);
if(it==tmp.begin())
return true;
if(it!=tmp.end())
return _dim!=1;
- std::vector<mcIdType>::reverse_iterator it2=std::search(tmp.rbegin(),tmp.rend(),conn2,conn2+lgth);
+ auto const it2=std::search(tmp.rbegin(),tmp.rend(),conn2,conn2+lgth);
if(it2!=tmp.rend())
return false;
throw INTERP_KERNEL::Exception("CellModel::getOrientationStatus : Request of orientation status of non equal connectively cells !");
if(_dim!=1)
{
std::vector<mcIdType> tmp(lgth);
- std::vector<mcIdType>::iterator it=std::copy(conn1,conn1+lgth/2,tmp.begin());
+ auto it=std::copy(conn1,conn1+lgth/2,tmp.begin());
std::copy(conn1,conn1+lgth/2,it);
it=std::search(tmp.begin(),tmp.end(),conn2,conn2+lgth/2);
- std::size_t d=std::distance(tmp.begin(),it);
+ std::size_t const d=std::distance(tmp.begin(),it);
if(it==tmp.end())
return false;
it=std::copy(conn1+lgth/2,conn1+lgth,tmp.begin());
it=std::search(tmp.begin(),tmp.end(),conn2,conn2+lgth);
if(it==tmp.end())
return false;
- std::size_t d2=std::distance(tmp.begin(),it);
+ std::size_t const d2=std::distance(tmp.begin(),it);
return d==d2;
}
else
{
- mcIdType p=(lgth+1)/2;
+ mcIdType const p=(lgth+1)/2;
std::vector<mcIdType> tmp(2*p);
- std::vector<mcIdType>::iterator it=std::copy(conn1,conn1+p,tmp.begin());
+ auto it=std::copy(conn1,conn1+p,tmp.begin());
std::copy(conn1,conn1+p,it);
it=std::search(tmp.begin(),tmp.end(),conn2,conn2+p);
- std::size_t d=std::distance(tmp.begin(),it);
+ std::size_t const d=std::distance(tmp.begin(),it);
if(it==tmp.end())
return false;
tmp.resize(2*p-2);
it=std::search(tmp.begin(),tmp.end(),conn2+p,conn2+lgth);
if(it==tmp.end())
return false;
- std::size_t d2=std::distance(tmp.begin(),it);
+ std::size_t const d2=std::distance(tmp.begin(),it);
return d==d2;
}
}
#include "INTERPKERNELDefines.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
+#include "NormalizedGeometricTypes"
#include "MCIdType.hxx"
#include <map>
#ifndef __CONVEXINTERSECTOR_HXX__
#define __CONVEXINTERSECTOR_HXX__
-#include "PlanarIntersectorP0P0.hxx"
-#include "PlanarIntersectorP0P1.hxx"
-#include "PlanarIntersectorP1P0.hxx"
-#include "PlanarIntersectorP1P1.hxx"
-#include "PlanarIntersectorP1P0Bary.hxx"
-#include "PlanarIntersectorP0P1Bary.hxx"
+#include "NormalizedUnstructuredMesh.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
public:
static const int SPACEDIM=MyMeshType::MY_SPACEDIM;
static const int MESHDIM=MyMeshType::MY_MESHDIM;
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
public:
ConvexIntersector(const MyMeshType& meshT, const MyMeshType& meshS,
#define __CONVEXINTERSECTOR_TXX__
#include "ConvexIntersector.hxx"
+#include "PlanarIntersector.txx"
#include "PlanarIntersectorP0P0.txx"
#include "PlanarIntersectorP0P1.txx"
#include "PlanarIntersectorP1P0.txx"
#include "PlanarIntersectorP0P1Bary.txx"
#include "PolygonAlgorithms.txx"
+#include "InterpolationUtils.hxx"
+#include <deque>
#include <iostream>
+#include <vector>
+#include <limits>
#define CONVINTERSECTOR_TEMPLATE template<class MyMeshType, class MyMatrix, template <class MeshType, class TheMatrix, class ThisIntersector> class InterpType>
#define CONVEX_INTERSECTOR_ ConvexIntersector<MyMeshType,MyMatrix,InterpType>
CONVINTERSECTOR_TEMPLATE
double CONVEX_INTERSECTOR_::intersectGeometryWithQuadrangle(const double * quadrangle,
const std::vector<double>& sourceCoords,
- bool isSourceQuad)
+ bool /*isSourceQuad*/)
{
double result = 0;
int nbOfNodesS=int(sourceCoords.size())/SPACEDIM;
CONVINTERSECTOR_TEMPLATE
double CONVEX_INTERSECTOR_::intersectGeoBary(const std::vector<double>& targetCell,
- bool targetCellQuadratic,
+ bool /*targetCellQuadratic*/,
const double * sourceTria,
std::vector<double>& res)
{
#include "TargetIntersector.txx"
#include "NormalizedUnstructuredMesh.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
#include "CurveIntersector.hxx"
#include "InterpolationUtils.hxx"
+#include "MCIdType.hxx"
+#include "NormalizedUnstructuredMesh.hxx"
+#include "NormalizedGeometricTypes"
#include "PointLocatorAlgos.txx"
+#include <algorithm>
+#include <cmath>
#include <limits>
+#include <vector>
+#include <utility>
namespace INTERP_KERNEL
{
template<class MyMeshType, class MyMatrix>
CurveIntersector<MyMeshType,MyMatrix>::~CurveIntersector()
- {
- }
+ = default;
//================================================================================
/*!
::coo2C(conn[OTT<ConnType,numPol>::conn2C(conn_index[icell]+j)]);
for(int idim=0; idim<SPACEDIM; idim++)
{
- double x = *(coord_node+idim);
+ double const x = *(coord_node+idim);
bbox[ibox*2*SPACEDIM + 2*idim] =
( bbox[ibox*2*SPACEDIM + 2*idim] < x ) ? bbox[ibox*2*SPACEDIM + 2*idim] : x;
bbox[ibox*2*SPACEDIM + 2*idim+1] =
SPACEDIM*(OTT<ConnType,numPol>::coo2C(conn[OTT<ConnType,numPol>::conn2C(conn_index[OTT<ConnType,numPol>::ind2C(iP)]+i)]));
for(int idim=0; idim<SPACEDIM; idim++)
{
- double x = *(coord_node+idim);
+ double const x = *(coord_node+idim);
bb[2*idim ] = (x<bb[2*idim ]) ? x : bb[2*idim ];
bb[2*idim+1] = (x>bb[2*idim+1]) ? x : bb[2*idim+1];
}
template<class MyMeshType, class MyMatrix>
void CurveIntersector<MyMeshType,MyMatrix>::ComputeBaryCoordsOf(double startOfSeg, double endOfSeg, double pt, double& startPos, double& endPos)
{
- double deno(endOfSeg-startOfSeg);
+ double const deno(endOfSeg-startOfSeg);
startPos = (endOfSeg-pt)/deno;
startPos = std::max(startPos,0.); startPos = std::min(startPos,1.);
endPos=1.-startPos;
double t0s1[2] = { s1[X]-t0[X], s1[Y]-t0[Y] };
double nt01_x_t0s0 = t0s0[X] * t01[Y] - t0s0[Y] * t01[X]; // t0s0 dot norm of t01
double nt01_x_t0s1 = t0s1[X] * t01[Y] - t0s1[Y] * t01[X]; // t0s1 dot norm of t01
- double dist_ts0 = fabs( nt01_x_t0s0 ); // dist from tgt seg to s0
- double dist_ts1 = fabs( nt01_x_t0s1 ); // dist from tgt seg to s1
+ double const dist_ts0 = fabs( nt01_x_t0s0 ); // dist from tgt seg to s0
+ double const dist_ts1 = fabs( nt01_x_t0s1 ); // dist from tgt seg to s1
bool s0_out_of_tol = ( dist_ts0 > _tolerance );
bool s1_out_of_tol = ( dist_ts1 > _tolerance );
if ( nt01_x_t0s0 * nt01_x_t0s1 > 0 && ( s0_out_of_tol || s1_out_of_tol ))
if ( xt0 > xt1 ) std::swap( xt0, xt1 );
if ( xs0 > xs1 ) std::swap( xs0, xs1 );
- double x0 = std::max( xt0, xs0 );
- double x1 = std::min( xt1, xs1 );
+ double const x0 = std::max( xt0, xs0 );
+ double const x1 = std::min( xt1, xs1 );
return ( x0 < x1 ) ? ( x1 - x0 ) : 0.;
}
public:
static const int MY_SPACEDIM=1;
static const int MY_MESHDIM=8;
- typedef mcIdType MyConnType;
+ using MyConnType = mcIdType;
static const INTERP_KERNEL::NumberingPolicy My_numPol=MyMeshType::My_numPol;
// begin
// useless, but for windows compilation ...
#define __CURVEINTERSECTORP0P0_HXX__
#include "CurveIntersector.hxx"
+#include "NormalizedUnstructuredMesh.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
public:
static const int SPACEDIM=MyMeshType::MY_SPACEDIM;
static const int MESHDIM=MyMeshType::MY_MESHDIM;
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
CurveIntersectorP0P0(const MyMeshType& meshT, const MyMeshType& meshS,
#ifndef __CURVEINTERSECTORP0P0_TXX__
#define __CURVEINTERSECTORP0P0_TXX__
+#include "CurveIntersector.hxx"
#include "CurveIntersectorP0P0.hxx"
-#include "CurveIntersector.txx"
+#include <vector>
+#include "InterpolationUtils.hxx"
#define BASE_INTERSECTOR CurveIntersector<MyMeshType,MyMatrix>
#define __CURVEINTERSECTORP0P1_HXX__
#include "CurveIntersector.hxx"
+#include "NormalizedUnstructuredMesh.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
public:
static const int SPACEDIM=MyMeshType::MY_SPACEDIM;
static const int MESHDIM=MyMeshType::MY_MESHDIM;
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
CurveIntersectorP0P1(const MyMeshType& meshT, const MyMeshType& meshS,
#ifndef __CurveIntersectorP0P1_TXX__
#define __CurveIntersectorP0P1_TXX__
+#include "CurveIntersector.hxx"
#include "CurveIntersectorP0P1.hxx"
-#include "CurveIntersector.txx"
+#include <vector>
+#include "InterpolationUtils.hxx"
#define BASE_INTERSECTOR CurveIntersector<MyMeshType,MyMatrix>
#define __CURVEINTERSECTORP1P0_HXX__
#include "CurveIntersector.hxx"
+#include "NormalizedUnstructuredMesh.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
public:
static const int SPACEDIM=MyMeshType::MY_SPACEDIM;
static const int MESHDIM=MyMeshType::MY_MESHDIM;
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
CurveIntersectorP1P0(const MyMeshType& meshT, const MyMeshType& meshS,
#ifndef __CurveIntersectorP1P0_TXX__
#define __CurveIntersectorP1P0_TXX__
+#include "CurveIntersector.hxx"
#include "CurveIntersectorP1P0.hxx"
-#include "CurveIntersector.txx"
+#include <vector>
+#include "InterpolationUtils.hxx"
#define BASE_INTERSECTOR CurveIntersector<MyMeshType,MyMatrix>
#define __CURVEINTERSECTORP1P1_HXX__
#include "CurveIntersector.hxx"
+#include "NormalizedUnstructuredMesh.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
public:
static const int SPACEDIM=MyMeshType::MY_SPACEDIM;
static const int MESHDIM=MyMeshType::MY_MESHDIM;
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
CurveIntersectorP1P1(const MyMeshType& meshT, const MyMeshType& meshS,
#ifndef __CurveIntersectorP1P1_TXX__
#define __CurveIntersectorP1P1_TXX__
+#include "CurveIntersector.hxx"
#include "CurveIntersectorP1P1.hxx"
-#include "CurveIntersector.txx"
+#include <vector>
+#include "InterpolationUtils.hxx"
#define BASE_INTERSECTOR CurveIntersector<MyMeshType,MyMatrix>
#define __CURVEINTERSECTORP1P1PL_HXX__
#include "CurveIntersector.hxx"
+#include "NormalizedUnstructuredMesh.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
public:
static const int SPACEDIM=MyMeshType::MY_SPACEDIM;
static const int MESHDIM=MyMeshType::MY_MESHDIM;
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
CurveIntersectorP1P1PL(const MyMeshType& meshT, const MyMeshType& meshS,
#pragma once
+#include "CurveIntersector.hxx"
#include "CurveIntersectorP1P1PL.hxx"
-#include "CurveIntersector.txx"
+#include "InterpolationUtils.hxx"
+#include "MCIdType.hxx"
#include <cassert>
+#include <cstdlib>
+#include <vector>
namespace INTERP_KERNEL
{
#include "DiameterCalculator.hxx"
#include "InterpKernelException.hxx"
#include "CellModel.hxx"
+#include "NormalizedGeometricTypes"
+#include "MCIdType.hxx"
#include <algorithm>
+#include <iterator>
#include <sstream>
#include <cmath>
void ComputeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr)
{
Evaluator evtor;
- NormalizedCellType ct(Evaluator::TYPE);
- int cti((int) ct);
+ NormalizedCellType const ct(Evaluator::TYPE);
+ int const cti((int) ct);
for(const mcIdType *it=bgIds;it!=endIds;it++)
{
- mcIdType offset(indPtr[*it]);
+ mcIdType const offset(indPtr[*it]);
if(connPtr[offset]==cti)
resPtr[*it]=evtor.ComputeForOneCellInternal(connPtr+offset+1,connPtr+indPtr[(*it)+1],coordsPtr);
else
void ComputeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr)
{
Evaluator evtor;
- NormalizedCellType ct(Evaluator::TYPE);
- int cti((int) ct);
+ NormalizedCellType const ct(Evaluator::TYPE);
+ int const cti((int) ct);
for(mcIdType it=bgId;it<endId;it++)
{
- mcIdType offset(indPtr[it]);
+ mcIdType const offset(indPtr[it]);
if(connPtr[offset]==cti)
resPtr[it]=evtor.ComputeForOneCellInternal(connPtr+offset+1,connPtr+indPtr[it+1],coordsPtr);
else
void ComputeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr)
{
Evaluator evtor;
- NormalizedCellType ct(Evaluator::TYPE);
+ NormalizedCellType const ct(Evaluator::TYPE);
const CellModel& cm(CellModel::GetCellModel(ct));
- unsigned nbNodes(cm.getNumberOfNodes());
+ unsigned const nbNodes(cm.getNumberOfNodes());
const mcIdType *ptr(connPtr);
for(mcIdType i=0;i<nbOfCells;i++,ptr+=nbNodes,resPtr++)
*resPtr=evtor.ComputeForOneCellInternal(ptr,ptr+nbNodes,coordsPtr);
class DiameterCalculator
{
public:
- INTERPKERNEL_EXPORT virtual ~DiameterCalculator() { }
+ INTERPKERNEL_EXPORT virtual ~DiameterCalculator() = default;
INTERPKERNEL_EXPORT virtual NormalizedCellType getType() const = 0;
INTERPKERNEL_EXPORT virtual double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const = 0;
INTERPKERNEL_EXPORT virtual void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const = 0;
class DiameterCalulatorTRI3S2 : public DiameterCalculator
{
public:
- NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ NormalizedCellType getType() const override { return TYPE; }
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const override { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
public:
static NormalizedCellType TYPE;
};
class DiameterCalulatorTRI3S3 : public DiameterCalculator
{
public:
- NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ NormalizedCellType getType() const override { return TYPE; }
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const override { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
public:
static NormalizedCellType TYPE;
};
class DiameterCalulatorTRI6S2 : public DiameterCalculator
{
public:
- NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ NormalizedCellType getType() const override { return TYPE; }
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const override { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
public:
static NormalizedCellType TYPE;
};
class DiameterCalulatorTRI6S3 : public DiameterCalculator
{
public:
- NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ NormalizedCellType getType() const override { return TYPE; }
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const override { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
public:
static NormalizedCellType TYPE;
};
class DiameterCalulatorTRI7S2 : public DiameterCalculator
{
public:
- NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ NormalizedCellType getType() const override { return TYPE; }
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const override { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
public:
static NormalizedCellType TYPE;
};
class DiameterCalulatorTRI7S3 : public DiameterCalculator
{
public:
- NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ NormalizedCellType getType() const override { return TYPE; }
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const override { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
public:
static NormalizedCellType TYPE;
};
class DiameterCalulatorQUAD4S2 : public DiameterCalculator
{
public:
- NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ NormalizedCellType getType() const override { return TYPE; }
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const override { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
public:
static NormalizedCellType TYPE;
};
class DiameterCalulatorQUAD4S3 : public DiameterCalculator
{
public:
- NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ NormalizedCellType getType() const override { return TYPE; }
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const override { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
public:
static NormalizedCellType TYPE;
};
class DiameterCalulatorQUAD8S2 : public DiameterCalculator
{
public:
- NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ NormalizedCellType getType() const override { return TYPE; }
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const override { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
public:
static NormalizedCellType TYPE;
};
class DiameterCalulatorQUAD8S3 : public DiameterCalculator
{
public:
- NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ NormalizedCellType getType() const override { return TYPE; }
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const override { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
public:
static NormalizedCellType TYPE;
};
class DiameterCalulatorQUAD9S2 : public DiameterCalculator
{
public:
- NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ NormalizedCellType getType() const override { return TYPE; }
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const override { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
public:
static NormalizedCellType TYPE;
};
class DiameterCalulatorQUAD9S3 : public DiameterCalculator
{
public:
- NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ NormalizedCellType getType() const override { return TYPE; }
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const override { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
public:
static NormalizedCellType TYPE;
};
class DiameterCalulatorTETRA4 : public DiameterCalculator
{
public:
- NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ NormalizedCellType getType() const override { return TYPE; }
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const override { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
public:
static NormalizedCellType TYPE;
};
class DiameterCalulatorTETRA10 : public DiameterCalculator
{
public:
- NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ NormalizedCellType getType() const override { return TYPE; }
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const override { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
public:
static NormalizedCellType TYPE;
};
class DiameterCalulatorHEXA8 : public DiameterCalculator
{
public:
- NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ NormalizedCellType getType() const override { return TYPE; }
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const override { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
public:
static NormalizedCellType TYPE;
};
class DiameterCalulatorHEXA20 : public DiameterCalculator
{
public:
- NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ NormalizedCellType getType() const override { return TYPE; }
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const override { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
public:
static NormalizedCellType TYPE;
};
class DiameterCalulatorHEXA27 : public DiameterCalculator
{
public:
- NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ NormalizedCellType getType() const override { return TYPE; }
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const override { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
public:
static NormalizedCellType TYPE;
};
class DiameterCalulatorPENTA6 : public DiameterCalculator
{
public:
- NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ NormalizedCellType getType() const override { return TYPE; }
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const override { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
public:
static NormalizedCellType TYPE;
};
class DiameterCalulatorPENTA15 : public DiameterCalculator
{
public:
- NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ NormalizedCellType getType() const override { return TYPE; }
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const override { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
public:
static NormalizedCellType TYPE;
};
class DiameterCalulatorPYRA5 : public DiameterCalculator
{
public:
- NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ NormalizedCellType getType() const override { return TYPE; }
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const override { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
public:
static NormalizedCellType TYPE;
};
class DiameterCalulatorPYRA13 : public DiameterCalculator
{
public:
- NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ NormalizedCellType getType() const override { return TYPE; }
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const override { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const override;
public:
static NormalizedCellType TYPE;
};
#include "DirectedBoundingBox.hxx"
#include "InterpolationUtils.hxx"
+#include <vector>
+#include <cmath>
+#include <cstdlib>
+#include <limits>
+#include <cstddef>
#define __TENSOR(i,j) tensor[(i)*_dim+(j)]
#define __AXIS(i) (&_axes[(i)*_dim])
// Rotate to make __TENSOR(k,l) == 0
- double diff = __TENSOR(l,l) - __TENSOR(k,k);
+ double const diff = __TENSOR(l,l) - __TENSOR(k,k);
double t; // tangent of rotation angle
if ( fabs(__TENSOR(k,l)) < abs(diff)*1.0e-36)
{
}
else
{
- double phi = diff/(2.0*__TENSOR(k,l));
+ double const phi = diff/(2.0*__TENSOR(k,l));
t = 1.0/(abs(phi) + sqrt(phi*phi + 1.0));
if ( phi < 0.0) t = -t;
}
- double c = 1.0/sqrt(t*t + 1.0); // cosine of rotation angle
- double s = t*c; // sine of rotation angle
- double tau = s/(1.0 + c);
+ double const c = 1.0/sqrt(t*t + 1.0); // cosine of rotation angle
+ double const s = t*c; // sine of rotation angle
+ double const tau = s/(1.0 + c);
__TENSOR(k,k) -= t*__TENSOR(k,l);
__TENSOR(l,l) += t*__TENSOR(k,l);
__TENSOR(k,l) = 0.0;
// find minmax of cornerBox in the CS of axisBox
- DirectedBoundingBox mmBox((double*)0,0,_dim); //!< empty box with CS == axisBox->_axes
+ DirectedBoundingBox mmBox((double*)nullptr,0,_dim); //!< empty box with CS == axisBox->_axes
mmBox._axes = axisBox->_axes;
vector<double> corners;
{
vector<double> cornersOther;
getCorners( cornersOther, box );
- DirectedBoundingBox mmBox((double*)0,0,_dim); //!< empty box with CS == this->_axes
+ DirectedBoundingBox mmBox((double*)nullptr,0,_dim); //!< empty box with CS == this->_axes
mmBox._axes = this->_axes;
for ( std::size_t iC = 0, nC = cornersOther.size()/_dim; iC < nC; ++iC)
mmBox.addPointToBox( &cornersOther[iC*_dim] );
{
vector<double> cornersThis;
getCorners( cornersThis, &_minmax[0] );
- DirectedBoundingBox mmBox((double*)0,0,_dim); //!< initailized _minmax
+ DirectedBoundingBox mmBox((double*)nullptr,0,_dim); //!< initailized _minmax
double globCorner[3];
for ( std::size_t iC = 0, nC = cornersThis.size()/_dim; iC < nC; ++iC)
{
double pLoc[3];
toLocalCS( point, pLoc );
- bool out = isLocalOut( pLoc );
+ bool const out = isLocalOut( pLoc );
#ifdef _DEBUG_
switch (_dim)
{
// Author : Anthony Geay (CEA/DEN)
#include "InterpKernelAsmX86.hxx"
+#include "InterpKernelException.hxx"//"
#include <cstring>
#include <sstream>
#include <algorithm>
+#include <vector>
+#include <string>
#ifdef _POSIX_MAPPED_FILES
#include <sys/mman.h>
std::vector<char> INTERP_KERNEL::AsmX86::convertIntoMachineLangage(const std::vector<std::string>& asmb) const
{
std::vector<char> ret;
- for(std::vector<std::string>::const_iterator iter=asmb.begin();iter!=asmb.end();iter++)
- convertOneInstructionInML(*iter,ret);
+ for(const auto & iter : asmb)
+ convertOneInstructionInML(iter,ret);
return ret;
}
-char *INTERP_KERNEL::AsmX86::copyToExecMemZone(const std::vector<char>& ml, unsigned& offset) const
+char *INTERP_KERNEL::AsmX86::copyToExecMemZone(const std::vector<char>& ml, unsigned& /*offset*/) const
{
- char *ret=0;
- std::size_t lgth=ml.size();
+ char *ret=nullptr;
+ std::size_t const lgth=ml.size();
#ifdef _POSIX_MAPPED_FILES
# ifdef __APPLE__
ret=(char *)mmap(0,lgth,PROT_EXEC | PROT_WRITE,MAP_ANON | MAP_PRIVATE,-1,0);
# else
- ret=(char *)mmap(0,lgth,PROT_EXEC | PROT_WRITE,MAP_ANONYMOUS | MAP_PRIVATE,-1,0);
+ ret=(char *)mmap(nullptr,lgth,PROT_EXEC | PROT_WRITE,MAP_ANONYMOUS | MAP_PRIVATE,-1,0);
# endif
#else
#ifdef WIN32
void INTERP_KERNEL::AsmX86::convertOneInstructionInML(const std::string& inst, std::vector<char>& ml) const
{
- std::string::size_type pos=inst.find_first_of(' ');
+ std::string::size_type const pos=inst.find_first_of(' ');
std::string op;
std::string param;
if(pos!=std::string::npos)
int id=0;
for(const char **it=OPS;it!=OPS+NB_OF_OPS;it++,id++)
{
- std::string tmp(*it);
+ std::string const tmp(*it);
if(op==tmp)
break;
}
std::ostringstream oss; oss << "not recognized instruction mov : " << inst;
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- std::string inst2=inst.substr(pos+1);
+ std::string const inst2=inst.substr(pos+1);
pos=inst2.find_first_of(',');
if(pos==std::string::npos)
{
std::ostringstream oss; oss << "not recognized instruction mov : " << inst;
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- std::string inst3=inst2.substr(0,pos);
- std::string inst4=inst2.substr(pos+1);
+ std::string const inst3=inst2.substr(0,pos);
+ std::string const inst4=inst2.substr(pos+1);
convertMovToEsp(inst3,inst4,ml);
}
{//mov dword [esp+4],0x3ff3c0ca
const unsigned char ML2[3]={0xc7,0x44,0x24};
ml.insert(ml.end(),ML2,ML2+sizeof(ML2));
- std::string::size_type pos=inst1bis.find_first_of(']');
- std::string inst1_1=inst1bis.substr(4,pos-4-1);
+ std::string::size_type const pos=inst1bis.find_first_of(']');
+ std::string const inst1_1=inst1bis.substr(4,pos-4-1);
appendAddress(inst1_1,1,ml);
appendAddress(inst2,4,ml);
return;
{//mov dword [rsp+4],0x3ff3c0ca
const unsigned char ML2[3]={0xc7,0x44,0x24};
ml.insert(ml.end(),ML2,ML2+sizeof(ML2));
- std::string::size_type pos=inst1bis.find_first_of(']');
- std::string inst1_1=inst1bis.substr(4,pos-4-1);
+ std::string::size_type const pos=inst1bis.find_first_of(']');
+ std::string const inst1_1=inst1bis.substr(4,pos-4-1);
appendAddress(inst1_1,1,ml);
appendAddress(inst2,4,ml);
return;
void INTERP_KERNEL::AsmX86::convertPush(const std::string& inst, std::vector<char>& ml)
{
- std::string::size_type pos=inst.find_first_of(' ');
- std::string inst2=inst.substr(pos+1);
+ std::string::size_type const pos=inst.find_first_of(' ');
+ std::string const inst2=inst.substr(pos+1);
const char ASM1[]="ebp";
const unsigned char ML1[1]={0x55};
if(inst2==ASM1)
void INTERP_KERNEL::AsmX86::convertPop(const std::string& inst, std::vector<char>& ml)
{
- std::string::size_type pos=inst.find_first_of(' ');
- std::string inst2=inst.substr(pos+1);
+ std::string::size_type const pos=inst.find_first_of(' ');
+ std::string const inst2=inst.substr(pos+1);
const char ASM1[]="ebp";
const unsigned char ML1[1]={0x5d};
if(inst2==ASM1)
void INTERP_KERNEL::AsmX86::convertFld(const std::string& inst, std::vector<char>& ml)
{
std::string::size_type pos=inst.find_first_of(' ');
- std::string params=inst.substr(pos+1);
- std::string params2=params.substr(1,params.length()-2);
+ std::string const params=inst.substr(pos+1);
+ std::string const params2=params.substr(1,params.length()-2);
if(params2.substr(0,3)=="esp")
{
const unsigned char ML1[3]={0xdd,0x04,0x24};
if(pos!=std::string::npos)
{//fld qword [esp+@]
ml.insert(ml.end(),ML1,ML1+sizeof(ML1));
- std::string params3=params2.substr(pos+1);
+ std::string const params3=params2.substr(pos+1);
appendAddress(params3,1,ml);
return ;
}
if(pos!=std::string::npos)
{//fld qword [esp+@]
ml.insert(ml.end(),ML2,ML2+sizeof(ML2));
- std::string params3=params2.substr(pos+1);
+ std::string const params3=params2.substr(pos+1);
appendAddress(params3,1,ml);
return ;
}
throw INTERP_KERNEL::Exception("Unrecognized fld instruction");
}
-void INTERP_KERNEL::AsmX86::convertFaddp(const std::string& inst, std::vector<char>& ml)
+void INTERP_KERNEL::AsmX86::convertFaddp(const std::string& /*inst*/, std::vector<char>& ml)
{
const unsigned char ML1[2]={0xde,0xc1};
ml.insert(ml.end(),ML1,ML1+sizeof(ML1));
}
-void INTERP_KERNEL::AsmX86::convertFsubp(const std::string& inst, std::vector<char>& ml)
+void INTERP_KERNEL::AsmX86::convertFsubp(const std::string& /*inst*/, std::vector<char>& ml)
{
const unsigned char ML1[2]={0xde,0xe9};
ml.insert(ml.end(),ML1,ML1+sizeof(ML1));
}
-void INTERP_KERNEL::AsmX86::convertFmulp(const std::string& inst, std::vector<char>& ml)
+void INTERP_KERNEL::AsmX86::convertFmulp(const std::string& /*inst*/, std::vector<char>& ml)
{
const unsigned char ML1[2]={0xde,0xc9};
ml.insert(ml.end(),ML1,ML1+sizeof(ML1));
}
-void INTERP_KERNEL::AsmX86::convertFdivp(const std::string& inst, std::vector<char>& ml)
+void INTERP_KERNEL::AsmX86::convertFdivp(const std::string& /*inst*/, std::vector<char>& ml)
{
const unsigned char ML1[2]={0xde,0xf9};
ml.insert(ml.end(),ML1,ML1+sizeof(ML1));
}
-void INTERP_KERNEL::AsmX86::convertFcos(const std::string& inst, std::vector<char>& ml)
+void INTERP_KERNEL::AsmX86::convertFcos(const std::string& /*inst*/, std::vector<char>& ml)
{
const unsigned char ML[2]={0xd9,0xff};
ml.insert(ml.end(),ML,ML+sizeof(ML));
}
-void INTERP_KERNEL::AsmX86::convertFsin(const std::string& inst, std::vector<char>& ml)
+void INTERP_KERNEL::AsmX86::convertFsin(const std::string& /*inst*/, std::vector<char>& ml)
{
const unsigned char ML[2]={0xd9,0xfe};
ml.insert(ml.end(),ML,ML+sizeof(ML));
}
-void INTERP_KERNEL::AsmX86::convertFabs(const std::string& inst, std::vector<char>& ml)
+void INTERP_KERNEL::AsmX86::convertFabs(const std::string& /*inst*/, std::vector<char>& ml)
{
const unsigned char ML[2]={0xd9,0xe1};
ml.insert(ml.end(),ML,ML+sizeof(ML));
}
-void INTERP_KERNEL::AsmX86::convertFchs(const std::string& inst, std::vector<char>& ml)
+void INTERP_KERNEL::AsmX86::convertFchs(const std::string& /*inst*/, std::vector<char>& ml)
{
const unsigned char ML[2]={0xd9,0xe0};
ml.insert(ml.end(),ML,ML+sizeof(ML));
}
-void INTERP_KERNEL::AsmX86::convertFsqrt(const std::string& inst, std::vector<char>& ml)
+void INTERP_KERNEL::AsmX86::convertFsqrt(const std::string& /*inst*/, std::vector<char>& ml)
{
const unsigned char ML[2]={0xd9,0xfa};
ml.insert(ml.end(),ML,ML+sizeof(ML));
{
const unsigned char ML[2]={0x81,0xec};
ml.insert(ml.end(),ML,ML+sizeof(ML));
- std::string inst2=inst.substr(4);
+ std::string const inst2=inst.substr(4);
appendAddress(inst2,4,ml);
return;
}
{
const unsigned char ML[2]={0x81,0xc4};
ml.insert(ml.end(),ML,ML+sizeof(ML));
- std::string inst2=inst.substr(4);
+ std::string const inst2=inst.substr(4);
appendAddress(inst2,4,ml);
return;
}
throw INTERP_KERNEL::Exception("Not recognized add instruction.");
}
-void INTERP_KERNEL::AsmX86::convertRet(const std::string& inst, std::vector<char>& ml)
+void INTERP_KERNEL::AsmX86::convertRet(const std::string& /*inst*/, std::vector<char>& ml)
{
const unsigned char ML[1]={0xc3};
ml.insert(ml.end(),ML,ML+sizeof(ML));
}
-void INTERP_KERNEL::AsmX86::convertLeave(const std::string& inst, std::vector<char>& ml)
+void INTERP_KERNEL::AsmX86::convertLeave(const std::string& /*inst*/, std::vector<char>& ml)
{
const unsigned char ML[1]={0xc9};
ml.insert(ml.end(),ML,ML+sizeof(ML));
#ifndef __INTERPKERNELASMX86_HXX__
#define __INTERPKERNELASMX86_HXX__
-#include "INTERPKERNELDefines.hxx"
-#include "InterpKernelException.hxx"
#include <vector>
#include <string>
// Author : Anthony Geay (CEA/DEN)
#include "InterpKernelExprParser.hxx"
+#include "InterpKernelFunction.hxx"
+#include "InterpKernelUnit.hxx"
#include "InterpKernelValue.hxx"
#include "InterpKernelAsmX86.hxx"
#include "InterpKernelAutoPtr.hxx"
+#include "InterpKernelException.hxx"
#include <cctype>
+#include <cstddef>
+#include <set>
#include <sstream>
#include <limits>
+#include <string>
+#include <utility>
#include <vector>
#include <iterator>
#include <iostream>
}
LeafExpr::~LeafExpr()
-{
-}
+= default;
LeafExprVal::LeafExprVal(double value):_value(value)
{
}
LeafExprVal::~LeafExprVal()
-{
-}
+= default;
void LeafExprVal::fillValue(Value *val) const
{
void LeafExprVal::replaceValues(const std::vector<double>& valuesInExpr)
{
- int pos=(int)_value;
- int lgth=(int)valuesInExpr.size();
+ int const pos=(int)_value;
+ int const lgth=(int)valuesInExpr.size();
if(pos>=lgth || pos<0)
throw INTERP_KERNEL::Exception("LeafExprVal::replaceValues : Big Problem detected! Send a mail to Salome support with expression.");
_value=valuesInExpr[pos];
return new LeafExprVal(*this);
}
-LeafExprVar::LeafExprVar(const std::string& var):_fast_pos(-1),_var_name(var),_val(0)
+LeafExprVar::LeafExprVar(const std::string& var):_fast_pos(-1),_var_name(var),_val(nullptr)
{
}
void LeafExprVar::prepareExprEvaluation(const std::vector<std::string>& vars, int nbOfCompo, int targetNbOfCompo) const
{
- std::vector<std::string>::const_iterator iter=std::find(vars.begin(),vars.end(),_var_name);
+ auto const iter=std::find(vars.begin(),vars.end(),_var_name);
if(iter==vars.end())
{
if(!isRecognizedKeyVar(_var_name,_fast_pos))
}
else
{
- int relPos=-7-_fast_pos;
+ int const relPos=-7-_fast_pos;
if(relPos>=targetNbOfCompo)
{
std::ostringstream oss; oss << "LeafExprVar::prepareExprEvaluation : Found recognized unitary vector \"" << _var_name << "\" which implies that component #" << relPos;
{
if(var.length()!=sizeof(END_OF_RECOGNIZED_VAR))
return false;
- std::string end=var.substr(1);
+ std::string const end=var.substr(1);
if(end!=END_OF_RECOGNIZED_VAR)
return false;
- char first=var[0];
+ char const first=var[0];
if(first<'I' || first>'Z')
return false;
pos=-7-(first-'I');
}
LeafExprVar::~LeafExprVar()
-{
-}
+= default;
void ExprParserOfEval::clearSortedMemory()
{
delete _leaf;
- for(std::vector<ExprParserOfEval>::iterator it=_sub_parts.begin();it!=_sub_parts.end();it++)
- (*it).clearSortedMemory();
- for(std::vector<Function *>::iterator it=_funcs.begin();it!=_funcs.end();it++)
- delete *it;
+ for(auto & _sub_part : _sub_parts)
+ _sub_part.clearSortedMemory();
+ for(auto & _func : _funcs)
+ delete _func;
}
void ExprParserOfEval::sortMemory()
{
- for(std::vector<ExprParserOfEval>::iterator it=_sub_parts.begin();it!=_sub_parts.end();it++)
- (*it).sortMemory();
+ for(auto & _sub_part : _sub_parts)
+ _sub_part.sortMemory();
if(_leaf)
_leaf=_leaf->deepCopy();
- for(std::vector<Function *>::iterator it=_funcs.begin();it!=_funcs.end();it++)
- if(*it)
- *it=(*it)->deepCopy();
+ for(auto & _func : _funcs)
+ if(_func)
+ _func=_func->deepCopy();
}
-ExprParser::ExprParser(const std::string& expr, ExprParser *father):_father(father),_is_parsed(false),_leaf(0),_is_parsing_ok(false),_expr(expr)
+ExprParser::ExprParser(const std::string& expr, ExprParser *father):_father(father),_is_parsed(false),_leaf(nullptr),_is_parsing_ok(false),_expr(expr)
{
_expr=deleteWhiteSpaces(_expr);
}
//! For \b NOT null terminated strings coming from FORTRAN.
-ExprParser::ExprParser(const char *expr, int lgth, ExprParser *father):_father(father),_is_parsed(false),_leaf(0),_is_parsing_ok(false)
+ExprParser::ExprParser(const char *expr, int lgth, ExprParser *father):_father(father),_is_parsed(false),_leaf(nullptr),_is_parsing_ok(false)
{
_expr=buildStringFromFortran(expr,lgth);
_expr=deleteWhiteSpaces(_expr);
int level=0;
for(std::size_t iter=0;iter<posOfCloseBracket;iter++)
{
- std::size_t iter2=posOfCloseBracket-1-iter;
+ std::size_t const iter2=posOfCloseBracket-1-iter;
if(expr[iter2]==')')
level++;
else if(expr[iter2]=='(')
std::string ExprParser::buildStringFromFortran(const char *expr, int lgth)
{
std::string ret(expr,lgth);
- std::string whiteSpaces(WHITE_SPACES);
- std::size_t found=ret.find_last_not_of(whiteSpaces);
+ std::string const whiteSpaces(WHITE_SPACES);
+ std::size_t const found=ret.find_last_not_of(whiteSpaces);
if (found!=std::string::npos)
ret.erase(found+1);
else
std::string ExprParser::deleteWhiteSpaces(const std::string& expr)
{
std::string ret(expr);
- std::string whiteSpaces(WHITE_SPACES);
+ std::string const whiteSpaces(WHITE_SPACES);
std::size_t where1=0,where2=0;
while(where2!=std::string::npos && where1!=std::string::npos)
{
releaseFunctions();
if(!_expr.empty())
{
- std::string tmp(_expr);
+ std::string const tmp(_expr);
std::vector<double> valuesInExpr;
fillValuesInExpr(valuesInExpr);
checkBracketsParity();
DecompositionInUnitBase ExprParser::evaluateUnit() const
{
Value *gen=new ValueUnit;
- ValueUnit *res=0;
+ ValueUnit *res=nullptr;
try
{
res=(ValueUnit *)evaluateLowLev(gen);
{
if(_leaf)
{
- LeafExprVar *leafC=dynamic_cast<LeafExprVar *>(_leaf);
+ auto *leafC=dynamic_cast<LeafExprVar *>(_leaf);
if(leafC)
leafC->prepareExprEvaluation(vars,nbOfCompo,targetNbOfCompo);
}
else
- for(std::vector<ExprParser>::const_iterator iter=_sub_expr.begin();iter!=_sub_expr.end();iter++)
- (*iter).prepareExprEvaluation(vars,nbOfCompo,targetNbOfCompo);
+ for(const auto & iter : _sub_expr)
+ iter.prepareExprEvaluation(vars,nbOfCompo,targetNbOfCompo);
}
/*!
throw INTERP_KERNEL::Exception("ExprParser::prepareExprEvaluationDouble : size of input vector must be equal to the input vector !");
if(_leaf)
{
- LeafExprVar *leafC=dynamic_cast<LeafExprVar *>(_leaf);
+ auto *leafC=dynamic_cast<LeafExprVar *>(_leaf);
if(leafC)
leafC->prepareExprEvaluationDouble(vars,nbOfCompo,targetNbOfCompo,refPos,ptOfInputStart,ptOfInputEnd);
}
else
- for(std::vector<ExprParser>::const_iterator iter=_sub_expr.begin();iter!=_sub_expr.end();iter++)
- (*iter).prepareExprEvaluationDouble(vars,nbOfCompo,targetNbOfCompo,refPos,ptOfInputStart,ptOfInputEnd);
+ for(const auto & iter : _sub_expr)
+ iter.prepareExprEvaluationDouble(vars,nbOfCompo,targetNbOfCompo,refPos,ptOfInputStart,ptOfInputEnd);
}
void ExprParser::prepareFastEvaluator() const
{
if(_leaf)
{
- LeafExprVar *leafC=dynamic_cast<LeafExprVar *>(_leaf);
+ auto *leafC=dynamic_cast<LeafExprVar *>(_leaf);
if(leafC)
leafC->prepareExprEvaluationVec();
}
else
- for(std::vector<ExprParser>::const_iterator iter=_sub_expr.begin();iter!=_sub_expr.end();iter++)
- (*iter).prepareExprEvaluationVecLowLev();
+ for(const auto & iter : _sub_expr)
+ iter.prepareExprEvaluationVecLowLev();
}
Value *ExprParser::evaluateLowLev(Value *valGen) const
else
{
stackOfVal.resize(_sub_expr.size());
- std::vector<Value *>::iterator iter2=stackOfVal.begin();
- for(std::vector<ExprParser>::const_iterator iter=_sub_expr.begin();iter!=_sub_expr.end();iter++,iter2++)
+ auto iter2=stackOfVal.begin();
+ for(auto iter=_sub_expr.begin();iter!=_sub_expr.end();iter++,iter2++)
*iter2=(*iter).evaluateLowLev(valGen);
}
- for(std::vector<Function *>::const_iterator iter3=_func_btw_sub_expr.begin();iter3!=_func_btw_sub_expr.end();iter3++)
- (*iter3)->operate(stackOfVal);
+ for(auto iter3 : _func_btw_sub_expr)
+ iter3->operate(stackOfVal);
}
catch(INTERP_KERNEL::Exception& e)
{
- for(std::vector<Value *>::iterator iter4=stackOfVal.begin();iter4!=stackOfVal.end();iter4++)
- delete *iter4;
+ for(auto & iter4 : stackOfVal)
+ delete iter4;
throw e;
}
return stackOfVal.back();
ExprParser::ExprParser(ExprParser&& other):_father(other._father),_leaf(other._leaf),_is_parsing_ok(std::move(other._is_parsing_ok)),_expr(std::move(other._expr)),_sub_expr(std::move(other._sub_expr)),_func_btw_sub_expr(std::move(other._func_btw_sub_expr))
{
- other._leaf=0;
+ other._leaf=nullptr;
}
ExprParser& ExprParser::operator=(ExprParser&& other)
_sub_expr=std::move(other._sub_expr);
_func_btw_sub_expr=std::move(other._func_btw_sub_expr);
other._leaf=other._leaf;
- other._leaf=0;
+ other._leaf=nullptr;
return *this;
}
{
if(_leaf)
return ;
- for(std::vector<ExprParser>::iterator iter=_sub_expr.begin();iter!=_sub_expr.end();iter++)
- (*iter).reverseThis();
- std::size_t sz(_sub_expr.size());
- std::size_t nbOfTurn(sz/2);
+ for(auto & iter : _sub_expr)
+ iter.reverseThis();
+ std::size_t const sz(_sub_expr.size());
+ std::size_t const nbOfTurn(sz/2);
for(std::size_t i=0;i<nbOfTurn;i++)
std::swap(_sub_expr[i],_sub_expr[sz-i-1]);
}
ExprParserOfEval ExprParser::convertMeTo() const
{
- std::size_t sz(_sub_expr.size());
+ std::size_t const sz(_sub_expr.size());
std::vector<ExprParserOfEval> subExpr(sz);
for(std::size_t i=0;i<sz;i++)
subExpr[i]=_sub_expr[i].convertMeTo();
{
if(_leaf)
{
- LeafExprVar *leafC=dynamic_cast<LeafExprVar *>(_leaf);
+ auto *leafC=dynamic_cast<LeafExprVar *>(_leaf);
if(leafC)
vars.insert(leafC->getVar());
}
else
- for(std::vector<ExprParser>::const_iterator iter=_sub_expr.begin();iter!=_sub_expr.end();iter++)
- (*iter).getSetOfVars(vars);
+ for(const auto & iter : _sub_expr)
+ iter.getSetOfVars(vars);
}
void ExprParser::getTrueSetOfVars(std::set<std::string>& trueVars) const
std::set<std::string> vars;
getSetOfVars(vars);
trueVars.clear();
- for(std::set<std::string>::const_iterator iter=vars.begin();iter!=vars.end();iter++)
+ for(const auto & var : vars)
{
int tmp;
- if(!LeafExprVar::isRecognizedKeyVar(*iter,tmp))
- trueVars.insert(*iter);
+ if(!LeafExprVar::isRecognizedKeyVar(var,tmp))
+ trueVars.insert(var);
}
}
void ExprParser::parseDeeper()
{
- for(std::vector<ExprParser>::iterator iter=_sub_expr.begin();iter!=_sub_expr.end();iter++)
- if(!(*iter).simplify())
- (*iter).parseDeeper();
+ for(auto & iter : _sub_expr)
+ if(!iter.simplify())
+ iter.parseDeeper();
}
/*!
if(_expr[_expr.length()-1]!=')')
return ;
//at this level of code _expr
- std::size_t pos1=_expr.find_first_of('(');
- std::size_t pos4=FindCorrespondingOpenBracket(_expr,_expr.length()-1);
+ std::size_t const pos1=_expr.find_first_of('(');
+ std::size_t const pos4=FindCorrespondingOpenBracket(_expr,_expr.length()-1);
if(pos4!=pos1)
return ;
std::string funcName=_expr.substr(0,pos1);
- std::size_t pos2=funcName.find_first_of("+-*/^><",0,7);
- std::size_t pos3=funcName.find_first_not_of("+-*/^><",0,7);
+ std::size_t const pos2=funcName.find_first_of("+-*/^><",0,7);
+ std::size_t const pos3=funcName.find_first_not_of("+-*/^><",0,7);
if(pos2!=std::string::npos && pos3!=std::string::npos)
return ;//Bracket group is not alone, can't conclude not recursively.
std::string newExp2=_expr.substr(pos1+1,_expr.length()-pos1-2);
- std::size_t nbOfParamsInFunc=std::count(newExp2.begin(),newExp2.end(),',')+1;
+ std::size_t const nbOfParamsInFunc=std::count(newExp2.begin(),newExp2.end(),',')+1;
if(pos3!=std::string::npos)
_func_btw_sub_expr.push_back(FunctionsFactory::buildFuncFromString(funcName.c_str(),(int)nbOfParamsInFunc));
else
{
- std::size_t lgth=funcName.length();
+ std::size_t const lgth=funcName.length();
char tmp[2]; tmp[1]='\0';
for(std::size_t i=0;i<lgth;i++)
{
std::size_t pos6=0;
for(std::size_t i=0;i<nbOfParamsInFunc;i++)
{
- std::size_t pos5=newExp2.find_first_of(',',pos6);
+ std::size_t const pos5=newExp2.find_first_of(',',pos6);
std::size_t len=std::string::npos;
if(pos5!=std::string::npos)
len=pos5-pos6;
- std::string newExp3=newExp2.substr(pos6,len);
+ std::string const newExp3=newExp2.substr(pos6,len);
_sub_expr.push_back(ExprParser(newExp3.c_str(),this));
pos6=pos5+1;
}
*/
bool ExprParser::tryToInterpALeaf()
{
- std::size_t pos=_expr.find_first_not_of("+-",0,2);
- std::string minimizedExpr=_expr.substr(pos);
- std::size_t pos2=minimizedExpr.find_first_of("+-*/^()<>",0,9);
+ std::size_t const pos=_expr.find_first_not_of("+-",0,2);
+ std::string const minimizedExpr=_expr.substr(pos);
+ std::size_t const pos2=minimizedExpr.find_first_of("+-*/^()<>",0,9);
if(pos2!=std::string::npos)
return false;
delete _leaf;
std::ostringstream errMsg;
char MSGTYP1[]="Error non unary function for '";
errMsg << EXPR_PARSE_ERR_MSG << MSGTYP1 << *iter << "'";
- std::string tmp=_expr.substr(iter-_expr.begin());
+ std::string const tmp=_expr.substr(iter-_expr.begin());
LocateError(errMsg,tmp,0);
throw INTERP_KERNEL::Exception(errMsg.str().c_str());
}
{
if(!curPart.empty())
{
- std::string::reverse_iterator accessor=curPart.rbegin();
+ std::string::reverse_iterator const accessor=curPart.rbegin();
if(*accessor!='*' && *accessor!='/' && *accessor!='^')
{
isParsingSucceed=true;
std::ostringstream errMsg;
char MSGTYP1[]="Error non unary function for '";
errMsg << EXPR_PARSE_ERR_MSG << MSGTYP1 << *iter << "'";
- std::string tmp=_expr.substr(iter-_expr.begin());
+ std::string const tmp=_expr.substr(iter-_expr.begin());
LocateError(errMsg,tmp,0);
throw INTERP_KERNEL::Exception(errMsg.str().c_str());
}
std::ostringstream errMsg;
char MSGTYP1[]="Error non unary function for '";
errMsg << EXPR_PARSE_ERR_MSG << MSGTYP1 << *iter << "'";
- std::string tmp=_expr.substr(iter-_expr.begin());
+ std::string const tmp=_expr.substr(iter-_expr.begin());
LocateError(errMsg,tmp,0);curPart+=*iter;
throw INTERP_KERNEL::Exception(errMsg.str().c_str());
}
void ExprParser::releaseFunctions()
{
- for(std::vector<Function *>::iterator iter=_func_btw_sub_expr.begin();iter!=_func_btw_sub_expr.end();iter++)
- delete *iter;
+ for(auto & iter : _func_btw_sub_expr)
+ delete iter;
_func_btw_sub_expr.clear();
}
static const char MSG[]="Internal error : A string expected to be a float is not one ! Bug to signal !";
std::istringstream stream;
std::ostringstream oss;
- std::size_t end2=end!=std::string::npos?end-bg:end;
- std::string tmp=expr.substr(bg,end2);
+ std::size_t const end2=end!=std::string::npos?end-bg:end;
+ std::string const tmp=expr.substr(bg,end2);
stream.str(tmp);
double ret=std::numeric_limits<double>::max();
stream >> ret;
if(!stream.eof())
throw INTERP_KERNEL::Exception(MSG);
oss << id;
- std::string tmp2(oss.str());
- std::size_t l1=tmp.length();
+ std::string const tmp2(oss.str());
+ std::size_t const l1=tmp.length();
delta=(int)tmp2.length()-(int)l1;
expr.replace(bg,l1,tmp2);
return ret;
{
const char FIGURES[]="0123456789";
const std::string other("+-*^/(<>,");
- std::size_t lgth=_expr.length();
+ std::size_t const lgth=_expr.length();
int id=0,delta;
for(std::size_t pos=0;pos!=std::string::npos;id++)
{
- std::size_t pos2=_expr.find_first_of(FIGURES,pos,10);
+ std::size_t const pos2=_expr.find_first_of(FIGURES,pos,10);
if(pos2==std::string::npos)
break;
if(pos2>0)
std::ostringstream oss; oss << "Invalid expr : float number at the end of expr is invalid lacking number after exponential and sign ! -> \"" << _expr.substr(pos2) << "\"";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- std::size_t pos5=_expr.find_first_not_of(FIGURES,pos4,10);
+ std::size_t const pos5=_expr.find_first_not_of(FIGURES,pos4,10);
if(pos4==pos5)
{//"x+1223334.223e+x" or "1223334.223E-y"
std::ostringstream oss; oss << "Invalid expr : float number in expr is invalid lacking number after exponential ! -> \"" << _expr.substr(pos2,pos4-pos2) << "\"";
_leaf->replaceValues(valuesInExpr);
else
{
- for(std::vector<ExprParser>::iterator iter=_sub_expr.begin();iter!=_sub_expr.end();iter++)
- (*iter).replaceValues(valuesInExpr);
+ for(auto & iter : _sub_expr)
+ iter.replaceValues(valuesInExpr);
}
}
ass.push_back("pop ebp");
ass.push_back("ret");
std::cout << std::endl;
- for(std::vector<std::string>::const_iterator iter=ass.begin();iter!=ass.end();iter++)
- std::cout << " " << *iter << std::endl;
- AsmX86 asmb;
- std::vector<char> output=asmb.convertIntoMachineLangage(ass);
- for(std::vector<char>::const_iterator iter=output.begin();iter!=output.end();iter++)
- std::cout << std::hex << (int)((unsigned char)(*iter)) << " ";
+ for(const auto & as : ass)
+ std::cout << " " << as << std::endl;
+ AsmX86 const asmb;
+ std::vector<char> const output=asmb.convertIntoMachineLangage(ass);
+ for(char const iter : output)
+ std::cout << std::hex << (int)((unsigned char)iter) << " ";
std::cout << std::endl;
unsigned offset;
return asmb.copyToExecMemZone(output,offset);
ass.push_back("leave");
ass.push_back("ret");
std::cout << std::endl;
- for(std::vector<std::string>::const_iterator iter=ass.begin();iter!=ass.end();iter++)
- std::cout << " " << *iter << std::endl;
- AsmX86 asmb;
- std::vector<char> output=asmb.convertIntoMachineLangage(ass);
- for(std::vector<char>::const_iterator iter=output.begin();iter!=output.end();iter++)
- std::cout << std::hex << (int)((unsigned char)(*iter)) << " ";
+ for(const auto & as : ass)
+ std::cout << " " << as << std::endl;
+ AsmX86 const asmb;
+ std::vector<char> const output=asmb.convertIntoMachineLangage(ass);
+ for(char const iter : output)
+ std::cout << std::hex << (int)((unsigned char)iter) << " ";
std::cout << std::endl;
unsigned offset;
return asmb.copyToExecMemZone(output,offset);
_leaf->compileX86(ass);
else
{
- for(std::vector<ExprParser>::const_iterator iter=_sub_expr.begin();iter!=_sub_expr.end();iter++)
- (*iter).compileX86LowLev(ass);
+ for(const auto & iter : _sub_expr)
+ iter.compileX86LowLev(ass);
}
- for(std::vector<Function *>::const_iterator iter2=_func_btw_sub_expr.begin();iter2!=_func_btw_sub_expr.end();iter2++)
- (*iter2)->operateX86(ass);
+ for(auto iter2 : _func_btw_sub_expr)
+ iter2->operateX86(ass);
}
void ExprParser::compileX86_64LowLev(std::vector<std::string>& ass) const
_leaf->compileX86_64(ass);
else
{
- for(std::vector<ExprParser>::const_iterator iter=_sub_expr.begin();iter!=_sub_expr.end();iter++)
- (*iter).compileX86_64LowLev(ass);
+ for(const auto & iter : _sub_expr)
+ iter.compileX86_64LowLev(ass);
}
- for(std::vector<Function *>::const_iterator iter2=_func_btw_sub_expr.begin();iter2!=_func_btw_sub_expr.end();iter2++)
- (*iter2)->operateX86(ass);
+ for(auto iter2 : _func_btw_sub_expr)
+ iter2->operateX86(ass);
}
double LeafExprVal::getDoubleValue() const
return _val[_fast_pos];
else
{
- int pos(-7-_fast_pos);
+ int const pos(-7-_fast_pos);
return pos==_ref_pos?1.:0.;
}
}
{
if(asker)
{
- int sz=_father->getStackSizeToPlayX86(this);
+ int const sz=_father->getStackSizeToPlayX86(this);
int i=0;
- for(std::vector<ExprParser>::const_reverse_iterator iter=_sub_expr.rbegin();iter!=_sub_expr.rend();iter++,i++)
+ for(auto iter=_sub_expr.rbegin();iter!=_sub_expr.rend();iter++,i++)
{
const ExprParser& obj=(*iter);
const ExprParser *pt=&obj;
#include "INTERPKERNELDefines.hxx"
#include "InterpKernelUnit.hxx"
-#include "InterpKernelException.hxx"
#include "InterpKernelFunction.hxx"
+#include <cstddef>
+#include <ostream>
#include <string>
-#include <list>
-#include <map>
#include <set>
+#include <vector>
namespace INTERP_KERNEL
{
{
public:
INTERPKERNEL_EXPORT LeafExprVal(double value);
- INTERPKERNEL_EXPORT ~LeafExprVal();
- INTERPKERNEL_EXPORT double getDoubleValue() const;
- INTERPKERNEL_EXPORT void compileX86(std::vector<std::string>& ass) const;
- INTERPKERNEL_EXPORT void compileX86_64(std::vector<std::string>& ass) const;
- INTERPKERNEL_EXPORT void fillValue(Value *val) const;
- INTERPKERNEL_EXPORT void replaceValues(const std::vector<double>& valuesInExpr);
- INTERPKERNEL_EXPORT LeafExprVal *deepCopy() const;
+ INTERPKERNEL_EXPORT ~LeafExprVal() override;
+ INTERPKERNEL_EXPORT double getDoubleValue() const override;
+ INTERPKERNEL_EXPORT void compileX86(std::vector<std::string>& ass) const override;
+ INTERPKERNEL_EXPORT void compileX86_64(std::vector<std::string>& ass) const override;
+ INTERPKERNEL_EXPORT void fillValue(Value *val) const override;
+ INTERPKERNEL_EXPORT void replaceValues(const std::vector<double>& valuesInExpr) override;
+ INTERPKERNEL_EXPORT LeafExprVal *deepCopy() const override;
private:
double _value;
};
public:
INTERPKERNEL_EXPORT LeafExprVar(const LeafExprVar& other):_fast_pos(other._fast_pos),_ref_pos(other._ref_pos),_var_name(other._var_name),_val(other._val) { }
INTERPKERNEL_EXPORT LeafExprVar(const std::string& var);
- INTERPKERNEL_EXPORT ~LeafExprVar();
- INTERPKERNEL_EXPORT double getDoubleValue() const;
- INTERPKERNEL_EXPORT void compileX86(std::vector<std::string>& ass) const;
- INTERPKERNEL_EXPORT void compileX86_64(std::vector<std::string>& ass) const;
- INTERPKERNEL_EXPORT void fillValue(Value *val) const;
+ INTERPKERNEL_EXPORT ~LeafExprVar() override;
+ INTERPKERNEL_EXPORT double getDoubleValue() const override;
+ INTERPKERNEL_EXPORT void compileX86(std::vector<std::string>& ass) const override;
+ INTERPKERNEL_EXPORT void compileX86_64(std::vector<std::string>& ass) const override;
+ INTERPKERNEL_EXPORT void fillValue(Value *val) const override;
INTERPKERNEL_EXPORT std::string getVar() const { return _var_name; }
INTERPKERNEL_EXPORT void prepareExprEvaluation(const std::vector<std::string>& vars, int nbOfCompo, int targetNbOfCompo) const;
INTERPKERNEL_EXPORT void prepareExprEvaluationDouble(const std::vector<std::string>& vars, int nbOfCompo, int targetNbOfCompo, int refPos, const double *ptOfInputStart, const double *ptOfInputEnd) const;
INTERPKERNEL_EXPORT void prepareExprEvaluationVec() const;
- INTERPKERNEL_EXPORT void replaceValues(const std::vector<double>& valuesInExpr);
+ INTERPKERNEL_EXPORT void replaceValues(const std::vector<double>& valuesInExpr) override;
INTERPKERNEL_EXPORT static bool isRecognizedKeyVar(const std::string& var, int& pos);
- INTERPKERNEL_EXPORT LeafExprVar *deepCopy() const;
+ INTERPKERNEL_EXPORT LeafExprVar *deepCopy() const override;
public:
static const char END_OF_RECOGNIZED_VAR[];
private:
class ExprParserOfEval
{
public:
- ExprParserOfEval():_leaf(0) { }
+ ExprParserOfEval():_leaf(nullptr) { }
ExprParserOfEval(LeafExpr *leaf, const std::vector<ExprParserOfEval>& subParts, const std::vector<Function *>& funcs):_leaf(leaf),_sub_parts(subParts),_funcs(funcs) { }
void evaluateDoubleInternal(std::vector<double>& stck) const
{
if(_leaf)
stck.push_back(_leaf->getDoubleValue());
else
- for(std::vector<ExprParserOfEval>::const_iterator iter=_sub_parts.begin();iter!=_sub_parts.end();iter++)
- (*iter).evaluateDoubleInternal(stck);
- for(std::vector<Function *>::const_iterator iter3=_funcs.begin();iter3!=_funcs.end();iter3++)
- (*iter3)->operateStackOfDouble(stck);
+ for(const auto & _sub_part : _sub_parts)
+ _sub_part.evaluateDoubleInternal(stck);
+ for(auto _func : _funcs)
+ _func->operateStackOfDouble(stck);
}
void evaluateDoubleInternalSafe(std::vector<double>& stck) const
{
if(_leaf)
stck.push_back(_leaf->getDoubleValue());
else
- for(std::vector<ExprParserOfEval>::const_iterator iter=_sub_parts.begin();iter!=_sub_parts.end();iter++)
- (*iter).evaluateDoubleInternalSafe(stck);
- for(std::vector<Function *>::const_iterator iter3=_funcs.begin();iter3!=_funcs.end();iter3++)
- (*iter3)->operateStackOfDoubleSafe(stck);
+ for(const auto & _sub_part : _sub_parts)
+ _sub_part.evaluateDoubleInternalSafe(stck);
+ for(auto _func : _funcs)
+ _func->operateStackOfDoubleSafe(stck);
}
void clearSortedMemory();
void sortMemory();
public:
INTERPKERNEL_EXPORT ExprParser(ExprParser&& other);
INTERPKERNEL_EXPORT ExprParser& operator=(ExprParser&& other);
- INTERPKERNEL_EXPORT ExprParser(const std::string& expr, ExprParser *father=0);
- INTERPKERNEL_EXPORT ExprParser(const char *expr, int lgth, ExprParser *father=0);
+ INTERPKERNEL_EXPORT ExprParser(const std::string& expr, ExprParser *father=nullptr);
+ INTERPKERNEL_EXPORT ExprParser(const char *expr, int lgth, ExprParser *father=nullptr);
INTERPKERNEL_EXPORT ~ExprParser();
INTERPKERNEL_EXPORT void parse();
INTERPKERNEL_EXPORT bool isParsingSuccessfull() const { return _is_parsing_ok; }
#include "InterpKernelFunction.hxx"
#include "InterpKernelValue.hxx"
+#include "InterpKernelException.hxx"
#include <algorithm>
#include <cmath>
#include <limits>
+#include <string>
+#include <vector>
using namespace INTERP_KERNEL;
Function *FunctionsFactory::buildUnaryFuncFromString(const char *type)
{
- std::string tmp(type);
+ std::string const tmp(type);
if(tmp.empty())
return new IdentityFunction;
if(tmp==CosFunction::REPR)
Function *FunctionsFactory::buildBinaryFuncFromString(const char *type)
{
- std::string tmp(type);
+ std::string const tmp(type);
if(tmp==PositiveFunction::REPR)
return new PlusFunction;
if(tmp==NegateFunction::REPR)
Function *FunctionsFactory::buildTernaryFuncFromString(const char *type)
{
- std::string tmp(type);
+ std::string const tmp(type);
if(tmp==IfFunction::REPR)
return new IfFunction();
std::string msg("Invalid ternary function detected : \"");
}
Function::~Function()
-{
-}
+= default;
IdentityFunction::~IdentityFunction()
-{
-}
+= default;
void IdentityFunction::operate(std::vector<Value *>& stck) const
{
}
PositiveFunction::~PositiveFunction()
-{
-}
+= default;
int UnaryFunction::getNbInputParams() const
{
}
NegateFunction::~NegateFunction()
-{
-}
+= default;
void NegateFunction::operate(std::vector<Value *>& stck) const
{
void NegateFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double v(stck.back());
+ double const v(stck.back());
stck.back()=-v;
}
}
CosFunction::~CosFunction()
-{
-}
+= default;
void CosFunction::operate(std::vector<Value *>& stck) const
{
void CosFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double v(stck.back());
+ double const v(stck.back());
stck.back()=cos(v);
}
}
SinFunction::~SinFunction()
-{
-}
+= default;
void SinFunction::operate(std::vector<Value *>& stck) const
{
void SinFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double v(stck.back());
+ double const v(stck.back());
stck.back()=sin(v);
}
}
TanFunction::~TanFunction()
-{
-}
+= default;
void TanFunction::operate(std::vector<Value *>& stck) const
{
val->tan();
}
-void TanFunction::operateX86(std::vector<std::string>& asmb) const
+void TanFunction::operateX86(std::vector<std::string>& /*asmb*/) const
{
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
void TanFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double v(stck.back());
+ double const v(stck.back());
stck.back()=tan(v);
}
}
ACosFunction::~ACosFunction()
-{
-}
+= default;
void ACosFunction::operate(std::vector<Value *>& stck) const
{
val->acos();
}
-void ACosFunction::operateX86(std::vector<std::string>& asmb) const
+void ACosFunction::operateX86(std::vector<std::string>& /*asmb*/) const
{
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
void ACosFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double v(stck.back());
+ double const v(stck.back());
stck.back()=acos(v);
}
void ACosFunction::operateStackOfDoubleSafe(std::vector<double>& stck) const
{
- double v(stck.back());
+ double const v(stck.back());
if(fabs(v)>1.)
throw INTERP_KERNEL::Exception("acos on a value which absolute is > 1 !");
stck.back()=acos(v);
}
ASinFunction::~ASinFunction()
-{
-}
+= default;
void ASinFunction::operate(std::vector<Value *>& stck) const
{
val->asin();
}
-void ASinFunction::operateX86(std::vector<std::string>& asmb) const
+void ASinFunction::operateX86(std::vector<std::string>& /*asmb*/) const
{
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
void ASinFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double v(stck.back());
+ double const v(stck.back());
stck.back()=asin(v);
}
void ASinFunction::operateStackOfDoubleSafe(std::vector<double>& stck) const
{
- double v(stck.back());
+ double const v(stck.back());
if(fabs(v)>1.)
throw INTERP_KERNEL::Exception("asin on a value which absolute is > 1 !");
stck.back()=asin(v);
}
ATanFunction::~ATanFunction()
-{
-}
+= default;
void ATanFunction::operate(std::vector<Value *>& stck) const
{
val->atan();
}
-void ATanFunction::operateX86(std::vector<std::string>& asmb) const
+void ATanFunction::operateX86(std::vector<std::string>& /*asmb*/) const
{
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
void ATanFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double v(stck.back());
+ double const v(stck.back());
stck.back()=atan(v);
}
}
CoshFunction::~CoshFunction()
-{
-}
+= default;
void CoshFunction::operate(std::vector<Value *>& stck) const
{
val->cosh();
}
-void CoshFunction::operateX86(std::vector<std::string>& asmb) const
+void CoshFunction::operateX86(std::vector<std::string>& /*asmb*/) const
{
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
void CoshFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double v(stck.back());
+ double const v(stck.back());
stck.back()=cosh(v);
}
}
SinhFunction::~SinhFunction()
-{
-}
+= default;
void SinhFunction::operate(std::vector<Value *>& stck) const
{
val->sinh();
}
-void SinhFunction::operateX86(std::vector<std::string>& asmb) const
+void SinhFunction::operateX86(std::vector<std::string>& /*asmb*/) const
{
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
void SinhFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double v(stck.back());
+ double const v(stck.back());
stck.back()=sinh(v);
}
}
TanhFunction::~TanhFunction()
-{
-}
+= default;
void TanhFunction::operate(std::vector<Value *>& stck) const
{
val->tanh();
}
-void TanhFunction::operateX86(std::vector<std::string>& asmb) const
+void TanhFunction::operateX86(std::vector<std::string>& /*asmb*/) const
{
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
void TanhFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double v(stck.back());
+ double const v(stck.back());
stck.back()=tanh(v);
}
}
SqrtFunction::~SqrtFunction()
-{
-}
+= default;
void SqrtFunction::operate(std::vector<Value *>& stck) const
{
void SqrtFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double v(stck.back());
+ double const v(stck.back());
stck.back()=sqrt(v);
}
void SqrtFunction::operateStackOfDoubleSafe(std::vector<double>& stck) const
{
- double v(stck.back());
+ double const v(stck.back());
if(v<0.)
throw INTERP_KERNEL::Exception("sqrt on a value < 0. !");
stck.back()=sqrt(v);
}
AbsFunction::~AbsFunction()
-{
-}
+= default;
void AbsFunction::operate(std::vector<Value *>& stck) const
{
void AbsFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double v(stck.back());
+ double const v(stck.back());
stck.back()=fabs(v);
}
val->exp();
}
-void ExpFunction::operateX86(std::vector<std::string>& asmb) const
+void ExpFunction::operateX86(std::vector<std::string>& /*asmb*/) const
{
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
void ExpFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double v(stck.back());
+ double const v(stck.back());
stck.back()=std::exp(v);
}
}
LnFunction::~LnFunction()
-{
-}
+= default;
void LnFunction::operate(std::vector<Value *>& stck) const
{
val->ln();
}
-void LnFunction::operateX86(std::vector<std::string>& asmb) const
+void LnFunction::operateX86(std::vector<std::string>& /*asmb*/) const
{
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
void LnFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double v(stck.back());
+ double const v(stck.back());
stck.back()=std::log(v);
}
void LnFunction::operateStackOfDoubleSafe(std::vector<double>& stck) const
{
- double v(stck.back());
+ double const v(stck.back());
if(v<0.)
throw INTERP_KERNEL::Exception("ln on a value < 0. !");
stck.back()=std::log(v);
}
LogFunction::~LogFunction()
-{
-}
+= default;
void LogFunction::operate(std::vector<Value *>& stck) const
{
val->ln();
}
-void LogFunction::operateX86(std::vector<std::string>& asmb) const
+void LogFunction::operateX86(std::vector<std::string>& /*asmb*/) const
{
throw INTERP_KERNEL::Exception("Assembly for log Not implemented yet !");
}
void LogFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double v(stck.back());
+ double const v(stck.back());
stck.back()=std::log(v);
}
void LogFunction::operateStackOfDoubleSafe(std::vector<double>& stck) const
{
- double v(stck.back());
+ double const v(stck.back());
if(v<0.)
throw INTERP_KERNEL::Exception("log on a value < 0. !");
stck.back()=std::log(v);
}
Log10Function::~Log10Function()
-{
-}
+= default;
void Log10Function::operate(std::vector<Value *>& stck) const
{
val->log10();
}
-void Log10Function::operateX86(std::vector<std::string>& asmb) const
+void Log10Function::operateX86(std::vector<std::string>& /*asmb*/) const
{
throw INTERP_KERNEL::Exception("Assembly for log Not implemented yet !");
}
void Log10Function::operateStackOfDouble(std::vector<double>& stck) const
{
- double v(stck.back());
+ double const v(stck.back());
stck.back()=std::log10(v);
}
void Log10Function::operateStackOfDoubleSafe(std::vector<double>& stck) const
{
- double v(stck.back());
+ double const v(stck.back());
if(v<0.)
throw INTERP_KERNEL::Exception("log10 on a value < 0. !");
stck.back()=std::log10(v);
}
PlusFunction::~PlusFunction()
-{
-}
+= default;
void PlusFunction::operate(std::vector<Value *>& stck) const
{
void PlusFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double a(stck.back());
+ double const a(stck.back());
stck.pop_back();
stck.back()=a+stck.back();
}
}
MinusFunction::~MinusFunction()
-{
-}
+= default;
void MinusFunction::operate(std::vector<Value *>& stck) const
{
void MinusFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double a(stck.back());
+ double const a(stck.back());
stck.pop_back();
stck.back()=a-stck.back();
}
}
MultFunction::~MultFunction()
-{
-}
+= default;
void MultFunction::operate(std::vector<Value *>& stck) const
{
void MultFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double a(stck.back());
+ double const a(stck.back());
stck.pop_back();
stck.back()=a*stck.back();
}
}
DivFunction::~DivFunction()
-{
-}
+= default;
void DivFunction::operate(std::vector<Value *>& stck) const
{
void DivFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double a(stck.back());
+ double const a(stck.back());
stck.pop_back();
stck.back()=a/stck.back();
}
void DivFunction::operateStackOfDoubleSafe(std::vector<double>& stck) const
{
- double a(stck.back());
+ double const a(stck.back());
stck.pop_back();
if(stck.back()==0.)
throw INTERP_KERNEL::Exception("division by 0. !");
}
PowFunction::~PowFunction()
-{
-}
+= default;
void PowFunction::operate(std::vector<Value *>& stck) const
{
val2=val3;
}
-void PowFunction::operateX86(std::vector<std::string>& asmb) const
+void PowFunction::operateX86(std::vector<std::string>& /*asmb*/) const
{
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
void PowFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double a(stck.back());
+ double const a(stck.back());
stck.pop_back();
stck.back()=std::pow(a,stck.back());
}
void PowFunction::operateStackOfDoubleSafe(std::vector<double>& stck) const
{
- double a(stck.back());
+ double const a(stck.back());
stck.pop_back();
- double b(stck.back());
+ double const b(stck.back());
if(a<0.)
throw INTERP_KERNEL::Exception("pow with val < 0. !");
stck.back()=std::pow(a,b);
}
ExpFunction::~ExpFunction()
-{
-}
+= default;
MaxFunction::~MaxFunction()
-{
-}
+= default;
void MaxFunction::operate(std::vector<Value *>& stck) const
{
val2=val3;
}
-void MaxFunction::operateX86(std::vector<std::string>& asmb) const
+void MaxFunction::operateX86(std::vector<std::string>& /*asmb*/) const
{
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
void MaxFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double a(stck.back());
+ double const a(stck.back());
stck.pop_back();
stck.back()=std::max(stck.back(),a);
}
}
MinFunction::~MinFunction()
-{
-}
+= default;
void MinFunction::operate(std::vector<Value *>& stck) const
{
val2=val3;
}
-void MinFunction::operateX86(std::vector<std::string>& asmb) const
+void MinFunction::operateX86(std::vector<std::string>& /*asmb*/) const
{
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
void MinFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double a(stck.back());
+ double const a(stck.back());
stck.pop_back();
stck.back()=std::min(stck.back(),a);
}
}
GreaterThanFunction::~GreaterThanFunction()
-{
-}
+= default;
void GreaterThanFunction::operate(std::vector<Value *>& stck) const
{
val2=val3;
}
-void GreaterThanFunction::operateX86(std::vector<std::string>& asmb) const
+void GreaterThanFunction::operateX86(std::vector<std::string>& /*asmb*/) const
{
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
void GreaterThanFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double a(stck.back());
+ double const a(stck.back());
stck.pop_back();
- double b(stck.back());
+ double const b(stck.back());
stck.back()=a>b?std::numeric_limits<double>::max():-std::numeric_limits<double>::max();
}
}
LowerThanFunction::~LowerThanFunction()
-{
-}
+= default;
void LowerThanFunction::operate(std::vector<Value *>& stck) const
{
val2=val3;
}
-void LowerThanFunction::operateX86(std::vector<std::string>& asmb) const
+void LowerThanFunction::operateX86(std::vector<std::string>& /*asmb*/) const
{
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
void LowerThanFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double a(stck.back());
+ double const a(stck.back());
stck.pop_back();
- double b(stck.back());
+ double const b(stck.back());
stck.back()=a<b?std::numeric_limits<double>::max():-std::numeric_limits<double>::max();
}
}
IfFunction::~IfFunction()
-{
-}
+= default;
void IfFunction::operate(std::vector<Value *>& stck) const
{
val3=val4;
}
-void IfFunction::operateX86(std::vector<std::string>& asmb) const
+void IfFunction::operateX86(std::vector<std::string>& /*asmb*/) const
{
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
void IfFunction::operateStackOfDouble(std::vector<double>& stck) const
{
- double cond(stck.back());
+ double const cond(stck.back());
stck.pop_back();
- double the(stck.back());
+ double const the(stck.back());
stck.pop_back();
if(cond==std::numeric_limits<double>::max())
stck.back()=the;
void IfFunction::operateStackOfDoubleSafe(std::vector<double>& stck) const
{
- double cond(stck.back());
+ double const cond(stck.back());
stck.pop_back();
- double the(stck.back());
+ double const the(stck.back());
stck.pop_back();
if(cond!=std::numeric_limits<double>::max() && cond!=-std::numeric_limits<double>::max())
throw INTERP_KERNEL::Exception("ifFunc : first parameter of ternary func is NOT a consequence of a boolean op !");
#define __INTERPKERNELFUNCTION_HXX__
#include "INTERPKERNELDefines.hxx"
-#include "InterpKernelException.hxx"
+#include <string>
#include <vector>
namespace INTERP_KERNEL
class INTERPKERNEL_EXPORT UnaryFunction : public Function
{
public:
- int getNbInputParams() const;
+ int getNbInputParams() const override;
};
class INTERPKERNEL_EXPORT IdentityFunction : public UnaryFunction
{
public:
- ~IdentityFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- IdentityFunction *deepCopy() const { return new IdentityFunction; }
+ ~IdentityFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ IdentityFunction *deepCopy() const override { return new IdentityFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT PositiveFunction : public UnaryFunction
{
public:
- ~PositiveFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- PositiveFunction *deepCopy() const { return new PositiveFunction; }
+ ~PositiveFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ PositiveFunction *deepCopy() const override { return new PositiveFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT NegateFunction : public UnaryFunction
{
public:
- ~NegateFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- NegateFunction *deepCopy() const { return new NegateFunction; }
+ ~NegateFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ NegateFunction *deepCopy() const override { return new NegateFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT CosFunction : public UnaryFunction
{
public:
- ~CosFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- CosFunction *deepCopy() const { return new CosFunction; }
+ ~CosFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ CosFunction *deepCopy() const override { return new CosFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT SinFunction : public UnaryFunction
{
public:
- ~SinFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- SinFunction *deepCopy() const { return new SinFunction; }
+ ~SinFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ SinFunction *deepCopy() const override { return new SinFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT TanFunction : public UnaryFunction
{
public:
- ~TanFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- TanFunction *deepCopy() const { return new TanFunction; }
+ ~TanFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ TanFunction *deepCopy() const override { return new TanFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT ACosFunction : public UnaryFunction
{
public:
- ~ACosFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- void operateStackOfDoubleSafe(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- ACosFunction *deepCopy() const { return new ACosFunction; }
+ ~ACosFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ void operateStackOfDoubleSafe(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ ACosFunction *deepCopy() const override { return new ACosFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT ASinFunction : public UnaryFunction
{
public:
- ~ASinFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- void operateStackOfDoubleSafe(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- ASinFunction *deepCopy() const { return new ASinFunction; }
+ ~ASinFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ void operateStackOfDoubleSafe(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ ASinFunction *deepCopy() const override { return new ASinFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT ATanFunction : public UnaryFunction
{
public:
- ~ATanFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- ATanFunction *deepCopy() const { return new ATanFunction; }
+ ~ATanFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ ATanFunction *deepCopy() const override { return new ATanFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT CoshFunction : public UnaryFunction
{
public:
- ~CoshFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- CoshFunction *deepCopy() const { return new CoshFunction; }
+ ~CoshFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ CoshFunction *deepCopy() const override { return new CoshFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT SinhFunction : public UnaryFunction
{
public:
- ~SinhFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- SinhFunction *deepCopy() const { return new SinhFunction; }
+ ~SinhFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ SinhFunction *deepCopy() const override { return new SinhFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT TanhFunction : public UnaryFunction
{
public:
- ~TanhFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- TanhFunction *deepCopy() const { return new TanhFunction; }
+ ~TanhFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ TanhFunction *deepCopy() const override { return new TanhFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT SqrtFunction : public UnaryFunction
{
public:
- ~SqrtFunction();
- void operateX86(std::vector<std::string>& asmb) const;
- void operate(std::vector<Value *>& stck) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- void operateStackOfDoubleSafe(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- SqrtFunction *deepCopy() const { return new SqrtFunction; }
+ ~SqrtFunction() override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ void operateStackOfDoubleSafe(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ SqrtFunction *deepCopy() const override { return new SqrtFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT AbsFunction : public UnaryFunction
{
public:
- ~AbsFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- AbsFunction *deepCopy() const { return new AbsFunction; }
+ ~AbsFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ AbsFunction *deepCopy() const override { return new AbsFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT ExpFunction : public UnaryFunction
{
public:
- ~ExpFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- ExpFunction *deepCopy() const { return new ExpFunction; }
+ ~ExpFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ ExpFunction *deepCopy() const override { return new ExpFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT LnFunction : public UnaryFunction
{
public:
- ~LnFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- void operateStackOfDoubleSafe(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- LnFunction *deepCopy() const { return new LnFunction; }
+ ~LnFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ void operateStackOfDoubleSafe(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ LnFunction *deepCopy() const override { return new LnFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT LogFunction : public UnaryFunction
{
public:
- ~LogFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- void operateStackOfDoubleSafe(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- LogFunction *deepCopy() const { return new LogFunction; }
+ ~LogFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ void operateStackOfDoubleSafe(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ LogFunction *deepCopy() const override { return new LogFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT Log10Function : public UnaryFunction
{
public:
- ~Log10Function();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- void operateStackOfDoubleSafe(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- Log10Function *deepCopy() const { return new Log10Function; }
+ ~Log10Function() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ void operateStackOfDoubleSafe(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ Log10Function *deepCopy() const override { return new Log10Function; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT BinaryFunction : public Function
{
public:
- int getNbInputParams() const;
+ int getNbInputParams() const override;
};
class PlusFunction : public BinaryFunction
{
public:
- ~PlusFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- PlusFunction *deepCopy() const { return new PlusFunction; }
+ ~PlusFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ PlusFunction *deepCopy() const override { return new PlusFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT MinusFunction : public BinaryFunction
{
public:
- ~MinusFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- MinusFunction *deepCopy() const { return new MinusFunction; }
+ ~MinusFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ MinusFunction *deepCopy() const override { return new MinusFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT MultFunction : public BinaryFunction
{
public:
- ~MultFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- MultFunction *deepCopy() const { return new MultFunction; }
+ ~MultFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ MultFunction *deepCopy() const override { return new MultFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT DivFunction : public BinaryFunction
{
public:
- ~DivFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- void operateStackOfDoubleSafe(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- DivFunction *deepCopy() const { return new DivFunction; }
+ ~DivFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ void operateStackOfDoubleSafe(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ DivFunction *deepCopy() const override { return new DivFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT PowFunction : public BinaryFunction
{
public:
- ~PowFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- void operateStackOfDoubleSafe(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- PowFunction *deepCopy() const { return new PowFunction; }
+ ~PowFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ void operateStackOfDoubleSafe(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ PowFunction *deepCopy() const override { return new PowFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT MaxFunction : public BinaryFunction
{
public:
- ~MaxFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- MaxFunction *deepCopy() const { return new MaxFunction; }
+ ~MaxFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ MaxFunction *deepCopy() const override { return new MaxFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT MinFunction : public BinaryFunction
{
public:
- ~MinFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- MinFunction *deepCopy() const { return new MinFunction; }
+ ~MinFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ MinFunction *deepCopy() const override { return new MinFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT GreaterThanFunction : public BinaryFunction
{
public:
- ~GreaterThanFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- GreaterThanFunction *deepCopy() const { return new GreaterThanFunction; }
+ ~GreaterThanFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ GreaterThanFunction *deepCopy() const override { return new GreaterThanFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT LowerThanFunction : public BinaryFunction
{
public:
- ~LowerThanFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- LowerThanFunction *deepCopy() const { return new LowerThanFunction; }
+ ~LowerThanFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ LowerThanFunction *deepCopy() const override { return new LowerThanFunction; }
public:
static const char REPR[];
};
class INTERPKERNEL_EXPORT TernaryFunction : public Function
{
public:
- int getNbInputParams() const;
+ int getNbInputParams() const override;
};
class INTERPKERNEL_EXPORT IfFunction : public TernaryFunction
{
public:
- ~IfFunction();
- void operate(std::vector<Value *>& stck) const;
- void operateX86(std::vector<std::string>& asmb) const;
- void operateStackOfDouble(std::vector<double>& stck) const;
- void operateStackOfDoubleSafe(std::vector<double>& stck) const;
- const char *getRepr() const;
- bool isACall() const;
- IfFunction *deepCopy() const { return new IfFunction; }
+ ~IfFunction() override;
+ void operate(std::vector<Value *>& stck) const override;
+ void operateX86(std::vector<std::string>& asmb) const override;
+ void operateStackOfDouble(std::vector<double>& stck) const override;
+ void operateStackOfDoubleSafe(std::vector<double>& stck) const override;
+ const char *getRepr() const override;
+ bool isACall() const override;
+ IfFunction *deepCopy() const override { return new IfFunction; }
public:
static const char REPR[];
};
#include "InterpKernelUnit.hxx"
#include "InterpKernelExprParser.hxx"
+#include "InterpKernelException.hxx"
#include <algorithm>
#include <cmath>
+#include <cstddef>
+#include <map>
#include <sstream>
#include <iomanip>
#include <limits>
+#include <string>
using namespace INTERP_KERNEL;
const UnitDataBase& UnitDataBase::GetUniqueMapForExpr()
{
- static UnitDataBase db;
+ static UnitDataBase const db;
return db;
}
const short *UnitDataBase::getInfoForUnit(const std::string& unit, double& addFact, double& mFact) const
{
- std::size_t lgth=unit.length();
+ std::size_t const lgth=unit.length();
std::string work,work2;
- const short *ret=0;
+ const short *ret=nullptr;
for(std::size_t i=0;i<lgth && !ret;i++)
{
work=unit.substr(i);
- std::map<std::string,const short *>::const_iterator iter=_units_semantic.find(work);
+ auto const iter=_units_semantic.find(work);
if(iter!=_units_semantic.end())
{
ret=(*iter).second;
- std::map<std::string,double>::const_iterator iter2=_units_add.find(work);
+ auto const iter2=_units_add.find(work);
addFact=(*iter2).second;
- std::map<std::string,double>::const_iterator iter3=_units_mul.find(work);
+ auto const iter3=_units_mul.find(work);
mFact=(*iter3).second;
work2=unit.substr(0,i);
}
}
if(!work2.empty())
{
- std::map<std::string,double>::const_iterator iter4=_prefix_pow_10.find(work2);
+ auto const iter4=_prefix_pow_10.find(work2);
if(iter4==_prefix_pow_10.end())
{
std::ostringstream os;
bool DecompositionInUnitBase::isEqual(short mass, short lgth, short time, short intensity, short temp, double add, double mult)
{
- bool ret1=mass==_value[0];
- bool ret2=lgth==_value[1];
- bool ret3=time==_value[2];
- bool ret4=intensity==_value[3];
- bool ret5=temp==_value[4];
- bool ret6=areDoubleEquals(add,_add_to_base);
- bool ret7=areDoubleEquals(mult,_mult_fact_to_base);
+ bool const ret1=mass==_value[0];
+ bool const ret2=lgth==_value[1];
+ bool const ret3=time==_value[2];
+ bool const ret4=intensity==_value[3];
+ bool const ret5=temp==_value[4];
+ bool const ret6=areDoubleEquals(add,_add_to_base);
+ bool const ret7=areDoubleEquals(mult,_mult_fact_to_base);
return ret1 && ret2 && ret3 && ret4 && ret5 && ret6 && ret7;
}
void DecompositionInUnitBase::tryToConvertInUnit(double val)
{
- int valI=(int)val;
+ int const valI=(int)val;
if((val-(double)valI)!=0.)
{
std::ostringstream os;
{
if(!other.isAdimensional())
throw INTERP_KERNEL::Exception("Trying to execute operator ^ with a second member not adimensionnal");
- int exp=couldItBeConsideredAsInt(other._mult_fact_to_base);
+ int const exp=couldItBeConsideredAsInt(other._mult_fact_to_base);
// *= causes ' conversion to 'short int' from 'int' may alter its value [-Wconversion]'
_value[0]=(short)(_value[0]*exp); _value[1]=(short)(_value[1]*exp); _value[2]=(short)(_value[2]*exp); _value[3]=(short)(_value[3]*exp); _value[4]=(short)(_value[4]*exp);
_mult_fact_to_base=powInt(_mult_fact_to_base,exp);
work*=val;
else
{
- int tmp=-exp;
+ int const tmp=-exp;
for(int i=0;i<tmp;i++)
work*=1/val;
}
{
if(a==0. || b==0.)
return a==b;
- double ref=std::max(a,b);
+ double const ref=std::max(a,b);
return fabs((a-b)/ref)<1e-7;
}
int DecompositionInUnitBase::couldItBeConsideredAsInt(double val)
{
- int ret=(int)val;
- double valT=(double) ret;
+ int const ret=(int)val;
+ auto const valT=(double) ret;
if(valT==val)
return ret;
else
tryToInterprate();
}
-Unit::Unit(const char *reprFortran, int sizeOfRepr, bool tryToInterp):_coarse_repr(ExprParser::buildStringFromFortran(reprFortran,sizeOfRepr)),
+Unit::Unit(const char *reprFortran, int sizeOfRepr, bool /*tryToInterp*/):_coarse_repr(ExprParser::buildStringFromFortran(reprFortran,sizeOfRepr)),
_is_interpreted(false),
_is_interpretation_ok(false)
{
#define __INTERPKERNELUNIT_HXX__
#include "INTERPKERNELDefines.hxx"
-#include "InterpKernelException.hxx"
#include <map>
-#include <sstream>
+#include <string>
namespace INTERP_KERNEL
{
#include "InterpKernelValue.hxx"
#include "InterpKernelFunction.hxx"
+#include "InterpKernelUnit.hxx"
+#include "InterpKernelException.hxx"
#include <cmath>
#include <limits>
#include <algorithm>
#include <functional>
+#include <string>
using namespace INTERP_KERNEL;
_data=val;
}
-void ValueDouble::setVarname(int fastPos, const std::string& var)
+void ValueDouble::setVarname(int /*fastPos*/, const std::string& var)
{
std::string msg("Error var : "); msg+=var; msg+=" not numeric : use another expression evaluator !";
throw INTERP_KERNEL::Exception(msg.c_str());
const ValueDouble *ValueDouble::checkSameType(const Value *val)
{
- const ValueDouble *valC=dynamic_cast<const ValueDouble *>(val);
+ const auto *valC=dynamic_cast<const ValueDouble *>(val);
if(!valC)
throw INTERP_KERNEL::Exception("Trying to operate on non homogeneous Values (double with other type) !");
return valC;
}
ValueUnit::ValueUnit()
-{
-}
+= default;
Value *ValueUnit::newInstance() const
{
_data.tryToConvertInUnit(val);
}
-void ValueUnit::setVarname(int fastPos, const std::string& var)
+void ValueUnit::setVarname(int /*fastPos*/, const std::string& var)
{
double add,mul;
const short *projInBase=UnitDataBase::GetUniqueMapForExpr().getInfoForUnit(var,add,mul);
unsupportedOp(Log10Function::REPR);
}
-Value *ValueUnit::plus(const Value *other) const
+Value *ValueUnit::plus(const Value * /*other*/) const
{
unsupportedOp(PlusFunction::REPR);
- return 0;
+ return nullptr;
}
-Value *ValueUnit::minus(const Value *other) const
+Value *ValueUnit::minus(const Value * /*other*/) const
{
unsupportedOp(MinusFunction::REPR);
- return 0;
+ return nullptr;
}
-Value *ValueUnit::greaterThan(const Value *other) const
+Value *ValueUnit::greaterThan(const Value * /*other*/) const
{
unsupportedOp(GreaterThanFunction::REPR);
- return 0;
+ return nullptr;
}
-Value *ValueUnit::lowerThan(const Value *other) const
+Value *ValueUnit::lowerThan(const Value * /*other*/) const
{
unsupportedOp(LowerThanFunction::REPR);
- return 0;
+ return nullptr;
}
-Value *ValueUnit::ifFunc(const Value *the, const Value *els) const
+Value *ValueUnit::ifFunc(const Value * /*the*/, const Value * /*els*/) const
{
unsupportedOp(IfFunction::REPR);
- return 0;
+ return nullptr;
}
Value *ValueUnit::mult(const Value *other) const
return new ValueUnit(tmp);
}
-Value *ValueUnit::max(const Value *other) const
+Value *ValueUnit::max(const Value * /*other*/) const
{
unsupportedOp(MaxFunction::REPR);
- return 0;
+ return nullptr;
}
-Value *ValueUnit::min(const Value *other) const
+Value *ValueUnit::min(const Value * /*other*/) const
{
unsupportedOp(MinFunction::REPR);
- return 0;
+ return nullptr;
}
const ValueUnit *ValueUnit::checkSameType(const Value *val)
{
- const ValueUnit *valC=dynamic_cast<const ValueUnit *>(val);
+ const auto *valC=dynamic_cast<const ValueUnit *>(val);
if(!valC)
throw INTERP_KERNEL::Exception("Trying to operate on non homogeneous Values (Units with other type) !");
return valC;
std::fill(_dest_data,_dest_data+_sz_dest_data,val);
}
-void ValueDoubleExpr::setVarname(int fastPos, const std::string& var)
+void ValueDoubleExpr::setVarname(int fastPos, const std::string& /*var*/)
{
if(fastPos==-2)
std::copy(_src_data,_src_data+_sz_dest_data,_dest_data);
Value *ValueDoubleExpr::plus(const Value *other) const
{
- const ValueDoubleExpr *otherC=static_cast<const ValueDoubleExpr *>(other);
- ValueDoubleExpr *ret=new ValueDoubleExpr(_sz_dest_data,_src_data);
+ const auto *otherC=static_cast<const ValueDoubleExpr *>(other);
+ auto *ret=new ValueDoubleExpr(_sz_dest_data,_src_data);
std::transform(_dest_data,_dest_data+_sz_dest_data,otherC->getData(),ret->getData(),std::plus<double>());
return ret;
}
Value *ValueDoubleExpr::minus(const Value *other) const
{
- const ValueDoubleExpr *otherC=static_cast<const ValueDoubleExpr *>(other);
- ValueDoubleExpr *ret=new ValueDoubleExpr(_sz_dest_data,_src_data);
+ const auto *otherC=static_cast<const ValueDoubleExpr *>(other);
+ auto *ret=new ValueDoubleExpr(_sz_dest_data,_src_data);
std::transform(_dest_data,_dest_data+_sz_dest_data,otherC->getData(),ret->getData(),std::minus<double>());
return ret;
}
Value *ValueDoubleExpr::mult(const Value *other) const
{
- const ValueDoubleExpr *otherC=static_cast<const ValueDoubleExpr *>(other);
- ValueDoubleExpr *ret=new ValueDoubleExpr(_sz_dest_data,_src_data);
+ const auto *otherC=static_cast<const ValueDoubleExpr *>(other);
+ auto *ret=new ValueDoubleExpr(_sz_dest_data,_src_data);
std::transform(_dest_data,_dest_data+_sz_dest_data,otherC->getData(),ret->getData(),std::multiplies<double>());
return ret;
}
Value *ValueDoubleExpr::div(const Value *other) const
{
- const ValueDoubleExpr *otherC=static_cast<const ValueDoubleExpr *>(other);
+ const auto *otherC=static_cast<const ValueDoubleExpr *>(other);
double *it=std::find(otherC->getData(),otherC->getData()+_sz_dest_data,0.);
if(it!=otherC->getData()+_sz_dest_data)
throw INTERP_KERNEL::Exception("Trying to operate division by 0. !");
- ValueDoubleExpr *ret=new ValueDoubleExpr(_sz_dest_data,_src_data);
+ auto *ret=new ValueDoubleExpr(_sz_dest_data,_src_data);
std::transform(_dest_data,_dest_data+_sz_dest_data,otherC->getData(),ret->getData(),std::divides<double>());
return ret;
}
Value *ValueDoubleExpr::pow(const Value *other) const
{
- const ValueDoubleExpr *otherC=static_cast<const ValueDoubleExpr *>(other);
- double p=otherC->getData()[0];
+ const auto *otherC=static_cast<const ValueDoubleExpr *>(other);
+ double const p=otherC->getData()[0];
double *it=std::find_if(_dest_data,_dest_data+_sz_dest_data,std::bind(std::less<double>(),std::placeholders::_1,0.));
if(it!=_dest_data+_sz_dest_data)
throw INTERP_KERNEL::Exception("Trying to operate pow(a,b) with a<0. !");
- ValueDoubleExpr *ret=new ValueDoubleExpr(_sz_dest_data,_src_data);
+ auto *ret=new ValueDoubleExpr(_sz_dest_data,_src_data);
std::transform(_dest_data,_dest_data+_sz_dest_data,ret->getData(),std::bind([](double x, double y){return std::pow(x,y);},std::placeholders::_1,p));
return ret;
}
Value *ValueDoubleExpr::max(const Value *other) const
{
- const ValueDoubleExpr *otherC=static_cast<const ValueDoubleExpr *>(other);
- ValueDoubleExpr *ret=new ValueDoubleExpr(_sz_dest_data,_src_data);
+ const auto *otherC=static_cast<const ValueDoubleExpr *>(other);
+ auto *ret=new ValueDoubleExpr(_sz_dest_data,_src_data);
std::transform(_dest_data,_dest_data+_sz_dest_data,otherC->getData(),ret->getData(),[](const double& x, const double& y){return std::max(x,y);});
return ret;
}
Value *ValueDoubleExpr::min(const Value *other) const
{
- const ValueDoubleExpr *otherC=static_cast<const ValueDoubleExpr *>(other);
- ValueDoubleExpr *ret=new ValueDoubleExpr(_sz_dest_data,_src_data);
+ const auto *otherC=static_cast<const ValueDoubleExpr *>(other);
+ auto *ret=new ValueDoubleExpr(_sz_dest_data,_src_data);
std::transform(_dest_data,_dest_data+_sz_dest_data,otherC->getData(),ret->getData(),[](const double& x, const double& y){return std::min(x,y);});
return ret;
}
Value *ValueDoubleExpr::greaterThan(const Value *other) const
{
- const ValueDoubleExpr *otherC=static_cast<const ValueDoubleExpr *>(other);
- ValueDoubleExpr *ret=new ValueDoubleExpr(_sz_dest_data,_src_data);
+ const auto *otherC=static_cast<const ValueDoubleExpr *>(other);
+ auto *ret=new ValueDoubleExpr(_sz_dest_data,_src_data);
for(int i=0;i<_sz_dest_data;i++)
if(_dest_data[i]<=otherC->getData()[i])
{
Value *ValueDoubleExpr::lowerThan(const Value *other) const
{
- const ValueDoubleExpr *otherC=static_cast<const ValueDoubleExpr *>(other);
- ValueDoubleExpr *ret=new ValueDoubleExpr(_sz_dest_data,_src_data);
+ const auto *otherC=static_cast<const ValueDoubleExpr *>(other);
+ auto *ret=new ValueDoubleExpr(_sz_dest_data,_src_data);
for(int i=0;i<_sz_dest_data;i++)
if(_dest_data[i]>=otherC->getData()[i])
{
Value *ValueDoubleExpr::ifFunc(const Value *the, const Value *els) const
{
- const ValueDoubleExpr *theC=static_cast<const ValueDoubleExpr *>(the);
- const ValueDoubleExpr *elsC=static_cast<const ValueDoubleExpr *>(els);
- ValueDoubleExpr *ret=new ValueDoubleExpr(_sz_dest_data,_src_data);
+ const auto *theC=static_cast<const ValueDoubleExpr *>(the);
+ const auto *elsC=static_cast<const ValueDoubleExpr *>(els);
+ auto *ret=new ValueDoubleExpr(_sz_dest_data,_src_data);
bool okmax=true;
bool okmin=true;
for(int i=0;i<_sz_dest_data && (okmax || okmin);i++)
#define __INTERPKERNELVALUE_HXX__
#include "INTERPKERNELDefines.hxx"
-#include "InterpKernelException.hxx"
#include "InterpKernelUnit.hxx"
+#include <string>
namespace INTERP_KERNEL
{
{
public:
virtual Value *newInstance() const = 0;
- virtual ~Value() { }
+ virtual ~Value() = default;
virtual void setDouble(double val) = 0;
virtual void setVarname(int fastPos, const std::string& var) = 0;
//unary
{
public:
ValueDouble();
- Value *newInstance() const;
- void setDouble(double val);
- void setVarname(int fastPos, const std::string& var);
+ Value *newInstance() const override;
+ void setDouble(double val) override;
+ void setVarname(int fastPos, const std::string& var) override;
//
double getData() const { return _data; }
- void positive();
- void negate();
- void sqrt();
- void cos();
- void sin();
- void tan();
- void acos();
- void asin();
- void atan();
- void cosh();
- void sinh();
- void tanh();
- void abs();
- void exp();
- void ln();
- void log10();
+ void positive() override;
+ void negate() override;
+ void sqrt() override;
+ void cos() override;
+ void sin() override;
+ void tan() override;
+ void acos() override;
+ void asin() override;
+ void atan() override;
+ void cosh() override;
+ void sinh() override;
+ void tanh() override;
+ void abs() override;
+ void exp() override;
+ void ln() override;
+ void log10() override;
//
- Value *plus(const Value *other) const;
- Value *minus(const Value *other) const;
- Value *mult(const Value *other) const;
- Value *div(const Value *other) const;
- Value *pow(const Value *other) const;
- Value *max(const Value *other) const;
- Value *min(const Value *other) const;
- Value *greaterThan(const Value *other) const;
- Value *lowerThan(const Value *other) const;
+ Value *plus(const Value *other) const override;
+ Value *minus(const Value *other) const override;
+ Value *mult(const Value *other) const override;
+ Value *div(const Value *other) const override;
+ Value *pow(const Value *other) const override;
+ Value *max(const Value *other) const override;
+ Value *min(const Value *other) const override;
+ Value *greaterThan(const Value *other) const override;
+ Value *lowerThan(const Value *other) const override;
//
- Value *ifFunc(const Value *the, const Value *els) const;
+ Value *ifFunc(const Value *the, const Value *els) const override;
private:
ValueDouble(double val);
static const ValueDouble *checkSameType(const Value *val);
{
public:
INTERPKERNEL_EXPORT ValueUnit();
- INTERPKERNEL_EXPORT Value *newInstance() const;
- INTERPKERNEL_EXPORT void setDouble(double val);
- INTERPKERNEL_EXPORT void setVarname(int fastPos, const std::string& var);
+ INTERPKERNEL_EXPORT Value *newInstance() const override;
+ INTERPKERNEL_EXPORT void setDouble(double val) override;
+ INTERPKERNEL_EXPORT void setVarname(int fastPos, const std::string& var) override;
//
INTERPKERNEL_EXPORT DecompositionInUnitBase getData() const { return _data; }
- INTERPKERNEL_EXPORT void positive();
- INTERPKERNEL_EXPORT void negate();
- INTERPKERNEL_EXPORT void sqrt();
- INTERPKERNEL_EXPORT void cos();
- INTERPKERNEL_EXPORT void sin();
- INTERPKERNEL_EXPORT void tan();
- INTERPKERNEL_EXPORT void acos();
- INTERPKERNEL_EXPORT void asin();
- INTERPKERNEL_EXPORT void atan();
- INTERPKERNEL_EXPORT void cosh();
- INTERPKERNEL_EXPORT void sinh();
- INTERPKERNEL_EXPORT void tanh();
- INTERPKERNEL_EXPORT void abs();
- INTERPKERNEL_EXPORT void exp();
- INTERPKERNEL_EXPORT void ln();
- INTERPKERNEL_EXPORT void log10();
+ INTERPKERNEL_EXPORT void positive() override;
+ INTERPKERNEL_EXPORT void negate() override;
+ INTERPKERNEL_EXPORT void sqrt() override;
+ INTERPKERNEL_EXPORT void cos() override;
+ INTERPKERNEL_EXPORT void sin() override;
+ INTERPKERNEL_EXPORT void tan() override;
+ INTERPKERNEL_EXPORT void acos() override;
+ INTERPKERNEL_EXPORT void asin() override;
+ INTERPKERNEL_EXPORT void atan() override;
+ INTERPKERNEL_EXPORT void cosh() override;
+ INTERPKERNEL_EXPORT void sinh() override;
+ INTERPKERNEL_EXPORT void tanh() override;
+ INTERPKERNEL_EXPORT void abs() override;
+ INTERPKERNEL_EXPORT void exp() override;
+ INTERPKERNEL_EXPORT void ln() override;
+ INTERPKERNEL_EXPORT void log10() override;
//
- INTERPKERNEL_EXPORT Value *plus(const Value *other) const;
- INTERPKERNEL_EXPORT Value *minus(const Value *other) const;
- INTERPKERNEL_EXPORT Value *mult(const Value *other) const;
- INTERPKERNEL_EXPORT Value *div(const Value *other) const;
- INTERPKERNEL_EXPORT Value *pow(const Value *other) const;
- INTERPKERNEL_EXPORT Value *max(const Value *other) const;
- INTERPKERNEL_EXPORT Value *min(const Value *other) const;
- INTERPKERNEL_EXPORT Value *greaterThan(const Value *other) const;
- INTERPKERNEL_EXPORT Value *lowerThan(const Value *other) const;
+ INTERPKERNEL_EXPORT Value *plus(const Value *other) const override;
+ INTERPKERNEL_EXPORT Value *minus(const Value *other) const override;
+ INTERPKERNEL_EXPORT Value *mult(const Value *other) const override;
+ INTERPKERNEL_EXPORT Value *div(const Value *other) const override;
+ INTERPKERNEL_EXPORT Value *pow(const Value *other) const override;
+ INTERPKERNEL_EXPORT Value *max(const Value *other) const override;
+ INTERPKERNEL_EXPORT Value *min(const Value *other) const override;
+ INTERPKERNEL_EXPORT Value *greaterThan(const Value *other) const override;
+ INTERPKERNEL_EXPORT Value *lowerThan(const Value *other) const override;
//
- INTERPKERNEL_EXPORT Value *ifFunc(const Value *the, const Value *els) const;
+ INTERPKERNEL_EXPORT Value *ifFunc(const Value *the, const Value *els) const override;
private:
ValueUnit(const DecompositionInUnitBase& unit);
static void unsupportedOp(const char *type);
{
public:
ValueDoubleExpr(int szDestData, const double *srcData);
- ~ValueDoubleExpr();
+ ~ValueDoubleExpr() override;
double *getData() const { return _dest_data; }
- Value *newInstance() const;
- void setDouble(double val);
- void setVarname(int fastPos, const std::string& var);
+ Value *newInstance() const override;
+ void setDouble(double val) override;
+ void setVarname(int fastPos, const std::string& var) override;
//
- void positive();
- void negate();
- void sqrt();
- void cos();
- void sin();
- void tan();
- void acos();
- void asin();
- void atan();
- void cosh();
- void sinh();
- void tanh();
- void abs();
- void exp();
- void ln();
- void log10();
+ void positive() override;
+ void negate() override;
+ void sqrt() override;
+ void cos() override;
+ void sin() override;
+ void tan() override;
+ void acos() override;
+ void asin() override;
+ void atan() override;
+ void cosh() override;
+ void sinh() override;
+ void tanh() override;
+ void abs() override;
+ void exp() override;
+ void ln() override;
+ void log10() override;
//
- Value *plus(const Value *other) const;
- Value *minus(const Value *other) const;
- Value *mult(const Value *other) const;
- Value *div(const Value *other) const;
- Value *pow(const Value *other) const;
- Value *max(const Value *other) const;
- Value *min(const Value *other) const;
- Value *greaterThan(const Value *other) const;
- Value *lowerThan(const Value *other) const;
+ Value *plus(const Value *other) const override;
+ Value *minus(const Value *other) const override;
+ Value *mult(const Value *other) const override;
+ Value *div(const Value *other) const override;
+ Value *pow(const Value *other) const override;
+ Value *max(const Value *other) const override;
+ Value *min(const Value *other) const override;
+ Value *greaterThan(const Value *other) const override;
+ Value *lowerThan(const Value *other) const override;
//
- Value *ifFunc(const Value *the, const Value *els) const;
+ Value *ifFunc(const Value *the, const Value *els) const override;
private:
int _sz_dest_data;
double *_dest_data;
//Local includes
#include "InterpKernelGaussCoords.hxx"
#include "CellModel.hxx"
+#include "NormalizedGeometricTypes"
+#include "InterpKernelException.hxx"
+#include "MCIdType.hxx"
//STL includes
+#include <cstddef>
#include <math.h>
#include <algorithm>
#include <sstream>
#include <cmath>
+#include <vector>
using namespace INTERP_KERNEL;
//---------------------------------------------------------------
static bool IsEqual(double theLeft, double theRight)
{
- static double EPS = 1.0E-3;
+ static double const EPS = 1.0E-3;
if(fabs(theLeft) + fabs(theRight) > EPS)
return fabs(theLeft-theRight)/(fabs(theLeft)+fabs(theRight)) < EPS;
return true;
* Destructor
*/
GaussInfo::~GaussInfo()
-{
-}
+= default;
/*!
* Return dimension of the gauss coordinates
{
case NORM_SEG3:
{
- std::vector<double> a(SEG3_REF,SEG3_REF+3);
+ std::vector<double> const a(SEG3_REF,SEG3_REF+3);
if(IsSatisfy(a,_my_reference_coord))
{
- std::vector<double> c(SEG2A_REF,SEG2A_REF+2);
+ std::vector<double> const c(SEG2A_REF,SEG2A_REF+2);
return GaussInfo(NORM_SEG2,_my_gauss_coord,getNbGauss(),c,2);
}
throw INTERP_KERNEL::Exception("GaussInfo::convertToLinear : not recognized pattern for SEG3 !");
std::vector<double> a(TRIA6A_REF,TRIA6A_REF+12),b(TRIA6B_REF,TRIA6B_REF+12);
if(IsSatisfy(a,_my_reference_coord))
{
- std::vector<double> c(TRIA3A_REF,TRIA3A_REF+6);
+ std::vector<double> const c(TRIA3A_REF,TRIA3A_REF+6);
return GaussInfo(NORM_TRI3,_my_gauss_coord,getNbGauss(),c,3);
}
if(IsSatisfy(b,_my_reference_coord))
{
- std::vector<double> c(TRIA3B_REF,TRIA3B_REF+6);
+ std::vector<double> const c(TRIA3B_REF,TRIA3B_REF+6);
return GaussInfo(NORM_TRI3,_my_gauss_coord,getNbGauss(),c,3);
}
throw INTERP_KERNEL::Exception("GaussInfo::convertToLinear : not recognized pattern for TRI6 !");
}
case NORM_TRI7:
{
- std::vector<double> a(TRIA7A_REF,TRIA7A_REF+14);
+ std::vector<double> const a(TRIA7A_REF,TRIA7A_REF+14);
if(IsSatisfy(a,_my_reference_coord))
{
- std::vector<double> c(TRIA3B_REF,TRIA3B_REF+6);
+ std::vector<double> const c(TRIA3B_REF,TRIA3B_REF+6);
return GaussInfo(NORM_TRI3,_my_gauss_coord,getNbGauss(),c,3);
}
throw INTERP_KERNEL::Exception("GaussInfo::convertToLinear : not recognized pattern for TRI7 !");
std::vector<double> a(QUAD8A_REF,QUAD8A_REF+16),b(QUAD8B_REF,QUAD8B_REF+16);
if(IsSatisfy(a,_my_reference_coord))
{
- std::vector<double> c(QUAD4A_REF,QUAD4A_REF+8);
+ std::vector<double> const c(QUAD4A_REF,QUAD4A_REF+8);
return GaussInfo(NORM_QUAD4,_my_gauss_coord,getNbGauss(),c,4);
}
if(IsSatisfy(b,_my_reference_coord))
{
- std::vector<double> c(QUAD4B_REF,QUAD4B_REF+8);
+ std::vector<double> const c(QUAD4B_REF,QUAD4B_REF+8);
return GaussInfo(NORM_QUAD4,_my_gauss_coord,getNbGauss(),c,4);
}
throw INTERP_KERNEL::Exception("GaussInfo::convertToLinear : not recognized pattern for QUAD8 !");
}
case NORM_QUAD9:
{
- std::vector<double> a(QUAD9A_REF,QUAD9A_REF+18);
+ std::vector<double> const a(QUAD9A_REF,QUAD9A_REF+18);
if(IsSatisfy(a,_my_reference_coord))
{
- std::vector<double> c(QUAD4B_REF,QUAD4B_REF+8);
+ std::vector<double> const c(QUAD4B_REF,QUAD4B_REF+8);
return GaussInfo(NORM_QUAD4,_my_gauss_coord,getNbGauss(),c,4);
}
throw INTERP_KERNEL::Exception("GaussInfo::convertToLinear : not recognized pattern for QUAD9 !");
std::vector<double> a(TETRA10A_REF,TETRA10A_REF+30),b(TETRA10B_REF,TETRA10B_REF+30);
if(IsSatisfy(a,_my_reference_coord))
{
- std::vector<double> c(TETRA4A_REF,TETRA4A_REF+12);
+ std::vector<double> const c(TETRA4A_REF,TETRA4A_REF+12);
return GaussInfo(NORM_TETRA4,_my_gauss_coord,getNbGauss(),c,4);
}
if(IsSatisfy(b,_my_reference_coord))
bool GaussInfo::isSatisfy()
{
- bool anIsSatisfy = ((_my_local_nb_ref == _my_nb_ref) && (_my_local_ref_dim == getReferenceCoordDim()));
+ bool const anIsSatisfy = ((_my_local_nb_ref == _my_nb_ref) && (_my_local_ref_dim == getReferenceCoordDim()));
//Check coordinates
if(anIsSatisfy)
{
if(sz%dim!=0)
throw INTERP_KERNEL::Exception("GaussInfo::NormalizeCoordinatesIfNecessary : invalid input array ! Inconsistent with the given dimension !");
const CellModel& cm(CellModel::GetCellModel(ct));
- std::size_t baseDim((std::size_t)cm.getDimension());
+ auto const baseDim((std::size_t)cm.getDimension());
if(baseDim==dim)
return inputArray;
- std::size_t nbOfItems(sz/dim);
+ std::size_t const nbOfItems(sz/dim);
std::vector<double> ret(nbOfItems*baseDim);
if(baseDim>dim)
{
}
}
-typedef void (*MapToShapeFunction)(GaussInfo& obj);
+using MapToShapeFunction = void (*)(GaussInfo &);
/*!
* Initialize the internal vectors
_my_local_ref_dim = 2;
_my_local_nb_ref = 4;
MapToShapeFunction QUAD4PTR[]={Quad4aInit,Quad4bInit,Quad4cInit,Quad4DegSeg2Init};
- std::size_t NB_OF_QUAD4PTR(sizeof(QUAD4PTR)/sizeof(MapToShapeFunction));
+ std::size_t const NB_OF_QUAD4PTR(sizeof(QUAD4PTR)/sizeof(MapToShapeFunction));
for(std::size_t i=0;i<NB_OF_QUAD4PTR && !aSatify;i++)
{
(QUAD4PTR[i])(*this);
_my_local_ref_dim = 3;
_my_local_nb_ref = 6;
MapToShapeFunction PENTA6PTR[]={Penta6aInit,Penta6bInit,Penta6DegTria3aInit,Penta6DegTria3bInit};
- std::size_t NB_OF_PENTA6PTR(sizeof(PENTA6PTR)/sizeof(MapToShapeFunction));
+ std::size_t const NB_OF_PENTA6PTR(sizeof(PENTA6PTR)/sizeof(MapToShapeFunction));
for(std::size_t i=0;i<NB_OF_PENTA6PTR && !aSatify;i++)
{
(PENTA6PTR[i])(*this);
_my_local_ref_dim = 3;
_my_local_nb_ref = 15;
MapToShapeFunction PENTA15PTR[]={Penta15aInit,Penta15bInit};
- std::size_t NB_OF_PENTA15PTR(sizeof(PENTA15PTR)/sizeof(MapToShapeFunction));
+ std::size_t const NB_OF_PENTA15PTR(sizeof(PENTA15PTR)/sizeof(MapToShapeFunction));
for(std::size_t i=0;i<NB_OF_PENTA15PTR && !aSatify;i++)
{
(PENTA15PTR[i])(*this);
_my_local_ref_dim = 3;
_my_local_nb_ref = 18;
MapToShapeFunction PENTA18PTR[]={Penta18aInit,Penta18bInit};
- std::size_t NB_OF_PENTA18PTR(sizeof(PENTA18PTR)/sizeof(MapToShapeFunction));
+ std::size_t const NB_OF_PENTA18PTR(sizeof(PENTA18PTR)/sizeof(MapToShapeFunction));
for(std::size_t i=0;i<NB_OF_PENTA18PTR && !aSatify;i++)
{
(PENTA18PTR[i])(*this);
_my_local_ref_dim = 3;
_my_local_nb_ref = 8;
MapToShapeFunction HEXA8PTR[]={Hexa8aInit,Hexa8bInit,Hexa8DegQuad4aInit,Hexa8DegQuad4bInit,Hexa8DegQuad4cInit};
- std::size_t NB_OF_HEXA8PTR(sizeof(HEXA8PTR)/sizeof(MapToShapeFunction));
+ std::size_t const NB_OF_HEXA8PTR(sizeof(HEXA8PTR)/sizeof(MapToShapeFunction));
for(std::size_t i=0;i<NB_OF_HEXA8PTR && !aSatify;i++)
{
(HEXA8PTR[i])(*this);
* Constructor
*/
GaussCoords::GaussCoords()
-{
-}
+= default;
/*!
* Destructor
aReferenceCoord.push_back(theReferenceCoord[i]);
- GaussInfo* info = new GaussInfo( theGeometry, aGaussCoord, FromIdType<int>(theNbGauss), aReferenceCoord, FromIdType<int>(theNbRef));
+ auto* info = new GaussInfo( theGeometry, aGaussCoord, FromIdType<int>(theNbGauss), aReferenceCoord, FromIdType<int>(theNbRef));
info->initLocalInfo();
//If info with cell type doesn't exist add it
const mcIdType *theIndex)
{
const GaussInfo *info = getInfoGivenCellType(theGeometry);
- int nbCoords = theSpaceDim * info->getNbGauss();
- double *aCoords = new double[nbCoords];
+ int const nbCoords = theSpaceDim * info->getNbGauss();
+ auto *aCoords = new double[nbCoords];
calculateCoordsAlg(info,theNodeCoords,theSpaceDim,theIndex,aCoords);
return aCoords;
}
void GaussCoords::calculateCoordsAlg(const GaussInfo *info, const double* theNodeCoords, const int theSpaceDim, const mcIdType *theIndex, double *result)
{
- int aConn = info->getNbRef();
+ int const aConn = info->getNbRef();
- int nbCoords = theSpaceDim * info->getNbGauss();
+ int const nbCoords = theSpaceDim * info->getNbGauss();
std::fill(result,result+nbCoords,0.);
for( int gaussId = 0; gaussId < info->getNbGauss(); gaussId++ )
#define __INTERPKERNELGAUSSCOORDS_HXX__
#include "INTERPKERNELDefines.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
-#include "InterpKernelException.hxx"
#include "MCIdType.hxx"
+#include "NormalizedGeometricTypes"
#include <vector>
namespace INTERP_KERNEL
{
- typedef std::vector<double> DataVector;
- typedef std::vector<int> IndexVector;
+ using DataVector = std::vector<double>;
+ using IndexVector = std::vector<int>;
//Class to store Gauss Points information
class GaussInfo
void calculateCoordsAlg(const GaussInfo *info, const double* theNodeCoords, const int theSpaceDim, const mcIdType *theIndex,
double *result);
private:
- typedef std::vector<GaussInfo*> GaussInfoVector;
+ using GaussInfoVector = std::vector<GaussInfo *>;
GaussInfoVector _my_gauss_info;
};
}
#ifndef __GENMATHFORMULAE_HXX__
#define __GENMATHFORMULAE_HXX__
-#include "InterpKernelException.hxx"
#include <cmath>
+#include <math.h>
namespace INTERP_KERNEL
{
*/
void computeEigenValues6(const double *matrix, double *eigenVals)
{
- double tr=(matrix[0]+matrix[1]+matrix[2])/3.;
- double K[6]={matrix[0]-tr,matrix[1]-tr,matrix[2]-tr,matrix[3],matrix[4],matrix[5]};
- double q=(K[0]*K[1]*K[2]+2.*K[4]*K[5]*K[3]-K[0]*K[4]*K[4]-K[2]*K[3]*K[3]-K[1]*K[5]*K[5])/2.;
+ double const tr=(matrix[0]+matrix[1]+matrix[2])/3.;
+ double const K[6]={matrix[0]-tr,matrix[1]-tr,matrix[2]-tr,matrix[3],matrix[4],matrix[5]};
+ double const q=(K[0]*K[1]*K[2]+2.*K[4]*K[5]*K[3]-K[0]*K[4]*K[4]-K[2]*K[3]*K[3]-K[1]*K[5]*K[5])/2.;
double p=K[0]*K[0]+K[1]*K[1]+K[2]*K[2]+2*(K[3]*K[3]+K[4]*K[4]+K[5]*K[5]);
p/=6.;
- double sqp=sqrt(p);
- double tmp=p*sqp;
+ double const sqp=sqrt(p);
+ double const tmp=p*sqp;
double phi;
if(fabs(q)<=fabs(tmp))
if(tmp !=0)
const double m9[9]={matrix[0]-eigenVal,matrix[3],matrix[5],matrix[3],matrix[1]-eigenVal,matrix[4],matrix[5],matrix[4],matrix[2]-eigenVal};
for(int i=0;i<3;i++)
{
- double w[9]={m9[0+3*i],m9[1+3*i],m9[2+3*i],m9[0+(3*(i+1))%6],m9[1+(3*(i+1))%6],m9[2+(3*(i+1))%6],1.,1.,1.};
- double det=w[0]*w[4]*w[8]+w[1]*w[5]*w[6]+w[2]*w[3]*w[7]-w[0]*w[5]*w[7]-w[1]*w[3]*w[8]-w[2]*w[4]*w[6];
+ double const w[9]={m9[0+3*i],m9[1+3*i],m9[2+3*i],m9[0+(3*(i+1))%6],m9[1+(3*(i+1))%6],m9[2+(3*(i+1))%6],1.,1.,1.};
+ double const det=w[0]*w[4]*w[8]+w[1]*w[5]*w[6]+w[2]*w[3]*w[7]-w[0]*w[5]*w[7]-w[1]*w[3]*w[8]-w[2]*w[4]*w[6];
if(fabs(det)>eps)
{
eigenVector[0]=(w[1]*w[5]-w[4]*w[2])/det;
eigenVector[1]=(w[2]*w[3]-w[0]*w[5])/det;
eigenVector[2]=(w[0]*w[4]-w[1]*w[3])/det;
- double norm=sqrt(eigenVector[0]*eigenVector[0]+eigenVector[1]*eigenVector[1]+eigenVector[2]*eigenVector[2]);
+ double const norm=sqrt(eigenVector[0]*eigenVector[0]+eigenVector[1]*eigenVector[1]+eigenVector[2]*eigenVector[2]);
eigenVector[0]/=norm;
eigenVector[1]/=norm;
eigenVector[2]/=norm;
#include "InterpKernelGeo2DAbstractEdge.hxx"
#include "InterpKernelGeo2DComposedEdge.hxx"
+#include "InterpKernelGeo2DEdge.hxx"
#include "InterpKernelGeo2DElementaryEdge.hxx"
+#include <list>
+#include <cstddef>
using namespace INTERP_KERNEL;
-IteratorOnComposedEdge::IteratorOnComposedEdge():_list_handle(0)
+IteratorOnComposedEdge::IteratorOnComposedEdge():_list_handle(nullptr)
{
}
void IteratorOnComposedEdge::assignMySelfToAllElems(ComposedEdge *elems)
{
std::list<ElementaryEdge *> *myList=elems->getListBehind();
- for(std::list<ElementaryEdge *>::iterator iter=myList->begin();iter!=myList->end();iter++)
- (*iter)->getIterator()=(*this);
+ for(auto & iter : *myList)
+ iter->getIterator()=(*this);
}
void IteratorOnComposedEdge::insertElemEdges(ComposedEdge *elems, bool changeMySelf)
{
std::list<ElementaryEdge *> *myListToInsert=elems->getListBehind();
- std::list<ElementaryEdge *>::iterator iter=myListToInsert->begin();
+ auto iter=myListToInsert->begin();
*_deep_it=*iter;
_deep_it++;
iter++;
- std::size_t sizeOfMyList=myListToInsert->size();
+ std::size_t const sizeOfMyList=myListToInsert->size();
_list_handle->insert(_deep_it,iter,myListToInsert->end());
if(!changeMySelf)
{
#include "INTERPKERNELDefines.hxx"
-#include <set>
#include <list>
-#include <fstream>
namespace INTERP_KERNEL
{
public:
INTERPKERNEL_EXPORT IteratorOnComposedEdge();
INTERPKERNEL_EXPORT IteratorOnComposedEdge(ComposedEdge *compEdges);
- INTERPKERNEL_EXPORT bool isValid() const { return _list_handle!=0; }
+ INTERPKERNEL_EXPORT bool isValid() const { return _list_handle!=nullptr; }
INTERPKERNEL_EXPORT void operator=(const IteratorOnComposedEdge& other);
INTERPKERNEL_EXPORT void first() { _deep_it=_list_handle->begin(); }
INTERPKERNEL_EXPORT void next() { _deep_it++; }
#include "InterpKernelException.hxx"
#include "InterpKernelGeo2DEdgeArcCircle.hxx"
#include "InterpKernelGeo2DNode.hxx"
+#include <cmath>
+#include <algorithm>
+#include "InterpKernelGeo2DPrecision.hxx"
using namespace INTERP_KERNEL;
double Bounds::getDiagonal() const
{
- double a=_x_max-_x_min;
- double b=_y_max-_y_min;
+ double const a=_x_max-_x_min;
+ double const b=_y_max-_y_min;
return sqrt(a*a+b*b);
}
*/
void Bounds::getInterceptedArc(const double *center, double radius, double& intrcptArcAngle0, double& intrcptArcDelta) const
{
- double diag=getDiagonal();
+ double const diag=getDiagonal();
if(diag<2.*radius)
{
double v1[2],v2[2],w1[2],w2[2];
v1[0]=_x_min-center[0]; v1[1]=_y_max-center[1]; v2[0]=_x_max-center[0]; v2[1]=_y_min-center[1];
w1[0]=v1[0]; w1[1]=_y_min-center[1]; w2[0]=v2[0]; w2[1]=_y_max-center[1];
- double delta1=EdgeArcCircle::SafeAsin(v1[0]*v2[1]-v1[1]*v2[0]);
- double delta2=EdgeArcCircle::SafeAsin(w1[0]*w2[1]-w1[1]*w2[0]);
+ double const delta1=EdgeArcCircle::SafeAsin(v1[0]*v2[1]-v1[1]*v2[0]);
+ double const delta2=EdgeArcCircle::SafeAsin(w1[0]*w2[1]-w1[1]*w2[0]);
double tmp;
if(fabs(delta1)>fabs(delta2))
{
double Bounds::fitXForXFigD(double val, int res) const
{
double delta=std::max(_x_max-_x_min,_y_max-_y_min)/2.;
- double ret=val-(_x_max+_x_min)/2.+delta;
+ double const ret=val-(_x_max+_x_min)/2.+delta;
delta=11.1375*res/(2.*delta);
return ret*delta;
}
double Bounds::fitYForXFigD(double val, int res) const
{
double delta=std::max(_x_max-_x_min,_y_max-_y_min)/2.;
- double ret=(_y_max+_y_min)/2.-val+delta;
+ double const ret=(_y_max+_y_min)/2.-val+delta;
delta=11.1375*res/(2.*delta);
return ret*delta;
}
Bounds *Bounds::nearlyAmIIntersectingWith(const Bounds& other) const
{
- double eps = QuadraticPlanarPrecision::getPrecision();
+ double const eps = QuadraticPlanarPrecision::getPrecision();
if( (other._x_min > _x_max+eps) || (other._x_max < _x_min-eps) || (other._y_min > _y_max+eps)
|| (other._y_max < _y_min-eps) )
- return 0;
+ return nullptr;
if( (other._x_min >= _x_max ) || (other._x_max <= _x_min) || (other._y_min >= _y_max) || (other._y_max <= _y_min) )
{
return new Bounds(std::max(_x_min-eps,other._x_min),
Bounds *Bounds::amIIntersectingWith(const Bounds& other) const
{
if( (other._x_min > _x_max) || (other._x_max < _x_min) || (other._y_min > _y_max) || (other._y_max < _y_min) )
- return 0;
+ return nullptr;
return new Bounds(std::max(_x_min,other._x_min),std::min(_x_max,other._x_max),std::max(_y_min,other._y_min),std::min(_y_max,other._y_max));
}
Position Bounds::nearlyWhere(double x, double y) const
{
- bool thinX=Node::areDoubleEquals(_x_min,_x_max);
- bool thinY=Node::areDoubleEquals(_y_min,_y_max);
+ bool const thinX=Node::areDoubleEquals(_x_min,_x_max);
+ bool const thinY=Node::areDoubleEquals(_y_min,_y_max);
if(!thinX)
{
if((Node::areDoubleEquals(x,_x_min) || Node::areDoubleEquals(x,_x_max)) && ((y<_y_max+QuadraticPlanarPrecision::getPrecision()) && (y>_y_min-QuadraticPlanarPrecision::getPrecision())))
void getBarycenter(double& xBary, double& yBary) const;
void applySimilarity(double xBary, double yBary, double dimChar);
void unApplySimilarity(double xBary, double yBary, double dimChar);
- Bounds& operator=(const Bounds& other) { _x_min=other._x_min; _x_max=other._x_max; _y_min=other._y_min; _y_max=other._y_max; return *this; }
+ Bounds& operator=(const Bounds& other) = default;
Bounds(double xMin, double xMax, double yMin, double yMax):_x_min(xMin),_x_max(xMax),_y_min(yMin),_y_max(yMax) { }
void setValues(double xMin, double xMax, double yMin, double yMax) { _x_min=xMin; _x_max=xMax; _y_min=yMin; _y_max=yMax; }
void prepareForAggregation();
// Author : Anthony Geay (CEA/DEN)
#include "InterpKernelGeo2DComposedEdge.hxx"
+#include "InterpKernelGeo2DEdge.hxx"
+#include "InterpKernelGeo2DBounds.hxx"
#include "InterpKernelGeo2DElementaryEdge.hxx"
#include "InterpKernelGeo2DEdgeArcCircle.hxx"
#include "InterpKernelGeo2DEdgeInfLin.hxx"
#include "InterpKernelException.hxx"
+#include "InterpKernelGeo2DNode.hxx"
+#include "InterpKernelGeo2DPrecision.hxx"
#include <algorithm>
+#include <list>
+#include <cmath>
+#include <map>
+#include <iostream>
+#include <math.h>
+#include <functional>
+#include <cstddef>
#include <memory>
#include <iterator>
+#include <ostream>
#include <set>
+#include <vector>
using namespace INTERP_KERNEL;
ComposedEdge::ComposedEdge(const ComposedEdge& other)
{
- for(std::list<ElementaryEdge *>::const_iterator iter=other._sub_edges.begin();iter!=other._sub_edges.end();iter++)
- _sub_edges.push_back((*iter)->clone());
+ for(auto _sub_edge : other._sub_edges)
+ _sub_edges.push_back(_sub_edge->clone());
}
ComposedEdge::~ComposedEdge()
void ComposedEdge::setValueAt(int i, Edge *e, bool direction)
{
- std::list<ElementaryEdge*>::iterator it=_sub_edges.begin();
+ auto it=_sub_edges.begin();
for(int j=0;j<i;j++)
it++;
delete *it;
double ComposedEdge::getCommonLengthWith(const ComposedEdge& other) const
{
double ret=0.;
- for(std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();iter!=_sub_edges.end();iter++)
+ for(auto _sub_edge : _sub_edges)
{
- if(find_if(other._sub_edges.begin(),other._sub_edges.end(),AbsEdgeCmp(*iter))!=other._sub_edges.end())
+ if(find_if(other._sub_edges.begin(),other._sub_edges.end(),AbsEdgeCmp(_sub_edge))!=other._sub_edges.end())
{
- const ElementaryEdge *tmp=static_cast<const ElementaryEdge *>(*iter);
+ const auto *tmp=static_cast<const ElementaryEdge *>(_sub_edge);
ret+=tmp->getCurveLength();
}
}
ElementaryEdge *ComposedEdge::operator[](int i) const
{
- std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();
+ auto iter=_sub_edges.begin();
for(int ii=0;ii<i;ii++)
iter++;
return *iter;
void ComposedEdge::reverse()
{
_sub_edges.reverse();
- for(std::list<ElementaryEdge *>::iterator iter=_sub_edges.begin();iter!=_sub_edges.end();iter++)
- (*iter)->reverse();
+ for(auto & _sub_edge : _sub_edges)
+ _sub_edge->reverse();
}
bool ComposedEdge::presenceOfOn() const
{
bool ret=false;
- for(std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();iter!=_sub_edges.end() && !ret;iter++)
+ for(auto iter=_sub_edges.begin();iter!=_sub_edges.end() && !ret;iter++)
ret=((*iter)->getLoc()==FULL_ON_1);
return ret;
}
bool ComposedEdge::presenceOfQuadraticEdge() const
{
bool ret=false;
- for(std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();iter!=_sub_edges.end() && !ret;iter++)
+ for(auto iter=_sub_edges.begin();iter!=_sub_edges.end() && !ret;iter++)
{
Edge *e=(*iter)->getPtr();
if(e)
- ret=dynamic_cast<EdgeArcCircle*>(e)!=0;
+ ret=dynamic_cast<EdgeArcCircle*>(e)!=nullptr;
}
return ret;
}
void ComposedEdge::initLocations() const
{
- for(std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();iter!=_sub_edges.end();iter++)
- (*iter)->initLocations();
+ for(auto _sub_edge : _sub_edges)
+ _sub_edge->initLocations();
}
/**
void ComposedEdge::InitLocationsWithOther(const ComposedEdge& first, const ComposedEdge& other)
{
std::set<Edge *> s1,s2;
- for(std::list<ElementaryEdge *>::const_iterator it1=first._sub_edges.begin();it1!=first._sub_edges.end();it1++)
- s1.insert((*it1)->getPtr());
- for(std::list<ElementaryEdge *>::const_iterator it2=other._sub_edges.begin();it2!=other._sub_edges.end();it2++)
- s2.insert((*it2)->getPtr());
+ for(auto _sub_edge : first._sub_edges)
+ s1.insert(_sub_edge->getPtr());
+ for(auto _sub_edge : other._sub_edges)
+ s2.insert(_sub_edge->getPtr());
first.initLocations();
other.initLocations();
std::vector<Edge *> s3;
std::set_intersection(s1.begin(),s1.end(),s2.begin(),s2.end(),std::back_insert_iterator< std::vector<Edge *> >(s3));
- for(std::vector<Edge *>::const_iterator it3=s3.begin();it3!=s3.end();it3++)
- (*it3)->declareOn();
+ for(auto it3 : s3)
+ it3->declareOn();
}
ComposedEdge *ComposedEdge::clone() const
bool ComposedEdge::isNodeIn(Node *n) const
{
bool ret=false;
- for(std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();iter!=_sub_edges.end() && !ret;iter++)
+ for(auto iter=_sub_edges.begin();iter!=_sub_edges.end() && !ret;iter++)
ret=(*iter)->isNodeIn(n);
return ret;
}
double ComposedEdge::getArea() const
{
double ret=0.;
- for(std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();iter!=_sub_edges.end();iter++)
- ret+=(*iter)->getAreaOfZone();
+ for(auto _sub_edge : _sub_edges)
+ ret+=_sub_edge->getAreaOfZone();
return ret;
}
double ComposedEdge::getPerimeter() const
{
double ret=0.;
- for(std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();iter!=_sub_edges.end();iter++)
- ret+=(*iter)->getCurveLength();
+ for(auto _sub_edge : _sub_edges)
+ ret+=_sub_edge->getCurveLength();
return ret;
}
bary[0]=0.;
bary[1]=0.;
double area=0.;
- for(std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();iter!=_sub_edges.end();iter++)
+ for(auto _sub_edge : _sub_edges)
{
- (*iter)->getBarycenterOfZone(bary);
- area+=(*iter)->getAreaOfZone();
+ _sub_edge->getBarycenterOfZone(bary);
+ area+=_sub_edge->getAreaOfZone();
}
bary[0]/=area;
bary[1]/=area;
Bounds b;
b.prepareForAggregation();
fillBounds(b);
- double dimChar=b.getCaracteristicDim();
+ double const dimChar=b.getCaracteristicDim();
b.getBarycenter(xBary,yBary);
applyGlobalSimilarity(xBary,yBary,dimChar);
return dimChar;
b.prepareForAggregation();
fillBounds(b);
other->fillBounds(b);
- double dimChar=b.getCaracteristicDim();
+ double const dimChar=b.getCaracteristicDim();
b.getBarycenter(xBary,yBary);
applyGlobalSimilarity(xBary,yBary,dimChar);
other->applyGlobalSimilarity(xBary,yBary,dimChar);
b.prepareForAggregation();
fillBounds(b);
other->fillBounds(b);
- double dimChar=b.getCaracteristicDim();
+ double const dimChar=b.getCaracteristicDim();
b.getBarycenter(xBary,yBary);
applyGlobalSimilarity2(other,xBary,yBary,dimChar);
return dimChar;
void ComposedEdge::dumpInXfigFile(std::ostream& stream, int resolution, const Bounds& box) const
{
stream.precision(10);
- for(std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();iter!=_sub_edges.end();iter++)
- (*iter)->dumpInXfigFile(stream,resolution,box);
+ for(auto _sub_edge : _sub_edges)
+ _sub_edge->dumpInXfigFile(stream,resolution,box);
}
void ComposedEdge::dumpToCout(const std::map<INTERP_KERNEL::Node *,int>& mapp) const
{
int i=0;
- for(std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();iter!=_sub_edges.end();iter++, i++)
+ for(auto iter=_sub_edges.begin();iter!=_sub_edges.end();iter++, i++)
(*iter)->dumpToCout(mapp, i);
std::cout << std::endl;
}
void ComposedEdge::fillBounds(Bounds& output) const
{
- for(std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();iter!=_sub_edges.end();iter++)
- (*iter)->fillBounds(output);
+ for(auto _sub_edge : _sub_edges)
+ _sub_edge->fillBounds(output);
}
/*!
*/
void ComposedEdge::applySimilarity(double xBary, double yBary, double dimChar)
{
- for(std::list<ElementaryEdge *>::iterator iter=_sub_edges.begin();iter!=_sub_edges.end();iter++)
- (*iter)->applySimilarity(xBary,yBary,dimChar);
+ for(auto & _sub_edge : _sub_edges)
+ _sub_edge->applySimilarity(xBary,yBary,dimChar);
}
/*!
{
std::set<Node *> allNodes;
getAllNodes(allNodes);
- for(std::set<Node *>::iterator iter=allNodes.begin();iter!=allNodes.end();iter++)
- (*iter)->applySimilarity(xBary,yBary,dimChar);
- for(std::list<ElementaryEdge *>::iterator iter=_sub_edges.begin();iter!=_sub_edges.end();iter++)
- (*iter)->applySimilarity(xBary,yBary,dimChar);
+ for(auto allNode : allNodes)
+ allNode->applySimilarity(xBary,yBary,dimChar);
+ for(auto & _sub_edge : _sub_edges)
+ _sub_edge->applySimilarity(xBary,yBary,dimChar);
}
/*!
*/
void ComposedEdge::dispatchPerimeter(double& partConsidered) const
{
- for(std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();iter!=_sub_edges.end();iter++)
+ for(auto _sub_edge : _sub_edges)
{
- TypeOfEdgeLocInPolygon loc=(*iter)->getLoc();
+ TypeOfEdgeLocInPolygon const loc=_sub_edge->getLoc();
if(loc==FULL_IN_1 || loc==FULL_ON_1)
- partConsidered+=(*iter)->getCurveLength();
+ partConsidered+=_sub_edge->getCurveLength();
}
}
*/
void ComposedEdge::dispatchPerimeterExcl(double& partConsidered, double& commonPart) const
{
- for(std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();iter!=_sub_edges.end();iter++)
+ for(auto _sub_edge : _sub_edges)
{
- TypeOfEdgeLocInPolygon loc=(*iter)->getLoc();
+ TypeOfEdgeLocInPolygon const loc=_sub_edge->getLoc();
if(loc==FULL_IN_1)
- partConsidered+=(*iter)->getCurveLength();
+ partConsidered+=_sub_edge->getCurveLength();
if(loc==FULL_ON_1)
- commonPart+=(*iter)->getCurveLength();
+ commonPart+=_sub_edge->getCurveLength();
}
}
void ComposedEdge::getAllNodes(std::set<Node *>& output) const
{
- std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();
+ auto iter=_sub_edges.begin();
for(;iter!=_sub_edges.end();iter++)
(*iter)->getAllNodes(output);
}
void ComposedEdge::initNodeHitStatus() const
{
- for(std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();iter!=_sub_edges.end();iter++)
+ for(auto _sub_edge : _sub_edges)
{
- (*iter)->getStartNode()->initHitStatus();
- (*iter)->getEndNode()->initHitStatus();
+ _sub_edge->getStartNode()->initHitStatus();
+ _sub_edge->getEndNode()->initHitStatus();
}
}
void ComposedEdge::applySimilarityOnMyNodes(double xBary, double yBary, double dimChar) const
{
- for(std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();iter!=_sub_edges.end();iter++)
+ for(auto _sub_edge : _sub_edges)
{
- (*iter)->getStartNode()->hitMeAlone(xBary,yBary,dimChar);
- (*iter)->getEndNode()->hitMeAlone(xBary,yBary,dimChar);
+ _sub_edge->getStartNode()->hitMeAlone(xBary,yBary,dimChar);
+ _sub_edge->getEndNode()->hitMeAlone(xBary,yBary,dimChar);
}
}
void ComposedEdge::unApplySimilarityOnMyNodes(double xBary, double yBary, double dimChar) const
{
- for(std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();iter!=_sub_edges.end();iter++)
+ for(auto _sub_edge : _sub_edges)
{
- (*iter)->getStartNode()->unHitMeAlone(xBary,yBary,dimChar);
- (*iter)->getEndNode()->unHitMeAlone(xBary,yBary,dimChar);
+ _sub_edge->getStartNode()->unHitMeAlone(xBary,yBary,dimChar);
+ _sub_edge->getEndNode()->unHitMeAlone(xBary,yBary,dimChar);
}
}
void ComposedEdge::applySimilarityOnMyNodesIfNotAlreadyHit(double xBary, double yBary, double dimChar) const
{
- for(std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();iter!=_sub_edges.end();iter++)
+ for(auto _sub_edge : _sub_edges)
{
- (*iter)->getStartNode()->hitMeAfter(xBary,yBary,dimChar);
- (*iter)->getEndNode()->hitMeAfter(xBary,yBary,dimChar);
+ _sub_edge->getStartNode()->hitMeAfter(xBary,yBary,dimChar);
+ _sub_edge->getEndNode()->hitMeAfter(xBary,yBary,dimChar);
}
}
void ComposedEdge::unApplySimilarityOnMyNodesIfNotAlreadyHit(double xBary, double yBary, double dimChar) const
{
- for(std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();iter!=_sub_edges.end();iter++)
+ for(auto _sub_edge : _sub_edges)
{
- (*iter)->getStartNode()->unHitMeAfter(xBary,yBary,dimChar);
- (*iter)->getEndNode()->unHitMeAfter(xBary,yBary,dimChar);
+ _sub_edge->getStartNode()->unHitMeAfter(xBary,yBary,dimChar);
+ _sub_edge->getEndNode()->unHitMeAfter(xBary,yBary,dimChar);
}
}
void ComposedEdge::initEdgeHitStatus() const
{
- for(std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();iter!=_sub_edges.end();iter++)
- (*iter)->getPtr()->initHitStatus();
+ for(auto _sub_edge : _sub_edges)
+ _sub_edge->getPtr()->initHitStatus();
}
void ComposedEdge::applySimilarityOnMyEdges(double xBary, double yBary, double dimChar) const
{
- for(std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();iter!=_sub_edges.end();iter++)
- (*iter)->getPtr()->hitMeAlone(xBary,yBary,dimChar);
+ for(auto _sub_edge : _sub_edges)
+ _sub_edge->getPtr()->hitMeAlone(xBary,yBary,dimChar);
}
void ComposedEdge::unApplySimilarityOnMyEdges(double xBary, double yBary, double dimChar) const
{
- for(std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();iter!=_sub_edges.end();iter++)
- (*iter)->getPtr()->unHitMeAlone(xBary,yBary,dimChar);
+ for(auto _sub_edge : _sub_edges)
+ _sub_edge->getPtr()->unHitMeAlone(xBary,yBary,dimChar);
}
void ComposedEdge::applySimilarityOnMyEdgesIfNotAlreadyHit(double xBary, double yBary, double dimChar) const
{
- for(std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();iter!=_sub_edges.end();iter++)
- (*iter)->getPtr()->hitMeAfter(xBary,yBary,dimChar);
+ for(auto _sub_edge : _sub_edges)
+ _sub_edge->getPtr()->hitMeAfter(xBary,yBary,dimChar);
}
void ComposedEdge::unApplySimilarityOnMyEdgesIfNotAlreadyHit(double xBary, double yBary, double dimChar) const
{
- for(std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();iter!=_sub_edges.end();iter++)
- (*iter)->getPtr()->unHitMeAfter(xBary,yBary,dimChar);
+ for(auto _sub_edge : _sub_edges)
+ _sub_edge->getPtr()->unHitMeAfter(xBary,yBary,dimChar);
}
void ComposedEdge::getBarycenter(double *bary, double& weigh) const
{
weigh=0.; bary[0]=0.; bary[1]=0.;
double tmp1,tmp2[2];
- for(std::list<ElementaryEdge *>::const_iterator iter=_sub_edges.begin();iter!=_sub_edges.end();iter++)
+ for(auto _sub_edge : _sub_edges)
{
- (*iter)->getBarycenter(tmp2,tmp1);
+ _sub_edge->getBarycenter(tmp2,tmp1);
weigh+=tmp1;
bary[0]+=tmp1*tmp2[0];
bary[1]+=tmp1*tmp2[1];
std::set< IntersectElement > inOutSwitch;
std::set<Node *> nodes;
getAllNodes(nodes);
- double ref(isInOrOutAlg(nodeToTest,nodes,inOutSwitch));
+ double const ref(isInOrOutAlg(nodeToTest,nodes,inOutSwitch));
bool ret(false);
- for(std::set< IntersectElement >::iterator iter4=inOutSwitch.begin();iter4!=inOutSwitch.end();iter4++)
+ for(const auto & iter4 : inOutSwitch)
{
- if((*iter4).getVal1()<ref)
+ if(iter4.getVal1()<ref)
{
- if((*iter4).getNodeOnly()->getLoc()==ON_1)
+ if(iter4.getNodeOnly()->getLoc()==ON_1)
ret=!ret;
}
else
std::set< IntersectElement > inOutSwitch;
std::set<Node *> nodes;
getAllNodes(nodes);
- for(std::set<Node *>::const_iterator iter=nodes.begin();iter!=nodes.end();iter++)
- if(sqrt((*iter)->distanceWithSq(*nodeToTest))<QuadraticPlanarPrecision::getPrecision())
+ for(auto node : nodes)
+ if(sqrt(node->distanceWithSq(*nodeToTest))<QuadraticPlanarPrecision::getPrecision())
return true;
- double ref(isInOrOutAlg(nodeToTest,nodes,inOutSwitch));
+ double const ref(isInOrOutAlg(nodeToTest,nodes,inOutSwitch));
bool ret(false);
- for(std::set< IntersectElement >::iterator iter4=inOutSwitch.begin();iter4!=inOutSwitch.end();iter4++)
+ for(const auto & iter4 : inOutSwitch)
{
- double val((*iter4).getVal1());
+ double const val(iter4.getVal1());
if(fabs(val-ref)>=QuadraticPlanarPrecision::getPrecision())
{
if(val<ref)
{
- if((*iter4).getNodeOnly()->getLoc()==ON_1)
+ if(iter4.getNodeOnly()->getLoc()==ON_1)
ret=!ret;
}
else
radialDistrib2.back()=M_PI+radialDistrib.front();
std::vector<double> radialDistrib3(radialDistrib.size());
std::transform(radialDistrib2.begin(),radialDistrib2.end(),radialDistrib.begin(),radialDistrib3.begin(),std::minus<double>());
- std::vector<double>::iterator iter3=max_element(radialDistrib3.begin(),radialDistrib3.end());
- std::size_t i=iter3-radialDistrib3.begin();
+ auto const iter3=max_element(radialDistrib3.begin(),radialDistrib3.end());
+ std::size_t const i=iter3-radialDistrib3.begin();
// ok for e1 - Let's go.
- EdgeInfLin *e1=new EdgeInfLin(nodeToTest,radialDistrib[i]+radialDistrib3[i]/2.);
- double ref=e1->getCharactValue(*nodeToTest);
- for(std::list<ElementaryEdge *>::const_iterator iter4=_sub_edges.begin();iter4!=_sub_edges.end();iter4++)
+ auto *e1=new EdgeInfLin(nodeToTest,radialDistrib[i]+radialDistrib3[i]/2.);
+ double const ref=e1->getCharactValue(*nodeToTest);
+ for(auto val : _sub_edges)
{
- ElementaryEdge *val=(*iter4);
if(val)
{
Edge *e=val->getPtr();
}
if(!areOverlapped)
{
- std::list< IntersectElement > listOfIntesc=intersc->getIntersectionsCharacteristicVal();
- for(std::list< IntersectElement >::iterator iter2=listOfIntesc.begin();iter2!=listOfIntesc.end();iter2++)
- if((*iter2).isIncludedByBoth())
- inOutSwitch.insert(*iter2);
+ std::list< IntersectElement > const listOfIntesc=intersc->getIntersectionsCharacteristicVal();
+ for(auto & iter2 : listOfIntesc)
+ if(iter2.isIncludedByBoth())
+ inOutSwitch.insert(iter2);
}
//if overlapped we can forget
}
void ComposedEdge::clearAll(std::list<ElementaryEdge *>::iterator startToDel)
{
- for(std::list<ElementaryEdge *>::iterator iter=startToDel;iter!=_sub_edges.end();iter++)
+ for(auto iter=startToDel;iter!=_sub_edges.end();iter++)
delete (*iter);
}
#include "INTERPKERNELDefines.hxx"
#include "InterpKernelGeo2DEdge.hxx"
+#include <map>
#include <set>
#include <list>
#include <vector>
{
friend class IteratorOnComposedEdge;
public:
- INTERPKERNEL_EXPORT ComposedEdge() { }
+ INTERPKERNEL_EXPORT ComposedEdge() = default;
INTERPKERNEL_EXPORT ComposedEdge(const ComposedEdge& other);
INTERPKERNEL_EXPORT ComposedEdge(int sz):_sub_edges(sz) { }
INTERPKERNEL_EXPORT static void Delete(ComposedEdge *pt) { delete pt; }
#include "InterpKernelGeo2DEdge.hxx"
#include "InterpKernelGeo2DEdgeLin.hxx"
-#include "InterpKernelGeo2DEdgeInfLin.hxx"
//#include "EdgeParabol.hxx"
#include "InterpKernelGeo2DEdgeArcCircle.hxx"
#include "InterpKernelGeo2DComposedEdge.hxx"
#include "InterpKernelException.hxx"
+#include "MCIdType.hxx"
#include <algorithm>
+#include <cstddef>
#include <functional>
+#include <map>
+#include <vector>
+#include <list>
+#include <ostream>
+#include <istream>
+#include <iostream>
+#include <string>
+#include <ios>
+#include <utility>
+#include <iterator>
using namespace INTERP_KERNEL;
void MergePoints::start1Replaced()
{
- unsigned nbOfAsso=getNumberOfAssociations();
+ unsigned const nbOfAsso=getNumberOfAssociations();
if(nbOfAsso==0)
_ass1Start1=1;
else
void MergePoints::end1Replaced()
{
- unsigned nbOfAsso=getNumberOfAssociations();
+ unsigned const nbOfAsso=getNumberOfAssociations();
if(nbOfAsso==0)
_ass1End1=1;
else
void MergePoints::start1OnStart2()
{
- unsigned nbOfAsso=getNumberOfAssociations();
+ unsigned const nbOfAsso=getNumberOfAssociations();
if(nbOfAsso==0)
{
_ass1Start1=1;
void MergePoints::start1OnEnd2()
{
- unsigned nbOfAsso=getNumberOfAssociations();
+ unsigned const nbOfAsso=getNumberOfAssociations();
if(nbOfAsso==0)
{
_ass1Start1=1;
void MergePoints::end1OnStart2()
{
- unsigned nbOfAsso=getNumberOfAssociations();
+ unsigned const nbOfAsso=getNumberOfAssociations();
if(nbOfAsso==0)
{
_ass1End1=1;
void MergePoints::end1OnEnd2()
{
- unsigned nbOfAsso=getNumberOfAssociations();
+ unsigned const nbOfAsso=getNumberOfAssociations();
if(nbOfAsso==0)
{
_ass1End1=1;
iter=listOfIntesc.erase(iter);
continue;
}
- unsigned tmp=(*iter).isOnExtrForAnEdgeAndInForOtherEdge();
+ unsigned const tmp=(*iter).isOnExtrForAnEdgeAndInForOtherEdge();
if(tmp==IntersectElement::LIMIT_ALONE)
{
iter=listOfIntesc.erase(iter);
std::vector<IntersectElement> vecOfIntesc(listOfIntesc.begin(),listOfIntesc.end());
listOfIntesc.clear();
sort(vecOfIntesc.begin(),vecOfIntesc.end());
- for(std::vector<IntersectElement>::iterator iterV=vecOfIntesc.begin();iterV!=vecOfIntesc.end();iterV++)
- newNodes.push_back((*iterV).getNodeAndReleaseIt());
+ for(auto & iterV : vecOfIntesc)
+ newNodes.push_back(iterV.getNodeAndReleaseIt());
order=vecOfIntesc.front().isLowerOnOther(vecOfIntesc.back());
}
return true;
bool Edge::decrRef()
{
- bool ret=(--_cnt==0);
+ bool const ret=(--_cnt==0);
if(ret)
delete this;
return ret;
{
std::copy((const double *)(*_end),(const double *)(*_end)+2,vectOutput);
std::transform(vectOutput,vectOutput+2,(const double *)(*_start),vectOutput,std::minus<double>());
- double norm=1./Node::norm(vectOutput);
+ double const norm=1./Node::norm(vectOutput);
std::transform(vectOutput,vectOutput+2,vectOutput,bind(std::multiplies<double>(),std::placeholders::_1,norm));
- double tmp=vectOutput[0];
+ double const tmp=vectOutput[0];
vectOutput[0]=vectOutput[1];
vectOutput[1]=-tmp;
}
Edge *Edge::BuildEdgeFrom3Points(const double *start, const double *middle, const double *end)
{
Node *b(new Node(start[0],start[1])),*m(new Node(middle[0],middle[1])),*e(new Node(end[0],end[1]));
- EdgeLin *e1(new EdgeLin(b,m)),*e2(new EdgeLin(m,e));
- SegSegIntersector inters(*e1,*e2); bool colinearity=inters.areColinears(); delete e1; delete e2;
- Edge *ret=0;
+ auto *e1(new EdgeLin(b,m)),*e2(new EdgeLin(m,e));
+ SegSegIntersector const inters(*e1,*e2); bool const colinearity=inters.areColinears(); delete e1; delete e2;
+ Edge *ret=nullptr;
if(colinearity)
ret=new EdgeLin(b,e);
else
else
{
std::cerr << "Unknown line found...";
- return 0;
+ return nullptr;
}
}
if(!merge)
return false;
delete merge;
- merge=0;
+ merge=nullptr;
EdgeIntersector *intersector=BuildIntersectorWith(this,other);
ret=Intersect(this,other,intersector,commonNode,outVal1,outVal2);
delete intersector;
bool Edge::IntersectOverlapped(const Edge *f1, const Edge *f2, EdgeIntersector *intersector, MergePoints& commonNode,
ComposedEdge& outValForF1, ComposedEdge& outValForF2)
{
- bool rev=intersector->haveTheySameDirection();
+ bool const rev=intersector->haveTheySameDirection();
Node *f2Start=f2->getNode(rev?START:END);
Node *f2End=f2->getNode(rev?END:START);
TypeOfLocInEdge place1, place2;
intersector->getPlacements(f2Start,f2End,place1,place2,commonNode);
- int codeForIntersectionCase=CombineCodes(place1,place2);
+ int const codeForIntersectionCase=CombineCodes(place1,place2);
return SplitOverlappedEdges(f1,f2,f2Start,f2End,rev,codeForIntersectionCase,outValForF1,outValForF2);
}
*/
void Edge::Interpolate1DLin(const std::vector<double>& distrib1, const std::vector<double>& distrib2, std::map<int, std::map<int,double> >& result)
{
- std::size_t nbOfV1=distrib1.size()-1;
- std::size_t nbOfV2=distrib2.size()-1;
+ std::size_t const nbOfV1=distrib1.size()-1;
+ std::size_t const nbOfV2=distrib2.size()-1;
Node *n1=new Node(0.,0.); Node *n3=new Node(0.,0.);
Node *n2=new Node(0.,0.); Node *n4=new Node(0.,0.);
MergePoints commonNode;
for(unsigned int i=0;i<nbOfV1;i++)
{
- std::vector<double>::const_iterator iter=find_if(distrib2.begin()+1,distrib2.end(),bind(std::greater_equal<double>(),std::placeholders::_1,distrib1[i]));
+ auto const iter=find_if(distrib2.begin()+1,distrib2.end(),bind(std::greater_equal<double>(),std::placeholders::_1,distrib1[i]));
if(iter!=distrib2.end())
{
for(unsigned int j=(unsigned)((iter-1)-distrib2.begin());j<nbOfV2;j++)
{
if(distrib2[j]<=distrib1[i+1])
{
- EdgeLin *e1=new EdgeLin(n1,n2); EdgeLin *e2=new EdgeLin(n3,n4);
+ auto *e1=new EdgeLin(n1,n2); auto *e2=new EdgeLin(n3,n4);
n1->setNewCoords(distrib1[i],0.); n2->setNewCoords(distrib1[i+1],0.);
n3->setNewCoords(distrib2[j],0.); n4->setNewCoords(distrib2[j+1],0.);
- ComposedEdge *f1=new ComposedEdge;
- ComposedEdge *f2=new ComposedEdge;
+ auto *f1=new ComposedEdge;
+ auto *f2=new ComposedEdge;
SegSegIntersector inters(*e1,*e2);
bool b1,b2;
inters.areOverlappedOrOnlyColinears(b1,b2);
EdgeIntersector *Edge::BuildIntersectorWith(const Edge *e1, const Edge *e2)
{
- EdgeIntersector *ret=0;
- const EdgeLin *tmp1=0;
- const EdgeArcCircle *tmp2=0;
+ EdgeIntersector *ret=nullptr;
+ const EdgeLin *tmp1=nullptr;
+ const EdgeArcCircle *tmp2=nullptr;
unsigned char type1=e1->getTypeOfFunc();
e1->dynCastFunction(tmp1,tmp2);
- unsigned char type2=e2->getTypeOfFunc();
+ unsigned char const type2=e2->getTypeOfFunc();
e2->dynCastFunction(tmp1,tmp2);
type1|=type2;
switch(type1)
{
if(newNodes.empty())
throw Exception("Internal error occurred - error in intersector implementation!");// This case should never happen
- std::vector<Node *>::iterator iter=newNodes.begin();
- std::vector<Node *>::reverse_iterator iterR=newNodes.rbegin();
+ auto const iter=newNodes.begin();
+ auto iterR=newNodes.rbegin();
f1->addSubEdgeInVector(f1->getStartNode(),*iter,outValForF1);
f2->addSubEdgeInVector(f2->getStartNode(),order?*iter:*iterR,outValForF2);
- for(std::vector<Node *>::iterator iter2=newNodes.begin();iter2!=newNodes.end();iter2++,iterR++)
+ for(auto iter2=newNodes.begin();iter2!=newNodes.end();iter2++,iterR++)
{
if((iter2+1)==newNodes.end())
{
b.prepareForAggregation();
b.aggregate(getBounds());
double xBary,yBary;
- double dimChar(b.getCaracteristicDim());
+ double const dimChar(b.getCaracteristicDim());
b.getBarycenter(xBary,yBary);
applySimilarity(xBary,yBary,dimChar);
_start->applySimilarity(xBary,yBary,dimChar);
bool ret(false);
for(i=0;i<sz;i++)
{
- mcIdType id(m[an2[i].second]);
+ mcIdType const id(m[an2[i].second]);
if(id!=subNodes[i])
{ subNodes[i]=id; ret=true; }
}
void Edge::sortIdsAbs(const std::vector<INTERP_KERNEL::Node *>& addNodes, const std::map<INTERP_KERNEL::Node *, mcIdType>& mapp1,
const std::map<INTERP_KERNEL::Node *, mcIdType>& mapp2, std::vector<mcIdType>& edgesThis)
{
- mcIdType startId=(*mapp1.find(_start)).second;
- mcIdType endId=(*mapp1.find(_end)).second;
+ mcIdType const startId=(*mapp1.find(_start)).second;
+ mcIdType const endId=(*mapp1.find(_end)).second;
if (! addNodes.size()) // quick way out, no new node to add.
{
edgesThis.push_back(startId);
b.prepareForAggregation();
b.aggregate(getBounds());
double xBary,yBary;
- double dimChar=b.getCaracteristicDim();
+ double const dimChar=b.getCaracteristicDim();
b.getBarycenter(xBary,yBary);
- for(std::vector<Node *>::const_iterator iter=addNodes.begin();iter!=addNodes.end();iter++)
- (*iter)->applySimilarity(xBary,yBary,dimChar);
+ for(auto addNode : addNodes)
+ addNode->applySimilarity(xBary,yBary,dimChar);
applySimilarity(xBary,yBary,dimChar);
_start->applySimilarity(xBary,yBary,dimChar);
_end->applySimilarity(xBary,yBary,dimChar);
- std::size_t sz=addNodes.size();
+ std::size_t const sz=addNodes.size();
std::vector< std::pair<double,Node *> > an2(sz);
for(std::size_t i=0;i<sz;i++)
an2[i]=std::pair<double,Node *>(getCharactValueBtw0And1(*addNodes[i]),addNodes[i]);
std::sort(an2.begin(),an2.end());
std::vector<mcIdType> tmpp;
- for(std::vector< std::pair<double,Node *> >::const_iterator it=an2.begin();it!=an2.end();it++)
+ for(const auto & it : an2)
{
- mcIdType idd=(*mapp2.find((*it).second)).second;
+ mcIdType const idd=(*mapp2.find(it.second)).second;
tmpp.push_back(idd);
}
std::vector<mcIdType> tmpp2(tmpp.size()+2);
tmpp2[0]=startId;
std::copy(tmpp.begin(),tmpp.end(),tmpp2.begin()+1);
tmpp2[tmpp.size()+1]=endId;
- std::vector<mcIdType>::iterator itt=std::unique(tmpp2.begin(),tmpp2.end());
+ auto const itt=std::unique(tmpp2.begin(),tmpp2.end());
tmpp2.resize(std::distance(tmpp2.begin(),itt));
- std::size_t nbOfEdges=tmpp2.size()-1;
+ std::size_t const nbOfEdges=tmpp2.size()-1;
for(std::size_t i=0;i<nbOfEdges;i++)
{
edgesThis.push_back(tmpp2[i]);
void setNode(Node *node) const;
void performMerging(MergePoints& commonNode) const;
Node *getNodeOnly() const { return _node; }
- Node *getNodeAndReleaseIt() { Node *tmp=_node; _node=0; return tmp; }
+ Node *getNodeAndReleaseIt() { Node *tmp=_node; _node=nullptr; return tmp; }
~IntersectElement();
private:
bool _1S; // true if starting point of edge 1 is located exactly on edge 2 (not nearby)
{
protected:
//! All non symmetric methods are relative to 'e1'.
- EdgeIntersector(const Edge& e1, const Edge& e2):_e1(e1),_e2(e2), _earlyInter(0) { }
+ EdgeIntersector(const Edge& e1, const Edge& e2):_e1(e1),_e2(e2) { }
public:
virtual ~EdgeIntersector() { if(_earlyInter) delete(_earlyInter); }
virtual bool keepOrder() const = 0;
protected:
const Edge& _e1;
const Edge& _e2;
- IntersectElement *_earlyInter; // Non null if the intersection can be determined early -> see areOverlappedOrOnlyColinears()
+ IntersectElement *_earlyInter{nullptr}; // Non null if the intersection can be determined early -> see areOverlappedOrOnlyColinears()
};
class INTERPKERNEL_EXPORT SameTypeEdgeIntersector : public EdgeIntersector
{
protected:
SameTypeEdgeIntersector(const Edge& e1, const Edge& e2):EdgeIntersector(e1,e2) { }
- bool keepOrder() const { return true; }
+ bool keepOrder() const override { return true; }
};
class INTERPKERNEL_EXPORT CrossTypeEdgeIntersector : public EdgeIntersector
{
protected:
CrossTypeEdgeIntersector(const Edge& e1, const Edge& e2, bool reverse):EdgeIntersector(e1,e2),_reverse(reverse) { }
- bool keepOrder() const { return _reverse; }
- bool haveTheySameDirection() const { throw Exception("Cross type intersector is not supposed to deal with overlapped in cross type."); }
+ bool keepOrder() const override { return _reverse; }
+ bool haveTheySameDirection() const override { throw Exception("Cross type intersector is not supposed to deal with overlapped in cross type."); }
const Edge *myE1() { if(_reverse) return &_e1; else return &_e2; }
const Edge *myE2() { if(_reverse) return &_e2; else return &_e1; }
protected:
void unHitMeAfter(double xBary, double yBary, double dimChar) { if(!_hit) unHitMeAlone(xBary,yBary,dimChar); }
const Bounds& getBounds() const { return _bounds; }
void fillXfigStreamForLoc(std::ostream& stream) const;
- Node *getNode(TypeOfLocInEdge where) const { if(where==START) return _start; else if(where==END) return _end; else return 0; }
+ Node *getNode(TypeOfLocInEdge where) const { if(where==START) return _start; else if(where==END) return _end; else return nullptr; }
Node *getStartNode() const { return _start; }
Node *getEndNode() const { return _end; }
void setEndNodeWithoutChange(Node *newEnd);
std::vector<mcIdType>& edgesOther, std::vector<double>& addCoo, std::map<INTERP_KERNEL::Node *,mcIdType>& mapAddCoo) const;
protected:
- Edge():_cnt(1),_loc(FULL_UNKNOWN),_start(0),_end(0) { }
+ Edge():_cnt(1),_loc(FULL_UNKNOWN),_start(nullptr),_end(nullptr) { }
virtual ~Edge();
static int CombineCodes(TypeOfLocInEdge code1, TypeOfLocInEdge code2);
static bool Intersect(const Edge *f1, const Edge *f2, EdgeIntersector *intersector, MergePoints& commonNode,
#ifndef __INTERPKERNELGEO2DEDGE_TXX__
#define __INTERPKERNELGEO2DEDGE_TXX__
+#include "InterpKernelGeo2DEdge.hxx"
#include "InterpKernelGeo2DEdgeArcCircle.hxx"
+#include "InterpKernelGeo2DNode.hxx"
template<INTERP_KERNEL::TypeOfMod4QuadEdge type>
INTERP_KERNEL::Edge *INTERP_KERNEL::Edge::BuildEdgeFrom(Node *start, Node *middle, Node *end)
// Author : Anthony Geay (CEA/DEN)
#include "InterpKernelGeo2DEdgeArcCircle.hxx"
+#include "InterpKernelGeo2DEdge.hxx"
#include "InterpKernelGeo2DEdgeLin.hxx"
#include "InterpKernelException.hxx"
#include "InterpKernelGeo2DNode.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
-
-#include <sstream>
+#include "InterpKernelGeo2DPrecision.hxx"
+#include "MCIdType.hxx"
+#include "NormalizedGeometricTypes"
+
+#include <cmath>
+#include <math.h>
+#include <list>
+#include <istream>
+#include <ostream>
#include <algorithm>
#include <limits>
+#include <string>
+#include <vector>
using namespace INTERP_KERNEL;
obviousCaseForCurvAbscisse(end,whereEnd,commonNode,obvious2);
if(obvious1 && obvious2)
return ;
- double angleInRadStart=getAngle(start);
- double angleInRadEnd=getAngle(end);
+ double const angleInRadStart=getAngle(start);
+ double const angleInRadEnd=getAngle(end);
if(obvious1 || obvious2)
{
if(obvious1)
bool ArcCArcCIntersector::internalAreColinears(const EdgeArcCircle& a1, const EdgeArcCircle& a2, double& distBetweenCenters, double& cst,
double& radiusL, double centerL[2], double& radiusB, double centerB[2])
{
- double lgth1=fabs(a1.getAngle()*a1.getRadius());
- double lgth2=fabs(a2.getAngle()*a2.getRadius());
+ double const lgth1=fabs(a1.getAngle()*a1.getRadius());
+ double const lgth2=fabs(a2.getAngle()*a2.getRadius());
if(lgth1<lgth2)
{//a1 is the little one ('L') and a2 the big one ('B')
a1.getCenter(centerL); radiusL=a1.getRadius();
tmp=sqrt(tmp);
if(Node::areDoubleEqualsWPLeft(tmp,0.,10*std::max(radiusL,radiusB)))
return Node::areDoubleEquals(radiusL,radiusB);
- double phi=EdgeArcCircle::GetAbsoluteAngleOfNormalizedVect((centerL[0]-centerB[0])/tmp,(centerL[1]-centerB[1])/tmp);
- double cst2=2*radiusL*tmp/(radiusB*radiusB);
+ double const phi=EdgeArcCircle::GetAbsoluteAngleOfNormalizedVect((centerL[0]-centerB[0])/tmp,(centerL[1]-centerB[1])/tmp);
+ double const cst2=2*radiusL*tmp/(radiusB*radiusB);
double cmpContainer[4];
int sizeOfCmpContainer=2;
cmpContainer[0]=cst+cst2*cos(phi-angle0L);
void ArcCArcCIntersector::areOverlappedOrOnlyColinears(bool& obviousNoIntersection, bool& areOverlapped)
{
_dist=Node::distanceBtw2Pt(getE1().getCenter(),getE2().getCenter());
- double radius1=getE1().getRadius(); double radius2=getE2().getRadius();
+ double const radius1=getE1().getRadius(); double const radius2=getE2().getRadius();
if(_dist>radius1+radius2+QuadraticPlanarPrecision::getPrecision() || _dist+std::min(radius1,radius2)+QuadraticPlanarPrecision::getPrecision()<std::max(radius1,radius2))
{
obviousNoIntersection=true;
std::list< IntersectElement > ret;
const double *center1=getE1().getCenter();
const double *center2=getE2().getCenter();
- double radius1=getE1().getRadius(); double radius2=getE2().getRadius();
- double d1_1=(_dist*_dist-radius2*radius2+radius1*radius1)/(2.*_dist); // computation of 'x' on wolfram
+ double const radius1=getE1().getRadius(); double const radius2=getE2().getRadius();
+ double const d1_1=(_dist*_dist-radius2*radius2+radius1*radius1)/(2.*_dist); // computation of 'x' on wolfram
double u[2];//u is normalized vector from center1 to center2.
u[0]=(center2[0]-center1[0])/_dist; u[1]=(center2[1]-center1[1])/_dist;
- double d1_1y=EdgeArcCircle::SafeSqrt(radius1*radius1-d1_1*d1_1); // computation of 'y' on wolfram
- double angleE1=EdgeArcCircle::NormalizeAngle(getE1().getAngle0()+getE1().getAngle());
- double angleE2=EdgeArcCircle::NormalizeAngle(getE2().getAngle0()+getE2().getAngle());
+ double const d1_1y=EdgeArcCircle::SafeSqrt(radius1*radius1-d1_1*d1_1); // computation of 'y' on wolfram
+ double const angleE1=EdgeArcCircle::NormalizeAngle(getE1().getAngle0()+getE1().getAngle());
+ double const angleE2=EdgeArcCircle::NormalizeAngle(getE2().getAngle0()+getE2().getAngle());
if(!Node::areDoubleEquals(d1_1y,0))
{
//2 intersections
v2[0]=u[0]*d1_1+u[1]*d1_1y; v2[1]=u[1]*d1_1-u[0]*d1_1y;
Node *node1=new Node(center1[0]+v1[0],center1[1]+v1[1]); node1->declareOn();
Node *node2=new Node(center1[0]+v2[0],center1[1]+v2[1]); node2->declareOn();
- double angle1_1=EdgeArcCircle::GetAbsoluteAngleOfNormalizedVect(v1[0]/radius1,v1[1]/radius1);
- double angle2_1=EdgeArcCircle::GetAbsoluteAngleOfNormalizedVect(v2[0]/radius1,v2[1]/radius1);
+ double const angle1_1=EdgeArcCircle::GetAbsoluteAngleOfNormalizedVect(v1[0]/radius1,v1[1]/radius1);
+ double const angle2_1=EdgeArcCircle::GetAbsoluteAngleOfNormalizedVect(v2[0]/radius1,v2[1]/radius1);
double v3[2],v4[2];
v3[0]=center1[0]-center2[0]+v1[0]; v3[1]=center1[1]-center2[1]+v1[1];
v4[0]=center1[0]-center2[0]+v2[0]; v4[1]=center1[1]-center2[1]+v2[1];
- double angle1_2=EdgeArcCircle::GetAbsoluteAngleOfNormalizedVect(v3[0]/radius2,v3[1]/radius2);
- double angle2_2=EdgeArcCircle::GetAbsoluteAngleOfNormalizedVect(v4[0]/radius2,v4[1]/radius2);
+ double const angle1_2=EdgeArcCircle::GetAbsoluteAngleOfNormalizedVect(v3[0]/radius2,v3[1]/radius2);
+ double const angle2_2=EdgeArcCircle::GetAbsoluteAngleOfNormalizedVect(v4[0]/radius2,v4[1]/radius2);
// Check whether intersection points are exactly ON the other arc or not
// -> the curvilinear distance (=radius*angle) must below eps
- bool e1_1S=Node::areDoubleEqualsWPLeft(angle1_1,getE1().getAngle0(),radius1);
- bool e1_1E=Node::areDoubleEqualsWPLeft(angle1_1,angleE1,radius1);
- bool e1_2S=Node::areDoubleEqualsWPLeft(angle1_2,getE2().getAngle0(),radius1);
- bool e1_2E=Node::areDoubleEqualsWPLeft(angle1_2,angleE2,radius1);
+ bool const e1_1S=Node::areDoubleEqualsWPLeft(angle1_1,getE1().getAngle0(),radius1);
+ bool const e1_1E=Node::areDoubleEqualsWPLeft(angle1_1,angleE1,radius1);
+ bool const e1_2S=Node::areDoubleEqualsWPLeft(angle1_2,getE2().getAngle0(),radius1);
+ bool const e1_2E=Node::areDoubleEqualsWPLeft(angle1_2,angleE2,radius1);
//
- bool e2_1S=Node::areDoubleEqualsWPLeft(angle2_1,getE1().getAngle0(),radius2);
- bool e2_1E=Node::areDoubleEqualsWPLeft(angle2_1,angleE1,radius2);
- bool e2_2S=Node::areDoubleEqualsWPLeft(angle2_2,getE2().getAngle0(),radius2);
- bool e2_2E=Node::areDoubleEqualsWPLeft(angle2_2,angleE2,radius2);
+ bool const e2_1S=Node::areDoubleEqualsWPLeft(angle2_1,getE1().getAngle0(),radius2);
+ bool const e2_1E=Node::areDoubleEqualsWPLeft(angle2_1,angleE1,radius2);
+ bool const e2_2S=Node::areDoubleEqualsWPLeft(angle2_2,getE2().getAngle0(),radius2);
+ bool const e2_2E=Node::areDoubleEqualsWPLeft(angle2_2,angleE2,radius2);
ret.push_back(IntersectElement(angle1_1,angle1_2,e1_1S,e1_1E,e1_2S,e1_2E,node1,_e1,_e2,keepOrder()));
ret.push_back(IntersectElement(angle2_1,angle2_2,e2_1S,e2_1E,e2_2S,e2_2E,node2,_e1,_e2,keepOrder()));
}
double v1[2],v2[2];
v1[0]=d1_1*u[0]; v1[1]=d1_1*u[1];
v2[0]=center1[0]-center2[0]+v1[0]; v2[1]=center1[1]-center2[1]+v1[1];
- double angle0_1=EdgeArcCircle::GetAbsoluteAngleOfNormalizedVect(v1[0]/radius1,v1[1]/radius1);
- double angle0_2=EdgeArcCircle::GetAbsoluteAngleOfNormalizedVect(v2[0]/radius2,v2[1]/radius2);
- bool e0_1S=Node::areDoubleEqualsWPLeft(angle0_1,getE1().getAngle0(),radius1);
- bool e0_1E=Node::areDoubleEqualsWPLeft(angle0_1,angleE1,radius1);
- bool e0_2S=Node::areDoubleEqualsWPLeft(angle0_2,getE2().getAngle0(),radius2);
- bool e0_2E=Node::areDoubleEqualsWPLeft(angle0_2,angleE2,radius2);
+ double const angle0_1=EdgeArcCircle::GetAbsoluteAngleOfNormalizedVect(v1[0]/radius1,v1[1]/radius1);
+ double const angle0_2=EdgeArcCircle::GetAbsoluteAngleOfNormalizedVect(v2[0]/radius2,v2[1]/radius2);
+ bool const e0_1S=Node::areDoubleEqualsWPLeft(angle0_1,getE1().getAngle0(),radius1);
+ bool const e0_1E=Node::areDoubleEqualsWPLeft(angle0_1,angleE1,radius1);
+ bool const e0_2S=Node::areDoubleEqualsWPLeft(angle0_2,getE2().getAngle0(),radius2);
+ bool const e0_2E=Node::areDoubleEqualsWPLeft(angle0_2,angleE2,radius2);
Node *node=new Node(center1[0]+d1_1*u[0],center1[1]+d1_1*u[1]); node->declareOnTangent();
ret.push_back(IntersectElement(angle0_1,angle0_2,e0_1S,e0_1E,e0_2S,e0_2E,node,_e1,_e2,keepOrder()));
}
// We need to compute d = R*R-_cross*_cross/_drSq
// In terms of numerical precision, this can trigger 'catastrophic cancellation' and is hence better expressed as:
- double _dr = sqrt(_drSq);
+ double const _dr = sqrt(_drSq);
double diff = (R-_cross/_dr), add=(R+_cross/_dr);
// Ah ah: we will be taking a square root later. If we want the user to be able to use an epsilon finer than 1.0e-8, then we need
// to prevent ourselves going below machine precision (typ. 1.0e-16 for double).
const double eps_machine = std::numeric_limits<double>::epsilon();
diff = fabs(diff/R) < eps_machine ? 0.0 : diff;
add = fabs(add/R) < eps_machine ? 0.0 : add;
- double d = add*diff;
+ double const d = add*diff;
// Compute deltaRoot_div_dr := sqrt(delta)/dr, where delta has the meaning of Wolfram.
// Then 2*deltaRoot_div_dr is the distance between the two intersection points of the line with the circle. This is what we compare to eps.
// We compute it in such a way that it can be used in boolean tests too (a very negative value means we're far apart from intersection)
return false;
}
-void ArcCSegIntersector::getPlacements(Node *start, Node *end, TypeOfLocInEdge& whereStart, TypeOfLocInEdge& whereEnd, MergePoints& commonNode) const
+void ArcCSegIntersector::getPlacements(Node * /*start*/, Node * /*end*/, TypeOfLocInEdge& /*whereStart*/, TypeOfLocInEdge& /*whereEnd*/, MergePoints& /*commonNode*/) const
{
throw Exception("Internal error. Should never been called : no overlapping possible between arc of circle and a segment.");
}
// There we can tell if the arc of circle is 'moving away' from the seg, or if it might intersect it twice
const Node &n(*_earlyInter->getNodeOnly());
- double tang[2] = {-(n[1]-center[1]), n[0]-center[0]}; // (-y, x) is the tangent vector in the trigo direction with (x,y) = (center->node)
- bool invSeg = _i1S2E || _i1E2E;
- double linEdge[2] = {invSeg ? (-_dx) : _dx, invSeg ? (-_dy) : _dy};
+ double const tang[2] = {-(n[1]-center[1]), n[0]-center[0]}; // (-y, x) is the tangent vector in the trigo direction with (x,y) = (center->node)
+ bool const invSeg = _i1S2E || _i1E2E;
+ double const linEdge[2] = {invSeg ? (-_dx) : _dx, invSeg ? (-_dy) : _dy};
if(tang[1]*linEdge[0]-tang[0]*linEdge[1] < 0)
{
ret.push_back(*_earlyInter);
}
}
- double determinant=fabs(_deltaRoot_div_dr)/sqrt(_drSq);
- double x1=(_cross*_dy/_drSq+Node::sign(_dy)*_dx*determinant)+center[0];
- double y1=(-_cross*_dx/_drSq+fabs(_dy)*determinant)+center[1];
+ double const determinant=fabs(_deltaRoot_div_dr)/sqrt(_drSq);
+ double const x1=(_cross*_dy/_drSq+Node::sign(_dy)*_dx*determinant)+center[0];
+ double const y1=(-_cross*_dx/_drSq+fabs(_dy)*determinant)+center[1];
Node *intersect1=new Node(x1,y1); intersect1->declareOn();
- double x2=(_cross*_dy/_drSq-Node::sign(_dy)*_dx*determinant)+center[0];
- double y2=(-_cross*_dx/_drSq-fabs(_dy)*determinant)+center[1];
+ double const x2=(_cross*_dy/_drSq-Node::sign(_dy)*_dx*determinant)+center[0];
+ double const y2=(-_cross*_dx/_drSq-fabs(_dy)*determinant)+center[1];
Node *intersect2=new Node(x2,y2); intersect2->declareOn();
bool isN1(false), isN2(false);
// Which node do we actually already found? Assume this is the closest ...
const Node &iN = *(_earlyInter->getNodeOnly());
const Node &n1(*intersect1), &n2(*intersect2);
- double d1 = std::max(fabs(iN[0]-n1[0]), fabs(iN[1]-n1[1]));
- double d2 = std::max(fabs(iN[0]-n2[0]), fabs(iN[1]-n2[1]));
+ double const d1 = std::max(fabs(iN[0]-n1[0]), fabs(iN[1]-n1[1]));
+ double const d2 = std::max(fabs(iN[0]-n2[0]), fabs(iN[1]-n2[1]));
isN1 = d1 < d2; isN2 = !isN1;
if (isN1) intersect1->decrRef();
if (isN2) intersect2->decrRef();
}
if (!isN1)
{
- bool i1_1S=_e1.getStartNode()->isEqual(*intersect1);
- bool i1_1E=_e1.getEndNode()->isEqual(*intersect1);
- bool i1_2S=_e2.getStartNode()->isEqual(*intersect1);
- bool i1_2E=_e2.getEndNode()->isEqual(*intersect1);
+ bool const i1_1S=_e1.getStartNode()->isEqual(*intersect1);
+ bool const i1_1E=_e1.getEndNode()->isEqual(*intersect1);
+ bool const i1_2S=_e2.getStartNode()->isEqual(*intersect1);
+ bool const i1_2E=_e2.getEndNode()->isEqual(*intersect1);
ret.push_back(IntersectElement(getE1().getCharactValue(*intersect1),getE2().getCharactValue(*intersect1),i1_1S,i1_1E,i1_2S,i1_2E,intersect1,_e1,_e2,keepOrder()));
}
if(!isN2)
{
- bool i2_1S=_e1.getStartNode()->isEqual(*intersect2);
- bool i2_1E=_e1.getEndNode()->isEqual(*intersect2);
- bool i2_2S=_e2.getStartNode()->isEqual(*intersect2);
- bool i2_2E=_e2.getEndNode()->isEqual(*intersect2);
+ bool const i2_1S=_e1.getStartNode()->isEqual(*intersect2);
+ bool const i2_1E=_e1.getEndNode()->isEqual(*intersect2);
+ bool const i2_2S=_e2.getStartNode()->isEqual(*intersect2);
+ bool const i2_2E=_e2.getEndNode()->isEqual(*intersect2);
ret.push_back(IntersectElement(getE1().getCharactValue(*intersect2),getE2().getCharactValue(*intersect2),i2_1S,i2_1E,i2_2S,i2_2E,intersect2,_e1,_e2,keepOrder()));
}
}
ret.push_back(*_earlyInter);
return ret;
}
- double x=(_cross*_dy)/_drSq+center[0];
- double y=(-_cross*_dx)/_drSq+center[1];
+ double const x=(_cross*_dy)/_drSq+center[0];
+ double const y=(-_cross*_dx)/_drSq+center[1];
Node *intersect3=new Node(x,y); intersect3->declareOnTangent();
- bool i_1S=_e1.getStartNode()->isEqual(*intersect3);
- bool i_1E=_e1.getEndNode()->isEqual(*intersect3);
- bool i_2S=_e2.getStartNode()->isEqual(*intersect3);
- bool i_2E=_e2.getEndNode()->isEqual(*intersect3);
+ bool const i_1S=_e1.getStartNode()->isEqual(*intersect3);
+ bool const i_1E=_e1.getEndNode()->isEqual(*intersect3);
+ bool const i_2S=_e2.getStartNode()->isEqual(*intersect3);
+ bool const i_2E=_e2.getEndNode()->isEqual(*intersect3);
ret.push_back(IntersectElement(_e1.getCharactValue(*intersect3),_e2.getCharactValue(*intersect3),i_1S,i_1E,i_2S,i_2E,intersect3,_e1,_e2,keepOrder()));
}
return ret;
Edge *EdgeArcCircle::buildEdgeLyingOnMe(Node *start, Node *end, bool direction) const
{
- double sx=((*start)[0]-_center[0])/_radius;
- double sy=((*start)[1]-_center[1])/_radius;
- double ex=((*end)[0]-_center[0])/_radius;
- double ey=((*end)[1]-_center[1])/_radius;
- double angle0=GetAbsoluteAngleOfNormalizedVect(direction?sx:ex,direction?sy:ey);
+ double const sx=((*start)[0]-_center[0])/_radius;
+ double const sy=((*start)[1]-_center[1])/_radius;
+ double const ex=((*end)[0]-_center[0])/_radius;
+ double const ey=((*end)[1]-_center[1])/_radius;
+ double const angle0=GetAbsoluteAngleOfNormalizedVect(direction?sx:ex,direction?sy:ey);
double deltaAngle=GetAbsoluteAngleOfNormalizedVect(sx*ex+sy*ey,sx*ey-sy*ex);
if(deltaAngle>0. && _angle<0.)
deltaAngle-=2.*M_PI;
void EdgeArcCircle::tesselate(const mcIdType *conn, mcIdType offset, double eps, std::vector<mcIdType>& newConn, std::vector<double>& addCoo) const
{
newConn.push_back(INTERP_KERNEL::NORM_POLYL);
- int nbOfSubDiv=(int)(fabs(_angle)/eps);
+ int const nbOfSubDiv=(int)(fabs(_angle)/eps);
if(nbOfSubDiv<=2)
{
newConn.push_back(conn[0]); newConn.push_back(conn[2]); newConn.push_back(conn[1]);
return ;
}
- double signOfAngle=_angle>0.?1.:-1.;
+ double const signOfAngle=_angle>0.?1.:-1.;
mcIdType offset2=offset+(ToIdType(addCoo.size()))/2;
newConn.push_back(conn[0]);
for(int i=1;i<nbOfSubDiv;i++,offset2++)
{
- double angle=_angle0+i*eps*signOfAngle;
+ double const angle=_angle0+i*eps*signOfAngle;
newConn.push_back(offset2);
addCoo.push_back(_center[0]+_radius*cos(angle)); addCoo.push_back(_center[1]+_radius*sin(angle));
}
EdgeLin *e1,*e2;
e1=new EdgeLin(start,middle);
e2=new EdgeLin(middle,end);
- SegSegIntersector inters(*e1,*e2);
- bool colinearity=inters.areColinears();
+ SegSegIntersector const inters(*e1,*e2);
+ bool const colinearity=inters.areColinears();
delete e1; delete e2;
if(colinearity)
{
start->decrRef(); middle->decrRef(); end->decrRef();
- return 0;
+ return nullptr;
}
else
{
- EdgeArcCircle *ret=new EdgeArcCircle(start,middle,end);
+ auto *ret=new EdgeArcCircle(start,middle,end);
start->decrRef(); middle->decrRef(); end->decrRef();
return ret;
}
void EdgeArcCircle::GetArcOfCirclePassingThru(const double *start, const double *middle, const double *end,
double *center, double& radius, double& angleInRad, double& angleInRad0)
{
- double delta=(middle[0]-start[0])*(end[1]-middle[1])-(end[0]-middle[0])*(middle[1]-start[1]);
- double b1=(middle[1]*middle[1]+middle[0]*middle[0]-start[0]*start[0]-start[1]*start[1])/2;
- double b2=(end[1]*end[1]+end[0]*end[0]-middle[0]*middle[0]-middle[1]*middle[1])/2;
+ double const delta=(middle[0]-start[0])*(end[1]-middle[1])-(end[0]-middle[0])*(middle[1]-start[1]);
+ double const b1=(middle[1]*middle[1]+middle[0]*middle[0]-start[0]*start[0]-start[1]*start[1])/2;
+ double const b2=(end[1]*end[1]+end[0]*end[0]-middle[0]*middle[0]-middle[1]*middle[1])/2;
center[0]=((end[1]-middle[1])*b1+(start[1]-middle[1])*b2)/delta;
center[1]=((middle[0]-end[0])*b1+(middle[0]-start[0])*b2)/delta;
radius=SafeSqrt((start[0]-center[0])*(start[0]-center[0])+(start[1]-center[1])*(start[1]-center[1]));
angleInRad0=GetAbsoluteAngleOfNormalizedVect((start[0]-center[0])/radius,(start[1]-center[1])/radius);
- double angleInRadM=GetAbsoluteAngleOfNormalizedVect((middle[0]-center[0])/radius,(middle[1]-center[1])/radius);
+ double const angleInRadM=GetAbsoluteAngleOfNormalizedVect((middle[0]-center[0])/radius,(middle[1]-center[1])/radius);
angleInRad=GetAbsoluteAngleOfNormalizedVect(((start[0]-center[0])*(end[0]-center[0])+(start[1]-center[1])*(end[1]-center[1]))/(radius*radius),
((start[0]-center[0])*(end[1]-center[1])-(start[1]-center[1])*(end[0]-center[0]))/(radius*radius));
if(IsAngleNotIn(angleInRad0,angleInRad,angleInRadM))
*/
void EdgeArcCircle::getBarycenterOfZone(double *bary) const
{
- double x0=_center[0];
- double y0=_center[1];
- double angle1=_angle0+_angle;
- double tmp1=sin(angle1);
- double tmp0=sin(_angle0);
- double tmp2=_radius*_radius*_radius;
- double tmp3=cos(angle1);
- double tmp4=cos(_angle0);
+ double const x0=_center[0];
+ double const y0=_center[1];
+ double const angle1=_angle0+_angle;
+ double const tmp1=sin(angle1);
+ double const tmp0=sin(_angle0);
+ double const tmp2=_radius*_radius*_radius;
+ double const tmp3=cos(angle1);
+ double const tmp4=cos(_angle0);
bary[0]=_radius*x0*y0*(tmp4-tmp3)+_radius*_radius*(y0*(cos(2*_angle0)-cos(2*angle1))/4.+
x0*(_angle/2.+(sin(2.*_angle0)-sin(2.*angle1))/4.))
+tmp2*(tmp1*tmp1*tmp1-tmp0*tmp0*tmp0)/3.;
*/
double EdgeArcCircle::getCharactValue(const Node& node) const
{
- double dx=(node[0]-_center[0])/_radius;
- double dy=(node[1]-_center[1])/_radius;
+ double const dx=(node[0]-_center[0])/_radius;
+ double const dy=(node[1]-_center[1])/_radius;
return GetAbsoluteAngleOfNormalizedVect(dx,dy);
}
double EdgeArcCircle::getCharactValueBtw0And1(const Node& node) const
{
- double dx=(node[0]-_center[0])/_radius;
- double dy=(node[1]-_center[1])/_radius;
- double angle=GetAbsoluteAngleOfNormalizedVect(dx,dy);
+ double const dx=(node[0]-_center[0])/_radius;
+ double const dy=(node[1]-_center[1])/_radius;
+ double const angle=GetAbsoluteAngleOfNormalizedVect(dx,dy);
//
double myDelta=angle-_angle0;
if(_angle>0.)
double EdgeArcCircle::getDistanceToPoint(const double *pt) const
{
- double angle=Node::computeAngle(_center,pt);
+ double const angle=Node::computeAngle(_center,pt);
if(IsIn2Pi(_angle0,_angle,angle))
return fabs(Node::distanceBtw2Pt(_center,pt)-_radius);
else
{
- double dist1=Node::distanceBtw2Pt(*_start,pt);
- double dist2=Node::distanceBtw2Pt(*_end,pt);
+ double const dist1=Node::distanceBtw2Pt(*_start,pt);
+ double const dist2=Node::distanceBtw2Pt(*_end,pt);
return std::min(dist1,dist2);
}
}
bool EdgeArcCircle::isNodeLyingOn(const double *coordOfNode) const
{
- double dist=Node::distanceBtw2Pt(_center,coordOfNode);
+ double const dist=Node::distanceBtw2Pt(_center,coordOfNode);
if(Node::areDoubleEquals(dist,_radius))
{
- double angle=Node::computeAngle(_center,coordOfNode);
+ double const angle=Node::computeAngle(_center,coordOfNode);
return IsIn2Pi(_angle0,_angle,angle);
}
else
#define __INTERPKERNELGEO2DEDGEARCCIRCLE_HXX__
#include "INTERPKERNELDefines.hxx"
+#include "InterpKernelGeo2DBounds.hxx"
#include "InterpKernelGeo2DEdge.hxx"
+#include "InterpKernelGeo2DNode.hxx"
#include "MCIdType.hxx"
+#include <list>
+#include <istream>
+#include <ostream>
+#include <vector>
+#include <algorithm>
+#include <cmath>
+#include <math.h>
namespace INTERP_KERNEL
{
{
public:
ArcCArcCIntersector(const EdgeArcCircle& e1, const EdgeArcCircle& e2);
- bool haveTheySameDirection() const;
- bool areColinears() const;
- void getPlacements(Node *start, Node *end, TypeOfLocInEdge& whereStart, TypeOfLocInEdge& whereEnd, MergePoints& commonNode) const;
- void areOverlappedOrOnlyColinears(bool& obviousNoIntersection, bool& areOverlapped);
- std::list< IntersectElement > getIntersectionsCharacteristicVal() const;
+ bool haveTheySameDirection() const override;
+ bool areColinears() const override;
+ void getPlacements(Node *start, Node *end, TypeOfLocInEdge& whereStart, TypeOfLocInEdge& whereEnd, MergePoints& commonNode) const override;
+ void areOverlappedOrOnlyColinears(bool& obviousNoIntersection, bool& areOverlapped) override;
+ std::list< IntersectElement > getIntersectionsCharacteristicVal() const override;
private:
//! return angle in ]-Pi;Pi[ - 'node' must be on curve of '_e1'
double getAngle(Node *node) const;
public:
ArcCSegIntersector(const EdgeArcCircle& e1, const EdgeLin& e2, bool reverse=true);
//virtual overloading
- bool areColinears() const;
- void getPlacements(Node *start, Node *end, TypeOfLocInEdge& whereStart, TypeOfLocInEdge& whereEnd, MergePoints& commonNode) const;
- void areOverlappedOrOnlyColinears(bool& obviousNoIntersection, bool& areOverlapped);
- std::list< IntersectElement > getIntersectionsCharacteristicVal() const;
+ bool areColinears() const override;
+ void getPlacements(Node *start, Node *end, TypeOfLocInEdge& whereStart, TypeOfLocInEdge& whereEnd, MergePoints& commonNode) const override;
+ void areOverlappedOrOnlyColinears(bool& obviousNoIntersection, bool& areOverlapped) override;
+ std::list< IntersectElement > getIntersectionsCharacteristicVal() const override;
private:
const EdgeArcCircle& getE1() const { return (const EdgeArcCircle&)_e1; }
const EdgeLin& getE2() const { return (const EdgeLin&)_e2; }
EdgeArcCircle(Node *start, Node *end, const double *center, double radius, double angle0, double deltaAngle, bool direction=true);
//! for tests
void changeMiddle(Node *newMiddle);
- void dumpInXfigFile(std::ostream& stream, bool direction, int resolution, const Bounds& box) const;
- void update(Node *m);
- double getAreaOfZone() const;
- double getCurveLength() const;
- void getBarycenter(double *bary) const;
- void getBarycenterOfZone(double *bary) const;
- void getMiddleOfPoints(const double *p1, const double *p2, double *mid) const;
- void getMiddleOfPointsOriented(const double *p1, const double *p2, double *mid) const;
- bool isIn(double characterVal) const;
- Node *buildRepresentantOfMySelf() const;
- bool isLower(double val1, double val2) const;
- double getCharactValue(const Node& node) const;
- double getCharactValueBtw0And1(const Node& node) const;
- double getDistanceToPoint(const double *pt) const;
- bool isNodeLyingOn(const double *coordOfNode) const;
- TypeOfFunction getTypeOfFunc() const { return ARC_CIRCLE; }
- void dynCastFunction(const EdgeLin * &seg,
- const EdgeArcCircle * &arcSeg) const { arcSeg=this; }
+ void dumpInXfigFile(std::ostream& stream, bool direction, int resolution, const Bounds& box) const override;
+ void update(Node *m) override;
+ double getAreaOfZone() const override;
+ double getCurveLength() const override;
+ void getBarycenter(double *bary) const override;
+ void getBarycenterOfZone(double *bary) const override;
+ void getMiddleOfPoints(const double *p1, const double *p2, double *mid) const override;
+ void getMiddleOfPointsOriented(const double *p1, const double *p2, double *mid) const override;
+ bool isIn(double characterVal) const override;
+ Node *buildRepresentantOfMySelf() const override;
+ bool isLower(double val1, double val2) const override;
+ double getCharactValue(const Node& node) const override;
+ double getCharactValueBtw0And1(const Node& node) const override;
+ double getDistanceToPoint(const double *pt) const override;
+ bool isNodeLyingOn(const double *coordOfNode) const override;
+ TypeOfFunction getTypeOfFunc() const override { return ARC_CIRCLE; }
+ void dynCastFunction(const EdgeLin * & /*seg*/,
+ const EdgeArcCircle * &arcSeg) const override { arcSeg=this; }
const double *getCenter() const { return _center; }
void getCenter(double *center) const { center[0]=_center[0]; center[1]=_center[1]; }
- bool doIHaveSameDirectionAs(const Edge& other) const { return false; }
- void applySimilarity(double xBary, double yBary, double dimChar);
- void unApplySimilarity(double xBary, double yBary, double dimChar);
+ bool doIHaveSameDirectionAs(const Edge& /*other*/) const { return false; }
+ void applySimilarity(double xBary, double yBary, double dimChar) override;
+ void unApplySimilarity(double xBary, double yBary, double dimChar) override;
double getAngle0() const { return _angle0; }
double getRadius() const { return _radius; }
double getAngle() const { return _angle; }
static void GetArcOfCirclePassingThru(const double *start, const double *middle, const double *end,
double *center, double& radius, double& angleInRad, double& angleInRad0);
//! To avoid in aggressive optimizations nan.
- static double SafeSqrt(double val) { double ret=std::max(val,0.); return sqrt(ret); }
+ static double SafeSqrt(double val) { double const ret=std::max(val,0.); return sqrt(ret); }
static double SafeAcos(double cosAngle) { double ret=std::min(cosAngle,1.); ret=std::max(ret,-1.); return acos(ret); }
static double SafeAsin(double sinAngle) { double ret=std::min(sinAngle,1.); ret=std::max(ret,-1.); return asin(ret); }
//! @param start and @param angleIn in ]-Pi;Pi] and @param delta in ]-2*Pi,2*Pi[
static double NormalizeAngle(double angle) { if(angle>M_PI) return angle-2.*M_PI; if(angle<-M_PI) return angle+2.*M_PI; return angle; }
protected:
void updateBounds();
- Edge *buildEdgeLyingOnMe(Node *start, Node *end, bool direction=true) const;
+ Edge *buildEdgeLyingOnMe(Node *start, Node *end, bool direction=true) const override;
protected:
//! Absolute angle where the arc starts. Value between -Pi and Pi
// Author : Anthony Geay (CEA/DEN)
#include "InterpKernelGeo2DEdgeInfLin.hxx"
+#include "InterpKernelGeo2DNode.hxx"
+#include <cmath>
using namespace INTERP_KERNEL;
#ifndef __INTERPKERNELGEO2DEDGEINFLIN_HXX__
#define __INTERPKERNELGEO2DEDGEINFLIN_HXX__
+#include "InterpKernelGeo2DEdge.hxx"
#include "InterpKernelGeo2DEdgeLin.hxx"
+#include "InterpKernelGeo2DNode.hxx"
namespace INTERP_KERNEL
{
public:
EdgeInfLin(Node *start, Node *end):EdgeLin(start,end,true) { }
EdgeInfLin(Node *pointPassingThrough, double slope);
- bool isIn(double characterVal) const { return true; }
+ bool isIn(double /*characterVal*/) const override { return true; }
void dynCastFunction(const EdgeLin * &seg,
- const EdgeArcCircle * &arcSeg) const { seg=this; }
+ const EdgeArcCircle * & /*arcSeg*/) const override { seg=this; }
protected:
- ~EdgeInfLin() { }
+ ~EdgeInfLin() override = default;
};
}
// Author : Anthony Geay (CEA/DEN)
#include "InterpKernelGeo2DEdgeLin.hxx"
+#include "InterpKernelGeo2DEdge.hxx"
#include "InterpKernelGeo2DNode.hxx"
-#include "InterpKernelException.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
+#include "InterpKernelGeo2DPrecision.hxx"
+#include <cmath>
+#include <list>
+#include <algorithm>
+#include <istream>
+#include <ostream>
using namespace INTERP_KERNEL;
obviousCaseForCurvAbscisse(node,where,commonNode,obvious);
if(obvious)
return ;
- double ret=((*node)[!_ind]-(*_e1.getStartNode())[!_ind])/((*_e1.getEndNode())[!_ind]-(*_e1.getStartNode())[!_ind]);
+ double const ret=((*node)[!_ind]-(*_e1.getStartNode())[!_ind])/((*_e1.getEndNode())[!_ind]-(*_e1.getStartNode())[!_ind]);
if(ret>0. && ret <1.)
where=INSIDE;
else if(ret<0.)
return ret;
}
- double x= (-_matrix[2]*_col[0]+_matrix[0]*_col[1]) / _determinant;
- double y= (-_matrix[3]*_col[0]+_matrix[1]*_col[1]) / _determinant;
+ double const x= (-_matrix[2]*_col[0]+_matrix[0]*_col[1]) / _determinant;
+ double const y= (-_matrix[3]*_col[0]+_matrix[1]*_col[1]) / _determinant;
//Only one intersect point possible
Node *node=new Node(x,y);
node->declareOn();
- bool i_1S=_e1.getStartNode()->isEqual(*node);
- bool i_1E=_e1.getEndNode()->isEqual(*node);
- bool i_2S=_e2.getStartNode()->isEqual(*node);
- bool i_2E=_e2.getEndNode()->isEqual(*node);
+ bool const i_1S=_e1.getStartNode()->isEqual(*node);
+ bool const i_1E=_e1.getEndNode()->isEqual(*node);
+ bool const i_2S=_e2.getStartNode()->isEqual(*node);
+ bool const i_2E=_e2.getEndNode()->isEqual(*node);
ret.push_back(IntersectElement(_e1.getCharactValue(*node),
_e2.getCharactValue(*node),
i_1S,i_1E,i_2S,i_2E,node,_e1,_e2,keepOrder()));
else // Colinear vectors
{
// Compute vectors joining tips of e1 and e2
- double xS=(*(_e1.getStartNode()))[0]-(*(_e2.getStartNode()))[0];
- double yS=(*(_e1.getStartNode()))[1]-(*(_e2.getStartNode()))[1];
- double xE=(*(_e1.getEndNode()))[0]-(*(_e2.getEndNode()))[0];
- double yE=(*(_e1.getEndNode()))[1]-(*(_e2.getEndNode()))[1];
+ double const xS=(*(_e1.getStartNode()))[0]-(*(_e2.getStartNode()))[0];
+ double const yS=(*(_e1.getStartNode()))[1]-(*(_e2.getStartNode()))[1];
+ double const xE=(*(_e1.getEndNode()))[0]-(*(_e2.getEndNode()))[0];
+ double const yE=(*(_e1.getEndNode()))[1]-(*(_e2.getEndNode()))[1];
double maxDimS(std::max(fabs(xS),fabs(yS))), maxDimE(std::max(fabs(xE), fabs(yE)));
bool isS = (maxDimS > maxDimE), isE1 = (dimCharE1 >= dimCharE2);
- double x = isS ? xS : xE;
- double y = isS ? yS : yE;
- unsigned shift = isE1 ? 0 : 2;
+ double const x = isS ? xS : xE;
+ double const y = isS ? yS : yE;
+ unsigned const shift = isE1 ? 0 : 2;
// test colinearity of the greatest tip-joining vector and greatest vector among {e1, e2}
areOverlapped = fabs(x*_matrix[1+shift]-y*_matrix[0+shift]) < dimCharE1*dimCharE2*QuadraticPlanarPrecision::getPrecision();
// explanation: if areOverlapped is true, we don't know yet if there will be an intersection (see meaning of areOverlapped in method doxy above)
}
EdgeLin::~EdgeLin()
-{
-}
+= default;
/*!
* Characteristic for edges is relative position btw 0.;1.
double EdgeLin::getDistanceToPoint(const double *pt) const
{
- double loc=getCharactValueEng(pt);
+ double const loc=getCharactValueEng(pt);
if(loc>0. && loc<1.)
{
double tmp[2];
}
else
{
- double dist1=Node::distanceBtw2Pt(*_start,pt);
- double dist2=Node::distanceBtw2Pt(*_end,pt);
+ double const dist1=Node::distanceBtw2Pt(*_start,pt);
+ double const dist2=Node::distanceBtw2Pt(*_end,pt);
return std::min(dist1,dist2);
}
}
bool EdgeLin::isNodeLyingOn(const double *coordOfNode) const
{
- double dBase=sqrt(_start->distanceWithSq(*_end));
+ double const dBase=sqrt(_start->distanceWithSq(*_end));
double d1=Node::distanceBtw2Pt(*_start,coordOfNode);
d1+=Node::distanceBtw2Pt(*_end,coordOfNode);
return Node::areDoubleEquals(dBase,d1);
stream << std::endl;
}
-void EdgeLin::update(Node *m)
+void EdgeLin::update(Node * /*m*/)
{
updateBounds();
}
*/
void EdgeLin::getBarycenterOfZone(double *bary) const
{
- double x1=(*_start)[0];
- double y1=(*_start)[1];
- double x2=(*_end)[0];
- double y2=(*_end)[1];
+ double const x1=(*_start)[0];
+ double const y1=(*_start)[1];
+ double const x2=(*_end)[0];
+ double const y2=(*_end)[1];
bary[0]=(x1-x2)*(y1*(2.*x1+x2)+y2*(2.*x2+x1))/6.;
//bary[0]+=(y1-y2)*(x2*x2/3.-(x1*x2+x1*x1)/6.)+y1*(x1*x1-x2*x2)/2.;
//bary[0]+=(y1-y2)*((x2*x2+x1*x2+x1*x1)/3.-(x2+x1)*x1/2.)+y1*(x1*x1-x2*x2)/2.;
double EdgeLin::getCurveLength() const
{
- double x=(*_start)[0]-(*_end)[0];
- double y=(*_start)[1]-(*_end)[1];
+ double const x=(*_start)[0]-(*_end)[0];
+ double const y=(*_start)[1]-(*_end)[1];
return sqrt(x*x+y*y);
}
double EdgeLin::getCharactValueEng(const double *node) const
{
- double car1_1x=node[0]-(*(_start))[0]; double car1_2x=(*(_end))[0]-(*(_start))[0];
- double car1_1y=node[1]-(*(_start))[1]; double car1_2y=(*(_end))[1]-(*(_start))[1];
+ double const car1_1x=node[0]-(*(_start))[0]; double const car1_2x=(*(_end))[0]-(*(_start))[0];
+ double const car1_1y=node[1]-(*(_start))[1]; double const car1_2y=(*(_end))[1]-(*(_start))[1];
return (car1_1x*car1_2x+car1_1y*car1_2y)/(car1_2x*car1_2x+car1_2y*car1_2y);
}
#define __INTERPKERNELGEO2DEDGELIN_HXX__
#include "INTERPKERNELDefines.hxx"
+#include "InterpKernelGeo2DBounds.hxx"
#include "InterpKernelGeo2DEdge.hxx"
+#include "InterpKernelGeo2DNode.hxx"
+#include <list>
+#include <istream>
+#include <ostream>
namespace INTERP_KERNEL
{
friend class Edge;
public:
SegSegIntersector(const EdgeLin& e1, const EdgeLin& e2);
- bool areColinears() const;
- bool haveTheySameDirection() const;
- void getPlacements(Node *start, Node *end, TypeOfLocInEdge& whereStart, TypeOfLocInEdge& whereEnd, MergePoints& commonNode) const;
- void areOverlappedOrOnlyColinears(bool& obviousNoIntersection, bool& areOverlapped);
- std::list< IntersectElement > getIntersectionsCharacteristicVal() const;
+ bool areColinears() const override;
+ bool haveTheySameDirection() const override;
+ void getPlacements(Node *start, Node *end, TypeOfLocInEdge& whereStart, TypeOfLocInEdge& whereEnd, MergePoints& commonNode) const override;
+ void areOverlappedOrOnlyColinears(bool& obviousNoIntersection, bool& areOverlapped) override;
+ std::list< IntersectElement > getIntersectionsCharacteristicVal() const override;
private:
void getCurveAbscisse(Node *node, TypeOfLocInEdge& where, MergePoints& commonNode) const;
private:
EdgeLin(std::istream& lineInXfig);
EdgeLin(Node *start, Node *end, bool direction=true);
EdgeLin(double sX, double sY, double eX, double eY);
- ~EdgeLin();
- TypeOfFunction getTypeOfFunc() const { return SEG; }
- void dumpInXfigFile(std::ostream& stream, bool direction, int resolution, const Bounds& box) const;
- void update(Node *m);
+ ~EdgeLin() override;
+ TypeOfFunction getTypeOfFunc() const override { return SEG; }
+ void dumpInXfigFile(std::ostream& stream, bool direction, int resolution, const Bounds& box) const override;
+ void update(Node *m) override;
double getNormSq() const;
- double getAreaOfZone() const;
- double getCurveLength() const;
- void getBarycenter(double *bary) const;
- void getBarycenterOfZone(double *bary) const;
- void getMiddleOfPoints(const double *p1, const double *p2, double *mid) const;
- bool isIn(double characterVal) const;
- Node *buildRepresentantOfMySelf() const;
- double getCharactValue(const Node& node) const;
- double getCharactValueBtw0And1(const Node& node) const;
- double getDistanceToPoint(const double *pt) const;
- bool isNodeLyingOn(const double *coordOfNode) const;
- bool isLower(double val1, double val2) const { return val1<val2; }
+ double getAreaOfZone() const override;
+ double getCurveLength() const override;
+ void getBarycenter(double *bary) const override;
+ void getBarycenterOfZone(double *bary) const override;
+ void getMiddleOfPoints(const double *p1, const double *p2, double *mid) const override;
+ bool isIn(double characterVal) const override;
+ Node *buildRepresentantOfMySelf() const override;
+ double getCharactValue(const Node& node) const override;
+ double getCharactValueBtw0And1(const Node& node) const override;
+ double getDistanceToPoint(const double *pt) const override;
+ bool isNodeLyingOn(const double *coordOfNode) const override;
+ bool isLower(double val1, double val2) const override { return val1<val2; }
double getCharactValueEng(const double *node) const;
bool doIHaveSameDirectionAs(const Edge& other) const;
void dynCastFunction(const EdgeLin * &seg,
- const EdgeArcCircle * &arcSeg) const { seg=this; }
+ const EdgeArcCircle * & /*arcSeg*/) const override { seg=this; }
protected:
EdgeLin() { }
void updateBounds();
- Edge *buildEdgeLyingOnMe(Node *start, Node *end, bool direction) const;
+ Edge *buildEdgeLyingOnMe(Node *start, Node *end, bool direction) const override;
};
}
// Author : Anthony Geay (CEA/DEN)
#include "InterpKernelGeo2DElementaryEdge.hxx"
-#include "InterpKernelException.hxx"
#include "InterpKernelGeo2DEdge.hxx"
#include "InterpKernelGeo2DComposedEdge.hxx"
+#include <set>
+#include "InterpKernelGeo2DNode.hxx"
+#include <ostream>
+#include <map>
+#include "MCIdType.hxx"
+#include <vector>
using namespace INTERP_KERNEL;
#define __INTERPKERNELGEO2DELEMENTARYEDGE_HXX__
#include "INTERPKERNELDefines.hxx"
-#include "InterpKernelException.hxx"
#include "InterpKernelGeo2DAbstractEdge.hxx"
#include "InterpKernelGeo2DEdge.hxx"
+#include <set>
+#include <ostream>
+#include <map>
+#include "MCIdType.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
INTERPKERNEL_EXPORT Edge *getPtr() const { return _ptr; }
INTERPKERNEL_EXPORT void reverse() { _direction=(!_direction); }
INTERPKERNEL_EXPORT bool isNodeIn(Node *n) const;
- INTERPKERNEL_EXPORT double getAreaOfZone() const { double ret=_ptr->getAreaOfZone(); return _direction?ret:-ret; }
+ INTERPKERNEL_EXPORT double getAreaOfZone() const { double const ret=_ptr->getAreaOfZone(); return _direction?ret:-ret; }
INTERPKERNEL_EXPORT void getBarycenterOfZone(double *bary) const;
INTERPKERNEL_EXPORT void fillBounds(Bounds& output) const;
INTERPKERNEL_EXPORT void applySimilarity(double xBary, double yBary, double dimChar) { _ptr->applySimilarity(xBary,yBary,dimChar); }
#include "InterpKernelGeo2DNode.hxx"
#include "InterpKernelGeo2DEdgeArcCircle.hxx"
+#include <istream>
+#include <vector>
+#include <ostream>
+#include <cmath>
+#include <math.h>
+#include <map>
+#include "MCIdType.hxx"
+#include <cstddef>
+#include <algorithm>
using namespace INTERP_KERNEL;
}
Node::~Node()
-{
-}
+= default;
bool Node::decrRef()
{
- bool ret=(--_cnt==0);
+ bool const ret=(--_cnt==0);
if(ret)
delete this;
return ret;
*/
bool Node::isEqualAndKeepTrack(const Node& other, std::vector<Node *>& track) const
{
- bool ret=isEqual(other);
+ bool const ret=isEqual(other);
if(ret)
track.push_back(const_cast<Node *>(&other));
return ret;
*/
double Node::computeSlope(const double *pt1, const double *pt2)
{
- double x=pt2[0]-pt1[0];
- double y=pt2[1]-pt1[1];
- double norm=sqrt(x*x+y*y);
- double ret=EdgeArcCircle::SafeAcos(fabs(x)/norm);
+ double const x=pt2[0]-pt1[0];
+ double const y=pt2[1]-pt1[1];
+ double const norm=sqrt(x*x+y*y);
+ double const ret=EdgeArcCircle::SafeAcos(fabs(x)/norm);
if( (x>=0. && y>=0.) || (x<0. && y<0.) )
return ret;
else
*/
double Node::computeAngle(const double *pt1, const double *pt2)
{
- double x=pt2[0]-pt1[0];
- double y=pt2[1]-pt1[1];
- double norm=sqrt(x*x+y*y);
+ double const x=pt2[0]-pt1[0];
+ double const y=pt2[1]-pt1[1];
+ double const norm=sqrt(x*x+y*y);
return EdgeArcCircle::GetAbsoluteAngleOfNormalizedVect(x/norm,y/norm);
}
void Node::fillGlobalInfoAbs(const std::map<INTERP_KERNEL::Node *,mcIdType>& mapThis, const std::map<INTERP_KERNEL::Node *,mcIdType>& mapOther, mcIdType offset1, mcIdType offset2, double fact, double baryX, double baryY,
std::vector<double>& addCoo, std::map<INTERP_KERNEL::Node *,mcIdType>& mapAddCoo, mcIdType *nodeId) const
{
- std::map<INTERP_KERNEL::Node *,mcIdType>::const_iterator it=mapOther.find(const_cast<Node *>(this));
+ auto it=mapOther.find(const_cast<Node *>(this));
if(it!=mapOther.end()) // order matters, try in mapOther first.
{
*nodeId=(*it).second+offset1;
*nodeId=(*it).second;
return;
}
- int id=(int)addCoo.size()/2;
+ int const id=(int)addCoo.size()/2;
addCoo.push_back(fact*_coords[0]+baryX);
addCoo.push_back(fact*_coords[1]+baryY);
*nodeId=offset2+id;
std::vector<double>& addCoo, std::map<INTERP_KERNEL::Node *,mcIdType>& mapAddCoo, std::vector<mcIdType>& pointsOther) const
{
mcIdType tmp;
- std::size_t sz1=addCoo.size();
+ std::size_t const sz1=addCoo.size();
fillGlobalInfoAbs(mapThis,mapOther,offset1,offset2,fact,baryX,baryY,addCoo,mapAddCoo,&tmp);
if(sz1!=addCoo.size() // newly created point
|| (tmp >= offset2 // or previously created point merged with a neighbour
pointsOther.push_back(tmp);
return ;
}
- std::vector<mcIdType>::const_iterator it=std::find(pointsOther.begin(),pointsOther.end(),tmp);
+ std::vector<mcIdType>::const_iterator const it=std::find(pointsOther.begin(),pointsOther.end(),tmp);
if(it!=pointsOther.end())
return ;
pointsOther.push_back(tmp);
// Author : Anthony Geay (CEA/DEN)
#include "InterpKernelGeo2DQuadraticPolygon.hxx"
+#include "InterpKernelGeo2DEdge.hxx"
#include "InterpKernelGeo2DElementaryEdge.hxx"
#include "InterpKernelGeo2DEdgeArcCircle.hxx"
#include "InterpKernelGeo2DAbstractEdge.hxx"
#include "InterpKernelGeo2DEdgeLin.hxx"
#include "InterpKernelGeo2DBounds.hxx"
-#include "InterpKernelGeo2DEdge.txx"
+#include "NormalizedGeometricTypes"
-#include "NormalizedUnstructuredMesh.hxx"
+#include "MCIdType.hxx"
+#include "InterpKernelGeo2DNode.hxx"
+#include <exception>
+#include <cmath>
+#include <cstdlib>
+#include <algorithm>
#include <fstream>
+#include <ios>
+#include <ostream>
+#include <list>
+#include <map>
+#include <iterator>
+#include <set>
#include <sstream>
#include <iomanip>
#include <cstring>
#include <limits>
+#include <string>
+#include <vector>
+#include <utility>
using namespace INTERP_KERNEL;
newEdge->changeStartNodeWith(back()->getEndNode());
pushBack(newEdge);
}
- while(1);
+ while(true);
}
catch(const std::ifstream::failure&)
{
}
QuadraticPolygon::~QuadraticPolygon()
-{
-}
+= default;
QuadraticPolygon *QuadraticPolygon::BuildLinearPolygon(std::vector<Node *>& nodes)
{
- QuadraticPolygon *ret(new QuadraticPolygon);
- std::size_t size=nodes.size();
+ auto *ret(new QuadraticPolygon);
+ std::size_t const size=nodes.size();
for(std::size_t i=0;i<size;i++)
{
ret->pushBack(new EdgeLin(nodes[i],nodes[(i+1)%size]));
QuadraticPolygon *QuadraticPolygon::BuildArcCirclePolygon(std::vector<Node *>& nodes)
{
- QuadraticPolygon *ret(new QuadraticPolygon);
- std::size_t size=nodes.size();
+ auto *ret(new QuadraticPolygon);
+ std::size_t const size=nodes.size();
for(std::size_t i=0;i<size/2;i++)
{
EdgeLin *e1,*e2;
e1=new EdgeLin(nodes[i],nodes[i+size/2]);
e2=new EdgeLin(nodes[i+size/2],nodes[(i+1)%(size/2)]);
- SegSegIntersector inters(*e1,*e2);
- bool colinearity=inters.areColinears();
+ SegSegIntersector const inters(*e1,*e2);
+ bool const colinearity=inters.areColinears();
delete e1; delete e2;
if(colinearity)
ret->pushBack(new EdgeLin(nodes[i],nodes[(i+1)%(size/2)]));
{
if(nodes.size()!=3)
throw INTERP_KERNEL::Exception("QuadraticPolygon::BuildArcCircleEdge : input vector is expected to be of size 3 !");
- EdgeLin *e1(new EdgeLin(nodes[0],nodes[2])),*e2(new EdgeLin(nodes[2],nodes[1]));
- SegSegIntersector inters(*e1,*e2);
- bool colinearity=inters.areColinears();
+ auto *e1(new EdgeLin(nodes[0],nodes[2])),*e2(new EdgeLin(nodes[2],nodes[1]));
+ SegSegIntersector const inters(*e1,*e2);
+ bool const colinearity=inters.areColinears();
delete e1; delete e2;
- Edge *ret(0);
+ Edge *ret(nullptr);
if(colinearity)
ret=new EdgeLin(nodes[0],nodes[1]);
else
std::ofstream file(fileName);
file << std::setprecision(16);
file << " double coords[]=" << std::endl << " { ";
- for(std::vector<Node *>::const_iterator iter=nodes.begin();iter!=nodes.end();iter++)
+ for(auto iter=nodes.begin();iter!=nodes.end();iter++)
{
if(iter!=nodes.begin())
file << "," << std::endl << " ";
double xBary,yBary;
b.prepareForAggregation();
fillBounds(b);
- double dimChar=b.getCaracteristicDim();
+ double const dimChar=b.getCaracteristicDim();
b.getBarycenter(xBary,yBary);
applyGlobalSimilarity(xBary,yBary,dimChar);
//
bool QuadraticPolygon::isButterfly() const
{
- for(std::list<ElementaryEdge *>::const_iterator it=_sub_edges.begin();it!=_sub_edges.end();it++)
+ for(auto it=_sub_edges.begin();it!=_sub_edges.end();it++)
{
Edge *e1=(*it)->getPtr();
- std::list<ElementaryEdge *>::const_iterator it2=it;
+ auto it2=it;
it2++;
for(;it2!=_sub_edges.end();it2++)
{
MergePoints commonNode;
- ComposedEdge *outVal1=new ComposedEdge;
- ComposedEdge *outVal2=new ComposedEdge;
+ auto *outVal1=new ComposedEdge;
+ auto *outVal2=new ComposedEdge;
Edge *e2=(*it2)->getPtr();
if(e1->intersectWith(e2,commonNode,*outVal1,*outVal2))
{
double QuadraticPolygon::intersectWithAbs(QuadraticPolygon& other)
{
double ret=0.,xBaryBB,yBaryBB;
- double fact=normalize(&other,xBaryBB,yBaryBB);
- std::vector<QuadraticPolygon *> polygs=intersectMySelfWith(other);
- for(std::vector<QuadraticPolygon *>::iterator iter=polygs.begin();iter!=polygs.end();iter++)
+ double const fact=normalize(&other,xBaryBB,yBaryBB);
+ std::vector<QuadraticPolygon *> const polygs=intersectMySelfWith(other);
+ for(auto & polyg : polygs)
{
- ret+=fabs((*iter)->getArea());
- delete *iter;
+ ret+=fabs(polyg->getArea());
+ delete polyg;
}
return ret*fact*fact;
}
std::vector<double>& addCoo, std::map<mcIdType,mcIdType>& mergedNodes)
{
double xBaryBB, yBaryBB;
- double fact=normalizeExt(&other, xBaryBB, yBaryBB);
+ double const fact=normalizeExt(&other, xBaryBB, yBaryBB);
//
IteratorOnComposedEdge itThis(this),itOther(&other); // other is (part of) the tool mesh
MergePoints merge;
- ComposedEdge *cThis=new ComposedEdge;
- ComposedEdge *cOther=new ComposedEdge;
+ auto *cThis=new ComposedEdge;
+ auto *cOther=new ComposedEdge;
int i=0;
std::map<INTERP_KERNEL::Node *,mcIdType> mapAddCoo;
for(itOther.first();!itOther.finished();itOther.next(),i++)
ElementaryEdge* curThis=itThis.current();
merge.clear();
//
- std::map<INTERP_KERNEL::Node *,mcIdType>::const_iterator thisStart(mapThis.find(curThis->getStartNode())),thisEnd(mapThis.find(curThis->getEndNode())),
+ auto thisStart(mapThis.find(curThis->getStartNode())),thisEnd(mapThis.find(curThis->getEndNode())),
otherStart(mapOther.find(curOtherTmp->getStartNode())),otherEnd(mapOther.find(curOtherTmp->getEndNode()));
mcIdType thisStart2(thisStart==mapThis.end()?-1:(*thisStart).second), thisEnd2(thisEnd==mapThis.end()?-1:(*thisEnd).second),
otherStart2(otherStart==mapOther.end()?-1:(*otherStart).second+offset1),otherEnd2(otherEnd==mapOther.end()?-1:(*otherEnd).second+offset1);
std::size_t jj = 0, sz(otherTmp._sub_edges.size());
for(std::list<ElementaryEdge *>::const_iterator it=otherTmp._sub_edges.begin();it!=otherTmp._sub_edges.end();it++, jj++)
{
- short skipStartOrEnd = jj == 0 ? -1 : (jj == sz-1 ? 1 : 0); // -1 means START, 1 means END, 0 other
+ short const skipStartOrEnd = jj == 0 ? -1 : (jj == sz-1 ? 1 : 0); // -1 means START, 1 means END, 0 other
(*it)->fillGlobalInfoAbs2(mapThis,mapOther,offset1,offset2,
fact,xBaryBB,yBaryBB, skipStartOrEnd,
/*out*/ subDivOther[otherEdgeIds[i]],addCoo,mapAddCoo);
void QuadraticPolygon::buildFromCrudeDataArray(const std::map<mcIdType,INTERP_KERNEL::Node *>& mapp, bool isQuad, const mcIdType *nodalBg, const double *coords,
const mcIdType *descBg, const mcIdType *descEnd, const std::vector<std::vector<mcIdType> >& intersectEdges)
{
- std::size_t nbOfSeg=std::distance(descBg,descEnd);
+ std::size_t const nbOfSeg=std::distance(descBg,descEnd);
for(std::size_t i=0;i<nbOfSeg;i++)
{
appendEdgeFromCrudeDataArray(i,mapp,isQuad,nodalBg,coords,descBg,descEnd,intersectEdges);
{
if(!isQuad)
{
- bool direct=descBg[edgePos]>0;
- mcIdType edgeId=std::abs(descBg[edgePos])-1; // back to C indexing mode
+ bool const direct=descBg[edgePos]>0;
+ mcIdType const edgeId=std::abs(descBg[edgePos])-1; // back to C indexing mode
const std::vector<mcIdType>& subEdge=intersectEdges[edgeId];
- std::size_t nbOfSubEdges=subEdge.size()/2;
+ std::size_t const nbOfSubEdges=subEdge.size()/2;
for(std::size_t j=0;j<nbOfSubEdges;j++)
- appendSubEdgeFromCrudeDataArray(0,j,direct,edgeId,subEdge,mapp);
+ appendSubEdgeFromCrudeDataArray(nullptr,j,direct,edgeId,subEdge,mapp);
}
else
{
- std::size_t nbOfSeg=std::distance(descBg,descEnd);
+ std::size_t const nbOfSeg=std::distance(descBg,descEnd);
const double *st=coords+2*(nodalBg[edgePos]);
- INTERP_KERNEL::Node *st0=new INTERP_KERNEL::Node(st[0],st[1]);
+ auto *st0=new INTERP_KERNEL::Node(st[0],st[1]);
const double *endd=coords+2*(nodalBg[(edgePos+1)%nbOfSeg]);
- INTERP_KERNEL::Node *endd0=new INTERP_KERNEL::Node(endd[0],endd[1]);
+ auto *endd0=new INTERP_KERNEL::Node(endd[0],endd[1]);
const double *middle=coords+2*(nodalBg[edgePos+nbOfSeg]);
- INTERP_KERNEL::Node *middle0=new INTERP_KERNEL::Node(middle[0],middle[1]);
+ auto *middle0=new INTERP_KERNEL::Node(middle[0],middle[1]);
EdgeLin *e1,*e2;
e1=new EdgeLin(st0,middle0);
e2=new EdgeLin(middle0,endd0);
- SegSegIntersector inters(*e1,*e2);
- bool colinearity=inters.areColinears();
+ SegSegIntersector const inters(*e1,*e2);
+ bool const colinearity=inters.areColinears();
delete e1; delete e2;
//
- bool direct=descBg[edgePos]>0;
- mcIdType edgeId=std::abs(descBg[edgePos])-1;
+ bool const direct=descBg[edgePos]>0;
+ mcIdType const edgeId=std::abs(descBg[edgePos])-1;
const std::vector<mcIdType>& subEdge=intersectEdges[edgeId];
- std::size_t nbOfSubEdges=subEdge.size()/2;
+ std::size_t const nbOfSubEdges=subEdge.size()/2;
if(colinearity)
{
for(std::size_t j=0;j<nbOfSubEdges;j++)
- appendSubEdgeFromCrudeDataArray(0,j,direct,edgeId,subEdge,mapp);
+ appendSubEdgeFromCrudeDataArray(nullptr,j,direct,edgeId,subEdge,mapp);
}
else
{
}
}
-void QuadraticPolygon::appendSubEdgeFromCrudeDataArray(Edge *baseEdge, std::size_t j, bool direct, mcIdType edgeId, const std::vector<mcIdType>& subEdge, const std::map<mcIdType,INTERP_KERNEL::Node *>& mapp)
+void QuadraticPolygon::appendSubEdgeFromCrudeDataArray(Edge *baseEdge, std::size_t j, bool direct, mcIdType /*edgeId*/, const std::vector<mcIdType>& subEdge, const std::map<mcIdType,INTERP_KERNEL::Node *>& mapp)
{
- std::size_t nbOfSubEdges=subEdge.size()/2;
+ std::size_t const nbOfSubEdges=subEdge.size()/2;
if(!baseEdge)
{//it is not a quadratic subedge
Node *start=(*mapp.find(direct?subEdge[2*j]:subEdge[2*nbOfSubEdges-2*j-1])).second;
Node *start=(*mapp.find(direct?subEdge[2*j]:subEdge[2*nbOfSubEdges-2*j-1])).second;
Node *end=(*mapp.find(direct?subEdge[2*j+1]:subEdge[2*nbOfSubEdges-2*j-2])).second;
Edge *ee=baseEdge->buildEdgeLyingOnMe(start,end);
- ElementaryEdge *eee=new ElementaryEdge(ee,true);
+ auto *eee=new ElementaryEdge(ee,true);
pushBack(eee);
}
}
const std::vector< std::vector<mcIdType> >& colinear1,
std::map<mcIdType,std::vector<INTERP_KERNEL::ElementaryEdge *> >& alreadyExistingIn2)
{
- std::size_t nbOfSeg=std::distance(descBg,descEnd);
+ std::size_t const nbOfSeg=std::distance(descBg,descEnd);
for(std::size_t i=0;i<nbOfSeg;i++)//loop over all edges of pol2
{
- bool direct=descBg[i]>0;
- mcIdType edgeId=std::abs(descBg[i])-1;//current edge id of pol2
+ bool const direct=descBg[i]>0;
+ mcIdType const edgeId=std::abs(descBg[i])-1;//current edge id of pol2
std::map<mcIdType,std::vector<INTERP_KERNEL::ElementaryEdge *> >::const_iterator it1=alreadyExistingIn2.find(descBg[i]),it2=alreadyExistingIn2.find(-descBg[i]);
if(it1!=alreadyExistingIn2.end() || it2!=alreadyExistingIn2.end())
{
- bool sameDir=(it1!=alreadyExistingIn2.end());
+ bool const sameDir=(it1!=alreadyExistingIn2.end());
const std::vector<INTERP_KERNEL::ElementaryEdge *>& edgesAlreadyBuilt=sameDir?(*it1).second:(*it2).second;
if(sameDir)
{
- for(std::vector<INTERP_KERNEL::ElementaryEdge *>::const_iterator it3=edgesAlreadyBuilt.begin();it3!=edgesAlreadyBuilt.end();it3++)
+ for(auto it3 : edgesAlreadyBuilt)
{
- Edge *ee=(*it3)->getPtr(); ee->incrRef();
- pushBack(new ElementaryEdge(ee,(*it3)->getDirection()));
+ Edge *ee=it3->getPtr(); ee->incrRef();
+ pushBack(new ElementaryEdge(ee,it3->getDirection()));
}
}
else
{
- for(std::vector<INTERP_KERNEL::ElementaryEdge *>::const_reverse_iterator it4=edgesAlreadyBuilt.rbegin();it4!=edgesAlreadyBuilt.rend();it4++)
+ for(auto it4=edgesAlreadyBuilt.rbegin();it4!=edgesAlreadyBuilt.rend();it4++)
{
Edge *ee=(*it4)->getPtr(); ee->incrRef();
pushBack(new ElementaryEdge(ee,!(*it4)->getDirection()));
if(!directos)
{// if the current edge of pol2 has one or more colinear edges part into pol1
const std::vector<mcIdType>& c=colinear1[edgeId];
- std::size_t nbOfEdgesIn1=std::distance(descBg1,descEnd1);
+ std::size_t const nbOfEdgesIn1=std::distance(descBg1,descEnd1);
for(std::size_t j=0;j<nbOfEdgesIn1;j++)
{
- mcIdType edgeId1=std::abs(descBg1[j])-1;
+ mcIdType const edgeId1=std::abs(descBg1[j])-1;
if(std::find(c.begin(),c.end(),edgeId1)!=c.end())
{
idIns1.push_back(std::pair<mcIdType,std::pair<bool,mcIdType> >(edgeId1,std::pair<bool,mcIdType>(descBg1[j]>0,offset1)));// it exists an edge into pol1 given by tuple (idIn1,direct1) that is colinear at edge 'edgeId' in pol2
}
if(directos)
{//no subpart of edge 'edgeId' of pol2 is in pol1 so let's operate the same thing that QuadraticPolygon::buildFromCrudeDataArray method
- std::size_t oldSz=_sub_edges.size();
+ std::size_t const oldSz=_sub_edges.size();
appendEdgeFromCrudeDataArray(i,mapp,isQuad,nodalBg,coords,descBg,descEnd,intersectEdges2);
- std::size_t newSz=_sub_edges.size();
- std::size_t zeSz=newSz-oldSz;
+ std::size_t const newSz=_sub_edges.size();
+ std::size_t const zeSz=newSz-oldSz;
alreadyExistingIn2[descBg[i]].resize(zeSz);
std::list<ElementaryEdge *>::const_reverse_iterator it5=_sub_edges.rbegin();
for(std::size_t p=0;p<zeSz;p++,it5++)
else
{//there is subpart of edge 'edgeId' of pol2 inside pol1
const std::vector<mcIdType>& subEdge=intersectEdges2[edgeId];
- std::size_t nbOfSubEdges=subEdge.size()/2;
+ std::size_t const nbOfSubEdges=subEdge.size()/2;
for(std::size_t j=0;j<nbOfSubEdges;j++)
{
- mcIdType idBg=direct?subEdge[2*j]:subEdge[2*nbOfSubEdges-2*j-1];
- mcIdType idEnd=direct?subEdge[2*j+1]:subEdge[2*nbOfSubEdges-2*j-2];
+ mcIdType const idBg=direct?subEdge[2*j]:subEdge[2*nbOfSubEdges-2*j-1];
+ mcIdType const idEnd=direct?subEdge[2*j+1]:subEdge[2*nbOfSubEdges-2*j-2];
bool direction11=false,found=false;
bool direct1=false;//store if needed the direction in 1
mcIdType offset2=0;
mcIdType nbOfSubEdges1=0;
for(std::vector<std::pair<mcIdType,std::pair<bool,mcIdType> > >::const_iterator it=idIns1.begin();it!=idIns1.end() && !found;it++)
{
- mcIdType idIn1=(*it).first;//store if needed the cell id in 1
+ mcIdType const idIn1=(*it).first;//store if needed the cell id in 1
direct1=(*it).second.first;
offset1=(*it).second.second;
const std::vector<mcIdType>& subEdge1PossiblyAlreadyIn1=intersectEdges1[idIn1];
ElementaryEdge *e=pol1[FromIdType<int>(offset1+(direct1?offset2:nbOfSubEdges1-offset2-1))];
Edge *ee=e->getPtr();
ee->incrRef();
- ElementaryEdge *e2=new ElementaryEdge(ee,!(direct1^direction11));
+ auto *e2=new ElementaryEdge(ee,!(direct1^direction11));
pushBack(e2);
alreadyExistingIn2[descBg[i]].push_back(e2);
}
const INTERP_KERNEL::QuadraticPolygon& pol1, const mcIdType *descBg1, const mcIdType *descEnd1,
const std::vector<std::vector<mcIdType> >& intersectEdges1, const std::vector< std::vector<mcIdType> >& colinear1) const
{
- std::size_t nbOfSeg=std::distance(descBg,descEnd);
+ std::size_t const nbOfSeg=std::distance(descBg,descEnd);
for(std::size_t i=0;i<nbOfSeg;i++)//loop over all edges of pol2
{
- bool direct=descBg[i]>0;
- mcIdType edgeId=std::abs(descBg[i])-1;//current edge id of pol2
+ bool const direct=descBg[i]>0;
+ mcIdType const edgeId=std::abs(descBg[i])-1;//current edge id of pol2
const std::vector<mcIdType>& c=colinear1[edgeId];
if(c.empty())
continue;
const std::vector<mcIdType>& subEdge=intersectEdges[edgeId];
- std::size_t nbOfSubEdges=subEdge.size()/2;
+ std::size_t const nbOfSubEdges=subEdge.size()/2;
//
- std::size_t nbOfEdgesIn1=std::distance(descBg1,descEnd1);
+ std::size_t const nbOfEdgesIn1=std::distance(descBg1,descEnd1);
mcIdType offset1=0;
for(std::size_t j=0;j<nbOfEdgesIn1;j++)
{
- mcIdType edgeId1=std::abs(descBg1[j])-1;
+ mcIdType const edgeId1=std::abs(descBg1[j])-1;
if(std::find(c.begin(),c.end(),edgeId1)!=c.end())
{
for(std::size_t k=0;k<nbOfSubEdges;k++)
{
- mcIdType idBg=direct?subEdge[2*k]:subEdge[2*nbOfSubEdges-2*k-1];
- mcIdType idEnd=direct?subEdge[2*k+1]:subEdge[2*nbOfSubEdges-2*k-2];
- mcIdType idIn1=edgeId1;
- bool direct1=descBg1[j]>0;
+ mcIdType const idBg=direct?subEdge[2*k]:subEdge[2*nbOfSubEdges-2*k-1];
+ mcIdType const idEnd=direct?subEdge[2*k+1]:subEdge[2*nbOfSubEdges-2*k-2];
+ mcIdType const idIn1=edgeId1;
+ bool const direct1=descBg1[j]>0;
const std::vector<mcIdType>& subEdge1PossiblyAlreadyIn1=intersectEdges1[idIn1];
- mcIdType nbOfSubEdges1=ToIdType(subEdge1PossiblyAlreadyIn1.size()/2);
+ mcIdType const nbOfSubEdges1=ToIdType(subEdge1PossiblyAlreadyIn1.size()/2);
mcIdType offset2=0;
bool found=false;
for(mcIdType kk=0;kk<nbOfSubEdges1 && !found;kk++)
void QuadraticPolygon::appendCrudeData(const std::map<INTERP_KERNEL::Node *,mcIdType>& mapp, double xBary, double yBary, double fact, mcIdType offset, std::vector<double>& addCoordsQuadratic, std::vector<mcIdType>& conn, std::vector<mcIdType>& connI) const
{
int nbOfNodesInPg=0;
- bool presenceOfQuadratic=presenceOfQuadraticEdge();
+ bool const presenceOfQuadratic=presenceOfQuadraticEdge();
conn.push_back(presenceOfQuadratic?NORM_QPOLYG:NORM_POLYGON);
- for(std::list<ElementaryEdge *>::const_iterator it=_sub_edges.begin();it!=_sub_edges.end();it++)
+ for(auto _sub_edge : _sub_edges)
{
- Node *tmp=0;
- tmp=(*it)->getStartNode();
- std::map<INTERP_KERNEL::Node *,mcIdType>::const_iterator it1=mapp.find(tmp);
+ Node *tmp=nullptr;
+ tmp=_sub_edge->getStartNode();
+ auto const it1=mapp.find(tmp);
conn.push_back((*it1).second);
nbOfNodesInPg++;
}
if(presenceOfQuadratic)
{
int j=0;
- mcIdType off=offset+ToIdType(addCoordsQuadratic.size())/2;
- for(std::list<ElementaryEdge *>::const_iterator it=_sub_edges.begin();it!=_sub_edges.end();it++,j++,nbOfNodesInPg++)
+ mcIdType const off=offset+ToIdType(addCoordsQuadratic.size())/2;
+ for(auto it=_sub_edges.begin();it!=_sub_edges.end();it++,j++,nbOfNodesInPg++)
{
INTERP_KERNEL::Node *node=(*it)->getPtr()->buildRepresentantOfMySelf();
node->unApplySimilarity(xBary,yBary,fact);
std::vector<mcIdType>& nbThis, std::vector<mcIdType>& nbOther)
{
double xBaryBB, yBaryBB;
- double fact=normalizeExt(&other, xBaryBB, yBaryBB);
+ double const fact=normalizeExt(&other, xBaryBB, yBaryBB);
//Locate \a this relative to \a other (edges of \a this, aka \a pol1 are marked as IN or OUT)
other.performLocatingOperationSlow(*this); // without any assumption
- std::vector<QuadraticPolygon *> res=buildIntersectionPolygons(*this,other);
- for(std::vector<QuadraticPolygon *>::iterator it=res.begin();it!=res.end();it++)
+ std::vector<QuadraticPolygon *> const res=buildIntersectionPolygons(*this,other);
+ for(auto & re : res)
{
- (*it)->appendCrudeData(mapp,xBaryBB,yBaryBB,fact,offset,addCoordsQuadratic,conn,connI);
- INTERP_KERNEL::IteratorOnComposedEdge it1(*it);
+ re->appendCrudeData(mapp,xBaryBB,yBaryBB,fact,offset,addCoordsQuadratic,conn,connI);
+ INTERP_KERNEL::IteratorOnComposedEdge it1(re);
for(it1.first();!it1.finished();it1.next())
{
Edge *e=it1.current()->getPtr();
}
nbThis.push_back(idThis);
nbOther.push_back(idOther);
- delete *it;
+ delete re;
}
unApplyGlobalSimilarityExt(other,xBaryBB,yBaryBB,fact);
}
void QuadraticPolygon::cleanDegeneratedConsecutiveEdges()
{
IteratorOnComposedEdge it(this);
- ElementaryEdge * prevEdge = 0;
+ ElementaryEdge * prevEdge = nullptr;
if (recursiveSize() > 2)
for(it.first();!it.finished();it.next())
{
double QuadraticPolygon::intersectWithAbs1D(QuadraticPolygon& other, bool& isColinear)
{
double ret = 0., xBaryBB, yBaryBB;
- double fact = normalize(&other, xBaryBB, yBaryBB);
+ double const fact = normalize(&other, xBaryBB, yBaryBB);
QuadraticPolygon cpyOfThis(*this);
QuadraticPolygon cpyOfOther(other);
{
double ret=0.,bary[2],area,xBaryBB,yBaryBB;
barycenter[0] = barycenter[1] = 0.;
- double fact=normalize(&other,xBaryBB,yBaryBB);
- std::vector<QuadraticPolygon *> polygs=intersectMySelfWith(other);
- for(std::vector<QuadraticPolygon *>::iterator iter=polygs.begin();iter!=polygs.end();iter++)
+ double const fact=normalize(&other,xBaryBB,yBaryBB);
+ std::vector<QuadraticPolygon *> const polygs=intersectMySelfWith(other);
+ for(auto & polyg : polygs)
{
- area=fabs((*iter)->getArea());
- (*iter)->getBarycenter(bary);
- delete *iter;
+ area=fabs(polyg->getArea());
+ polyg->getBarycenter(bary);
+ delete polyg;
ret+=area;
barycenter[0] += bary[0]*area;
barycenter[1] += bary[1]*area;
double QuadraticPolygon::intersectWith(const QuadraticPolygon& other) const
{
double ret=0.;
- std::vector<QuadraticPolygon *> polygs=intersectMySelfWith(other);
- for(std::vector<QuadraticPolygon *>::iterator iter=polygs.begin();iter!=polygs.end();iter++)
+ std::vector<QuadraticPolygon *> const polygs=intersectMySelfWith(other);
+ for(auto & polyg : polygs)
{
- ret+=fabs((*iter)->getArea());
- delete *iter;
+ ret+=fabs(polyg->getArea());
+ delete polyg;
}
return ret;
}
{
double ret=0., bary[2];
barycenter[0] = barycenter[1] = 0.;
- std::vector<QuadraticPolygon *> polygs=intersectMySelfWith(other);
- for(std::vector<QuadraticPolygon *>::iterator iter=polygs.begin();iter!=polygs.end();iter++)
+ std::vector<QuadraticPolygon *> const polygs=intersectMySelfWith(other);
+ for(auto & polyg : polygs)
{
- double area = fabs((*iter)->getArea());
- (*iter)->getBarycenter(bary);
- delete *iter;
+ double const area = fabs(polyg->getArea());
+ polyg->getBarycenter(bary);
+ delete polyg;
ret+=area;
barycenter[0] += bary[0]*area;
barycenter[1] += bary[1]*area;
{
IteratorOnComposedEdge it1(&pol1),it2(&pol2);
MergePoints merge;
- ComposedEdge *c1=new ComposedEdge;
- ComposedEdge *c2=new ComposedEdge;
+ auto *c1=new ComposedEdge;
+ auto *c2=new ComposedEdge;
for(it2.first();!it2.finished();it2.next())
{
ElementaryEdge* curE2=it2.current();
{
std::list<QuadraticPolygon *> ret;
IteratorOnComposedEdge it(const_cast<QuadraticPolygon *>(this));
- int nbOfTurns=recursiveSize();
+ int const nbOfTurns=recursiveSize();
int i=0;
if(!it.goToNextInOn(false,i,nbOfTurns))
return ret;
//
while(i<nbOfTurns)
{
- QuadraticPolygon *tmp1=new QuadraticPolygon;
+ auto *tmp1=new QuadraticPolygon;
TypeOfEdgeLocInPolygon loc=it.current()->getLoc();
while(loc!=FULL_OUT_1 && i<nbOfTurns)
{
bool directionKnownInPol2=false;
bool directionInPol2=false;
bool needCleaning = false;
- for(std::list<QuadraticPolygon *>::iterator iter=pol1Zip.begin();iter!=pol1Zip.end();)
+ for(auto iter=pol1Zip.begin();iter!=pol1Zip.end();)
{
// Build incrementally the full closed cells from the consecutive line parts already built in pol1Zip.
// At the end of the process the item currently iterated has been totally completed (start_node=end_node)
else
directionKnownInPol2=true;
}
- std::list<QuadraticPolygon *>::iterator iter2=iter; iter2++;
+ auto iter2=iter; iter2++;
// Fill as much as possible the current iterate (=a part of pol1) with consecutive pieces from pol2:
- std::list<QuadraticPolygon *>::iterator iter3=(*iter)->fillAsMuchAsPossibleWith(pol2,iter2,pol1Zip.end(),directionInPol2);
+ auto const iter3=(*iter)->fillAsMuchAsPossibleWith(pol2,iter2,pol1Zip.end(),directionInPol2);
// and now add a full connected piece from pol1Zip:
if(iter3!=pol1Zip.end())
{
it2.nextLoop();
cur=it2.current();
Node *repr=cur->getPtr()->buildRepresentantOfMySelf();
- bool ret=pol1NotSplitted.isInOrOut(repr);
+ bool const ret=pol1NotSplitted.isInOrOut(repr);
repr->decrRef();
direction = ret;
needCleaning = ret; // if true we are in tricky case 2 above, we know that we will produce two consecutive overlapping edges in result
else // here we don't need to go prev or next:
{
Node *repr=cur->getPtr()->buildRepresentantOfMySelf();
- bool ret=pol1NotSplitted.isInOrOut(repr);
+ bool const ret=pol1NotSplitted.isInOrOut(repr);
repr->decrRef();
direction = ret;
return ret;
std::list<QuadraticPolygon *>::iterator QuadraticPolygon::CheckInList(Node *n, std::list<QuadraticPolygon *>::iterator iStart,
std::list<QuadraticPolygon *>::iterator iEnd)
{
- for(std::list<QuadraticPolygon *>::iterator iter=iStart;iter!=iEnd;iter++)
+ for(auto iter=iStart;iter!=iEnd;iter++)
if((*iter)->isNodeIn(n))
return iter;
return iEnd;
{
// Initialise locations on pol1. Remember that edges found in 'notUsedInPol1' are also part of the edges forming pol1.
pol1.initLocations();
- for(std::set<Edge *>::const_iterator it1=notUsedInPol1.begin();it1!=notUsedInPol1.end();it1++)
- { (*it1)->initLocs(); (*it1)->declareOn(); }
- for(std::set<Edge *>::const_iterator it2=edgesInPol2OnBoundary.begin();it2!=edgesInPol2OnBoundary.end();it2++)
- { (*it2)->initLocs(); (*it2)->declareIn(); }
+ for(auto it1 : notUsedInPol1)
+ { it1->initLocs(); it1->declareOn(); }
+ for(auto it2 : edgesInPol2OnBoundary)
+ { it2->initLocs(); it2->declareIn(); }
////
std::set<Edge *> notUsedInPol1L(notUsedInPol1);
IteratorOnComposedEdge itPol1(const_cast<QuadraticPolygon *>(&pol1));
- int sz=pol1.size();
+ int const sz=pol1.size();
std::list<QuadraticPolygon *> pol1Zip;
// If none of the edges of pol1 was consumed by the rebuilding process, we can directly take pol1 as it is to form a cell:
if(pol1.size()==(int)notUsedInPol1.size() && edgesInPol2OnBoundary.empty())
itPol1.nextLoop();
if(itPol1.current()->getStartNode()->getLoc()!=IN_1 || itPol1.current()->getLoc()!=FULL_ON_1)
throw INTERP_KERNEL::Exception("Presence of a target polygon fully included in source polygon ! The partition of this leads to a non simply connex cell (with hole) ! Impossible ! Such resulting cell cannot be stored in MED cell format !");
- QuadraticPolygon *tmp1=new QuadraticPolygon;
+ auto *tmp1=new QuadraticPolygon;
do
{
Edge *ee=itPol1.current()->getPtr();
while(nbOfTurn<maxNbOfTurn) // the 'normal' way out of this loop is the break towards the end when pol1Zip is empty.
{
// retPolsUnderConstruction initially empty -> see if(!pol1Zip.empty()) below ...
- for(std::list<QuadraticPolygon *>::iterator itConstr=retPolsUnderContruction.begin();itConstr!=retPolsUnderContruction.end();)
+ for(auto itConstr=retPolsUnderContruction.begin();itConstr!=retPolsUnderContruction.end();)
{
Node *startN = (*itConstr)->getStartNode();
Node *curN = (*itConstr)->getEndNode();
bool smthHappened=false, doneEarly=false;
// Complete a partially reconstructed polygon with boundary edges of pol2 by matching nodes:
- for(std::list<Edge *>::iterator it2=edgesInPol2OnBoundaryL.begin();it2!=edgesInPol2OnBoundaryL.end();)
+ for(auto it2=edgesInPol2OnBoundaryL.begin();it2!=edgesInPol2OnBoundaryL.end();)
{
if(curN==(*it2)->getEndNode()) // only end node should be considered if orientation is correct for input meshes
// in the funny case of cells exactly included (see test case testIntersect2DMeshesTmp13) this is mandatory to take edges from pol2 in the right order.
// Be somewhat flexible and keep on supporting this case here (useful for voronisation notably):
if(!smthHappened)
{
- for(std::list<Edge *>::iterator it2=edgesInPol2OnBoundaryL.begin();it2!=edgesInPol2OnBoundaryL.end();)
+ for(auto it2=edgesInPol2OnBoundaryL.begin();it2!=edgesInPol2OnBoundaryL.end();)
{
if(curN==(*it2)->getStartNode())
{
if(smthHappened) // Now continue the construction by finding the next bit in pol1Zip. Not too sure what are the cases where the boolean if False ...
{
- for(std::list<QuadraticPolygon *>::iterator itZip=pol1Zip.begin();itZip!=pol1Zip.end();)
+ for(auto itZip=pol1Zip.begin();itZip!=pol1Zip.end();)
{
if(curN==(*itZip)->getStartNode()) // we found a matching piece to append in pol1Zip. Append all of it to the current polygon being reconstr
{
for(std::list<ElementaryEdge *>::const_iterator it4=(*itZip)->_sub_edges.begin();it4!=(*itZip)->_sub_edges.end();it4++)
- { (*it4)->getPtr()->incrRef(); bool dir=(*it4)->getDirection(); (*itConstr)->pushBack(new ElementaryEdge((*it4)->getPtr(),dir)); }
+ { (*it4)->getPtr()->incrRef(); bool const dir=(*it4)->getDirection(); (*itConstr)->pushBack(new ElementaryEdge((*it4)->getPtr(),dir)); }
pol1ZipConsumed[*itConstr].push_back(*itZip);
curN=(*itZip)->getEndNode();
itZip=pol1Zip.erase(itZip); // one zipped piece has been consumed
if(edgesInPol2OnBoundary.find(ee)!=edgesInPol2OnBoundary.end())
edgesInPol2OnBoundaryL.push_back(ee);
}
- for(std::list<QuadraticPolygon *>::iterator it6=pol1ZipConsumed[*itConstr].begin();it6!=pol1ZipConsumed[*itConstr].end();it6++)
- pol1Zip.push_front(*it6);
+ for(auto & it6 : pol1ZipConsumed[*itConstr])
+ pol1Zip.push_front(it6);
pol1ZipConsumed.erase(*itConstr);
delete *itConstr;
itConstr=retPolsUnderContruction.erase(itConstr);
}
if(!pol1Zip.empty()) // the filling process of retPolsUnderConstruction starts here
{
- QuadraticPolygon *tmp=new QuadraticPolygon;
+ auto *tmp=new QuadraticPolygon;
QuadraticPolygon *first=*(pol1Zip.begin());
for(std::list<ElementaryEdge *>::const_iterator it4=first->_sub_edges.begin();it4!=first->_sub_edges.end();it4++)
- { (*it4)->getPtr()->incrRef(); bool dir=(*it4)->getDirection(); tmp->pushBack(new ElementaryEdge((*it4)->getPtr(),dir)); }
+ { (*it4)->getPtr()->incrRef(); bool const dir=(*it4)->getDirection(); tmp->pushBack(new ElementaryEdge((*it4)->getPtr(),dir)); }
pol1ZipConsumed[tmp].push_back(first);
retPolsUnderContruction.push_back(tmp);
pol1Zip.erase(pol1Zip.begin());
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
// Convert to integer connectivity:
- for(std::list<QuadraticPolygon *>::iterator itConstr=retPolsUnderContruction.begin();itConstr!=retPolsUnderContruction.end();itConstr++)
+ for(auto & itConstr : retPolsUnderContruction)
{
- if((*itConstr)->getStartNode()==(*itConstr)->getEndNode()) // take only fully closed reconstructed polygon
+ if(itConstr->getStartNode()==itConstr->getEndNode()) // take only fully closed reconstructed polygon
{
- (*itConstr)->cleanDegeneratedConsecutiveEdges();
- (*itConstr)->appendCrudeData(mapp,0.,0.,1.,offset,addCoordsQuadratic,conn,connI); nb1.push_back(idThis); nb2.push_back(-1);
- for(std::list<QuadraticPolygon *>::iterator it6=pol1ZipConsumed[*itConstr].begin();it6!=pol1ZipConsumed[*itConstr].end();it6++)
- delete *it6;
- delete *itConstr;
+ itConstr->cleanDegeneratedConsecutiveEdges();
+ itConstr->appendCrudeData(mapp,0.,0.,1.,offset,addCoordsQuadratic,conn,connI); nb1.push_back(idThis); nb2.push_back(-1);
+ for(auto & it6 : pol1ZipConsumed[itConstr])
+ delete it6;
+ delete itConstr;
}
else
{
#include "InterpKernelGeo2DComposedEdge.hxx"
#include "InterpKernelGeo2DAbstractEdge.hxx"
#include "InterpKernelGeo2DElementaryEdge.hxx"
+#include "MCIdType.hxx"
+#include <cstddef>
#include <list>
+#include <utility>
+#include <map>
+#include <set>
+#include <ostream>
#include <vector>
namespace INTERP_KERNEL
class MergePoints;
enum NodeUsage { USAGE_UNKNOWN, USAGE_LINEAR, USAGE_QUADRATIC_ONLY };
- typedef std::pair<INTERP_KERNEL::Node *,NodeUsage> NodeWithUsage;
+ using NodeWithUsage = std::pair<INTERP_KERNEL::Node *, NodeUsage>;
/**
* A set of quadratic or linear edges, not necessarily connected to form a closed polygon.
class QuadraticPolygon : public ComposedEdge
{
public:
- INTERPKERNEL_EXPORT QuadraticPolygon() { }
- INTERPKERNEL_EXPORT QuadraticPolygon(const QuadraticPolygon& other):ComposedEdge(other) { }
+ INTERPKERNEL_EXPORT QuadraticPolygon() = default;
+ INTERPKERNEL_EXPORT QuadraticPolygon(const QuadraticPolygon& other) = default;
INTERPKERNEL_EXPORT QuadraticPolygon(const char *fileName);
INTERPKERNEL_EXPORT static QuadraticPolygon *BuildLinearPolygon(std::vector<Node *>& nodes);
INTERPKERNEL_EXPORT static QuadraticPolygon *BuildArcCirclePolygon(std::vector<Node *>& nodes);
namespace INTERP_KERNEL
{
template<class EDGES>
- void QuadraticPolygon::UpdateNeighbours(const MergePoints& merger, IteratorOnComposedEdge it1, IteratorOnComposedEdge it2,
+ void QuadraticPolygon::UpdateNeighbours(const MergePoints& /*merger*/, IteratorOnComposedEdge it1, IteratorOnComposedEdge it2,
const EDGES *e1, const EDGES *e2)
{
it1.previousLoop(); it2.previousLoop();
#ifndef __GEOMETRIC2DINTERSECTOR_HXX__
#define __GEOMETRIC2DINTERSECTOR_HXX__
-#include "PlanarIntersectorP0P0.hxx"
-#include "PlanarIntersectorP0P1.hxx"
-#include "PlanarIntersectorP1P0.hxx"
-#include "PlanarIntersectorP1P1.hxx"
-#include "PlanarIntersectorP1P0Bary.hxx"
-#include "PlanarIntersectorP0P1Bary.hxx"
+#include "NormalizedUnstructuredMesh.hxx"
+#include "NormalizedGeometricTypes"
+#include "InterpKernelGeo2DPrecision.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
public:
static const int SPACEDIM=MyMeshType::MY_SPACEDIM;
static const int MESHDIM=MyMeshType::MY_MESHDIM;
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
public:
Geometric2DIntersector(const MyMeshType& meshT, const MyMeshType& meshS,
#define __GEOMETRIC2DINTERSECTOR_TXX__
#include "Geometric2DIntersector.hxx"
+#include "PlanarIntersector.txx"
#include "PlanarIntersectorP0P0.txx"
#include "Planar2D1DIntersectorP0P0.txx"
#include "PlanarIntersectorP0P1.txx"
#include "PlanarIntersectorP1P1.txx"
#include "PlanarIntersectorP1P0Bary.txx"
#include "PlanarIntersectorP0P1Bary.txx"
+#include "InterpolationUtils.hxx"
#include "CellModel.hxx"
+#include "NormalizedGeometricTypes"
#include "InterpKernelGeo2DQuadraticPolygon.hxx"
#include "InterpKernelGeo2DEdgeArcCircle.hxx"
#include "InterpKernelGeo2DEdgeLin.hxx"
#include "InterpKernelGeo2DNode.hxx"
+#include <vector>
+#include <cstddef>
+#include <limits>
+
+
#define GEO2D_INTERSECTOR Geometric2DIntersector<MyMeshType,MyMatrix,InterpType>
#define INTERSECTOR_TEMPLATE template<class MyMeshType, class MyMatrix, template <class MeshType, class TheMatrix, class ThisIntersector> class InterpType>
#ifndef __INTEGRALUNIFORMINTERSECTOR_HXX__
#define __INTEGRALUNIFORMINTERSECTOR_HXX__
-#include "TargetIntersector.txx"
+#include "TargetIntersector.hxx"
#include <cmath>
+#include <vector>
namespace INTERP_KERNEL
{
class IntegralUniformIntersector : public TargetIntersector<MyMeshType,MyMatrix>
{
public:
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
public:
IntegralUniformIntersector(const MyMeshType& mesh, bool isAbs);
double performNormalization(double val) const { if(_is_abs) return fabs(val); else return val; }
class IntegralUniformIntersectorP0 : public IntegralUniformIntersector<MyMeshType,MyMatrix>
{
public:
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
public:
IntegralUniformIntersectorP0(const MyMeshType& mesh, bool isAbs);
ConnType getNumberOfRowsOfResMatrix() const;
class IntegralUniformIntersectorP1 : public IntegralUniformIntersector<MyMeshType,MyMatrix>
{
public:
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
public:
IntegralUniformIntersectorP1(const MyMeshType& mesh, bool isAbs);
ConnType getNumberOfRowsOfResMatrix() const;
#define __INTEGRALUNIFORMINTERSECTOR_TXX__
#include "IntegralUniformIntersector.hxx"
+#include "NormalizedGeometricTypes"
+#include "NormalizedUnstructuredMesh.hxx"
+#include "InterpolationUtils.hxx"
#include "VolSurfUser.txx"
+#include <vector>
namespace INTERP_KERNEL
{
}
template<class MyMeshType, class MyMatrix>
- void IntegralUniformIntersectorP0<MyMeshType,MyMatrix>::intersectCells(ConnType targetCell, const std::vector<ConnType>& srcCells, MyMatrix& res)
+ void IntegralUniformIntersectorP0<MyMeshType,MyMatrix>::intersectCells(ConnType /*targetCell*/, const std::vector<ConnType>& /*srcCells*/, MyMatrix& res)
{
static const NumberingPolicy numPol=MyMeshType::My_numPol;
res.resize(getNumberOfRowsOfResMatrix());
}
template<class MyMeshType, class MyMatrix>
- void IntegralUniformIntersectorP1<MyMeshType,MyMatrix>::intersectCells(ConnType targetCell, const std::vector<ConnType>& srcCells, MyMatrix& res)
+ void IntegralUniformIntersectorP1<MyMeshType,MyMatrix>::intersectCells(ConnType /*targetCell*/, const std::vector<ConnType>& /*srcCells*/, MyMatrix& res)
{
static const NumberingPolicy numPol=MyMeshType::My_numPol;
res.resize(getNumberOfRowsOfResMatrix());
#include "InterpKernelCellSimplify.hxx"
#include "CellModel.hxx"
+#include "NormalizedGeometricTypes"
+#include "MCIdType.hxx"
+#include "InterpKernelException.hxx"
#include <functional>
#include <algorithm>
#include <iterator>
-#include <sstream>
-#include <numeric>
#include <cstring>
-#include <limits>
+#include <utility>
#include <vector>
-#include <list>
#include <set>
using namespace INTERP_KERNEL;
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
std::set<mcIdType> c(conn,conn+lgth);
c.erase(-1);
- bool isObviousNonDegeneratedCell=(ToIdType(c.size())==lgth);
+ bool const isObviousNonDegeneratedCell=(ToIdType(c.size())==lgth);
if((cm.getDimension()==3 && cm.isQuadratic()) || isObviousNonDegeneratedCell)
{//quadratic 3D, do nothing for the moment.
retLgth=lgth;
- mcIdType *tmp=new mcIdType[lgth];//no direct std::copy ! overlapping of conn and retConn !
+ auto *tmp=new mcIdType[lgth];//no direct std::copy ! overlapping of conn and retConn !
std::copy(conn,conn+lgth,tmp);
std::copy(tmp,tmp+lgth,retConn);
delete [] tmp;
}
if(cm.getDimension()==2)
{
- mcIdType *tmp=new mcIdType[lgth];
+ auto *tmp=new mcIdType[lgth];
int newPos=0;
if(!cm.isQuadratic())
{
}
else
{
- mcIdType quadOff = lgth/2;
- mcIdType *tmpQuad = new mcIdType[quadOff];
+ mcIdType const quadOff = lgth/2;
+ auto *tmpQuad = new mcIdType[quadOff];
for(int i = 0; i < quadOff; i++)
if(conn[i] != conn[(i+1)%quadOff] || conn[i] != conn[i+quadOff]) // zip nul segments/arcs (quad point must match too)
{
delete [] tmpQuad;
newPos *= 2; // take in quad points in the final length
}
- INTERP_KERNEL::NormalizedCellType ret=tryToUnPoly2D(cm.isQuadratic(),tmp,newPos,retConn,retLgth);
+ INTERP_KERNEL::NormalizedCellType const ret=tryToUnPoly2D(cm.isQuadratic(),tmp,newPos,retConn,retLgth);
delete [] tmp;
return ret;
}
{
mcIdType nbOfFaces,lgthOfPolyhConn;
mcIdType *zipFullReprOfPolyh=getFullPolyh3DCell(type,conn,lgth,nbOfFaces,lgthOfPolyhConn);
- INTERP_KERNEL::NormalizedCellType ret=tryToUnPoly3D(zipFullReprOfPolyh,nbOfFaces,lgthOfPolyhConn,retConn,retLgth);
+ INTERP_KERNEL::NormalizedCellType const ret=tryToUnPoly3D(zipFullReprOfPolyh,nbOfFaces,lgthOfPolyhConn,retConn,retLgth);
delete [] zipFullReprOfPolyh;
return ret;
}
mcIdType& retNbOfFaces, mcIdType& retLgth)
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
- unsigned nbOfFaces=cm.getNumberOfSons2(conn,lgth);
- mcIdType *tmp=new mcIdType[nbOfFaces*(lgth+1)];
+ unsigned const nbOfFaces=cm.getNumberOfSons2(conn,lgth);
+ auto *tmp=new mcIdType[nbOfFaces*(lgth+1)];
mcIdType *work=tmp;
std::vector<mcIdType> faces;
for(unsigned j=0;j<nbOfFaces;j++)
{
INTERP_KERNEL::NormalizedCellType type2;
- unsigned offset=cm.fillSonCellNodalConnectivity2(j,conn,lgth,work,type2);
+ unsigned const offset=cm.fillSonCellNodalConnectivity2(j,conn,lgth,work,type2);
//
- mcIdType *tmp2=new mcIdType[offset];
+ auto *tmp2=new mcIdType[offset];
tmp2[0]=work[0];
mcIdType newPos=1;
for(unsigned k=1;k<offset;k++)
{
std::set<mcIdType> nodes(conn,conn+lgth);
nodes.erase(-1);
- std::size_t nbOfNodes=nodes.size();
- std::size_t magicNumber=100*nbOfNodes+nbOfFaces;
+ std::size_t const nbOfNodes=nodes.size();
+ std::size_t const magicNumber=100*nbOfNodes+nbOfFaces;
switch(magicNumber)
{
case 806:
bool CellSimplify::orientOppositeFace(const mcIdType *baseFace, mcIdType *retConn, const mcIdType *sideFace, mcIdType lgthBaseFace)
{
std::vector<mcIdType> tmp2;
- std::set<mcIdType> bases(baseFace,baseFace+lgthBaseFace);
- std::set<mcIdType> sides(sideFace,sideFace+4);
+ std::set<mcIdType> const bases(baseFace,baseFace+lgthBaseFace);
+ std::set<mcIdType> const sides(sideFace,sideFace+4);
std::set_intersection(bases.begin(),bases.end(),sides.begin(),sides.end(),std::back_insert_iterator< std::vector<mcIdType> >(tmp2));
if(tmp2.size()!=2)
return false;
for(int i=0;i<4;i++)
sideEdges[i]=std::pair<mcIdType,mcIdType>(sideFace[i],sideFace[(i+1)%4]);
std::vector< std::pair<mcIdType,mcIdType> > tmp;
- std::set< std::pair<mcIdType,mcIdType> > baseEdgesS(baseEdges.begin(),baseEdges.end());
- std::set< std::pair<mcIdType,mcIdType> > sideEdgesS(sideEdges.begin(),sideEdges.end());
+ std::set< std::pair<mcIdType,mcIdType> > const baseEdgesS(baseEdges.begin(),baseEdges.end());
+ std::set< std::pair<mcIdType,mcIdType> > const sideEdgesS(sideEdges.begin(),sideEdges.end());
std::set_intersection(baseEdgesS.begin(),baseEdgesS.end(),sideEdgesS.begin(),sideEdgesS.end(),std::back_insert_iterator< std::vector< std::pair<mcIdType,mcIdType> > >(tmp));
if(tmp.empty())
{
//reverse sideFace
for(int i=0;i<4;i++)
{
- std::pair<mcIdType,mcIdType> p=sideEdges[i];
- std::pair<mcIdType,mcIdType> r(p.second,p.first);
+ std::pair<mcIdType,mcIdType> const p=sideEdges[i];
+ std::pair<mcIdType,mcIdType> const r(p.second,p.first);
sideEdges[i]=r;
}
//end reverse sideFace
- std::set< std::pair<mcIdType,mcIdType> > baseEdgesS2(baseEdges.begin(),baseEdges.end());
- std::set< std::pair<mcIdType,mcIdType> > sideEdgesS2(sideEdges.begin(),sideEdges.end());
+ std::set< std::pair<mcIdType,mcIdType> > const baseEdgesS2(baseEdges.begin(),baseEdges.end());
+ std::set< std::pair<mcIdType,mcIdType> > const sideEdgesS2(sideEdges.begin(),sideEdges.end());
std::set_intersection(baseEdgesS2.begin(),baseEdgesS2.end(),sideEdgesS2.begin(),sideEdgesS2.end(),std::back_insert_iterator< std::vector< std::pair<mcIdType,mcIdType> > >(tmp));
if(tmp.empty())
return false;
}
if(!found)
return false;
- int pos=(int)std::distance(baseEdges.begin(),std::find(baseEdges.begin(),baseEdges.end(),tmp[0]));
- std::vector< std::pair<mcIdType,mcIdType> >::iterator it=std::find(oppEdges.begin(),oppEdges.end(),pInOpp);
+ int const pos=(int)std::distance(baseEdges.begin(),std::find(baseEdges.begin(),baseEdges.end(),tmp[0]));
+ auto const it=std::find(oppEdges.begin(),oppEdges.end(),pInOpp);
if(it==oppEdges.end())//the opposite edge of side face is not found opposite face ... maybe problem of orientation of polyhedron
return false;
- mcIdType pos2=ToIdType(std::distance(oppEdges.begin(),it));
+ mcIdType const pos2=ToIdType(std::distance(oppEdges.begin(),it));
mcIdType offset=pos-pos2;
if(offset<0)
offset+=lgthBaseFace;
//this is the end copy the result
- mcIdType *tmp3=new mcIdType[lgthBaseFace];
+ auto *tmp3=new mcIdType[lgthBaseFace];
for(int i=0;i<lgthBaseFace;i++)
tmp3[(offset+i)%lgthBaseFace]=oppEdges[i].first;
std::copy(tmp3,tmp3+lgthBaseFace,retConn);
return true;
}
-bool CellSimplify::isWellOriented(const mcIdType *baseFace, mcIdType *retConn, const mcIdType *sideFace, mcIdType lgthBaseFace)
+bool CellSimplify::isWellOriented(const mcIdType * /*baseFace*/, mcIdType * /*retConn*/, const mcIdType * /*sideFace*/, mcIdType /*lgthBaseFace*/)
{
return true;
}
if(std::find_if(conn+lgth,conn+lgth+nbOfFaces,std::bind(std::not_equal_to<mcIdType>(),std::placeholders::_1,ToIdType(INTERP_KERNEL::NORM_QUAD4)))==conn+lgth+nbOfFaces)
{//6 faces are QUAD4.
int oppositeFace=-1;
- std::set<mcIdType> conn1(conn,conn+4);
+ std::set<mcIdType> const conn1(conn,conn+4);
for(int i=1;i<6 && oppositeFace<0;i++)
{
std::vector<mcIdType> tmp;
- std::set<mcIdType> conn2(conn+5*i,conn+5*i+4);
+ std::set<mcIdType> const conn2(conn+5*i,conn+5*i+4);
std::set_intersection(conn1.begin(),conn1.end(),conn2.begin(),conn2.end(),std::back_insert_iterator< std::vector<mcIdType> >(tmp));
if(tmp.empty())
oppositeFace=i;
INTERP_KERNEL::NormalizedCellType CellSimplify::tryToUnPolyHexp12(const mcIdType *conn, mcIdType nbOfFaces, mcIdType lgth, mcIdType *retConn, mcIdType& retLgth)
{
- std::size_t nbOfHexagon=std::count(conn+lgth,conn+lgth+nbOfFaces,ToIdType(INTERP_KERNEL::NORM_POLYGON));
- std::size_t nbOfQuad=std::count(conn+lgth,conn+lgth+nbOfFaces,ToIdType(INTERP_KERNEL::NORM_QUAD4));
+ std::size_t const nbOfHexagon=std::count(conn+lgth,conn+lgth+nbOfFaces,ToIdType(INTERP_KERNEL::NORM_POLYGON));
+ std::size_t const nbOfQuad=std::count(conn+lgth,conn+lgth+nbOfFaces,ToIdType(INTERP_KERNEL::NORM_QUAD4));
if(nbOfQuad==6 && nbOfHexagon==2)
{
const mcIdType *hexag0=std::find(conn+lgth,conn+lgth+nbOfFaces,ToIdType(INTERP_KERNEL::NORM_POLYGON));
- std::size_t hexg0Id=std::distance(conn+lgth,hexag0);
+ std::size_t const hexg0Id=std::distance(conn+lgth,hexag0);
const mcIdType *hexag1=std::find(hexag0+1,conn+lgth+nbOfFaces,ToIdType(INTERP_KERNEL::NORM_POLYGON));
- std::size_t hexg1Id=std::distance(conn+lgth,hexag1);
+ std::size_t const hexg1Id=std::distance(conn+lgth,hexag1);
const mcIdType *connHexag0=conn+5*hexg0Id;
- std::size_t lgthH0=std::distance(connHexag0,std::find(connHexag0,conn+lgth,-1));
+ std::size_t const lgthH0=std::distance(connHexag0,std::find(connHexag0,conn+lgth,-1));
if(lgthH0==6)
{
const mcIdType *connHexag1=conn+5*hexg0Id+7+(hexg1Id-hexg0Id-1)*5;
- std::size_t lgthH1=std::distance(connHexag1,std::find(connHexag1,conn+lgth,-1));
+ std::size_t const lgthH1=std::distance(connHexag1,std::find(connHexag1,conn+lgth,-1));
if(lgthH1==6)
{
std::vector<mcIdType> tmp;
- std::set<mcIdType> conn1(connHexag0,connHexag0+6);
- std::set<mcIdType> conn2(connHexag1,connHexag1+6);
+ std::set<mcIdType> const conn1(connHexag0,connHexag0+6);
+ std::set<mcIdType> const conn2(connHexag1,connHexag1+6);
std::set_intersection(conn1.begin(),conn1.end(),conn2.begin(),conn2.end(),std::back_insert_iterator< std::vector<mcIdType> >(tmp));
if(tmp.empty())
{
*/
INTERP_KERNEL::NormalizedCellType CellSimplify::tryToUnPolyPenta6(const mcIdType *conn, mcIdType nbOfFaces, mcIdType lgth, mcIdType *retConn, mcIdType& retLgth)
{
- std::size_t nbOfTriFace=std::count(conn+lgth,conn+lgth+nbOfFaces,ToIdType(INTERP_KERNEL::NORM_TRI3));
- std::size_t nbOfQuadFace=std::count(conn+lgth,conn+lgth+nbOfFaces,ToIdType(INTERP_KERNEL::NORM_QUAD4));
+ std::size_t const nbOfTriFace=std::count(conn+lgth,conn+lgth+nbOfFaces,ToIdType(INTERP_KERNEL::NORM_TRI3));
+ std::size_t const nbOfQuadFace=std::count(conn+lgth,conn+lgth+nbOfFaces,ToIdType(INTERP_KERNEL::NORM_QUAD4));
if(nbOfTriFace==2 && nbOfQuadFace==3)
{
- std::size_t tri3_0=std::distance(conn+lgth,std::find(conn+lgth,conn+lgth+nbOfFaces,ToIdType(INTERP_KERNEL::NORM_TRI3)));
- std::size_t tri3_1=std::distance(conn+lgth,std::find(conn+lgth+tri3_0+1,conn+lgth+nbOfFaces,ToIdType(INTERP_KERNEL::NORM_TRI3)));
- const mcIdType *tri_0=0,*tri_1=0;
+ std::size_t const tri3_0=std::distance(conn+lgth,std::find(conn+lgth,conn+lgth+nbOfFaces,ToIdType(INTERP_KERNEL::NORM_TRI3)));
+ std::size_t const tri3_1=std::distance(conn+lgth,std::find(conn+lgth+tri3_0+1,conn+lgth+nbOfFaces,ToIdType(INTERP_KERNEL::NORM_TRI3)));
+ const mcIdType *tri_0=nullptr,*tri_1=nullptr;
const mcIdType *w=conn;
for(std::size_t i=0;i<5;i++)
{
w++;
}
std::vector<mcIdType> tmp;
- std::set<mcIdType> conn1(tri_0,tri_0+3);
- std::set<mcIdType> conn2(tri_1,tri_1+3);
+ std::set<mcIdType> const conn1(tri_0,tri_0+3);
+ std::set<mcIdType> const conn2(tri_1,tri_1+3);
std::set_intersection(conn1.begin(),conn1.end(),conn2.begin(),conn2.end(),std::back_insert_iterator< std::vector<mcIdType> >(tmp));
if(tmp.empty())
{
*/
INTERP_KERNEL::NormalizedCellType CellSimplify::tryToUnPolyPyra5(const mcIdType *conn, mcIdType nbOfFaces, mcIdType lgth, mcIdType *retConn, mcIdType& retLgth)
{
- std::size_t nbOfTriFace=std::count(conn+lgth,conn+lgth+nbOfFaces,ToIdType(INTERP_KERNEL::NORM_TRI3));
- std::size_t nbOfQuadFace=std::count(conn+lgth,conn+lgth+nbOfFaces,ToIdType(INTERP_KERNEL::NORM_QUAD4));
+ std::size_t const nbOfTriFace=std::count(conn+lgth,conn+lgth+nbOfFaces,ToIdType(INTERP_KERNEL::NORM_TRI3));
+ std::size_t const nbOfQuadFace=std::count(conn+lgth,conn+lgth+nbOfFaces,ToIdType(INTERP_KERNEL::NORM_QUAD4));
if(nbOfTriFace==4 && nbOfQuadFace==1)
{
- std::size_t quad4_pos=std::distance(conn+lgth,std::find(conn+lgth,conn+lgth+nbOfFaces,ToIdType(INTERP_KERNEL::NORM_QUAD4)));
- const mcIdType *quad4=0;
+ std::size_t const quad4_pos=std::distance(conn+lgth,std::find(conn+lgth,conn+lgth+nbOfFaces,ToIdType(INTERP_KERNEL::NORM_QUAD4)));
+ const mcIdType *quad4=nullptr;
const mcIdType *w=conn;
- for(std::size_t i=0;i<5 && quad4==0;i++)
+ for(std::size_t i=0;i<5 && quad4==nullptr;i++)
{
if(i==quad4_pos)
quad4=w;
w=std::find(w,conn+lgth,-1);
w++;
}
- std::set<mcIdType> quad4S(quad4,quad4+4);
+ std::set<mcIdType> const quad4S(quad4,quad4+4);
w=conn;
bool ok=true;
mcIdType point=-1;
if(i!=quad4_pos)
{
std::vector<mcIdType> tmp;
- std::set<mcIdType> conn2(w,w+3);
+ std::set<mcIdType> const conn2(w,w+3);
std::set_intersection(conn2.begin(),conn2.end(),quad4S.begin(),quad4S.end(),std::back_insert_iterator< std::vector<mcIdType> >(tmp));
ok=tmp.size()==2;
tmp.clear();
{
if(std::find_if(conn+lgth,conn+lgth+nbOfFaces,std::bind(std::not_equal_to<mcIdType>(),std::placeholders::_1,ToIdType(INTERP_KERNEL::NORM_TRI3)))==conn+lgth+nbOfFaces)
{
- std::set<mcIdType> tribase(conn,conn+3);
+ std::set<mcIdType> const tribase(conn,conn+3);
mcIdType point=-1;
bool ok=true;
for(int i=1;i<4 && ok;i++)
{
std::vector<mcIdType> tmp;
- std::set<mcIdType> conn2(conn+i*4,conn+4*i+3);
+ std::set<mcIdType> const conn2(conn+i*4,conn+4*i+3);
std::set_intersection(conn2.begin(),conn2.end(),tribase.begin(),tribase.end(),std::back_insert_iterator< std::vector<mcIdType> >(tmp));
ok=tmp.size()==2;
tmp.clear();
#define __INTERPKERNELCELLSIMPLIFY_HXX__
#include "INTERPKERNELDefines.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
-#include "InterpKernelException.hxx"
#include "MCIdType.hxx"
+#include "NormalizedGeometricTypes"
namespace INTERP_KERNEL
{
#include "InterpKernelDenseMatrix.hxx"
#include "InterpKernelException.hxx"
+#include "MCIdType.hxx"
#include "VectorUtils.hxx"
#include <cmath>
//
#ifndef __INTERPKERNELMATRIX_HXX_
-#define __INTERPKERNELMATRIX_HXX__
+#define __INTERPKERNELMATRIX_HXX_
#include "InterpolationUtils.hxx"
+#include "NormalizedUnstructuredMesh.hxx"
+#include <utility>
#include <vector>
#include <iostream>
#include <ostream>
void erase(int elem) { std::vector< std::pair<int,T> >::erase(std::find_if(std::vector< std::pair<int,T> >::begin(),std::vector< std::pair<int,T> >::end(),KeyComparator(elem))); }
- void insert(const std::pair<int,T>& myPair) { vector<std::pair<int,T> >::push_back(myPair); }
+ void insert(const std::pair<int,T>& myPair) { std::vector<std::pair<int,T> >::push_back(myPair); }
};
private:
friend std::istream& operator>><>(std::istream& in, Matrix<T,type>& m);
bool _is_configured;
public:
- typedef Row value_type;
+ using value_type = Row;
public:
- Matrix():_coeffs(0), _cols(0), _nb_rows(0), _is_configured(false)
+ Matrix():_coeffs(0), _cols(nullptr), _nb_rows(0), _is_configured(false)
{ }
- Matrix(int nbrows):_coeffs(0), _cols(0), _is_configured(false)
+ Matrix(int nbrows):_coeffs(0), _cols(nullptr), _is_configured(false)
{ _nb_rows=nbrows; }
Matrix(std::vector<std::map<int,T> > & matrix) :
- _coeffs(0), _cols(0), _is_configured(false)
+ _coeffs(0), _cols(nullptr), _is_configured(false)
{
_nb_rows=matrix.size();
_auxiliary_matrix.resize(_nb_rows);
#include "InterpKernelMatrixTools.hxx"
#include "InterpKernelException.hxx"
#include "InterpKernelAutoPtr.hxx"
+#include "MCIdType.hxx"
#include <sstream>
#include <algorithm>
t=work[j];
daxpy(n,t,a+0+j*lda,1,a+0+k*lda,1);
}
- mcIdType l=ipvt[k];
+ mcIdType const l=ipvt[k];
if(l!=k-1)
dswap(n,a+0+k*lda,1,a+0+l*lda,1);
}
#include <cmath>
#include <limits>
-#include <numeric>
#include <algorithm>
double INTERP_KERNEL::quadSkew(const double *coo)
coo[7]+coo[10]-coo[1]-coo[4],
coo[8]+coo[11]-coo[2]-coo[5],
};
- double l0=sqrt(pa0[0]*pa0[0]+pa0[1]*pa0[1]+pa0[2]*pa0[2]);
- double l1=sqrt(pa1[0]*pa1[0]+pa1[1]*pa1[1]+pa1[2]*pa1[2]);
+ double const l0=sqrt(pa0[0]*pa0[0]+pa0[1]*pa0[1]+pa0[2]*pa0[2]);
+ double const l1=sqrt(pa1[0]*pa1[0]+pa1[1]*pa1[1]+pa1[2]*pa1[2]);
if(l0<1.e-15)
return 0.;
if(l1<1.e-15)
double INTERP_KERNEL::quadEdgeRatio(const double *coo)
{
- double a2=(coo[3]-coo[0])*(coo[3]-coo[0])+(coo[4]-coo[1])*(coo[4]-coo[1])+(coo[5]-coo[2])*(coo[5]-coo[2]);
- double b2=(coo[6]-coo[3])*(coo[6]-coo[3])+(coo[7]-coo[4])*(coo[7]-coo[4])+(coo[8]-coo[5])*(coo[8]-coo[5]);
- double c2=(coo[9]-coo[6])*(coo[9]-coo[6])+(coo[10]-coo[7])*(coo[10]-coo[7])+(coo[11]-coo[8])*(coo[11]-coo[8]);
- double d2=(coo[0]-coo[9])*(coo[0]-coo[9])+(coo[1]-coo[10])*(coo[1]-coo[10])+(coo[2]-coo[11])*(coo[2]-coo[11]);
- double mab=a2<b2?a2:b2;
- double Mab=a2<b2?b2:a2;
- double mcd=c2<d2?c2:d2;
- double Mcd=c2<d2?d2:c2;
- double m2=mab<mcd?mab:mcd;
- double M2=Mab>Mcd?Mab:Mcd;
+ double const a2=(coo[3]-coo[0])*(coo[3]-coo[0])+(coo[4]-coo[1])*(coo[4]-coo[1])+(coo[5]-coo[2])*(coo[5]-coo[2]);
+ double const b2=(coo[6]-coo[3])*(coo[6]-coo[3])+(coo[7]-coo[4])*(coo[7]-coo[4])+(coo[8]-coo[5])*(coo[8]-coo[5]);
+ double const c2=(coo[9]-coo[6])*(coo[9]-coo[6])+(coo[10]-coo[7])*(coo[10]-coo[7])+(coo[11]-coo[8])*(coo[11]-coo[8]);
+ double const d2=(coo[0]-coo[9])*(coo[0]-coo[9])+(coo[1]-coo[10])*(coo[1]-coo[10])+(coo[2]-coo[11])*(coo[2]-coo[11]);
+ double const mab=a2<b2?a2:b2;
+ double const Mab=a2<b2?b2:a2;
+ double const mcd=c2<d2?c2:d2;
+ double const Mcd=c2<d2?d2:c2;
+ double const m2=mab<mcd?mab:mcd;
+ double const M2=Mab>Mcd?Mab:Mcd;
if(m2>1.e-15)
return sqrt(M2/m2);
else
double INTERP_KERNEL::quadAspectRatio(const double *coo)
{
- double a=sqrt((coo[3]-coo[0])*(coo[3]-coo[0])+(coo[4]-coo[1])*(coo[4]-coo[1])+(coo[5]-coo[2])*(coo[5]-coo[2]));
- double b=sqrt((coo[6]-coo[3])*(coo[6]-coo[3])+(coo[7]-coo[4])*(coo[7]-coo[4])+(coo[8]-coo[5])*(coo[8]-coo[5]));
- double c=sqrt((coo[9]-coo[6])*(coo[9]-coo[6])+(coo[10]-coo[7])*(coo[10]-coo[7])+(coo[11]-coo[8])*(coo[11]-coo[8]));
- double d=sqrt((coo[0]-coo[9])*(coo[0]-coo[9])+(coo[1]-coo[10])*(coo[1]-coo[10])+(coo[2]-coo[11])*(coo[2]-coo[11]));
- double ma=a>b?a:b;
- double mb=c>d?c:d;
- double hm=ma>mb?ma:mb;
- double ab[3]={(coo[4]-coo[1])*(coo[8]-coo[5])-(coo[7]-coo[4])*(coo[5]-coo[2]),
+ double const a=sqrt((coo[3]-coo[0])*(coo[3]-coo[0])+(coo[4]-coo[1])*(coo[4]-coo[1])+(coo[5]-coo[2])*(coo[5]-coo[2]));
+ double const b=sqrt((coo[6]-coo[3])*(coo[6]-coo[3])+(coo[7]-coo[4])*(coo[7]-coo[4])+(coo[8]-coo[5])*(coo[8]-coo[5]));
+ double const c=sqrt((coo[9]-coo[6])*(coo[9]-coo[6])+(coo[10]-coo[7])*(coo[10]-coo[7])+(coo[11]-coo[8])*(coo[11]-coo[8]));
+ double const d=sqrt((coo[0]-coo[9])*(coo[0]-coo[9])+(coo[1]-coo[10])*(coo[1]-coo[10])+(coo[2]-coo[11])*(coo[2]-coo[11]));
+ double const ma=a>b?a:b;
+ double const mb=c>d?c:d;
+ double const hm=ma>mb?ma:mb;
+ double const ab[3]={(coo[4]-coo[1])*(coo[8]-coo[5])-(coo[7]-coo[4])*(coo[5]-coo[2]),
(coo[5]-coo[2])*(coo[6]-coo[3])-(coo[3]-coo[0])*(coo[8]-coo[5]),
(coo[3]-coo[0])*(coo[7]-coo[4])-(coo[4]-coo[1])*(coo[6]-coo[3])};
- double cd[3]={(coo[10]-coo[7])*(coo[2]-coo[11])-(coo[1]-coo[10])*(coo[11]-coo[8]),
+ double const cd[3]={(coo[10]-coo[7])*(coo[2]-coo[11])-(coo[1]-coo[10])*(coo[11]-coo[8]),
(coo[11]-coo[8])*(coo[0]-coo[9])-(coo[9]-coo[6])*(coo[2]-coo[11]),
(coo[9]-coo[6])*(coo[1]-coo[10])-(coo[10]-coo[7])*(coo[0]-coo[9])};
- double e=sqrt(ab[0]*ab[0]+ab[1]*ab[1]+ab[2]*ab[2])+sqrt(cd[0]*cd[0]+cd[1]*cd[1]+cd[2]*cd[2]);
+ double const e=sqrt(ab[0]*ab[0]+ab[1]*ab[1]+ab[2]*ab[2])+sqrt(cd[0]*cd[0]+cd[1]*cd[1]+cd[2]*cd[2]);
if(d>1e-15)
return 0.5*(a+b+c+d)*hm/e;
else
double INTERP_KERNEL::quadWarp(const double *coo)
{
- double e0[3]={coo[3]-coo[0],coo[4]-coo[1],coo[5]-coo[2]};
- double e1[3]={coo[6]-coo[3],coo[7]-coo[4],coo[8]-coo[5]};
- double e2[3]={coo[9]-coo[6],coo[10]-coo[7],coo[11]-coo[8]};
- double e3[3]={coo[0]-coo[9],coo[1]-coo[10],coo[2]-coo[11]};
+ double const e0[3]={coo[3]-coo[0],coo[4]-coo[1],coo[5]-coo[2]};
+ double const e1[3]={coo[6]-coo[3],coo[7]-coo[4],coo[8]-coo[5]};
+ double const e2[3]={coo[9]-coo[6],coo[10]-coo[7],coo[11]-coo[8]};
+ double const e3[3]={coo[0]-coo[9],coo[1]-coo[10],coo[2]-coo[11]};
- double n0[3]={e3[1]*e0[2]-e3[2]*e0[1],e3[2]*e0[0]-e3[0]*e0[2],e3[0]*e0[1]-e3[1]*e0[0]};
- double n1[3]={e0[1]*e1[2]-e0[2]*e1[1],e0[2]*e1[0]-e0[0]*e1[2],e0[0]*e1[1]-e0[1]*e1[0]};
- double n2[3]={e1[1]*e2[2]-e1[2]*e2[1],e1[2]*e2[0]-e1[0]*e2[2],e1[0]*e2[1]-e1[1]*e2[0]};
- double n3[3]={e2[1]*e3[2]-e2[2]*e3[1],e2[2]*e3[0]-e2[0]*e3[2],e2[0]*e3[1]-e2[1]*e3[0]};
+ double const n0[3]={e3[1]*e0[2]-e3[2]*e0[1],e3[2]*e0[0]-e3[0]*e0[2],e3[0]*e0[1]-e3[1]*e0[0]};
+ double const n1[3]={e0[1]*e1[2]-e0[2]*e1[1],e0[2]*e1[0]-e0[0]*e1[2],e0[0]*e1[1]-e0[1]*e1[0]};
+ double const n2[3]={e1[1]*e2[2]-e1[2]*e2[1],e1[2]*e2[0]-e1[0]*e2[2],e1[0]*e2[1]-e1[1]*e2[0]};
+ double const n3[3]={e2[1]*e3[2]-e2[2]*e3[1],e2[2]*e3[0]-e2[0]*e3[2],e2[0]*e3[1]-e2[1]*e3[0]};
- double l0=sqrt(n0[0]*n0[0]+n0[1]*n0[1]+n0[2]*n0[2]);
- double l1=sqrt(n1[0]*n1[0]+n1[1]*n1[1]+n1[2]*n1[2]);
- double l2=sqrt(n2[0]*n2[0]+n2[1]*n2[1]+n2[2]*n2[2]);
- double l3=sqrt(n3[0]*n3[0]+n3[1]*n3[1]+n3[2]*n3[2]);
+ double const l0=sqrt(n0[0]*n0[0]+n0[1]*n0[1]+n0[2]*n0[2]);
+ double const l1=sqrt(n1[0]*n1[0]+n1[1]*n1[1]+n1[2]*n1[2]);
+ double const l2=sqrt(n2[0]*n2[0]+n2[1]*n2[1]+n2[2]*n2[2]);
+ double const l3=sqrt(n3[0]*n3[0]+n3[1]*n3[1]+n3[2]*n3[2]);
if(l0<1.e-15 || l1<1.e-15 || l2<1.e-15 || l3<1e-15)
return std::numeric_limits<double>::min();
- double warp=std::min(n0[0]/l0*n2[0]/l2+n0[1]/l0*n2[1]/l2+n0[2]/l0*n2[2]/l2,n1[0]/l1*n3[0]/l3+n1[1]/l1*n3[1]/l3+n1[2]/l1*n3[2]/l3);
+ double const warp=std::min(n0[0]/l0*n2[0]/l2+n0[1]/l0*n2[1]/l2+n0[2]/l0*n2[2]/l2,n1[0]/l1*n3[0]/l3+n1[1]/l1*n3[1]/l3+n1[2]/l1*n3[2]/l3);
return warp*warp*warp;
}
double INTERP_KERNEL::triEdgeRatio(const double *coo)
{
- double a2=(coo[3]-coo[0])*(coo[3]-coo[0])+(coo[4]-coo[1])*(coo[4]-coo[1])+(coo[5]-coo[2])*(coo[5]-coo[2]);
- double b2=(coo[6]-coo[3])*(coo[6]-coo[3])+(coo[7]-coo[4])*(coo[7]-coo[4])+(coo[8]-coo[5])*(coo[8]-coo[5]);
- double c2=(coo[0]-coo[6])*(coo[0]-coo[6])+(coo[1]-coo[7])*(coo[1]-coo[7])+(coo[2]-coo[8])*(coo[2]-coo[8]);
- double mab=a2<b2?a2:b2;
- double Mab=a2<b2?b2:a2;
- double m2=c2>mab?mab:c2;
- double M2=c2>Mab?c2:Mab;
+ double const a2=(coo[3]-coo[0])*(coo[3]-coo[0])+(coo[4]-coo[1])*(coo[4]-coo[1])+(coo[5]-coo[2])*(coo[5]-coo[2]);
+ double const b2=(coo[6]-coo[3])*(coo[6]-coo[3])+(coo[7]-coo[4])*(coo[7]-coo[4])+(coo[8]-coo[5])*(coo[8]-coo[5]);
+ double const c2=(coo[0]-coo[6])*(coo[0]-coo[6])+(coo[1]-coo[7])*(coo[1]-coo[7])+(coo[2]-coo[8])*(coo[2]-coo[8]);
+ double const mab=a2<b2?a2:b2;
+ double const Mab=a2<b2?b2:a2;
+ double const m2=c2>mab?mab:c2;
+ double const M2=c2>Mab?c2:Mab;
if(m2>1.e-15)
return sqrt(M2/m2);
else
double INTERP_KERNEL::triAspectRatio(const double *coo)
{
- double a=sqrt((coo[3]-coo[0])*(coo[3]-coo[0])+(coo[4]-coo[1])*(coo[4]-coo[1])+(coo[5]-coo[2])*(coo[5]-coo[2]));
- double b=sqrt((coo[6]-coo[3])*(coo[6]-coo[3])+(coo[7]-coo[4])*(coo[7]-coo[4])+(coo[8]-coo[5])*(coo[8]-coo[5]));
- double c=sqrt((coo[0]-coo[6])*(coo[0]-coo[6])+(coo[1]-coo[7])*(coo[1]-coo[7])+(coo[2]-coo[8])*(coo[2]-coo[8]));
+ double const a=sqrt((coo[3]-coo[0])*(coo[3]-coo[0])+(coo[4]-coo[1])*(coo[4]-coo[1])+(coo[5]-coo[2])*(coo[5]-coo[2]));
+ double const b=sqrt((coo[6]-coo[3])*(coo[6]-coo[3])+(coo[7]-coo[4])*(coo[7]-coo[4])+(coo[8]-coo[5])*(coo[8]-coo[5]));
+ double const c=sqrt((coo[0]-coo[6])*(coo[0]-coo[6])+(coo[1]-coo[7])*(coo[1]-coo[7])+(coo[2]-coo[8])*(coo[2]-coo[8]));
double hm=a>b?a:b;
hm=hm>c?hm:c;
- double ab[3]={(coo[4]-coo[1])*(coo[8]-coo[5])-(coo[7]-coo[4])*(coo[5]-coo[2]),
+ double const ab[3]={(coo[4]-coo[1])*(coo[8]-coo[5])-(coo[7]-coo[4])*(coo[5]-coo[2]),
(coo[5]-coo[2])*(coo[6]-coo[3])-(coo[3]-coo[0])*(coo[8]-coo[5]),
(coo[3]-coo[0])*(coo[7]-coo[4])-(coo[4]-coo[1])*(coo[6]-coo[3])};
- double d=sqrt(ab[0]*ab[0]+ab[1]*ab[1]+ab[2]*ab[2]);
+ double const d=sqrt(ab[0]*ab[0]+ab[1]*ab[1]+ab[2]*ab[2]);
static const double normalizeCoeff=sqrt(3.)/6.;
if(d>1.e-15)
return normalizeCoeff*hm*(a+b+c)/d;
double INTERP_KERNEL::tetraEdgeRatio(const double *coo)
{
- double a[3]={coo[3]-coo[0],coo[4]-coo[1],coo[5]-coo[2]};
- double b[3]={coo[6]-coo[3],coo[7]-coo[4],coo[8]-coo[5]};
- double c[3]={coo[0]-coo[6],coo[1]-coo[7],coo[2]-coo[8]};
- double d[3]={coo[9]-coo[0],coo[10]-coo[1],coo[11]-coo[2]};
- double e[3]={coo[9]-coo[3],coo[10]-coo[4],coo[11]-coo[5]};
- double f[3]={coo[9]-coo[6],coo[10]-coo[7],coo[11]-coo[8]};
+ double const a[3]={coo[3]-coo[0],coo[4]-coo[1],coo[5]-coo[2]};
+ double const b[3]={coo[6]-coo[3],coo[7]-coo[4],coo[8]-coo[5]};
+ double const c[3]={coo[0]-coo[6],coo[1]-coo[7],coo[2]-coo[8]};
+ double const d[3]={coo[9]-coo[0],coo[10]-coo[1],coo[11]-coo[2]};
+ double const e[3]={coo[9]-coo[3],coo[10]-coo[4],coo[11]-coo[5]};
+ double const f[3]={coo[9]-coo[6],coo[10]-coo[7],coo[11]-coo[8]};
double l2[6]=
{a[0]*a[0]+a[1]*a[1]+a[2]*a[2],
e[0]*e[0]+e[1]*e[1]+e[2]*e[2],
f[0]*f[0]+f[1]*f[1]+f[2]*f[2]};
- double M2=*std::max_element(l2,l2+6);
- double m2=*std::min_element(l2,l2+6);
+ double const M2=*std::max_element(l2,l2+6);
+ double const m2=*std::min_element(l2,l2+6);
if(m2>1e-15)
return sqrt(M2/m2);
else
double INTERP_KERNEL::tetraAspectRatio(const double *coo)
{
static const double normalizeCoeff=sqrt(6.)/12.;
- double ab[3]={coo[3]-coo[0],coo[4]-coo[1],coo[5]-coo[2]};
- double ac[3]={coo[6]-coo[0],coo[7]-coo[1],coo[8]-coo[2]};
- double ad[3]={coo[9]-coo[0],coo[10]-coo[1],coo[11]-coo[2]};
- double detTet=(ab[0]*(ac[1]*ad[2]-ac[2]*ad[1]))+(ab[1]*(ac[2]*ad[0]-ac[0]*ad[2]))+(ab[2]*(ac[0]*ad[1]-ac[1]*ad[0]));
+ double const ab[3]={coo[3]-coo[0],coo[4]-coo[1],coo[5]-coo[2]};
+ double const ac[3]={coo[6]-coo[0],coo[7]-coo[1],coo[8]-coo[2]};
+ double const ad[3]={coo[9]-coo[0],coo[10]-coo[1],coo[11]-coo[2]};
+ double const detTet=(ab[0]*(ac[1]*ad[2]-ac[2]*ad[1]))+(ab[1]*(ac[2]*ad[0]-ac[0]*ad[2]))+(ab[2]*(ac[0]*ad[1]-ac[1]*ad[0]));
//if(detTet<1.e-15)
// return std::numeric_limits<double>::max();
- double bc[3]={coo[6]-coo[3],coo[7]-coo[4],coo[8]-coo[5]};
+ double const bc[3]={coo[6]-coo[3],coo[7]-coo[4],coo[8]-coo[5]};
double bd[3]={coo[9]-coo[3],coo[10]-coo[4],coo[11]-coo[5]};
- double cd[3]={coo[9]-coo[6],coo[10]-coo[7],coo[11]-coo[8]};
+ double const cd[3]={coo[9]-coo[6],coo[10]-coo[7],coo[11]-coo[8]};
- double ab2=ab[0]*ab[0]+ab[1]*ab[1]+ab[2]*ab[2];
- double bc2=bc[0]*bc[0]+bc[1]*bc[1]+bc[2]*bc[2];
- double ac2=ac[0]*ac[0]+ac[1]*ac[1]+ac[2]*ac[2];
- double ad2=ad[0]*ad[0]+ad[1]*ad[1]+ad[2]*ad[2];
- double bd2=bd[0]*bd[0]+bd[1]*bd[1]+bd[2]*bd[2];
- double cd2=cd[0]*cd[0]+cd[1]*cd[1]+cd[2]*cd[2];
+ double const ab2=ab[0]*ab[0]+ab[1]*ab[1]+ab[2]*ab[2];
+ double const bc2=bc[0]*bc[0]+bc[1]*bc[1]+bc[2]*bc[2];
+ double const ac2=ac[0]*ac[0]+ac[1]*ac[1]+ac[2]*ac[2];
+ double const ad2=ad[0]*ad[0]+ad[1]*ad[1]+ad[2]*ad[2];
+ double const bd2=bd[0]*bd[0]+bd[1]*bd[1]+bd[2]*bd[2];
+ double const cd2=cd[0]*cd[0]+cd[1]*cd[1]+cd[2]*cd[2];
double A=ab2>bc2?ab2:bc2;
double B=ac2>ad2?ac2:ad2;
double C=bd2>cd2?bd2:cd2;
double D=A>B?A:B;
- double hm=D>C?sqrt(D):sqrt(C);
+ double const hm=D>C?sqrt(D):sqrt(C);
bd[0]=ab[1]*bc[2]-ab[2]*bc[1]; bd[1]=ab[2]*bc[0]-ab[0]*bc[2]; bd[2]=ab[0]*bc[1]-ab[1]*bc[0];
A=sqrt(bd[0]*bd[0]+bd[1]*bd[1]+bd[2]*bd[2]);
#include "InterpKernelDenseMatrix.hxx"
#include "InterpKernelLUDecomp.hxx"
-#include "InterpKernelQRDecomp.hxx"
#include "InterpKernelException.hxx"
#include "MCIdType.hxx"
+#include <sstream>
#include <vector>
#include <limits>
#include <cmath>
+#include <functional>
template<class T>
inline T sqr(const T a) { return a*a; }
class JacobianCalculator
{
private:
- const double EPS;
+ const double EPS{1.0e-8};
T &func;
public:
- JacobianCalculator(T &funcc) : EPS(1.0e-8),func(funcc) {}
+ JacobianCalculator(T &funcc) : func(funcc) {}
INTERP_KERNEL::DenseMatrix operator() (const std::vector<double>& x, const std::vector<double>& fvec)
{
- mcIdType n=x.size();
+ mcIdType const n=x.size();
INTERP_KERNEL::DenseMatrix df(n,n);
std::vector<double> xh=x;
for (mcIdType j=0;j<n;j++)
{
- double temp=xh[j];
+ double const temp=xh[j];
double h=EPS*std::abs(temp);
if (h == 0.0) h=EPS;
xh[j]=temp+h;
#ifndef __INTERPOLATION_HXX__
#define __INTERPOLATION_HXX__
-#include "INTERPKERNELDefines.hxx"
#include "InterpolationOptions.hxx"
-#include "InterpKernelException.hxx"
#include <string>
class Interpolation : public InterpolationOptions
{
public:
- Interpolation() { }
+ Interpolation() = default;
Interpolation(const InterpolationOptions& io) :InterpolationOptions(io){}
//interpolation of two triangular meshes.
template<class MatrixType, class MyMeshType>
#define __INTERPOLATION_TXX__
#include "Interpolation.hxx"
-#include "IntegralUniformIntersector.hxx"
#include "IntegralUniformIntersector.txx"
+#include "InterpolationOptions.hxx"
+#include "InterpKernelException.hxx"
#include "VectorUtils.hxx"
+#include <algorithm>
+#include <string>
+#include <limits>
+#include <iostream>
+#include <vector>
namespace INTERP_KERNEL
{
#ifndef __INTERPOLATION1D_HXX__
#define __INTERPOLATION1D_HXX__
-#include "InterpolationCurve.hxx"
+#include "InterpolationOptions.hxx"
+#include "InterpolationCurve.txx"
namespace INTERP_KERNEL
{
class Interpolation1D : public InterpolationCurve<Interpolation1D>
{
public:
- Interpolation1D() { }
+ Interpolation1D() = default;
Interpolation1D(const InterpolationOptions& io):InterpolationCurve<Interpolation1D>(io) {}
};
}
#ifndef __INTERPOLATION1D_TXX__
#define __INTERPOLATION1D_TXX__
-#include "Interpolation1D.hxx"
-#include "InterpolationCurve.txx"
#endif
// Author : Anthony GEAY (EDF R&D)
#include "Interpolation1D0D.hxx"
-#include "Interpolation1D0D.txx"
+#include "InterpolationOptions.hxx"
+#include <cstddef>
+#include <vector>
namespace INTERP_KERNEL
{
Interpolation1D0D::Interpolation1D0D()
- {}
+ = default;
Interpolation1D0D::Interpolation1D0D(const InterpolationOptions& io):Interpolation<Interpolation1D0D>(io)
{}
const int SPACE_DIM = 3;
const double adj(getPrecision());// here precision is used instead of getBoundingBoxAdjustment and getBoundingBoxAdjustmentAbs because in the context only precision is relevant
- std::size_t size = bbox.size()/(2*SPACE_DIM);
+ std::size_t const size = bbox.size()/(2*SPACE_DIM);
for (std::size_t i=0; i<size; i++)
{
for(int idim=0; idim<SPACE_DIM; idim++)
#define __INTERPOLATION1D0D_HXX__
#include "INTERPKERNELDefines.hxx"
-#include "Interpolation.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
#include "InterpolationOptions.hxx"
+#include "Interpolation.hxx"
+#include <string>
#include <vector>
namespace INTERP_KERNEL
#ifndef __INTERPOLATION1D0D_TXX__
#define __INTERPOLATION1D0D_TXX__
+#include "InterpKernelException.hxx"
#include "Interpolation1D0D.hxx"
-#include "Interpolation.txx"
-#include "MeshElement.txx"
-#include "PointLocator3DIntersectorP0P0.txx"
-#include "PointLocator3DIntersectorP0P1.txx"
-#include "PointLocator3DIntersectorP1P0.txx"
-#include "PointLocator3DIntersectorP1P1.txx"
+#include "MeshElement.hxx"
#include "Log.hxx"
#include "BBTree.txx"
#include "InterpKernelAssert.hxx"
+#include <string>
+#include <vector>
+#include <map>
+#include <sstream>
namespace INTERP_KERNEL
{
typename MyMeshType::MyConnType Interpolation1D0D::interpolateMeshes(const MyMeshType& srcMesh, const MyMeshType& targetMesh, MatrixType& result, const std::string& method)
{
constexpr int SPACEDIM=MyMeshType::MY_SPACEDIM;
- using ConnType=typename MyMeshType::MyConnType;
+ typedef typename MyMeshType::MyConnType ConnType;
IKAssert(SPACEDIM==3);
if(InterpolationOptions::getIntersectionType() != PointLocator)
#ifndef __INTERPOLATION2D_HXX__
#define __INTERPOLATION2D_HXX__
-#include "InterpolationPlanar.hxx"
+#include "InterpolationOptions.hxx"
+#include "PlanarIntersector.hxx"
+#include "InterpolationPlanar.txx"
+#include <vector>
namespace INTERP_KERNEL
{
class Interpolation2D : public InterpolationPlanar<Interpolation2D>
{
public:
- Interpolation2D() { }
+ Interpolation2D() = default;
Interpolation2D(const InterpolationOptions& io):InterpolationPlanar<Interpolation2D>(io) { }
public:
bool doRotate() const { return false; }
#ifndef __INTERPOLATION2D_TXX__
#define __INTERPOLATION2D_TXX__
-#include "Interpolation2D.hxx"
-#include "InterpolationPlanar.txx"
#endif
#ifndef __INTERPOLATION2D1D_HXX__
#define __INTERPOLATION2D1D_HXX__
-#include "Interpolation.hxx"
-#include "Planar2D1DIntersectorP0P0.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
+#include <string>
+#include <set>
+#include <map>
+
#include "InterpolationOptions.hxx"
+#include "Interpolation.hxx"
+#include "MCIdType.hxx"
namespace INTERP_KERNEL
{
class Interpolation2D1D : public Interpolation<Interpolation2D1D>
{
public:
- typedef std::map<mcIdType,std::set<mcIdType> > DuplicateFacesType;
+ using DuplicateFacesType = std::map<mcIdType, std::set<mcIdType>>;
Interpolation2D1D() { setOrientation(2); }
Interpolation2D1D(const InterpolationOptions& io):Interpolation<Interpolation2D1D>(io) { }
#define __INTERPOLATION2D1D_TXX__
#include "Interpolation2D1D.hxx"
+#include <string>
+#include "NormalizedUnstructuredMesh.hxx"
+#include "PlanarIntersector.txx"
+#include "Planar2D1DIntersectorP0P0.hxx"
+#include "InterpolationOptions.hxx"
+#include "Geometric2DIntersector.txx"
+#include "InterpKernelException.hxx"
+#include "BBTree.txx"
+#include "InterpolationUtils.hxx"
+
+#include <ctime>
+#include <cstddef>
+#include <utility>
+#include <vector>
+#include <iostream>
namespace INTERP_KERNEL
{
typedef typename MyMeshType::MyConnType ConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
- long global_start =clock();
+ long const global_start =clock();
std::size_t counter=0;
/***********************************************************/
/* Check both meshes are made of triangles and quadrangles */
}
PlanarIntersector<MyMeshType,MatrixType>* intersector=0;
- std::string meth = InterpolationOptions::filterInterpolationMethod(method);
+ std::string const meth = InterpolationOptions::filterInterpolationMethod(method);
if(meth=="P0P0")
{
switch (InterpolationOptions::getIntersectionType())
/* Instantiate the intersector and initialise the result vector */
/****************************************************************/
- long start_filtering=clock();
+ long const start_filtering=clock();
std::vector<double> bbox;
intersector->createBoundingBoxes(myMeshS,bbox); // create the bounding boxes
- const double *bboxPtr=0;
+ const double *bboxPtr=nullptr;
if(nbMailleS>0)
bboxPtr=&bbox[0];
BBTree<SPACEDIM,ConnType> my_tree(bboxPtr, 0, 0,nbMailleS, -getPrecision());//creating the search structure
- long end_filtering=clock();
+ long const end_filtering=clock();
result.resize(intersector->getNumberOfRowsOfResMatrix());//on initialise.
/****************************************************/
/* Loop on the target cells - core of the algorithm */
/****************************************************/
- long start_intersection=clock();
+ long const start_intersection=clock();
ConnType nbelem_type=myMeshT.getNumberOfElements();
const ConnType *connIndxT=myMeshT.getConnectivityIndexPtr();
for(ConnType iT=0; iT<nbelem_type; iT++)
if (InterpolationOptions::getPrintLevel() >=1)
{
- long end_intersection=clock();
+ long const end_intersection=clock();
std::cout << "Filtering time= " << end_filtering-start_filtering << std::endl;
std::cout << "Intersection time= " << end_intersection-start_intersection << std::endl;
- long global_end =clock();
+ long const global_end =clock();
std::cout << "Number of computed intersections = " << counter << std::endl;
std::cout << "Global time= " << global_end - global_start << std::endl;
}
//
#include "Interpolation2D3D.hxx"
+#include "InterpolationOptions.hxx"
namespace INTERP_KERNEL
{
*
*/
Interpolation2D3D::Interpolation2D3D()
- {
- }
+ = default;
Interpolation2D3D::Interpolation2D3D(const InterpolationOptions& io):Interpolation<Interpolation2D3D>(io)
{
}
#ifndef __INTERPOLATION2D3D_HXX__
#define __INTERPOLATION2D3D_HXX__
+#include <cstddef>
#include <set>
#include <map>
#include "INTERPKERNELDefines.hxx"
-#include "Interpolation.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
#include "InterpolationOptions.hxx"
#include "MCIdType.hxx"
#include "Intersector3D.hxx"
-#include <vector>
+#include "NormalizedGeometricTypes"
+#include "Interpolation.hxx"
+#include <string>
namespace INTERP_KERNEL
{
class Interpolation2D3D : public Interpolation<Interpolation2D3D>
{
public:
- typedef std::map<mcIdType,std::set<mcIdType> > DuplicateFacesType;
+ using DuplicateFacesType = std::map<mcIdType, std::set<mcIdType>>;
INTERPKERNEL_EXPORT Interpolation2D3D();
INTERPKERNEL_EXPORT Interpolation2D3D(const InterpolationOptions& io);
#ifndef __INTERPOLATION2D3D_TXX__
#define __INTERPOLATION2D3D_TXX__
+#include "BBTreeStandAlone.txx"
+#include "BoundingBox.hxx"
#include "Interpolation2D3D.hxx"
-#include "Interpolation.txx"
+// #include "Interpolation.txx"
+#include "Intersector3D.txx"
+#include "Log.hxx"
+#include "InterpolationOptions.hxx"
#include "MeshElement.txx"
-#include "TransformedTriangle.hxx"
+#include "NormalizedGeometricTypes"
#include "Polyhedron3D2DIntersectorP0P0.txx"
-#include "PointLocator3DIntersectorP0P0.txx"
-#include "PolyhedronIntersectorP0P1.txx"
-#include "PointLocator3DIntersectorP0P1.txx"
-#include "PolyhedronIntersectorP1P0.txx"
-#include "PolyhedronIntersectorP1P0Bary.txx"
-#include "PointLocator3DIntersectorP1P0.txx"
-#include "PolyhedronIntersectorP1P1.txx"
-#include "PointLocator3DIntersectorP1P1.txx"
#include "InterpolationHelper.txx"
+#include "InterpKernelException.hxx"
-#include "BBTree.txx"
+#include <memory>
+#include <string>
+#include <vector>
+#include <utility>
namespace INTERP_KERNEL
{
#include "Interpolation2DCurve.hxx"
#include "InterpolationCurve.txx"
+#include "InterpolationOptions.hxx"
namespace INTERP_KERNEL
{
#ifndef __INTERPOLATION2DCURVE_HXX__
#define __INTERPOLATION2DCURVE_HXX__
-#include "InterpolationCurve.hxx"
+#include "INTERPKERNELDefines.hxx"
#include "InterpolationOptions.hxx"
+#include "InterpolationCurve.hxx"
namespace INTERP_KERNEL
{
// Author : Anthony Geay (CEA/DEN)
#include "Interpolation3D.hxx"
-#include "Interpolation3D.txx"
+#include "InterpolationOptions.hxx"
namespace INTERP_KERNEL
{
*
*/
Interpolation3D::Interpolation3D()
- {
- }
+ = default;
Interpolation3D::Interpolation3D(const InterpolationOptions& io):Interpolation<Interpolation3D>(io)
{
}
#define __INTERPOLATION3D_HXX__\r
\r
#include "INTERPKERNELDefines.hxx"\r
-#include "Interpolation.hxx"\r
-#include "NormalizedUnstructuredMesh.hxx"\r
#include "InterpolationOptions.hxx"\r
+#include "Interpolation.hxx"
+#include <string>
\r
namespace INTERP_KERNEL\r
{
#define __INTERPOLATION3D_TXX__
#include "Interpolation3D.hxx"
-#include "Interpolation.txx"
+
+#include "BBTreeStandAlone.txx"
+#include "BoundingBox.hxx"
+#include "InterpolationOptions.hxx"
+#include "Intersector3D.hxx"
#include "MeshElement.txx"
-#include "TransformedTriangle.hxx"
+
#include "PolyhedronIntersectorP0P0.txx"
#include "PointLocator3DIntersectorP0P0.txx"
#include "PolyhedronIntersectorP0P1.txx"
#include "Barycentric3DIntersectorP1P1.txx"
#include "MappedBarycentric3DIntersectorP1P1.txx"
#include "Log.hxx"
+#include "InterpKernelException.hxx"
+#include <memory>
+#include <string>
+#include <vector>
// If defined, use recursion to traverse the binary search tree, else use the BBTree class
//#define USE_RECURSIVE_BBOX_FILTER
#endif
-#include <memory>
namespace INTERP_KERNEL
{
// Author : Adrien Bruneton (CEA/DEN)
#include "Interpolation3D1D.hxx"
-#include "Interpolation3D1D.txx"
+#include "InterpolationOptions.hxx"
+#include <cstddef>
+#include <limits>
+#include <vector>
namespace INTERP_KERNEL
{
- Interpolation3D1D::Interpolation3D1D() { }
+ Interpolation3D1D::Interpolation3D1D() = default;
Interpolation3D1D::Interpolation3D1D(const InterpolationOptions& io):Interpolation<Interpolation3D1D>(io) { }
const double adj = getBoundingBoxAdjustmentAbs();
const double adjRel = getBoundingBoxAdjustment();
- std::size_t size = sz/(2*SPACE_DIM);
+ std::size_t const size = sz/(2*SPACE_DIM);
for (std::size_t i=0; i<size; i++)
{
double max=- std::numeric_limits<double>::max();
for(int idim=0; idim<SPACE_DIM; idim++)
{
- double Dx=bbox[i*2*SPACE_DIM+1+2*idim]-bbox[i*2*SPACE_DIM+2*idim];
+ double const Dx=bbox[i*2*SPACE_DIM+1+2*idim]-bbox[i*2*SPACE_DIM+2*idim];
max=(max<Dx)?Dx:max;
}
for(int idim=0; idim<SPACE_DIM; idim++)
#include "INTERPKERNELDefines.hxx"
#include "Interpolation.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
#include "InterpolationOptions.hxx"
+#include <string>
+#include <cstddef>
#include <vector>
namespace INTERP_KERNEL
#pragma once
+#include "InterpKernelException.hxx"
+#include "BBTreeStandAlone.txx"
+#include "BoundingBox.hxx"
#include "Interpolation3D1D.hxx"
-#include "Interpolation.txx"
-#include "MeshElement.txx"
-#include "PointLocator3DIntersectorP0P0.txx"
-#include "PointLocator3DIntersectorP0P1.txx"
-#include "PointLocator3DIntersectorP1P0.txx"
-#include "PointLocator3DIntersectorP1P1.txx"
+#include "Intersector3D.hxx"
+#include "MeshElement.hxx"
+#include "PointLocator3DIntersectorP0P0.hxx"
+#include "PointLocator3DIntersectorP0P1.hxx"
+#include "PointLocator3DIntersectorP1P0.hxx"
+#include "PointLocator3DIntersectorP1P1.hxx"
#include "Log.hxx"
#include "InterpolationHelper.txx"
+#include <memory>
+#include <string>
+#include <vector>
namespace INTERP_KERNEL
{
// Author : Anthony Geay (CEA/DEN)
#include "Interpolation3DSurf.hxx"
+#include "InterpolationOptions.hxx"
#include "InterpolationPlanar.txx"
namespace INTERP_KERNEL
{
Interpolation3DSurf::Interpolation3DSurf()
- {
- }
+ = default;
Interpolation3DSurf::Interpolation3DSurf(const InterpolationOptions& io):InterpolationPlanar<Interpolation3DSurf>(io)
{
- Values: integer between 0 and 3.
- Default: 0.
*/
- void Interpolation3DSurf::setOptions(double precision, int printLevel, double medianPlan,
- IntersectionType intersectionType, bool doRotat, int orientation)
+ void Interpolation3DSurf::setOptions(double precision, int printLevel, double medianPlan,
+ IntersectionType intersectionType, bool doRotat, int orientation)
{
InterpolationPlanar<Interpolation3DSurf>::setOptions(precision,printLevel,intersectionType, orientation);
InterpolationPlanar<Interpolation3DSurf>::setDoRotate(doRotat);
#ifndef __INTERPOLATION3DSURF_HXX__
#define __INTERPOLATION3DSURF_HXX__
-#include "InterpolationPlanar.txx"
#include "INTERPKERNELDefines.hxx"
#include "InterpolationOptions.hxx"
+#include "PlanarIntersector.hxx"
+#include "InterpolationPlanar.txx"
+#include <vector>
namespace INTERP_KERNEL
{
#ifndef __InterpolationCC_HXX__
#define __InterpolationCC_HXX__
+#include "InterpolationOptions.hxx"
#include "Interpolation.hxx"
namespace INTERP_KERNEL
//
#include "InterpolationCC.hxx"
+#include "InterpolationOptions.hxx"
#include "InterpolationUtils.hxx"
+#include <algorithm>
+#include <string>
+#include <list>
// convert index "From Mesh Index"
#define _FMI(i) OTT<typename MyMeshType::MyConnType,MyMeshType::My_numPol>::ind2C((i))
*/
//================================================================================
InterpolationCC::InterpolationCC()
- {
- }
+ = default;
InterpolationCC::InterpolationCC(const InterpolationOptions& io):Interpolation<InterpolationCC>(io)
{
x2t = tgt_coords[ j ][ it+1 ];
x2s = src_coords[ j ][ is+1 ];
- double x1 = std::max( x1s ,x1t );
- double x2 = std::min( x2s ,x2t );
+ double const x1 = std::max( x1s ,x1t );
+ double const x2 = std::min( x2s ,x2t );
axis_interferences.push_back( Interference( is, it, x2 - x1 ));
// to the next target and/or source cell
- double diff2 = x2s - x2t;
+ double const diff2 = x2s - x2t;
if ( diff2 > -eps )
intersection = ( ++it < tgt_nb_cells[j] );
if ( diff2 < eps )
#ifndef __InterpolationCU_HXX__
#define __InterpolationCU_HXX__
+#include "InterpolationOptions.hxx"
#include "Interpolation.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
-#include "InterpKernelUtilities.hxx"
namespace INTERP_KERNEL
{
#include "InterpolationCU.hxx"
-#include "Interpolation.txx"
+#include "InterpolationUtils.hxx"
+#include "InterpolationOptions.hxx"
+#include "IntersectorCU.txx"
#include "IntersectorCU1D.txx"
#include "IntersectorCU2D.txx"
#include "IntersectorCU3D.txx"
-
+#include "NormalizedGeometricTypes"
+#include "TargetIntersector.hxx"
+#include <string>
#include <map>
+#include <vector>
+
// // convert index "From Mesh Index"
#define _FMIU(i) OTT<typename MyUMeshType::MyConnType,MyUMeshType::My_numPol>::ind2C((i))
//================================================================================
InterpolationCU::InterpolationCU()
- {
- }
+ = default;
InterpolationCU::InterpolationCU(const InterpolationOptions & io)
:Interpolation<InterpolationCU>(io)
MatrixType revResult;
CConnType sizeT = interpolateMeshes( meshT, meshS, revResult, method );
- UConnType sizeS = static_cast<UConnType>(revResult.size());
+ auto sizeS = static_cast<UConnType>(revResult.size());
result.resize( sizeT );
for ( CConnType iS = 0; iS < sizeS; ++iS )
#include "BBTree.txx"\r
\r
#include <functional>\r
+#include <string>
+#include <vector>
\r
namespace INTERP_KERNEL\r
{
#ifndef __INTERPOLATIONCURVE_TXX__
#define __INTERPOLATIONCURVE_TXX__
-#include "InterpolationCurve.hxx"
-#include "InterpolationOptions.hxx"
+#include "Interpolation.txx"
+#include "BBTree.txx"
+#include "CurveIntersector.txx"
#include "CurveIntersectorP0P0.txx"
-#include "CurveIntersectorP1P0.txx"
#include "CurveIntersectorP0P1.txx"
+#include "CurveIntersectorP1P0.txx"
#include "CurveIntersectorP1P1.txx"
#include "CurveIntersectorP1P1PL.txx"
+#include "InterpolationCurve.hxx"
+#include "InterpolationOptions.hxx"
+#include "NormalizedUnstructuredMesh.hxx"
+#include "InterpolationUtils.hxx"
+#include <string>
+#include <functional>
+#include <cstddef>
+#include <iostream>
+#include <ostream>
#include <time.h>
#include <memory>
+#include <vector>
namespace INTERP_KERNEL
{
template<class RealCurve>
InterpolationCurve<RealCurve>::InterpolationCurve()
- {
- }
+ = default;
template<class RealCurve>
InterpolationCurve<RealCurve>::InterpolationCurve (const InterpolationOptions& io)
typedef typename MyMeshType::MyConnType ConnType;
static const NumberingPolicy numPol = MyMeshType::My_numPol;
- long global_start = clock();
+ long const global_start = clock();
std::size_t counter=0;
ConnType nbMailleS = myMeshS.getNumberOfElements();
/* Instantiate the intersector and initialise the result vector */
/****************************************************************/
- long start_filtering=clock();
+ long const start_filtering=clock();
std::vector<double> bbox;
intersector->createBoundingBoxes(myMeshS,bbox); // create the bounding boxes
InterpolationOptions::getBoundingBoxAdjustmentAbs());
BBTree<SPACEDIM,ConnType> my_tree(&bbox[0], 0, 0, nbMailleS);//creating the search structure
- long end_filtering = clock();
+ long const end_filtering = clock();
result.resize(intersector->getNumberOfRowsOfResMatrix());//on initialise.
/****************************************************/
/* Loop on the target cells - core of the algorithm */
/****************************************************/
- long start_intersection = clock();
+ long const start_intersection = clock();
const ConnType *connIndxT = myMeshT.getConnectivityIndexPtr();
for(ConnType iT=0; iT<nbMailleT; iT++)
{
if (InterpolationOptions::getPrintLevel() >= 1)
{
- long end_intersection=clock();
+ long const end_intersection=clock();
std::cout << "Filtering time= " << end_filtering-start_filtering << std::endl;
std::cout << "Intersection time= " << end_intersection-start_intersection << std::endl;
- long global_end =clock();
+ long const global_end =clock();
std::cout << "Number of computed intersections = " << counter << std::endl;
std::cout << "Global time= " << global_end - global_start << std::endl;
}
#include "BBTreeStandAlone.txx"
#include "MeshElement.txx"
+#include "BoundingBox.hxx"
#include "Log.hxx"
#include <memory>
#include <functional>
+#include <utility>
namespace INTERP_KERNEL
{
// Author : Anthony Geay (CEA/DEN)
#include "InterpolationOptions.hxx"
-#include "InterpKernelGeo2DPrecision.hxx"
#include "InterpKernelException.hxx"
+#include "NormalizedGeometricTypes"
+#include <ostream>
+#include <ios>
#include <sstream>
+#include <string>
const double INTERP_KERNEL::InterpolationOptions::DFT_MEDIAN_PLANE=0.5;
}
else if(key==MEASURE_ABS_STR)
{
- bool valBool=(value!=0);
+ bool const valBool=(value!=0);
setMeasureAbsStatus(valBool);
return true;
}
#define __INTERPOLATIONOPTIONS_HXX__
#include "INTERPKERNELDefines.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
+#include "NormalizedGeometricTypes"
#include <string>
\r
#include "Interpolation.hxx"\r
#include "PlanarIntersector.hxx"\r
-#include "NormalizedUnstructuredMesh.hxx"\r
#include "InterpolationOptions.hxx"\r
+#include <string>
+#include <vector>
\r
namespace INTERP_KERNEL\r
{
#define __INTERPOLATIONPLANAR_TXX__
#include "InterpolationPlanar.hxx"
+
#include "Interpolation.txx"
#include "InterpolationOptions.hxx"
-#include "PlanarIntersector.hxx"
+#include "NormalizedUnstructuredMesh.hxx"
+#include "InterpolationUtils.hxx"
+
+#include "PlanarIntersectorP0P0.hxx"
+#include "PlanarIntersectorP1P0.hxx"
+#include "PlanarIntersectorP0P1.hxx"
+#include "PlanarIntersectorP1P1.hxx"
+#include "PlanarIntersectorP0P1Bary.hxx"
+#include "PlanarIntersectorP1P0Bary.hxx"
+
#include "PlanarIntersector.txx"
-#include "TriangulationIntersector.hxx"
#include "TriangulationIntersector.txx"
-#include "ConvexIntersector.hxx"
#include "ConvexIntersector.txx"
-#include "Geometric2DIntersector.hxx"
#include "Geometric2DIntersector.txx"
-#include "PointLocator2DIntersector.hxx"
#include "PointLocator2DIntersector.txx"
-#include "PlanarIntersectorP0P1PL.hxx"
#include "PlanarIntersectorP0P1PL.txx"
-#include "PlanarIntersectorP1P0PL.hxx"
#include "PlanarIntersectorP1P0PL.txx"
-#include "PlanarIntersectorP1P1PL.hxx"
#include "PlanarIntersectorP1P1PL.txx"
-#include "MappedBarycentric2DIntersectorP1P1.hxx"
#include "MappedBarycentric2DIntersectorP1P1.txx"
#include "VectorUtils.hxx"
#include "BBTree.txx"
+#include <algorithm>
+#include <cstddef>
+#include <iostream>
#include <limits>
+#include <string>
#include <time.h>
+#include <vector>
namespace INTERP_KERNEL
{
typedef typename MyMeshType::MyConnType ConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
- long global_start =clock();
+ long const global_start =clock();
std::size_t counter=0;
/***********************************************************/
/* Check both meshes are made of triangles and quadrangles */
/* Instantiate the intersector and initialise the result vector */
/****************************************************************/
- long start_filtering=clock();
+ long const start_filtering=clock();
std::vector<double> bbox;
intersector->createBoundingBoxes(myMeshS,bbox); // create the bounding boxes
performAdjustmentOfBB(intersector,bbox);
- const double *bboxPtr=0;
+ const double *bboxPtr=nullptr;
if(nbMailleS>0)
bboxPtr=&bbox[0];
BBTree<SPACEDIM,ConnType> my_tree(bboxPtr, 0, 0,nbMailleS);//creating the search structure
- long end_filtering=clock();
+ long const end_filtering=clock();
result.resize(intersector->getNumberOfRowsOfResMatrix());//on initialise.
/****************************************************/
/* Loop on the target cells - core of the algorithm */
/****************************************************/
- long start_intersection=clock();
+ long const start_intersection=clock();
ConnType nbelem_type=myMeshT.getNumberOfElements();
const ConnType *connIndxT=myMeshT.getConnectivityIndexPtr();
for(ConnType iT=0; iT<nbelem_type; iT++)
if (InterpolationOptions::getPrintLevel() >=1)
{
- long end_intersection=clock();
+ long const end_intersection=clock();
std::cout << "Filtering time= " << end_filtering-start_filtering << std::endl;
std::cout << "Intersection time= " << end_intersection-start_intersection << std::endl;
- long global_end =clock();
+ long const global_end =clock();
std::cout << "Number of computed intersections = " << counter << std::endl;
std::cout << "Global time= " << global_end - global_start << std::endl;
}
#ifndef __INTERPOLATIONUTILS_HXX__
#define __INTERPOLATIONUTILS_HXX__
-#include "INTERPKERNELDefines.hxx"
#include "InterpKernelException.hxx"
+#include "MCIdType.hxx"
#include "VolSurfUser.hxx"
+#include "NormalizedGeometricTypes"
#include "NormalizedUnstructuredMesh.hxx"
+#include <cstddef>
#include <deque>
+#include <iterator>
#include <map>
#include <cmath>
-#include <string>
+#include <utility>
#include <vector>
#include <algorithm>
#include <iostream>
inline double Surf_Tri(const double *P_1,const double *P_2,const double *P_3)
{
- double A=(P_3[1]-P_1[1])*(P_2[0]-P_1[0])-(P_2[1]-P_1[1])*(P_3[0]-P_1[0]);
- double Surface = 0.5*fabs(A);
+ double const A=(P_3[1]-P_1[1])*(P_2[0]-P_1[0])-(P_2[1]-P_1[1])*(P_3[0]-P_1[0]);
+ double const Surface = 0.5*fabs(A);
return Surface;
}
const double *P_2,
const double *P_3)
{
- double mon_det=(P_1[0]-P_3[0])*(P_2[1]-P_3[1])-(P_2[0]-P_3[0])*(P_1[1]-P_3[1]);
+ double const mon_det=(P_1[0]-P_3[0])*(P_2[1]-P_3[1])-(P_2[0]-P_3[0])*(P_1[1]-P_3[1]);
return mon_det;
}
inline double norme_vecteur(const double* P_1,const double* P_2)
{
- double X=P_1[0]-P_2[0];
- double Y=P_1[1]-P_2[1];
+ double const X=P_1[0]-P_2[0];
+ double const Y=P_1[1]-P_2[1];
return sqrt(X*X+Y*Y);
}
{
std::vector<double> Vect;
- double P1_P2=norme_vecteur(P_1,P_2);
- double P2_P3=norme_vecteur(P_2,P_3);
- double P3_P1=norme_vecteur(P_3,P_1);
+ double const P1_P2=norme_vecteur(P_1,P_2);
+ double const P2_P3=norme_vecteur(P_2,P_3);
+ double const P3_P1=norme_vecteur(P_3,P_1);
- double N=P1_P2*P1_P2+P3_P1*P3_P1-P2_P3*P2_P3;
- double D=2.0*P1_P2*P3_P1;
+ double const N=P1_P2*P1_P2+P3_P1*P3_P1-P2_P3*P2_P3;
+ double const D=2.0*P1_P2*P3_P1;
double COS=N/D;
if (COS>1.0) COS=1.0;
if (COS<-1.0) COS=-1.0;
Vect.push_back(COS);
- double V=mon_determinant(P_2,P_3,P_1);
- double D_1=P1_P2*P3_P1;
+ double const V=mon_determinant(P_2,P_3,P_1);
+ double const D_1=P1_P2*P3_P1;
double SIN=V/D_1;
if (SIN>1.0) SIN=1.0;
if (SIN<-1.0) SIN=-1.0;
inline std::vector<double> bary_poly(const std::vector<double>& V)
{
std::vector<double> Bary;
- std::size_t taille=V.size();
+ std::size_t const taille=V.size();
double x=0;
double y=0;
x=x+V[2*i];
y=y+V[2*i+1];
}
- double A=2*x/(static_cast<double>(taille));
- double B=2*y/(static_cast<double>(taille));
+ double const A=2*x/(static_cast<double>(taille));
+ double const B=2*y/(static_cast<double>(taille));
Bary.push_back(A);//taille vecteur=2*nb de points.
Bary.push_back(B);
double max = std::fabs( M[ iR[i] ][i] );
for ( int r = i+1; r < (int)nbRow; ++r )
{
- double m = std::fabs( M[ iR[r] ][i] );
+ double const m = std::fabs( M[ iR[r] ][i] );
if ( m > max )
{
max = m;
for ( int r = i+1; r < (int)nbRow; ++r )
{
double* mRow = M[ iR[r] ];
- double coef = mRow[ i ] / tUpRow[ i ];
+ double const coef = mRow[ i ] / tUpRow[ i ];
for ( int c = i+1; c < nbCol; ++c )
mRow[ c ] -= tUpRow[ c ] * coef;
}
T11 = triaCoords[0]-triaCoords[2*SPACEDIM], T12 = triaCoords[SPACEDIM]-triaCoords[2*SPACEDIM],
T21 = triaCoords[1]-triaCoords[2*SPACEDIM+1], T22 = triaCoords[SPACEDIM+1]-triaCoords[2*SPACEDIM+1];
// matrix determinant
- double Tdet = T11*T22 - T12*T21;
+ double const Tdet = T11*T22 - T12*T21;
if ( fabs( Tdet ) < std::numeric_limits<double>::min() ) {
bc[0]=1; bc[1]=0; bc[2]=0;
return;
inline void barycentric_coords_seg2(const std::vector<const double*>& n, const double *p, double *bc)
{
- double delta=n[0][0]-n[1][0];
+ double const delta=n[0][0]-n[1][0];
bc[0]=fabs((*p-n[1][0])/delta);
bc[1]=fabs((*p-n[0][0])/delta);
}
T11 = n[0][_XX]-n[2][_XX], T12 = n[1][_XX]-n[2][_XX],
T21 = n[0][_YY]-n[2][_YY], T22 = n[1][_YY]-n[2][_YY];
// matrix determinant
- double Tdet = T11*T22 - T12*T21;
+ double const Tdet = T11*T22 - T12*T21;
if ( (std::fabs( Tdet) ) < (std::numeric_limits<double>::min()) )
{
bc[0]=1; bc[1]=bc[2]=0; // no solution
inline bool IsPointOn3DSeg(const double segStart[3], const double segStop[3], const double point[3], double eps, double& bc0, double& bc1)
{
double AB[3]={segStop[0]-segStart[0],segStop[1]-segStart[1],segStop[2]-segStart[2]},AP[3]={point[0]-segStart[0],point[1]-segStart[1],point[2]-segStart[2]};
- double l_AB(sqrt(AB[0]*AB[0]+AB[1]*AB[1]+AB[2]*AB[2]));
+ double const l_AB(sqrt(AB[0]*AB[0]+AB[1]*AB[1]+AB[2]*AB[2]));
double AP_dot_AB((AP[0]*AB[0]+AP[1]*AB[1]+AP[2]*AB[2])/(l_AB*l_AB));
- double projOfPOnAB[3]={segStart[0]+AP_dot_AB*AB[0],segStart[1]+AP_dot_AB*AB[1],segStart[2]+AP_dot_AB*AB[2]};
- double V_dist_P_AB[3]={point[0]-projOfPOnAB[0],point[1]-projOfPOnAB[1],point[2]-projOfPOnAB[2]};
- double dist_P_AB(sqrt(V_dist_P_AB[0]*V_dist_P_AB[0]+V_dist_P_AB[1]*V_dist_P_AB[1]+V_dist_P_AB[2]*V_dist_P_AB[2]));
+ double const projOfPOnAB[3]={segStart[0]+AP_dot_AB*AB[0],segStart[1]+AP_dot_AB*AB[1],segStart[2]+AP_dot_AB*AB[2]};
+ double const V_dist_P_AB[3]={point[0]-projOfPOnAB[0],point[1]-projOfPOnAB[1],point[2]-projOfPOnAB[2]};
+ double const dist_P_AB(sqrt(V_dist_P_AB[0]*V_dist_P_AB[0]+V_dist_P_AB[1]*V_dist_P_AB[1]+V_dist_P_AB[2]*V_dist_P_AB[2]));
if(dist_P_AB>=eps)
return false;//to far from segment [segStart,segStop]
if(AP_dot_AB<-eps || AP_dot_AB>1.+eps)
*/
inline void quad_mapped_coords(const std::vector<const double*>& n, const double *p, double *bc)
{
- double prec = 1.0e-14;
+ double const prec = 1.0e-14;
enum { _XX=0, _YY, _ZZ };
if(n.size() != 4)
throw INTERP_KERNEL::Exception("INTERP_KERNEL::quad_mapped_coords : unrecognized geometric type! Only QUAD4 supported.");
- double A[2] = {n[1][_XX] - n[0][_XX], n[1][_YY] - n[0][_YY]};
- double B[2] = {n[2][_XX] - n[0][_XX], n[2][_YY] - n[0][_YY]};
- double C[2] = {n[3][_XX] - n[0][_XX], n[3][_YY] - n[0][_YY]};
- double N[2] = {B[_XX] - A[_XX] - C[_XX], B[_YY] - A[_YY] - C[_YY]};
- double P[2] = {p[_XX] - n[0][_XX], p[_YY] - n[0][_YY]};
+ double const A[2] = {n[1][_XX] - n[0][_XX], n[1][_YY] - n[0][_YY]};
+ double const B[2] = {n[2][_XX] - n[0][_XX], n[2][_YY] - n[0][_YY]};
+ double const C[2] = {n[3][_XX] - n[0][_XX], n[3][_YY] - n[0][_YY]};
+ double const N[2] = {B[_XX] - A[_XX] - C[_XX], B[_YY] - A[_YY] - C[_YY]};
+ double const P[2] = {p[_XX] - n[0][_XX], p[_YY] - n[0][_YY]};
// degenerated case: a rectangle:
if (fabs(N[0]) < prec && fabs(N[1]) < prec)
{
- double det = C[0]*A[1] -C[1]*A[0];
+ double const det = C[0]*A[1] -C[1]*A[0];
if (fabs(det) < prec)
throw INTERP_KERNEL::Exception("MappedBarycentric intersection type: quad_mapped_coords() has a degenerated 2x2 system!");
bc[0] = (P[0]*A[1]-P[1]*A[0])/det;
c = -P[0]*A[1] + P[1]*A[0];
cas1 = false;
}
- double delta = b*b - 4.0*a*c;
+ double const delta = b*b - 4.0*a*c;
if (delta < 0.0)
throw INTERP_KERNEL::Exception("MappedBarycentric intersection type: quad_mapped_coords(): imaginary solutions!");
bc[1] = 0.5*(-b+sqrt(delta))/a;
throw INTERP_KERNEL::Exception("MappedBarycentric intersection type: quad_mapped_coords(): point doesn't seem to be in quad4!");
if (cas1)
{
- double denom = C[0]+bc[1]*N[0];
+ double const denom = C[0]+bc[1]*N[0];
if (fabs(denom) < prec)
throw INTERP_KERNEL::Exception("MappedBarycentric intersection type: quad_mapped_coords(): point doesn't seem to be in quad4!");
bc[0] = (P[0]-bc[1]*A[0])/denom;
else
{
bc[0] = bc[1];
- double denom = A[1]+bc[0]*N[1];
+ double const denom = A[1]+bc[0]*N[1];
if (fabs(denom) < prec)
throw INTERP_KERNEL::Exception("MappedBarycentric intersection type: cuboid_mapped_coord(): point doesn't seem to be in quad4!");
bc[1] = (P[1]-bc[0]*C[1])/denom;
inline void cuboid_mapped_coords(const std::vector<const double*>& n, const double *p, double *bc)
{
- double prec = 1.0e-14;
+ double const prec = 1.0e-14;
enum { _XX=0, _YY };
if (n.size() != 8)
throw INTERP_KERNEL::Exception("INTERP_KERNEL::cuboid_mapped_coords: unrecognized geometric type! Only HEXA8 supported.");
double Surface=0;
for(unsigned long i=0; i<(Poly.size())/2-2; i++)
{
- double Surf=Surf_Tri( &Poly[0],&Poly[2*(i+1)],&Poly[2*(i+2)] );
+ double const Surf=Surf_Tri( &Poly[0],&Poly[2*(i+1)],&Poly[2*(i+2)] );
Surface=Surface + Surf ;
}
return Surface ;
{
bool A=false;
- double det_1=mon_determinant(P_1,P_3,P_0);
- double det_2=mon_determinant(P_3,P_2,P_0);
- double det_3=mon_determinant(P_2,P_1,P_0);
+ double const det_1=mon_determinant(P_1,P_3,P_0);
+ double const det_2=mon_determinant(P_3,P_2,P_0);
+ double const det_3=mon_determinant(P_2,P_1,P_0);
if( (det_1>=-eps && det_2>=-eps && det_3>=-eps) || (det_1<=eps && det_2<=eps && det_3<=eps) )
{
A=true;
inline void verif_point_dans_vect(const double* P, std::vector<double>& V, double absolute_precision )
{
- std::size_t taille=V.size();
+ std::size_t const taille=V.size();
bool isPresent=false;
for(std::size_t i=0;i<taille/2;i++)
{
std::vector<double>& V, double dim_caracteristic, double precision)
{
- double absolute_precision = precision*dim_caracteristic;
- bool A_1=INTERP_KERNEL::point_dans_triangle(P_1,P_4,P_5,P_6,absolute_precision);
+ double const absolute_precision = precision*dim_caracteristic;
+ bool const A_1=INTERP_KERNEL::point_dans_triangle(P_1,P_4,P_5,P_6,absolute_precision);
if(A_1)
verif_point_dans_vect(P_1,V,absolute_precision);
- bool A_2=INTERP_KERNEL::point_dans_triangle(P_2,P_4,P_5,P_6,absolute_precision);
+ bool const A_2=INTERP_KERNEL::point_dans_triangle(P_2,P_4,P_5,P_6,absolute_precision);
if(A_2)
verif_point_dans_vect(P_2,V,absolute_precision);
- bool A_3=INTERP_KERNEL::point_dans_triangle(P_3,P_4,P_5,P_6,absolute_precision);
+ bool const A_3=INTERP_KERNEL::point_dans_triangle(P_3,P_4,P_5,P_6,absolute_precision);
if(A_3)
verif_point_dans_vect(P_3,V,absolute_precision);
}
double dim_caracteristic, double precision)
{
// calcul du determinant de P_1P_2 et P_3P_4.
- double det=(P_2[0]-P_1[0])*(P_4[1]-P_3[1])-(P_4[0]-P_3[0])*(P_2[1]-P_1[1]);
+ double const det=(P_2[0]-P_1[0])*(P_4[1]-P_3[1])-(P_4[0]-P_3[0])*(P_2[1]-P_1[1]);
- double absolute_precision = dim_caracteristic*precision;
+ double const absolute_precision = dim_caracteristic*precision;
if(fabs(det)>absolute_precision)
{
- double k_1=-((P_3[1]-P_4[1])*(P_3[0]-P_1[0])+(P_4[0]-P_3[0])*(P_3[1]-P_1[1]))/det;
+ double const k_1=-((P_3[1]-P_4[1])*(P_3[0]-P_1[0])+(P_4[0]-P_3[0])*(P_3[1]-P_1[1]))/det;
if (k_1 >= -absolute_precision && k_1 <= 1+absolute_precision)
//if( k_1 >= -precision && k_1 <= 1+precision)
{
- double k_2= ((P_1[1]-P_2[1])*(P_1[0]-P_3[0])+(P_2[0]-P_1[0])*(P_1[1]-P_3[1]))/det;
+ double const k_2= ((P_1[1]-P_2[1])*(P_1[0]-P_3[0])+(P_2[0]-P_1[0])*(P_1[1]-P_3[1]))/det;
if (k_2 >= -absolute_precision && k_2 <= 1+absolute_precision)
//if( k_2 >= -precision && k_2 <= 1+precision)
inline void verif_maill_dans_vect(int Num, std::vector<int>& V)
{
- std::size_t taille=V.size();
+ std::size_t const taille=V.size();
int A=0;
for(std::size_t i=0;i<taille;i++)
{
public:
bool operator()(std::pair<double,double>theta1, std::pair<double,double> theta2) const
{
- double norm1 = sqrt(theta1.first*theta1.first +theta1.second*theta1.second);
- double norm2 = sqrt(theta2.first*theta2.first +theta2.second*theta2.second);
+ double const norm1 = sqrt(theta1.first*theta1.first +theta1.second*theta1.second);
+ double const norm2 = sqrt(theta2.first*theta2.first +theta2.second*theta2.second);
- double epsilon = 1.e-12;
+ double const epsilon = 1.e-12;
if( norm1 < epsilon || norm2 < epsilon )
std::cout << "Warning InterpolationUtils.hxx: AngleLess : Vector with zero norm, cannot define the angle !!!! " << std::endl;
inline std::vector<double> reconstruct_polygon(const std::vector<double>& V)
{
- int taille((int)V.size());
+ int const taille((int)V.size());
//VB : why 6 ?
{return V;}
else
{
- double *COS=new double[taille/2];
- double *SIN=new double[taille/2];
+ auto *COS=new double[taille/2];
+ auto *SIN=new double[taille/2];
//double *angle=new double[taille/2];
std::vector<double> Bary=bary_poly(V);
COS[0]=1.0;
// }
for(micossin=CosSin.begin();micossin!=CosSin.end();micossin++)
{
- int j=(*micossin).second;
+ int const j=(*micossin).second;
Pt_ordonne.push_back(V[2*j]);
Pt_ordonne.push_back(V[2*j+1]);
}
for (int i=0; i<nb_nodes; i++)
{
- double x = coordsOfMesh[3*(iP+i)];
- double y = coordsOfMesh[3*(iP+i)+1];
- double z = coordsOfMesh[3*(iP+i)+2];
+ double const x = coordsOfMesh[3*(iP+i)];
+ double const y = coordsOfMesh[3*(iP+i)+1];
+ double const z = coordsOfMesh[3*(iP+i)+2];
bb[0]=(x<bb[0])?x:bb[0];
bb[1]=(x>bb[1])?x:bb[1];
bb[2]=(y<bb[2])?y:bb[2];
std::vector<bool> sw(3,false);
double inpVect2[3];
std::transform(inpVect,inpVect + 3,inpVect2,[](double c){return fabs(c);});
- std::size_t posMin(std::distance(inpVect2,std::min_element(inpVect2,inpVect2+3)));
+ std::size_t const posMin(std::distance(inpVect2,std::min_element(inpVect2,inpVect2+3)));
sw[posMin]=true;
std::size_t posMax(std::distance(inpVect2,std::max_element(inpVect2,inpVect2+3)));
if(posMax==posMin)
{ posMax=(posMin+1)%3; }
sw[posMax]=true;
- std::size_t posMid(std::distance(sw.begin(),std::find(sw.begin(),sw.end(),false)));
+ std::size_t const posMid(std::distance(sw.begin(),std::find(sw.begin(),sw.end(),false)));
outVect[posMin]=0.; outVect[posMid]=1.; outVect[posMax]=-inpVect[posMid]/inpVect[posMax];
}
/*_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _*/
/* Computes the geometric angle (in [0,Pi]) between two non zero vectors AB and AC */
/*_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _*/
- template<int dim> inline double angle(const double * A, const double * B, const double * C, double * n)
+ template<int dim> inline double angle(const double * A, const double * B, const double * C, double * /*n*/)
{
double AB[dim];
double AC[dim];
double AB_dot_AC=dotprod<dim>(AB,AC);
for(int idim =0; idim<dim; idim++) orthAB[idim] = AC[idim]-AB_dot_AC*AB[idim];
- double denom= normAC+AB_dot_AC;
+ double const denom= normAC+AB_dot_AC;
double numer=norm<dim>(orthAB);
return 2*atan2(numer,denom);
*/
inline double TripleProduct(const double *A, const double *B, const double *C, const double *X)
{
- double XA[3]={ A[0]-X[0], A[1]-X[1], A[2]-X[2] };
- double XB[3]={ B[0]-X[0], B[1]-X[1], B[2]-X[2] };
- double XC[3]={ C[0]-X[0], C[1]-X[1], C[2]-X[2] };
+ double const XA[3]={ A[0]-X[0], A[1]-X[1], A[2]-X[2] };
+ double const XB[3]={ B[0]-X[0], B[1]-X[1], B[2]-X[2] };
+ double const XC[3]={ C[0]-X[0], C[1]-X[1], C[2]-X[2] };
- double XA_cross_XB[3] = {XA[1]*XB[2]-XA[2]*XB[1], XA[2]*XB[0]-XA[0]*XB[2], XA[0]*XB[1]-XA[1]*XB[0]};
+ double const XA_cross_XB[3] = {XA[1]*XB[2]-XA[2]*XB[1], XA[2]*XB[0]-XA[0]*XB[2], XA[0]*XB[1]-XA[1]*XB[0]};
// norm is equal to double the area of the triangle
- double norm = std::sqrt(XA_cross_XB[0]*XA_cross_XB[0]+XA_cross_XB[1]*XA_cross_XB[1]+XA_cross_XB[2]*XA_cross_XB[2]);
+ double const norm = std::sqrt(XA_cross_XB[0]*XA_cross_XB[0]+XA_cross_XB[1]*XA_cross_XB[1]+XA_cross_XB[2]*XA_cross_XB[2]);
return ( XA_cross_XB[0]*XC[0]+ XA_cross_XB[1]*XC[1] + XA_cross_XB[2]*XC[2] ) / norm;
}
#ifndef __INTERSECTOR3D_HXX__
#define __INTERSECTOR3D_HXX__
-#include "TargetIntersector.txx"
+#include "TargetIntersector.hxx"
+#include "NormalizedUnstructuredMesh.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
public:
static const int SPACEDIM=MyMeshType::MY_SPACEDIM;
static const int MESHDIM=MyMeshType::MY_MESHDIM;
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
public:
Intersector3D(const MyMeshType& targetMesh, const MyMeshType& srcMesh);
#define __INTERSECTOR3D_TXX__
#include "Intersector3D.hxx"
+#include "InterpolationUtils.hxx"
#include <algorithm>
+#include <vector>
namespace INTERP_KERNEL
{
{
ConnType nbNodesT=_target_mesh.getNumberOfNodesOfElement(icellT);
coordsT.resize(SPACEDIM*nbNodesT);
- std::vector<double>::iterator iter=coordsT.begin();
+ auto iter=coordsT.begin();
for (ConnType iT=0; iT<nbNodesT; iT++)
{
const double *coordsCur=getCoordsOfNode(iT,icellT,_target_mesh);
{
ConnType nbNodesS=_src_mesh.getNumberOfNodesOfElement(icellS);
coordsS.resize(SPACEDIM*nbNodesS);
- std::vector<double>::iterator iter=coordsS.begin();
+ auto iter=coordsS.begin();
for (ConnType iS=0; iS<nbNodesS; iS++)
{
const double *coordsCur=getCoordsOfNode(iS,icellS,_src_mesh);
#ifndef __INTERSECTOR3DP0P0_TXX__
#define __INTERSECTOR3DP0P0_TXX__
+#include "Intersector3D.hxx"
#include "Intersector3DP0P0.hxx"
-#include "Intersector3D.txx"
namespace INTERP_KERNEL
{
#ifndef __INTERSECTOR3DP0P1_TXX__
#define __INTERSECTOR3DP0P1_TXX__
+#include "Intersector3D.hxx"
#include "Intersector3DP0P1.hxx"
-#include "Intersector3D.txx"
namespace INTERP_KERNEL
{
#ifndef __INTERSECTOR3DP1P0_TXX__
#define __INTERSECTOR3DP1P0_TXX__
+#include "Intersector3D.hxx"
#include "Intersector3DP1P0.hxx"
-#include "Intersector3D.txx"
namespace INTERP_KERNEL
{
#ifndef __Intersector3DP1P0Bary_TXX__
#define __Intersector3DP1P0Bary_TXX__
+#include "Intersector3D.hxx"
#include "Intersector3DP1P0Bary.hxx"
-#include "Intersector3D.txx"
namespace INTERP_KERNEL
{
#ifndef __Intersector3DP1P1_TXX__
#define __Intersector3DP1P1_TXX__
+#include "Intersector3D.hxx"
#include "Intersector3DP1P1.hxx"
-#include "Intersector3D.txx"
namespace INTERP_KERNEL
{
#ifndef __IntersectorCU_HXX__
#define __IntersectorCU_HXX__
-#include "TargetIntersector.txx"
-#include "NormalizedUnstructuredMesh.hxx"
+#include "TargetIntersector.hxx"
+#include "InterpKernelException.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
#define __IntersectorCU_TXX__
#include "IntersectorCU.hxx"
+#include "InterpolationUtils.hxx"
+#include <limits>
+#include <vector>
// convert index "From Mesh Index"
#define _FMIU(i) OTT<typename MyUMeshType::MyConnType,MyUMeshType::My_numPol>::ind2C((i))
_CU_TEMPLATE
_INTERSECTOR_CU_::~IntersectorCU()
- {
- }
+ = default;
//================================================================================
/*!
const double* coord_node=_coordsU+SPACEDIM*(_FMCOO( _connectU[_FMCON (_connIndexU[_FMIU(icell)]+i)]));
for(int idim=0; idim<SPACEDIM; idim++)
{
- double x = *(coord_node+idim);
+ double const x = *(coord_node+idim);
bb[2*idim ] = (x<bb[2*idim ])?x:bb[2*idim ];
bb[2*idim+1] = (x>bb[2*idim+1])?x:bb[2*idim+1];
}
#define __IntersectorCU1D_HXX__
#include "IntersectorCU.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
class IntersectorCU1D : public IntersectorCU<MyCMeshType,MyUMeshType,MyMatrix,IntersectorCU1D<MyCMeshType,MyUMeshType,MyMatrix> >
{
public:
- typedef typename MyUMeshType::MyConnType UConnType;
- typedef typename MyCMeshType::MyConnType CConnType;
+ using UConnType = typename MyUMeshType::MyConnType;
+ using CConnType = typename MyCMeshType::MyConnType;
public:
IntersectorCU1D(const MyCMeshType& meshS, const MyUMeshType& meshT);
~IntersectorCU1D();
#ifndef __IntersectorCU1D_TXX__
#define __IntersectorCU1D_TXX__
+#include "IntersectorCU.hxx"
#include "IntersectorCU1D.hxx"
#include "IntersectorCU.txx"
+#include "InterpKernelException.hxx"
+#include <vector>
+#include <algorithm>
#define IntersectorCU1D_TEMPLATE template<class MyCMeshType, class MyUMeshType, class MyMatrix>
#define INTERSECTOR_CU1D IntersectorCU1D<MyCMeshType,MyUMeshType,MyMatrix >
IntersectorCU1D_TEMPLATE
INTERSECTOR_CU1D::~IntersectorCU1D()
- {
- }
+ = default;
//================================================================================
/*!
const double* coordsC = & _INTER_CU::_coordsC[0][ _FMIC(icellS[0]) ];
- double res = std::min( coordsU[1], coordsC[1] ) - std::max( coordsU[0], coordsC[0] );
+ double const res = std::min( coordsU[1], coordsC[1] ) - std::max( coordsU[0], coordsC[0] );
return res;
}
}
#define __IntersectorCU2D_HXX__
#include "IntersectorCU.hxx"
+#include "PlanarIntersectorP0P0.hxx"
+#include "TriangulationIntersector.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
class IntersectorCU2D : public IntersectorCU<MyCMeshType,MyUMeshType,MyMatrix,IntersectorCU2D<MyCMeshType,MyUMeshType,MyMatrix> >
{
public:
- typedef typename MyUMeshType::MyConnType UConnType;
- typedef typename MyCMeshType::MyConnType CConnType;
+ using UConnType = typename MyUMeshType::MyConnType;
+ using CConnType = typename MyCMeshType::MyConnType;
public:
IntersectorCU2D(const MyCMeshType& meshS, const MyUMeshType& meshT);
double intersectGeometry(UConnType icellT, const std::vector<CConnType>& icellC);
#ifndef __IntersectorCU2D_TXX__
#define __IntersectorCU2D_TXX__
+#include "IntersectorCU.hxx"
#include "IntersectorCU2D.hxx"
#include "IntersectorCU.txx"
+#include "InterpKernelException.hxx"
+#include "CellModel.hxx"
+#include "NormalizedGeometricTypes"
+#include <vector>
#define IntersectorCU2D_TEMPLATE template<class MyCMeshType, class MyUMeshType, class MyMatrix>
#define INTERSECTOR_CU2D IntersectorCU2D<MyCMeshType, MyUMeshType, MyMatrix >
#include "IntersectorCU.hxx"
#include "SplitterTetra.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
class IntersectorCU3D : public IntersectorCU<MyCMeshType,MyUMeshType,MyMatrix,IntersectorCU3D<MyCMeshType,MyUMeshType,MyMatrix> >
{
public:
- typedef typename MyUMeshType::MyConnType UConnType;
- typedef typename MyCMeshType::MyConnType CConnType;
+ using UConnType = typename MyUMeshType::MyConnType;
+ using CConnType = typename MyCMeshType::MyConnType;
public:
IntersectorCU3D(const MyCMeshType& meshS, const MyUMeshType& meshT, SplittingPolicy splitting_policy);
~IntersectorCU3D();
private:
- typedef SplitterTetra2<MyUMeshType, _Cartesian3D2UnstructHexMesh > TSplitter;
- typedef SplitterTetra <_Cartesian3D2UnstructHexMesh > TTetra;
+ using TSplitter = SplitterTetra2<MyUMeshType, _Cartesian3D2UnstructHexMesh>;
+ using TTetra = SplitterTetra<_Cartesian3D2UnstructHexMesh>;
_Cartesian3D2UnstructHexMesh* _uHexMesh;
TSplitter* _split;
};
#ifndef __IntersectorCU3D_TXX__
#define __IntersectorCU3D_TXX__
+#include "IntersectorCU.hxx"
#include "IntersectorCU3D.hxx"
#include "IntersectorCU.txx"
-#include "SplitterTetra.txx"
+#include "MCIdType.hxx"
+#include "NormalizedUnstructuredMesh.hxx"
+#include "InterpKernelException.hxx"
+#include "NormalizedGeometricTypes"
+#include "BoundingBox.hxx"
#define IntersectorCU3D_TEMPLATE template<class MyCMeshType, class MyUMeshType, class MyMatrix>
#define INTERSECTOR_CU3D IntersectorCU3D<MyCMeshType,MyUMeshType,MyMatrix >
public:
static const int MY_SPACEDIM=3;
static const int MY_MESHDIM=3;
- typedef mcIdType MyConnType;
+ using MyConnType = mcIdType;
static const NumberingPolicy My_numPol=ALL_C_MODE;
_Cartesian3D2UnstructHexMesh(const double * coords[3]): _coordsC(coords) {}
boundingBox[BoundingBox::ZMIN] = _coordsU[2];
boundingBox[BoundingBox::ZMAX] = _coordsU[2+4*MY_SPACEDIM];
}
- NormalizedCellType getTypeOfElement(mcIdType eltId) const { return NORM_HEXA8; }
- mcIdType getNumberOfNodesOfElement(mcIdType eltId) const { return 8; }
+ NormalizedCellType getTypeOfElement(mcIdType /*eltId*/) const { return NORM_HEXA8; }
+ mcIdType getNumberOfNodesOfElement(mcIdType /*eltId*/) const { return 8; }
mcIdType getNumberOfElements() const { return 1; }
mcIdType getNumberOfNodes() const { return 8; }
const double *getCoordinatesPtr() const { return _coordsU; }
IntersectorCU3D_TEMPLATE
INTERSECTOR_CU3D::~IntersectorCU3D()
{
- delete _uHexMesh; _uHexMesh=0;
+ delete _uHexMesh; _uHexMesh=nullptr;
delete _split; _split=0;
}
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+#include "INTERPKERNELDefines.hxx"
#include "InterpKernelDenseMatrix.txx"
template class INTERPKERNEL_EXPORT INTERP_KERNEL::DenseMatrixT<double>;
// Implementation coming from Numerical Recipes in C of 1994 (version 2.04)
#include "InterpKernelLUDecomp.hxx"
+#include "InterpKernelDenseMatrix.hxx"
#include "InterpKernelException.hxx"
+#include "MCIdType.hxx"
#include <cmath>
+#include <vector>
#include <sstream>
using namespace INTERP_KERNEL;
#pragma once
+#include "INTERPKERNELDefines.hxx"
#include "InterpKernelDenseMatrix.hxx"
+#include "MCIdType.hxx"
#include <vector>
namespace INTERP_KERNEL
// Implementation coming from Numerical Recipes in C of 1994 (version 2.04)
#include "InterpKernelQRDecomp.hxx"
+#include "InterpKernelDenseMatrix.hxx"
#include "InterpKernelException.hxx"
+#include "MCIdType.hxx"
#include <cmath>
+#include <vector>
+#include <sstream>
using namespace INTERP_KERNEL;
#pragma once
#include "InterpKernelDenseMatrix.hxx"
+#include "MCIdType.hxx"
#include <vector>
namespace INTERP_KERNEL
#else
-typedef std::int64_t mcIdType;
+using mcIdType = std::int64_t;
#endif
#ifdef WIN32
typedef long long mcPyPtrType;
#else
-typedef long mcPyPtrType;
+using mcPyPtrType = long;
#endif
template <class T> inline std::size_t ToSizeT(T val)
#ifndef __MappedBarycenter2DIntersectorP1P1_HXX__
#define __MappedBarycenter2DIntersectorP1P1_HXX__
+#include "NormalizedUnstructuredMesh.hxx"
#include "PlanarIntersector.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
public:
static const int SPACEDIM=MyMeshType::MY_SPACEDIM;
static const int MESHDIM=MyMeshType::MY_MESHDIM;
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
public:
MappedBarycentric2DIntersectorP1P1(const MyMeshType& meshT, const MyMeshType& meshS, double dimCaracteristic, double md3DSurf, double minDot3DSurf, double medianPlane, double precision, int orientation);
#ifndef __MappedBarycentric2DIntersectorP1P1_TXX__
#define __MappedBarycentric2DIntersectorP1P1_TXX__
+#include "InterpolationUtils.hxx"
#include "MappedBarycentric2DIntersectorP1P1.hxx"
-#include "PlanarIntersector.txx"
-#include "CellModel.hxx"
+#include "PlanarIntersector.hxx"
+#include "NormalizedGeometricTypes"
+#include "InterpKernelUtilities.hxx"
#include "PointLocatorAlgos.txx"
-#include "MeshUtils.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
#include "Intersector3DP1P1.hxx"
#include "NormalizedUnstructuredMesh.hxx"
-#include "InterpKernelUtilities.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
#ifndef __MAPPEDBARYCENTRIC3DINTERSECTORP1P1_TXX__
#define __MAPPEDBARYCENTRIC3DINTERSECTORP1P1_TXX__
-#include "MappedBarycentric3DIntersectorP1P1.hxx"
#include "Intersector3DP1P1.txx"
-#include "MeshUtils.hxx"
+#include "InterpolationUtils.hxx"
+#include "InterpKernelUtilities.hxx"
+#include "MappedBarycentric3DIntersectorP1P1.hxx"
+#include "NormalizedGeometricTypes"
+#include "CellModel.hxx"
+#include "PointLocatorAlgos.txx"
+#include <vector>
+#include <cstddef>
+#include <cmath>
namespace INTERP_KERNEL
{
template<class MyMeshType, class MyMatrix>
MappedBarycentric3DIntersectorP1P1<MyMeshType,MyMatrix>::~MappedBarycentric3DIntersectorP1P1()
- {
- }
+ = default;
/**
* @param targetCell in C mode.
//
#include "MeshElement.hxx"
+#include "BoundingBox.hxx"
namespace INTERP_KERNEL
{
template<class MyMeshType>
void assign(const ConnType index, const MyMeshType& mesh);
- ~MeshElement() { }
+ ~MeshElement() = default;
nbnodesincelltype getNumberOfNodes() const { return _number; }
private:
/// disallow copying
- MeshElement(const MeshElement& elem);
+ MeshElement(const MeshElement& elem) = delete;
nbnodesincelltype _number;
#ifndef __MESHELEMENT_TXX__
#define __MESHELEMENT_TXX__
+#include "InterpolationUtils.hxx"
+#include "InterpKernelException.hxx"
#include "MeshElement.hxx"
-#include "TetraAffineTransform.hxx"
-#include "TransformedTriangle.hxx"
#include "MeshUtils.hxx"
#include "BoundingBox.hxx"
#include <assert.h>
-#include <type_traits>
#include <limits>
#include <memory>
+#include <sstream>
namespace INTERP_KERNEL
{
#include "MeshElement.hxx"
#include "BoundingBox.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
#include <vector>
#ifndef __MESHREGION_TXX__
#define __MESHREGION_TXX__
+#include "MeshElement.hxx"
+#include "InterpolationUtils.hxx"
+#include "BoundingBox.hxx"
#include "MeshRegion.hxx"
-#include "MeshElement.txx"
#include "MeshUtils.hxx"
+#include <cassert>
namespace INTERP_KERNEL
{
*
*/
template<class ConnType>
- MeshRegion<ConnType>::MeshRegion():_box(0)
+ MeshRegion<ConnType>::MeshRegion():_box(nullptr)
{
}
const unsigned char numNodes = element->getNumberOfNodes();
const ConnType elemIdx = element->getIndex();
- if(_box == 0)
+ if(_box == nullptr)
{
- const double** pts = new const double*[numNodes];
+ const auto** pts = new const double*[numNodes];
// get coordinates of the nodes of the element
for(unsigned char i = 0 ; i < numNodes ; ++i)
#define __MESHUTILS_HXX__
#include "InterpolationUtils.hxx"
+#include "NormalizedGeometricTypes"
+#include "NormalizedUnstructuredMesh.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
#include "OrientationInverter.hxx"
#include "InterpKernelException.hxx"
#include "CellModel.hxx"
+#include "NormalizedGeometricTypes"
+#include "MCIdType.hxx"
+#include <iterator>
+#include <cstddef>
#include <sstream>
#include <algorithm>
void OrientationInverter2DQuadratic::operateAndShutUp(mcIdType *beginPt) const
{
- int nbNodes(getNbNodes());
+ int const nbNodes(getNbNodes());
std::reverse(beginPt+1,beginPt+nbNodes/2);
std::reverse(beginPt+nbNodes/2,beginPt+nbNodes);
}
void OrientationInverterQPolygon::operate(mcIdType *beginPt, mcIdType *endPt) const
{
- std::size_t sz(std::distance(beginPt,endPt));
+ std::size_t const sz(std::distance(beginPt,endPt));
std::reverse(beginPt+1,beginPt+sz/2);
std::reverse(beginPt+sz/2,endPt);
}
void OrientationInverter3DExtrusionLinear::operateAndShutUp(mcIdType *beginPt) const
{
- int nbNodes(getNbNodes());
+ int const nbNodes(getNbNodes());
std::reverse(beginPt+1,beginPt+nbNodes/2);
std::reverse(beginPt+nbNodes/2+1,beginPt+nbNodes);
}
{
public:
INTERPKERNEL_EXPORT static OrientationInverter *BuildInstanceFrom(NormalizedCellType gt);
- INTERPKERNEL_EXPORT virtual ~OrientationInverter() { }
+ INTERPKERNEL_EXPORT virtual ~OrientationInverter() = default;
INTERPKERNEL_EXPORT virtual void operate(mcIdType *beginPt, mcIdType *endPt) const = 0;
};
{
public:
OrientationInverterChecker(unsigned nbNodes):_nb_nodes(nbNodes) { }
- void operate(mcIdType *beginPt, mcIdType *endPt) const { check(beginPt,endPt); operateAndShutUp(beginPt); }
+ void operate(mcIdType *beginPt, mcIdType *endPt) const override { check(beginPt,endPt); operateAndShutUp(beginPt); }
virtual void operateAndShutUp(mcIdType *beginPt) const = 0;
protected:
unsigned getNbNodes() const { return _nb_nodes; }
{
public:
OrientationInverterSEG2():OrientationInverterChecker(2u) { }
- void operateAndShutUp(mcIdType *beginPt) const;
+ void operateAndShutUp(mcIdType *beginPt) const override;
};
class OrientationInverterSEG3 : public OrientationInverterChecker
{
public:
OrientationInverterSEG3():OrientationInverterChecker(3u) { }
- void operateAndShutUp(mcIdType *beginPt) const;
+ void operateAndShutUp(mcIdType *beginPt) const override;
};
class OrientationInverter2DLinear : public OrientationInverterChecker
{
public:
OrientationInverter2DLinear(unsigned nbNodes):OrientationInverterChecker(nbNodes) { }
- void operateAndShutUp(mcIdType *beginPt) const;
+ void operateAndShutUp(mcIdType *beginPt) const override;
};
class OrientationInverter2DQuadratic : public OrientationInverterChecker
{
public:
OrientationInverter2DQuadratic(unsigned nbNodes):OrientationInverterChecker(nbNodes) { }
- void operateAndShutUp(mcIdType *beginPt) const;
+ void operateAndShutUp(mcIdType *beginPt) const override;
};
class OrientationInverterPolygon : public OrientationInverter
{
public:
- void operate(mcIdType *beginPt, mcIdType *endPt) const;
+ void operate(mcIdType *beginPt, mcIdType *endPt) const override;
};
class OrientationInverterQPolygon : public OrientationInverter
{
public:
- void operate(mcIdType *beginPt, mcIdType *endPt) const;
+ void operate(mcIdType *beginPt, mcIdType *endPt) const override;
};
class OrientationInverterTetra4 : public OrientationInverterChecker
{
public:
OrientationInverterTetra4():OrientationInverterChecker(4u) { }
- void operateAndShutUp(mcIdType *beginPt) const;
+ void operateAndShutUp(mcIdType *beginPt) const override;
};
class OrientationInverterTetra10 : public OrientationInverterChecker
{
public:
OrientationInverterTetra10():OrientationInverterChecker(10u) { }
- void operateAndShutUp(mcIdType *beginPt) const;
+ void operateAndShutUp(mcIdType *beginPt) const override;
};
class OrientationInverterPyra5 : public OrientationInverterChecker
{
public:
OrientationInverterPyra5():OrientationInverterChecker(5u) { }
- void operateAndShutUp(mcIdType *beginPt) const;
+ void operateAndShutUp(mcIdType *beginPt) const override;
};
class OrientationInverterPyra13 : public OrientationInverterChecker
{
public:
OrientationInverterPyra13():OrientationInverterChecker(13u) { }
- void operateAndShutUp(mcIdType *beginPt) const;
+ void operateAndShutUp(mcIdType *beginPt) const override;
};
class OrientationInverter3DExtrusionLinear : public OrientationInverterChecker
{
public:
OrientationInverter3DExtrusionLinear(unsigned nbNodes):OrientationInverterChecker(nbNodes) { }
- void operateAndShutUp(mcIdType *beginPt) const;
+ void operateAndShutUp(mcIdType *beginPt) const override;
};
class OrientationInverter3DExtrusionQuadratic : public OrientationInverterChecker
{
public:
OrientationInverter3DExtrusionQuadratic(unsigned nbNodes):OrientationInverterChecker(nbNodes) { }
- void operateAndShutUp(mcIdType *beginPt) const;
+ void operateAndShutUp(mcIdType *beginPt) const override;
};
}
#ifndef __PLANAR2D1DINTERSECTORP0P0_HXX__
#define __PLANAR2D1DINTERSECTORP0P0_HXX__
+#include "NormalizedUnstructuredMesh.hxx"
#include "PlanarIntersector.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
#define __PLANAR2D1DINTERSECTORP0P0_TXX__
#include "Planar2D1DIntersectorP0P0.hxx"
+#include "PlanarIntersector.hxx"
+#include "InterpolationUtils.hxx"
+#include <vector>
+#include <set>
namespace INTERP_KERNEL
{
#include "TargetIntersector.txx"
#include "NormalizedUnstructuredMesh.hxx"
+#include <cstddef>
#include <map>
#include <set>
+#include <vector>
namespace INTERP_KERNEL
{
#include "InterpolationUtils.hxx"
#include "TranslationRotationMatrix.hxx"
+#include <cmath>
#include <iostream>
#include <limits>
+#include <vector>
namespace INTERP_KERNEL
{
template<class MyMeshType, class MyMatrix>
PlanarIntersector<MyMeshType,MyMatrix>::~PlanarIntersector()
- {
- }
+ = default;
/*!
\brief creates the bounding boxes for all the cells of mesh \a mesh
const double* coord_node=coords+SPACEDIM*OTT<ConnType,numPol>::coo2C(conn[OTT<ConnType,numPol>::conn2C(conn_index[icell]+j)]);
for(int idim=0; idim<SPACEDIM; idim++)
{
- double x=*(coord_node+idim);
+ double const x=*(coord_node+idim);
bbox[ibox*2*SPACEDIM + 2*idim] = (bbox[ibox*2*SPACEDIM + 2*idim] <x)?bbox[ibox*2*SPACEDIM + 2*idim ]:x;
bbox[ibox*2*SPACEDIM + 2*idim+1] = (bbox[ibox*2*SPACEDIM + 2*idim+1]>x)?bbox[ibox*2*SPACEDIM + 2*idim+1]:x;
}
const double* coord_node=coords+SPACEDIM*(OTT<ConnType,numPol>::coo2C(conn[OTT<ConnType,numPol>::conn2C(conn_index[OTT<ConnType,numPol>::ind2C(iP)]+i)]));
for(int idim=0; idim<SPACEDIM; idim++)
{
- double x = *(coord_node+idim);
+ double const x = *(coord_node+idim);
//double y = *(mesh.getCoordinates(MED_FULL_INTERLACE)+3*(iP+i)+1);
bb[2*idim ] = (x<bb[2*idim ])?x:bb[2*idim ];
bb[2*idim+1] = (x>bb[2*idim+1])?x:bb[2*idim+1];
prodvect[0]=G1[1]*G2[2]-G1[2]*G2[1];
prodvect[1]=G1[2]*G2[0]-G1[0]*G2[2];
prodvect[2]=G1[0]*G2[1]-G1[1]*G2[0];
- double prodscal=prodvect[0]*G3[0]+prodvect[1]*G3[1]+prodvect[2]*G3[2];
+ double const prodscal=prodvect[0]*G3[0]+prodvect[1]*G3[1]+prodvect[2]*G3[2];
if(fabs(prodscal)>md3DSurf)
return 0;
}
#ifndef __PLANARINTERSECTORP0P0_HXX__
#define __PLANARINTERSECTORP0P0_HXX__
+#include "NormalizedUnstructuredMesh.hxx"
#include "PlanarIntersector.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
public:
static const int SPACEDIM=MyMeshType::MY_SPACEDIM;
static const int MESHDIM=MyMeshType::MY_MESHDIM;
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
protected:
PlanarIntersectorP0P0(const MyMeshType& meshT, const MyMeshType& meshS, double dimCaracteristic, double precision, double md3DSurf, double minDot3DSurf, double medianPlane, bool doRotate, int orientation, int printLevel);
#ifndef __PLANARINTERSECTORP0P0_TXX__
#define __PLANARINTERSECTORP0P0_TXX__
+#include "PlanarIntersector.hxx"
#include "PlanarIntersectorP0P0.hxx"
+#include "InterpolationUtils.hxx"
namespace INTERP_KERNEL
{
#ifndef __PLANARINTERSECTORP0P1_HXX__
#define __PLANARINTERSECTORP0P1_HXX__
+#include "NormalizedUnstructuredMesh.hxx"
#include "PlanarIntersector.hxx"
-#include "InterpKernelUtilities.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
public:
static const int SPACEDIM=MyMeshType::MY_SPACEDIM;
static const int MESHDIM=MyMeshType::MY_MESHDIM;
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
protected:
PlanarIntersectorP0P1(const MyMeshType& meshT, const MyMeshType& meshS, double dimCaracteristic, double precision, double md3DSurf, double minDot3DSurf, double medianPlane, bool doRotate, int orientation, int printLevel);
#ifndef __PLANARINTERSECTORP0P1_TXX__
#define __PLANARINTERSECTORP0P1_TXX__
+#include "PlanarIntersector.txx"
+#include "InterpKernelUtilities.hxx"
+#include "NormalizedGeometricTypes"
#include "PlanarIntersectorP0P1.hxx"
#include "InterpolationUtils.hxx"
#include "CellModel.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
#ifndef __PlanarIntersectorP0P1Bary_HXX__
#define __PlanarIntersectorP0P1Bary_HXX__
+#include "NormalizedUnstructuredMesh.hxx"
#include "PlanarIntersector.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
#ifndef __PlanarIntersectorP0P1Bary_TXX__
#define __PlanarIntersectorP0P1Bary_TXX__
+#include "NormalizedGeometricTypes"
+#include "PlanarIntersector.hxx"
#include "PlanarIntersectorP0P1Bary.hxx"
#include "InterpolationUtils.hxx"
+#include "InterpKernelUtilities.hxx"
+#include "CellModel.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
#ifndef __PLANARINTERSECTORP0P1PL_HXX__
#define __PLANARINTERSECTORP0P1PL_HXX__
+#include "NormalizedUnstructuredMesh.hxx"
#include "PlanarIntersector.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
#ifndef __PLANARINTERSECTORP0P1PL_TXX__
#define __PLANARINTERSECTORP0P1PL_TXX__
+#include "PlanarIntersector.hxx"
+#include "InterpolationUtils.hxx"
+#include "InterpKernelUtilities.hxx"
#include "PlanarIntersectorP0P1PL.hxx"
-#include "PlanarIntersector.txx"
-#include "CellModel.hxx"
#include "PointLocatorAlgos.txx"
+#include <vector>
namespace INTERP_KERNEL
{
#ifndef __PLANARINTERSECTORP1P0_HXX__
#define __PLANARINTERSECTORP1P0_HXX__
+#include "NormalizedUnstructuredMesh.hxx"
#include "PlanarIntersector.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
#ifndef __PLANARINTERSECTORP1P0_TXX__
#define __PLANARINTERSECTORP1P0_TXX__
+#include "NormalizedGeometricTypes"
+#include "PlanarIntersector.txx"
#include "PlanarIntersectorP1P0.hxx"
#include "InterpolationUtils.hxx"
+#include "InterpKernelUtilities.hxx"
+#include "CellModel.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
#ifndef __PlanarIntersectorP1P0Bary_HXX__
#define __PlanarIntersectorP1P0Bary_HXX__
+#include "NormalizedUnstructuredMesh.hxx"
#include "PlanarIntersector.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
public:
static const int SPACEDIM=MyMeshType::MY_SPACEDIM;
static const int MESHDIM=MyMeshType::MY_MESHDIM;
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
protected:
PlanarIntersectorP1P0Bary(const MyMeshType& meshT, const MyMeshType& meshS, double dimCaracteristic, double precision, double md3DSurf, double minDot3DSurf, double medianPlane, bool doRotate, int orientation, int printLevel);
#ifndef __PlanarIntersectorP1P0Bary_TXX__
#define __PlanarIntersectorP1P0Bary_TXX__
+#include "NormalizedGeometricTypes"
+#include "PlanarIntersector.hxx"
#include "PlanarIntersectorP1P0Bary.hxx"
#include "InterpolationUtils.hxx"
+#include "InterpKernelUtilities.hxx"
+#include "CellModel.hxx"
+#include <vector>
#define PLAN_INTERSECTOR PlanarIntersectorP1P0Bary<MyMeshType,MyMatrix,ConcreteP1P0Intersector>
#define PLAN_INTER_TEMPLATE template<class MyMeshType, class MyMatrix, class ConcreteP1P0Intersector>
#ifndef __PLANARINTERSECTORP1P0PL_HXX__
#define __PLANARINTERSECTORP1P0PL_HXX__
+#include "NormalizedUnstructuredMesh.hxx"
#include "PlanarIntersector.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
public:
static const int SPACEDIM=MyMeshType::MY_SPACEDIM;
static const int MESHDIM=MyMeshType::MY_MESHDIM;
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
public:
PlanarIntersectorP1P0PL(const MyMeshType& meshT, const MyMeshType& meshS, double dimCaracteristic, double md3DSurf, double minDot3DSurf, double medianPlane, double precision, int orientation);
#ifndef __PLANARINTERSECTORP1P0PL_TXX__
#define __PLANARINTERSECTORP1P0PL_TXX__
-#include "PlanarIntersectorP1P0PL.hxx"
#include "PlanarIntersector.txx"
-#include "CellModel.hxx"
+#include "InterpolationUtils.hxx"
+#include "NormalizedGeometricTypes"
+#include "PlanarIntersectorP1P0PL.hxx"
+#include "InterpKernelUtilities.hxx"
+#include "VolSurfFormulae.hxx"
#include "PointLocatorAlgos.txx"
-#include "InterpKernelGeo2DQuadraticPolygon.hxx"
-#include "MeshUtils.hxx"
+#include <vector>
+#include <cmath>
namespace INTERP_KERNEL
{
#ifndef __PLANARINTERSECTORP1P1_HXX__
#define __PLANARINTERSECTORP1P1_HXX__
+#include "NormalizedUnstructuredMesh.hxx"
#include "PlanarIntersector.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
#ifndef __PLANARINTERSECTORP1P1_TXX__
#define __PLANARINTERSECTORP1P1_TXX__
+#include "PlanarIntersector.txx"
#include "PlanarIntersectorP1P1.hxx"
#include "InterpolationUtils.hxx"
-#include "CellModel.hxx"
+#include "InterpKernelUtilities.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
#ifndef __PLANARINTERSECTORP1P1PL_HXX__
#define __PLANARINTERSECTORP1P1PL_HXX__
+#include "NormalizedUnstructuredMesh.hxx"
#include "PlanarIntersector.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
#ifndef __PLANARINTERSECTORP1P1PL_TXX__
#define __PLANARINTERSECTORP1P1PL_TXX__
-#include "PlanarIntersectorP1P1PL.hxx"
#include "PlanarIntersector.txx"
-#include "CellModel.hxx"
+#include "InterpolationUtils.hxx"
+#include "NormalizedGeometricTypes"
+#include "PlanarIntersectorP1P1PL.hxx"
+#include "InterpKernelUtilities.hxx"
#include "PointLocatorAlgos.txx"
-#include "MeshUtils.hxx"
+#include <vector>
+#include <cmath>
namespace INTERP_KERNEL
{
#ifndef __POINTLOCATORINTERSECTOR_HXX__
#define __POINTLOCATORINTERSECTOR_HXX__
-#include "PlanarIntersectorP0P0.hxx"
-#include "PlanarIntersectorP0P1.hxx"
-#include "PlanarIntersectorP1P0.hxx"
-#include "PlanarIntersectorP1P1.hxx"
-#include "PlanarIntersectorP1P0Bary.hxx"
+#include "NormalizedUnstructuredMesh.hxx"
+#include "NormalizedGeometricTypes"
+#include <vector>
namespace INTERP_KERNEL
{
#define __POINTLOCATORINTERSECTOR_TXX__
#include "PointLocator2DIntersector.hxx"
-#include "PlanarIntersectorP0P0.txx"
-#include "PlanarIntersectorP0P1.txx"
-#include "PlanarIntersectorP1P0.txx"
-#include "PlanarIntersectorP1P1.txx"
-#include "PlanarIntersectorP1P0Bary.txx"
+#include "PlanarIntersector.hxx"
#include "CellModel.hxx"
-
-#include "InterpKernelGeo2DQuadraticPolygon.hxx"
#include "PointLocatorAlgos.txx"
+#include "NormalizedGeometricTypes"
+
+#include <vector>
+#include <numeric>
+
#define PTLOC2D_INTERSECTOR PointLocator2DIntersector<MyMeshType,MyMatrix,InterpType>
#define INTERSECTOR_TEMPLATE template<class MyMeshType, class MyMatrix, template <class MeshType, class TheMatrix, class ThisIntersector> class InterpType>
#include "Intersector3DP0P0.hxx"
#include "NormalizedUnstructuredMesh.hxx"
-#include "InterpKernelUtilities.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
#ifndef __POINTLOCATOR3DINTERSECTORP0P0_TXX__
#define __POINTLOCATOR3DINTERSECTORP0P0_TXX__
-#include "PointLocator3DIntersectorP0P0.hxx"
#include "Intersector3DP0P0.txx"
-#include "MeshUtils.hxx"
+#include "InterpolationUtils.hxx"
+#include "InterpKernelUtilities.hxx"
+#include "NormalizedGeometricTypes"
+#include "CellModel.hxx"
+#include "PointLocator3DIntersectorP0P0.hxx"
+#include "VolSurfFormulae.hxx"
-#include "SplitterTetra.txx"
#include "PointLocatorAlgos.txx"
+#include <vector>
namespace INTERP_KERNEL
{
template<class MyMeshType, class MyMatrix>
PointLocator3DIntersectorP0P0<MyMeshType,MyMatrix>::~PointLocator3DIntersectorP0P0()
- {
- }
+ = default;
/**
*
#include "Intersector3DP0P1.hxx"
#include "NormalizedUnstructuredMesh.hxx"
-#include "InterpKernelUtilities.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
#ifndef __POINTLOCATOR3DINTERSECTORP0P1_TXX__
#define __POINTLOCATOR3DINTERSECTORP0P1_TXX__
-#include "PointLocator3DIntersectorP0P1.hxx"
#include "Intersector3DP0P1.txx"
-#include "MeshUtils.hxx"
+#include "InterpolationUtils.hxx"
+#include "InterpKernelUtilities.hxx"
+#include "NormalizedGeometricTypes"
+#include "PointLocator3DIntersectorP0P1.hxx"
+#include "PointLocatorAlgos.txx"
+#include "CellModel.hxx"
+#include <vector>
+#include <cstddef>
namespace INTERP_KERNEL
{
template<class MyMeshType, class MyMatrix>
PointLocator3DIntersectorP0P1<MyMeshType,MyMatrix>::~PointLocator3DIntersectorP0P1()
- {
- }
+ = default;
/**
*
#include "Intersector3DP1P0.hxx"
#include "NormalizedUnstructuredMesh.hxx"
-#include "InterpKernelUtilities.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
public:
static const int SPACEDIM=MyMeshType::MY_SPACEDIM;
static const int MESHDIM=MyMeshType::MY_MESHDIM;
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
public:
PointLocator3DIntersectorP1P0(const MyMeshType& targetMesh, const MyMeshType& srcMesh, double precision);
#ifndef __POINTLOCATOR3DINTERSECTORP1P0_TXX__
#define __POINTLOCATOR3DINTERSECTORP1P0_TXX__
-#include "PointLocator3DIntersectorP1P0.hxx"
#include "Intersector3DP1P0.txx"
-#include "MeshUtils.hxx"
+#include "InterpolationUtils.hxx"
+#include "InterpKernelUtilities.hxx"
+#include "NormalizedGeometricTypes"
+#include "PointLocator3DIntersectorP1P0.hxx"
+#include "CellModel.hxx"
+#include "PointLocatorAlgos.txx"
+#include "VolSurfFormulae.hxx"
+#include <vector>
+#include <cmath>
namespace INTERP_KERNEL
{
template<class MyMeshType, class MyMatrix>
PointLocator3DIntersectorP1P0<MyMeshType,MyMatrix>::~PointLocator3DIntersectorP1P0()
- {
- }
+ = default;
/**
* @param targetCell in C mode.
#include "Intersector3DP1P1.hxx"
#include "NormalizedUnstructuredMesh.hxx"
-#include "InterpKernelUtilities.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
public:
static const int SPACEDIM=MyMeshType::MY_SPACEDIM;
static const int MESHDIM=MyMeshType::MY_MESHDIM;
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
public:
PointLocator3DIntersectorP1P1(const MyMeshType& targetMesh, const MyMeshType& srcMesh, double precision);
#ifndef __POINTLOCATOR3DINTERSECTORP1P1_TXX__
#define __POINTLOCATOR3DINTERSECTORP1P1_TXX__
-#include "PointLocator3DIntersectorP1P1.hxx"
#include "Intersector3DP1P1.txx"
-#include "MeshUtils.hxx"
+#include "InterpolationUtils.hxx"
+#include "InterpKernelUtilities.hxx"
+#include "NormalizedGeometricTypes"
+#include "PointLocator3DIntersectorP1P1.hxx"
+#include "CellModel.hxx"
+#include "PointLocatorAlgos.txx"
+#include <vector>
+#include <cstddef>
+#include <cmath>
namespace INTERP_KERNEL
{
template<class MyMeshType, class MyMatrix>
PointLocator3DIntersectorP1P1<MyMeshType,MyMatrix>::~PointLocator3DIntersectorP1P1()
- {
- }
+ = default;
/**
* @param targetCell in C mode.
#ifndef __POINTLOCATORALGOS_TXX__
#define __POINTLOCATORALGOS_TXX__
+#include "InterpKernelGeo2DPrecision.hxx"
#include "InterpolationUtils.hxx"
#include "CellModel.hxx"
#include "BBTree.txx"
#include "InterpKernelGeo2DNode.hxx"
#include "InterpKernelGeo2DQuadraticPolygon.hxx"
+#include "MCIdType.hxx"
+#include "NormalizedUnstructuredMesh.hxx"
+#include "NormalizedGeometricTypes"
+#include <algorithm>
+#include <cmath>
#include <list>
#include <vector>
#include <set>
class GenericPointLocatorAlgos
{
public:
- virtual ~GenericPointLocatorAlgos() { }
+ virtual ~GenericPointLocatorAlgos() = default;
virtual std::list<mcIdType> locates(const double* x, double eps) = 0;
};
_tree=new BBTree<SPACEDIM,typename MyMeshType::MyConnType>(_bb,0,0,nelem);
}
- ~PointLocatorAlgos()
+ ~PointLocatorAlgos() override
{
delete[] _bb;
delete _tree;
//returns the list of elements that contains
//the point pointed to by x
- std::list<typename MyMeshType::MyConnType> locates(const double* x, double eps)
+ std::list<typename MyMeshType::MyConnType> locates(const double* x, double eps) override
{
typedef typename MyMeshType::MyConnType ConnType;
const NumberingPolicy numPol=MyMeshType::My_numPol;
here XA^XC and XC^XB have different signs*/
const int SPACEDIM=MyMeshType::MY_SPACEDIM;
- std::unique_ptr<char[]> sign( new char[nbEdges] );
+ std::unique_ptr<char[]> const sign( new char[nbEdges] );
for (mcIdType iedge=0; iedge<nbEdges; iedge++)
{
const double* A=cellPts+SPACEDIM*iedge;
const double* B=cellPts+SPACEDIM*((iedge+1)%nbEdges);
- double a=mon_determinant(ptToTest, A, B);
+ double const a=mon_determinant(ptToTest, A, B);
if(a<-eps)
sign[iedge]=-1;
else if(a>eps)
// Same as isElementContainsPointAlg2DSimple() with a different input format ...
static bool isElementContainsPointAlgo2DSimple2(const double *ptToTest, NormalizedCellType type,
const double *coords, const typename MyMeshType::MyConnType *conn_elem,
- typename MyMeshType::MyConnType conn_elem_sz, double eps)
+ typename MyMeshType::MyConnType /*conn_elem_sz*/, double eps)
{
const int SPACEDIM=MyMeshType::MY_SPACEDIM;
typedef typename MyMeshType::MyConnType ConnType;
const CellModel& cmType=CellModel::GetCellModel(type);
bool ret=false;
- int nbEdges=cmType.getNumberOfSons();
- double *pts = new double[nbEdges*SPACEDIM];
+ int const nbEdges=cmType.getNumberOfSons();
+ auto *pts = new double[nbEdges*SPACEDIM];
for (int iedge=0; iedge<nbEdges; iedge++)
{
const double* a=coords+SPACEDIM*(OTT<ConnType,numPol>::ind2C(conn_elem[iedge]));
typename MyMeshType::MyConnType conn_elem_sz, double eps)
{
// Override precision for this method only:
- INTERP_KERNEL::QuadraticPlanarPrecision prec(eps);
+ INTERP_KERNEL::QuadraticPlanarPrecision const prec(eps);
const int SPACEDIM=MyMeshType::MY_SPACEDIM;
typedef typename MyMeshType::MyConnType ConnType;
const NumberingPolicy numPol=MyMeshType::My_numPol;
std::vector<INTERP_KERNEL::Node *> nodes(conn_elem_sz);
- INTERP_KERNEL::QuadraticPolygon *pol(0);
+ INTERP_KERNEL::QuadraticPolygon *pol(nullptr);
for(mcIdType j=0;j<conn_elem_sz;j++)
{
mcIdType nodeId(OTT<ConnType,numPol>::ind2C(conn_elem[j]));
pol=INTERP_KERNEL::QuadraticPolygon::BuildLinearPolygon(nodes);
else
pol=INTERP_KERNEL::QuadraticPolygon::BuildArcCirclePolygon(nodes);
- INTERP_KERNEL::Node *n(new INTERP_KERNEL::Node(ptToTest[0],ptToTest[1]));
+ auto *n(new INTERP_KERNEL::Node(ptToTest[0],ptToTest[1]));
double a(0.),b(0.),c(0.);
a=pol->normalizeMe(b,c); n->applySimilarity(b,c,a);
- bool ret=pol->isInOrOut2(n);
+ bool const ret=pol->isInOrOut2(n);
delete pol; n->decrRef();
return ret;
}
const NumberingPolicy numPol=MyMeshType::My_numPol;
int nbfaces = cmType.getNumberOfSons2(conn_elem,conn_elem_sz);
- std::unique_ptr<char[]> sign( new char[nbfaces] );
+ std::unique_ptr<char[]> const sign( new char[nbfaces] );
std::unique_ptr<ConnType[]> connOfSon( new ConnType[conn_elem_sz] );
- std::unique_ptr<double[]> ptsOfTetrahedrizedPolyhedron( new double[3*3*nbfaces] );
+ std::unique_ptr<double[]> const ptsOfTetrahedrizedPolyhedron( new double[3*3*nbfaces] );
for (int iface=0; iface<nbfaces; iface++)
{
NormalizedCellType typeOfSon;
}
}
double centerPt[3];
- double normalizeFact = NormalizeTetrahedrizedPolyhedron(ptsOfTetrahedrizedPolyhedron.get(),nbfaces,centerPt);
+ double const normalizeFact = NormalizeTetrahedrizedPolyhedron(ptsOfTetrahedrizedPolyhedron.get(),nbfaces,centerPt);
double ptToTestNorm[3] = {(ptToTest[0]-centerPt[0])/normalizeFact,
(ptToTest[1]-centerPt[1])/normalizeFact,
(ptToTest[2]-centerPt[2])/normalizeFact};
{
double p1=coords[(OTT<ConnType,numPol>::ind2C(conn_elem[0]))];
double p2=coords[(OTT<ConnType,numPol>::ind2C(conn_elem[1]))];
- double delta=fabs(p1-p2)+eps;
- double val=*ptToTest-std::min(p1,p2);
+ double const delta=fabs(p1-p2)+eps;
+ double const val=*ptToTest-std::min(p1,p2);
return val>-eps && val<delta;
}
throw INTERP_KERNEL::Exception("Invalid spacedim detected ! Managed spaceDim are 2 and 3 !");
#ifndef __POLYGONALGORITHMS_HXX__
#define __POLYGONALGORITHMS_HXX__
+#include <utility>
#include <vector>
#include <deque>
#include <map>
#include "PolygonAlgorithms.hxx"
#include "InterpolationUtils.hxx"
+#include <cmath>
+#include <deque>
+#include <cstdlib>
#include <list>
#include <map>
#include <iostream>
+#include <utility>
+#include <vector>
namespace INTERP_KERNEL
{
/* i is the local index of the current vertex */
/*************************************************************/
template<int DIM>
- inline void PolygonAlgorithms<DIM>::addNewVertex( int i, int i_glob, int i_next_glob, int i_prev_glob,
+ inline void PolygonAlgorithms<DIM>::addNewVertex( int i, int i_glob, int i_next_glob, int /*i_prev_glob*/,
const double * P)
{
/* Question:Should we add vertex i to the front or back ? */
//fifth and sixth arguments are useless here
{
/* Updating _End_segments */
- std::pair< int,int > i_i_next = std::make_pair(i, i_next);
- std::pair< int,int > j_j_next = std::make_pair(j, j_next);
+ std::pair< int,int > const i_i_next = std::make_pair(i, i_next);
+ std::pair< int,int > const j_j_next = std::make_pair(j, j_next);
if( _End_segments[0] == i_i_next)
{
for(int idim=DIM-1;idim>-1;idim--) _Inter.push_front(ABCD[idim]);
/* Updating _Status */
_Status.insert(make_pair(i_next,std::make_pair(i, false)));
- std::multimap< int, std::pair< int,bool> >::iterator mi =_Status.find(j_next);
+ auto mi =_Status.find(j_next);
((* mi).second).second= !((* mi).second).second;
}
else _Status.insert(std::make_pair(i_next,std::make_pair(i,true)));
int& j3, int& j3_glob, int& j4, int& j4_glob,
int& i_glob, int& i_next_glob, int& i_prev_glob,
const double * P_1, const double * P_2,
- int N1, int N2, int sign)
+ int N1, int N2, int /*sign*/)
{
int N0, shift;
if(i_glob < N1)
Poly1 = P_1;
Poly2 = P_2;
- std::multimap< int, std::pair< int,bool> >::reverse_iterator mi1=_Status.rbegin();
+ auto mi1=_Status.rbegin();
j1_glob=((*mi1).second).first;
j1=j1_glob-N1;
j2_glob=(*mi1).first;
Poly1 = P_2;
Poly2 = P_1;
- std::multimap< int, std::pair< int,bool> >::iterator mi2= _Status.begin();
+ auto mi2= _Status.begin();
j1_glob=((*mi2).second).first;
j1=j1_glob;
j2_glob=(*mi2).first;
/******** Treatment of the first vertex ********/
mi1=events.begin();
i_glob = (* mi1).second;
- bool which_start = i_glob < N1;
+ bool const which_start = i_glob < N1;
if(i_glob < N1){ i_next_glob = (i_glob +1)%N1; i_prev_glob = (i_glob -1+N1)%N1;}
else{ i_next_glob = (i_glob-N1+1)%N2 + N1;i_prev_glob = (i_glob-N1-1+N2)%N2 + N1;}
_Status.insert(std::make_pair(i_next_glob,std::make_pair(i_glob, false)));
which_is_inside[inside_j2] = std::make_pair(j1_glob,j2_glob);
which_is_inside[inside_j4] = std::make_pair(j3_glob,j4_glob);
- std::map<double, std::pair<int,int> >::iterator min = which_is_inside.begin();
- std::map<double, std::pair<int,int> >::iterator minext = min;
+ auto const min = which_is_inside.begin();
+ auto minext = min;
minext++;
- std::map<double, std::pair<int,int> >::reverse_iterator max = which_is_inside.rbegin();
- std::multimap< int, std::pair< int,bool> >::iterator j2_in_status = _Status.find(((*min).second).second);
- std::multimap< int, std::pair< int,bool> >::iterator j4_in_status = _Status.find(((*minext).second).second);
+ auto const max = which_is_inside.rbegin();
+ auto j2_in_status = _Status.find(((*min).second).second);
+ auto j4_in_status = _Status.find(((*minext).second).second);
if((*min).first < -_epsilon) //there is someone clearly inside
{
/* in the end, subP contains only the elements belonging to the convex hull, and not_in_hull the others */
/**************************************************************************/
template<int DIM>
- inline void PolygonAlgorithms<DIM>::convHull(const double *P, int N, double * normal,
+ inline void PolygonAlgorithms<DIM>::convHull(const double *P, int /*N*/, double * normal,
std::map< int,int >& subP, std::map< int,int >& not_in_hull,
int& NsubP, const double epsilon)
{
if(NsubP>3)
{
- std::map< int,int >::iterator mi_prev = subP.begin();
- std::map< int,int >::iterator mi = mi_prev;
+ auto mi_prev = subP.begin();
+ auto mi = mi_prev;
mi++;
- std::map< int,int >::iterator mi_next = mi;
+ auto mi_next = mi;
mi_next++;
double directframe=0.;
/* Check if the polygon subP is positively oriented */
- std::map< int,int >::iterator mi1=mi;
+ auto mi1=mi;
while(mi1 != subP.end() && distance2<DIM>(&P[DIM*(*subP.begin()).second],&P[DIM*(*mi1).second])< epsilon)
mi1++;
- std::map< int,int >::iterator mi2=mi1;
+ auto mi2=mi1;
while(mi2 != subP.end() && fabs(directframe)<epsilon)
{
directframe =direct_frame<DIM>(&P[DIM* (*mi1).second],
#define __POLYHEDRON3D2DINTERSECTORP0P0_HXX__
#include "Intersector3DP0P0.hxx"
+#include "MCIdType.hxx"
#include "SplitterTetra.hxx"
#include "NormalizedUnstructuredMesh.hxx"
+#include <map>
+#include <set>
+#include <vector>
namespace INTERP_KERNEL
{
template<class MyMeshType, class MyMatrixType>
class Polyhedron3D2DIntersectorP0P0 : public Intersector3DP0P0<MyMeshType,MyMatrixType>
{
- typedef typename std::map<mcIdType,std::set<mcIdType> > DuplicateFacesType;
+ using DuplicateFacesType = typename std::map<mcIdType, std::set<mcIdType>>;
public:
static const int SPACEDIM=MyMeshType::MY_SPACEDIM;
static const int MESHDIM=MyMeshType::MY_MESHDIM;
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
public:
#ifndef __POLYHEDRON3D2DINTERSECTORP0P0_TXX__
#define __POLYHEDRON3D2DINTERSECTORP0P0_TXX__
-#include "Polyhedron3D2DIntersectorP0P0.hxx"
+#include "NormalizedGeometricTypes"
#include "Intersector3DP0P0.txx"
+#include "Intersector3D.hxx"
+#include "InterpolationUtils.hxx"
+#include "CellModel.hxx"
+#include "MCIdType.hxx"
+#include "Polyhedron3D2DIntersectorP0P0.hxx"
#include "MeshUtils.hxx"
-
+#include <vector>
#include "SplitterTetra.txx"
+#include <set>
+
namespace INTERP_KERNEL
{
const CellModel& cellModelCell=CellModel::GetCellModel(normCellType);
const MyMeshType& src_mesh = Intersector3D<MyMeshType,MyMatrixType>::_src_mesh;
ConnType nbOfNodes4Type=cellModelCell.isDynamic() ? src_mesh.getNumberOfNodesOfElement(cellSrcIdx) : cellModelCell.getNumberOfNodes();
- mcIdType *polyNodes=new mcIdType[nbOfNodes4Type];
- double **polyCoords = new double*[nbOfNodes4Type];
+ auto *polyNodes=new mcIdType[nbOfNodes4Type];
+ auto **polyCoords = new double*[nbOfNodes4Type];
for(int i = 0;i<(int)nbOfNodes4Type;++i)
{
// we could store mapping local -> global numbers too, but not sure it is worth it
if (isSrcFaceColinearWithFaceOfTetraTargetCell)
{
- DuplicateFacesType::iterator intersectFacesIter = _intersect_faces.find(cellSrcIdx);
+ auto intersectFacesIter = _intersect_faces.find(cellSrcIdx);
if (intersectFacesIter != _intersect_faces.end())
{
intersectFacesIter->second.insert(targetCell);
#include "Intersector3DP0P0.hxx"
#include "SplitterTetra.hxx"
#include "NormalizedUnstructuredMesh.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
public:
static const int SPACEDIM=MyMeshType::MY_SPACEDIM;
static const int MESHDIM=MyMeshType::MY_MESHDIM;
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
public:
#define __POLYHEDRONINTERSECTORP0P0_TXX__
#include "PolyhedronIntersectorP0P0.hxx"
-#include "Intersector3DP0P0.txx"
-#include "MeshUtils.hxx"
+#include <vector>
+
+#include "NormalizedGeometricTypes"
+#include "Intersector3DP0P0.txx"
+#include "InterpolationUtils.hxx"
#include "SplitterTetra.txx"
namespace INTERP_KERNEL
#include "Intersector3DP0P1.hxx"
#include "SplitterTetra.hxx"
#include "NormalizedUnstructuredMesh.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
#ifndef __POLYHEDRONINTERSECTORP0P1_TXX__
#define __POLYHEDRONINTERSECTORP0P1_TXX__
-#include "PolyhedronIntersectorP0P1.hxx"
+#include "NormalizedGeometricTypes"
#include "Intersector3DP0P1.txx"
-#include "MeshUtils.hxx"
+#include "InterpolationUtils.hxx"
+#include "PolyhedronIntersectorP0P1.hxx"
-#include "SplitterTetra.txx"
+#include "SplitterTetra.hxx"
+#include <sstream>
+#include <vector>
namespace INTERP_KERNEL
{
for(typename std::vector<SplitterTetra<MyMeshType>*>::iterator iter = _tetra.begin(); iter != _tetra.end(); ++iter)
{
(*iter)->splitIntoDualCells(subTetras);
- for(int i=0;i<24;i++)
+ for(auto tmp : subTetras)
{
- SplitterTetra<MyMeshType> *tmp=subTetras[i];
double volume = tmp->intersectSourceCell(*iterCellS);
if(volume!=0.)
{
#include "Intersector3DP1P0.hxx"
#include "SplitterTetra.hxx"
#include "NormalizedUnstructuredMesh.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
public:
static const int SPACEDIM=MyMeshType::MY_SPACEDIM;
static const int MESHDIM=MyMeshType::MY_MESHDIM;
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
public:
#ifndef __POLYHEDRONINTERSECTORP1P0_TXX__
#define __POLYHEDRONINTERSECTORP1P0_TXX__
-#include "PolyhedronIntersectorP1P0.hxx"
+#include "NormalizedGeometricTypes"
#include "Intersector3DP1P0.txx"
-#include "MeshUtils.hxx"
+#include "InterpKernelException.hxx"
+#include "InterpolationUtils.hxx"
+#include "Intersector3D.txx"
+#include "PolyhedronIntersectorP1P0.hxx"
#include "SplitterTetra.txx"
+#include <vector>
namespace INTERP_KERNEL
{
{
(*iter)->splitIntoDualCells(subTetras);
double vol2 = 0.;
- for(int i=0;i<24;i++)
+ for(auto tmp : subTetras)
{
- SplitterTetra<MyMeshType> *tmp=subTetras[i];
double volume = tmp->intersectSourceCell(targetCell);
vol2 += volume;
ConnType sourceNode=tmp->getId(0);
#include "Intersector3DP1P0Bary.hxx"
#include "SplitterTetra.hxx"
#include "NormalizedUnstructuredMesh.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
public:
static const int SPACEDIM=MyMeshType::MY_SPACEDIM;
static const int MESHDIM=MyMeshType::MY_MESHDIM;
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
public:
#ifndef __PolyhedronIntersectorP1P0Bary_TXX__
#define __PolyhedronIntersectorP1P0Bary_TXX__
-#include "PolyhedronIntersectorP1P0Bary.hxx"
+#include "NormalizedGeometricTypes"
#include "Intersector3DP1P0Bary.txx"
-#include "MeshUtils.hxx"
+#include "InterpolationUtils.hxx"
+#include "Intersector3D.txx"
+#include "PolyhedronIntersectorP1P0Bary.hxx"
+// #include "MeshUtils.hxx"
#include "SplitterTetra.txx"
+#include <vector>
namespace INTERP_KERNEL
{
#define __PolyhedronIntersectorP1P1_HXX__
#include "Intersector3DP1P1.hxx"
-#include "SplitterTetra.hxx"
#include "NormalizedUnstructuredMesh.hxx"
+#include "NormalizedGeometricTypes"
+#include <vector>
namespace INTERP_KERNEL
{
public:
static const int SPACEDIM=MyMeshType::MY_SPACEDIM;
static const int MESHDIM=MyMeshType::MY_MESHDIM;
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
public:
#define __PolyhedronIntersectorP1P1_TXX__
#include "PolyhedronIntersectorP1P1.hxx"
+
+#include "NormalizedGeometricTypes"
#include "Intersector3DP1P1.txx"
-#include "MeshUtils.hxx"
+#include "InterpolationUtils.hxx"
+#include "Intersector3D.txx"
+// #include "MeshUtils.hxx"
#include "SplitterTetra.txx"
+#include <vector>
+#include <utility>
namespace INTERP_KERNEL
{
* @param policy splitting policy to be used
*/
template<class MyMeshType, class MyMatrix>
- PolyhedronIntersectorP1P1<MyMeshType,MyMatrix>::PolyhedronIntersectorP1P1(const MyMeshType& targetMesh, const MyMeshType& srcMesh, SplittingPolicy policy):Intersector3DP1P1<MyMeshType,MyMatrix>(targetMesh,srcMesh)
+ PolyhedronIntersectorP1P1<MyMeshType,MyMatrix>::PolyhedronIntersectorP1P1(const MyMeshType& targetMesh, const MyMeshType& srcMesh, SplittingPolicy /*policy*/):Intersector3DP1P1<MyMeshType,MyMatrix>(targetMesh,srcMesh)
{
// SPEC:
// "Limitation. Concerning P1P1 3D improvement only tetrahedron will be supported.
*/
template<class MyMeshType, class MyMatrix>
PolyhedronIntersectorP1P1<MyMeshType,MyMatrix>::~PolyhedronIntersectorP1P1()
- {
- }
+ = default;
/**
* Calculates the volume of intersection of an element in the source mesh and the target element
srcTetra.splitIntoDualCells(subTetrasS);
// intersect each target subTetra with each source one
- for(int i=0;i<24;i++)
+ for(auto tmp : subTetrasS)
{
- SplitterTetra<MyMeshType> *tmp=subTetrasS[i];
ConnType sourceNode=OTT<ConnType,numPol>::indFC(tmp->getId(0));
- for(int j=0;j<24;j++)
+ for(auto & subTetraNode : subTetraNodes)
{
- const double* tetraNodes12 = &subTetraNodes[j].second[0];
+ const double* tetraNodes12 = &subTetraNode.second[0];
const double* tetraNodesT[4]={ tetraNodes12, tetraNodes12+3, tetraNodes12+6, tetraNodes12+9 };
double volume = tmp->intersectTetra( tetraNodesT );
if(volume!=0.)
{
- ConnType tgtNode=subTetraNodes[j].first;
+ ConnType tgtNode=subTetraNode.first;
typename MyMatrix::value_type& resRow = res[tgtNode];
typename MyMatrix::value_type::const_iterator iterRes=resRow.find( sourceNode );
if(iterRes!=resRow.end())
{
public:
- RegionNode() { }
+ RegionNode() = default;
- ~RegionNode() { }
+ ~RegionNode() = default;
/**
* Accessor to source region
// Author : Anthony Geay (CEA/DEN)
#include "SplitterTetra.hxx"
+#include "MCIdType.hxx"
+#include "InterpKernelException.hxx"
+#include <vector>
+#include <iterator>
+#include <cstddef>
namespace INTERP_KERNEL
{
tmp2[0]=0.; tmp2[1]=0.; tmp2[2]=0.;
for(int j=0;j<4;j++,conn+=4)
{
- mcIdType tmp3(nodalConnBg[GENERAL_24_SUB_NODES_WO[4*i+j]]);
+ mcIdType const tmp3(nodalConnBg[GENERAL_24_SUB_NODES_WO[4*i+j]]);
tmp2[0]+=coords[3*tmp3+0];
tmp2[1]+=coords[3*tmp3+1];
tmp2[2]+=coords[3*tmp3+2];
{
case NORM_TETRA4:
{
- std::size_t sz(std::distance(nodalConnBg,nodalConnEnd));
+ std::size_t const sz(std::distance(nodalConnBg,nodalConnEnd));
if(sz!=4)
throw INTERP_KERNEL::Exception("SplitIntoTetras : input tetra do not have 4 nodes !");
tetrasNodalConn.insert(tetrasNodalConn.end(),nodalConnBg,nodalConnEnd);
conn[0]=work[j]; conn[1]=work[(j+1)%nbOfNodesOfFace]; conn[2]=-(i+1); conn[3]=ToIdType(-(nbOfFaces+1));
tmp[0]+=coords[3*work[j]+0]; tmp[1]+=coords[3*work[j]+1]; tmp[2]+=coords[3*work[j]+2];
}
- double nbNF = (double)nbOfNodesOfFace;
+ auto const nbNF = (double)nbOfNodesOfFace;
tmp[0]/=nbNF; tmp[1]/=nbNF; tmp[2]/=nbNF;
tmp2[0]+=tmp[0]; tmp2[1]+=tmp[1]; tmp2[2]+=tmp[2];
work+=nbOfNodesOfFace+1;
}
- double nbF = (double)nbOfFaces;
+ auto const nbF = (double)nbOfFaces;
tmp2[0]/=nbF; tmp2[1]/=nbF; tmp2[2]/=nbF;
return ;
}
#define __SPLITTERTETRA_HXX__
#include "INTERPKERNELDefines.hxx"
+#include "InterpKernelHashFun.hxx"
#include "TransformedTriangle.hxx"
#include "TetraAffineTransform.hxx"
-#include "InterpolationOptions.hxx"
-#include "InterpKernelException.hxx"
#include "InterpKernelHashMap.hxx"
#include "VectorUtils.hxx"
#include "MCIdType.hxx"
+#include "NormalizedGeometricTypes"
#include <functional>
+#include <utility>
#include <vector>
#include <cassert>
-#include <map>
#include <set>
namespace INTERP_KERNEL
class SplitterTetra
{
public:
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
SplitterTetra(const MyMeshType& srcMesh, const double** tetraCorners, const typename MyMeshType::MyConnType *nodesId);
~SplitterTetra();
- double intersectSourceCell(typename MyMeshType::MyConnType srcCell, double* baryCentre=0);
+ double intersectSourceCell(typename MyMeshType::MyConnType srcCell, double* baryCentre=nullptr);
double intersectSourceFace(const NormalizedCellType polyType,
const ConnType polyNodesNbr,
const ConnType *const polyNodes,
inline void SplitterTetra<MyMeshType>::calculateNode(typename MyMeshType::MyConnType globalNodeNum)
{
const double* node = _src_mesh.getCoordinatesPtr()+MyMeshType::MY_SPACEDIM*globalNodeNum;
- double* transformedNode = new double[MyMeshType::MY_SPACEDIM];
+ auto* transformedNode = new double[MyMeshType::MY_SPACEDIM];
assert(transformedNode != 0);
_t->apply(transformedNode, node);
_nodes[globalNodeNum] = transformedNode;
template<class MyMeshType>
inline void SplitterTetra<MyMeshType>::calculateNode2(typename MyMeshType::MyConnType globalNodeNum, const double* node)
{
- double* transformedNode = new double[MyMeshType::MY_SPACEDIM];
+ auto* transformedNode = new double[MyMeshType::MY_SPACEDIM];
assert(transformedNode != 0);
_t->apply(transformedNode, node);
_nodes[globalNodeNum] = transformedNode;
#ifndef __SPLITTERTETRA_TXX__
#define __SPLITTERTETRA_TXX__
+#include "InterpKernelHashMap.hxx"
+#include "NormalizedUnstructuredMesh.hxx"
+#include "NormalizedGeometricTypes"
+#include "InterpolationUtils.hxx"
#include "SplitterTetra.hxx"
#include "TetraAffineTransform.hxx"
#include <cmath>
#include <cassert>
-#include <string>
-#include <sstream>
+#include <iostream>
+#include <cstddef>
+#include <functional>
+#include <set>
#include <vector>
namespace INTERP_KERNEL
*/
template<class MyMeshType>
SplitterTetra<MyMeshType>::SplitterTetra(const MyMeshType& srcMesh, const double** tetraCorners, const typename MyMeshType::MyConnType *nodesId)
- : _t(0), _src_mesh(srcMesh)
+ : _t(nullptr), _src_mesh(srcMesh)
{
std::copy(nodesId,nodesId+4,_conn);
_coords[0]=tetraCorners[0][0]; _coords[1]=tetraCorners[0][1]; _coords[2]=tetraCorners[0][2];
* \param [in] tetraCorners array 4*3 doubles containing corners of input tetrahedron (P0X,P0Y,P0Y,P1X,P1Y,P1Z,P2X,P2Y,P2Z,P3X,P3Y,P3Z).
*/
template<class MyMeshType>
- SplitterTetra<MyMeshType>::SplitterTetra(const MyMeshType& srcMesh, const double tetraCorners[12], const ConnType *conn): _t(0),_src_mesh(srcMesh)
+ SplitterTetra<MyMeshType>::SplitterTetra(const MyMeshType& srcMesh, const double tetraCorners[12], const ConnType *conn): _t(nullptr),_src_mesh(srcMesh)
{
if(!conn)
{ _conn[0]=0; _conn[1]=1; _conn[2]=2; _conn[3]=3; }
void SplitterTetra<MyMeshType>::splitMySelfForDual(double* output, int i, typename MyMeshType::MyConnType& nodeId)
{
double *tmp[4];
- int offset=i/6;
+ int const offset=i/6;
nodeId=_conn[offset];
tmp[0]=_coords+3*offset; tmp[1]=_coords+((offset+1)%4)*3; tmp[2]=_coords+((offset+2)%4)*3; tmp[3]=_coords+((offset+3)%4)*3;
- int caseToTreat=i%6;
- int case1=caseToTreat/2;
- int case2=caseToTreat%2;
+ int const caseToTreat=i%6;
+ int const case1=caseToTreat/2;
+ int const case2=caseToTreat%2;
const int tab[3][2]={{1,2},{3,2},{1,3}};
const int *curTab=tab[case1];
double pt0[3]; pt0[0]=(tmp[curTab[case2]][0]+tmp[0][0])/2.; pt0[1]=(tmp[curTab[case2]][1]+tmp[0][1])/2.; pt0[2]=(tmp[curTab[case2]][2]+tmp[0][2])/2.;
bool isTargetOutside = false;
// calculate the coordinates of the nodes
- ConnType *cellNodes=new ConnType[nbOfNodes4Type];
+ auto *cellNodes=new ConnType[nbOfNodes4Type];
for(ConnType i = 0;i<nbOfNodes4Type;++i)
{
// we could store mapping local -> global numbers too, but not sure it is worth it
// halfspace filtering check
// NB : might not be beneficial for caching of triangles
- for(int i = 0; i < 8; ++i)
- if(isOutside[i])
+ for(bool const i : isOutside)
+ if(i)
isTargetOutside = true;
double totalVolume = 0.0;
// Map 2D intersections back to the 3D triangle space.
if (maxNormal == 0)
{
- double invNX = ((double) 1.) / planeNormal[0];
+ double const invNX = ((double) 1.) / planeNormal[0];
for (i = 0; i < nb_inter; i++)
{
inter3[3 * i + 1] = inter2[2 * i];
}
else if (maxNormal == 1)
{
- double invNY = ((double) 1.) / planeNormal[1];
+ double const invNY = ((double) 1.) / planeNormal[1];
for (i = 0; i < nb_inter; i++)
{
inter3[3 * i] = inter2[2 * i];
}
else
{
- double invNZ = ((double) 1.) / planeNormal[2];
+ double const invNZ = ((double) 1.) / planeNormal[2];
for (i = 0; i < nb_inter; i++)
{
inter3[3 * i] = inter2[2 * i];
{ 0, 3, 1 },
{ 1, 2, 3 } };
double planeNormal[3];
- for (int iTetraFace = 0; iTetraFace < 4; ++iTetraFace)
+ for (auto tetraFaceNodesConn : tetraFacesNodesConn)
{
- const int * const tetraFaceNodesConn = tetraFacesNodesConn[iTetraFace];
TriangleFaceKey key = TriangleFaceKey(_conn[tetraFaceNodesConn[0]],
_conn[tetraFaceNodesConn[1]],
_conn[tetraFaceNodesConn[2]]);
const double normOfTetraTriNormal = norm(planeNormal);
if (epsilonEqual(normOfTetraTriNormal, 0.))
{
- for (int i = 0; i < 3; ++i)
+ for (double & i : planeNormal)
{
- planeNormal[i] = 0.;
+ i = 0.;
}
}
else
{
const double invNormOfTetraTriNormal = 1. / normOfTetraTriNormal;
- for (int i = 0; i < 3; ++i)
+ for (double & i : planeNormal)
{
- planeNormal[i] *= invNormOfTetraTriNormal;
+ i *= invNormOfTetraTriNormal;
}
}
- double planeConstant = dot(planeNormal, coordsTetraTriNode1);
+ double const planeConstant = dot(planeNormal, coordsTetraTriNode1);
if (IsFacesCoplanar(planeNormal, planeConstant, polyCoords, precision))
{
ConnType nbrPolyTri = polyNodesNbr - 2; // split polygon into nbrPolyTri triangles
// halfspace filtering check
// NB : might not be beneficial for caching of triangles
- for(int i = 0; i < 8; ++i)
+ for(bool const i : isOutside)
{
- if(isOutside[i])
+ if(i)
{
isTargetOutside = true;
}
cellModelCell.fillSonCellNodalConnectivity(ii,cellNodes,faceNodes);
TransformedTriangle tri(nodes[faceNodes[0]], nodes[faceNodes[1]], nodes[faceNodes[2]]);
- double vol = tri.calculateIntersectionVolume();
+ double const vol = tri.calculateIntersectionVolume();
LOG(1, "ii = " << ii << " Volume=" << vol)
totalVolume += vol;
}
// free potential sub-mesh nodes that have been allocated
if(_nodes.size()>=/*8*/_node_ids.size())
{
- typename MyMeshTypeT::MyConnType nbOfNodesT = static_cast<typename MyMeshTypeT::MyConnType>(_node_ids.size());
- std::vector<const double*>::iterator iter = _nodes.begin() + /*8*/nbOfNodesT;
+ auto nbOfNodesT = static_cast<typename MyMeshTypeT::MyConnType>(_node_ids.size());
+ auto iter = _nodes.begin() + /*8*/nbOfNodesT;
while(iter != _nodes.end())
{
delete[] *iter;
nodes[node]=getCoordsOfNode2(node, OTT<ConnType,numPol>::indFC(targetCell),_target_mesh,conn[node]);
}
std::copy(conn,conn+4,_node_ids.begin());
- SplitterTetra<MyMeshTypeS>* t = new SplitterTetra<MyMeshTypeS>(_src_mesh, nodes,conn);
+ auto* t = new SplitterTetra<MyMeshTypeS>(_src_mesh, nodes,conn);
tetra.push_back(t);
return ;
}
nodes[j] = getCoordsOfSubNode2(conn[j],realConn);
conn[j] = realConn;
}
- SplitterTetra<MyMeshTypeS>* t = new SplitterTetra<MyMeshTypeS>(_src_mesh, nodes,conn);
+ auto* t = new SplitterTetra<MyMeshTypeS>(_src_mesh, nodes,conn);
tetra.push_back(t);
}
}
conn[j] = subZone[SPLIT_NODES_6[4*i+j]];
func(*this,conn[j],nodes[j]);
}
- SplitterTetra<MyMeshTypeS>* t = new SplitterTetra<MyMeshTypeS>(_src_mesh, nodes,conn);
+ auto* t = new SplitterTetra<MyMeshTypeS>(_src_mesh, nodes,conn);
tetra.push_back(t);
}
}
conn[2] = TETRA_EDGES_GENERAL_24[2*row];
conn[3] = TETRA_EDGES_GENERAL_24[2*row + 1];
func(*this,conn,nodes);
- SplitterTetra<MyMeshTypeS>* t = new SplitterTetra<MyMeshTypeS>(_src_mesh, nodes, conn);
+ auto* t = new SplitterTetra<MyMeshTypeS>(_src_mesh, nodes, conn);
tetra.push_back(t);
}
}
// create tetrahedra
const double* nodes[4];
typename MyMeshTypeS::MyConnType conn[4];
- for(int i = 0; i < 2; ++i)
+ for(auto i : SPLIT_PYPA5)
{
for(int j = 0; j < 4; ++j)
- nodes[j] = getCoordsOfSubNode2(SPLIT_PYPA5[i][j],conn[j]);
- SplitterTetra<MyMeshTypeS>* t = new SplitterTetra<MyMeshTypeS>(_src_mesh, nodes,conn);
+ nodes[j] = getCoordsOfSubNode2(i[j],conn[j]);
+ auto* t = new SplitterTetra<MyMeshTypeS>(_src_mesh, nodes,conn);
tetra.push_back(t);
}
}
if ( normCellType != NORM_POLYHED )
cellModelCell.fillSonCellNodalConnectivity(ii,&allNodeIndices[0],faceNodes);
- int nbTetra = nbFaceNodes - 2; // split polygon into nbTetra triangles
+ int const nbTetra = nbFaceNodes - 2; // split polygon into nbTetra triangles
// create tetrahedra
for(int i = 0; i < nbTetra; ++i)
nodes[0] = getCoordsOfSubNode2( faceNodes[0], conn[0]);
nodes[1] = getCoordsOfSubNode2( faceNodes[1+i],conn[1]);
nodes[2] = getCoordsOfSubNode2( faceNodes[2+i],conn[2]);
- SplitterTetra<MyMeshTypeS>* t = new SplitterTetra<MyMeshTypeS>(_src_mesh, nodes,conn);
+ auto* t = new SplitterTetra<MyMeshTypeS>(_src_mesh, nodes,conn);
tetra.push_back(t);
}
{
// retrieve real mesh nodes
- typename MyMeshTypeT::MyConnType nbOfNodesT = static_cast<typename MyMeshTypeT::MyConnType>(_node_ids.size());// Issue 0020634. _node_ids.resize(8);
+ auto nbOfNodesT = static_cast<typename MyMeshTypeT::MyConnType>(_node_ids.size());// Issue 0020634. _node_ids.resize(8);
for(int node = 0; node < nbOfNodesT ; ++node)
{
// calculate only normal nodes
{
for(int i = 0; i < 7; ++i)
{
- double* barycenter = new double[3];
+ auto* barycenter = new double[3];
calcBarycenter(4, barycenter, &GENERAL_24_SUB_NODES[4*i]);
_nodes.push_back(barycenter);
}
{
for(int i = 0; i < 19; ++i)
{
- double* barycenter = new double[3];
+ auto* barycenter = new double[3];
calcBarycenter(2, barycenter, &GENERAL_48_SUB_NODES[2*i]);
_nodes.push_back(barycenter);
}
// add barycenter of a cell
std::vector<int> allIndices(nbOfNodesT);
for ( int i = 0; i < nbOfNodesT; ++i ) allIndices[i] = i;
- double* barycenter = new double[3];
+ auto* barycenter = new double[3];
calcBarycenter(nbOfNodesT, barycenter, &allIndices[0]);
_nodes.push_back(barycenter);
}
#ifndef __TARGETINTERSECTOR__HXX__
#define __TARGETINTERSECTOR__HXX__
-#include "INTERPKERNELDefines.hxx"
+#include <cstddef>
#include <vector>
namespace INTERP_KERNEL
{
public:
static const int SPACEDIM=MyMeshType::MY_SPACEDIM;
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
public:
/*!
* Tool for cell intersection, result is always positive.
virtual ConnType getNumberOfRowsOfResMatrix() const = 0;
virtual ConnType getNumberOfColsOfResMatrix() const = 0;
- virtual ~TargetIntersector() { }
+ virtual ~TargetIntersector() = default;
void adjustBoundingBoxes(std::vector<double>& bbox, double adjustmentEps, double adjustmentEpsAbs);
void adjustBoundingBoxes(double *bbox, std::size_t sz, double adjustmentEps, double adjustmentEpsAbs);
};
#define __TARGETINTERSECTOR__TXX__
#include "TargetIntersector.hxx"
+#include <cstddef>
#include <limits>
+#include <vector>
namespace INTERP_KERNEL
{
}
// swap rows in index vector
- int tmp = idx[k];
+ int const tmp = idx[k];
idx[k] = idx[row];
idx[row] = tmp;
//
#include "TransformedTriangle.hxx"
+#include "Log.hxx"
#include "VectorUtils.hxx"
#include "TetraAffineTransform.hxx"
+#include <cmath>
+#include <cstddef>
#include <iostream>
-#include <fstream>
#include <cassert>
#include <algorithm>
-#include <functional>
-#include <iterator>
#include <math.h>
#include <vector>
// };
// double sign = uv_xy[0] * uv_xy[3] - uv_xy[1] * uv_xy[2];
- int sign = isTriangleInclinedToFacet( OXY );
+ int const sign = isTriangleInclinedToFacet( OXY );
if(sign == 0 )
{
{
if(testSurfaceEdgeIntersection(edge))
{
- double* ptA = new double[3];
+ auto* ptA = new double[3];
calcIntersectionPtSurfaceEdge(edge, ptA);
_polygonA.push_back(ptA);
LOG(3,"Surface-edge (edge " << strTE(edge) << "): " << vToStr(ptA) << " added to A ");
if(edge >= XY)
{
- double* ptB = new double[3];
+ auto* ptB = new double[3];
copyVector3(ptA, ptB);
_polygonB.push_back(ptB);
LOG(3,"Surface-edge (edge " << strTE(edge) << "): " << vToStr(ptB) << " added to B ");
{
if(testSurfaceRayIntersection(corner))
{
- double* ptB = new double[3];
+ auto* ptB = new double[3];
copyVector3(&COORDS_TET_CORNER[3 * corner], ptB);
_polygonB.push_back(ptB);
LOG(3,"Surface-ray (corner " << strTC(corner) << "): " << vToStr(ptB) << " added to B");
if(doTest && testSegmentFacetIntersection(seg, facet))
{
- double* ptA = new double[3];
+ auto* ptA = new double[3];
calcIntersectionPtSegmentFacet(seg, facet, ptA);
_polygonA.push_back(ptA);
LOG(3,"Segment-facet (facet " << strTF(facet) << ", seg " << strTriS(seg) << "): " << vToStr(ptA) << " added to A");
if(facet == XYZ)
{
- double* ptB = new double[3];
+ auto* ptB = new double[3];
copyVector3(ptA, ptB);
_polygonB.push_back(ptB);
LOG(3,"Segment-facet (facet " << strTF(facet) << ", seg " << strTriS(seg) << "): " << vToStr(ptB) << " added to B");
// segment - edge
for(TetraEdge edge = OX ; edge <= ZX ; edge = TetraEdge(edge + 1))
{
- const DoubleProduct edge_dp = DoubleProduct(edge);
+ const auto edge_dp = DoubleProduct(edge);
if(isZero[edge_dp] && testSegmentEdgeIntersection(seg, edge))
{
- double* ptA = new double[3];
+ auto* ptA = new double[3];
calcIntersectionPtSegmentEdge(seg, edge, ptA);
_polygonA.push_back(ptA);
LOG(3,"Segment-edge (edge " << strTE(edge) << ", seg " << strTriS(seg) << "): " << vToStr(ptA) << " added to A");
if(edge >= XY)
{
- double* ptB = new double[3];
+ auto* ptB = new double[3];
copyVector3(ptA, ptB);
_polygonB.push_back(ptB);
LOG(3,"Segment-edge (edge " << strTE(edge) << ", seg " << strTriS(seg) << "): " << vToStr(ptA) << " added to B");
if(doTest && testSegmentCornerIntersection(seg, corner))
{
- double* ptA = new double[3];
+ auto* ptA = new double[3];
copyVector3(&COORDS_TET_CORNER[3 * corner], ptA);
_polygonA.push_back(ptA);
LOG(3,"Segment-corner (corner " << strTC(corner) << ", seg " << strTriS(seg) << "): " << vToStr(ptA) << " added to A");
if(corner != O)
{
- double* ptB = new double[3];
+ auto* ptB = new double[3];
_polygonB.push_back(ptB);
copyVector3(&COORDS_TET_CORNER[3 * corner], ptB);
LOG(3,"Segment-corner (corner " << strTC(corner) << ", seg " << strTriS(seg) << "): " << vToStr(ptB) << " added to B");
{
if(isZero[DP_SEGMENT_RAY_INTERSECTION[7*(corner-1)]] && testSegmentRayIntersection(seg, corner))
{
- double* ptB = new double[3];
+ auto* ptB = new double[3];
copyVector3(&COORDS_TET_CORNER[3 * corner], ptB);
_polygonB.push_back(ptB);
LOG(3,"Segment-ray (corner " << strTC(corner) << ", seg " << strTriS(seg) << "): " << vToStr(ptB) << " added to B");
#endif
if(testSegmentHalfstripIntersection(seg, edge))
{
- double* ptB = new double[3];
+ auto* ptB = new double[3];
calcIntersectionPtSegmentHalfstrip(seg, edge, ptB);
_polygonB.push_back(ptB);
LOG(3,"Segment-halfstrip : " << vToStr(ptB) << " added to B");
// tetrahedron
if(testCornerInTetrahedron(corner))
{
- double* ptA = new double[3];
+ auto* ptA = new double[3];
copyVector3(&_coords[5*corner], ptA);
_polygonA.push_back(ptA);
LOG(3,"Inclusion tetrahedron (corner " << strTriC(corner) << "): " << vToStr(ptA) << " added to A");
// XYZ - plane
if(testCornerOnXYZFacet(corner))
{
- double* ptB = new double[3];
+ auto* ptB = new double[3];
copyVector3(&_coords[5*corner], ptB);
_polygonB.push_back(ptB);
LOG(3,"Inclusion XYZ-plane (corner " << strTriC(corner) << "): " << vToStr(ptB) << " added to B");
// projection on XYZ - facet
if(testCornerAboveXYZFacet(corner))
{
- double* ptB = new double[3];
+ auto* ptB = new double[3];
copyVector3(&_coords[5*corner], ptB);
ptB[2] = 1 - ptB[0] - ptB[1]; // lower z to project on XYZ
assert(epsilonEqual(ptB[0]+ptB[1]+ptB[2] - 1, 0.0));
{
if(testSurfaceEdgeIntersection(edge))
{
- double* ptA = new double[3];
+ auto* ptA = new double[3];
calcIntersectionPtSurfaceEdge(edge, ptA);
_polygonA.push_back(ptA);
LOG(3,"Surface-edge : " << vToStr(ptA) << " added to A ");
if(doTest && testSegmentFacetIntersection(seg, facet))
{
- double* ptA = new double[3];
+ auto* ptA = new double[3];
calcIntersectionPtSegmentFacet(seg, facet, ptA);
_polygonA.push_back(ptA);
LOG(3,"Segment-facet : " << vToStr(ptA) << " added to A");
// segment - edge
for(TetraEdge edge = OX ; edge <= ZX ; edge = TetraEdge(edge + 1))
{
- const DoubleProduct edge_dp = DoubleProduct(edge);
+ const auto edge_dp = DoubleProduct(edge);
if(isZero[edge_dp] && testSegmentEdgeIntersection(seg, edge))
{
- double* ptA = new double[3];
+ auto* ptA = new double[3];
calcIntersectionPtSegmentEdge(seg, edge, ptA);
_polygonA.push_back(ptA);
LOG(3,"Segment-edge : " << vToStr(ptA) << " added to A");
if(doTest && testSegmentCornerIntersection(seg, corner))
{
- double* ptA = new double[3];
+ auto* ptA = new double[3];
copyVector3(&COORDS_TET_CORNER[3 * corner], ptA);
_polygonA.push_back(ptA);
LOG(3,"Segment-corner : " << vToStr(ptA) << " added to A");
// tetrahedron
if(testCornerInTetrahedron(corner))
{
- double* ptA = new double[3];
+ auto* ptA = new double[3];
copyVector3(&_coords[5*corner], ptA);
_polygonA.push_back(ptA);
LOG(3,"Inclusion tetrahedron : " << vToStr(ptA) << " added to A");
}
// create order object
- SortOrder order(barycenter, type);
+ SortOrder const order(barycenter, type);
// sort vector with this object
// NB : do not change place of first object, with respect to which the order
#include "VectorUtils.hxx"
#include "assert.h"
+#include <string>
+#include <cmath>
+#include <map>
#include <vector>
// Levels :
_coords[5*corner + 3] // z
};
- for(int i = 0 ; i < 4 ; ++i)
+ for(double const i : pt)
{
- if(pt[i] < 0.0 || pt[i] > 1.0)
+ if(i < 0.0 || i > 1.0)
{
return false;
}
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+#include "Log.hxx"
#include "TransformedTriangle.hxx"
-#include <iostream>
-#include <fstream>
#include <cassert>
#include <cmath>
-#include "VectorUtils.hxx"
namespace INTERP_KERNEL
{
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+#include "Log.hxx"
#include "TransformedTriangle.hxx"
-#include <iostream>
-#include <fstream>
+#include <algorithm>
#include <cassert>
#include <cmath>
#include <limits>
#include <map>
+#include <math.h>
#include <utility>
#include "VectorUtils.hxx"
double TransformedTriangle::calculateDistanceCornerSegment(const TetraCorner corner, const TriSegment seg) const
{
// NB uses fact that TriSegment <=> TriCorner that is first point of segment (PQ <=> P)
- const TriCorner ptP_idx = TriCorner(seg);
- const TriCorner ptQ_idx = TriCorner( (seg + 1) % 3);
+ const auto ptP_idx = TriCorner(seg);
+ const auto ptQ_idx = TriCorner( (seg + 1) % 3);
const double ptP[3] = { _coords[5*ptP_idx], _coords[5*ptP_idx + 1], _coords[5*ptP_idx + 2] };
const double ptQ[3] = { _coords[5*ptQ_idx], _coords[5*ptQ_idx + 1], _coords[5*ptQ_idx + 2] };
const DoubleProduct dp = DP_FOR_DETERMINANT_EXPANSION[3*corner + (row - 1)];
// get edge by using correspondence between Double Product and Edge
- TetraEdge edge = TetraEdge(dp);
+ auto const edge = TetraEdge(dp);
// use edge only if it is surrounded by the surface
if( _triangleSurroundsEdgeCache[edge] )
void rotate_x (double* P)
{
_rotation_coeffs[0]=1.0;
- double r_sqr = P[1]*P[1]+P[2]*P[2];
+ double const r_sqr = P[1]*P[1]+P[2]*P[2];
if (r_sqr < EPS)
{_rotation_coeffs[4]=1.0; _rotation_coeffs[8]=1.0; return;}
- double r = sqrt(r_sqr);
- double cos =P[1]/r;
- double sin =P[2]/r;
+ double const r = sqrt(r_sqr);
+ double const cos =P[1]/r;
+ double const sin =P[2]/r;
_rotation_coeffs[4]=cos;
_rotation_coeffs[5]=sin;
void rotate_z (double* P)
{
_rotation_coeffs[8]=1.0;
- double r_sqr = P[0]*P[0]+P[1]*P[1];
+ double const r_sqr = P[0]*P[0]+P[1]*P[1];
if (r_sqr < EPS)
{_rotation_coeffs[4]=1.0; _rotation_coeffs[0]=1.0; return;}
- double r = sqrt(r_sqr);
- double cos =P[0]/r;
- double sin =P[1]/r;
+ double const r = sqrt(r_sqr);
+ double const cos =P[0]/r;
+ double const sin =P[1]/r;
_rotation_coeffs[0]=cos;
_rotation_coeffs[1]=sin;
#ifndef __TRIANGULATIONINTERSECTOR_HXX__
#define __TRIANGULATIONINTERSECTOR_HXX__
-#include "PlanarIntersectorP0P0.hxx"
-#include "PlanarIntersectorP0P1.hxx"
-#include "PlanarIntersectorP1P0.hxx"
-#include "PlanarIntersectorP1P1.hxx"
-#include "PlanarIntersectorP1P0Bary.hxx"
+#include "NormalizedUnstructuredMesh.hxx"
+#include <vector>
namespace INTERP_KERNEL
{
public:
static const int SPACEDIM=MyMeshType::MY_SPACEDIM;
static const int MESHDIM=MyMeshType::MY_MESHDIM;
- typedef typename MyMeshType::MyConnType ConnType;
+ using ConnType = typename MyMeshType::MyConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
public:
TriangulationIntersector(const MyMeshType& meshT, const MyMeshType& meshS,
#ifndef __TRIANGULATIONINTERSECTOR_TXX__
#define __TRIANGULATIONINTERSECTOR_TXX__
+#include "InterpKernelUtilities.hxx"
#include "TriangulationIntersector.hxx"
-#include "PlanarIntersectorP0P0.txx"
-#include "PlanarIntersectorP0P1.txx"
-#include "PlanarIntersectorP1P0.txx"
-#include "PlanarIntersectorP1P0Bary.txx"
-
-#include "InterpolationUtils.hxx"
#include "PlanarIntersector.hxx"
+#include "InterpolationUtils.hxx"
#include <iostream>
+#include <vector>
+
+
#define TRI_INTERSECTOR TriangulationIntersector<MyMeshType,MyMatrix,InterpType>
#define TRI_INTER_TEMPLATE template<class MyMeshType, class MyMatrix, \
//
#include "UnitTetraIntersectionBary.hxx"
+#include "TransformedTriangle.hxx"
#include "VectorUtils.hxx"
#include "InterpolationUtils.hxx"
#include "VolSurfFormulae.hxx"
+#include <vector>
+#include <cmath>
+#include <list>
+#include <cstddef>
#define NB_TETRA_SIDES 4
#define NB_TETRA_NODES 4
}
// check if polygon orientation is same as the one of triangle
- std::vector<double*>::const_iterator p = pPolygonA->begin(), pEnd = pPolygonA->end();
+ auto p = pPolygonA->begin(), pEnd = pPolygonA->end();
#ifdef DMP_UNITTETRAINTERSECTIONBARY
std::cout.precision(18);
std::cout << "**** int polygon() " << std::endl;
baryCenter[0] = baryCenter[1] = baryCenter[2] = 0.;
- std::list< std::vector< double* > >::iterator f = _faces.begin(), fEnd = _faces.end();
+ auto f = _faces.begin(), fEnd = _faces.end();
double * PP = f->at(0);
for ( ++f; f != fEnd; ++f )
continue;
bool pBelongsToPoly = false;
- std::vector<double*>::iterator v = polygon.begin(), vEnd = polygon.end();
+ auto v = polygon.begin(), vEnd = polygon.end();
for ( ; !pBelongsToPoly && v != vEnd; ++v )
pBelongsToPoly = samePoint( PP, *v );
if ( pBelongsToPoly )
bool sideAdded[NB_TETRA_SIDES] = { false, false, false, false };
int nbAddedSides = 0;
- std::list< std::vector< double* > >::iterator f = _faces.begin(), fEnd = _faces.end();
+ auto f = _faces.begin(), fEnd = _faces.end();
for ( ; f != fEnd; ++f )
{
- std::vector< double* >& polygon = *f;
+ std::vector< double* > const& polygon = *f;
double coordSum[3] = {0,0,0};
- for ( int i = 0; i < (int)polygon.size(); ++i )
+ for (auto p : polygon)
{
- double* p = polygon[i];
coordSum[0] += p[0];
coordSum[1] += p[1];
coordSum[2] += p[2];
// Add segments of already added polygons to future polygonal faces on sides of tetra
// ---------------------------------------------------------------------------------
- std::size_t nbIntersectPolygs = _faces.size();
+ std::size_t const nbIntersectPolygs = _faces.size();
std::vector< double* > * sideFaces[ 4 ]; // future polygons on sides of tetra
for ( int i = 0; i < NB_TETRA_SIDES; ++i )
{
- sideFaces[ i ]=0;
+ sideFaces[ i ]=nullptr;
if ( !sideAdded[ i ] )
{
_faces.push_back( std::vector< double* > () );
if ( ic ) corner2Poly[ ic-1 ] -= 1.0;
// _polyNormals are outside of a tetrahedron
- double dot = dotprod<3>( corner2Poly, &_polyNormals[iF][0] );
+ double const dot = dotprod<3>( corner2Poly, &_polyNormals[iF][0] );
if ( dot < -DEFAULT_ABS_TOL*DEFAULT_ABS_TOL )
{
#ifdef DMP_UNITTETRAINTERSECTIONBARY
if ( !sideFaces[i] ) continue;
std::vector< double* >& sideFace = *sideFaces[i];
- std::size_t nbPoints = sideFace.size();
+ std::size_t const nbPoints = sideFace.size();
if ( nbPoints == 0 )
continue; // not intersected face at all - no cut off corners can be detected
bool isSegmentOnEdge=false;
for ( std::size_t ip = 0; ip < nbPoints; ++ip )
{
- std::size_t isSegmentEnd = ( ip % 2 );
+ std::size_t const isSegmentEnd = ( ip % 2 );
double* p = sideFace[ ip ];
- double* p2 = isSegmentEnd ? 0 : sideFace[ip+1];
+ double* p2 = isSegmentEnd ? nullptr : sideFace[ip+1];
if ( !isSegmentEnd )
isSegmentOnEdge = false; // initialize
if ( !sideFaces[ i ] ) continue;
std::vector< double* >& sideFace = *sideFaces[i];
- int excludeCorner = (i + 1) % NB_TETRA_NODES;
+ int const excludeCorner = (i + 1) % NB_TETRA_NODES;
for ( int ic = 0; ic < NB_TETRA_NODES; ++ic )
{
if ( !cutOffCorners[ ic ] && ic != excludeCorner )
sortIntersectionPolygon( A, _barycenterA );
}
// exclude equal points
- std::vector< double* >::iterator v = _polygonA.begin(), vEnd = _polygonA.end();
+ auto v = _polygonA.begin(), vEnd = _polygonA.end();
face.push_back( *v );
*v = 0;
for ( ++v; v != vEnd; ++v )
void UnitTetraIntersectionBary::clearPolygons(bool andFaces)
{
- for(std::vector<double*>::iterator it = _polygonA.begin() ; it != _polygonA.end() ; ++it)
- { delete[] *it;
- *it = 0;
+ for(auto & it : _polygonA)
+ { delete[] it;
+ it = nullptr;
}
- for(std::vector<double*>::iterator it = _polygonB.begin() ; it != _polygonB.end() ; ++it)
+ for(auto & it : _polygonB)
{
- delete[] *it;
- *it = 0;
+ delete[] it;
+ it = nullptr;
}
_polygonA.clear();
if ( andFaces )
{
- std::list< std::vector< double* > >::iterator f = this->_faces.begin(), fEnd = this->_faces.end();
+ auto f = this->_faces.begin(), fEnd = this->_faces.end();
for ( ; f != fEnd; ++f )
{
std::vector< double* >& polygon = *f;
- for(std::vector<double*>::iterator it = polygon.begin() ; it != polygon.end() ; ++it)
+ for(auto & it : polygon)
{
- delete[] *it;
- *it = 0;
+ delete[] it;
+ it = nullptr;
}
}
this->_faces.clear();
#ifndef __VTKNORMALIZEDUNSTRUCTUREDMESH_HXX__
#define __VTKNORMALIZEDUNSTRUCTUREDMESH_HXX__
-#include "NormalizedUnstructuredMesh.hxx"
#include "vtkType.h"
#ifndef __VTKNORMALIZEDUNSTRUCTUREDMESH_TXX__
#define __VTKNORMALIZEDUNSTRUCTUREDMESH_TXX__
-#include "VTKNormalizedUnstructuredMesh.hxx"
#include "vtkUnstructuredGrid.h"
#include "vtkCellArray.h"
#define __VECTORUTILS_HXX__
#include <algorithm>
+#include <ios>
#include <sstream>
#include <iomanip>
-#include <numeric>
#include <string>
#include <cmath>
-#include <map>
namespace INTERP_KERNEL
*/
inline double normInf(const double mat[9])
{
- double ret(std::max(sumOfAbsoluteValues(mat),sumOfAbsoluteValues(mat+3)));
+ double const ret(std::max(sumOfAbsoluteValues(mat),sumOfAbsoluteValues(mat+3)));
return std::max(ret,sumOfAbsoluteValues(mat+6));
}
#ifndef __VOLSURFFORMULAE_HXX__
#define __VOLSURFFORMULAE_HXX__
+#include "InterpKernelGeo2DNode.hxx"
#include "InterpolationUtils.hxx"
#include "InterpKernelException.hxx"
-#include "InterpKernelGeo2DEdgeLin.hxx"
-#include "InterpKernelGeo2DEdgeArcCircle.hxx"
#include "InterpKernelGeo2DQuadraticPolygon.hxx"
#include "MCIdType.hxx"
+#include "NormalizedUnstructuredMesh.hxx"
+#include <cstddef>
+#include <limits>
#include <sstream>
#include <cmath>
+#include <vector>
namespace INTERP_KERNEL
{
if(spaceDim==2)
{
Edge *ed=Edge::BuildEdgeFrom3Points(begin,middle,end);
- double ret=ed->getCurveLength(); ed->decrRef();
+ double const ret=ed->getCurveLength(); ed->decrRef();
return ret;
}
else
calculateBarycenterDyn(coords,nbOfPtsInPolygs,spaceDim,coordOfBary);
for ( mcIdType i=0; i<nbOfPtsInPolygs; i++ )
{
- double tmp = calculateAreaForTria(coords[i],coords[(i+1)%nbOfPtsInPolygs],
+ double const tmp = calculateAreaForTria(coords[i],coords[(i+1)%nbOfPtsInPolygs],
coordOfBary,spaceDim);
ret+=tmp;
}
for(mcIdType i=0;i<nbOfPtsInPolygs;i++)
nodes[i]=new Node(coords[i][0],coords[i][1]);
QuadraticPolygon *pol=QuadraticPolygon::BuildArcCirclePolygon(nodes);
- double ret=pol->getArea();
+ double const ret=pol->getArea();
delete pol;
return -ret;
}
double f1 = (p1[0]-p3[0])/2.0, f2 = (p1[1]-p3[1])/2.0, f3 = (p1[2]-p3[2])/2.0;
double h1 = (p4[0]-p6[0])/2.0, h2 = (p4[1]-p6[1])/2.0, h3 = (p4[2]-p6[2])/2.0;
- double A = a1*c2*f3 - a1*c3*f2 - a2*c1*f3 + a2*c3*f1 + a3*c1*f2 - a3*c2*f1;
- double B = b1*c2*h3 - b1*c3*h2 - b2*c1*h3 + b2*c3*h1 + b3*c1*h2 - b3*c2*h1;
- double C = (a1*c2*h3 + b1*c2*f3) - (a1*c3*h2 + b1*c3*f2)
+ double const A = a1*c2*f3 - a1*c3*f2 - a2*c1*f3 + a2*c3*f1 + a3*c1*f2 - a3*c2*f1;
+ double const B = b1*c2*h3 - b1*c3*h2 - b2*c1*h3 + b2*c3*h1 + b3*c1*h2 - b3*c2*h1;
+ double const C = (a1*c2*h3 + b1*c2*f3) - (a1*c3*h2 + b1*c3*f2)
- (a2*c1*h3 + b2*c1*f3) + (a2*c3*h1 + b2*c3*f1)
+ (a3*c1*h2 + b3*c1*f2) - (a3*c2*h1 + b3*c2*f1);
- double D = a1*d2*f3 - a1*d3*f2 - a2*d1*f3 + a2*d3*f1 + a3*d1*f2 - a3*d2*f1;
- double E = b1*d2*h3 - b1*d3*h2 - b2*d1*h3 + b2*d3*h1 + b3*d1*h2 - b3*d2*h1;
- double F = (a1*d2*h3 + b1*d2*f3) - (a1*d3*h2 + b1*d3*f2)
+ double const D = a1*d2*f3 - a1*d3*f2 - a2*d1*f3 + a2*d3*f1 + a3*d1*f2 - a3*d2*f1;
+ double const E = b1*d2*h3 - b1*d3*h2 - b2*d1*h3 + b2*d3*h1 + b3*d1*h2 - b3*d2*h1;
+ double const F = (a1*d2*h3 + b1*d2*f3) - (a1*d3*h2 + b1*d3*f2)
- (a2*d1*h3 + b2*d1*f3) + (a2*d3*h1 + b2*d3*f1)
+ (a3*d1*h2 + b3*d1*f2) - (a3*d2*h1 + b3*d2*f1);
- double G = a1*e2*f3 - a1*e3*f2 - a2*e1*f3 + a2*e3*f1 + a3*e1*f2 - a3*e2*f1;
- double H = b1*e2*h3 - b1*e3*h2 - b2*e1*h3 + b2*e3*h1 + b3*e1*h2 - b3*e2*h1;
- double P = (a1*e2*h3 + b1*e2*f3) - (a1*e3*h2 + b1*e3*f2)
+ double const G = a1*e2*f3 - a1*e3*f2 - a2*e1*f3 + a2*e3*f1 + a3*e1*f2 - a3*e2*f1;
+ double const H = b1*e2*h3 - b1*e3*h2 - b2*e1*h3 + b2*e3*h1 + b3*e1*h2 - b3*e2*h1;
+ double const P = (a1*e2*h3 + b1*e2*f3) - (a1*e3*h2 + b1*e3*f2)
- (a2*e1*h3 + b2*e1*f3) + (a2*e3*h1 + b2*e3*f1)
+ (a3*e1*h2 + b3*e1*f2) - (a3*e2*h1 + b3*e2*f1);
double s1=(pt2[0]-pt6[0])/8.0, s2=(pt2[1]-pt6[1])/8.0, s3=(pt2[2]-pt6[2])/8.0;
double t1=(pt1[0]-pt5[0])/8.0, t2=(pt1[1]-pt5[1])/8.0, t3=(pt1[2]-pt5[2])/8.0;
- double A = a1*e2*q3 - a1*e3*q2 - a2*e1*q3 + a2*e3*q1 + a3*e1*q2 - a3*e2*q1;
- double B = c1*h2*q3 - c1*h3*q2 - c2*h1*q3 + c2*h3*q1 + c3*h1*q2 - c3*h2*q1;
- double C = (a1*h2 + c1*e2)*q3 - (a1*h3 + c1*e3)*q2
+ double const A = a1*e2*q3 - a1*e3*q2 - a2*e1*q3 + a2*e3*q1 + a3*e1*q2 - a3*e2*q1;
+ double const B = c1*h2*q3 - c1*h3*q2 - c2*h1*q3 + c2*h3*q1 + c3*h1*q2 - c3*h2*q1;
+ double const C = (a1*h2 + c1*e2)*q3 - (a1*h3 + c1*e3)*q2
- (a2*h1 + c2*e1)*q3 + (a2*h3 + c2*e3)*q1
+ (a3*h1 + c3*e1)*q2 - (a3*h2 + c3*e2)*q1;
- double D = b1*e2*s3 - b1*e3*s2 - b2*e1*s3 + b2*e3*s1 + b3*e1*s2 - b3*e2*s1;
- double E = d1*h2*s3 - d1*h3*s2 - d2*h1*s3 + d2*h3*s1 + d3*h1*s2 - d3*h2*s1;
- double F = (b1*h2 + d1*e2)*s3 - (b1*h3 + d1*e3)*s2
+ double const D = b1*e2*s3 - b1*e3*s2 - b2*e1*s3 + b2*e3*s1 + b3*e1*s2 - b3*e2*s1;
+ double const E = d1*h2*s3 - d1*h3*s2 - d2*h1*s3 + d2*h3*s1 + d3*h1*s2 - d3*h2*s1;
+ double const F = (b1*h2 + d1*e2)*s3 - (b1*h3 + d1*e3)*s2
- (b2*h1 + d2*e1)*s3 + (b2*h3 + d2*e3)*s1
+ (b3*h1 + d3*e1)*s2 - (b3*h2 + d3*e2)*s1;
- double G = (a1*e2*s3 + b1*e2*q3) - (a1*e3*s2 + b1*e3*q2)
+ double const G = (a1*e2*s3 + b1*e2*q3) - (a1*e3*s2 + b1*e3*q2)
- (a2*e1*s3 + b2*e1*q3) + (a2*e3*s1 + b2*e3*q1)
+ (a3*e1*s2 + b3*e1*q2) - (a3*e2*s1 + b3*e2*q1);
- double H = (c1*h2*s3 + d1*h2*q3) - (c1*h3*s2 + d1*h3*q2)
+ double const H = (c1*h2*s3 + d1*h2*q3) - (c1*h3*s2 + d1*h3*q2)
- (c2*h1*s3 + d2*h1*q3) + (c2*h3*s1 + d2*h3*q1)
+ (c3*h1*s2 + d3*h1*q2) - (c3*h2*s1 + d3*h2*q1);
- double I = ((a1*h2 + c1*e2)*s3 + (b1*h2 + d1*e2)*q3)
+ double const I = ((a1*h2 + c1*e2)*s3 + (b1*h2 + d1*e2)*q3)
- ((a1*h3 + c1*e3)*s2 + (b1*h3 + d1*e3)*q2)
- ((a2*h1 + c2*e1)*s3 + (b2*h1 + d2*e1)*q3)
+ ((a2*h3 + c2*e3)*s1 + (b2*h3 + d2*e3)*q1)
+ ((a3*h1 + c3*e1)*s2 + (b3*h1 + d3*e1)*q2)
- ((a3*h2 + c3*e2)*s1 + (b3*h2 + d3*e2)*q1);
- double J = a1*f2*r3 - a1*f3*r2 - a2*f1*r3 + a2*f3*r1 + a3*f1*r2 - a3*f2*r1;
- double K = c1*p2*r3 - c1*p3*r2 - c2*p1*r3 + c2*p3*r1 + c3*p1*r2 - c3*p2*r1;
- double L = (a1*p2 + c1*f2)*r3 - (a1*p3 + c1*f3)*r2
+ double const J = a1*f2*r3 - a1*f3*r2 - a2*f1*r3 + a2*f3*r1 + a3*f1*r2 - a3*f2*r1;
+ double const K = c1*p2*r3 - c1*p3*r2 - c2*p1*r3 + c2*p3*r1 + c3*p1*r2 - c3*p2*r1;
+ double const L = (a1*p2 + c1*f2)*r3 - (a1*p3 + c1*f3)*r2
- (a2*p1 + c2*f1)*r3 + (a2*p3 + c2*f3)*r1
+ (a3*p1 + c3*f1)*r2 - (a3*p2 + c3*f2)*r1;
- double M = b1*f2*t3 - b1*f3*t2 - b2*f1*t3 + b2*f3*t1 + b3*f1*t2 - b3*f2*t1;
- double N = d1*p2*t3 - d1*p3*t2 - d2*p1*t3 + d2*p3*t1 + d3*p1*t2 - d3*p2*t1;
- double O = (b1*p2 + d1*f2)*t3 - (b1*p3 + d1*f3)*t2
+ double const M = b1*f2*t3 - b1*f3*t2 - b2*f1*t3 + b2*f3*t1 + b3*f1*t2 - b3*f2*t1;
+ double const N = d1*p2*t3 - d1*p3*t2 - d2*p1*t3 + d2*p3*t1 + d3*p1*t2 - d3*p2*t1;
+ double const O = (b1*p2 + d1*f2)*t3 - (b1*p3 + d1*f3)*t2
- (b2*p1 + d2*f1)*t3 + (b2*p3 + d2*f3)*t1
+ (b3*p1 + d3*f1)*t2 - (b3*p2 + d3*f2)*t1;
- double P = (a1*f2*t3 + b1*f2*r3) - (a1*f3*t2 + b1*f3*r2)
+ double const P = (a1*f2*t3 + b1*f2*r3) - (a1*f3*t2 + b1*f3*r2)
- (a2*f1*t3 + b2*f1*r3) + (a2*f3*t1 + b2*f3*r1)
+ (a3*f1*t2 + b3*f1*r2) - (a3*f2*t1 + b3*f2*r1);
- double Q = (c1*p2*t3 + d1*p2*r3) - (c1*p3*t2 + d1*p3*r2)
+ double const Q = (c1*p2*t3 + d1*p2*r3) - (c1*p3*t2 + d1*p3*r2)
- (c2*p1*t3 + d2*p1*r3) + (c2*p3*t1 + d2*p3*r1)
+ (c3*p1*t2 + d3*p1*r2) - (c3*p2*t1 + d3*p2*r1);
- double R = ((a1*p2 + c1*f2)*t3 + (b1*p2 + d1*f2)*r3)
+ double const R = ((a1*p2 + c1*f2)*t3 + (b1*p2 + d1*f2)*r3)
- ((a1*p3 + c1*f3)*t2 + (b1*p3 + d1*f3)*r2)
- ((a2*p1 + c2*f1)*t3 + (b2*p1 + d2*f1)*r3)
+ ((a2*p3 + c2*f3)*t1 + (b2*p3 + d2*f3)*r1)
+ ((a3*p1 + c3*f1)*t2 + (b3*p1 + d3*f1)*r2)
- ((a3*p2 + c3*f2)*t1 + (b3*p2 + d3*f2)*r1);
- double S = (a1*e2*r3 + a1*f2*q3) - (a1*e3*r2 + a1*f3*q2)
+ double const S = (a1*e2*r3 + a1*f2*q3) - (a1*e3*r2 + a1*f3*q2)
- (a2*e1*r3 + a2*f1*q3) + (a2*e3*r1 + a2*f3*q1)
+ (a3*e1*r2 + a3*f1*q2) - (a3*e2*r1 + a3*f2*q1);
- double T = (c1*h2*r3 + c1*p2*q3) - (c1*h3*r2 + c1*p3*q2)
+ double const T = (c1*h2*r3 + c1*p2*q3) - (c1*h3*r2 + c1*p3*q2)
- (c2*h1*r3 + c2*p1*q3) + (c2*h3*r1 + c2*p3*q1)
+ (c3*h1*r2 + c3*p1*q2) - (c3*h2*r1 + c3*p2*q1);
- double U = ((a1*h2 + c1*e2)*r3 + (a1*p2 + c1*f2)*q3)
+ double const U = ((a1*h2 + c1*e2)*r3 + (a1*p2 + c1*f2)*q3)
- ((a1*h3 + c1*e3)*r2 + (a1*p3 + c1*f3)*q2)
- ((a2*h1 + c2*e1)*r3 + (a2*p1 + c2*f1)*q3)
+ ((a2*h3 + c2*e3)*r1 + (a2*p3 + c2*f3)*q1)
+ ((a3*h1 + c3*e1)*r2 + (a3*p1 + c3*f1)*q2)
- ((a3*h2 + c3*e2)*r1 + (a3*p2 + c3*f2)*q1);
- double V = (b1*e2*t3 + b1*f2*s3) - (b1*e3*t2 + b1*f3*s2)
+ double const V = (b1*e2*t3 + b1*f2*s3) - (b1*e3*t2 + b1*f3*s2)
- (b2*e1*t3 + b2*f1*s3) + (b2*e3*t1 + b2*f3*s1)
+ (b3*e1*t2 + b3*f1*s2) - (b3*e2*t1 + b3*f2*s1);
- double W = (d1*h2*t3 + d1*p2*s3) - (d1*h3*t2 + d1*p3*s2)
+ double const W = (d1*h2*t3 + d1*p2*s3) - (d1*h3*t2 + d1*p3*s2)
- (d2*h1*t3 + d2*p1*s3) + (d2*h3*t1 + d2*p3*s1)
+ (d3*h1*t2 + d3*p1*s2) - (d3*h2*t1 + d3*p2*s1);
- double X = ((b1*h2 + d1*e2)*t3 + (b1*p2 + d1*f2)*s3)
+ double const X = ((b1*h2 + d1*e2)*t3 + (b1*p2 + d1*f2)*s3)
- ((b1*h3 + d1*e3)*t2 + (b1*p3 + d1*f3)*s2)
- ((b2*h1 + d2*e1)*t3 + (b2*p1 + d2*f1)*s3)
+ ((b2*h3 + d2*e3)*t1 + (b2*p3 + d2*f3)*s1)
+ ((b3*h1 + d3*e1)*t2 + (b3*p1 + d3*f1)*s2)
- ((b3*h2 + d3*e2)*t1 + (b3*p2 + d3*f2)*s1);
- double Y = (a1*e2*t3 + a1*f2*s3 + b1*e2*r3 + b1*f2*q3)
+ double const Y = (a1*e2*t3 + a1*f2*s3 + b1*e2*r3 + b1*f2*q3)
- (a1*e3*t2 + a1*f3*s2 + b1*e3*r2 + b1*f3*q2)
- (a2*e1*t3 + a2*f1*s3 + b2*e1*r3 + b2*f1*q3)
+ (a2*e3*t1 + a2*f3*s1 + b2*e3*r1 + b2*f3*q1)
+ (a3*e1*t2 + a3*f1*s2 + b3*e1*r2 + b3*f1*q2)
- (a3*e2*t1 + a3*f2*s1 + b3*e2*r1 + b3*f2*q1);
- double Z = (c1*h2*t3 + c1*p2*s3 + d1*h2*r3 + d1*p2*q3)
+ double const Z = (c1*h2*t3 + c1*p2*s3 + d1*h2*r3 + d1*p2*q3)
- (c1*h3*t2 + c1*p3*s2 + d1*h3*r2 + d1*p3*q2)
- (c2*h1*t3 + c2*p1*s3 + d2*h1*r3 + d2*p1*q3)
+ (c2*h3*t1 + c2*p3*s1 + d2*h3*r1 + d2*p3*q1)
+ (c3*h1*t2 + c3*p1*s2 + d3*h1*r2 + d3*p1*q2)
- (c3*h2*t1 + c3*p2*s1 + d3*h2*r1 + d3*p2*q1);
- double AA = ((a1*h2 + c1*e2)*t3 + (a1*p2 + c1*f2)*s3
+ double const AA = ((a1*h2 + c1*e2)*t3 + (a1*p2 + c1*f2)*s3
+(b1*h2 + d1*e2)*r3 + (b1*p2 + d1*f2)*q3)
- ((a1*h3 + c1*e3)*t2 + (a1*p3 + c1*f3)*s2
+(b1*h3 + d1*e3)*r2 + (b1*p3 + d1*f3)*q2)
coords[3*OTT<ConnType,numPol>::coo2C(connec[i+1])+2])/3.;
ConnType tmpConn[3]={connec[0],connec[i],connec[i+1]};
areaVectorOfPolygon<ConnType,numPol>(tmpConn,3,coords,tmpArea);
- double norm2=sqrt(tmpArea[0]*tmpArea[0]+tmpArea[1]*tmpArea[1]+tmpArea[2]*tmpArea[2]);
+ double const norm2=sqrt(tmpArea[0]*tmpArea[0]+tmpArea[1]*tmpArea[1]+tmpArea[2]*tmpArea[2]);
if(norm2>1e-12)
{
tmpArea[0]/=norm2; tmpArea[1]/=norm2; tmpArea[2]/=norm2;
- double signOfArea=area[0]*tmpArea[0]+area[1]*tmpArea[1]+area[2]*tmpArea[2];
+ double const signOfArea=area[0]*tmpArea[0]+area[1]*tmpArea[1]+area[2]*tmpArea[2];
res[0]+=signOfArea*norm2*v[0]/norm; res[1]+=signOfArea*norm2*v[1]/norm; res[2]+=signOfArea*norm2*v[2]/norm;
}
}
// projection to (u,v) of each faces of polyh to compute integral(x^2/2) on each faces.
double normal[3];
areaVectorOfPolygon<ConnType,numPol>(work,nbOfNodesOfCurFace,coords,normal);
- double normOfNormal=sqrt(normal[0]*normal[0]+normal[1]*normal[1]+normal[2]*normal[2]);
+ double const normOfNormal=sqrt(normal[0]*normal[0]+normal[1]*normal[1]+normal[2]*normal[2]);
if(normOfNormal<std::numeric_limits<double>::min())
continue;
normal[0]/=normOfNormal; normal[1]/=normOfNormal; normal[2]/=normOfNormal;
double u[2]={normal[1],-normal[0]};
- double s=sqrt(u[0]*u[0]+u[1]*u[1]);
- double c=normal[2];
+ double const s=sqrt(u[0]*u[0]+u[1]*u[1]);
+ double const c=normal[2];
if(fabs(s)>1e-12)
{
u[0]/=std::abs(s); u[1]/=std::abs(s);
normal[1]*coords[3*OTT<ConnType,numPol>::coo2C(work[0])+1]+
normal[2]*coords[3*OTT<ConnType,numPol>::coo2C(work[0])+2];
// A,B,D,F,G,H,L,M,N coeffs of rotation matrix defined by (u,c,s)
- double A=u[0]*u[0]*(1-c)+c;
- double B=u[0]*u[1]*(1-c);
- double D=u[1]*s;
- double F=B;
- double G=u[1]*u[1]*(1-c)+c;
- double H=-u[0]*s;
- double L=-u[1]*s;
- double M=u[0]*s;
- double N=c;
- double CX=-w*D;
- double CY=-w*H;
- double CZ=-w*N;
+ double const A=u[0]*u[0]*(1-c)+c;
+ double const B=u[0]*u[1]*(1-c);
+ double const D=u[1]*s;
+ double const F=B;
+ double const G=u[1]*u[1]*(1-c)+c;
+ double const H=-u[0]*s;
+ double const L=-u[1]*s;
+ double const M=u[0]*s;
+ double const N=c;
+ double const CX=-w*D;
+ double const CY=-w*H;
+ double const CZ=-w*N;
for(int j=0;j<nbOfNodesOfCurFace;j++)
{
const double *p1=coords+3*OTT<ConnType,numPol>::coo2C(work[j]);
const double *p2=coords+3*OTT<ConnType,numPol>::coo2C(work[(j+1)%nbOfNodesOfCurFace]);
- double u1=A*p1[0]+B*p1[1]+D*p1[2];
- double u2=A*p2[0]+B*p2[1]+D*p2[2];
- double v1=F*p1[0]+G*p1[1]+H*p1[2];
- double v2=F*p2[0]+G*p2[1]+H*p2[2];
+ double const u1=A*p1[0]+B*p1[1]+D*p1[2];
+ double const u2=A*p2[0]+B*p2[1]+D*p2[2];
+ double const v1=F*p1[0]+G*p1[1]+H*p1[2];
+ double const v2=F*p2[0]+G*p2[1]+H*p2[2];
//
- double gx=integrationOverA3DLine(u1,v1,u2,v2,A,B,CX);
- double gy=integrationOverA3DLine(u1,v1,u2,v2,F,G,CY);
- double gz=integrationOverA3DLine(u1,v1,u2,v2,L,M,CZ);
+ double const gx=integrationOverA3DLine(u1,v1,u2,v2,A,B,CX);
+ double const gy=integrationOverA3DLine(u1,v1,u2,v2,F,G,CY);
+ double const gz=integrationOverA3DLine(u1,v1,u2,v2,L,M,CZ);
res[0]+=gx*normal[0];
res[1]+=gy*normal[1];
res[2]+=gz*normal[2];
int nbOfNodesOfCurFace=(int)std::distance(work,work2);
double normal[3];
areaVectorOfPolygon<ConnType,numPol>(work,nbOfNodesOfCurFace,coords,normal);
- double normOfNormal=sqrt(normal[0]*normal[0]+normal[1]*normal[1]+normal[2]*normal[2]);
+ double const normOfNormal=sqrt(normal[0]*normal[0]+normal[1]*normal[1]+normal[2]*normal[2]);
if(normOfNormal<std::numeric_limits<double>::min())
continue;
sum+=normOfNormal;
res[0]=0.; res[1]=0.;
for(mcIdType i=0;i<lgth;i++)
{
- double cp=coords[i][0]*coords[(i+1)%lgth][1]-coords[i][1]*coords[(i+1)%lgth][0];
+ double const cp=coords[i][0]*coords[(i+1)%lgth][1]-coords[i][1]*coords[(i+1)%lgth][0];
area+=cp;
res[0]+=cp*(coords[i][0]+coords[(i+1)%lgth][0]);
res[1]+=cp*(coords[i][1]+coords[(i+1)%lgth][1]);
template<class ConnType, NumberingPolicy numPol>
inline void computePolygonBarycenter2D(const ConnType *connec, mcIdType lgth, const double *coords, double *res)
{
- double **coords2=new double *[lgth];
+ auto **coords2=new double *[lgth];
for(mcIdType i=0;i<lgth;i++)
coords2[i]=const_cast<double *>(coords+2*OTT<ConnType,numPol>::coo2C(connec[i]));
computePolygonBarycenter2DEngine(coords2,lgth,res);
#include "VolSurfUser.hxx"
#include "InterpKernelAutoPtr.hxx"
#include "InterpolationUtils.hxx"
-#include "VectorUtils.hxx"
+#include "MCIdType.hxx"
#include <cmath>
+#include <cstddef>
+#include <iterator>
#include <limits>
#include <algorithm>
#include <functional>
*/
double OrthoDistanceFromPtToPlaneInSpaceDim3(const double *p, const double *p1, const double *p2, const double *p3)
{
- double prec = 1.0e-14;
- double T[2][3] = {{p1[0] - p2[0], p1[1] - p2[1], p1[2] - p2[2]},
+ double const prec = 1.0e-14;
+ double const T[2][3] = {{p1[0] - p2[0], p1[1] - p2[1], p1[2] - p2[2]},
{p3[0] - p2[0], p3[1] - p2[1], p3[2] - p2[2]}};
- double N[3] = {T[0][1]*T[1][2]-T[0][2]*T[1][1],
+ double const N[3] = {T[0][1]*T[1][2]-T[0][2]*T[1][1],
T[0][2]*T[1][0]-T[0][0]*T[1][2],
T[0][0]*T[1][1]-T[0][1]*T[1][0]};
- double norm2 = N[0]*N[0] + N[1]*N[1] + N[2]*N[2];
+ double const norm2 = N[0]*N[0] + N[1]*N[1] + N[2]*N[2];
if (norm2 < prec)
throw INTERP_KERNEL::Exception("OrthoDistanceFromPtToPlaneInSpaceDim3: degenerated normal vector!");
- double num = N[0]*(p[0]-p1[0]) + N[1]*(p[1]-p1[1]) + N[2]*(p[2]-p1[2]);
+ double const num = N[0]*(p[0]-p1[0]) + N[1]*(p[1]-p1[1]) + N[2]*(p[2]-p1[2]);
return num/sqrt(norm2);
}
double SquareDistanceFromPtToSegInSpaceDim2(const double *pt, const double *pt0Seg2, const double *pt1Seg2, std::size_t &nbOfHint)
{
double dx=pt1Seg2[0]-pt0Seg2[0],dy=pt1Seg2[1]-pt0Seg2[1];
- double norm=sqrt(dx*dx+dy*dy);
+ double const norm=sqrt(dx*dx+dy*dy);
if(norm==0.)
return (pt[0]-pt0Seg2[0])*(pt[0]-pt0Seg2[0])+(pt[1]-pt0Seg2[1])*(pt[1]-pt0Seg2[1]);//return std::numeric_limits<double>::max();
dx/=norm; dy/=norm;
double dx2=pt[0]-pt0Seg2[0],dy2=pt[1]-pt0Seg2[1];
- double dotP=(dx2*dx+dy2*dy);
+ double const dotP=(dx2*dx+dy2*dy);
if(dotP<0. || dotP>norm)
return dotP<0.?(pt[0]-pt0Seg2[0])*(pt[0]-pt0Seg2[0])+(pt[1]-pt0Seg2[1])*(pt[1]-pt0Seg2[1]):(pt[0]-pt1Seg2[0])*(pt[0]-pt1Seg2[0])+(pt[1]-pt1Seg2[1])*(pt[1]-pt1Seg2[1]);
nbOfHint++;
w[i] = pt[i] - pt0Seg2[i];
}
- double c1 = dotprod<3>(w,v);
+ double const c1 = dotprod<3>(w,v);
if ( c1 <= 0 )
return norm<3>(w);
- double c2 = dotprod<3>(v,v);
+ double const c2 = dotprod<3>(v,v);
if ( c2 <= c1 )
{
for(int i=0; i < 3; i++)
w[i] = pt[i] - pt1Seg2[i];
return norm<3>(w);
}
- double b = c1 / c2;
+ double const b = c1 / c2;
for(int i=0; i < 3; i++)
w[i] = pt0Seg2[i] + b * v[i] - pt[i];
return norm<3>(w);
double a00=dotprod<3>(edge0, edge0), a01=dotprod<3>(edge0,edge1), a11=dotprod<3>(edge1,edge1);
double b0=dotprod<3>(diff, edge0), b1=dotprod<3>(diff, edge1), c=dotprod<3>(diff, diff);
- double det = fabs(a00*a11 - a01*a01);
+ double const det = fabs(a00*a11 - a01*a01);
double s = a01*b1 - a11*b0, t = a01*b0 - a00*b1;
double sDist;
{
// points are colinear (degenerated triangle)
// => Compute distance between segments
- double distance = std::min(DistanceFromPtToSegInSpaceDim3(pt, pt0Tri3, pt1Tri3),
+ double const distance = std::min(DistanceFromPtToSegInSpaceDim3(pt, pt0Tri3, pt1Tri3),
DistanceFromPtToSegInSpaceDim3(pt, pt1Tri3, pt2Tri3));
return distance;
}
// else we can divide by non-zero
- double invDet = 1 / det;
+ double const invDet = 1 / det;
s *= invDet; t *= invDet;
sDist = s*(a00*s + a01*t + 2*b0) + t*(a01*s + a11*t + 2*b1) + c;
}
if (t < 0.0) // region 6
sDist = _HelperDistancePtToTri3D_2(a01, a11, a00, b1, b0, c);
else { // region 1
- double numer = a11 + b1 - a01 - b0;
+ double const numer = a11 + b1 - a01 - b0;
if (numer <= 0.0)
sDist = a11 + 2*b1 + c;
else {
- double denom = a00 - 2*a01 + a11;
+ double const denom = a00 - 2*a01 + a11;
if (numer >= denom)
sDist = a00 + 2*b0 + c;
else {
double DistanceFromPtToPolygonInSpaceDim3(const double *pt, const mcIdType *connOfPolygonBg, const mcIdType *connOfPolygonEnd, const double *coords)
{
- std::size_t nbOfEdges=std::distance(connOfPolygonBg,connOfPolygonEnd);
+ std::size_t const nbOfEdges=std::distance(connOfPolygonBg,connOfPolygonEnd);
if(nbOfEdges<3)
throw INTERP_KERNEL::Exception("DistanceFromPtToPolygonInSpaceDim3 : trying to compute a distance to a polygon containing less than 3 edges !");
double baryOfNodes[3]={0.,0.,0.};
ptXY[2*i+1]=matrix[4]*coords[3*connOfPolygonBg[i]]+matrix[5]*coords[3*connOfPolygonBg[i]+1]+matrix[6]*coords[3*connOfPolygonBg[i]+2]+matrix[7];
}
double xy[2]={matrix[0]*pt[0]+matrix[1]*pt[1]+matrix[2]*pt[2]+matrix[3],matrix[4]*pt[0]+matrix[5]*pt[1]+matrix[6]*pt[2]+matrix[7]};
- double z=matrix[8]*pt[0]+matrix[9]*pt[1]+matrix[10]*pt[2]+matrix[11];
+ double const z=matrix[8]*pt[0]+matrix[9]*pt[1]+matrix[10]*pt[2]+matrix[11];
double ret=std::numeric_limits<double>::max();
std::size_t nbOfHint=0;
for(std::size_t i=0;i<nbOfEdges;i++)
{
- double tmp=SquareDistanceFromPtToSegInSpaceDim2(xy,((double *)ptXY)+2*i,((double *)ptXY)+2*((i+1)%nbOfEdges),nbOfHint);
+ double const tmp=SquareDistanceFromPtToSegInSpaceDim2(xy,((double *)ptXY)+2*i,((double *)ptXY)+2*((i+1)%nbOfEdges),nbOfHint);
ret=std::min(ret,z*z+tmp);
}
if(nbOfHint==nbOfEdges)
z*s,y*y*(1-c)+c,y*z*(1-c),
-y*s,z*y*(1-c),z*z*(1-c)+c};
// 2nd rotation matrix
- double x=p2[0]-p0[0];
+ double const x=p2[0]-p0[0];
y=p2[1]-p0[1]; z=p2[2]-p0[2];
double y1=x*r0[3]+y*r0[4]+z*r0[5],z1=x*r0[6]+y*r0[7]+z*r0[8];
c=y1/sqrt(y1*y1+z1*z1);
#define __VOLSURFUSER_HXX__
#include "INTERPKERNELDefines.hxx"
-#include "InterpKernelException.hxx"
#include "NormalizedUnstructuredMesh.hxx"
+#include "NormalizedGeometricTypes"
#include "MCIdType.hxx"
+#include <cstddef>
namespace INTERP_KERNEL
{
#ifndef __VOLSURFUSER_TXX__
#define __VOLSURFUSER_TXX__
+#include "NormalizedGeometricTypes"
+#include "NormalizedUnstructuredMesh.hxx"
+#include "MCIdType.hxx"
+#include "InterpKernelGeo2DEdge.hxx"
#include "VolSurfUser.hxx"
#include "VolSurfFormulae.hxx"
#include "InterpolationUtils.hxx"
#include "VectorUtils.hxx"
#include <algorithm>
+#include <functional>
+#include <cmath>
namespace INTERP_KERNEL
{
break;
case INTERP_KERNEL::NORM_POLYGON :
{
- const double **pts=new const double *[lgth];
+ const auto **pts=new const double *[lgth];
for(int inod=0;inod<lgth;inod++)
pts[inod] = coords+SPACEDIM*OTT<ConnType,numPol>::coo2C(connec[inod]);
double val=INTERP_KERNEL::calculateAreaForPolyg(pts,lgth,SPACEDIM);
break;
case INTERP_KERNEL::NORM_QPOLYG :
{
- const double **pts=new const double *[lgth];
+ const auto **pts=new const double *[lgth];
for(int inod=0;inod<lgth;inod++)
pts[inod] = coords+SPACEDIM*OTT<ConnType,numPol>::coo2C(connec[inod]);
double val=INTERP_KERNEL::calculateAreaForQPolyg(pts,lgth,SPACEDIM);
{
if(SPACEDIM==2)
{
- double **pts=new double *[lgth];
+ auto **pts=new double *[lgth];
for(int i=0;i<lgth;i++)
pts[i]=const_cast<double *>(coords+2*OTT<ConnType,numPol>::coo2C(connec[i]));
computeQPolygonBarycenter2D(pts,lgth,2,res);
double AB = getDistanceBtw2Pts<SPACEDIM>(PA,PB); double maxLength = AB;
double BC = getDistanceBtw2Pts<SPACEDIM>(PB,PC); if (BC > maxLength) maxLength = BC;
double CA = getDistanceBtw2Pts<SPACEDIM>(PC,PA); if (CA > maxLength) maxLength = CA;
- double perim( (AB+BC+CA)*0.5 );
- double num( 2*sqrt(perim*(perim-AB)*(perim-BC)*(perim-CA)) );
+ double const perim( (AB+BC+CA)*0.5 );
+ double const num( 2*sqrt(perim*(perim-AB)*(perim-BC)*(perim-CA)) );
res[0] = num/AB; res[1] = num/BC; res[2] = num/CA;
if (AB/maxLength <= EPS)
res[0] = BC;
//
#include "BBTreeTest.hxx"
-#include <iostream>
+#include <cppunit/TestAssert.h>
#include <vector>
+#include "BBTree.txx"
#include "DirectedBoundingBox.hxx"
namespace INTERP_TEST
void BBTreeTest::test_BBTree() {
//bbox tree creation
const int N=10;
- double* bbox=new double[4*N*N];
+ auto* bbox=new double[4*N*N];
for (int i=0; i<N; i++)
for (int j=0; j<N; j++)
{
bbox[4*(i*N+j)+2]=j;
bbox[4*(i*N+j)+3]=j+1;
}
- BBTree<2> tree(bbox,0,0,N*N);
+ BBTree<2> const tree(bbox,nullptr,0,N*N);
std::vector <int> elems;
//box outside the tree
0,-3,0, 2,-3,0, 2,-2,0, 0,-2,0,
10,-3,10, 12,-3,10, 12,-2,10, 10,-2,10
};
- INTERP_KERNEL::DirectedBoundingBox shiftedBB_x( shifted_x, nbP, dim);
- INTERP_KERNEL::DirectedBoundingBox shiftedBB_X( shifted_X, nbP, dim);
- INTERP_KERNEL::DirectedBoundingBox shiftedBB_y( shifted_y, nbP, dim);
- INTERP_KERNEL::DirectedBoundingBox shiftedBB_Y( shifted_Y, nbP, dim);
+ INTERP_KERNEL::DirectedBoundingBox const shiftedBB_x( shifted_x, nbP, dim);
+ INTERP_KERNEL::DirectedBoundingBox const shiftedBB_X( shifted_X, nbP, dim);
+ INTERP_KERNEL::DirectedBoundingBox const shiftedBB_y( shifted_y, nbP, dim);
+ INTERP_KERNEL::DirectedBoundingBox const shiftedBB_Y( shifted_Y, nbP, dim);
CPPUNIT_ASSERT( bb.isDisjointWith( shiftedBB_x ));
CPPUNIT_ASSERT( bb.isDisjointWith( shiftedBB_X ));
0,0,0, 2,0,0, 2,1,0, 0,1,0,
0,0,2, 2,0,2, 2,1,2, 0,1,2
};
- INTERP_KERNEL::DirectedBoundingBox ibb( inters_coords, nbP, dim);
+ INTERP_KERNEL::DirectedBoundingBox const ibb( inters_coords, nbP, dim);
CPPUNIT_ASSERT( !bb.isDisjointWith( ibb ));
// overlapping non-directed BB
-3,0, -1,0,
7,10, 9,10,
};
- INTERP_KERNEL::DirectedBoundingBox shiftedBB_x( shifted_x, nbP, dim);
- INTERP_KERNEL::DirectedBoundingBox shiftedBB_X( shifted_X, nbP, dim);
+ INTERP_KERNEL::DirectedBoundingBox const shiftedBB_x( shifted_x, nbP, dim);
+ INTERP_KERNEL::DirectedBoundingBox const shiftedBB_X( shifted_X, nbP, dim);
CPPUNIT_ASSERT( bb.isDisjointWith( shiftedBB_x ));
CPPUNIT_ASSERT( bb.isDisjointWith( shiftedBB_X ));
0,0, 2,0,
0,2, 2,2
};
- INTERP_KERNEL::DirectedBoundingBox ibb( inters_coords, nbP, dim);
+ INTERP_KERNEL::DirectedBoundingBox const ibb( inters_coords, nbP, dim);
CPPUNIT_ASSERT( !bb.isDisjointWith( ibb ));
// overlapping non-directed BB
{
-3.0, -0.001
};
- INTERP_KERNEL::DirectedBoundingBox shiftedBB_x( shifted_x, nbP, dim);
- INTERP_KERNEL::DirectedBoundingBox shiftedBB_X( shifted_X, nbP, dim);
+ INTERP_KERNEL::DirectedBoundingBox const shiftedBB_x( shifted_x, nbP, dim);
+ INTERP_KERNEL::DirectedBoundingBox const shiftedBB_X( shifted_X, nbP, dim);
CPPUNIT_ASSERT( bb.isDisjointWith( shiftedBB_x ));
CPPUNIT_ASSERT( bb.isDisjointWith( shiftedBB_X ));
{
-2,2
};
- INTERP_KERNEL::DirectedBoundingBox ibb( inters_coords, nbP, dim);
+ INTERP_KERNEL::DirectedBoundingBox const ibb( inters_coords, nbP, dim);
CPPUNIT_ASSERT( !bb.isDisjointWith( ibb ));
// overlapping non-directed BB
#ifndef __TU_BB_TREE_HXX__
#define __TU_BB_TREE_HXX__
+#include <cppunit/TestFixture.h>
#include <cppunit/extensions/HelperMacros.h>
-#include "InterpKernelTestExport.hxx"
#include "BBTree.txx"
+#include "InterpKernelTestExport.hxx"
namespace INTERP_TEST
{
#define _BASICMAINTEST_HXX_
#include <cppunit/CompilerOutputter.h>
+#include <cppunit/Portability.h>
#include <cppunit/TestResult.h>
#include <cppunit/TestResultCollector.h>
#include <cppunit/TextTestProgressListener.h>
-#include <cppunit/BriefTestProgressListener.h>
#include <cppunit/extensions/TestFactoryRegistry.h>
#include <cppunit/TestRunner.h>
-#include <stdexcept>
#include <iostream>
#include <fstream>
*/
// ============================================================================
-int main(int argc, char* argv[])
+int main(int /*argc*/, char* /*argv*/[])
{
#if !defined WIN32 && !defined __APPLE__
fpu_control_t cw = _FPU_DEFAULT & ~(_FPU_MASK_IM | _FPU_MASK_ZM | _FPU_MASK_OM);
// --- Run the tests.
- bool wasSucessful = result.wasSuccessful();
+ bool const wasSucessful = result.wasSuccessful();
testFile.close();
// --- Return error code 1 if the one of test failed.
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-#include "CppUnitTest.hxx"
#ifndef __TU_TEST_CPPUNIT_HXX__
#define __TU_TEST_CPPUNIT_HXX__
+#include <cppunit/TestFixture.h>
+#include <cppunit/TestAssert.h>
#include <cppunit/extensions/HelperMacros.h>
#include "InterpKernelTestExport.hxx"
CPPUNIT_TEST_SUITE_END();
public:
- void setUp() {
+ void setUp() override {
obj = new BogusClass(3.14);
}
- void tearDown() {
+ void tearDown() override {
delete obj;
}
// Author : Anthony Geay (CEA/DEN)
#include "ExprEvalInterpTest.hxx"
+#include "InterpKernelException.hxx"
#include "InterpKernelExprParser.hxx"
+#include "InterpKernelUnit.hxx"
+#include <cppunit/TestAssert.h>
+#include <algorithm>
#include <limits>
-#include <iterator>
+#include <string>
+#include <set>
+#include <vector>
using namespace INTERP_TEST;
void ExprEvalInterpTest::testInterpreterUnit1()
{
- INTERP_KERNEL::Unit unit1("m/s");
- INTERP_KERNEL::Unit unit2("km/h");
+ INTERP_KERNEL::Unit const unit1("m/s");
+ INTERP_KERNEL::Unit const unit2("km/h");
CPPUNIT_ASSERT(unit1.isCompatibleWith(unit2) && unit2.isCompatibleWith(unit1));
CPPUNIT_ASSERT_DOUBLES_EQUAL(360,unit1.convert(unit2,100.),1e-10);
- INTERP_KERNEL::Unit unit3("J/s");
- INTERP_KERNEL::Unit unit4("kW");
+ INTERP_KERNEL::Unit const unit3("J/s");
+ INTERP_KERNEL::Unit const unit4("kW");
CPPUNIT_ASSERT(unit3.isCompatibleWith(unit4) && unit4.isCompatibleWith(unit3));
CPPUNIT_ASSERT_DOUBLES_EQUAL(1.,unit3.convert(unit4,1000.),1e-10);
CPPUNIT_ASSERT(unit4.getCoarseRepr()=="kW");
- INTERP_KERNEL::Unit unit5("kpT");
+ INTERP_KERNEL::Unit const unit5("kpT");
CPPUNIT_ASSERT(!unit5.isInterpretationOK());
CPPUNIT_ASSERT(unit5.getCoarseRepr()=="kpT");
- INTERP_KERNEL::Unit unit6("m*kpT");
+ INTERP_KERNEL::Unit const unit6("m*kpT");
CPPUNIT_ASSERT(!unit6.isInterpretationOK());
- INTERP_KERNEL::Unit unit7("m*s^-1");
+ INTERP_KERNEL::Unit const unit7("m*s^-1");
CPPUNIT_ASSERT(unit7.isCompatibleWith(unit2) && unit2.isCompatibleWith(unit7));
CPPUNIT_ASSERT_DOUBLES_EQUAL(360,unit7.convert(unit2,100.),1e-10);
const char unit8C[3]={-0x50,0x43,0x0};
- INTERP_KERNEL::Unit unit8(unit8C);
- INTERP_KERNEL::Unit unit9("K");
+ INTERP_KERNEL::Unit const unit8(unit8C);
+ INTERP_KERNEL::Unit const unit9("K");
CPPUNIT_ASSERT(unit9.isCompatibleWith(unit8) && unit8.isCompatibleWith(unit9));
CPPUNIT_ASSERT_DOUBLES_EQUAL(335.15,unit8.convert(unit9,62.),1e-10);
CPPUNIT_ASSERT_DOUBLES_EQUAL(-16.37,unit9.convert(unit8,256.78),1e-10);
- INTERP_KERNEL::Unit unit10("m");
- INTERP_KERNEL::Unit unit11("cm");
+ INTERP_KERNEL::Unit const unit10("m");
+ INTERP_KERNEL::Unit const unit11("cm");
CPPUNIT_ASSERT(unit10.isCompatibleWith(unit11) && unit11.isCompatibleWith(unit10));
CPPUNIT_ASSERT_DOUBLES_EQUAL(6200.,unit10.convert(unit11,62.),1e-8);
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.62,unit11.convert(unit10,62.),1e-15);
- INTERP_KERNEL::Unit unit12("m-m");
+ INTERP_KERNEL::Unit const unit12("m-m");
CPPUNIT_ASSERT(!unit12.isInterpretationOK());
}
INTERP_KERNEL::ExprParser expr5("x-2*cos(y/3.)");
expr5.parse();
expr5.prepareFastEvaluator();
- double *aa(new double[2]);
+ auto *aa(new double[2]);
std::vector<std::string> vv(2); vv[0]="x"; vv[1]="y";
expr5.prepareExprEvaluationDouble(vv,2,1,0,aa,aa+2);
expr5.prepareFastEvaluator();
#ifndef _EXPREVALINTERPTEST_HXX_
#define _EXPREVALINTERPTEST_HXX_
+#include <cppunit/TestFixture.h>
#include <cppunit/extensions/HelperMacros.h>
#include "InterpKernelTestExport.hxx"
#define __HEXA_TESTS_HXX_
#include "InterpolationTestSuite.hxx"
+#include <cppunit/extensions/HelperMacros.h>
namespace INTERP_TEST
{
#include "Interpolation3DTest.hxx"
#include "MEDFileMesh.hxx"
+#include "MCAuto.hxx"
#include "MEDCouplingUMesh.hxx"
#include "MEDCouplingFieldDouble.hxx"
+#include "MeshTestToolkit.hxx"
-#include <map>
+#include <cstdlib>
+#include <cppunit/TestAssert.h>
#include <cmath>
-#include <vector>
+#include <map>
+#include <string>
#include <iostream>
#include <algorithm>
+#include <vector>
+#include <numeric>
#include "VectorUtils.hxx"
#ifndef __TU_INTERPOLATION_3D_TEST_HXX__
#define __TU_INTERPOLATION_3D_TEST_HXX__
-#include <cppunit/extensions/HelperMacros.h>
+#include "MeshTestToolkit.hxx"
#include "Interpolation3D.hxx"
+#include <cppunit/TestFixture.h>
+
#define ERR_TOL 1.0e-8
/// \brief OBSOLETE - renamed Interpolation3DTestSuite
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+#include "MEDCouplingUMesh.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MEDCouplingNormalizedUnstructuredMesh.txx"
+#include "Interpolation2D.hxx"
#include "MEDFileMesh.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "InterpolationOptionsTest.hxx"
-#include "MEDCouplingNormalizedUnstructuredMesh.txx"
-#include "Interpolation2D.txx"
#include "TestInterpKernelUtils.hxx"
-#include <iostream>
-#include <vector>
+#include <string>
using namespace MEDCoupling;
*/
void InterpolationOptionsTest::test_InterpolationOptions()
{
- std::string sourcename=INTERP_TEST::getResourceFile("square1.med");
+ std::string const sourcename=INTERP_TEST::getResourceFile("square1.med");
MEDFileUMesh *source_mesh=MEDFileUMesh::New(sourcename.c_str(),"Mesh_2");
- std::string targetname=INTERP_TEST::getResourceFile("square2.med");
+ std::string const targetname=INTERP_TEST::getResourceFile("square2.med");
MEDFileUMesh *target_mesh=MEDFileUMesh::New(targetname.c_str(),"Mesh_3");
MEDCouplingUMesh *source_mesh_mc=source_mesh->getMeshAtLevel(0);
targetvalue[i]=0.0;
// Ok at this point we have our mesh in MED-Memory format.
// Go to wrap med_source_mesh and med_target_mesh.
- MEDCouplingNormalizedUnstructuredMesh<2,2> wrap_source_mesh(source_mesh_mc);
- MEDCouplingNormalizedUnstructuredMesh<2,2> wrap_target_mesh(target_mesh_mc);
+ MEDCouplingNormalizedUnstructuredMesh<2,2> const wrap_source_mesh(source_mesh_mc);
+ MEDCouplingNormalizedUnstructuredMesh<2,2> const wrap_target_mesh(target_mesh_mc);
// Go for interpolation...
INTERP_KERNEL::Interpolation2D myInterpolator;
//optional call to parametrize your interpolation. First precision, tracelevel, intersector wanted.
#ifndef __TU_INTERPOLATIONOPTIONS_HXX__
#define __TU_INTERPOLATIONOPTIONS_HXX__
+#include <cppunit/TestFixture.h>
#include <cppunit/extensions/HelperMacros.h>
#include "InterpKernelTestExport.hxx"
#ifndef __TU_INTERPOLATION_PLANAR_TEST_SUITE_HXX__
#define __TU_INTERPOLATION_PLANAR_TEST_SUITE_HXX__
-#include <cppunit/extensions/HelperMacros.h>
+#include <cppunit/TestFixture.h>
+#include <cstddef>
#include <deque>
#include <cmath>
#include <iostream>
+#include <vector>
namespace INTERP_TEST
{
* Sets up the test suite.
*
*/
- void setUp()
+ void setUp() override
{
_Epsilon = 1.e-6;
_Precision = 1.e-6;
}
- void tearDown() {}
+ void tearDown() override {}
// bool checkDequesEqual(std::deque< double > deque1, std::deque< double > deque2, double epsilon);
// bool checkVectorsEqual(std::vector< double > Vect1, std::vector< double > Vect2, double epsilon);
bool checkDequesEqual(std::deque< double > deque1,
std::deque< double > deque2, double epsilon)
{
- std::size_t size1 = deque1.size();
- std::size_t size2 = deque2.size();
+ std::size_t const size1 = deque1.size();
+ std::size_t const size2 = deque2.size();
bool are_equal = size1 == size2;
if(are_equal)
bool checkVectorsEqual(std::vector< double > vect1,
std::vector< double > vect2, double epsilon)
{
- std::size_t size1 = vect1.size();
- std::size_t size2 = vect2.size();
+ std::size_t const size1 = vect1.size();
+ std::size_t const size2 = vect2.size();
bool are_equal = size1 == size2;
if(are_equal)
}
void dequePrintOut(std::deque< double > deque1)
{
- for(std::size_t i = 0; i< deque1.size(); i++)
+ for(double const i : deque1)
{
- std::cerr << deque1[i] << " ";
+ std::cerr << i << " ";
}
std::cerr<< std::endl;
}
void vectPrintOut(std::vector< double > vect)
{
- for(std::size_t i = 0; i< vect.size(); i++)
+ for(double const i : vect)
{
- std::cerr << vect[i] << " ";
+ std::cerr << i << " ";
}
std::cerr<< std::endl;
}
#ifndef __TU_INTERPOLATION_TEST_SUITE_HXX__
#define __TU_INTERPOLATION_TEST_SUITE_HXX__
+#include "MeshTestToolkit.hxx"
#include "MeshTestToolkit.txx"
-#include <cppunit/extensions/HelperMacros.h>
+#include <cppunit/TestFixture.h>
namespace INTERP_TEST
{
#include "MCAuto.hxx"
#include "MEDCouplingCMesh.hxx"
+#include "MEDCouplingUMesh.hxx"
+#include "MEDCouplingMemArray.hxx"
#include "MEDMeshMaker.hxx"
#ifndef __TU_MESH_TEST_TOOLKIT_HXX__
#define __TU_MESH_TEST_TOOLKIT_HXX__
-#include "Interpolation3D.hxx"
-#include "Interpolation3D.txx"
-#include "InterpolationPlanar.hxx"
+#include "InterpolationOptions.hxx"
+#include "MCIdType.hxx"
#include <vector>
#include <map>
{
public:
- double _precision;
- INTERP_KERNEL::IntersectionType _intersectionType;//Used only in the case MESHDIM==2 (planar intersections)
+ double _precision{1.e-6};
+ INTERP_KERNEL::IntersectionType _intersectionType{INTERP_KERNEL::Triangulation};//Used only in the case MESHDIM==2 (planar intersections)
- MeshTestToolkit():_precision(1.e-6),_intersectionType(INTERP_KERNEL::Triangulation) {}
+ MeshTestToolkit() = default;
- ~MeshTestToolkit() {}
+ ~MeshTestToolkit() = default;
void intersectMeshes(const char* mesh1, const char* mesh2, const double correctVol, const double prec = 1.0e-5, bool doubleTest = true) const;
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-#include "TestInterpKernelUtils.hxx"
+#ifndef __MESHTESTTOOLKI_TXX__
+#define __MESHTESTTOOLKI_TXX__
#include "MeshTestToolkit.hxx"
+#include "MCAuto.hxx"
+#include "MCIdType.hxx"
+#include "Interpolation2D.hxx"
+
#include "MEDFileMesh.hxx"
-#include "MEDCouplingNormalizedUnstructuredMesh.hxx"
#include "MEDCouplingNormalizedUnstructuredMesh.txx"
#include "MEDCouplingFieldDouble.hxx"
#include "Interpolation3DSurf.hxx"
#include "Interpolation2D.txx"
#include "Interpolation3D.txx"
+#include "TestInterpKernelUtils.hxx"
-#include <map>
+#include <cppunit/TestAssert.h>
#include <cmath>
-#include <vector>
+#include <map>
+#include <string>
#include <cstring>
#include <iostream>
#include <algorithm>
+#include <vector>
+#include <numeric>
// levels :
// 4 - empty
// 5 - misc
#include "Log.hxx"
+#include "VectorUtils.hxx"
-#include <cppunit/extensions/HelperMacros.h>
//#define VOL_PREC 1.0e-6
using namespace MEDCoupling;
double MeshTestToolkit<SPACEDIM,MESHDIM>::sumRow(const IntersectionMatrix& m, int i) const
{
double vol = 0.0;
- for(IntersectionMatrix::const_iterator iter = m.begin() ; iter != m.end() ; ++iter)
+ for(const auto & iter : m)
{
- if(iter->count(i) != 0.0)
+ if(iter.count(i) != 0.0)
{
- std::map<mcIdType, double>::const_iterator iter2 = iter->find(i);
+ auto iter2 = iter.find(i);
vol += fabs(iter2->second);
}
}
{
double vol = 0.0;
const std::map<mcIdType, double>& col = m[i];
- for(std::map<mcIdType, double>::const_iterator iter = col.begin() ; iter != col.end() ; ++iter)
+ for(auto iter : col)
{
- vol += fabs(iter->second);
+ vol += fabs(iter.second);
}
return vol;
}
double MeshTestToolkit<SPACEDIM,MESHDIM>::sumVolume(const IntersectionMatrix& m) const
{
std::vector<double> volumes;
- for(IntersectionMatrix::const_iterator iter = m.begin() ; iter != m.end() ; ++iter)
+ for(const auto & iter : m)
{
- for(std::map<mcIdType, double>::const_iterator iter2 = iter->begin() ; iter2 != iter->end() ; ++iter2)
+ for(const auto & iter2 : iter)
{
- volumes.push_back(fabs(iter2->second));
+ volumes.push_back(fabs(iter2.second));
}
}
// sum in ascending order to avoid rounding errors
- sort(volumes.begin(), volumes.end());
+ std::sort(volumes.begin(), volumes.end());
const double vol = accumulate(volumes.begin(), volumes.end(), 0.0);
return vol;
bool ok = true;
// source elements
- double* sVol = new double[sMesh.getNumberOfCells()];
+ auto* sVol = new double[sMesh.getNumberOfCells()];
getVolumes(sMesh, sVol);
for(int i = 0; i < sMesh.getNumberOfCells(); ++i)
}
// target elements
- double* tVol = new double[tMesh.getNumberOfCells()];
+ auto* tVol = new double[tMesh.getNumberOfCells()];
getVolumes(tMesh, tVol);
for(int i = 0; i < tMesh.getNumberOfCells(); ++i)
{
int i = 0;
for(IntersectionMatrix::const_iterator iter = m1.begin() ; iter != m1.end() ; ++iter)
{
- for(std::map<mcIdType, double>::const_iterator iter2 = iter->begin() ; iter2 != iter->end() ; ++iter2)
+ for(auto iter2 = iter->begin() ; iter2 != iter->end() ; ++iter2)
{
mcIdType j = iter2->first;
if(m2.at(j).count(i) == 0)
for(IntersectionMatrix::const_iterator iter = m1.begin() ; iter != m1.end() ; ++iter)
{
- for(std::map<mcIdType, double>::const_iterator iter2 = iter->begin() ; iter2 != iter->end() ; ++iter2)
+ for(auto iter2 = iter->begin() ; iter2 != iter->end() ; ++iter2)
{
mcIdType j = iter2->first;
const double v1 = fabs(iter2->second);
bool isDiagonal = true;
for(IntersectionMatrix::const_iterator iter = m.begin() ; iter != m.end() ; ++iter)
{
- for(std::map<mcIdType, double>::const_iterator iter2 = iter->begin() ; iter2 != iter->end() ; ++iter2)
+ for(auto iter2 = iter->begin() ; iter2 != iter->end() ; ++iter2)
{
- mcIdType j = iter2->first;
+ mcIdType const j = iter2->first;
const double vol = iter2->second;
if(vol != 0.0 && (i != j))
{
intersectMeshes(path1.c_str(), mesh1, path2.c_str(), mesh2, correctVol, prec, doubleTest);
}
}
+
+#endif
#include "InterpolationTestSuite.hxx"
+#include <cppunit/extensions/HelperMacros.h>
+#include "MeshTestToolkit.hxx"
+
namespace INTERP_TEST
{
/**
#define __MULTI_ELEMENT_3DSurf_TESTS_HXX_
#include "InterpolationTestSuite.hxx"
+#include "InterpolationOptions.hxx"
+#include <cppunit/extensions/HelperMacros.h>
+#include "MeshTestToolkit.hxx"
namespace INTERP_TEST
{
* different geometries : triangle, quadrilateral.
*
*/
- class MultiElement2DTests : public InterpolationTestSuite<3,2>
+ class MultiElement3DSurfTests : public InterpolationTestSuite<3,2>
{
CPPUNIT_TEST_SUITE( MultiElement3DSurfTests );
#define __MULTI_ELEMENT_TETRA_TESTS_HXX_
#include "InterpolationTestSuite.hxx"
+#include <cppunit/extensions/HelperMacros.h>
namespace INTERP_TEST
{
#include "Interpolation3D.hxx"
#include "Interpolation3D.txx"
+#include "MeshTestToolkit.hxx"
+#include "MCAuto.hxx"
+#include "MEDFileMesh.hxx"
+#include "MEDCouplingUMesh.hxx"
#include "MeshTestToolkit.txx"
#include "Log.hxx"
#include "VectorUtils.hxx"
-#include "TestInterpKernelUtils.hxx"
-#include "MEDCouplingNormalizedUnstructuredMesh.hxx"
+#include "MEDCouplingNormalizedUnstructuredMesh.txx"
#include <cassert>
#include <string>
+#include <utility>
/**
* Test program which takes two meshes and calculates their intersection matrix.
// Author : Anthony Geay (CEA/DEN)
#include "QuadraticPlanarInterpTest.hxx"
+#include "InterpKernelGeo2DPrecision.hxx"
#include "InterpKernelGeo2DQuadraticPolygon.hxx"
#include "InterpKernelGeo2DEdgeArcCircle.hxx"
#include "InterpKernelGeo2DElementaryEdge.hxx"
#include "InterpKernelGeo2DEdgeLin.hxx"
#include "TestInterpKernelUtils.hxx"
+#include <cppunit/TestAssert.h>
+#include <math.h>
#include <sstream>
-#include <iostream>
using namespace INTERP_KERNEL;
{
//Testing bounds calculation. For Seg2
std::istringstream stream("2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2\n3200 3400 4500 4700");
- EdgeLin *e1=new EdgeLin(stream);
+ auto *e1=new EdgeLin(stream);
Bounds bound=e1->getBounds();
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.32,bound[0],ADMISSIBLE_ERROR);
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.45,bound[1],ADMISSIBLE_ERROR);
void QuadraticPlanarInterpTest::ReadWriteInXfigGlobal()
{
- QuadraticPolygon pol1(INTERP_TEST::getResourceFile("Pol1.fig").c_str());
+ QuadraticPolygon const pol1(INTERP_TEST::getResourceFile("Pol1.fig").c_str());
pol1.dumpInXfigFile("Pol1_gen.fig");
- QuadraticPolygon pol2(INTERP_TEST::getResourceFile("Pol2.fig").c_str());
+ QuadraticPolygon const pol2(INTERP_TEST::getResourceFile("Pol2.fig").c_str());
pol2.dumpInXfigFile("Pol2_gen.fig");
- QuadraticPolygon pol3(INTERP_TEST::getResourceFile("Pol3.fig").c_str());
+ QuadraticPolygon const pol3(INTERP_TEST::getResourceFile("Pol3.fig").c_str());
pol3.dumpInXfigFile("Pol3_gen.fig");
- QuadraticPolygon pol4(INTERP_TEST::getResourceFile("Pol4.fig").c_str());
+ QuadraticPolygon const pol4(INTERP_TEST::getResourceFile("Pol4.fig").c_str());
CPPUNIT_ASSERT_EQUAL(1,pol4.size());
- ElementaryEdge *edge1=dynamic_cast<ElementaryEdge *>(pol4[0]);
+ auto *edge1=dynamic_cast<ElementaryEdge *>(pol4[0]);
CPPUNIT_ASSERT(edge1);
Edge *edge2=edge1->getPtr();
- EdgeArcCircle *edge=dynamic_cast<EdgeArcCircle *>(edge2);
+ auto *edge=dynamic_cast<EdgeArcCircle *>(edge2);
CPPUNIT_ASSERT(edge);
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.24375,edge->getRadius(),ADMISSIBLE_ERROR);
CPPUNIT_ASSERT_DOUBLES_EQUAL(5.7857653289925404,edge->getAngle(),ADMISSIBLE_ERROR);
CPPUNIT_ASSERT_DOUBLES_EQUAL(-0.49741997818704586,edge->getAngle(),ADMISSIBLE_ERROR);//5.7857653289925404 + 2*PI
n1->decrRef();
//A half circle.
- EdgeArcCircle *e=new EdgeArcCircle(0.84,0.54,0.78,0.6,0.84,0.66);
+ auto *e=new EdgeArcCircle(0.84,0.54,0.78,0.6,0.84,0.66);
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.06,e->getRadius(),ADMISSIBLE_ERROR);
CPPUNIT_ASSERT_DOUBLES_EQUAL(-3.1415925921507317,e->getAngle(),1e-5);
e->decrRef();
{
Node *n1=new Node(1.,1.);
Node *n2=new Node(4.,2.);
- EdgeLin *e1=new EdgeLin(n1,n2);
+ auto *e1=new EdgeLin(n1,n2);
double tmp[2];
e1->getNormalVector(tmp);
CPPUNIT_ASSERT_DOUBLES_EQUAL(-0.94868329805051377,tmp[1],ADMISSIBLE_ERROR);
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.0158113883008418,e1->getDistanceToPoint(tmp),1e-12);
tmp[0]=0.; tmp[1]=5.;
CPPUNIT_ASSERT_DOUBLES_EQUAL(1.,e1->getDistanceToPoint(tmp),1e-12);
- EdgeArcCircle *e=new EdgeArcCircle(4.,3.,0.,5.,-5.,0.);
+ auto *e=new EdgeArcCircle(4.,3.,0.,5.,-5.,0.);
tmp[0]=-4.; tmp[1]=3.;
CPPUNIT_ASSERT(e->isNodeLyingOn(tmp));
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,e->getDistanceToPoint(tmp),1e-12);
{
//Testing intersection of Bounds.
std::istringstream stream1("2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2\n3200 3400 4500 4800");
- EdgeLin *e1=new EdgeLin(stream1);
+ auto *e1=new EdgeLin(stream1);
std::istringstream stream2("2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2\n3200 3400 4500 4800");
- EdgeLin *e2=new EdgeLin(stream2);
+ auto *e2=new EdgeLin(stream2);
Bounds *bound=e1->getBounds().amIIntersectingWith(e2->getBounds()); CPPUNIT_ASSERT(bound);
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.32,(*bound)[0],ADMISSIBLE_ERROR);
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.45,(*bound)[1],ADMISSIBLE_ERROR);
e2->decrRef(); e1->decrRef();
//
std::istringstream stream3("2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2\n3000 7200 6000 3700");
- EdgeLin *e3=new EdgeLin(stream3);
+ auto *e3=new EdgeLin(stream3);
std::istringstream stream4("2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2\n4800 6600 7200 4200");
- EdgeLin *e4=new EdgeLin(stream4);
+ auto *e4=new EdgeLin(stream4);
bound=e3->getBounds().amIIntersectingWith(e4->getBounds()); CPPUNIT_ASSERT(bound);
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.48,(*bound)[0],ADMISSIBLE_ERROR);
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.6,(*bound)[1],ADMISSIBLE_ERROR);
void QuadraticPlanarInterpTest::EdgeLinUnitary()
{
- EdgeLin *e1=new EdgeLin(0.5,0.5,3.7,4.1);
+ auto *e1=new EdgeLin(0.5,0.5,3.7,4.1);
Node *n=new Node(2.1,2.3);
CPPUNIT_ASSERT_DOUBLES_EQUAL(e1->getCharactValue(*n),0.5,1e-8);
n->decrRef();
v1.clear(); v2.clear(); v3.clear();
//Test 3bis - INSIDE - INSIDE - Bis | opp dir.
double center[2]={0.,0.};
- double radius=1.;
+ double const radius=1.;
e1=buildArcOfCircle(center,radius,-M_PI,0); e2=buildArcOfCircle(center,radius,-2*M_PI/3.+2*M_PI,-M_PI/3.);
CPPUNIT_ASSERT_DOUBLES_EQUAL(M_PI,e1->getCurveLength(),1e-12); CPPUNIT_ASSERT_DOUBLES_EQUAL(5.*M_PI/3.,e2->getCurveLength(),1e-12);// To check that in the previous line +2.M_PI has done its job.
CPPUNIT_ASSERT(e1->intersectWith(e2,v3,v1,v2));
void QuadraticPlanarInterpTest::IntersectionPointOnlyUnitarySegSeg()
{
// 0deg - classical
- EdgeLin *e1=new EdgeLin(0.,0.,1.,0.);
- EdgeLin *e2=new EdgeLin(0.3,0.3,0.5,-0.3);
+ auto *e1=new EdgeLin(0.,0.,1.,0.);
+ auto *e2=new EdgeLin(0.3,0.3,0.5,-0.3);
ComposedEdge& v1=*(new ComposedEdge);
ComposedEdge& v2=*(new ComposedEdge); MergePoints v3;
CPPUNIT_ASSERT(e1->intersectWith(e2,v3,v1,v2));
#ifndef _QUADRATICPLANARINTERPTEST_HXX_
#define _QUADRATICPLANARINTERPTEST_HXX_
+#include <cppunit/TestFixture.h>
#include <cppunit/extensions/HelperMacros.h>
+#include "InterpKernelGeo2DNode.hxx"
#include "InterpKernelTestExport.hxx"
#include "InterpKernelGeo2DEdgeArcCircle.hxx"
#include "InterpKernelGeo2DQuadraticPolygon.hxx"
//
// Author : Anthony Geay (CEA/DEN)
+#include "InterpKernelGeo2DEdge.hxx"
+#include "InterpKernelGeo2DNode.hxx"
+#include "InterpKernelGeo2DPrecision.hxx"
#include "QuadraticPlanarInterpTest.hxx"
#include "InterpKernelGeo2DQuadraticPolygon.hxx"
#include "InterpKernelGeo2DEdgeArcCircle.hxx"
#include "InterpKernelGeo2DEdgeLin.hxx"
#include <cmath>
-#include <sstream>
-#include <iostream>
+#include <math.h>
+#include <cppunit/TestAssert.h>
+#include <vector>
using namespace INTERP_KERNEL;
void QuadraticPlanarInterpTest::IntersectArcCircleBase()
{
double center[2]={0.5,0.5};
- double radius=0.3;
+ double const radius=0.3;
EdgeArcCircle *e1=buildArcOfCircle(center,radius,M_PI/4.,M_PI/3.);
CPPUNIT_ASSERT_DOUBLES_EQUAL(e1->getBounds()[0],center[0]+radius*cos(M_PI/3),ADMISSIBLE_ERROR);
CPPUNIT_ASSERT_DOUBLES_EQUAL(e1->getBounds()[1],center[0]+radius*cos(M_PI/4),ADMISSIBLE_ERROR);
std::vector<Node *> v4;
MergePoints v3;
EdgeArcCircle *e2;
- ArcCArcCIntersector *intersector=0;
+ ArcCArcCIntersector *intersector=nullptr;
for(unsigned k=0;k<8;k++)
{
e1=buildArcOfCircle(center,radius,M_PI/4.+k*M_PI/4.,M_PI/3.+k*M_PI/4.);
CPPUNIT_ASSERT_DOUBLES_EQUAL(e2->getRadius(),Node::distanceBtw2Pt(e2->getCenter(),(*(v4[1]))),ADMISSIBLE_ERROR);
CPPUNIT_ASSERT(!v4[0]->isEqual(*v4[1]));
CPPUNIT_ASSERT_DOUBLES_EQUAL(btw2NodesAndACenter(*v4[0],*v4[1],e1->getCenter()),0.35587863972199624,1e-10);
- for(std::vector<Node *>::iterator iter=v4.begin();iter!=v4.end();iter++)
- (*iter)->decrRef();
+ for(auto & iter : v4)
+ iter->decrRef();
v4.clear(); v3.clear();
delete intersector; e2->decrRef(); e1->decrRef();
}
CPPUNIT_ASSERT_DOUBLES_EQUAL(e2->getRadius(),Node::distanceBtw2Pt(e2->getCenter(),(*(v4[1]))),ADMISSIBLE_ERROR);
CPPUNIT_ASSERT(!v4[0]->isEqual(*v4[1]));
CPPUNIT_ASSERT_DOUBLES_EQUAL(btw2NodesAndACenter(*v4[0],*v4[1],e1->getCenter()),0.35587863972199624,1e-10);
- for(std::vector<Node *>::iterator iter=v4.begin();iter!=v4.end();iter++)
- (*iter)->decrRef();
+ for(auto & iter : v4)
+ iter->decrRef();
v4.clear(); v3.clear();
delete intersector; e2->decrRef(); e1->decrRef();
}
CPPUNIT_ASSERT_DOUBLES_EQUAL(e2->getRadius(),Node::distanceBtw2Pt(e2->getCenter(),(*(v4[1]))),ADMISSIBLE_ERROR);
CPPUNIT_ASSERT(!v4[0]->isEqual(*v4[1]));
CPPUNIT_ASSERT_DOUBLES_EQUAL(btw2NodesAndACenter(*v4[0],*v4[1],e1->getCenter()),0.6793851523346941,1e-10);
- for(std::vector<Node *>::iterator iter=v4.begin();iter!=v4.end();iter++)
- (*iter)->decrRef();
+ for(auto & iter : v4)
+ iter->decrRef();
v4.clear(); v3.clear();
delete intersector; e2->decrRef(); e1->decrRef();
}
CPPUNIT_ASSERT_DOUBLES_EQUAL(e2->getRadius(),Node::distanceBtw2Pt(e2->getCenter(),(*(v4[1]))),ADMISSIBLE_ERROR);
CPPUNIT_ASSERT(!v4[0]->isEqual(*v4[1]));
CPPUNIT_ASSERT_DOUBLES_EQUAL(btw2NodesAndACenter(*v4[0],*v4[1],e1->getCenter()),0.6793851523346941,1e-10);
- for(std::vector<Node *>::iterator iter=v4.begin();iter!=v4.end();iter++)
- (*iter)->decrRef();
+ for(auto & iter : v4)
+ iter->decrRef();
v4.clear(); v3.clear();
delete intersector; e2->decrRef(); e1->decrRef();
}
CPPUNIT_ASSERT_DOUBLES_EQUAL(e2->getRadius(),Node::distanceBtw2Pt(e2->getCenter(),(*(v4[1]))),ADMISSIBLE_ERROR);
CPPUNIT_ASSERT(!v4[0]->isEqual(*v4[1]));
CPPUNIT_ASSERT_DOUBLES_EQUAL(1.1195732971845034,btw2NodesAndACenter(*v4[0],*v4[1],e1->getCenter()),1e-10);
- for(std::vector<Node *>::iterator iter=v4.begin();iter!=v4.end();iter++)
- (*iter)->decrRef();
+ for(auto & iter : v4)
+ iter->decrRef();
v4.clear(); v3.clear();
delete intersector; e2->decrRef(); e1->decrRef();
}
CPPUNIT_ASSERT_DOUBLES_EQUAL(e2->getRadius(),Node::distanceBtw2Pt(e2->getCenter(),(*(v4[1]))),ADMISSIBLE_ERROR);
CPPUNIT_ASSERT(!v4[0]->isEqual(*v4[1]));
CPPUNIT_ASSERT_DOUBLES_EQUAL(-1.1195732971845034,btw2NodesAndACenter(*v4[0],*v4[1],e1->getCenter()),1e-10);
- for(std::vector<Node *>::iterator iter=v4.begin();iter!=v4.end();iter++)
- (*iter)->decrRef();
+ for(auto & iter : v4)
+ iter->decrRef();
v4.clear(); v3.clear();
delete intersector; e2->decrRef(); e1->decrRef();
}
CPPUNIT_ASSERT_DOUBLES_EQUAL(e2->getRadius(),Node::distanceBtw2Pt(e2->getCenter(),(*(v4[1]))),ADMISSIBLE_ERROR);
CPPUNIT_ASSERT(!v4[0]->isEqual(*v4[1]));
CPPUNIT_ASSERT_DOUBLES_EQUAL(-3.0844420190512074,btw2NodesAndACenter(*v4[0],*v4[1],e1->getCenter()),1e-10);
- for(std::vector<Node *>::iterator iter=v4.begin();iter!=v4.end();iter++)
- (*iter)->decrRef();
+ for(auto & iter : v4)
+ iter->decrRef();
v4.clear(); v3.clear();
delete intersector; e2->decrRef(); e1->decrRef();
}
CPPUNIT_ASSERT_DOUBLES_EQUAL(e2->getRadius(),Node::distanceBtw2Pt(e2->getCenter(),(*(v4[1]))),ADMISSIBLE_ERROR);
CPPUNIT_ASSERT(!v4[0]->isEqual(*v4[1]));
CPPUNIT_ASSERT_DOUBLES_EQUAL(-3.0844420190512074,btw2NodesAndACenter(*v4[0],*v4[1],e1->getCenter()),1e-10);
- for(std::vector<Node *>::iterator iter=v4.begin();iter!=v4.end();iter++)
- (*iter)->decrRef();
+ for(auto & iter : v4)
+ iter->decrRef();
v4.clear(); v3.clear();
delete intersector; e2->decrRef(); e1->decrRef();
}
CPPUNIT_ASSERT_EQUAL(1,(int)v4.size()); CPPUNIT_ASSERT_EQUAL(0,(int)v3.getNumberOfAssociations());
CPPUNIT_ASSERT_DOUBLES_EQUAL(e1->getRadius(),Node::distanceBtw2Pt(e1->getCenter(),(*(v4[0]))),ADMISSIBLE_ERROR);
CPPUNIT_ASSERT_DOUBLES_EQUAL(e2->getRadius(),Node::distanceBtw2Pt(e2->getCenter(),(*(v4[0]))),ADMISSIBLE_ERROR);
- for(std::vector<Node *>::iterator iter=v4.begin();iter!=v4.end();iter++)
- (*iter)->decrRef();
+ for(auto & iter : v4)
+ iter->decrRef();
v4.clear(); v4.clear();
delete intersector; e2->decrRef(); e1->decrRef();
}
void QuadraticPlanarInterpTest::IntersectArcCircleFull()
{
- double center1[2]; center1[0]=0.; center1[1]=0.; double radius1=3.;
+ double center1[2]; center1[0]=0.; center1[1]=0.; double const radius1=3.;
double center2[2]; center2[0]=0.75; center2[1]=-2.6; double radius2=1.;
EdgeArcCircle *e1=buildArcOfCircle(center1,radius1,-M_PI/3.,4.*M_PI/3.);
EdgeArcCircle *e2=buildArcOfCircle(center2,radius2,0.,M_PI/2.);
{
double center[2]={2.,2.};
EdgeArcCircle *e1=buildArcOfCircle(center,2.3,M_PI/4.,5.*M_PI/4.);
- EdgeLin *e2=new EdgeLin(-1.3,1.,3.,5.3);
+ auto *e2=new EdgeLin(-1.3,1.,3.,5.3);
EdgeIntersector *intersector=new ArcCSegIntersector(*e1,*e2);
bool order;
bool obvious,areOverlapped;
EdgeArcCircle *QuadraticPlanarInterpTest::buildArcOfCircle(const double *center, double radius, double alphaStart, double alphaEnd)
{
- double alphaM=(alphaStart+alphaEnd)/2;
+ double const alphaM=(alphaStart+alphaEnd)/2;
return new EdgeArcCircle(center[0]+cos(alphaStart)*radius,center[1]+sin(alphaStart)*radius,
center[0]+cos(alphaM)*radius,center[1]+sin(alphaM)*radius,
center[0]+cos(alphaEnd)*radius,center[1]+sin(alphaEnd)*radius);
double tmp1[2],tmp2[2];
tmp1[0]=n1Pt[0]-center[0]; tmp1[1]=n1Pt[1]-center[1];
tmp2[0]=n2Pt[0]-center[0]; tmp2[1]=n2Pt[1]-center[1];
- double distTmp1=sqrt(tmp1[0]*tmp1[0]+tmp1[1]*tmp1[1]);
- double distTmp2=sqrt(tmp2[0]*tmp2[0]+tmp2[1]*tmp2[1]);
+ double const distTmp1=sqrt(tmp1[0]*tmp1[0]+tmp1[1]*tmp1[1]);
+ double const distTmp2=sqrt(tmp2[0]*tmp2[0]+tmp2[1]*tmp2[1]);
double ret=acos((tmp1[0]*tmp2[0]+tmp1[1]*tmp2[1])/(distTmp1*distTmp2));
if(tmp1[0]*tmp2[1]-tmp1[1]*tmp2[0]<0)
ret=-ret;
//
// Author : Anthony Geay (CEA/DEN)
+#include "InterpKernelGeo2DNode.hxx"
+#include "InterpKernelGeo2DComposedEdge.hxx"
+#include "InterpKernelGeo2DAbstractEdge.hxx"
+#include "InterpKernelGeo2DEdge.hxx"
#include "QuadraticPlanarInterpTest.hxx"
#include "InterpKernelGeo2DQuadraticPolygon.hxx"
#include "InterpKernelGeo2DElementaryEdge.hxx"
-#include "InterpKernelGeo2DEdgeArcCircle.hxx"
#include "InterpKernelGeo2DEdgeLin.hxx"
#include <cmath>
-#include <sstream>
-#include <iostream>
+#include <cppunit/TestAssert.h>
using namespace INTERP_KERNEL;
Node *n1=new Node(0.,0.);
Node *n2=new Node(1.,0.);
Node *n3=new Node(0.5,1.);
- EdgeLin *e1=new EdgeLin(n1,n2);
- EdgeLin *e2=new EdgeLin(n2,n3);
- EdgeLin *e3=new EdgeLin(n3,n1);
- ComposedEdge *tri=new ComposedEdge;
+ auto *e1=new EdgeLin(n1,n2);
+ auto *e2=new EdgeLin(n2,n3);
+ auto *e3=new EdgeLin(n3,n1);
+ auto *tri=new ComposedEdge;
tri->pushBack(e1); tri->pushBack(e2); tri->pushBack(e3);
//
Node *where=new Node(0.4,0.1);
void QuadraticPlanarInterpTest::checkAssemblingBases1()
{
Node *n1=new Node(0.,0.);
- Node *n2=new Node(0.1,0.); EdgeLin *e1_2=new EdgeLin(n1,n2);
- Node *n3=new Node(0.2,0.); EdgeLin *e2_3=new EdgeLin(n2,n3);
- Node *n4=new Node(0.3,0.); EdgeLin *e3_4=new EdgeLin(n3,n4);
- Node *n5=new Node(0.4,0.); EdgeLin *e4_5=new EdgeLin(n4,n5);
- Node *n6=new Node(0.5,0.); EdgeLin *e5_6=new EdgeLin(n5,n6);
- Node *n7=new Node(0.6,0.); EdgeLin *e6_7=new EdgeLin(n6,n7);
- Node *n8=new Node(0.7,0.); EdgeLin *e7_8=new EdgeLin(n7,n8);
- Node *n9=new Node(0.8,0.); EdgeLin *e8_9=new EdgeLin(n8,n9);
- Node *n10=new Node(0.9,0.); EdgeLin *e9_10=new EdgeLin(n9,n10);
- Node *n11=new Node(1.,0.); EdgeLin *e10_11=new EdgeLin(n10,n11);
- Node *n12=new Node(0.5,1.); EdgeLin *e11_12=new EdgeLin(n11,n12);
- EdgeLin *e12_1=new EdgeLin(n12,n1);
+ Node *n2=new Node(0.1,0.); auto *e1_2=new EdgeLin(n1,n2);
+ Node *n3=new Node(0.2,0.); auto *e2_3=new EdgeLin(n2,n3);
+ Node *n4=new Node(0.3,0.); auto *e3_4=new EdgeLin(n3,n4);
+ Node *n5=new Node(0.4,0.); auto *e4_5=new EdgeLin(n4,n5);
+ Node *n6=new Node(0.5,0.); auto *e5_6=new EdgeLin(n5,n6);
+ Node *n7=new Node(0.6,0.); auto *e6_7=new EdgeLin(n6,n7);
+ Node *n8=new Node(0.7,0.); auto *e7_8=new EdgeLin(n7,n8);
+ Node *n9=new Node(0.8,0.); auto *e8_9=new EdgeLin(n8,n9);
+ Node *n10=new Node(0.9,0.); auto *e9_10=new EdgeLin(n9,n10);
+ Node *n11=new Node(1.,0.); auto *e10_11=new EdgeLin(n10,n11);
+ Node *n12=new Node(0.5,1.); auto *e11_12=new EdgeLin(n11,n12);
+ auto *e12_1=new EdgeLin(n12,n1);
//Only one level
e1_2->incrRef(); e2_3->incrRef(); e3_4->incrRef(); e4_5->incrRef(); e5_6->incrRef(); e6_7->incrRef();
e7_8->incrRef(); e8_9->incrRef(); e9_10->incrRef(); e10_11->incrRef(); e11_12->incrRef(); e12_1->incrRef();
- ComposedEdge *c=new ComposedEdge;
+ auto *c=new ComposedEdge;
c->pushBack(e1_2); c->pushBack(e2_3); c->pushBack(e3_4); c->pushBack(e4_5); c->pushBack(e5_6); c->pushBack(e6_7);
c->pushBack(e7_8); c->pushBack(e8_9); c->pushBack(e9_10); c->pushBack(e10_11); c->pushBack(e11_12); c->pushBack(e12_1);
CPPUNIT_ASSERT_EQUAL(12,c->recursiveSize());
//(e1_2, (e2_3,(e3_4, e4_5, e5_6, e6_7, (e7_8, e8_9 ), ( e9_10 , e10_11 ), e11_12 ),e12_1 ) )
e1_2->incrRef(); e2_3->incrRef(); e3_4->incrRef(); e4_5->incrRef(); e5_6->incrRef(); e6_7->incrRef();
e7_8->incrRef(); e8_9->incrRef(); e9_10->incrRef(); e10_11->incrRef(); e11_12->incrRef(); e12_1->incrRef();
- ComposedEdge *c2_2_4=new ComposedEdge; c2_2_4->pushBack(e7_8); c2_2_4->pushBack(e8_9);
- ComposedEdge *c2_2_5=new ComposedEdge; c2_2_5->pushBack(e9_10); c2_2_5->pushBack(e10_11);
- ComposedEdge *c2_2=new ComposedEdge; c2_2->pushBack(e3_4); c2_2->pushBack(e4_5); c2_2->pushBack(e5_6); c2_2->pushBack(e6_7); c2_2->pushBack(c2_2_4); c2_2->pushBack(c2_2_5); c2_2->pushBack(e11_12);
- ComposedEdge *c2=new ComposedEdge; c2->pushBack(e2_3); c2->pushBack(c2_2); c2->pushBack(e12_1);
+ auto *c2_2_4=new ComposedEdge; c2_2_4->pushBack(e7_8); c2_2_4->pushBack(e8_9);
+ auto *c2_2_5=new ComposedEdge; c2_2_5->pushBack(e9_10); c2_2_5->pushBack(e10_11);
+ auto *c2_2=new ComposedEdge; c2_2->pushBack(e3_4); c2_2->pushBack(e4_5); c2_2->pushBack(e5_6); c2_2->pushBack(e6_7); c2_2->pushBack(c2_2_4); c2_2->pushBack(c2_2_5); c2_2->pushBack(e11_12);
+ auto *c2=new ComposedEdge; c2->pushBack(e2_3); c2->pushBack(c2_2); c2->pushBack(e12_1);
c=new ComposedEdge; c->pushBack(e1_2); c->pushBack(c2); CPPUNIT_ASSERT_EQUAL(12,c->recursiveSize());
IteratorOnComposedEdge it2(c);
CPPUNIT_ASSERT(it2.current()->getPtr()==e1_2);
Node *n1=new Node(0.,0.); Node *n4=new Node(0.,-0.3);
Node *n2=new Node(1.,0.); Node *n5=new Node(1.,-0.3);
Node *n3=new Node(0.5,1.); Node *n6=new Node(0.5,0.7);
- EdgeLin *e1_2=new EdgeLin(n1,n2); EdgeLin *e4_5=new EdgeLin(n4,n5);
- EdgeLin *e2_3=new EdgeLin(n2,n3); EdgeLin *e5_6=new EdgeLin(n5,n6);
- EdgeLin *e3_1=new EdgeLin(n3,n1); EdgeLin *e6_4=new EdgeLin(n6,n4);
+ auto *e1_2=new EdgeLin(n1,n2); auto *e4_5=new EdgeLin(n4,n5);
+ auto *e2_3=new EdgeLin(n2,n3); auto *e5_6=new EdgeLin(n5,n6);
+ auto *e3_1=new EdgeLin(n3,n1); auto *e6_4=new EdgeLin(n6,n4);
//
e1_2->incrRef(); e2_3->incrRef(); e3_1->incrRef(); e4_5->incrRef(); e5_6->incrRef(); e6_4->incrRef();
QuadraticPolygon pol1; pol1.pushBack(e1_2); pol1.pushBack(e2_3); pol1.pushBack(e3_1);
QuadraticPolygon pol2; pol2.pushBack(e4_5); pol2.pushBack(e5_6); pol2.pushBack(e6_4);
- QuadraticPolygon cpyPol1(pol1); int nbOfSplits=0;
+ QuadraticPolygon const cpyPol1(pol1); int nbOfSplits=0;
cpyPol1.SplitPolygonsEachOther(pol1,pol2,nbOfSplits);
CPPUNIT_ASSERT_EQUAL(5,pol1.recursiveSize());
CPPUNIT_ASSERT_EQUAL(5,pol2.recursiveSize());CPPUNIT_ASSERT_EQUAL(15,nbOfSplits);
CPPUNIT_ASSERT(pol2[3]->getEndNode()==pol1[0]->getEndNode());
CPPUNIT_ASSERT(pol2[3]->getEndNode()->getLoc()==ON_1);
cpyPol1.performLocatingOperation(pol2);
- ElementaryEdge *tmp=dynamic_cast<ElementaryEdge *>(pol2[0]); CPPUNIT_ASSERT(tmp); CPPUNIT_ASSERT(tmp->getPtr()==e4_5);
+ auto *tmp=dynamic_cast<ElementaryEdge *>(pol2[0]); CPPUNIT_ASSERT(tmp); CPPUNIT_ASSERT(tmp->getPtr()==e4_5);
CPPUNIT_ASSERT(tmp->getLoc()==FULL_OUT_1);
CPPUNIT_ASSERT(tmp->getLoc()==FULL_OUT_1);
tmp=dynamic_cast<ElementaryEdge *>(pol2[1]); CPPUNIT_ASSERT(tmp);
n2=new Node(1.,0.); n5=new Node(0.5,0.);
n3=new Node(0.5,1.); n6=new Node(0.75,0.5); Node *n7=new Node(2.,0.5);
e1_2=new EdgeLin(n1,n2); e2_3=new EdgeLin(n2,n3); e3_1=new EdgeLin(n3,n1);
- EdgeLin *e5_4=new EdgeLin(n5,n4); EdgeLin *e4_7=new EdgeLin(n4,n7); EdgeLin *e7_6=new EdgeLin(n7,n6); EdgeLin *e6_5=new EdgeLin(n6,n5);
+ auto *e5_4=new EdgeLin(n5,n4); auto *e4_7=new EdgeLin(n4,n7); auto *e7_6=new EdgeLin(n7,n6); auto *e6_5=new EdgeLin(n6,n5);
//
e1_2->incrRef(); e2_3->incrRef(); e3_1->incrRef(); e5_4->incrRef(); e4_7->incrRef(); e7_6->incrRef(); e6_5->incrRef();
QuadraticPolygon pol3; pol3.pushBack(e1_2); pol3.pushBack(e2_3); pol3.pushBack(e3_1);
QuadraticPolygon pol4; pol4.pushBack(e5_4); pol4.pushBack(e4_7); pol4.pushBack(e7_6); pol4.pushBack(e6_5);
- QuadraticPolygon cpyPol3(pol3); nbOfSplits=0;
+ QuadraticPolygon const cpyPol3(pol3); nbOfSplits=0;
cpyPol3.SplitPolygonsEachOther(pol3,pol4,nbOfSplits);
CPPUNIT_ASSERT_EQUAL(5,pol3.recursiveSize());
CPPUNIT_ASSERT_EQUAL(4,pol4.recursiveSize());CPPUNIT_ASSERT_EQUAL(16,nbOfSplits);
e1_2->incrRef(); e2_3->incrRef(); e3_1->incrRef(); e4_5->incrRef(); e5_6->incrRef(); e6_4->incrRef();
QuadraticPolygon pol5; pol5.pushBack(e1_2); pol5.pushBack(e2_3); pol5.pushBack(e3_1);
QuadraticPolygon pol6; pol6.pushBack(e4_5); pol6.pushBack(e5_6); pol6.pushBack(e6_4);
- QuadraticPolygon cpyPol5(pol5); nbOfSplits=0;
+ QuadraticPolygon const cpyPol5(pol5); nbOfSplits=0;
cpyPol5.SplitPolygonsEachOther(pol5,pol6,nbOfSplits);
CPPUNIT_ASSERT_EQUAL(4,pol5.recursiveSize());
CPPUNIT_ASSERT_EQUAL(4,pol6.recursiveSize()); CPPUNIT_ASSERT_EQUAL(13,nbOfSplits);
e1_2->incrRef(); e2_3->incrRef(); e3_1->incrRef(); e4_5->incrRef(); e5_6->incrRef(); e6_4->incrRef();
QuadraticPolygon pol7; pol7.pushBack(e1_2); pol7.pushBack(e2_3); pol7.pushBack(e3_1);
QuadraticPolygon pol8; pol8.pushBack(e4_5); pol8.pushBack(e5_6); pol8.pushBack(e6_4);
- QuadraticPolygon cpyPol7(pol7); nbOfSplits=0;
+ QuadraticPolygon const cpyPol7(pol7); nbOfSplits=0;
cpyPol7.SplitPolygonsEachOther(pol7,pol8,nbOfSplits);
tmp=dynamic_cast<ElementaryEdge *>(pol8[0]); CPPUNIT_ASSERT(tmp); CPPUNIT_ASSERT(tmp->getPtr()==e1_2);
CPPUNIT_ASSERT(tmp->getLoc()==FULL_ON_1);
//
// Author : Anthony Geay (CEA/DEN)
+#include "InterpKernelGeo2DNode.hxx"
+#include "InterpKernelGeo2DPrecision.hxx"
+#include "InterpKernelGeo2DBounds.hxx"
#include "QuadraticPlanarInterpTest.hxx"
#include "InterpKernelGeo2DQuadraticPolygon.hxx"
#include "InterpKernelGeo2DElementaryEdge.hxx"
#include "InterpKernelGeo2DEdgeArcCircle.hxx"
#include "InterpKernelGeo2DEdgeLin.hxx"
+#include <algorithm>
#include <cmath>
-#include <sstream>
-#include <iostream>
-#include <iterator>
+#include <cppunit/TestAssert.h>
+#include <math.h>
+#include <map>
+#include <vector>
using namespace INTERP_KERNEL;
Node *n1=new Node(0.,0.); Node *n4=new Node(0.,-0.3);
Node *n2=new Node(1.,0.); Node *n5=new Node(1.,-0.3);
Node *n3=new Node(0.5,1.); Node *n6=new Node(0.5,0.7);
- EdgeLin *e1_2=new EdgeLin(n1,n2); EdgeLin *e4_5=new EdgeLin(n4,n5);
- EdgeLin *e2_3=new EdgeLin(n2,n3); EdgeLin *e5_6=new EdgeLin(n5,n6);
- EdgeLin *e3_1=new EdgeLin(n3,n1); EdgeLin *e6_4=new EdgeLin(n6,n4);
+ auto *e1_2=new EdgeLin(n1,n2); auto *e4_5=new EdgeLin(n4,n5);
+ auto *e2_3=new EdgeLin(n2,n3); auto *e5_6=new EdgeLin(n5,n6);
+ auto *e3_1=new EdgeLin(n3,n1); auto *e6_4=new EdgeLin(n6,n4);
//
std::vector<QuadraticPolygon *> result;
for(int k=0;k<2;k++)
n2=new Node(1.,0.); n5=new Node(0.5,0.);
n3=new Node(0.5,1.); n6=new Node(0.75,0.5); Node *n7=new Node(2.,0.5);
e1_2=new EdgeLin(n1,n2); e2_3=new EdgeLin(n2,n3); e3_1=new EdgeLin(n3,n1);
- EdgeLin *e5_4=new EdgeLin(n5,n4); EdgeLin *e4_7=new EdgeLin(n4,n7); EdgeLin *e7_6=new EdgeLin(n7,n6); EdgeLin *e6_5=new EdgeLin(n6,n5);
+ auto *e5_4=new EdgeLin(n5,n4); auto *e4_7=new EdgeLin(n4,n7); auto *e7_6=new EdgeLin(n7,n6); auto *e6_5=new EdgeLin(n6,n5);
//
for(int k=0;k<2;k++)
for(int i=0;i<3;i++)
QuadraticPolygon *pol=QuadraticPolygon::BuildArcCirclePolygon(nodes);
CPPUNIT_ASSERT_DOUBLES_EQUAL(-1.04719755,pol->getArea(),1e-5);
CPPUNIT_ASSERT_EQUAL(3,pol->size());
- ElementaryEdge *e0=dynamic_cast<ElementaryEdge *>((*pol)[0]);
- ElementaryEdge *e1=dynamic_cast<ElementaryEdge *>((*pol)[1]);
- ElementaryEdge *e2=dynamic_cast<ElementaryEdge *>((*pol)[0]);
+ auto *e0=dynamic_cast<ElementaryEdge *>((*pol)[0]);
+ auto *e1=dynamic_cast<ElementaryEdge *>((*pol)[1]);
+ auto *e2=dynamic_cast<ElementaryEdge *>((*pol)[0]);
CPPUNIT_ASSERT(e0); CPPUNIT_ASSERT(e1); CPPUNIT_ASSERT(e2);
CPPUNIT_ASSERT(dynamic_cast<EdgeLin *>(e0->getPtr()));// <- testing detection of colinearity
CPPUNIT_ASSERT(dynamic_cast<EdgeArcCircle *>(e1->getPtr()));
0.1000 , 0.1500 , 0.2000 , 0.2500, 0.3000, 0.3500, 0.4000, 0.4500, 0.5000, 0.5500,
0.6000, 0.6500, 0.7000, 0.7194, 0.7388, 0.7581, 0.7775, 0.7969, 0.8163, 0.8356,
0.8550};
- std::vector<double> zLev1(Z_VALS_1,Z_VALS_1+NB_OF_CELL_AXIAL_1+1);
+ std::vector<double> const zLev1(Z_VALS_1,Z_VALS_1+NB_OF_CELL_AXIAL_1+1);
const int NB_OF_CELL_AXIAL_2=46;
static const double Z_VALS_2[NB_OF_CELL_AXIAL_2+1]=
, 0.20, 0.25, 0.30, 0.350 ,0.40 ,0.450 ,0.500 , 0.550, 0.600 ,0.650 ,0.700
, 0.7194 ,0.7388 ,0.7581 ,0.7775 ,0.7969 ,0.8163 ,0.8356, 0.8550
, 0.8738 ,0.8925 ,0.9113 ,0.9300 ,0.9488 ,0.9675 ,0.9863, 1.0050};
- std::vector<double> zLev2(Z_VALS_2,Z_VALS_2+NB_OF_CELL_AXIAL_2+1);
+ std::vector<double> const zLev2(Z_VALS_2,Z_VALS_2+NB_OF_CELL_AXIAL_2+1);
std::map<int,std::map<int,double> > m;
Edge::Interpolate1DLin(zLev1,zLev2,m);
CPPUNIT_ASSERT_EQUAL(30,(int)m.size());
static const double Z_VALS_3[NB_OF_CELL_AXIAL_3+1]={
0.,0.01,0.05,0.10,0.15,0.20,0.25,0.30,
0.35,0.40,0.45,0.50,0.55,0.60 };
- std::vector<double> zLev3(Z_VALS_3,Z_VALS_3+NB_OF_CELL_AXIAL_3+1);
+ std::vector<double> const zLev3(Z_VALS_3,Z_VALS_3+NB_OF_CELL_AXIAL_3+1);
Edge::Interpolate1DLin(zLev3,zLev1,m);
CPPUNIT_ASSERT_EQUAL(13,(int)m.size());
CPPUNIT_ASSERT_DOUBLES_EQUAL(1.,m[0][8],1e-12);
const double radius1=2.902;
const double angleS1=-0.49999999950907054; const double angleL1=-0.0942156629996692;
const double center1[2]={13.66, -23.66};
- EdgeArcCircle *e1=new EdgeArcCircle(nS1,nE1,center1,radius1,angleS1,angleL1);
+ auto *e1=new EdgeArcCircle(nS1,nE1,center1,radius1,angleS1,angleL1);
//
const double coords2[]=
{
const double radius2=2.4345;
const double angleS2=-0.523598776190207; const double angleL2=0.5235987755846041;
const double center2[]={ 13.933240960547204, -24.132999998525658 };
- EdgeArcCircle *e2=new EdgeArcCircle(nS2,nE2,center2,radius2,angleS2,angleL2);
+ auto *e2=new EdgeArcCircle(nS2,nE2,center2,radius2,angleS2,angleL2);
MergePoints merge;
QuadraticPolygon c1,c2;
e1->intersectWith(e2,merge,c1,c2);
const double radius1=3.4304999897666599;
const double angleS1=2.6179938783536514; const double angleL1=-0.52359877711901204;
const double center1[2]={13.933240950441375, -24.132999992807399};
- EdgeArcCircle *e1=new EdgeArcCircle(nS1,nE1,center1,radius1,angleS1,angleL1);
+ auto *e1=new EdgeArcCircle(nS1,nE1,center1,radius1,angleS1,angleL1);
//
const double coords2[]=
{
};
Node *nS2=new Node(coords2);
Node *nE2=new Node(coords2+2);
- EdgeLin *e2=new EdgeLin(nS2,nE2);
+ auto *e2=new EdgeLin(nS2,nE2);
MergePoints merge;
QuadraticPolygon c1,c2;
CPPUNIT_ASSERT(e1->intersectWith(e2,merge,c1,c2));
CPPUNIT_ASSERT_EQUAL(2,c1.size());
CPPUNIT_ASSERT_EQUAL(2,c2.size());
- ElementaryEdge *tmp1=dynamic_cast<ElementaryEdge *>(c1.front()); CPPUNIT_ASSERT(tmp1);
- EdgeArcCircle *tmp2=dynamic_cast<EdgeArcCircle *>(tmp1->getPtr()); CPPUNIT_ASSERT(tmp2);
+ auto *tmp1=dynamic_cast<ElementaryEdge *>(c1.front()); CPPUNIT_ASSERT(tmp1);
+ auto *tmp2=dynamic_cast<EdgeArcCircle *>(tmp1->getPtr()); CPPUNIT_ASSERT(tmp2);
CPPUNIT_ASSERT_DOUBLES_EQUAL(2.6179938783536514,tmp2->getAngle0(),1e-14);
//clean-up
nS1->decrRef(); nE1->decrRef(); nS2->decrRef(); nE2->decrRef(); e1->decrRef(); e2->decrRef();
nodes2.push_back(new Node(coords2+12));
nodes2.push_back(new Node(coords2+14));
QuadraticPolygon *pol2=QuadraticPolygon::BuildArcCirclePolygon(nodes2);
- std::vector<QuadraticPolygon *> v=pol1->intersectMySelfWith(*pol2);
+ std::vector<QuadraticPolygon *> const v=pol1->intersectMySelfWith(*pol2);
CPPUNIT_ASSERT_EQUAL(0,(int)v.size());
//CPPUNIT_ASSERT_DOUBLES_EQUAL(0.00164773941455998,v[0]->getArea(),1e-7);
//delete v[0];
nodes2.push_back(new Node(coords2+12));
nodes2.push_back(new Node(coords2+14));
QuadraticPolygon *pol2=QuadraticPolygon::BuildArcCirclePolygon(nodes2);
- std::vector<QuadraticPolygon *> v=pol1->intersectMySelfWith(*pol2);
+ std::vector<QuadraticPolygon *> const v=pol1->intersectMySelfWith(*pol2);
CPPUNIT_ASSERT_EQUAL(0,(int)v.size());
delete pol1;
delete pol2;
Node *n3_1=new Node(coords1+4);
Node *n1_2=new Node(coords2);
Node *n2_2=new Node(coords2+2);
- EdgeArcCircle *e1=new EdgeArcCircle(n1_1,n3_1,n2_1);
- EdgeLin *e2=new EdgeLin(n1_2,n2_2);
+ auto *e1=new EdgeArcCircle(n1_1,n3_1,n2_1);
+ auto *e2=new EdgeLin(n1_2,n2_2);
MergePoints merge;
- ComposedEdge *c1=new ComposedEdge;
- ComposedEdge *c2=new ComposedEdge;
+ auto *c1=new ComposedEdge;
+ auto *c2=new ComposedEdge;
CPPUNIT_ASSERT(e1->intersectWith(e2,merge,*c1,*c2));
CPPUNIT_ASSERT_EQUAL(2,c1->size());
CPPUNIT_ASSERT_EQUAL(2,c2->size());
Node *n1=new Node(0.,0.); Node *n4=new Node(0.,-3.);
Node *n2=new Node(10.,0.); Node *n5=new Node(10.,-3.);
Node *n3=new Node(5.,10.); Node *n6=new Node(5.,7.);
- EdgeLin *e1_2=new EdgeLin(n1,n2); EdgeLin *e4_5=new EdgeLin(n4,n5);
- EdgeLin *e2_3=new EdgeLin(n2,n3); EdgeLin *e5_6=new EdgeLin(n5,n6);
- EdgeLin *e3_1=new EdgeLin(n3,n1); EdgeLin *e6_4=new EdgeLin(n6,n4);
+ auto *e1_2=new EdgeLin(n1,n2); auto *e4_5=new EdgeLin(n4,n5);
+ auto *e2_3=new EdgeLin(n2,n3); auto *e5_6=new EdgeLin(n5,n6);
+ auto *e3_1=new EdgeLin(n3,n1); auto *e6_4=new EdgeLin(n6,n4);
//
QuadraticPolygon pol1; pol1.pushBack(e1_2); pol1.pushBack(e2_3); pol1.pushBack(e3_1);
QuadraticPolygon pol2; pol2.pushBack(e4_5); pol2.pushBack(e5_6); pol2.pushBack(e6_4);
n1->decrRef(); n2->decrRef(); n3->decrRef(); n4->decrRef(); n5->decrRef(); n6->decrRef();
- double area1Start=pol1.getArea();
+ double const area1Start=pol1.getArea();
double xb,yb;
- double fact=pol1.normalize(&pol2,xb,yb);
- double area1End=pol1.getArea();
+ double const fact=pol1.normalize(&pol2,xb,yb);
+ double const area1End=pol1.getArea();
CPPUNIT_ASSERT_DOUBLES_EQUAL(area1Start,area1End*fact*fact,1e-14);
CPPUNIT_ASSERT_DOUBLES_EQUAL(13.,fact,1.e-14);
- double area=pol1.intersectWith(pol2);
+ double const area=pol1.intersectWith(pol2);
CPPUNIT_ASSERT_DOUBLES_EQUAL(24.5,area*fact*fact,1e-14);
//
n1=new Node(0.,0.); n4=new Node(0.,-3.);
CPPUNIT_ASSERT_DOUBLES_EQUAL(24.5,pol3.intersectWithAbs(pol4),1.e-14);
// Ok testing EdgeArcCircle update.
double center[2]={5.,5.};
- double radius=300.;
+ double const radius=300.;
EdgeArcCircle *e1=buildArcOfCircle(center,radius,M_PI/4.,M_PI/3.);
const Bounds& b=e1->getBounds();
double x,y,fact2;
Node *n1=new Node(0.,0.5); Node *n5=new Node(0.3,1.2);
Node *n2=new Node(1.,0.5); Node *n6=new Node(1.1,1.3);
Node *n3=new Node(1.,0.); Node *n7=new Node(-0.1,0.9);
- EdgeLin *e0_1=new EdgeLin(n0,n1);
- EdgeLin *e1_2=new EdgeLin(n1,n2); EdgeLin *e4_5=new EdgeLin(n4,n5);
- EdgeLin *e2_3=new EdgeLin(n2,n3); EdgeLin *e5_6=new EdgeLin(n5,n6);
- EdgeLin *e3_0=new EdgeLin(n3,n0); EdgeLin *e6_4=new EdgeLin(n6,n4);
- EdgeLin *e4_7=new EdgeLin(n4,n7); EdgeLin *e7_5=new EdgeLin(n7,n5);
+ auto *e0_1=new EdgeLin(n0,n1);
+ auto *e1_2=new EdgeLin(n1,n2); auto *e4_5=new EdgeLin(n4,n5);
+ auto *e2_3=new EdgeLin(n2,n3); auto *e5_6=new EdgeLin(n5,n6);
+ auto *e3_0=new EdgeLin(n3,n0); auto *e6_4=new EdgeLin(n6,n4);
+ auto *e4_7=new EdgeLin(n4,n7); auto *e7_5=new EdgeLin(n7,n5);
QuadraticPolygon pol1; pol1.pushBack(e0_1); pol1.pushBack(e1_2); pol1.pushBack(e2_3); pol1.pushBack(e3_0);
QuadraticPolygon pol2; pol2.pushBack(e4_5); pol2.pushBack(e5_6); pol2.pushBack(e6_4);
pol2.pushBack(e7_5); e4_5->incrRef(); pol2.pushBack(new ElementaryEdge(e4_5,false)); pol2.pushBack(e4_7);
*/
void QuadraticPlanarInterpTest::checkArcArcIntersection1()
{
- double eps=1.0e-8;
+ double const eps=1.0e-8;
INTERP_KERNEL::QuadraticPlanarPrecision::setPrecision(eps);
Node *n0=new Node(6.37533,38.8928); Node *n3=new Node(6.29194,39.2789);
Node *n6=new Node(6.2534549999999998, 38.861800000000002); // to have a linear edge e1
//EdgeArcCircle *e1=new EdgeArcCircle(n0, n2, n6, true); // to have a linear edge e1
- EdgeArcCircle *e1=new EdgeArcCircle(n0, n2, n1, true);
- EdgeArcCircle *e2=new EdgeArcCircle(n3, n5, n4, true);
+ auto *e1=new EdgeArcCircle(n0, n2, n1, true);
+ auto *e2=new EdgeArcCircle(n3, n5, n4, true);
MergePoints merge;
QuadraticPolygon c1,c2;
//
// Author : Anthony Geay (CEA/DEN)
+#include "InterpKernelGeo2DPrecision.hxx"
+#include "InterpKernelGeo2DNode.hxx"
#include "QuadraticPlanarInterpTest.hxx"
#include "InterpKernelGeo2DQuadraticPolygon.hxx"
-#include "InterpKernelGeo2DElementaryEdge.hxx"
#include "InterpKernelGeo2DEdgeArcCircle.hxx"
-#include "InterpKernelGeo2DEdgeLin.hxx"
+#include <algorithm>
#include <cmath>
-#include <sstream>
-#include <iostream>
-#include <iterator>
+#include <cppunit/TestAssert.h>
+#include <vector>
using namespace INTERP_KERNEL;
Node * start = new Node(0.,0.); Node * end = new Node(0.,0.); // unused
// start, end, center_x, center_y, radius, angle0, angle
- EdgeArcCircle e(start, end, e_center, 1.2264175471673588, -0.9533904350433241, 0.95339043504332388);
+ EdgeArcCircle const e(start, end, e_center, 1.2264175471673588, -0.9533904350433241, 0.95339043504332388);
e.getMiddleOfPoints(p1, p2, mid);
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.37969180470645592, mid[0], 1.e-7);
Node * start = new Node(0.,0.); Node * end = new Node(0.,0.); // unused
// start, end, center_x, center_y, radius, angle0, angle
- EdgeArcCircle e(start, end, e_center, 6.0104076400856474, -0.69522150912422953, -0.18035330854643861);
+ EdgeArcCircle const e(start, end, e_center, 6.0104076400856474, -0.69522150912422953, -0.18035330854643861);
e.getMiddleOfPoints(p1, p2, mid);
CPPUNIT_ASSERT_DOUBLES_EQUAL(-0.6, mid[0], 1.e-7);
Node * start = new Node(0.,0.); Node * end = new Node(0.,0.); // unused
// start, end, center_x, center_y, radius, angle0, angle
- EdgeArcCircle e(start, end, e_center, 2.0977501175200861, 1.0829141821052615, -0.59503203741562627);
+ EdgeArcCircle const e(start, end, e_center, 2.0977501175200861, 1.0829141821052615, -0.59503203741562627);
e.getMiddleOfPoints(p1, p2, mid);
CPPUNIT_ASSERT_DOUBLES_EQUAL(-0.5, mid[0], 1.e-7);
Node * start = new Node(0.,0.); Node * end = new Node(0.,0.); // unused
// start, end, center_x, center_y, radius, angle0, angle
- EdgeArcCircle e(start, end, e_center, 1.0, -0.7853981633974485, -1.5707963267948966);
+ EdgeArcCircle const e(start, end, e_center, 1.0, -0.7853981633974485, -1.5707963267948966);
e.getMiddleOfPointsOriented(p1, p2, mid);
CPPUNIT_ASSERT_DOUBLES_EQUAL(1., mid[0], 1.e-7);
#include "SingleElementPlanarTests.hxx"
#include "InterpolationUtils.hxx"
-#include "PolygonAlgorithms.hxx"
#include "PolygonAlgorithms.txx"
-#include "InterpolationPlanarTestSuite.hxx"
+#include <cppunit/TestAssert.h>
#include <deque>
+#include <vector>
using namespace INTERP_KERNEL;
// \brief Status : pass
void SingleElementPlanarTests::identicalSquares()
{
- INTERP_KERNEL::PolygonAlgorithms<2> intersector (_Epsilon, _Precision);;
+ INTERP_KERNEL::PolygonAlgorithms<2> const intersector (_Epsilon, _Precision);;
/*
////////////////// TEST DEACTIVATED by A. GEAY because memory fault :
// conditional jump INTERP_KERNEL::PolygonAlgorithms<2>::intersectConvexPolygons(double const*, double const*, int, int) (PolygonAlgorithms.txx:629)
#include "InterpKernelTestExport.hxx"
#include "InterpolationPlanarTestSuite.hxx"
+#include <cppunit/extensions/HelperMacros.h>
namespace INTERP_TEST
{
#define __SINGLE_ELEMENT_TETRA_TESTS_HXX_
#include "InterpolationTestSuite.hxx"
+#include <cppunit/extensions/HelperMacros.h>
namespace INTERP_TEST
{
#include "TransformedTriangleTest.hxx"
#include "UnitTetraIntersectionBaryTest.hxx"
#include "UnitTetra3D2DIntersectionTest.hxx"
+#include "MeshTestToolkit.txx"
+#include <cppunit/extensions/HelperMacros.h>
#ifndef MEDCOUPLING_MICROMED
#include "HexaTests.hxx"
#include "InterpKernelException.hxx"
#include <cstdlib>
+#include <string>
#ifdef WIN32
#include<direct.h>
#define getcwd _getcwd
resourceFile = getenv("MEDCOUPLING_ROOT_DIR");
resourceFile += "/share/resources/med/";
resourceFile += filename;
- std::ifstream my_file(resourceFile.c_str());
+ std::ifstream const my_file(resourceFile.c_str());
if (my_file.good())
return resourceFile;
}
resourceFile.erase(std::remove(resourceFile.begin(), resourceFile.end(), ':'), resourceFile.end());
resourceFile += "/";
resourceFile += filename;
- std::ifstream my_file(resourceFile.c_str());
+ std::ifstream const my_file(resourceFile.c_str());
if (my_file.good())
return resourceFile;
}
// else
- char * tmp_c = getcwd(NULL, 0);
+ char * tmp_c = getcwd(nullptr, 0);
resourceFile = tmp_c;
free(tmp_c);
resourceFile += "/";
resourceFile += "../";
resourceFile += "resources/";
resourceFile += filename;
- std::ifstream my_file(resourceFile.c_str());
+ std::ifstream const my_file(resourceFile.c_str());
if (!my_file.good())
{
std::stringstream ss;
//
#include "ThreeDSurfProjectionTest.hxx"
+#include "NormalizedUnstructuredMesh.hxx"
#include "PlanarIntersector.txx"
#include "MCIdType.hxx"
+#include <algorithm>
+#include <cppunit/TestAssert.h>
class MyMeshType
{
//MEDCouplingPointSet.Rotate3DAlg([0.,0.,0.],[2.,1.,3.],0.3,coo2)
const double coo[9]={0.,0.,0.,0.96809749223257568,0.24332379388106262,-0.059839592782071335,-0.23056279077409292,0.95852673990234838,0.16753294721527912};
const double coo2[9]={9.8122602102980502e-08,-1.4839144255482456e-7,9.8404874611628791e-7,0.96809759035517784,0.24332364548962007,-0.059838608733325221,-0.23056269265149082,0.9585265915109058,0.16753393126402524};
- double *tmp0(new double[9]),*tmp1(new double[9]);
+ auto *tmp0(new double[9]),*tmp1(new double[9]);
int ret;
//eps=1e-2. eps is a tolerance to detect that two points are the same or not in a same polygon.
// here the max 3D distance is 1e-5 > 1e-6 so 1 is expected
//
const double coo[9]={0.,0.,0.,0.96809749223257568,0.24332379388106262,-0.059839592782071335,-0.23056279077409292,0.95852673990234838,0.16753294721527912};
const double coo2[9]={7.2311562622637225e-07,6.8998795679738294e-07,3.1943866106249849e-08,0.72852072144314628,0.33125439126063028,0.5996079016637561,0.0090154262465889021,0.87059752249869415,-0.49191448334281612};
- double *tmp0(new double[9]),*tmp1(new double[9]);
+ auto *tmp0(new double[9]),*tmp1(new double[9]);
int ret;
//eps=1e-2. eps is a tolerance to detect that two points are the same or not in a same polygon.
// here the max 3D distance is 1e-5 > 1e-6 so 1 is expected
#ifndef __THREEDSURFPROJECTIONTEST_HXX__
#define __THREEDSURFPROJECTIONTEST_HXX__
+#include <cppunit/TestFixture.h>
#include <cppunit/extensions/HelperMacros.h>
#include "InterpKernelTestExport.hxx"
//
#include "TransformedTriangleIntersectTest.hxx"
-#include <iostream>
-#include <iomanip>
+#include <cppunit/TestAssert.h>
+#include <cmath>
#include "Log.hxx"
+#include "TransformedTriangle.hxx"
/// macro to test for zero double products outside the segment-edge intersection test method
/// as is done in TransformedTriangle when OPTIMIZE is defined
0.4, 2.5, 0.5 // R
};
- TransformedTriangle* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
+ auto* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
// run all intersection tests and ensure that the ones
// listed with yes in the tables above return true and
1.5, 0.5,-0.25, // Q
-0.5,-1.5, 0.75 // R
};
- TransformedTriangle* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
+ auto* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
// run all intersection tests and ensure that the ones
// listed with yes in the tables above return true and
-0.4, 0.3, 0.9 // R
};
- TransformedTriangle* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
+ auto* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
// run all intersection tests and ensure that the ones
// listed with yes in the tables above return true and
0.2, -1.3, -1.4 // R
};
- TransformedTriangle* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
+ auto* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
// run all intersection tests and ensure that the ones
// listed with yes in the tables above return true and
0.5, -2.6, 1.3 // R
};
- TransformedTriangle* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
+ auto* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
// run all intersection tests and ensure that the ones
// listed with yes in the tables above return true and
-3.0, 3.0, -0.5 // R
};
- TransformedTriangle* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
+ auto* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
// run all intersection tests and ensure that the ones
// listed with yes in the tables above return true and
0.3, 0.4, 0.2 // R
};
- TransformedTriangle* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
+ auto* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
// run all intersection tests and ensure that the ones
// listed with yes in the tables above return true and
-0.1, -0.4, 0.9 // R
};
- TransformedTriangle* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
+ auto* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
// run all intersection tests and ensure that the ones
// listed with yes in the tables above return true and
0.1, 0.2, 0.8 // R
};
- TransformedTriangle* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
+ auto* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
// run all intersection tests and ensure that the ones
// listed with yes in the tables above return true and
0.4, 0.3, 0.3 // R
};
- TransformedTriangle* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
+ auto* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
// run all intersection tests and ensure that the ones
// listed with yes in the tables above return true and
0.3, 0.3, 0.3 // R
};
- TransformedTriangle* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
+ auto* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
// run all intersection tests and ensure that the ones
// listed with yes in the tables above return true and
0.6, 0.6, -0.6 // R
};
- TransformedTriangle* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
+ auto* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
// run all intersection tests and ensure that the ones
// listed with yes in the tables above return true and
-0.2, -0.1, 3.0 // R
};
- TransformedTriangle* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
+ auto* tri = new TransformedTriangle(&coords[0], &coords[3], &coords[6]);
// run all intersection tests and ensure that the ones
// listed with yes in the tables above return true and
0.44117647058823506, 0, 0.55882352941176483,
-0.89215686274509864, 1.3333333333333339, 0.55882352941176483};
- double refVol = 0.054383777732546296;
+ double const refVol = 0.054383777732546296;
TransformedTriangle tri(&coords[0], &coords[3], &coords[6]);
const double vol = tri.calculateIntersectionVolume();
-0.55882352941176472, 0, 1.5588235294117649,
-0.89215686274509864, 1.3333333333333339, 0.55882352941176483 };
- double refVol = -0.06869529818848;
+ double const refVol = -0.06869529818848;
TransformedTriangle tri(&coords[0], &coords[3], &coords[6]);
const double vol = tri.calculateIntersectionVolume();
-1.2062474433365091, -0.037350951323461778, 2.1879983126221099,
0.49877186496532655, 0.59827776894780405, 0.79353793765518521
};
- double refVol = -0.051135429735185;
+ double const refVol = -0.051135429735185;
TransformedTriangle tri(&coords[0], &coords[3], &coords[6]);
const double vol = tri.calculateIntersectionVolume();
2.022774182629973, -1.020222639063029, -0.01375178680446254,
0.7495960843059706, 0.1125313911637846, 0.7430770879625861
};
- double refVol = -0.00060846166394417;
+ double const refVol = -0.00060846166394417;
TransformedTriangle tri(&coords[0], &coords[3], &coords[6]);
const double vol = tri.calculateIntersectionVolume();
-3.552713678800501e-15, 0, 0.9999999999999982,
0, 1.000000000000004, -8.881784197001252e-16
};
- double refVol = -1/6.;
+ double const refVol = -1/6.;
TransformedTriangle tri(&coords[0], &coords[3], &coords[6]);
const double vol = tri.calculateIntersectionVolume();
1.000000000000004, 0, 0,
0, 0, 0.9999999999999929,
3.552713678800501e-15, 1, 0};
- double refVol = -1/6.;
+ double const refVol = -1/6.;
TransformedTriangle tri(&coords[0], &coords[3], &coords[6]);
const double vol = tri.calculateIntersectionVolume();
3.700743415417188e-17, 0.9999999999999999, 3.700743415417188e-17
};
- double refVol = -1/6.;
+ double const refVol = -1/6.;
TransformedTriangle tri(&coords[0], &coords[3], &coords[6]);
const double vol = tri.calculateIntersectionVolume();
-7.105427357601002e-15, 1.000000000000014, -3.552713678800501e-15
};
- double refVol = -1/6.;
+ double const refVol = -1/6.;
TransformedTriangle tri(&coords[0], &coords[3], &coords[6]);
const double vol = tri.calculateIntersectionVolume();
#ifndef __TU_TRANSFORMED_TRIANGLE_INTERSECT_HXX__
#define __TU_TRANSFORMED_TRIANGLE_INTERSECT_HXX__
+#include <cppunit/TestFixture.h>
#include <cppunit/extensions/HelperMacros.h>
#include "InterpKernelTestExport.hxx"
//
#include "TransformedTriangleTest.hxx"
+#include "TransformedTriangle.hxx"
-#include <iostream>
+#include <cppunit/TestAssert.h>
using namespace INTERP_KERNEL;
void TransformedTriangleTest::test_constructor() {
// test that _coords has correct values after constructor is called
- double good_values1[15] =
+ double const good_values1[15] =
{
p1[0], p1[1], p1[2], hp1, Hp1,
q1[0], q1[1], q1[2], hq1, Hq1,
r1[0], r1[1], r1[2], hr1, Hr1
};
- double good_values2[15] =
+ double const good_values2[15] =
{
p2[0], p2[1], p2[2], hp2, Hp2,
q2[0], q2[1], q2[2], hq2, Hq2,
// test that the correct c-values are calculated
- double correct_c_vals[24] =
+ double const correct_c_vals[24] =
{
p1[0] * q1[1] - p1[1] * q1[0],
p1[1] * q1[2] - p1[2] * q1[1],
for(int i = 0; i < 3 ; ++i)
{
- DoubleProduct dp = DOUBLE_PRODUCTS[3*min_corner + i];
+ DoubleProduct const dp = DOUBLE_PRODUCTS[3*min_corner + i];
// std::cout << std::endl << "in test inconsistent (seg,dp) :(" << seg <<", " << dp << ")" << std::endl;
CPPUNIT_ASSERT_EQUAL(0.0, tri2->calcStableC(seg, dp));
correct_c_vals[8*seg + dp] = 0.0;
#ifndef __TU_TRANSFORMED_TRIANGLE_HXX__
#define __TU_TRANSFORMED_TRIANGLE_HXX__
+#include <cppunit/TestFixture.h>
#include <cppunit/extensions/HelperMacros.h>
#include "InterpKernelTestExport.hxx"
// CPPUNIT_TEST( test_calcStableC_Consistency );
CPPUNIT_TEST_SUITE_END();
- typedef INTERP_KERNEL::TransformedTriangle::TriSegment TriSegment;
- typedef INTERP_KERNEL::TransformedTriangle::DoubleProduct DoubleProduct;
+ using TriSegment = INTERP_KERNEL::TransformedTriangle::TriSegment;
+ using DoubleProduct = INTERP_KERNEL::TransformedTriangle::DoubleProduct;
public:
void setUp();
#include "UnitTetra3D2DIntersectionTest.hxx"
-#include "TetraAffineTransform.hxx"
-#include "InterpolationUtils.hxx"
#include "SplitterTetra.txx"
+#include "NormalizedGeometricTypes"
#include "MCIdType.hxx"
-#include <iostream>
+#include <cppunit/TestAssert.h>
+#include <set>
using namespace INTERP_KERNEL;
{
struct __MESH_DUMMY
{
- typedef mcIdType MyConnType;
+ using MyConnType = mcIdType;
static const int MY_SPACEDIM=3;
};
const double* tetraCoords[]={ targetCoords, targetCoords+3, targetCoords+6, targetCoords+9 };
- __MESH_DUMMY dummyMesh;
+ __MESH_DUMMY const dummyMesh;
SplitterTetra<__MESH_DUMMY>* targetTetra = new SplitterTetra<__MESH_DUMMY>( dummyMesh, tetraCoords, conn );
return targetTetra;
}
CPPUNIT_ASSERT_EQUAL(4,(int)listOfTetraFacesTreated.size());
std::multiset<TriangleFaceKey> correctListOfTetraFacesTreated;
- TriangleFaceKey key1 = TriangleFaceKey(0, 1, 2);
+ TriangleFaceKey const key1 = TriangleFaceKey(0, 1, 2);
correctListOfTetraFacesTreated.insert(key1);
- TriangleFaceKey key2 = TriangleFaceKey(0, 1, 3);
+ TriangleFaceKey const key2 = TriangleFaceKey(0, 1, 3);
correctListOfTetraFacesTreated.insert(key2);
- TriangleFaceKey key3 = TriangleFaceKey(0, 2, 3);
+ TriangleFaceKey const key3 = TriangleFaceKey(0, 2, 3);
correctListOfTetraFacesTreated.insert(key3);
- TriangleFaceKey key4 = TriangleFaceKey(1, 2, 3);
+ TriangleFaceKey const key4 = TriangleFaceKey(1, 2, 3);
correctListOfTetraFacesTreated.insert(key4);
CPPUNIT_ASSERT(correctListOfTetraFacesTreated == listOfTetraFacesTreated);
CPPUNIT_ASSERT_EQUAL(4,(int)listOfTetraFacesTreated.size());
std::multiset<TriangleFaceKey> correctListOfTetraFacesTreated;
- TriangleFaceKey key1 = TriangleFaceKey(0, 1, 2);
+ TriangleFaceKey const key1 = TriangleFaceKey(0, 1, 2);
correctListOfTetraFacesTreated.insert(key1);
- TriangleFaceKey key2 = TriangleFaceKey(0, 1, 3);
+ TriangleFaceKey const key2 = TriangleFaceKey(0, 1, 3);
correctListOfTetraFacesTreated.insert(key2);
- TriangleFaceKey key3 = TriangleFaceKey(0, 2, 3);
+ TriangleFaceKey const key3 = TriangleFaceKey(0, 2, 3);
correctListOfTetraFacesTreated.insert(key3);
- TriangleFaceKey key4 = TriangleFaceKey(1, 2, 3);
+ TriangleFaceKey const key4 = TriangleFaceKey(1, 2, 3);
correctListOfTetraFacesTreated.insert(key4);
CPPUNIT_ASSERT(correctListOfTetraFacesTreated == listOfTetraFacesTreated);
#ifndef __UNITTETRA3D2DINTERSECTIONTEST_HXX__
#define __UNITTETRA3D2DINTERSECTIONTEST_HXX__
+#include <cppunit/TestFixture.h>
#include <cppunit/extensions/HelperMacros.h>
#include "InterpKernelTestExport.hxx"
//
#include "UnitTetraIntersectionBaryTest.hxx"
+#include "TransformedTriangle.hxx"
+#include "SplitterTetra.txx"
+#include "InterpKernelException.hxx"
#include "UnitTetraIntersectionBary.hxx"
#include "TetraAffineTransform.hxx"
#include "InterpolationUtils.hxx"
-#include "SplitterTetra.txx"
#include "MCIdType.hxx"
-#include <iostream>
+#include <cppunit/TestAssert.h>
+#include <vector>
using namespace INTERP_KERNEL;
// { 1, 2, 3 },
// { 3, 2, 0 } };
bary.init(true);
- for ( int i = 0; i < 4; ++i ) {
- int* faceNodes = faceConn[ i ];
+ for (auto faceNodes : faceConn) {
TransformedTriangle tri(nodes[faceNodes[0]], nodes[faceNodes[1]], nodes[faceNodes[2]]);
tri.calculateIntersectionVolume();
bary.addSide( tri );
UnitTetraIntersectionBary bary;
fill_UnitTetraIntersectionBary(bary,nodes);
double baryCenter[3];
- bool ok = bary.getBary( baryCenter );
- double vol = bary.getVolume();
+ bool const ok = bary.getBary( baryCenter );
+ double const vol = bary.getVolume();
CPPUNIT_ASSERT( ok );
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.166667, vol, 1e-5);
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.25, baryCenter[0], 1e-5);
UnitTetraIntersectionBary bary;
fill_UnitTetraIntersectionBary(bary,nodes);
double baryCenter[3];
- bool ok = bary.getBary( baryCenter );
- double vol = bary.getVolume();
+ bool const ok = bary.getBary( baryCenter );
+ double const vol = bary.getVolume();
CPPUNIT_ASSERT( ok );
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.166667, vol, 1e-5);
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.25, baryCenter[0], 1e-5);
UnitTetraIntersectionBary bary;
fill_UnitTetraIntersectionBary(bary,nodes);
double baryCenter[3];
- bool ok = bary.getBary( baryCenter );
- double vol = bary.getVolume();
+ bool const ok = bary.getBary( baryCenter );
+ double const vol = bary.getVolume();
CPPUNIT_ASSERT( ok );
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.020833333333333332, vol, 1e-5);
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.125, baryCenter[0], 1e-5);
UnitTetraIntersectionBary bary;
fill_UnitTetraIntersectionBary(bary,nodes);
double baryCenter[3];
- bool ok = bary.getBary( baryCenter );
- double vol = bary.getVolume();
+ bool const ok = bary.getBary( baryCenter );
+ double const vol = bary.getVolume();
CPPUNIT_ASSERT( ok );
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.020833333333333332, vol, 1e-5);
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.125, baryCenter[0], 1e-5);
UnitTetraIntersectionBary bary;
fill_UnitTetraIntersectionBary(bary,nodes);
double baryCenter[3];
- bool ok = bary.getBary( baryCenter );
- double vol = bary.getVolume();
+ bool const ok = bary.getBary( baryCenter );
+ double const vol = bary.getVolume();
CPPUNIT_ASSERT( ok );
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.1215, vol, 1e-5);
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.225, baryCenter[0], 1e-5);
UnitTetraIntersectionBary bary;
fill_UnitTetraIntersectionBary(bary,nodes);
double baryCenter[3];
- bool ok = bary.getBary( baryCenter );
- double vol = bary.getVolume();
+ bool const ok = bary.getBary( baryCenter );
+ double const vol = bary.getVolume();
CPPUNIT_ASSERT( ok );
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.000441855, vol, 1e-5);
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.353463 , baryCenter[0], 1e-5 );
UnitTetraIntersectionBary bary;
fill_UnitTetraIntersectionBary(bary,nodes);
double baryCenter[3];
- bool ok = bary.getBary( baryCenter );
- double vol = bary.getVolume();
+ bool const ok = bary.getBary( baryCenter );
+ double const vol = bary.getVolume();
CPPUNIT_ASSERT( ok );
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.0103501, vol, 1e-5);
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.215578 , baryCenter[0], 1e-5 );
UnitTetraIntersectionBary bary;
fill_UnitTetraIntersectionBary(bary,nodes);
double baryCenter[3];
- bool ok = bary.getBary( baryCenter );
- double vol = bary.getVolume();
+ bool const ok = bary.getBary( baryCenter );
+ double const vol = bary.getVolume();
CPPUNIT_ASSERT( ok );
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.0349217, vol, 1e-5);
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.332275 , baryCenter[0], 1e-2 );
UnitTetraIntersectionBary bary;
fill_UnitTetraIntersectionBary(bary,nodes);
double baryCenter[3];
- bool ok = bary.getBary( baryCenter );
- double vol = bary.getVolume();
+ bool const ok = bary.getBary( baryCenter );
+ double const vol = bary.getVolume();
CPPUNIT_ASSERT( !ok );
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.0, vol, 1e-15);
CPPUNIT_ASSERT_DOUBLES_EQUAL( -1. , baryCenter[0], 1e-5 );
UnitTetraIntersectionBary bary;
fill_UnitTetraIntersectionBary(bary,nodes);
double baryCenter[3];
- bool ok = bary.getBary( baryCenter );
- double vol = bary.getVolume();
+ bool const ok = bary.getBary( baryCenter );
+ double const vol = bary.getVolume();
CPPUNIT_ASSERT( ok );
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.166667, vol, 1e-5);
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.25, baryCenter[0], 1e-5);
UnitTetraIntersectionBary bary;
fill_UnitTetraIntersectionBary(bary,nodes);
double baryCenter[3];
- bool ok = bary.getBary( baryCenter );
- double vol = bary.getVolume();
+ bool const ok = bary.getBary( baryCenter );
+ double const vol = bary.getVolume();
CPPUNIT_ASSERT( ok );
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.15873 , vol, 1e-5);
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.250000, baryCenter[0], 1e-5);
UnitTetraIntersectionBary bary;
fill_UnitTetraIntersectionBary(bary,nodes);
double baryCenter[3];
- bool ok = bary.getBary( baryCenter );
- double vol = bary.getVolume();
+ bool const ok = bary.getBary( baryCenter );
+ double const vol = bary.getVolume();
CPPUNIT_ASSERT( ok );
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.005208 , vol, 1e-5);
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.562500, baryCenter[0], 1e-5);
struct __MESH_DUMMY
{
- typedef mcIdType MyConnType;
+ using MyConnType = mcIdType;
};
void UnitTetraIntersectionBaryTest::test_UnitTetraIntersectionBary_13()
75,150,75,
100,100,100};
- mcIdType conn[4] = { 0,1,2,3 };
+ mcIdType const conn[4] = { 0,1,2,3 };
const double* tnodes[4]={ T, T+3, T+6, T+9 };
const double* snodes[4]={ S, S+3, S+6, S+9 };
- __MESH_DUMMY dummyMesh;
+ __MESH_DUMMY const dummyMesh;
SplitterTetra<__MESH_DUMMY> src( dummyMesh, snodes, conn );
double volume = src.intersectTetra( tnodes );
CPPUNIT_ASSERT_DOUBLES_EQUAL(6944.4444444444443,volume,1e-9);
41.6666666666666714036, 120.0, 6.3333333333333348136,
25.0, 120.0, 17.6666666666666714036};
- mcIdType conn[4] = { 0,1,2,3 };
+ mcIdType const conn[4] = { 0,1,2,3 };
const double* tnodes[4]={ T, T+3, T+6, T+9 };
const double* snodes[4]={ S, S+3, S+6, S+9 };
const double refVol = 48.6591695501729;
- __MESH_DUMMY dummyMesh;
+ __MESH_DUMMY const dummyMesh;
SplitterTetra<__MESH_DUMMY> src( dummyMesh, snodes, conn );
- double volume = src.intersectTetra( tnodes );
+ double const volume = src.intersectTetra( tnodes );
CPPUNIT_ASSERT_DOUBLES_EQUAL(refVol,volume,1e-9);
// Now the other way round:
SplitterTetra<__MESH_DUMMY> tgt( dummyMesh, tnodes, conn );
- double volume2 = tgt.intersectTetra( snodes );
+ double const volume2 = tgt.intersectTetra( snodes );
CPPUNIT_ASSERT_DOUBLES_EQUAL(refVol,volume2,1e-9);
}
// double pSrc[3] = { -4.0, 9.0, 3.0 };
double pSrc[3] = { 40., -20., 100. };
double pDest[] = {1,1,1};
- TetraAffineTransform a(nodes);
+ TetraAffineTransform const a(nodes);
a.apply( pDest, pSrc );
a.reverseApply( pDest, pDest );
CPPUNIT_ASSERT_DOUBLES_EQUAL( pSrc[0], pDest[0], 1e-12);
void UnitTetraIntersectionBaryTest::test_barycentric_coords()
{
// compute barycentric coordinates
- double nodes[4][3] = { {11.0, 0.0, 2.0 },
+ double const nodes[4][3] = { {11.0, 0.0, 2.0 },
{-4.0, 9.0, 3.0 },
{ 0.0, 0.0, 0.0 },
{ 6.0, 1.0,10.0 }};
{ 1.0, 2.0, 0.0 }
};
// Translate cube:
- for (int i=0; i < 8; ++i)
- for (int j=0; j < 3; ++j)
- nodes[i][j] += 15.0;
+ for (auto & node : nodes)
+ for (double & j : node)
+ j += 15.0;
std::vector<const double*> n (8);
for (int i=0; i<8; i++)
{ 1.0, 0.0 } };
// Translate quad4:
- for (int i=0; i < 4; ++i)
- for (int j=0; j < 2; ++j)
- nodes[i][j] += 15.0;
+ for (auto & node : nodes)
+ for (double & j : node)
+ j += 15.0;
std::vector<const double*> n (4);
for (int i=0; i<4; i++)
#ifndef __UNITTETRAINTERSECTIONBARYTEST_HXX__
#define __UNITTETRAINTERSECTIONBARYTEST_HXX__
+#include <cppunit/TestFixture.h>
#include <cppunit/extensions/HelperMacros.h>
#include "InterpKernelTestExport.hxx"
#pragma once
-#include "MEDCouplingRefCountObject.hxx"
#include "InterpKernelException.hxx"
+#include <cstddef>
#include <vector>
#include <algorithm>
#include "MCAuto.hxx"
+#include <cstddef>
#include <vector>
namespace MEDCoupling
#include <cstdint>
#include <stddef.h>
-#include <cstddef>
namespace MEDCoupling
{
//
// Author : Anthony Geay (EDF R&D)
+#include "CellModel.hxx"
+#include "MEDCouplingPointSet.hxx"
#include "MEDCoupling1GTUMesh.txx"
+#include "MCAuto.hxx"
+#include "MCIdType.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MEDCouplingMesh.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "InterpKernelHashMap.hxx"
+#include "InterpKernelException.hxx"
+#include "MEDCouplingStructuredMesh.hxx"
#include "MEDCouplingUMesh.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "MEDCouplingCMesh.hxx"
-#include "SplitterTetra.hxx"
+#include "NormalizedGeometricTypes"
+#include "SplitterTetra.txx"
#include "DiameterCalculator.hxx"
#include "OrientationInverter.hxx"
#include "InterpKernelAutoPtr.hxx"
#include "VolSurfUser.txx"
+#include <string>
+#include <set>
+#include <sstream>
+#include <vector>
+#include <ostream>
+#include <cstddef>
+#include <algorithm>
+#include <iterator>
+#include <functional>
+#include <map>
+#include <cstdlib>
+#include <limits>
using namespace MEDCoupling;
const int MEDCoupling1SGTUMesh::HEXA8_FACE_PAIRS[6]={0,1,2,4,3,5};
-MEDCoupling1GTUMesh::MEDCoupling1GTUMesh():_cm(0)
+MEDCoupling1GTUMesh::MEDCoupling1GTUMesh():_cm(nullptr)
{
}
{
if(!m)
throw INTERP_KERNEL::Exception("MEDCoupling1GTUMesh::New : input mesh is null !");
- std::set<INTERP_KERNEL::NormalizedCellType> gts(m->getAllGeoTypes());
+ std::set<INTERP_KERNEL::NormalizedCellType> const gts(m->getAllGeoTypes());
if(gts.size()!=1)
throw INTERP_KERNEL::Exception("MEDCoupling1GTUMesh::New : input mesh must have exactly one geometric type !");
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(*gts.begin());
*/
DataArrayIdType *MEDCoupling1GTUMesh::checkTypeConsistencyAndContig(const std::vector<mcIdType>& code, const std::vector<const DataArrayIdType *>& idsPerType) const
{
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
if(code.size()!=3)
throw INTERP_KERNEL::Exception("MEDCoupling1GTUMesh::checkTypeConsistencyAndContig : invalid input code should be exactly of size 3 !");
if(code[0]!=ToIdType(getCellModelEnum()))
if(code[2]==-1)
{
if(code[1]==nbOfCells)
- return 0;
+ return nullptr;
else
{
std::ostringstream oss; oss << "MEDCoupling1GTUMesh::checkTypeConsistencyAndContig : mismatch between the number of cells in this (" << nbOfCells << ") and the number of non profile (" << code[1] << ") !";
return false;
if(!other)
throw INTERP_KERNEL::Exception("MEDCoupling1GTUMesh::isEqualIfNotWhy : input other pointer is null !");
- const MEDCoupling1GTUMesh *otherC=dynamic_cast<const MEDCoupling1GTUMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCoupling1GTUMesh *>(other);
if(!otherC)
{
reason="mesh given in input is not castable in MEDCouplingSGTUMesh !";
return false;
if(!other)
throw INTERP_KERNEL::Exception("MEDCoupling1GTUMesh::isEqualWithoutConsideringStr : input other pointer is null !");
- const MEDCoupling1GTUMesh *otherC=dynamic_cast<const MEDCoupling1GTUMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCoupling1GTUMesh *>(other);
if(!otherC)
return false;
if(_cm!=otherC->_cm)
if(!firstPart)
throw INTERP_KERNEL::Exception("MEDCoupling1GTUMesh::AggregateOnSameCoordsToUMesh : the first instance in input parts is null !");
const DataArrayDouble *coords(firstPart->getCoords());
- int meshDim(firstPart->getMeshDimension());
+ int const meshDim(firstPart->getMeshDimension());
MCAuto<MEDCouplingUMesh> ret(MEDCouplingUMesh::New(firstPart->getName(),meshDim)); ret->setDescription(firstPart->getDescription());
ret->setCoords(coords);
mcIdType nbOfCells(0),connSize(0);
- for(std::vector< const MEDCoupling1GTUMesh *>::const_iterator it=parts.begin();it!=parts.end();it++)
+ for(auto part : parts)
{
- if(!(*it))
+ if(!part)
throw INTERP_KERNEL::Exception("MEDCoupling1GTUMesh::AggregateOnSameCoordsToUMesh : presence of null pointer in input vector !");
- if((*it)->getMeshDimension()!=meshDim)
+ if(part->getMeshDimension()!=meshDim)
throw INTERP_KERNEL::Exception("MEDCoupling1GTUMesh::AggregateOnSameCoordsToUMesh : all the instances in input vector must have same mesh dimension !");
- if((*it)->getCoords()!=coords)
+ if(part->getCoords()!=coords)
throw INTERP_KERNEL::Exception("MEDCoupling1GTUMesh::AggregateOnSameCoordsToUMesh : all the instances must share the same coordinates pointer !");
- nbOfCells+=(*it)->getNumberOfCells();
- connSize+=(*it)->getNodalConnectivityLength();
+ nbOfCells+=part->getNumberOfCells();
+ connSize+=part->getNodalConnectivityLength();
}
MCAuto<DataArrayIdType> conn(DataArrayIdType::New()),connI(DataArrayIdType::New());
connI->alloc(nbOfCells+1,1); conn->alloc(connSize+nbOfCells,1);
mcIdType *c(conn->getPointer()),*ci(connI->getPointer()); *ci=0;
- for(std::vector< const MEDCoupling1GTUMesh *>::const_iterator it=parts.begin();it!=parts.end();it++)
+ for(auto part : parts)
{
- mcIdType curNbCells=(*it)->getNumberOfCells();
- mcIdType geoType(ToIdType((*it)->getCellModelEnum()));
- const mcIdType *cinPtr((*it)->getNodalConnectivity()->begin());
- const MEDCoupling1SGTUMesh *ps(dynamic_cast<const MEDCoupling1SGTUMesh *>(*it));
- const MEDCoupling1DGTUMesh *pd(dynamic_cast<const MEDCoupling1DGTUMesh *>(*it));
+ mcIdType const curNbCells=part->getNumberOfCells();
+ mcIdType const geoType(ToIdType(part->getCellModelEnum()));
+ const mcIdType *cinPtr(part->getNodalConnectivity()->begin());
+ const auto *ps(dynamic_cast<const MEDCoupling1SGTUMesh *>(part));
+ const auto *pd(dynamic_cast<const MEDCoupling1DGTUMesh *>(part));
if(ps && !pd)
{
- mcIdType nNodesPerCell(ps->getNumberOfNodesPerCell());
+ mcIdType const nNodesPerCell(ps->getNumberOfNodesPerCell());
for(int i=0;i<curNbCells;i++,ci++,cinPtr+=nNodesPerCell)
{
*c++=geoType;
}
MEDCoupling1SGTUMesh::MEDCoupling1SGTUMesh()
-{
-}
+= default;
MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::New()
{
{
if(!m)
throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::New : input mesh is null !");
- std::set<INTERP_KERNEL::NormalizedCellType> gts(m->getAllGeoTypes());
+ std::set<INTERP_KERNEL::NormalizedCellType> const gts(m->getAllGeoTypes());
if(gts.size()!=1)
throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::New : input mesh must have exactly one geometric type !");
- mcIdType geoType(ToIdType(*gts.begin()));
+ mcIdType const geoType(ToIdType(*gts.begin()));
MCAuto<MEDCoupling1SGTUMesh> ret(MEDCoupling1SGTUMesh::New(m->getName(),*gts.begin()));
ret->setCoords(m->getCoords()); ret->setDescription(m->getDescription());
- mcIdType nbCells=m->getNumberOfCells();
- mcIdType nbOfNodesPerCell(ret->getNumberOfNodesPerCell());
+ mcIdType const nbCells=m->getNumberOfCells();
+ mcIdType const nbOfNodesPerCell(ret->getNumberOfNodesPerCell());
MCAuto<DataArrayIdType> conn(DataArrayIdType::New()); conn->alloc(nbCells*nbOfNodesPerCell,1);
mcIdType *c(conn->getPointer());
const mcIdType *cin(m->getNodalConnectivity()->begin()),*ciin(m->getNodalConnectivityIndex()->begin());
{
if(!other)
throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::shallowCopyConnectivityFrom : input pointer is null !");
- const MEDCoupling1SGTUMesh *otherC=dynamic_cast<const MEDCoupling1SGTUMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCoupling1SGTUMesh *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::shallowCopyConnectivityFrom : input pointer is not an MEDCoupling1SGTUMesh instance !");
setNodalConnectivity(otherC->getNodalConnectivity());
if(!other)
throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::isEqualIfNotWhy : input other pointer is null !");
std::ostringstream oss; oss.precision(15);
- const MEDCoupling1SGTUMesh *otherC=dynamic_cast<const MEDCoupling1SGTUMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCoupling1SGTUMesh *>(other);
if(!otherC)
{
reason="mesh given in input is not castable in MEDCoupling1SGTUMesh !";
{
if(!other)
throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::isEqualWithoutConsideringStr : input other pointer is null !");
- const MEDCoupling1SGTUMesh *otherC=dynamic_cast<const MEDCoupling1SGTUMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCoupling1SGTUMesh *>(other);
if(!otherC)
return false;
if(!MEDCoupling1GTUMesh::isEqualWithoutConsideringStr(other,prec))
checkConsistencyOfConnectivity();
}
-void MEDCoupling1SGTUMesh::checkConsistency(double eps) const
+void MEDCoupling1SGTUMesh::checkConsistency(double /*eps*/) const
{
checkConsistencyLight();
const DataArrayIdType *c1(_conn);
- mcIdType nbOfTuples(c1->getNumberOfTuples());
- mcIdType nbOfNodesPerCell=_cm->getNumberOfNodes();
+ mcIdType const nbOfTuples(c1->getNumberOfTuples());
+ mcIdType const nbOfNodesPerCell=_cm->getNumberOfNodes();
if(nbOfTuples%nbOfNodesPerCell!=0)
{
std::ostringstream oss; oss << "MEDCoupling1SGTUMesh::checkConsistency : the nb of tuples in conn is " << nbOfTuples << " and number of nodes per cell is " << nbOfNodesPerCell << ". But " << nbOfTuples << "%" << nbOfNodesPerCell << " !=0 !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- mcIdType nbOfNodes=getNumberOfNodes();
- mcIdType nbOfCells=nbOfTuples/nbOfNodesPerCell;
+ mcIdType const nbOfNodes=getNumberOfNodes();
+ mcIdType const nbOfCells=nbOfTuples/nbOfNodesPerCell;
const mcIdType *w(c1->begin());
for(mcIdType i=0;i<nbOfCells;i++)
for(int j=0;j<nbOfNodesPerCell;j++,w++)
mcIdType MEDCoupling1SGTUMesh::getNumberOfCells() const
{
- mcIdType nbOfTuples(getNodalConnectivityLength());
- mcIdType nbOfNodesPerCell(getNumberOfNodesPerCell());
+ mcIdType const nbOfTuples(getNodalConnectivityLength());
+ mcIdType const nbOfNodesPerCell(getNumberOfNodesPerCell());
if(nbOfTuples%nbOfNodesPerCell!=0)
{
std::ostringstream oss; oss << "MEDCoupling1SGTUMesh:getNumberOfCells: : the nb of tuples in conn is " << nbOfTuples << " and number of nodes per cell is " << nbOfNodesPerCell << ". But " << nbOfTuples << "%" << nbOfNodesPerCell << " !=0 !";
return nbOfTuples/nbOfNodesPerCell;
}
-mcIdType MEDCoupling1SGTUMesh::getNumberOfNodesInCell(mcIdType cellId) const
+mcIdType MEDCoupling1SGTUMesh::getNumberOfNodesInCell(mcIdType /*cellId*/) const
{
return getNumberOfNodesPerCell();
}
{
checkNonDynamicGeoType();
MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
- mcIdType nbCells=getNumberOfCells();
+ mcIdType const nbCells=getNumberOfCells();
ret->alloc(nbCells,1);
mcIdType *retPtr(ret->getPointer());
- mcIdType nbNodesPerCell(getNumberOfNodesPerCell());
+ mcIdType const nbNodesPerCell(getNumberOfNodesPerCell());
const mcIdType *conn(_conn->begin());
for(mcIdType i=0;i<nbCells;i++,conn+=nbNodesPerCell,retPtr++)
{
- std::set<mcIdType> s(conn,conn+nbNodesPerCell);
+ std::set<mcIdType> const s(conn,conn+nbNodesPerCell);
*retPtr=ToIdType(s.size());
}
return ret.retn();
void MEDCoupling1SGTUMesh::getNodeIdsOfCell(mcIdType cellId, std::vector<mcIdType>& conn) const
{
- mcIdType sz=getNumberOfNodesPerCell();
+ mcIdType const sz=getNumberOfNodesPerCell();
conn.resize(sz);
if(cellId<getNumberOfCells())
std::copy(_conn->begin()+cellId*sz,_conn->begin()+(cellId+1)*sz,conn.begin());
ret << "Single static geometic type (" << _cm->getRepr() << ") unstructured mesh with name : \"" << getName() << "\"\n";
ret << "Description of mesh : \"" << getDescription() << "\"\n";
int tmpp1,tmpp2;
- double tt=getTime(tmpp1,tmpp2);
+ double const tt=getTime(tmpp1,tmpp2);
ret << "Time attached to the mesh [unit] : " << tt << " [" << getTimeUnit() << "]\n";
ret << "Iteration : " << tmpp1 << " Order : " << tmpp2 << "\n";
ret << "Mesh dimension : " << getMeshDimension() << "\nSpace dimension : ";
- if(_coords!=0)
+ if(_coords!=nullptr)
{
const int spaceDim=getSpaceDimension();
ret << spaceDim << "\nInfo attached on space dimension : ";
else
ret << msg0 << "\n";
ret << "Number of nodes : ";
- if(_coords!=0)
+ if(_coords!=nullptr)
ret << getNumberOfNodes() << "\n";
else
ret << msg0 << "\n";
{
if(_conn->getNumberOfComponents()==1)
{
- mcIdType nbOfCells=getNumberOfCells();
- mcIdType sz=getNumberOfNodesPerCell();
+ mcIdType const nbOfCells=getNumberOfCells();
+ mcIdType const sz=getNumberOfNodesPerCell();
const mcIdType *connPtr=_conn->begin();
for(mcIdType i=0;i<nbOfCells;i++,connPtr+=sz)
{
DataArrayDouble *MEDCoupling1SGTUMesh::computeIsoBarycenterOfNodesPerCell() const
{
MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- int spaceDim=getSpaceDimension();
- mcIdType nbOfCells=getNumberOfCells();//checkConsistencyLight()
- mcIdType nbOfNodes=getNumberOfNodes();
+ int const spaceDim=getSpaceDimension();
+ mcIdType const nbOfCells=getNumberOfCells();//checkConsistencyLight()
+ mcIdType const nbOfNodes=getNumberOfNodes();
ret->alloc(nbOfCells,spaceDim);
double *ptToFill=ret->getPointer();
const double *coor=_coords->begin();
const mcIdType *nodal=_conn->begin();
- mcIdType sz=getNumberOfNodesPerCell();
- double coeff=1./FromIdType<double>(sz);
+ mcIdType const sz=getNumberOfNodesPerCell();
+ double const coeff=1./FromIdType<double>(sz);
for(mcIdType i=0;i<nbOfCells;i++,ptToFill+=spaceDim)
{
std::fill(ptToFill,ptToFill+spaceDim,0.);
void MEDCoupling1SGTUMesh::renumberCells(const mcIdType *old2NewBg, bool check)
{
- mcIdType nbCells=getNumberOfCells();
+ mcIdType const nbCells=getNumberOfCells();
MCAuto<DataArrayIdType> o2n=DataArrayIdType::New();
o2n->useArray(old2NewBg,false,DeallocType::C_DEALLOC,nbCells,1);
if(check)
MCAuto<DataArrayIdType> newConn=DataArrayIdType::New();
newConn->alloc(_conn->getNumberOfTuples(),1);
newConn->copyStringInfoFrom(*_conn);
- mcIdType sz=getNumberOfNodesPerCell();
+ mcIdType const sz=getNumberOfNodesPerCell();
//
mcIdType *newC=newConn->getPointer();
for(mcIdType i=0;i<nbCells;i++,newC+=sz)
{
- mcIdType pos=n2oPtr[i];
+ mcIdType const pos=n2oPtr[i];
std::copy(conn+pos*sz,conn+(pos+1)*sz,newC);
}
_conn=newConn;
*/
void MEDCoupling1SGTUMesh::fillCellIdsToKeepFromNodeIds(const mcIdType *begin, const mcIdType *end, bool fullyIn, DataArrayIdType *&cellIdsKeptArr) const
{
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
MCAuto<DataArrayIdType> cellIdsKept=DataArrayIdType::New(); cellIdsKept->alloc(0,1);
mcIdType tmp=-1;
mcIdType sz=_conn->getMaxValue(tmp); sz=std::max(sz,ToIdType(0))+1;
if(*work>=0 && *work<sz)
fastFinder[*work]=true;
const mcIdType *conn=_conn->begin();
- mcIdType nbNodesPerCell=getNumberOfNodesPerCell();
+ mcIdType const nbNodesPerCell=getNumberOfNodesPerCell();
for(mcIdType i=0;i<nbOfCells;i++,conn+=nbNodesPerCell)
{
int ref=0,nbOfHit=0;
{
if(other->getType()!=SINGLE_STATIC_GEO_TYPE_UNSTRUCTURED)
throw INTERP_KERNEL::Exception("Merge of umesh only available with umesh single static geo type each other !");
- const MEDCoupling1SGTUMesh *otherC=static_cast<const MEDCoupling1SGTUMesh *>(other);
+ const auto *otherC=static_cast<const MEDCoupling1SGTUMesh *>(other);
return Merge1SGTUMeshes(this,otherC);
}
MCAuto<MEDCouplingUMesh> ret=MEDCouplingUMesh::New(getName(),getMeshDimension());
ret->setCoords(getCoords());
const mcIdType *nodalConn=_conn->begin();
- mcIdType nbCells=getNumberOfCells();
- mcIdType nbNodesPerCell=getNumberOfNodesPerCell();
- mcIdType geoType=ToIdType(getCellModelEnum());
+ mcIdType const nbCells=getNumberOfCells();
+ mcIdType const nbNodesPerCell=getNumberOfNodesPerCell();
+ mcIdType const geoType=ToIdType(getCellModelEnum());
MCAuto<DataArrayIdType> c=DataArrayIdType::New(); c->alloc(nbCells*(nbNodesPerCell+1),1);
mcIdType *cPtr=c->getPointer();
for(mcIdType i=0;i<nbCells;i++,nodalConn+=nbNodesPerCell)
struct MEDCouplingAccVisit
{
- MEDCouplingAccVisit():_new_nb_of_nodes(0) { }
+ MEDCouplingAccVisit() = default;
mcIdType operator()(mcIdType val) { if(val!=-1) return _new_nb_of_nodes++; else return -1; }
- mcIdType _new_nb_of_nodes;
+ mcIdType _new_nb_of_nodes{0};
};
/// @endcond
DataArrayIdType *MEDCoupling1SGTUMesh::computeFetchedNodeIds() const
{
checkConsistencyOfConnectivity();
- mcIdType nbNodes(getNumberOfNodes());
+ mcIdType const nbNodes(getNumberOfNodes());
std::vector<bool> fetchedNodes(nbNodes,false);
computeNodeIdsAlg(fetchedNodes);
- mcIdType sz(ToIdType(std::count(fetchedNodes.begin(),fetchedNodes.end(),true)));
+ mcIdType const sz(ToIdType(std::count(fetchedNodes.begin(),fetchedNodes.end(),true)));
MCAuto<DataArrayIdType> ret(DataArrayIdType::New()); ret->alloc(sz,1);
mcIdType *retPtr(ret->getPointer());
for(mcIdType i=0;i<nbNodes;i++)
DataArrayIdType *MEDCoupling1SGTUMesh::getNodeIdsInUse(mcIdType& nbrOfNodesInUse) const
{
nbrOfNodesInUse=-1;
- mcIdType nbOfNodes=getNumberOfNodes();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfNodes=getNumberOfNodes();
+ mcIdType const nbOfCells=getNumberOfCells();
MCAuto<DataArrayIdType> ret(DataArrayIdType::New());
ret->alloc(nbOfNodes,1);
mcIdType *traducer=ret->getPointer();
std::fill(traducer,traducer+nbOfNodes,-1);
const mcIdType *conn=_conn->begin();
- mcIdType nbNodesPerCell=getNumberOfNodesPerCell();
+ mcIdType const nbNodesPerCell=getNumberOfNodesPerCell();
for(mcIdType i=0;i<nbOfCells;i++)
for(int j=0;j<nbNodesPerCell;j++,conn++)
if(*conn>=0 && *conn<nbOfNodes)
MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::Merge1SGTUMeshes(std::vector<const MEDCoupling1SGTUMesh *>& a)
{
- std::size_t sz=a.size();
+ std::size_t const sz=a.size();
if(sz==0)
return Merge1SGTUMeshesLL(a);
for(std::size_t ii=0;ii<sz;ii++)
std::vector<const MEDCoupling1SGTUMesh *>::const_iterator it=a.begin();
mcIdType nbOfCells=(*it)->getNumberOfCells();
const INTERP_KERNEL::CellModel *cm=&((*it)->getCellModel());
- mcIdType nbNodesPerCell=(*it)->getNumberOfNodesPerCell();
+ mcIdType const nbNodesPerCell=(*it)->getNumberOfNodesPerCell();
it++;
for(;it!=a.end();it++)
{
mcIdType offset=0;
for(it=a.begin();it!=a.end();it++)
{
- mcIdType curConnLgth=(*it)->getNodalConnectivityLength();
+ mcIdType const curConnLgth=(*it)->getNodalConnectivityLength();
const mcIdType *curC=(*it)->_conn->begin();
cPtr=std::transform(curC,curC+curConnLgth,cPtr,std::bind(std::plus<mcIdType>(),std::placeholders::_1,offset));
offset+=(*it)->getNumberOfNodes();
MEDCouplingPointSet *MEDCoupling1SGTUMesh::buildPartOfMySelfKeepCoords(const mcIdType *begin, const mcIdType *end) const
{
- mcIdType ncell=getNumberOfCells();
+ mcIdType const ncell=getNumberOfCells();
MCAuto<MEDCoupling1SGTUMesh> ret(new MEDCoupling1SGTUMesh(getName(),*_cm));
ret->setCoords(_coords);
- std::size_t nbOfElemsRet=std::distance(begin,end);
+ std::size_t const nbOfElemsRet=std::distance(begin,end);
const mcIdType *inConn=_conn->getConstPointer();
- mcIdType sz=getNumberOfNodesPerCell();
+ mcIdType const sz=getNumberOfNodesPerCell();
MCAuto<DataArrayIdType> connRet=DataArrayIdType::New(); connRet->alloc(nbOfElemsRet*sz,1);
mcIdType *connPtr=connRet->getPointer();
for(const mcIdType *work=begin;work!=end;work++,connPtr+=sz)
MEDCouplingPointSet *MEDCoupling1SGTUMesh::buildPartOfMySelfKeepCoordsSlice(mcIdType start, mcIdType end, mcIdType step) const
{
- mcIdType ncell=getNumberOfCells();
- mcIdType nbOfElemsRet=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"MEDCoupling1SGTUMesh::buildPartOfMySelfKeepCoordsSlice : ");
+ mcIdType const ncell=getNumberOfCells();
+ mcIdType const nbOfElemsRet=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"MEDCoupling1SGTUMesh::buildPartOfMySelfKeepCoordsSlice : ");
MCAuto<MEDCoupling1SGTUMesh> ret(new MEDCoupling1SGTUMesh(getName(),*_cm));
ret->setCoords(_coords);
const mcIdType *inConn=_conn->getConstPointer();
- mcIdType sz=getNumberOfNodesPerCell();
+ mcIdType const sz=getNumberOfNodesPerCell();
MCAuto<DataArrayIdType> connRet=DataArrayIdType::New(); connRet->alloc(nbOfElemsRet*sz,1);
mcIdType *connPtr=connRet->getPointer();
mcIdType curId=start;
void MEDCoupling1SGTUMesh::computeNodeIdsAlg(std::vector<bool>& nodeIdsInUse) const
{
- mcIdType sz(ToIdType(nodeIdsInUse.size()));
+ mcIdType const sz(ToIdType(nodeIdsInUse.size()));
for(const mcIdType *conn=_conn->begin();conn!=_conn->end();conn++)
{
if(*conn>=0 && *conn<sz)
DataArrayIdType *MEDCoupling1SGTUMesh::simplexizePol0()
{
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
if(getCellModelEnum()!=INTERP_KERNEL::NORM_QUAD4)
return DataArrayIdType::Range(0,nbOfCells,1);
MCAuto<DataArrayIdType> newConn=DataArrayIdType::New(); newConn->alloc(2*3*nbOfCells,1);
DataArrayIdType *MEDCoupling1SGTUMesh::simplexizePol1()
{
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
if(getCellModelEnum()!=INTERP_KERNEL::NORM_QUAD4)
return DataArrayIdType::Range(0,nbOfCells,1);
MCAuto<DataArrayIdType> newConn=DataArrayIdType::New(); newConn->alloc(2*3*nbOfCells,1);
DataArrayIdType *MEDCoupling1SGTUMesh::simplexizePlanarFace5()
{
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
if(getCellModelEnum()!=INTERP_KERNEL::NORM_HEXA8)
return DataArrayIdType::Range(0,nbOfCells,1);
MCAuto<DataArrayIdType> newConn=DataArrayIdType::New(); newConn->alloc(5*4*nbOfCells,1);
DataArrayIdType *MEDCoupling1SGTUMesh::simplexizePlanarFace6()
{
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
if(getCellModelEnum()!=INTERP_KERNEL::NORM_HEXA8)
return DataArrayIdType::Range(0,nbOfCells,1);
MCAuto<DataArrayIdType> newConn=DataArrayIdType::New(); newConn->alloc(6*4*nbOfCells,1);
/*!
* First step of unserialization process.
*/
-bool MEDCoupling1SGTUMesh::isEmptyMesh(const std::vector<mcIdType>& tinyInfo) const
+bool MEDCoupling1SGTUMesh::isEmptyMesh(const std::vector<mcIdType>& /*tinyInfo*/) const
{
throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::isEmptyMesh : not implemented yet !");
}
void MEDCoupling1SGTUMesh::getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const
{
int it,order;
- double time=getTime(it,order);
+ double const time=getTime(it,order);
tinyInfo.clear(); tinyInfoD.clear(); littleStrings.clear();
//
littleStrings.push_back(getName());
tinyInfoD.push_back(time);
}
-void MEDCoupling1SGTUMesh::resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const
+void MEDCoupling1SGTUMesh::resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& /*littleStrings*/) const
{
- std::vector<mcIdType> tinyInfo2(tinyInfo.begin()+7,tinyInfo.begin()+7+tinyInfo[5]);
- std::vector<mcIdType> tinyInfo1(tinyInfo.begin()+7+tinyInfo[5],tinyInfo.begin()+7+tinyInfo[5]+tinyInfo[6]);
+ std::vector<mcIdType> const tinyInfo2(tinyInfo.begin()+7,tinyInfo.begin()+7+tinyInfo[5]);
+ std::vector<mcIdType> const tinyInfo1(tinyInfo.begin()+7+tinyInfo[5],tinyInfo.begin()+7+tinyInfo[5]+tinyInfo[6]);
a1->resizeForUnserialization(tinyInfo1);
a2->resizeForUnserialization(tinyInfo2);
}
void MEDCoupling1SGTUMesh::unserialization(const std::vector<double>& tinyInfoD, const std::vector<mcIdType>& tinyInfo, const DataArrayIdType *a1, DataArrayDouble *a2,
const std::vector<std::string>& littleStrings)
{
- INTERP_KERNEL::NormalizedCellType gt((INTERP_KERNEL::NormalizedCellType)tinyInfo[0]);
+ auto const gt((INTERP_KERNEL::NormalizedCellType)tinyInfo[0]);
_cm=&INTERP_KERNEL::CellModel::GetCellModel(gt);
setName(littleStrings[0]);
setDescription(littleStrings[1]);
mcIdType sz0(tinyInfo[3]),sz1(tinyInfo[4]),sz2(tinyInfo[5]),sz3(tinyInfo[6]);
//
_coords=DataArrayDouble::New();
- std::vector<mcIdType> tinyInfo2(tinyInfo.begin()+7,tinyInfo.begin()+7+sz2);
+ std::vector<mcIdType> const tinyInfo2(tinyInfo.begin()+7,tinyInfo.begin()+7+sz2);
_coords->resizeForUnserialization(tinyInfo2);
std::copy(a2->begin(),a2->end(),_coords->getPointer());
_conn=DataArrayIdType::New();
- std::vector<mcIdType> tinyInfo3(tinyInfo.begin()+7+sz2,tinyInfo.begin()+7+sz2+sz3);
+ std::vector<mcIdType> const tinyInfo3(tinyInfo.begin()+7+sz2,tinyInfo.begin()+7+sz2+sz3);
_conn->resizeForUnserialization(tinyInfo3);
std::copy(a1->begin(),a1->end(),_conn->getPointer());
- std::vector<std::string> littleStrings2(littleStrings.begin()+3,littleStrings.begin()+3+sz0);
+ std::vector<std::string> const littleStrings2(littleStrings.begin()+3,littleStrings.begin()+3+sz0);
_coords->finishUnserialization(tinyInfo2,littleStrings2);
- std::vector<std::string> littleStrings3(littleStrings.begin()+3+sz0,littleStrings.begin()+3+sz0+sz1);
+ std::vector<std::string> const littleStrings3(littleStrings.begin()+3+sz0,littleStrings.begin()+3+sz0+sz1);
_conn->finishUnserialization(tinyInfo3,littleStrings3);
}
void MEDCoupling1SGTUMesh::checkFastEquivalWith(const MEDCouplingMesh *other, double prec) const
{
MEDCouplingPointSet::checkFastEquivalWith(other,prec);
- const MEDCoupling1SGTUMesh *otherC=dynamic_cast<const MEDCoupling1SGTUMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCoupling1SGTUMesh *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::checkFastEquivalWith : Two meshes are not unstructured with single static geometric type !");
const DataArrayIdType *c1(_conn),*c2(otherC->_conn);
{
if(!other)
throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::mergeMyselfWithOnSameCoords : input other is null !");
- const MEDCoupling1SGTUMesh *otherC=dynamic_cast<const MEDCoupling1SGTUMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCoupling1SGTUMesh *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::mergeMyselfWithOnSameCoords : the input other mesh is not of type single statuc geo type unstructured !");
std::vector<const MEDCoupling1SGTUMesh *> ms(2);
void MEDCoupling1SGTUMesh::getReverseNodalConnectivity(DataArrayIdType *revNodal, DataArrayIdType *revNodalIndx) const
{
checkFullyDefined();
- mcIdType nbOfNodes=getNumberOfNodes();
- mcIdType *revNodalIndxPtr=(mcIdType *)malloc((nbOfNodes+1)*sizeof(mcIdType));
+ mcIdType const nbOfNodes=getNumberOfNodes();
+ auto *revNodalIndxPtr=(mcIdType *)malloc((nbOfNodes+1)*sizeof(mcIdType));
revNodalIndx->useArray(revNodalIndxPtr,true,DeallocType::C_DEALLOC,nbOfNodes+1,1);
std::fill(revNodalIndxPtr,revNodalIndxPtr+nbOfNodes+1,0);
const mcIdType *conn=_conn->begin();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
mcIdType nbOfEltsInRevNodal=0;
- mcIdType nbOfNodesPerCell=getNumberOfNodesPerCell();
+ mcIdType const nbOfNodesPerCell=getNumberOfNodesPerCell();
for(mcIdType eltId=0;eltId<nbOfCells;eltId++)
{
for(int j=0;j<nbOfNodesPerCell;j++,conn++)
}
std::transform(revNodalIndxPtr+1,revNodalIndxPtr+nbOfNodes+1,revNodalIndxPtr,revNodalIndxPtr+1,std::plus<mcIdType>());
conn=_conn->begin();
- mcIdType *revNodalPtr=(mcIdType *)malloc(nbOfEltsInRevNodal*sizeof(mcIdType));
+ auto *revNodalPtr=(mcIdType *)malloc(nbOfEltsInRevNodal*sizeof(mcIdType));
revNodal->useArray(revNodalPtr,true,DeallocType::C_DEALLOC,nbOfEltsInRevNodal,1);
std::fill(revNodalPtr,revNodalPtr+nbOfEltsInRevNodal,-1);
for(mcIdType eltId=0;eltId<nbOfCells;eltId++)
*/
void MEDCoupling1SGTUMesh::insertNextCell(const mcIdType *nodalConnOfCellBg, const mcIdType *nodalConnOfCellEnd)
{
- mcIdType sz=ToIdType(std::distance(nodalConnOfCellBg,nodalConnOfCellEnd));
- mcIdType ref=getNumberOfNodesPerCell();
+ mcIdType const sz=ToIdType(std::distance(nodalConnOfCellBg,nodalConnOfCellEnd));
+ mcIdType const ref=getNumberOfNodesPerCell();
if(sz==ref)
{
DataArrayIdType *c(_conn);
const INTERP_KERNEL::CellModel& cm(getCellModel());
if(cm.getEnum()!=INTERP_KERNEL::NORM_HEXA8)
throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::explodeEachHexa8To6Quad4 : this method can be applied only on HEXA8 mesh !");
- mcIdType nbHexa8=getNumberOfCells();
+ mcIdType const nbHexa8=getNumberOfCells();
const mcIdType *inConnPtr(getNodalConnectivity()->begin());
MCAuto<MEDCoupling1SGTUMesh> ret(MEDCoupling1SGTUMesh::New(getName(),INTERP_KERNEL::NORM_QUAD4));
MCAuto<DataArrayIdType> c(DataArrayIdType::New()); c->alloc(nbHexa8*6*4,1);
if(cm.getEnum()!=INTERP_KERNEL::NORM_TRI3)
THROW_IK_EXCEPTION("MEDCoupling1SGTUMesh::computeTriangleHeight : this method can be applied only on TRI3 mesh !");
MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
- mcIdType nbTri3( getNumberOfCells() );
+ mcIdType const nbTri3( getNumberOfCells() );
const double *coordPtr( this->getCoords()->begin() );
const mcIdType *inConnPtr(getNodalConnectivity()->begin());
ret->alloc(nbTri3,3);
MEDCouplingCMesh *MEDCoupling1SGTUMesh::structurizeMe(DataArrayIdType *& cellPerm, DataArrayIdType *& nodePerm, double eps) const
{
checkConsistencyLight();
- int spaceDim(getSpaceDimension()),meshDim(getMeshDimension()); mcIdType nbNodes(getNumberOfNodes());
+ int spaceDim(getSpaceDimension()),meshDim(getMeshDimension()); mcIdType const nbNodes(getNumberOfNodes());
if(MEDCouplingStructuredMesh::GetGeoTypeGivenMeshDimension(meshDim)!=getCellModelEnum())
throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::structurizeMe : the unique geo type in this is not compatible with the geometric type regarding mesh dimension !");
MCAuto<MEDCouplingCMesh> cm(MEDCouplingCMesh::New());
for(int i=0;i<spaceDim;i++)
{
- std::vector<std::size_t> tmp(1,i);
+ std::vector<std::size_t> const tmp(1,i);
MCAuto<DataArrayDouble> elt(static_cast<DataArrayDouble*>(getCoords()->keepSelectedComponents(tmp)));
elt=elt->getDifferentValues(eps);
elt->sort(true);
static const int TAB2[6]={0,0,3,3,3,3};
if(myNeighbours[validAxis]==neighId && allFacesNodalConn[4*validAxis+0]==validConnQuad4NeighSide[TAB2[validAxis]])
return true;
- mcIdType oldAxis(ToIdType(std::distance(myNeighbours,std::find(myNeighbours,myNeighbours+6,neighId))));
- std::size_t pos(std::distance(MEDCoupling1SGTUMesh::HEXA8_FACE_PAIRS,std::find(MEDCoupling1SGTUMesh::HEXA8_FACE_PAIRS,MEDCoupling1SGTUMesh::HEXA8_FACE_PAIRS+6,oldAxis)));
+ mcIdType const oldAxis(ToIdType(std::distance(myNeighbours,std::find(myNeighbours,myNeighbours+6,neighId))));
+ std::size_t const pos(std::distance(MEDCoupling1SGTUMesh::HEXA8_FACE_PAIRS,std::find(MEDCoupling1SGTUMesh::HEXA8_FACE_PAIRS,MEDCoupling1SGTUMesh::HEXA8_FACE_PAIRS+6,oldAxis)));
std::size_t pos0(pos/2),pos1(pos%2);
- int oldAxisOpp(MEDCoupling1SGTUMesh::HEXA8_FACE_PAIRS[2*pos0+(pos1+1)%2]);
+ int const oldAxisOpp(MEDCoupling1SGTUMesh::HEXA8_FACE_PAIRS[2*pos0+(pos1+1)%2]);
mcIdType oldConn[8],myConn2[8]={-1,-1,-1,-1,-1,-1,-1,-1},myConn[8],edgeConn[2],allFacesTmp[24],neighTmp[6];
oldConn[0]=allFacesNodalConn[0]; oldConn[1]=allFacesNodalConn[1]; oldConn[2]=allFacesNodalConn[2]; oldConn[3]=allFacesNodalConn[3];
oldConn[4]=allFacesNodalConn[4]; oldConn[5]=allFacesNodalConn[7]; oldConn[6]=allFacesNodalConn[6]; oldConn[7]=allFacesNodalConn[5];
myConn2[i]=validConnQuad4NeighSide[(4-i+TAB2[validAxis])%4];
for(int i=0;i<4;i++)
{
- mcIdType nodeId(myConn2[i]);//the node id for which the opposite one will be found
+ mcIdType const nodeId(myConn2[i]);//the node id for which the opposite one will be found
bool found(false);
INTERP_KERNEL::NormalizedCellType typeOfSon;
for(int j=0;j<12 && !found;j++)
for(int i=0;i<6;i++)
{
cm.fillSonCellNodalConnectivity(i,myConn,allFacesTmp+4*i);
- std::set<mcIdType> s(allFacesTmp+4*i,allFacesTmp+4*i+4);
+ std::set<mcIdType> const s(allFacesTmp+4*i,allFacesTmp+4*i+4);
bool found(false);
for(int j=0;j<6 && !found;j++)
{
- std::set<mcIdType> s1(allFacesNodalConn+4*j,allFacesNodalConn+4*j+4);
+ std::set<mcIdType> const s1(allFacesNodalConn+4*j,allFacesNodalConn+4*j+4);
if(s==s1)
{
neighTmp[i]=myNeighbours[j];
DataArrayIdType *MEDCoupling1SGTUMesh::sortHexa8EachOther()
{
MCAuto<MEDCoupling1SGTUMesh> quads(explodeEachHexa8To6Quad4());//checks that only hexa8
- mcIdType nbHexa8=getNumberOfCells();
+ mcIdType const nbHexa8=getNumberOfCells();
mcIdType *cQuads(quads->getNodalConnectivity()->getPointer());
MCAuto<DataArrayIdType> neighOfQuads(DataArrayIdType::New()); neighOfQuads->alloc(nbHexa8*6,1); neighOfQuads->fillWithValue(-1);
mcIdType *ptNeigh(neighOfQuads->getPointer());
{//neighOfQuads tells for each face of each Quad8 which cell (if!=-1) is connected to this face.
MCAuto<MEDCouplingUMesh> quadsTmp(quads->buildUnstructured());
MCAuto<DataArrayIdType> ccSafe,cciSafe;
- DataArrayIdType *cc(0),*cci(0);
+ DataArrayIdType *cc(nullptr),*cci(nullptr);
quadsTmp->findCommonCells(3,0,cc,cci);
ccSafe=cc; cciSafe=cci;
const mcIdType *ccPtr(ccSafe->begin());
- mcIdType nbOfPair=cci->getNumberOfTuples()-1;
+ mcIdType const nbOfPair=cci->getNumberOfTuples()-1;
for(mcIdType i=0;i<nbOfPair;i++)
{ ptNeigh[ccPtr[2*i+0]]=ccPtr[2*i+1]/6; ptNeigh[ccPtr[2*i+1]]=ccPtr[2*i+0]/6; }
}
MCAuto<DataArrayIdType> ret(DataArrayIdType::New()); ret->alloc(0,1);
std::vector<bool> fetched(nbHexa8,false);
- std::vector<bool>::iterator it(std::find(fetched.begin(),fetched.end(),false));
+ auto it(std::find(fetched.begin(),fetched.end(),false));
while(it!=fetched.end())//it will turns as time as number of connected zones
{
- mcIdType cellId(ToIdType(std::distance(fetched.begin(),it)));//it is the seed of the connected zone.
+ mcIdType const cellId(ToIdType(std::distance(fetched.begin(),it)));//it is the seed of the connected zone.
std::set<mcIdType> s; s.insert(cellId);//s contains already organized.
while(!s.empty())
{
std::set<mcIdType> sNext;
- for(std::set<mcIdType>::const_iterator it0=s.begin();it0!=s.end();it0++)
+ for(long const it0 : s)
{
- fetched[*it0]=true;
- mcIdType *myNeighb(ptNeigh+6*(*it0));
+ fetched[it0]=true;
+ mcIdType *myNeighb(ptNeigh+6*it0);
for(int i=0;i<6;i++)
{
if(myNeighb[i]!=-1 && !fetched[myNeighb[i]])
{
- std::size_t pos(std::distance(HEXA8_FACE_PAIRS,std::find(HEXA8_FACE_PAIRS,HEXA8_FACE_PAIRS+6,i)));
+ std::size_t const pos(std::distance(HEXA8_FACE_PAIRS,std::find(HEXA8_FACE_PAIRS,HEXA8_FACE_PAIRS+6,i)));
std::size_t pos0(pos/2),pos1(pos%2);
- if(!UpdateHexa8Cell(HEXA8_FACE_PAIRS[2*pos0+(pos1+1)%2],*it0,cQuads+6*4*(*it0)+4*i,cQuads+6*4*myNeighb[i],ptNeigh+6*myNeighb[i]))
+ if(!UpdateHexa8Cell(HEXA8_FACE_PAIRS[2*pos0+(pos1+1)%2],it0,cQuads+6*4*it0+4*i,cQuads+6*4*myNeighb[i],ptNeigh+6*myNeighb[i]))
ret->pushBackSilent(myNeighb[i]);
fetched[myNeighb[i]]=true;
sNext.insert(myNeighb[i]);
if(!ret->empty())
{
mcIdType *conn(getNodalConnectivity()->getPointer());
- for(const mcIdType *pt=ret->begin();pt!=ret->end();pt++)
+ for(long const cellId : *ret)
{
- mcIdType cellId(*pt);
conn[8*cellId+0]=cQuads[24*cellId+0]; conn[8*cellId+1]=cQuads[24*cellId+1]; conn[8*cellId+2]=cQuads[24*cellId+2]; conn[8*cellId+3]=cQuads[24*cellId+3];
conn[8*cellId+4]=cQuads[24*cellId+4]; conn[8*cellId+5]=cQuads[24*cellId+7]; conn[8*cellId+6]=cQuads[24*cellId+6]; conn[8*cellId+7]=cQuads[24*cellId+5];
}
MCAuto<MEDCouplingUMesh> edges(thisu->explode3DMeshTo1D(d1Arr,di1Arr,rd1Arr,rdi1Arr));
const mcIdType *d1(d1Arr->begin());
MCAuto<DataArrayIdType> d2Arr(DataArrayIdType::New()),di2Arr(DataArrayIdType::New()),rd2Arr(DataArrayIdType::New()),rdi2Arr(DataArrayIdType::New());
- MCAuto<MEDCouplingUMesh> faces(thisu->buildDescendingConnectivity(d2Arr,di2Arr,rd2Arr,rdi2Arr)); thisu=0;
+ MCAuto<MEDCouplingUMesh> faces(thisu->buildDescendingConnectivity(d2Arr,di2Arr,rd2Arr,rdi2Arr)); thisu=nullptr;
const mcIdType *d2(d2Arr->begin()),*rdi2(rdi2Arr->begin());
MCAuto<DataArrayDouble> edgesBaryArr(edges->computeCellCenterOfMass()),facesBaryArr(faces->computeCellCenterOfMass()),baryArr(computeCellCenterOfMass());
const mcIdType nbOfNodes(getNumberOfNodes());
const mcIdType offset0=nbOfNodes+faces->getNumberOfCells();
const mcIdType offset1=offset0+edges->getNumberOfCells();
- edges=0; faces=0;
+ edges=nullptr; faces=nullptr;
std::vector<const DataArrayDouble *> v(4); v[0]=getCoords(); v[1]=facesBaryArr; v[2]=edgesBaryArr; v[3]=baryArr;
- MCAuto<DataArrayDouble> zeArr(DataArrayDouble::Aggregate(v)); baryArr=0; edgesBaryArr=0; facesBaryArr=0;
+ MCAuto<DataArrayDouble> zeArr(DataArrayDouble::Aggregate(v)); baryArr=nullptr; edgesBaryArr=nullptr; facesBaryArr=nullptr;
std::string name("DualOf_"); name+=getName();
MCAuto<MEDCoupling1DGTUMesh> ret(MEDCoupling1DGTUMesh::New(name,INTERP_KERNEL::NORM_POLYHED)); ret->setCoords(zeArr);
MCAuto<DataArrayIdType> cArr(DataArrayIdType::New()),ciArr(DataArrayIdType::New()); ciArr->alloc(nbOfNodes+1,1); ciArr->setIJ(0,0,0); cArr->alloc(0,1);
for(mcIdType i=0;i<nbOfNodes;i++,revNodI++)
{
- mcIdType nbOfCellsSharingNode(revNodI[1]-revNodI[0]);
+ mcIdType const nbOfCellsSharingNode(revNodI[1]-revNodI[0]);
if(nbOfCellsSharingNode==0)
{
std::ostringstream oss; oss << "MEDCoupling1SGTUMesh::computeDualMesh3D : Node #" << i << " is orphan !";
}
for(int j=0;j<nbOfCellsSharingNode;j++)
{
- mcIdType curCellId(revNod[revNodI[0]+j]);
+ mcIdType const curCellId(revNod[revNodI[0]+j]);
const mcIdType *connOfCurCell(nodal+4*curCellId);
- std::size_t nodePosInCurCell(std::distance(connOfCurCell,std::find(connOfCurCell,connOfCurCell+4,i)));
+ std::size_t const nodePosInCurCell(std::distance(connOfCurCell,std::find(connOfCurCell,connOfCurCell+4,i)));
if(j!=0) cArr->pushBackSilent(-1);
mcIdType tmp[14];
//
thisu->getReverseNodalConnectivity(revNodArr,revNodIArr);
const mcIdType *revNod(revNodArr->begin()),*revNodI(revNodIArr->begin()),*nodal(_conn->begin());
MCAuto<DataArrayIdType> d2Arr(DataArrayIdType::New()),di2Arr(DataArrayIdType::New()),rd2Arr(DataArrayIdType::New()),rdi2Arr(DataArrayIdType::New());
- MCAuto<MEDCouplingUMesh> edges(thisu->buildDescendingConnectivity(d2Arr,di2Arr,rd2Arr,rdi2Arr)); thisu=0;
+ MCAuto<MEDCouplingUMesh> edges(thisu->buildDescendingConnectivity(d2Arr,di2Arr,rd2Arr,rdi2Arr)); thisu=nullptr;
const mcIdType *d2(d2Arr->begin()),*rdi2(rdi2Arr->begin());
MCAuto<DataArrayDouble> edgesBaryArr(edges->computeCellCenterOfMass()),baryArr(computeCellCenterOfMass());
const mcIdType nbOfNodes(getNumberOfNodes()),offset0(nbOfNodes+edges->getNumberOfCells());
- edges=0;
+ edges=nullptr;
std::vector<const DataArrayDouble *> v(3); v[0]=getCoords(); v[1]=edgesBaryArr; v[2]=baryArr;
- MCAuto<DataArrayDouble> zeArr(DataArrayDouble::Aggregate(v)); baryArr=0; edgesBaryArr=0;
+ MCAuto<DataArrayDouble> zeArr(DataArrayDouble::Aggregate(v)); baryArr=nullptr; edgesBaryArr=nullptr;
std::string name("DualOf_"); name+=getName();
MCAuto<MEDCoupling1DGTUMesh> ret(MEDCoupling1DGTUMesh::New(name,INTERP_KERNEL::NORM_POLYGON)); ret->setCoords(zeArr);
MCAuto<DataArrayIdType> cArr(DataArrayIdType::New()),ciArr(DataArrayIdType::New()); ciArr->alloc(nbOfNodes+1,1); ciArr->setIJ(0,0,0); cArr->alloc(0,1);
for(mcIdType i=0;i<nbOfNodes;i++,revNodI++)
{
- mcIdType nbOfCellsSharingNode(revNodI[1]-revNodI[0]);
+ mcIdType const nbOfCellsSharingNode(revNodI[1]-revNodI[0]);
if(nbOfCellsSharingNode==0)
{
std::ostringstream oss; oss << "MEDCoupling1SGTUMesh::computeDualMesh2D : Node #" << i << " is orphan !";
std::vector< std::vector<mcIdType> > polyg;
for(int j=0;j<nbOfCellsSharingNode;j++)
{
- mcIdType curCellId(revNod[revNodI[0]+j]);
+ mcIdType const curCellId(revNod[revNodI[0]+j]);
const mcIdType *connOfCurCell(nodal+3*curCellId);
- std::size_t nodePosInCurCell(std::distance(connOfCurCell,std::find(connOfCurCell,connOfCurCell+4,i)));
+ std::size_t const nodePosInCurCell(std::distance(connOfCurCell,std::find(connOfCurCell,connOfCurCell+4,i)));
std::vector<mcIdType> locV(3);
locV[0]=d2[3*curCellId+DUAL_TRI_0[2*nodePosInCurCell+0]]+nbOfNodes; locV[1]=curCellId+offset0; locV[2]=d2[3*curCellId+DUAL_TRI_0[2*nodePosInCurCell+1]]+nbOfNodes;
polyg.push_back(locV);
if(rdi2[*edgeId+1]-rdi2[*edgeId]==1)
{
std::vector<mcIdType> locV2(2);
- int zeLocEdgeIdRel(DUAL_TRI_1[2*nodePosInCurCell+kk]);
+ int const zeLocEdgeIdRel(DUAL_TRI_1[2*nodePosInCurCell+kk]);
if(zeLocEdgeIdRel>0)
{ locV2[0]=d2[3*curCellId+zeLocEdgeIdRel-3]+nbOfNodes; locV2[1]=i; }
else
* \throw If \a this is not fully set (coordinates and connectivity).
* \throw If a cell in \a this has no valid nodeId.
*/
-DataArrayDouble *MEDCoupling1SGTUMesh::getBoundingBoxForBBTree(double arcDetEps) const
+DataArrayDouble *MEDCoupling1SGTUMesh::getBoundingBoxForBBTree(double /*arcDetEps*/) const
{
mcIdType spaceDim(getSpaceDimension()),nbOfCells(getNumberOfCells()),nbOfNodes(getNumberOfNodes()),nbOfNodesPerCell(getNumberOfNodesPerCell());
MCAuto<DataArrayDouble> ret(DataArrayDouble::New()); ret->alloc(nbOfCells,2*spaceDim);
int kk(0);
for(int j=0;j<nbOfNodesPerCell;j++,conn++)
{
- mcIdType nodeId(*conn);
+ mcIdType const nodeId(*conn);
if(nodeId>=0 && nodeId<nbOfNodes)
{
for(int k=0;k<spaceDim;k++)
{
checkFullyDefined();
MCAuto<MEDCouplingFieldDouble> ret(MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME));
- mcIdType nbCells=getNumberOfCells();
+ mcIdType const nbCells=getNumberOfCells();
MCAuto<DataArrayDouble> arr(DataArrayDouble::New());
arr->alloc(nbCells,1);
INTERP_KERNEL::AutoCppPtr<INTERP_KERNEL::DiameterCalculator> dc(_cm->buildInstanceOfDiameterCalulator(getSpaceDimension()));
}
MEDCoupling1DGTUMesh::MEDCoupling1DGTUMesh()
-{
-}
+= default;
MEDCoupling1DGTUMesh::MEDCoupling1DGTUMesh(const std::string& name, const INTERP_KERNEL::CellModel& cm):MEDCoupling1GTUMesh(name,cm)
{
if(!other)
throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::isEqualIfNotWhy : input other pointer is null !");
std::ostringstream oss; oss.precision(15);
- const MEDCoupling1DGTUMesh *otherC=dynamic_cast<const MEDCoupling1DGTUMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCoupling1DGTUMesh *>(other);
if(!otherC)
{
reason="mesh given in input is not castable in MEDCoupling1DGTUMesh !";
{
if(!other)
throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::isEqualWithoutConsideringStr : input other pointer is null !");
- const MEDCoupling1DGTUMesh *otherC=dynamic_cast<const MEDCoupling1DGTUMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCoupling1DGTUMesh *>(other);
if(!otherC)
return false;
if(!MEDCoupling1GTUMesh::isEqualWithoutConsideringStr(other,prec))
void MEDCoupling1DGTUMesh::checkFastEquivalWith(const MEDCouplingMesh *other, double prec) const
{
MEDCouplingPointSet::checkFastEquivalWith(other,prec);
- const MEDCoupling1DGTUMesh *otherC=dynamic_cast<const MEDCoupling1DGTUMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCoupling1DGTUMesh *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::checkFastEquivalWith : Two meshes are not unstructured with single dynamic geometric type !");
const DataArrayIdType *c1(_conn),*c2(otherC->_conn);
else
throw INTERP_KERNEL::Exception("Nodal connectivity array not defined !");
//
- mcIdType sz2(_conn->getNumberOfTuples());
+ mcIdType const sz2(_conn->getNumberOfTuples());
c1=_conn_indx;
if(c1)
{
}
else
throw INTERP_KERNEL::Exception("Nodal connectivity index array not defined !");
- mcIdType szOfC1Exp=_conn_indx->back();
+ mcIdType const szOfC1Exp=_conn_indx->back();
if(sz2<szOfC1Exp)
{
std::ostringstream oss; oss << "MEDCoupling1DGTUMesh::checkConsistencyOfConnectivity : The expected length of nodal connectivity array regarding index is " << szOfC1Exp << " but the actual size of it is " << c1->getNumberOfTuples() << " !";
checkConsistencyOfConnectivity();
}
-void MEDCoupling1DGTUMesh::checkConsistency(double eps) const
+void MEDCoupling1DGTUMesh::checkConsistency(double /*eps*/) const
{
checkConsistencyLight();
const DataArrayIdType *c1(_conn),*c2(_conn_indx);
if(!c2->isMonotonic(true))
throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::checkConsistency : the nodal connectivity index is expected to be increasing monotinic !");
//
- mcIdType nbOfTuples(c1->getNumberOfTuples());
- mcIdType nbOfNodes=getNumberOfNodes();
+ mcIdType const nbOfTuples(c1->getNumberOfTuples());
+ mcIdType const nbOfNodes=getNumberOfNodes();
const mcIdType *w(c1->begin());
for(mcIdType i=0;i<nbOfTuples;i++,w++)
{
if(getCellModelEnum()!=INTERP_KERNEL::NORM_POLYHED)
return _conn_indx->deltaShiftIndex();
// for polyhedrons
- mcIdType nbOfCells=_conn_indx->getNumberOfTuples()-1;
+ mcIdType const nbOfCells=_conn_indx->getNumberOfTuples()-1;
MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
ret->alloc(nbOfCells,1);
mcIdType *retPtr=ret->getPointer();
return ret.retn();
}
// for polyhedrons
- mcIdType nbOfCells=_conn_indx->getNumberOfTuples()-1;
+ mcIdType const nbOfCells=_conn_indx->getNumberOfTuples()-1;
MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
ret->alloc(nbOfCells,1);
mcIdType *retPtr=ret->getPointer();
{
checkConsistencyLight();
_conn_indx->checkMonotonic(true);
- mcIdType nbOfCells=_conn_indx->getNumberOfTuples()-1;
+ mcIdType const nbOfCells=_conn_indx->getNumberOfTuples()-1;
MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
ret->alloc(nbOfCells,1);
mcIdType *retPtr(ret->getPointer());
{
for(mcIdType i=0;i<nbOfCells;i++,retPtr++,ci++)
{
- std::set<mcIdType> s(c+ci[0],c+ci[1]);
+ std::set<mcIdType> const s(c+ci[0],c+ci[1]);
*retPtr=ToIdType(s.size());
}
}
void MEDCoupling1DGTUMesh::getNodeIdsOfCell(mcIdType cellId, std::vector<mcIdType>& conn) const
{
- mcIdType nbOfCells(getNumberOfCells());//performs checks
+ mcIdType const nbOfCells(getNumberOfCells());//performs checks
if(cellId<nbOfCells)
{
mcIdType strt=_conn_indx->getIJ(cellId,0),stp=_conn_indx->getIJ(cellId+1,0);
- mcIdType nbOfNodes=stp-strt;
+ mcIdType const nbOfNodes=stp-strt;
if(nbOfNodes<0)
throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::getNodeIdsOfCell : the index array is invalid ! Should be increasing monotonic !");
conn.resize(nbOfNodes);
mcIdType MEDCoupling1DGTUMesh::getNumberOfNodesInCell(mcIdType cellId) const
{
- mcIdType nbOfCells=getNumberOfCells();//performs checks
+ mcIdType const nbOfCells=getNumberOfCells();//performs checks
if(cellId>=0 && cellId<nbOfCells)
{
const mcIdType *conn(_conn->begin());
ret << "Single dynamic geometic type (" << _cm->getRepr() << ") unstructured mesh with name : \"" << getName() << "\"\n";
ret << "Description of mesh : \"" << getDescription() << "\"\n";
int tmpp1,tmpp2;
- double tt=getTime(tmpp1,tmpp2);
+ double const tt=getTime(tmpp1,tmpp2);
ret << "Time attached to the mesh [unit] : " << tt << " [" << getTimeUnit() << "]\n";
ret << "Iteration : " << tmpp1 << " Order : " << tmpp2 << "\n";
ret << "Mesh dimension : " << getMeshDimension() << "\nSpace dimension : ";
- if(_coords!=0)
+ if(_coords!=nullptr)
{
const int spaceDim=getSpaceDimension();
ret << spaceDim << "\nInfo attached on space dimension : ";
else
ret << msg0 << "\n";
ret << "Number of nodes : ";
- if(_coords!=0)
+ if(_coords!=nullptr)
ret << getNumberOfNodes() << "\n";
else
ret << msg0 << "\n";
}
if(!isOK)
return ret.str();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
const mcIdType *ci=_conn_indx->begin(),*c=_conn->begin();
for(mcIdType i=0;i<nbOfCells;i++,ci++)
{
DataArrayDouble *MEDCoupling1DGTUMesh::computeIsoBarycenterOfNodesPerCell() const
{
MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- int spaceDim=getSpaceDimension();
- mcIdType nbOfCells=getNumberOfCells();//checkConsistencyLight()
- mcIdType nbOfNodes=getNumberOfNodes();
+ int const spaceDim=getSpaceDimension();
+ mcIdType const nbOfCells=getNumberOfCells();//checkConsistencyLight()
+ mcIdType const nbOfNodes=getNumberOfNodes();
ret->alloc(nbOfCells,spaceDim);
double *ptToFill=ret->getPointer();
const double *coor=_coords->begin();
void MEDCoupling1DGTUMesh::renumberCells(const mcIdType *old2NewBg, bool check)
{
- mcIdType nbCells=getNumberOfCells();
+ mcIdType const nbCells=getNumberOfCells();
MCAuto<DataArrayIdType> o2n=DataArrayIdType::New();
o2n->useArray(old2NewBg,false,DeallocType::C_DEALLOC,nbCells,1);
if(check)
mcIdType *newC=newConn->getPointer(),*newCI=newConnI->getPointer();
for(mcIdType i=0;i<nbCells;i++)
{
- mcIdType newPos=o2nPtr[i];
- mcIdType sz=conni[i+1]-conni[i];
+ mcIdType const newPos=o2nPtr[i];
+ mcIdType const sz=conni[i+1]-conni[i];
if(sz>=0)
newCI[newPos]=sz;
else
//
for(mcIdType i=0;i<nbCells;i++,conni++)
{
- mcIdType newp=o2nPtr[i];
+ mcIdType const newp=o2nPtr[i];
std::copy(conn+conni[0],conn+conni[1],newC+newCI[newp]);
}
_conn=newConn;
{
if(other->getType()!=SINGLE_DYNAMIC_GEO_TYPE_UNSTRUCTURED)
throw INTERP_KERNEL::Exception("Merge of umesh only available with umesh single dynamic geo type each other !");
- const MEDCoupling1DGTUMesh *otherC=static_cast<const MEDCoupling1DGTUMesh *>(other);
+ const auto *otherC=static_cast<const MEDCoupling1DGTUMesh *>(other);
return Merge1DGTUMeshes(this,otherC);
}
MCAuto<MEDCouplingUMesh> ret=MEDCouplingUMesh::New(getName(),getMeshDimension());
ret->setCoords(getCoords());
const mcIdType *nodalConn=_conn->begin(),*nodalConnI=_conn_indx->begin();
- mcIdType nbCells=getNumberOfCells();//checkConsistencyLight
- mcIdType geoType=ToIdType(getCellModelEnum());
+ mcIdType const nbCells=getNumberOfCells();//checkConsistencyLight
+ mcIdType const geoType=ToIdType(getCellModelEnum());
MCAuto<DataArrayIdType> c=DataArrayIdType::New(); c->alloc(nbCells+_conn->getNumberOfTuples(),1);
MCAuto<DataArrayIdType> cI=DataArrayIdType::New(); cI->alloc(nbCells+1);
mcIdType *cPtr=c->getPointer(),*ciPtr=cI->getPointer();
ciPtr[0]=0;
for(mcIdType i=0;i<nbCells;i++,ciPtr++)
{
- mcIdType sz=nodalConnI[i+1]-nodalConnI[i];
+ mcIdType const sz=nodalConnI[i+1]-nodalConnI[i];
if(sz>=0)
{
*cPtr++=geoType;
/*!
* Do nothing for the moment, because there is no policy that allows to split polygons, polyhedrons ... into simplexes
*/
-DataArrayIdType *MEDCoupling1DGTUMesh::simplexize(int policy)
+DataArrayIdType *MEDCoupling1DGTUMesh::simplexize(int /*policy*/)
{
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
ret->alloc(nbOfCells,1);
ret->iota(0);
{
if(!other)
throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::shallowCopyConnectivityFrom : input pointer is null !");
- const MEDCoupling1DGTUMesh *otherC=dynamic_cast<const MEDCoupling1DGTUMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCoupling1DGTUMesh *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::shallowCopyConnectivityFrom : input pointer is not an MEDCoupling1DGTUMesh instance !");
setNodalConnectivity(otherC->getNodalConnectivity(),otherC->getNodalConnectivityIndex());
{
if(!other)
throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::mergeMyselfWithOnSameCoords : input other is null !");
- const MEDCoupling1DGTUMesh *otherC=dynamic_cast<const MEDCoupling1DGTUMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCoupling1DGTUMesh *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::mergeMyselfWithOnSameCoords : the input other mesh is not of type single statuc geo type unstructured !");
std::vector<const MEDCoupling1DGTUMesh *> ms(2);
checkConsistencyLight();
MCAuto<MEDCoupling1DGTUMesh> ret(new MEDCoupling1DGTUMesh(getName(),*_cm));
ret->setCoords(_coords);
- DataArrayIdType *c=0,*ci=0;
+ DataArrayIdType *c=nullptr,*ci=nullptr;
DataArrayIdType::ExtractFromIndexedArrays(begin,end,_conn,_conn_indx,c,ci);
MCAuto<DataArrayIdType> cSafe(c),ciSafe(ci);
ret->setNodalConnectivity(c,ci);
checkConsistencyLight();
MCAuto<MEDCoupling1DGTUMesh> ret(new MEDCoupling1DGTUMesh(getName(),*_cm));
ret->setCoords(_coords);
- DataArrayIdType *c=0,*ci=0;
+ DataArrayIdType *c=nullptr,*ci=nullptr;
DataArrayIdType::ExtractFromIndexedArraysSlice(start,end,step,_conn,_conn_indx,c,ci);
MCAuto<DataArrayIdType> cSafe(c),ciSafe(ci);
ret->setNodalConnectivity(c,ci);
void MEDCoupling1DGTUMesh::computeNodeIdsAlg(std::vector<bool>& nodeIdsInUse) const
{
checkConsistency();
- mcIdType sz(ToIdType(nodeIdsInUse.size()));
+ mcIdType const sz(ToIdType(nodeIdsInUse.size()));
for(const mcIdType *conn=_conn->begin();conn!=_conn->end();conn++)
{
if(*conn>=0 && *conn<sz)
void MEDCoupling1DGTUMesh::getReverseNodalConnectivity(DataArrayIdType *revNodal, DataArrayIdType *revNodalIndx) const
{
checkFullyDefined();
- mcIdType nbOfNodes=getNumberOfNodes();
- mcIdType *revNodalIndxPtr=(mcIdType *)malloc((nbOfNodes+1)*sizeof(mcIdType));
+ mcIdType const nbOfNodes=getNumberOfNodes();
+ auto *revNodalIndxPtr=(mcIdType *)malloc((nbOfNodes+1)*sizeof(mcIdType));
revNodalIndx->useArray(revNodalIndxPtr,true,DeallocType::C_DEALLOC,nbOfNodes+1,1);
std::fill(revNodalIndxPtr,revNodalIndxPtr+nbOfNodes+1,0);
const mcIdType *conn=_conn->begin(),*conni=_conn_indx->begin();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
mcIdType nbOfEltsInRevNodal=0;
for(mcIdType eltId=0;eltId<nbOfCells;eltId++)
{
- mcIdType nbOfNodesPerCell=conni[eltId+1]-conni[eltId];
+ mcIdType const nbOfNodesPerCell=conni[eltId+1]-conni[eltId];
if(nbOfNodesPerCell>=0)
{
for(mcIdType j=0;j<nbOfNodesPerCell;j++)
{
- mcIdType nodeId=conn[conni[eltId]+j];
+ mcIdType const nodeId=conn[conni[eltId]+j];
if(nodeId==-1) continue;
if(nodeId>=0 && nodeId<nbOfNodes)
{
}
std::transform(revNodalIndxPtr+1,revNodalIndxPtr+nbOfNodes+1,revNodalIndxPtr,revNodalIndxPtr+1,std::plus<mcIdType>());
conn=_conn->begin();
- mcIdType *revNodalPtr=(mcIdType *)malloc((nbOfEltsInRevNodal)*sizeof(mcIdType));
+ auto *revNodalPtr=(mcIdType *)malloc((nbOfEltsInRevNodal)*sizeof(mcIdType));
revNodal->useArray(revNodalPtr,true,DeallocType::C_DEALLOC,nbOfEltsInRevNodal,1);
std::fill(revNodalPtr,revNodalPtr+nbOfEltsInRevNodal,-1);
for(mcIdType eltId=0;eltId<nbOfCells;eltId++)
{
- mcIdType nbOfNodesPerCell=conni[eltId+1]-conni[eltId];
+ mcIdType const nbOfNodesPerCell=conni[eltId+1]-conni[eltId];
for(mcIdType j=0;j<nbOfNodesPerCell;j++)
{
- mcIdType nodeId=conn[conni[eltId]+j];
+ mcIdType const nodeId=conn[conni[eltId]+j];
if(nodeId!=-1)
*std::find_if(revNodalPtr+revNodalIndxPtr[nodeId],revNodalPtr+revNodalIndxPtr[nodeId+1],std::bind(std::equal_to<mcIdType>(),std::placeholders::_1,-1))=eltId;
}
throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::checkFullyDefined : part of this is not fully defined.");
}
-bool MEDCoupling1DGTUMesh::isEmptyMesh(const std::vector<mcIdType>& tinyInfo) const
+bool MEDCoupling1DGTUMesh::isEmptyMesh(const std::vector<mcIdType>& /*tinyInfo*/) const
{
throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::isEmptyMesh : not implemented yet !");
}
void MEDCoupling1DGTUMesh::getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const
{
int it,order;
- double time=getTime(it,order);
+ double const time=getTime(it,order);
tinyInfo.clear(); tinyInfoD.clear(); littleStrings.clear();
//
littleStrings.push_back(getName());
tinyInfoD.push_back(time);
}
-void MEDCoupling1DGTUMesh::resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const
+void MEDCoupling1DGTUMesh::resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& /*littleStrings*/) const
{
- std::vector<mcIdType> tinyInfo2(tinyInfo.begin()+9,tinyInfo.begin()+9+tinyInfo[6]);
- std::vector<mcIdType> tinyInfo1(tinyInfo.begin()+9+tinyInfo[6],tinyInfo.begin()+9+tinyInfo[6]+tinyInfo[7]);
- std::vector<mcIdType> tinyInfo12(tinyInfo.begin()+9+tinyInfo[6]+tinyInfo[7],tinyInfo.begin()+9+tinyInfo[6]+tinyInfo[7]+tinyInfo[8]);
+ std::vector<mcIdType> const tinyInfo2(tinyInfo.begin()+9,tinyInfo.begin()+9+tinyInfo[6]);
+ std::vector<mcIdType> const tinyInfo1(tinyInfo.begin()+9+tinyInfo[6],tinyInfo.begin()+9+tinyInfo[6]+tinyInfo[7]);
+ std::vector<mcIdType> const tinyInfo12(tinyInfo.begin()+9+tinyInfo[6]+tinyInfo[7],tinyInfo.begin()+9+tinyInfo[6]+tinyInfo[7]+tinyInfo[8]);
MCAuto<DataArrayIdType> p1(DataArrayIdType::New()); p1->resizeForUnserialization(tinyInfo1);
MCAuto<DataArrayIdType> p2(DataArrayIdType::New()); p2->resizeForUnserialization(tinyInfo12);
std::vector<const DataArrayIdType *> v(2); v[0]=p1; v[1]=p2;
void MEDCoupling1DGTUMesh::unserialization(const std::vector<double>& tinyInfoD, const std::vector<mcIdType>& tinyInfo, const DataArrayIdType *a1, DataArrayDouble *a2,
const std::vector<std::string>& littleStrings)
{
- INTERP_KERNEL::NormalizedCellType gt((INTERP_KERNEL::NormalizedCellType)tinyInfo[0]);
+ auto gt((INTERP_KERNEL::NormalizedCellType)tinyInfo[0]);
_cm=&INTERP_KERNEL::CellModel::GetCellModel(gt);
setName(littleStrings[0]);
setDescription(littleStrings[1]);
mcIdType sz0(tinyInfo[3]),sz1(tinyInfo[4]),sz2(tinyInfo[5]),sz3(tinyInfo[6]),sz4(tinyInfo[7]),sz5(tinyInfo[8]);
//
_coords=DataArrayDouble::New();
- std::vector<mcIdType> tinyInfo2(tinyInfo.begin()+9,tinyInfo.begin()+9+sz3);
+ std::vector<mcIdType> const tinyInfo2(tinyInfo.begin()+9,tinyInfo.begin()+9+sz3);
_coords->resizeForUnserialization(tinyInfo2);
std::copy(a2->begin(),a2->end(),_coords->getPointer());
_conn=DataArrayIdType::New();
- std::vector<mcIdType> tinyInfo3(tinyInfo.begin()+9+sz3,tinyInfo.begin()+9+sz3+sz4);
+ std::vector<mcIdType> const tinyInfo3(tinyInfo.begin()+9+sz3,tinyInfo.begin()+9+sz3+sz4);
_conn->resizeForUnserialization(tinyInfo3);
std::copy(a1->begin(),a1->begin()+_conn->getNbOfElems(),_conn->getPointer());
_conn_indx=DataArrayIdType::New();
- std::vector<mcIdType> tinyInfo4(tinyInfo.begin()+9+sz3+sz4,tinyInfo.begin()+9+sz3+sz4+sz5);
+ std::vector<mcIdType> const tinyInfo4(tinyInfo.begin()+9+sz3+sz4,tinyInfo.begin()+9+sz3+sz4+sz5);
_conn_indx->resizeForUnserialization(tinyInfo4);
std::copy(a1->begin()+_conn->getNbOfElems(),a1->end(),_conn_indx->getPointer());
- std::vector<std::string> littleStrings2(littleStrings.begin()+3,littleStrings.begin()+3+sz0);
+ std::vector<std::string> const littleStrings2(littleStrings.begin()+3,littleStrings.begin()+3+sz0);
_coords->finishUnserialization(tinyInfo2,littleStrings2);
- std::vector<std::string> littleStrings3(littleStrings.begin()+3+sz0,littleStrings.begin()+3+sz0+sz1);
+ std::vector<std::string> const littleStrings3(littleStrings.begin()+3+sz0,littleStrings.begin()+3+sz0+sz1);
_conn->finishUnserialization(tinyInfo3,littleStrings3);
- std::vector<std::string> littleStrings4(littleStrings.begin()+3+sz0+sz1,littleStrings.begin()+3+sz0+sz1+sz2);
+ std::vector<std::string> const littleStrings4(littleStrings.begin()+3+sz0+sz1,littleStrings.begin()+3+sz0+sz1+sz2);
_conn_indx->finishUnserialization(tinyInfo4,littleStrings4);
}
DataArrayIdType *MEDCoupling1DGTUMesh::computeFetchedNodeIds() const
{
checkConsistency();
- mcIdType nbNodes(getNumberOfNodes());
+ mcIdType const nbNodes(getNumberOfNodes());
std::vector<bool> fetchedNodes(nbNodes,false);
computeNodeIdsAlg(fetchedNodes);
- mcIdType sz(ToIdType(std::count(fetchedNodes.begin(),fetchedNodes.end(),true)));
+ mcIdType const sz(ToIdType(std::count(fetchedNodes.begin(),fetchedNodes.end(),true)));
MCAuto<DataArrayIdType> ret(DataArrayIdType::New()); ret->alloc(sz,1);
mcIdType *retPtr(ret->getPointer());
for(mcIdType i=0;i<nbNodes;i++)
DataArrayIdType *MEDCoupling1DGTUMesh::getNodeIdsInUse(mcIdType& nbrOfNodesInUse) const
{
nbrOfNodesInUse=-1;
- mcIdType nbOfNodes=getNumberOfNodes();
- mcIdType nbOfCells=getNumberOfCells();//checkConsistencyLight
+ mcIdType const nbOfNodes=getNumberOfNodes();
+ mcIdType const nbOfCells=getNumberOfCells();//checkConsistencyLight
MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
ret->alloc(nbOfNodes,1);
mcIdType *traducer=ret->getPointer();
const mcIdType *conn=_conn->begin(),*conni(_conn_indx->begin());
for(mcIdType i=0;i<nbOfCells;i++,conni++)
{
- mcIdType nbNodesPerCell=conni[1]-conni[0];
+ mcIdType const nbNodesPerCell=conni[1]-conni[0];
for(mcIdType j=0;j<nbNodesPerCell;j++)
{
- mcIdType nodeId=conn[conni[0]+j];
+ mcIdType const nodeId=conn[conni[0]+j];
if(nodeId==-1) continue;
if(nodeId>=0 && nodeId<nbOfNodes)
traducer[nodeId]=1;
{
getNumberOfCells();//only to check that all is well defined.
//
- mcIdType nbOfTuples(_conn->getNumberOfTuples());
+ mcIdType const nbOfTuples(_conn->getNumberOfTuples());
mcIdType *pt(_conn->getPointer());
for(mcIdType i=0;i<nbOfTuples;i++,pt++)
{
*/
void MEDCoupling1DGTUMesh::fillCellIdsToKeepFromNodeIds(const mcIdType *begin, const mcIdType *end, bool fullyIn, DataArrayIdType *&cellIdsKeptArr) const
{
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
MCAuto<DataArrayIdType> cellIdsKept=DataArrayIdType::New(); cellIdsKept->alloc(0,1);
mcIdType tmp=-1;
mcIdType sz=_conn->getMaxValue(tmp); sz=std::max(sz,ToIdType(0))+1;
for(mcIdType i=0;i<nbOfCells;i++,conni++)
{
int ref=0,nbOfHit=0;
- mcIdType nbNodesPerCell=conni[1]-conni[0];
+ mcIdType const nbNodesPerCell=conni[1]-conni[0];
if(nbNodesPerCell>=0)
{
for(mcIdType j=0;j<nbNodesPerCell;j++)
{
- mcIdType nodeId=conn[conni[0]+j];
+ mcIdType const nodeId=conn[conni[0]+j];
if(nodeId>=0)
{
ref++;
*/
void MEDCoupling1DGTUMesh::insertNextCell(const mcIdType *nodalConnOfCellBg, const mcIdType *nodalConnOfCellEnd)
{
- std::size_t sz(std::distance(nodalConnOfCellBg,nodalConnOfCellEnd));
+ std::size_t const sz(std::distance(nodalConnOfCellBg,nodalConnOfCellEnd));
DataArrayIdType *c(_conn),*c2(_conn_indx);
if(c && c2)
{
- mcIdType pos=c2->back();
+ mcIdType const pos=c2->back();
if(pos==c->getNumberOfTuples())
{
c->pushBackValsSilent(nodalConnOfCellBg,nodalConnOfCellEnd);
MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::copyWithNodalConnectivityPacked(bool& isShallowCpyOfNodalConnn) const
{
MCAuto<MEDCoupling1DGTUMesh> ret(new MEDCoupling1DGTUMesh(getName(),*_cm));
- DataArrayIdType *nc=0,*nci=0;
+ DataArrayIdType *nc=nullptr,*nci=nullptr;
isShallowCpyOfNodalConnn=retrievePackedNodalConnectivity(nc,nci);
MCAuto<DataArrayIdType> ncs(nc),ncis(nci);
ret->_conn=ncs; ret->_conn_indx=ncis;
MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::Merge1DGTUMeshes(std::vector<const MEDCoupling1DGTUMesh *>& a)
{
- std::size_t sz=a.size();
+ std::size_t const sz=a.size();
if(sz==0)
return Merge1DGTUMeshesLL(a);
for(std::size_t ii=0;ii<sz;ii++)
* \throw If \a this is not fully set (coordinates and connectivity).
* \throw If a cell in \a this has no valid nodeId.
*/
-DataArrayDouble *MEDCoupling1DGTUMesh::getBoundingBoxForBBTree(double arcDetEps) const
+DataArrayDouble *MEDCoupling1DGTUMesh::getBoundingBoxForBBTree(double /*arcDetEps*/) const
{
checkFullyDefined();
mcIdType spaceDim(getSpaceDimension()),nbOfCells(getNumberOfCells()),nbOfNodes(getNumberOfNodes());
const mcIdType *conn(_conn->getConstPointer()),*connI(_conn_indx->getConstPointer());
for(mcIdType i=0;i<nbOfCells;i++)
{
- mcIdType offset=connI[i];
+ mcIdType const offset=connI[i];
mcIdType nbOfNodesForCell(connI[i+1]-offset),kk(0);
for(mcIdType j=0;j<nbOfNodesForCell;j++)
{
- mcIdType nodeId=conn[offset+j];
+ mcIdType const nodeId=conn[offset+j];
if(nodeId>=0 && nodeId<nbOfNodes)
{
for(int k=0;k<spaceDim;k++)
{
checkConsistencyOfConnectivity();
INTERP_KERNEL::AutoCppPtr<INTERP_KERNEL::OrientationInverter> oi(INTERP_KERNEL::OrientationInverter::BuildInstanceFrom(getCellModelEnum()));
- mcIdType nbCells=getNumberOfCells();
+ mcIdType const nbCells=getNumberOfCells();
const mcIdType *connI(_conn_indx->begin());
mcIdType *conn(_conn->getPointer());
for(mcIdType i=0;i<nbCells;i++)
if(sz1==0)
throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::AggregateNodalConnAndShiftNodeIds : empty vectors in input !");
mcIdType nbOfTuples=0;
- for(std::vector<const DataArrayIdType *>::const_iterator it=nodalConns.begin();it!=nodalConns.end();it++)
+ for(auto nodalConn : nodalConns)
{
- if(!(*it))
+ if(!nodalConn)
throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::AggregateNodalConnAndShiftNodeIds : presence of null pointer in input vector !");
- if(!(*it)->isAllocated())
+ if(!nodalConn->isAllocated())
throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::AggregateNodalConnAndShiftNodeIds : presence of non allocated array in input vector !");
- if((*it)->getNumberOfComponents()!=1)
+ if(nodalConn->getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::AggregateNodalConnAndShiftNodeIds : presence of array with not exactly one component !");
- nbOfTuples+=(*it)->getNumberOfTuples();
+ nbOfTuples+=nodalConn->getNumberOfTuples();
}
MCAuto<DataArrayIdType> ret=DataArrayIdType::New(); ret->alloc(nbOfTuples,1);
mcIdType *pt=ret->getPointer();
mcIdType i=0;
- for(std::vector<const DataArrayIdType *>::const_iterator it=nodalConns.begin();it!=nodalConns.end();it++,i++)
+ for(auto it=nodalConns.begin();it!=nodalConns.end();it++,i++)
{
- mcIdType curNbt=(*it)->getNumberOfTuples();
+ mcIdType const curNbt=(*it)->getNumberOfTuples();
const mcIdType *inPt=(*it)->begin();
- mcIdType offset=offsetInNodeIdsPerElt[i];
+ mcIdType const offset=offsetInNodeIdsPerElt[i];
for(mcIdType j=0;j<curNbt;j++,pt++)
{
if(inPt[j]!=-1)
{
if(!m)
throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::New : input mesh is null !");
- std::set<INTERP_KERNEL::NormalizedCellType> gts(m->getAllGeoTypes());
+ std::set<INTERP_KERNEL::NormalizedCellType> const gts(m->getAllGeoTypes());
if(gts.size()!=1)
throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::New : input mesh must have exactly one geometric type !");
- mcIdType geoType(ToIdType(*gts.begin()));
+ mcIdType const geoType(ToIdType(*gts.begin()));
MCAuto<MEDCoupling1DGTUMesh> ret(MEDCoupling1DGTUMesh::New(m->getName(),*gts.begin()));
ret->setCoords(m->getCoords()); ret->setDescription(m->getDescription());
- mcIdType nbCells=m->getNumberOfCells();
+ mcIdType const nbCells=m->getNumberOfCells();
MCAuto<DataArrayIdType> conn(DataArrayIdType::New()),connI(DataArrayIdType::New());
conn->alloc(m->getNodalConnectivityArrayLen()-nbCells,1); connI->alloc(nbCells+1,1);
mcIdType *c(conn->getPointer()),*ci(connI->getPointer()); *ci=0;
#ifndef __PARAMEDMEM_MEDCOUPLING1GTUMESH_HXX__
#define __PARAMEDMEM_MEDCOUPLING1GTUMESH_HXX__
+#include "InterpKernelHashMap.hxx"
#include "MEDCoupling.hxx"
#include "MCType.hxx"
+#include "MEDCouplingMesh.hxx"
#include "MEDCouplingPointSet.hxx"
#include "MEDCouplingMemArray.hxx"
#include "MCAuto.hxx"
#include "CellModel.hxx"
+#include <string>
+#include "NormalizedGeometricTypes"
+#include <set>
+#include <vector>
+#include <ostream>
+#include <cstddef>
+#include "MEDCouplingRefCountObject.hxx"
+#include <map>
namespace MEDCoupling
{
MEDCOUPLING_EXPORT static MEDCoupling1GTUMesh *New(const MEDCouplingUMesh *m);
MEDCOUPLING_EXPORT const INTERP_KERNEL::CellModel& getCellModel() const;
MEDCOUPLING_EXPORT INTERP_KERNEL::NormalizedCellType getCellModelEnum() const;
- MEDCOUPLING_EXPORT int getMeshDimension() const;
- MEDCOUPLING_EXPORT DataArrayIdType *giveCellsWithType(INTERP_KERNEL::NormalizedCellType type) const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType type) const;
- MEDCOUPLING_EXPORT INTERP_KERNEL::NormalizedCellType getTypeOfCell(mcIdType cellId) const;
- MEDCOUPLING_EXPORT std::set<INTERP_KERNEL::NormalizedCellType> getAllGeoTypes() const;
- MEDCOUPLING_EXPORT std::vector<mcIdType> getDistributionOfTypes() const;
- MEDCOUPLING_EXPORT void splitProfilePerType(const DataArrayIdType *profile, std::vector<mcIdType>& code, std::vector<DataArrayIdType *>& idsInPflPerType, std::vector<DataArrayIdType *>& idsPerType, bool smartPflKiller=true) const;
- MEDCOUPLING_EXPORT DataArrayIdType *checkTypeConsistencyAndContig(const std::vector<mcIdType>& code, const std::vector<const DataArrayIdType *>& idsPerType) const;
- MEDCOUPLING_EXPORT void writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData, DataArrayByte *byteData) const;
- MEDCOUPLING_EXPORT std::string getVTKDataSetType() const;
- MEDCOUPLING_EXPORT std::string getVTKFileExtension() const;
+ MEDCOUPLING_EXPORT int getMeshDimension() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *giveCellsWithType(INTERP_KERNEL::NormalizedCellType type) const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType type) const override;
+ MEDCOUPLING_EXPORT INTERP_KERNEL::NormalizedCellType getTypeOfCell(mcIdType cellId) const override;
+ MEDCOUPLING_EXPORT std::set<INTERP_KERNEL::NormalizedCellType> getAllGeoTypes() const override;
+ MEDCOUPLING_EXPORT std::vector<mcIdType> getDistributionOfTypes() const override;
+ MEDCOUPLING_EXPORT void splitProfilePerType(const DataArrayIdType *profile, std::vector<mcIdType>& code, std::vector<DataArrayIdType *>& idsInPflPerType, std::vector<DataArrayIdType *>& idsPerType, bool smartPflKiller=true) const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *checkTypeConsistencyAndContig(const std::vector<mcIdType>& code, const std::vector<const DataArrayIdType *>& idsPerType) const override;
+ MEDCOUPLING_EXPORT void writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData, DataArrayByte *byteData) const override;
+ MEDCOUPLING_EXPORT std::string getVTKDataSetType() const override;
+ MEDCOUPLING_EXPORT std::string getVTKFileExtension() const override;
//
- MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
+ MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
MEDCOUPLING_EXPORT mcIdType getNodalConnectivityLength() const;
- MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const;
- MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const;
- MEDCOUPLING_EXPORT void checkConsistencyLight() const;
- MEDCOUPLING_EXPORT DataArrayDouble *computeCellCenterOfMass() const;
- MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureField(bool isAbs) const;
- MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureFieldOnNode(bool isAbs) const;
- MEDCOUPLING_EXPORT mcIdType getCellContainingPoint(const double *pos, double eps) const;
+ MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const override;
+ MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const override;
+ MEDCOUPLING_EXPORT void checkConsistencyLight() const override;
+ MEDCOUPLING_EXPORT DataArrayDouble *computeCellCenterOfMass() const override;
+ MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureField(bool isAbs) const override;
+ MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureFieldOnNode(bool isAbs) const override;
+ MEDCOUPLING_EXPORT mcIdType getCellContainingPoint(const double *pos, double eps) const override;
MEDCOUPLING_EXPORT void getCellsContainingPoint(const double *pos, double eps, std::vector<mcIdType>& elts) const override;
MEDCOUPLING_EXPORT void getCellsContainingPoints(const double *pos, mcIdType nbOfPoints, double eps, MCAuto<DataArrayIdType>& elts, MCAuto<DataArrayIdType>& eltsIndex) const override;
- MEDCOUPLING_EXPORT MEDCouplingFieldDouble *buildOrthogonalField() const;
- MEDCOUPLING_EXPORT DataArrayIdType *getCellsInBoundingBox(const double *bbox, double eps) const;
- MEDCOUPLING_EXPORT DataArrayIdType *getCellsInBoundingBox(const INTERP_KERNEL::DirectedBoundingBox& bbox, double eps);
- MEDCOUPLING_EXPORT MEDCouplingPointSet *buildFacePartOfMySelfNode(const mcIdType *start, const mcIdType *end, bool fullyIn) const;
- MEDCOUPLING_EXPORT DataArrayIdType *findBoundaryNodes() const;
- MEDCOUPLING_EXPORT MEDCouplingPointSet *buildBoundaryMesh(bool keepCoords) const;
- MEDCOUPLING_EXPORT void findCommonCells(int compType, mcIdType startCellId, DataArrayIdType *& commonCellsArr, DataArrayIdType *& commonCellsIArr) const;
+ MEDCOUPLING_EXPORT MEDCouplingFieldDouble *buildOrthogonalField() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *getCellsInBoundingBox(const double *bbox, double eps) const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *getCellsInBoundingBox(const INTERP_KERNEL::DirectedBoundingBox& bbox, double eps) override;
+ MEDCOUPLING_EXPORT MEDCouplingPointSet *buildFacePartOfMySelfNode(const mcIdType *start, const mcIdType *end, bool fullyIn) const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *findBoundaryNodes() const override;
+ MEDCOUPLING_EXPORT MEDCouplingPointSet *buildBoundaryMesh(bool keepCoords) const override;
+ MEDCOUPLING_EXPORT void findCommonCells(int compType, mcIdType startCellId, DataArrayIdType *& commonCellsArr, DataArrayIdType *& commonCellsIArr) const override;
MEDCOUPLING_EXPORT static MEDCouplingUMesh *AggregateOnSameCoordsToUMesh(const std::vector< const MEDCoupling1GTUMesh *>& parts);
public:
MEDCOUPLING_EXPORT virtual void allocateCells(mcIdType nbOfCells=0) = 0;
MEDCOUPLING_EXPORT static MEDCoupling1SGTUMesh *New();
MEDCOUPLING_EXPORT std::string getClassName() const override { return std::string("MEDCoupling1SGTUMesh"); }
// Copy methods
- MEDCOUPLING_EXPORT MEDCoupling1SGTUMesh *clone(bool recDeepCpy) const;
- MEDCOUPLING_EXPORT MEDCoupling1SGTUMesh *deepCopy() const;
- MEDCOUPLING_EXPORT MEDCoupling1SGTUMesh *deepCopyConnectivityOnly() const;
+ MEDCOUPLING_EXPORT MEDCoupling1SGTUMesh *clone(bool recDeepCpy) const override;
+ MEDCOUPLING_EXPORT MEDCoupling1SGTUMesh *deepCopy() const override;
+ MEDCOUPLING_EXPORT MEDCoupling1SGTUMesh *deepCopyConnectivityOnly() const override;
// overload of TimeLabel and RefCountObject
- MEDCOUPLING_EXPORT void updateTime() const;
- MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDCOUPLING_EXPORT void updateTime() const override;
+ MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
// overload of MEDCouplingMesh
- MEDCOUPLING_EXPORT MEDCouplingMeshType getType() const { return SINGLE_STATIC_GEO_TYPE_UNSTRUCTURED; }
+ MEDCOUPLING_EXPORT MEDCouplingMeshType getType() const override { return SINGLE_STATIC_GEO_TYPE_UNSTRUCTURED; }
- MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const;
- MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const;
- MEDCOUPLING_EXPORT void checkFastEquivalWith(const MEDCouplingMesh *other, double prec) const;
- MEDCOUPLING_EXPORT void checkConsistencyLight() const;
- MEDCOUPLING_EXPORT void checkConsistency(double eps=1e-12) const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfCells() const;
- MEDCOUPLING_EXPORT DataArrayIdType *computeNbOfNodesPerCell() const;
- MEDCOUPLING_EXPORT DataArrayIdType *computeNbOfFacesPerCell() const;
- MEDCOUPLING_EXPORT DataArrayIdType *computeEffectiveNbOfNodesPerCell() const;
- MEDCOUPLING_EXPORT void getNodeIdsOfCell(mcIdType cellId, std::vector<mcIdType>& conn) const;
- MEDCOUPLING_EXPORT std::string simpleRepr() const;
- MEDCOUPLING_EXPORT std::string advancedRepr() const;
- MEDCOUPLING_EXPORT DataArrayDouble *computeIsoBarycenterOfNodesPerCell() const;
- MEDCOUPLING_EXPORT void renumberCells(const mcIdType *old2NewBg, bool check=true);
- MEDCOUPLING_EXPORT MEDCouplingMesh *mergeMyselfWith(const MEDCouplingMesh *other) const;
- MEDCOUPLING_EXPORT MEDCouplingUMesh *buildUnstructured() const;
- MEDCOUPLING_EXPORT DataArrayIdType *simplexize(int policy);
- MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const;
+ MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const override;
+ MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const override;
+ MEDCOUPLING_EXPORT void checkFastEquivalWith(const MEDCouplingMesh *other, double prec) const override;
+ MEDCOUPLING_EXPORT void checkConsistencyLight() const override;
+ MEDCOUPLING_EXPORT void checkConsistency(double eps=1e-12) const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfCells() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *computeNbOfNodesPerCell() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *computeNbOfFacesPerCell() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *computeEffectiveNbOfNodesPerCell() const override;
+ MEDCOUPLING_EXPORT void getNodeIdsOfCell(mcIdType cellId, std::vector<mcIdType>& conn) const override;
+ MEDCOUPLING_EXPORT std::string simpleRepr() const override;
+ MEDCOUPLING_EXPORT std::string advancedRepr() const override;
+ MEDCOUPLING_EXPORT DataArrayDouble *computeIsoBarycenterOfNodesPerCell() const override;
+ MEDCOUPLING_EXPORT void renumberCells(const mcIdType *old2NewBg, bool check=true) override;
+ MEDCOUPLING_EXPORT MEDCouplingMesh *mergeMyselfWith(const MEDCouplingMesh *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingUMesh *buildUnstructured() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *simplexize(int policy) override;
+ MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const override;
// overload of MEDCouplingPointSet
- MEDCOUPLING_EXPORT void shallowCopyConnectivityFrom(const MEDCouplingPointSet *other);
- MEDCOUPLING_EXPORT MEDCouplingPointSet *mergeMyselfWithOnSameCoords(const MEDCouplingPointSet *other) const;
- MEDCOUPLING_EXPORT MEDCouplingPointSet *buildPartOfMySelfKeepCoords(const mcIdType *begin, const mcIdType *end) const;
- MEDCOUPLING_EXPORT MEDCouplingPointSet *buildPartOfMySelfKeepCoordsSlice(mcIdType start, mcIdType end, mcIdType step) const;
- MEDCOUPLING_EXPORT void computeNodeIdsAlg(std::vector<bool>& nodeIdsInUse) const;
- MEDCOUPLING_EXPORT void getReverseNodalConnectivity(DataArrayIdType *revNodal, DataArrayIdType *revNodalIndx) const;
- MEDCOUPLING_EXPORT void checkFullyDefined() const;
- MEDCOUPLING_EXPORT bool isEmptyMesh(const std::vector<mcIdType>& tinyInfo) const;
- MEDCOUPLING_EXPORT DataArrayIdType *computeFetchedNodeIds() const;
- MEDCOUPLING_EXPORT DataArrayIdType *getNodeIdsInUse(mcIdType& nbrOfNodesInUse) const;
- MEDCOUPLING_EXPORT void renumberNodesWithOffsetInConn(mcIdType offset);
- MEDCOUPLING_EXPORT void renumberNodesInConn(const INTERP_KERNEL::HashMap<mcIdType,mcIdType>& newNodeNumbersO2N);
+ MEDCOUPLING_EXPORT void shallowCopyConnectivityFrom(const MEDCouplingPointSet *other) override;
+ MEDCOUPLING_EXPORT MEDCouplingPointSet *mergeMyselfWithOnSameCoords(const MEDCouplingPointSet *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingPointSet *buildPartOfMySelfKeepCoords(const mcIdType *begin, const mcIdType *end) const override;
+ MEDCOUPLING_EXPORT MEDCouplingPointSet *buildPartOfMySelfKeepCoordsSlice(mcIdType start, mcIdType end, mcIdType step) const override;
+ MEDCOUPLING_EXPORT void computeNodeIdsAlg(std::vector<bool>& nodeIdsInUse) const override;
+ MEDCOUPLING_EXPORT void getReverseNodalConnectivity(DataArrayIdType *revNodal, DataArrayIdType *revNodalIndx) const override;
+ MEDCOUPLING_EXPORT void checkFullyDefined() const override;
+ MEDCOUPLING_EXPORT bool isEmptyMesh(const std::vector<mcIdType>& tinyInfo) const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *computeFetchedNodeIds() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *getNodeIdsInUse(mcIdType& nbrOfNodesInUse) const override;
+ MEDCOUPLING_EXPORT void renumberNodesWithOffsetInConn(mcIdType offset) override;
+ MEDCOUPLING_EXPORT void renumberNodesInConn(const INTERP_KERNEL::HashMap<mcIdType,mcIdType>& newNodeNumbersO2N) override;
MEDCOUPLING_EXPORT void renumberNodesInConn(const std::map<mcIdType,mcIdType>& newNodeNumbersO2N) override;
- MEDCOUPLING_EXPORT void renumberNodesInConn(const mcIdType *newNodeNumbersO2N);
- MEDCOUPLING_EXPORT void fillCellIdsToKeepFromNodeIds(const mcIdType *begin, const mcIdType *end, bool fullyIn, DataArrayIdType *&cellIdsKeptArr) const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfNodesInCell(mcIdType cellId) const;
- MEDCOUPLING_EXPORT DataArrayDouble *getBoundingBoxForBBTree(double arcDetEps=1e-12) const;
- MEDCOUPLING_EXPORT MEDCouplingFieldDouble *computeDiameterField() const;
- MEDCOUPLING_EXPORT void invertOrientationOfAllCells();
+ MEDCOUPLING_EXPORT void renumberNodesInConn(const mcIdType *newNodeNumbersO2N) override;
+ MEDCOUPLING_EXPORT void fillCellIdsToKeepFromNodeIds(const mcIdType *begin, const mcIdType *end, bool fullyIn, DataArrayIdType *&cellIdsKeptArr) const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfNodesInCell(mcIdType cellId) const override;
+ MEDCOUPLING_EXPORT DataArrayDouble *getBoundingBoxForBBTree(double arcDetEps=1e-12) const override;
+ MEDCOUPLING_EXPORT MEDCouplingFieldDouble *computeDiameterField() const override;
+ MEDCOUPLING_EXPORT void invertOrientationOfAllCells() override;
// overload of MEDCoupling1GTUMesh
- MEDCOUPLING_EXPORT void checkConsistencyOfConnectivity() const;
- MEDCOUPLING_EXPORT void allocateCells(mcIdType nbOfCells=0);
- MEDCOUPLING_EXPORT void insertNextCell(const mcIdType *nodalConnOfCellBg, const mcIdType *nodalConnOfCellEnd);
+ MEDCOUPLING_EXPORT void checkConsistencyOfConnectivity() const override;
+ MEDCOUPLING_EXPORT void allocateCells(mcIdType nbOfCells=0) override;
+ MEDCOUPLING_EXPORT void insertNextCell(const mcIdType *nodalConnOfCellBg, const mcIdType *nodalConnOfCellEnd) override;
public://specific
MEDCOUPLING_EXPORT void setNodalConnectivity(DataArrayIdType *nodalConn);
- MEDCOUPLING_EXPORT DataArrayIdType *getNodalConnectivity() const;
+ MEDCOUPLING_EXPORT DataArrayIdType *getNodalConnectivity() const override;
MEDCOUPLING_EXPORT mcIdType getNumberOfNodesPerCell() const;
MEDCOUPLING_EXPORT static MEDCoupling1SGTUMesh *Merge1SGTUMeshes(const MEDCoupling1SGTUMesh *mesh1, const MEDCoupling1SGTUMesh *mesh2);
MEDCOUPLING_EXPORT static MEDCoupling1SGTUMesh *Merge1SGTUMeshes(std::vector<const MEDCoupling1SGTUMesh *>& a);
MEDCOUPLING_EXPORT MCAuto<DataArrayDouble> computeTriangleHeight() const;
MEDCOUPLING_EXPORT MEDCouplingCMesh *structurizeMe(DataArrayIdType *& cellPerm, DataArrayIdType *& nodePerm, double eps=1e-12) const;
public://serialization
- MEDCOUPLING_EXPORT void getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const;
- MEDCOUPLING_EXPORT void resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const;
- MEDCOUPLING_EXPORT void serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const;
+ MEDCOUPLING_EXPORT void getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const override;
+ MEDCOUPLING_EXPORT void resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const override;
+ MEDCOUPLING_EXPORT void serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const override;
MEDCOUPLING_EXPORT void unserialization(const std::vector<double>& tinyInfoD, const std::vector<mcIdType>& tinyInfo, const DataArrayIdType *a1, DataArrayDouble *a2,
- const std::vector<std::string>& littleStrings);
+ const std::vector<std::string>& littleStrings) override;
private:
MEDCoupling1SGTUMesh(const std::string& name, const INTERP_KERNEL::CellModel& cm);
MEDCoupling1SGTUMesh(const MEDCoupling1SGTUMesh& other, bool recDeepCpy);
MEDCOUPLING_EXPORT static MEDCoupling1DGTUMesh *New();
MEDCOUPLING_EXPORT std::string getClassName() const override { return std::string("MEDCoupling1DGTUMesh"); }
// Copy methods
- MEDCOUPLING_EXPORT MEDCoupling1DGTUMesh *clone(bool recDeepCpy) const;
- MEDCOUPLING_EXPORT MEDCoupling1DGTUMesh *deepCopy() const;
- MEDCOUPLING_EXPORT MEDCoupling1DGTUMesh *deepCopyConnectivityOnly() const;
+ MEDCOUPLING_EXPORT MEDCoupling1DGTUMesh *clone(bool recDeepCpy) const override;
+ MEDCOUPLING_EXPORT MEDCoupling1DGTUMesh *deepCopy() const override;
+ MEDCOUPLING_EXPORT MEDCoupling1DGTUMesh *deepCopyConnectivityOnly() const override;
// overload of TimeLabel and RefCountObject
- MEDCOUPLING_EXPORT void updateTime() const;
- MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDCOUPLING_EXPORT void updateTime() const override;
+ MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
// overload of MEDCouplingMesh
- MEDCOUPLING_EXPORT MEDCouplingMeshType getType() const { return SINGLE_DYNAMIC_GEO_TYPE_UNSTRUCTURED; }
- MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const;
- MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const;
- MEDCOUPLING_EXPORT void checkFastEquivalWith(const MEDCouplingMesh *other, double prec) const;
- MEDCOUPLING_EXPORT void checkConsistencyLight() const;
- MEDCOUPLING_EXPORT void checkConsistency(double eps=1e-12) const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfCells() const;
- MEDCOUPLING_EXPORT DataArrayIdType *computeNbOfNodesPerCell() const;
- MEDCOUPLING_EXPORT DataArrayIdType *computeNbOfFacesPerCell() const;
- MEDCOUPLING_EXPORT DataArrayIdType *computeEffectiveNbOfNodesPerCell() const;
- MEDCOUPLING_EXPORT void getNodeIdsOfCell(mcIdType cellId, std::vector<mcIdType>& conn) const;
- MEDCOUPLING_EXPORT std::string simpleRepr() const;
- MEDCOUPLING_EXPORT std::string advancedRepr() const;
- MEDCOUPLING_EXPORT DataArrayDouble *computeIsoBarycenterOfNodesPerCell() const;
- MEDCOUPLING_EXPORT void renumberCells(const mcIdType *old2NewBg, bool check=true);
- MEDCOUPLING_EXPORT MEDCouplingMesh *mergeMyselfWith(const MEDCouplingMesh *other) const;
- MEDCOUPLING_EXPORT MEDCouplingUMesh *buildUnstructured() const;
- MEDCOUPLING_EXPORT DataArrayIdType *simplexize(int policy);
- MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const;
+ MEDCOUPLING_EXPORT MEDCouplingMeshType getType() const override { return SINGLE_DYNAMIC_GEO_TYPE_UNSTRUCTURED; }
+ MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const override;
+ MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const override;
+ MEDCOUPLING_EXPORT void checkFastEquivalWith(const MEDCouplingMesh *other, double prec) const override;
+ MEDCOUPLING_EXPORT void checkConsistencyLight() const override;
+ MEDCOUPLING_EXPORT void checkConsistency(double eps=1e-12) const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfCells() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *computeNbOfNodesPerCell() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *computeNbOfFacesPerCell() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *computeEffectiveNbOfNodesPerCell() const override;
+ MEDCOUPLING_EXPORT void getNodeIdsOfCell(mcIdType cellId, std::vector<mcIdType>& conn) const override;
+ MEDCOUPLING_EXPORT std::string simpleRepr() const override;
+ MEDCOUPLING_EXPORT std::string advancedRepr() const override;
+ MEDCOUPLING_EXPORT DataArrayDouble *computeIsoBarycenterOfNodesPerCell() const override;
+ MEDCOUPLING_EXPORT void renumberCells(const mcIdType *old2NewBg, bool check=true) override;
+ MEDCOUPLING_EXPORT MEDCouplingMesh *mergeMyselfWith(const MEDCouplingMesh *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingUMesh *buildUnstructured() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *simplexize(int policy) override;
+ MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const override;
// overload of MEDCouplingPointSet
- MEDCOUPLING_EXPORT void shallowCopyConnectivityFrom(const MEDCouplingPointSet *other);
- MEDCOUPLING_EXPORT MEDCouplingPointSet *mergeMyselfWithOnSameCoords(const MEDCouplingPointSet *other) const;
- MEDCOUPLING_EXPORT MEDCouplingPointSet *buildPartOfMySelfKeepCoords(const mcIdType *begin, const mcIdType *end) const;
- MEDCOUPLING_EXPORT MEDCouplingPointSet *buildPartOfMySelfKeepCoordsSlice(mcIdType start, mcIdType end, mcIdType step) const;
- MEDCOUPLING_EXPORT void computeNodeIdsAlg(std::vector<bool>& nodeIdsInUse) const;
- MEDCOUPLING_EXPORT void getReverseNodalConnectivity(DataArrayIdType *revNodal, DataArrayIdType *revNodalIndx) const;
- MEDCOUPLING_EXPORT void checkFullyDefined() const;
- MEDCOUPLING_EXPORT bool isEmptyMesh(const std::vector<mcIdType>& tinyInfo) const;
- MEDCOUPLING_EXPORT DataArrayIdType *computeFetchedNodeIds() const;
- MEDCOUPLING_EXPORT DataArrayIdType *getNodeIdsInUse(mcIdType& nbrOfNodesInUse) const;
- MEDCOUPLING_EXPORT void renumberNodesWithOffsetInConn(mcIdType offset);
- MEDCOUPLING_EXPORT void renumberNodesInConn(const INTERP_KERNEL::HashMap<mcIdType,mcIdType>& newNodeNumbersO2N);
+ MEDCOUPLING_EXPORT void shallowCopyConnectivityFrom(const MEDCouplingPointSet *other) override;
+ MEDCOUPLING_EXPORT MEDCouplingPointSet *mergeMyselfWithOnSameCoords(const MEDCouplingPointSet *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingPointSet *buildPartOfMySelfKeepCoords(const mcIdType *begin, const mcIdType *end) const override;
+ MEDCOUPLING_EXPORT MEDCouplingPointSet *buildPartOfMySelfKeepCoordsSlice(mcIdType start, mcIdType end, mcIdType step) const override;
+ MEDCOUPLING_EXPORT void computeNodeIdsAlg(std::vector<bool>& nodeIdsInUse) const override;
+ MEDCOUPLING_EXPORT void getReverseNodalConnectivity(DataArrayIdType *revNodal, DataArrayIdType *revNodalIndx) const override;
+ MEDCOUPLING_EXPORT void checkFullyDefined() const override;
+ MEDCOUPLING_EXPORT bool isEmptyMesh(const std::vector<mcIdType>& tinyInfo) const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *computeFetchedNodeIds() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *getNodeIdsInUse(mcIdType& nbrOfNodesInUse) const override;
+ MEDCOUPLING_EXPORT void renumberNodesWithOffsetInConn(mcIdType offset) override;
+ MEDCOUPLING_EXPORT void renumberNodesInConn(const INTERP_KERNEL::HashMap<mcIdType,mcIdType>& newNodeNumbersO2N) override;
MEDCOUPLING_EXPORT void renumberNodesInConn(const std::map<mcIdType,mcIdType>& newNodeNumbersO2N) override;
- MEDCOUPLING_EXPORT void renumberNodesInConn(const mcIdType *newNodeNumbersO2N);
- MEDCOUPLING_EXPORT void fillCellIdsToKeepFromNodeIds(const mcIdType *begin, const mcIdType *end, bool fullyIn, DataArrayIdType *&cellIdsKeptArr) const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfNodesInCell(mcIdType cellId) const;
- MEDCOUPLING_EXPORT DataArrayDouble *getBoundingBoxForBBTree(double arcDetEps=1e-12) const;
- MEDCOUPLING_EXPORT MEDCouplingFieldDouble *computeDiameterField() const;
- MEDCOUPLING_EXPORT void invertOrientationOfAllCells();
+ MEDCOUPLING_EXPORT void renumberNodesInConn(const mcIdType *newNodeNumbersO2N) override;
+ MEDCOUPLING_EXPORT void fillCellIdsToKeepFromNodeIds(const mcIdType *begin, const mcIdType *end, bool fullyIn, DataArrayIdType *&cellIdsKeptArr) const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfNodesInCell(mcIdType cellId) const override;
+ MEDCOUPLING_EXPORT DataArrayDouble *getBoundingBoxForBBTree(double arcDetEps=1e-12) const override;
+ MEDCOUPLING_EXPORT MEDCouplingFieldDouble *computeDiameterField() const override;
+ MEDCOUPLING_EXPORT void invertOrientationOfAllCells() override;
// overload of MEDCoupling1GTUMesh
- MEDCOUPLING_EXPORT void checkConsistencyOfConnectivity() const;
- MEDCOUPLING_EXPORT void allocateCells(mcIdType nbOfCells=0);
- MEDCOUPLING_EXPORT void insertNextCell(const mcIdType *nodalConnOfCellBg, const mcIdType *nodalConnOfCellEnd);
+ MEDCOUPLING_EXPORT void checkConsistencyOfConnectivity() const override;
+ MEDCOUPLING_EXPORT void allocateCells(mcIdType nbOfCells=0) override;
+ MEDCOUPLING_EXPORT void insertNextCell(const mcIdType *nodalConnOfCellBg, const mcIdType *nodalConnOfCellEnd) override;
public://specific
MEDCOUPLING_EXPORT void setNodalConnectivity(DataArrayIdType *nodalConn, DataArrayIdType *nodalConnIndex);
- MEDCOUPLING_EXPORT DataArrayIdType *getNodalConnectivity() const;
+ MEDCOUPLING_EXPORT DataArrayIdType *getNodalConnectivity() const override;
MEDCOUPLING_EXPORT DataArrayIdType *getNodalConnectivityIndex() const;
MEDCOUPLING_EXPORT MEDCoupling1DGTUMesh *copyWithNodalConnectivityPacked(bool& isShallowCpyOfNodalConnn) const;
MEDCOUPLING_EXPORT bool retrievePackedNodalConnectivity(DataArrayIdType *&nodalConn, DataArrayIdType *&nodalConnIndx) const;
MEDCOUPLING_EXPORT static std::vector<mcIdType> BuildAPolygonFromParts(const std::vector< std::vector<mcIdType> >& parts);
MEDCOUPLING_EXPORT MEDCoupling1DGTUMesh *buildSetInstanceFromThis(std::size_t spaceDim) const;
public://serialization
- MEDCOUPLING_EXPORT void getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const;
- MEDCOUPLING_EXPORT void resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const;
- MEDCOUPLING_EXPORT void serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const;
+ MEDCOUPLING_EXPORT void getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const override;
+ MEDCOUPLING_EXPORT void resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const override;
+ MEDCOUPLING_EXPORT void serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const override;
MEDCOUPLING_EXPORT void unserialization(const std::vector<double>& tinyInfoD, const std::vector<mcIdType>& tinyInfo, const DataArrayIdType *a1, DataArrayDouble *a2,
- const std::vector<std::string>& littleStrings);
+ const std::vector<std::string>& littleStrings) override;
private:
MEDCoupling1DGTUMesh(const std::string& name, const INTERP_KERNEL::CellModel& cm);
MEDCoupling1DGTUMesh(const MEDCoupling1DGTUMesh& other, bool recDeepCpy);
// Author : Anthony Geay (EDF R&D)
#pragma once
+#include "MCType.hxx"
#include "MEDCoupling1GTUMesh.hxx"
+#include <iterator>
#include <sstream>
template<class MAPCLS>
{
getNumberOfCells();//only to check that all is well defined.
mcIdType *begPtr(_conn->getPointer());
- mcIdType nbElt(_conn->getNumberOfTuples());
+ mcIdType const nbElt(_conn->getNumberOfTuples());
mcIdType *endPtr(begPtr+nbElt);
for(mcIdType *it=begPtr;it!=endPtr;it++)
{
{
getNumberOfCells();//only to check that all is well defined.
//
- mcIdType nbOfTuples(_conn->getNumberOfTuples());
+ mcIdType const nbOfTuples(_conn->getNumberOfTuples());
mcIdType *pt(_conn->getPointer());
for(mcIdType i=0;i<nbOfTuples;i++,pt++)
{
// Author : Anthony Geay
#include "MEDCouplingAMRAttribute.hxx"
+#include "MCType.hxx"
+#include "MCIdType.hxx"
+#include "MEDCouplingCartesianAMRMesh.hxx"
+#include "MCAuto.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "MEDCouplingMemArray.hxx"
#include "MEDCouplingIMesh.hxx"
-
+#include "MEDCouplingNatureOfFieldEnum"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingMesh.hxx"
+#include "MEDCouplingStructuredMesh.hxx"
+
+#include <algorithm>
+#include <cstddef>
+#include <iterator>
+#include <set>
+#include <map>
#include <sstream>
#include <fstream>
#include <functional>
+#include <string>
+#include <utility>
+#include <vector>
using namespace MEDCoupling;
void DataArrayDoubleCollection::allocTuples(mcIdType nbOfTuples)
{
- std::size_t sz(_arrs.size());
+ std::size_t const sz(_arrs.size());
for(std::size_t i=0;i<sz;i++)
_arrs[i].first->reAlloc(nbOfTuples);
}
void DataArrayDoubleCollection::dellocTuples()
{
- std::size_t sz(_arrs.size());
+ std::size_t const sz(_arrs.size());
for(std::size_t i=0;i<sz;i++)
_arrs[i].first->reAlloc(0);
}
void DataArrayDoubleCollection::copyFrom(const DataArrayDoubleCollection& other)
{
- std::size_t sz(_arrs.size());
+ std::size_t const sz(_arrs.size());
if(sz!=other._arrs.size())
throw INTERP_KERNEL::Exception("DataArrayDoubleCollection::copyFrom : size are not the same !");
for(std::size_t i=0;i<sz;i++)
void DataArrayDoubleCollection::spillInfoOnComponents(const std::vector< std::vector<std::string> >& compNames)
{
- std::size_t sz(_arrs.size());
+ std::size_t const sz(_arrs.size());
if(sz!=compNames.size())
throw INTERP_KERNEL::Exception("DataArrayDoubleCollection::spillInfoOnComponents : first size of compNames has to be equal to the number of fields defined !");
for(std::size_t i=0;i<sz;i++)
void DataArrayDoubleCollection::spillNatures(const std::vector<NatureOfField>& nfs)
{
- std::size_t sz(_arrs.size());
+ std::size_t const sz(_arrs.size());
if(sz!=nfs.size())
throw INTERP_KERNEL::Exception("DataArrayDoubleCollection::spillNatures : first size of vector of NatureOfField has to be equal to the number of fields defined !");
for(std::size_t i=0;i<sz;i++)
std::vector< std::pair < std::string, std::vector<std::string> > > DataArrayDoubleCollection::getInfoOnComponents() const
{
- std::size_t sz(_arrs.size());
+ std::size_t const sz(_arrs.size());
std::vector< std::pair < std::string, std::vector<std::string> > > ret(sz);
for(std::size_t i=0;i<sz;i++)
{
std::vector<NatureOfField> DataArrayDoubleCollection::getNatures() const
{
- std::size_t sz(_arrs.size());
+ std::size_t const sz(_arrs.size());
std::vector<NatureOfField> ret(sz);
for(std::size_t i=0;i<sz;i++)
ret[i]=_arrs[i].second;
std::vector<DataArrayDouble *> DataArrayDoubleCollection::retrieveFields() const
{
- std::size_t sz(_arrs.size());
+ std::size_t const sz(_arrs.size());
std::vector<DataArrayDouble *> ret(sz);
for(std::size_t i=0;i<sz;i++)
{
const DataArrayDouble *DataArrayDoubleCollection::getFieldWithName(const std::string& name) const
{
std::vector<std::string> vec;
- for(std::vector< std::pair< MCAuto<DataArrayDouble>, NatureOfField > >::const_iterator it=_arrs.begin();it!=_arrs.end();it++)
+ for(const auto & _arr : _arrs)
{
- const DataArrayDouble *obj((*it).first);
+ const DataArrayDouble *obj(_arr.first);
if(obj)
{
if(obj->getName()==name)
DataArrayDouble *DataArrayDoubleCollection::getFieldWithName(const std::string& name)
{
std::vector<std::string> vec;
- for(std::vector< std::pair< MCAuto<DataArrayDouble>, NatureOfField > >::iterator it=_arrs.begin();it!=_arrs.end();it++)
+ for(auto & _arr : _arrs)
{
- DataArrayDouble *obj((*it).first);
+ DataArrayDouble *obj(_arr.first);
if(obj)
{
if(obj->getName()==name)
{
if(!fine || !coarse)
throw INTERP_KERNEL::Exception("DataArrayDoubleCollection::SynchronizeFineToCoarse : the input DataArrayDouble collections must be non NULL !");
- std::size_t sz(coarse->_arrs.size());
+ std::size_t const sz(coarse->_arrs.size());
if(fine->_arrs.size()!=sz)
throw INTERP_KERNEL::Exception("DataArrayDoubleCollection::SynchronizeFineToCoarse : the input DataArrayDouble collection must have the same size !");
for(std::size_t i=0;i<sz;i++)
{
if(!fine || !coarse)
throw INTERP_KERNEL::Exception("DataArrayDoubleCollection::SynchronizeCoarseToFine : the input DataArrayDouble collections must be non NULL !");
- std::size_t sz(coarse->_arrs.size());
+ std::size_t const sz(coarse->_arrs.size());
if(fine->_arrs.size()!=sz)
throw INTERP_KERNEL::Exception("DataArrayDoubleCollection::SynchronizeCoarseToFine : the input DataArrayDouble collection must have the same size !");
for(std::size_t i=0;i<sz;i++)
{
if(!fatherOfFineMesh)
throw INTERP_KERNEL::Exception("DataArrayDoubleCollection::SynchronizeFineEachOther : father is NULL !");
- std::size_t sz(children.size());
+ std::size_t const sz(children.size());
if(fieldsOnFine.size()!=sz)
throw INTERP_KERNEL::Exception("DataArrayDoubleCollection::SynchronizeFineEachOther : sizes of vectors mismatch !");
if(sz<=1)
return ;
- std::size_t nbOfCall(fieldsOnFine[0]->_arrs.size());
+ std::size_t const nbOfCall(fieldsOnFine[0]->_arrs.size());
for(std::size_t i=0;i<sz;i++)
if(fatherOfFineMesh->getPatchIdFromChildMesh(children[i])!=ToIdType(i))
throw INTERP_KERNEL::Exception("DataArrayDoubleCollection::SynchronizeFineEachOther : internal error !");
{
if(!p1 || !p1dac || !p2 || !p2dac)
throw INTERP_KERNEL::Exception("DataArrayDoubleCollection::SynchronizeGhostZoneOfOneUsingTwo : input pointer must be not NULL !");
- std::size_t sz(p1dac->_arrs.size());
+ std::size_t const sz(p1dac->_arrs.size());
if(p2dac->_arrs.size()!=sz)
throw INTERP_KERNEL::Exception("DataArrayDoubleCollection::SynchronizeGhostZoneOfOneUsingTwo : size of DataArrayDouble Collection must be the same !");
for(std::size_t i=0;i<sz;i++)
{
const DataArrayDouble *zeArrWhichGhostsWillBeUpdated(p1dac->_arrs[i].first);
DataArrayDoubleCollection::CheckSameNatures(p1dac->_arrs[i].second,p2dac->_arrs[i].second);
- bool isConservative(DataArrayDoubleCollection::IsConservativeNature(p1dac->_arrs[i].second));
+ bool const isConservative(DataArrayDoubleCollection::IsConservativeNature(p1dac->_arrs[i].second));
MEDCouplingCartesianAMRPatch::UpdateNeighborsOfOneWithTwoMixedLev(ghostLev,p1,p2,const_cast<DataArrayDouble *>(zeArrWhichGhostsWillBeUpdated),p2dac->_arrs[i].first,isConservative);
}
}
{
if(!fine || !coarse)
throw INTERP_KERNEL::Exception("DataArrayDoubleCollection::SynchronizeCoarseToFineOnlyInGhostZone : the input DataArrayDouble collections must be non NULL !");
- std::size_t sz(coarse->_arrs.size());
+ std::size_t const sz(coarse->_arrs.size());
if(fine->_arrs.size()!=sz)
throw INTERP_KERNEL::Exception("DataArrayDoubleCollection::SynchronizeCoarseToFineOnlyInGhostZone : the input DataArrayDouble collection must have the same size !");
for(std::size_t i=0;i<sz;i++)
void DataArrayDoubleCollection::synchronizeMyGhostZoneUsing(mcIdType ghostLev, const DataArrayDoubleCollection& other, const MEDCouplingCartesianAMRPatch *thisp, const MEDCouplingCartesianAMRPatch *otherp, const MEDCouplingCartesianAMRMeshGen *father) const
{
- DataArrayDoubleCollection *thisNC(const_cast<DataArrayDoubleCollection *>(this));
- std::size_t sz(_arrs.size());
+ auto *thisNC(const_cast<DataArrayDoubleCollection *>(this));
+ std::size_t const sz(_arrs.size());
if(other._arrs.size()!=sz)
throw INTERP_KERNEL::Exception("DataArrayDoubleCollection::synchronizeMyGhostZoneUsing : sizes of collections must match !");
for(std::size_t i=0;i<sz;i++)
void DataArrayDoubleCollection::synchronizeMyGhostZoneUsingExt(mcIdType ghostLev, const DataArrayDoubleCollection& other, const MEDCouplingCartesianAMRPatch *thisp, const MEDCouplingCartesianAMRPatch *otherp) const
{
- DataArrayDoubleCollection *thisNC(const_cast<DataArrayDoubleCollection *>(this));
- std::size_t sz(_arrs.size());
+ auto *thisNC(const_cast<DataArrayDoubleCollection *>(this));
+ std::size_t const sz(_arrs.size());
if(other._arrs.size()!=sz)
throw INTERP_KERNEL::Exception("DataArrayDoubleCollection::synchronizeMyGhostZoneUsingExt : sizes of collections must match !");
for(std::size_t i=0;i<sz;i++)
DataArrayDoubleCollection::DataArrayDoubleCollection(const std::vector< std::pair<std::string,int> >& fieldNames):_arrs(fieldNames.size())
{
- std::size_t sz(fieldNames.size());
+ std::size_t const sz(fieldNames.size());
std::vector<std::string> names(sz);
for(std::size_t i=0;i<sz;i++)
{
DataArrayDoubleCollection::DataArrayDoubleCollection(const DataArrayDoubleCollection& other):RefCountObject(other),_arrs(other._arrs.size())
{
- std::size_t sz(other._arrs.size());
+ std::size_t const sz(other._arrs.size());
for(std::size_t i=0;i<sz;i++)
{
_arrs[i].second=other._arrs[i].second;
std::vector<const BigMemoryObject *> DataArrayDoubleCollection::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
- for(std::vector< std::pair< MCAuto<DataArrayDouble>, NatureOfField > >::const_iterator it=_arrs.begin();it!=_arrs.end();it++)
- ret.push_back((const DataArrayDouble *)(*it).first);
+ for(const auto & _arr : _arrs)
+ ret.push_back((const DataArrayDouble *)_arr.first);
return ret;
}
void DataArrayDoubleCollection::updateTime() const
{
- for(std::vector< std::pair< MCAuto<DataArrayDouble>, NatureOfField > >::const_iterator it=_arrs.begin();it!=_arrs.end();it++)
+ for(const auto & _arr : _arrs)
{
- const DataArrayDouble *pt((*it).first);
+ const DataArrayDouble *pt(_arr.first);
if(pt)
updateTimeWith(*pt);
}
void DataArrayDoubleCollection::CheckDiscriminantNames(const std::vector<std::string>& names)
{
- std::set<std::string> s(names.begin(),names.end());
+ std::set<std::string> const s(names.begin(),names.end());
if(s.size()!=names.size())
throw INTERP_KERNEL::Exception("DataArrayDoubleCollection::CheckDiscriminantNames : The names of fields must be different each other ! It is not the case !");
}
void MEDCouplingGridCollection::alloc(mcIdType ghostLev)
{
- for(std::vector< std::pair<const MEDCouplingCartesianAMRMeshGen *,MCAuto<DataArrayDoubleCollection> > >::iterator it=_map_of_dadc.begin();it!=_map_of_dadc.end();it++)
+ for(auto & it : _map_of_dadc)
{
- mcIdType nbTuples((*it).first->getNumberOfCellsAtCurrentLevelGhost(ghostLev));
- DataArrayDoubleCollection *dadc((*it).second);
+ mcIdType const nbTuples(it.first->getNumberOfCellsAtCurrentLevelGhost(ghostLev));
+ DataArrayDoubleCollection *dadc(it.second);
if(dadc)
dadc->allocTuples(nbTuples);
else
void MEDCouplingGridCollection::dealloc()
{
- for(std::vector< std::pair<const MEDCouplingCartesianAMRMeshGen *,MCAuto<DataArrayDoubleCollection> > >::iterator it=_map_of_dadc.begin();it!=_map_of_dadc.end();it++)
+ for(auto & it : _map_of_dadc)
{
- DataArrayDoubleCollection *dadc((*it).second);
+ DataArrayDoubleCollection *dadc(it.second);
if(dadc)
dadc->dellocTuples();
else
void MEDCouplingGridCollection::spillInfoOnComponents(const std::vector< std::vector<std::string> >& compNames)
{
- for(std::vector< std::pair<const MEDCouplingCartesianAMRMeshGen *,MCAuto<DataArrayDoubleCollection> > >::iterator it=_map_of_dadc.begin();it!=_map_of_dadc.end();it++)
- (*it).second->spillInfoOnComponents(compNames);
+ for(auto & it : _map_of_dadc)
+ it.second->spillInfoOnComponents(compNames);
}
void MEDCouplingGridCollection::spillNatures(const std::vector<NatureOfField>& nfs)
{
- for(std::vector< std::pair<const MEDCouplingCartesianAMRMeshGen *,MCAuto<DataArrayDoubleCollection> > >::iterator it=_map_of_dadc.begin();it!=_map_of_dadc.end();it++)
- (*it).second->spillNatures(nfs);
+ for(auto & it : _map_of_dadc)
+ it.second->spillNatures(nfs);
}
std::vector< std::pair<std::string, std::vector<std::string> > > MEDCouplingGridCollection::getInfoOnComponents() const
bool MEDCouplingGridCollection::presenceOf(const MEDCouplingCartesianAMRMeshGen *m, mcIdType& pos) const
{
mcIdType ret(0);
- for(std::vector< std::pair<const MEDCouplingCartesianAMRMeshGen *,MCAuto<DataArrayDoubleCollection> > >::const_iterator it=_map_of_dadc.begin();it!=_map_of_dadc.end();it++,ret++)
+ for(auto it=_map_of_dadc.begin();it!=_map_of_dadc.end();it++,ret++)
{
if((*it).first==m)
{
*/
void MEDCouplingGridCollection::copyOverlappedZoneFrom(mcIdType ghostLev, const MEDCouplingGridCollection& other)
{
- for(std::vector< std::pair<const MEDCouplingCartesianAMRMeshGen *,MCAuto<DataArrayDoubleCollection> > >::iterator it=_map_of_dadc.begin();it!=_map_of_dadc.end();it++)
+ for(auto & it : _map_of_dadc)
{
std::vector<mcIdType> deltaThis,deltaOther;
- std::vector< std::pair<mcIdType,mcIdType> > rgThis((*it).first->positionRelativeToGodFather(deltaThis));
- std::vector<mcIdType> thisSt((*it).first->getImageMesh()->getCellGridStructure());
+ std::vector< std::pair<mcIdType,mcIdType> > const rgThis(it.first->positionRelativeToGodFather(deltaThis));
+ std::vector<mcIdType> thisSt(it.first->getImageMesh()->getCellGridStructure());
std::transform(thisSt.begin(),thisSt.end(),thisSt.begin(),std::bind(std::plus<mcIdType>(),std::placeholders::_1,2*ghostLev));
- for(std::vector< std::pair<const MEDCouplingCartesianAMRMeshGen *,MCAuto<DataArrayDoubleCollection> > >::const_iterator it2=other._map_of_dadc.begin();it2!=other._map_of_dadc.end();it2++)
+ for(const auto & it2 : other._map_of_dadc)
{
- std::vector< std::pair<mcIdType,mcIdType> > rgOther((*it2).first->positionRelativeToGodFather(deltaOther));
+ std::vector< std::pair<mcIdType,mcIdType> > const rgOther(it2.first->positionRelativeToGodFather(deltaOther));
if(MEDCouplingStructuredMesh::AreRangesIntersect(rgThis,rgOther))
{
- std::vector< std::pair<mcIdType,mcIdType> > isect(MEDCouplingStructuredMesh::IntersectRanges(rgThis,rgOther));
+ std::vector< std::pair<mcIdType,mcIdType> > const isect(MEDCouplingStructuredMesh::IntersectRanges(rgThis,rgOther));
std::vector< std::pair<mcIdType,mcIdType> > pThis,pOther;
MEDCouplingStructuredMesh::ChangeReferenceFromGlobalOfCompactFrmt(rgThis,isect,pThis,true);
MEDCouplingStructuredMesh::ChangeReferenceFromGlobalOfCompactFrmt(rgOther,isect,pOther,true);
- std::vector<mcIdType> otherSt((*it2).first->getImageMesh()->getCellGridStructure());
+ std::vector<mcIdType> otherSt(it2.first->getImageMesh()->getCellGridStructure());
MEDCouplingStructuredMesh::ApplyGhostOnCompactFrmt(pThis,ghostLev);
MEDCouplingStructuredMesh::ApplyGhostOnCompactFrmt(pOther,ghostLev);
std::transform(otherSt.begin(),otherSt.end(),otherSt.begin(),std::bind(std::plus<mcIdType>(),std::placeholders::_1,2*ghostLev));
- mcIdType sz((*it2).second->size());
+ mcIdType const sz(it2.second->size());
for(mcIdType i=0;i<sz;i++)
{
- const DataArrayDouble *otherArr((*it2).second->at(i));
- DataArrayDouble *thisArr((*it).second->at(i));
+ const DataArrayDouble *otherArr(it2.second->at(i));
+ DataArrayDouble *thisArr(it.second->at(i));
MCAuto<DataArrayDouble> partOfOther(MEDCouplingStructuredMesh::ExtractFieldOfDoubleFrom(otherSt,otherArr,pOther));
MEDCouplingStructuredMesh::AssignPartOfFieldOfDoubleUsing(thisSt,thisArr,pThis,partOfOther);
}
throw INTERP_KERNEL::Exception("MEDCouplingGridCollection::SynchronizeFineToCoarse : one or more input pointer is NULL !");
const std::vector< std::pair<const MEDCouplingCartesianAMRMeshGen *,MCAuto<DataArrayDoubleCollection> > >& mf(fine->_map_of_dadc);
const std::vector< std::pair<const MEDCouplingCartesianAMRMeshGen *,MCAuto<DataArrayDoubleCollection> > >& mc(coarse->_map_of_dadc);
- for(std::vector< std::pair<const MEDCouplingCartesianAMRMeshGen *,MCAuto<DataArrayDoubleCollection> > >::const_iterator it=mf.begin();it!=mf.end();it++)
+ for(const auto & it : mf)
{
- const MEDCouplingCartesianAMRMeshGen *fineMesh((*it).first);
+ const MEDCouplingCartesianAMRMeshGen *fineMesh(it.first);
const MEDCouplingCartesianAMRMeshGen *fatherOfFineMesh(fineMesh->getFather());
bool found(false);
- for(std::vector< std::pair<const MEDCouplingCartesianAMRMeshGen *,MCAuto<DataArrayDoubleCollection> > >::const_iterator it0=mc.begin();it0!=mc.end() && !found;it0++)
+ for(auto it0=mc.begin();it0!=mc.end() && !found;it0++)
{
if((*it0).first==fatherOfFineMesh)
{
found=true;
- mcIdType patchId(fatherOfFineMesh->getPatchIdFromChildMesh(fineMesh));
+ mcIdType const patchId(fatherOfFineMesh->getPatchIdFromChildMesh(fineMesh));
const DataArrayDoubleCollection *coarseDaCol((*it0).second);
- DataArrayDoubleCollection *coarseModified(const_cast<DataArrayDoubleCollection *>(coarseDaCol));//coarse values in DataArrayDouble will be altered
- DataArrayDoubleCollection::SynchronizeFineToCoarse(ghostLev,fatherOfFineMesh,patchId,(*it).second,coarseModified);
+ auto *coarseModified(const_cast<DataArrayDoubleCollection *>(coarseDaCol));//coarse values in DataArrayDouble will be altered
+ DataArrayDoubleCollection::SynchronizeFineToCoarse(ghostLev,fatherOfFineMesh,patchId,it.second,coarseModified);
}
}
if(!found)
throw INTERP_KERNEL::Exception("MEDCouplingGridCollection::SynchronizeCoarseToFine : one or more input pointer is NULL !");
const std::vector< std::pair<const MEDCouplingCartesianAMRMeshGen *,MCAuto<DataArrayDoubleCollection> > >& mf(fine->_map_of_dadc);
const std::vector< std::pair<const MEDCouplingCartesianAMRMeshGen *,MCAuto<DataArrayDoubleCollection> > >& mc(coarse->_map_of_dadc);
- for(std::vector< std::pair<const MEDCouplingCartesianAMRMeshGen *,MCAuto<DataArrayDoubleCollection> > >::const_iterator it=mf.begin();it!=mf.end();it++)
+ for(const auto & it : mf)
{
- const MEDCouplingCartesianAMRMeshGen *fineMesh((*it).first);
+ const MEDCouplingCartesianAMRMeshGen *fineMesh(it.first);
const MEDCouplingCartesianAMRMeshGen *fatherOfFineMesh(fineMesh->getFather());
bool found(false);
- for(std::vector< std::pair<const MEDCouplingCartesianAMRMeshGen *,MCAuto<DataArrayDoubleCollection> > >::const_iterator it0=mc.begin();it0!=mc.end() && !found;it0++)
+ for(auto it0=mc.begin();it0!=mc.end() && !found;it0++)
{
if((*it0).first==fatherOfFineMesh)
{
found=true;
- mcIdType patchId(fatherOfFineMesh->getPatchIdFromChildMesh(fineMesh));
- const DataArrayDoubleCollection *fineDaCol((*it).second);
- DataArrayDoubleCollection *fineModified(const_cast<DataArrayDoubleCollection *>(fineDaCol));//fine values in DataArrayDouble will be altered
+ mcIdType const patchId(fatherOfFineMesh->getPatchIdFromChildMesh(fineMesh));
+ const DataArrayDoubleCollection *fineDaCol(it.second);
+ auto *fineModified(const_cast<DataArrayDoubleCollection *>(fineDaCol));//fine values in DataArrayDouble will be altered
DataArrayDoubleCollection::SynchronizeCoarseToFine(ghostLev,fatherOfFineMesh,patchId,(*it0).second,fineModified);
}
}
*/
void MEDCouplingGridCollection::synchronizeFineEachOther(mcIdType ghostLev, const std::vector< std::pair<const MEDCouplingCartesianAMRPatch *,const MEDCouplingCartesianAMRPatch *> >& ps) const
{
- for(std::vector< std::pair<const MEDCouplingCartesianAMRPatch *,const MEDCouplingCartesianAMRPatch *> >::const_iterator it=ps.begin();it!=ps.end();it++)
+ for(const auto & p : ps)
{
mcIdType p1,p2;
- if(!presenceOf((*it).first->getMesh(),p1))
+ if(!presenceOf(p.first->getMesh(),p1))
throw INTERP_KERNEL::Exception("MEDCouplingGridCollection::synchronizeFineEachOther : internal error #1 !");
- if(!presenceOf((*it).second->getMesh(),p2))
+ if(!presenceOf(p.second->getMesh(),p2))
throw INTERP_KERNEL::Exception("MEDCouplingGridCollection::synchronizeFineEachOther : internal error #2 !");
const DataArrayDoubleCollection& col1(getFieldsAt(p1));
const DataArrayDoubleCollection& col2(getFieldsAt(p2));
- col1.synchronizeMyGhostZoneUsing(ghostLev,col2,(*it).first,(*it).second,(*it).first->getMesh()->getFather());
+ col1.synchronizeMyGhostZoneUsing(ghostLev,col2,p.first,p.second,p.first->getMesh()->getFather());
}
}
*/
void MEDCouplingGridCollection::synchronizeFineEachOtherExt(mcIdType ghostLev, const std::vector< std::pair<const MEDCouplingCartesianAMRPatch *,const MEDCouplingCartesianAMRPatch *> >& ps) const
{
- for(std::vector< std::pair<const MEDCouplingCartesianAMRPatch *,const MEDCouplingCartesianAMRPatch *> >::const_iterator it=ps.begin();it!=ps.end();it++)
+ for(const auto & p : ps)
{
mcIdType p1,p2;
- if(!presenceOf((*it).first->getMesh(),p1))
+ if(!presenceOf(p.first->getMesh(),p1))
throw INTERP_KERNEL::Exception("MEDCouplingGridCollection::synchronizeFineEachOtherExt : internal error #1 !");
- if(!presenceOf((*it).second->getMesh(),p2))
+ if(!presenceOf(p.second->getMesh(),p2))
throw INTERP_KERNEL::Exception("MEDCouplingGridCollection::synchronizeFineEachOtherExt : internal error #2 !");
const DataArrayDoubleCollection& col1(getFieldsAt(p1));
const DataArrayDoubleCollection& col2(getFieldsAt(p2));
- col1.synchronizeMyGhostZoneUsingExt(ghostLev,col2,(*it).first,(*it).second);
+ col1.synchronizeMyGhostZoneUsingExt(ghostLev,col2,p.first,p.second);
}
}
{
std::vector< std::pair<const MEDCouplingCartesianAMRPatch *,const MEDCouplingCartesianAMRPatch *> > ret;
std::map<const MEDCouplingCartesianAMRMeshGen *,std::vector< const MEDCouplingCartesianAMRMeshGen * > > m;
- for(std::vector< std::pair<const MEDCouplingCartesianAMRMeshGen *,MCAuto<DataArrayDoubleCollection> > >::const_iterator it=_map_of_dadc.begin();it!=_map_of_dadc.end();it++)
+ for(const auto & it : _map_of_dadc)
{
- const MEDCouplingCartesianAMRMeshGen *fineMesh((*it).first);
+ const MEDCouplingCartesianAMRMeshGen *fineMesh(it.first);
const MEDCouplingCartesianAMRMeshGen *fatherOfFineMesh(fineMesh->getFather());
m[fatherOfFineMesh].push_back(fineMesh);
}
for(std::map<const MEDCouplingCartesianAMRMeshGen *,std::vector< const MEDCouplingCartesianAMRMeshGen * > >::const_iterator it0=m.begin();it0!=m.end();it0++)
{
- for(std::vector<const MEDCouplingCartesianAMRMeshGen *>::const_iterator it1=(*it0).second.begin();it1!=(*it0).second.end();it1++)
+ for(auto it1=(*it0).second.begin();it1!=(*it0).second.end();it1++)
{
- mcIdType patchId((*it0).first->getPatchIdFromChildMesh(*it1));
- std::vector<mcIdType> neighs((*it0).first->getPatchIdsInTheNeighborhoodOf(patchId,ghostLev));
+ mcIdType const patchId((*it0).first->getPatchIdFromChildMesh(*it1));
+ std::vector<mcIdType> const neighs((*it0).first->getPatchIdsInTheNeighborhoodOf(patchId,ghostLev));
const MEDCouplingCartesianAMRPatch *pRef((*it0).first->getPatch(patchId));
- for(std::vector<mcIdType>::const_iterator it2=neighs.begin();it2!=neighs.end();it2++)
+ for(long const neigh : neighs)
{
- const MEDCouplingCartesianAMRPatch *pLoc((*it0).first->getPatch(*it2));
+ const MEDCouplingCartesianAMRPatch *pLoc((*it0).first->getPatch(neigh));
ret.push_back(std::pair<const MEDCouplingCartesianAMRPatch *,const MEDCouplingCartesianAMRPatch *>(pRef,pLoc));
}
}
throw INTERP_KERNEL::Exception("MEDCouplingGridCollection::SynchronizeCoarseToFineOnlyInGhostZone : one or more input pointer is NULL !");
const std::vector< std::pair<const MEDCouplingCartesianAMRMeshGen *,MCAuto<DataArrayDoubleCollection> > >& mf(fine->_map_of_dadc);
const std::vector< std::pair<const MEDCouplingCartesianAMRMeshGen *,MCAuto<DataArrayDoubleCollection> > >& mc(coarse->_map_of_dadc);
- for(std::vector< std::pair<const MEDCouplingCartesianAMRMeshGen *,MCAuto<DataArrayDoubleCollection> > >::const_iterator it=mf.begin();it!=mf.end();it++)
+ for(const auto & it : mf)
{
- const MEDCouplingCartesianAMRMeshGen *fineMesh((*it).first);
+ const MEDCouplingCartesianAMRMeshGen *fineMesh(it.first);
const MEDCouplingCartesianAMRMeshGen *fatherOfFineMesh(fineMesh->getFather());
bool found(false);
- for(std::vector< std::pair<const MEDCouplingCartesianAMRMeshGen *,MCAuto<DataArrayDoubleCollection> > >::const_iterator it0=mc.begin();it0!=mc.end() && !found;it0++)
+ for(auto it0=mc.begin();it0!=mc.end() && !found;it0++)
{
if((*it0).first==fatherOfFineMesh)
{
found=true;
- mcIdType patchId(fatherOfFineMesh->getPatchIdFromChildMesh(fineMesh));
- const DataArrayDoubleCollection *fineDaCol((*it).second);
- DataArrayDoubleCollection *fineModified(const_cast<DataArrayDoubleCollection *>(fineDaCol));//fine values in DataArrayDouble will be altered
+ mcIdType const patchId(fatherOfFineMesh->getPatchIdFromChildMesh(fineMesh));
+ const DataArrayDoubleCollection *fineDaCol(it.second);
+ auto *fineModified(const_cast<DataArrayDoubleCollection *>(fineDaCol));//fine values in DataArrayDouble will be altered
DataArrayDoubleCollection::SynchronizeCoarseToFineOnlyInGhostZone(ghostLev,fatherOfFineMesh,patchId,(*it0).second,fineModified);
}
}
void MEDCouplingGridCollection::fillIfInTheProgenyOf(const std::string& fieldName, const MEDCouplingCartesianAMRMeshGen *head, std::vector<const DataArrayDouble *>& recurseArrs) const
{
- for(std::vector< std::pair<const MEDCouplingCartesianAMRMeshGen *,MCAuto<DataArrayDoubleCollection> > >::const_iterator it=_map_of_dadc.begin();it!=_map_of_dadc.end();it++)
+ for(const auto & it : _map_of_dadc)
{
- const MEDCouplingCartesianAMRMeshGen *a((*it).first);
+ const MEDCouplingCartesianAMRMeshGen *a(it.first);
if(head==a || head->isObjectInTheProgeny(a))
{
- const DataArrayDoubleCollection *gc((*it).second);
+ const DataArrayDoubleCollection *gc(it.second);
recurseArrs.push_back(gc->getFieldWithName(fieldName));
}
}
MEDCouplingGridCollection::MEDCouplingGridCollection(const std::vector<const MEDCouplingCartesianAMRMeshGen *>& ms, const std::vector< std::pair<std::string,int> >& fieldNames):_map_of_dadc(ms.size())
{
- std::size_t sz(ms.size());
+ std::size_t const sz(ms.size());
for(std::size_t i=0;i<sz;i++)
{
if(!ms[i])
MEDCouplingGridCollection::MEDCouplingGridCollection(const MEDCouplingGridCollection& other, const MEDCouplingCartesianAMRMeshGen *newGf, const MEDCouplingCartesianAMRMeshGen *oldGf):RefCountObject(other),_map_of_dadc(other._map_of_dadc.size())
{
- std::size_t sz(other._map_of_dadc.size());
+ std::size_t const sz(other._map_of_dadc.size());
for(std::size_t i=0;i<sz;i++)
{
- std::vector<mcIdType> pos(other._map_of_dadc[i].first->getPositionRelativeTo(oldGf));
+ std::vector<mcIdType> const pos(other._map_of_dadc[i].first->getPositionRelativeTo(oldGf));
_map_of_dadc[i].first=newGf->getMeshAtPosition(pos);
const DataArrayDoubleCollection *dac(other._map_of_dadc[i].second);
if(dac)
std::vector<const BigMemoryObject *> MEDCouplingGridCollection::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
- for(std::vector< std::pair<const MEDCouplingCartesianAMRMeshGen *,MCAuto<DataArrayDoubleCollection> > >::const_iterator it=_map_of_dadc.begin();it!=_map_of_dadc.end();it++)
- ret.push_back((const DataArrayDoubleCollection *)(*it).second);
+ for(const auto & it : _map_of_dadc)
+ ret.push_back((const DataArrayDoubleCollection *)it.second);
return ret;
}
void MEDCouplingGridCollection::updateTime() const
{
- for(std::vector< std::pair<const MEDCouplingCartesianAMRMeshGen *,MCAuto<DataArrayDoubleCollection> > >::const_iterator it=_map_of_dadc.begin();it!=_map_of_dadc.end();it++)
+ for(const auto & it : _map_of_dadc)
{
- const MEDCouplingCartesianAMRMeshGen *a((*it).first);
+ const MEDCouplingCartesianAMRMeshGen *a(it.first);
if(a)
updateTimeWith(*a);
- const DataArrayDoubleCollection *b((*it).second);
+ const DataArrayDoubleCollection *b(it.second);
if(b)
updateTimeWith(*b);
}
bool MEDCouplingDataForGodFather::changeGodFather(MEDCouplingCartesianAMRMesh *gf)
{
- bool ret(_tlc.keepTrackOfNewTL(gf));
+ bool const ret(_tlc.keepTrackOfNewTL(gf));
if(ret)
{
_gf=gf;
{
const MEDCouplingCartesianAMRMesh *gf(other._gf);
if(gf)
- _gf=gf->deepCopy(0);
+ _gf=gf->deepCopy(nullptr);
_tlc.keepTrackOfNewTL(_gf);
}
}
MEDCouplingAMRAttribute *MEDCouplingAMRAttribute::New(MEDCouplingCartesianAMRMesh *gf, const std::vector< std::pair<std::string, std::vector<std::string> > >& fieldNames, mcIdType ghostLev)
{
- std::size_t sz(fieldNames.size());
+ std::size_t const sz(fieldNames.size());
std::vector< std::pair<std::string,int> > fieldNames2(sz);
std::vector< std::vector<std::string> > compNames(sz);
for(std::size_t i=0;i<sz;i++)
void MEDCouplingAMRAttribute::spillInfoOnComponents(const std::vector< std::vector<std::string> >& compNames)
{
_tlc.checkConst();
- for(std::vector< MCAuto<MEDCouplingGridCollection> >::iterator it=_levs.begin();it!=_levs.end();it++)
- (*it)->spillInfoOnComponents(compNames);
+ for(auto & _lev : _levs)
+ _lev->spillInfoOnComponents(compNames);
}
/*!
void MEDCouplingAMRAttribute::spillNatures(const std::vector<NatureOfField>& nfs)
{
_tlc.checkConst();
- for(std::vector< MCAuto<MEDCouplingGridCollection> >::iterator it=_levs.begin();it!=_levs.end();it++)
- (*it)->spillNatures(nfs);
+ for(auto & _lev : _levs)
+ _lev->spillNatures(nfs);
}
MEDCouplingAMRAttribute *MEDCouplingAMRAttribute::deepCopy() const
*/
std::vector<DataArrayDouble *> MEDCouplingAMRAttribute::retrieveFieldsOn(MEDCouplingCartesianAMRMeshGen *mesh) const
{
- for(std::vector< MCAuto<MEDCouplingGridCollection> >::const_iterator it=_levs.begin();it!=_levs.end();it++)
+ for(const auto & _lev : _levs)
{
mcIdType tmp(-1);
- if((*it)->presenceOf(mesh,tmp))
+ if(_lev->presenceOf(mesh,tmp))
{
- const DataArrayDoubleCollection& ddc((*it)->getFieldsAt(tmp));
+ const DataArrayDoubleCollection& ddc(_lev->getFieldsAt(tmp));
return ddc.retrieveFields();
}
}
*/
const DataArrayDouble *MEDCouplingAMRAttribute::getFieldOn(MEDCouplingCartesianAMRMeshGen *mesh, const std::string& fieldName) const
{
- for(std::vector< MCAuto<MEDCouplingGridCollection> >::const_iterator it=_levs.begin();it!=_levs.end();it++)
+ for(const auto & _lev : _levs)
{
mcIdType tmp(-1);
- if((*it)->presenceOf(mesh,tmp))
+ if(_lev->presenceOf(mesh,tmp))
{
- const DataArrayDoubleCollection& ddc((*it)->getFieldsAt(tmp));
+ const DataArrayDoubleCollection& ddc(_lev->getFieldsAt(tmp));
return ddc.getFieldWithName(fieldName);
}
}
DataArrayDouble *MEDCouplingAMRAttribute::getFieldOn(MEDCouplingCartesianAMRMeshGen *mesh, const std::string& fieldName)
{
- for(std::vector< MCAuto<MEDCouplingGridCollection> >::iterator it=_levs.begin();it!=_levs.end();it++)
+ for(auto & _lev : _levs)
{
mcIdType tmp(-1);
- if((*it)->presenceOf(mesh,tmp))
+ if(_lev->presenceOf(mesh,tmp))
{
- DataArrayDoubleCollection& ddc((*it)->getFieldsAt(tmp));
+ DataArrayDoubleCollection& ddc(_lev->getFieldsAt(tmp));
return ddc.getFieldWithName(fieldName);
}
}
{
std::vector<const DataArrayDouble *> recurseArrs;
std::size_t lev(0);
- for(std::vector< MCAuto<MEDCouplingGridCollection> >::const_iterator it=_levs.begin();it!=_levs.end();it++,lev++)
+ for(auto it=_levs.begin();it!=_levs.end();it++,lev++)
{
mcIdType tmp(-1);
if((*it)->presenceOf(mesh,tmp))
*/
MEDCouplingFieldDouble *MEDCouplingAMRAttribute::buildCellFieldOnWithGhost(MEDCouplingCartesianAMRMeshGen *mesh, const std::string& fieldName) const
{
- const DataArrayDouble *arr(0);
- for(std::vector< MCAuto<MEDCouplingGridCollection> >::const_iterator it=_levs.begin();it!=_levs.end();it++)
+ const DataArrayDouble *arr(nullptr);
+ for(const auto & _lev : _levs)
{
mcIdType tmp(-1);
- if((*it)->presenceOf(mesh,tmp))
+ if(_lev->presenceOf(mesh,tmp))
{
- const DataArrayDoubleCollection& ddc((*it)->getFieldsAt(tmp));
+ const DataArrayDoubleCollection& ddc(_lev->getFieldsAt(tmp));
arr=ddc.getFieldWithName(fieldName);
}
}
*/
MEDCouplingFieldDouble *MEDCouplingAMRAttribute::buildCellFieldOnWithoutGhost(MEDCouplingCartesianAMRMeshGen *mesh, const std::string& fieldName) const
{
- const DataArrayDouble *arr(0);
- for(std::vector< MCAuto<MEDCouplingGridCollection> >::const_iterator it=_levs.begin();it!=_levs.end();it++)
+ const DataArrayDouble *arr(nullptr);
+ for(const auto & _lev : _levs)
{
mcIdType tmp(-1);
- if((*it)->presenceOf(mesh,tmp))
+ if(_lev->presenceOf(mesh,tmp))
{
- const DataArrayDoubleCollection& ddc((*it)->getFieldsAt(tmp));
+ const DataArrayDoubleCollection& ddc(_lev->getFieldsAt(tmp));
arr=ddc.getFieldWithName(fieldName);
}
}
if(!arr)
throw INTERP_KERNEL::Exception("MEDCouplingAMRAttribute::buildCellFieldOnWithoutGhost : the mesh specified is not in the progeny of this !");
//
- MCAuto<MEDCouplingIMesh> im(mesh->getImageMesh()->buildWithGhost(_ghost_lev));
+ MCAuto<MEDCouplingIMesh> const im(mesh->getImageMesh()->buildWithGhost(_ghost_lev));
std::vector<mcIdType> cgs(mesh->getImageMesh()->getCellGridStructure()),cgsWG(im->getCellGridStructure());
MCAuto<DataArrayDouble> arr2(DataArrayDouble::New());
arr2->alloc(mesh->getImageMesh()->getNumberOfCells(),arr->getNumberOfComponents());
std::vector< std::pair<mcIdType,mcIdType> > cgs2(MEDCouplingStructuredMesh::GetCompactFrmtFromDimensions(cgs));
MEDCouplingStructuredMesh::ApplyGhostOnCompactFrmt(cgs2,_ghost_lev);
- std::vector<mcIdType> fakeFactors(mesh->getImageMesh()->getSpaceDimension(),1);
+ std::vector<mcIdType> const fakeFactors(mesh->getImageMesh()->getSpaceDimension(),1);
MEDCouplingIMesh::SpreadCoarseToFine(arr,cgsWG,arr2,cgs2,fakeFactors);
arr2->copyStringInfoFrom(*arr);
//
const MEDCouplingIMesh *gfm(gf->getImageMesh());
std::vector<double> orig(gfm->getOrigin());
std::vector<double> spacing(gfm->getDXYZ());
- mcIdType dim(ToIdType(orig.size()));
+ mcIdType const dim(ToIdType(orig.size()));
std::copy(orig.begin(),orig.end(),std::ostream_iterator<double>(ofs," ")); ofs << "\" grid_description=\"";
for(mcIdType i=0;i<dim;i++)
{
for(mcIdType i=0;i<maxLev;i++)
{
std::vector<MEDCouplingCartesianAMRPatchGen *> patches(gf->retrieveGridsAt(i));
- std::size_t sz(patches.size());
+ std::size_t const sz(patches.size());
std::vector< MCAuto<MEDCouplingCartesianAMRPatchGen> > patchesSafe(sz);
for(std::size_t j=0;j<sz;j++)
patchesSafe[j]=patches[j];
for(std::vector<MEDCouplingCartesianAMRPatchGen *>::const_iterator it=patches.begin();it!=patches.end();it++,jj++,kk++)
{
ofs << " <DataSet index=\"" << jj << "\" amr_box=\"";
- const MEDCouplingCartesianAMRPatch *patchCast(dynamic_cast<const MEDCouplingCartesianAMRPatch *>(*it));
+ const auto *patchCast(dynamic_cast<const MEDCouplingCartesianAMRPatch *>(*it));
const MEDCouplingCartesianAMRMeshGen *mesh((*it)->getMesh());
if(patchCast)
{
{
const DataArrayDoubleCollection& ddc(_levs[i]->getFieldsAt(tmp));
std::vector<DataArrayDouble *> arrs(ddc.retrieveFields());
- std::size_t nbFields(arrs.size());
+ std::size_t const nbFields(arrs.size());
std::vector< MCAuto<DataArrayDouble> > arrsSafe(nbFields),arrs2Safe(nbFields);
std::vector< const MEDCouplingFieldDouble *> fields(nbFields);
std::vector< MCAuto<MEDCouplingFieldDouble> > fieldsSafe(nbFields);
arrsSafe[pp]=arrs[pp];
for(std::size_t pp=0;pp<nbFields;pp++)
{
- MCAuto<MEDCouplingIMesh> im(mesh->getImageMesh()->buildWithGhost(_ghost_lev));
+ MCAuto<MEDCouplingIMesh> const im(mesh->getImageMesh()->buildWithGhost(_ghost_lev));
std::vector<mcIdType> cgs(mesh->getImageMesh()->getCellGridStructure()),cgsWG(im->getCellGridStructure());
arrs2Safe[pp]=DataArrayDouble::New();
arrs2Safe[pp]->alloc(mesh->getImageMesh()->getNumberOfCells(),arrs[pp]->getNumberOfComponents());
std::vector< std::pair<mcIdType,mcIdType> > cgs2(MEDCouplingStructuredMesh::GetCompactFrmtFromDimensions(cgs));
MEDCouplingStructuredMesh::ApplyGhostOnCompactFrmt(cgs2,_ghost_lev);
- std::vector<mcIdType> fakeFactors(mesh->getImageMesh()->getSpaceDimension(),1);
+ std::vector<mcIdType> const fakeFactors(mesh->getImageMesh()->getSpaceDimension(),1);
MEDCouplingIMesh::SpreadCoarseToFine(arrs[pp],cgsWG,arrs2Safe[pp],cgs2,fakeFactors);
arrs2Safe[pp]->copyStringInfoFrom(*arrs[pp]);
//
const MEDCouplingGridCollection *lev0(_levs[0]);
if(!lev0)
throw INTERP_KERNEL::Exception("MEDCouplingAMRAttribute::projectTo : lev0 is NULL !");
- std::vector< std::pair < std::string, std::vector<std::string> > > fieldNames(lev0->getInfoOnComponents());
+ std::vector< std::pair < std::string, std::vector<std::string> > > const fieldNames(lev0->getInfoOnComponents());
MCAuto<MEDCouplingAMRAttribute> ret(MEDCouplingAMRAttribute::New(targetGF,fieldNames,_ghost_lev));
ret->spillNatures(lev0->getNatures());
ret->alloc();
- mcIdType nbLevs(getNumberOfLevels());
+ mcIdType const nbLevs(getNumberOfLevels());
if(targetGF->getMaxNumberOfLevelsRelativeToThis()!=nbLevs)
throw INTERP_KERNEL::Exception("MEDCouplingAMRAttribute::projectTo : number of levels of this and targetGF must be the same !");
// first step copy level0
*/
void MEDCouplingAMRAttribute::synchronizeFineToCoarseBetween(mcIdType fromLev, mcIdType toLev)
{
- mcIdType nbl(getNumberOfLevels());
+ mcIdType const nbl(getNumberOfLevels());
if(fromLev<0 || toLev<0 || fromLev>=nbl || toLev>=nbl)
throw INTERP_KERNEL::Exception("MEDCouplingAMRAttribute::synchronizeFineToCoarseBetween : fromLev and toLev must be >= 0 and lower than number of levels in this !");
if(fromLev==toLev)
{
if(_levs.empty())
throw INTERP_KERNEL::Exception("MEDCouplingAMRAttribute::synchronizeCoarseToFine : not any levels in this !");
- std::size_t sz(_levs.size());
+ std::size_t const sz(_levs.size());
//
for(std::size_t i=0;i<sz-1;i++)
synchronizeCoarseToFineByOneLevel(ToIdType(i));
*/
void MEDCouplingAMRAttribute::synchronizeCoarseToFineBetween(mcIdType fromLev, mcIdType toLev)
{
- mcIdType nbl(getNumberOfLevels());
+ mcIdType const nbl(getNumberOfLevels());
if(fromLev<0 || toLev<0 || fromLev>=nbl || toLev>=nbl)
throw INTERP_KERNEL::Exception("MEDCouplingAMRAttribute::synchronizeCoarseToFineBetween : fromLev and toLev must be >= 0 and lower than number of levels in this !");
if(fromLev==toLev)
*/
void MEDCouplingAMRAttribute::synchronizeAllGhostZones()
{
- mcIdType sz(getNumberOfLevels());
+ mcIdType const sz(getNumberOfLevels());
if(sz==0)
throw INTERP_KERNEL::Exception("MEDCouplingAMRAttribute::synchronizeFineEachOther : not any levels in this !");
// 1st - synchronize from coarse to the finest all the patches (excepted the god father one)
curLev->synchronizeFineEachOther(_ghost_lev,_neighbors[i]);
}
// 3rd - mixed level
- for(std::vector< std::pair<const MEDCouplingCartesianAMRPatch *,const MEDCouplingCartesianAMRPatch *> >::const_iterator it=_mixed_lev_neighbors.begin();it!=_mixed_lev_neighbors.end();it++)
+ for(const auto & _mixed_lev_neighbor : _mixed_lev_neighbors)
{
- const DataArrayDoubleCollection *firstDAC(&findCollectionAttachedTo((*it).first->getMesh())),*secondDAC(&findCollectionAttachedTo((*it).second->getMesh()));
- DataArrayDoubleCollection::SynchronizeGhostZoneOfOneUsingTwo(_ghost_lev,(*it).first,firstDAC,(*it).second,secondDAC);
+ const DataArrayDoubleCollection *firstDAC(&findCollectionAttachedTo(_mixed_lev_neighbor.first->getMesh())),*secondDAC(&findCollectionAttachedTo(_mixed_lev_neighbor.second->getMesh()));
+ DataArrayDoubleCollection::SynchronizeGhostZoneOfOneUsingTwo(_ghost_lev,_mixed_lev_neighbor.first,firstDAC,_mixed_lev_neighbor.second,secondDAC);
}
// 4th - same level but with far ancestor.
for(mcIdType i=1;i<sz;i++)
throw INTERP_KERNEL::Exception("MEDCouplingAMRAttribute::synchronizeAllGhostZonesOfDirectChidrenOf : the specified level does not exist ! Must be in [0,nbOfLevelsOfThis-1) !");
const std::vector< std::pair<const MEDCouplingCartesianAMRPatch *,const MEDCouplingCartesianAMRPatch *> >& itemsToFilter(_neighbors[level+1]);
std::vector< std::pair<const MEDCouplingCartesianAMRPatch *,const MEDCouplingCartesianAMRPatch *> > itemsToSync; itemsToSync.reserve(itemsToFilter.size());
- for(std::vector< std::pair<const MEDCouplingCartesianAMRPatch *,const MEDCouplingCartesianAMRPatch *> >::const_iterator it=itemsToFilter.begin();it!=itemsToFilter.end();it++)
+ for(const auto & it : itemsToFilter)
{
- if((*it).first->getMesh()->getFather()==mesh && (*it).second->getMesh()->getFather()==mesh)
- itemsToSync.push_back(std::pair<const MEDCouplingCartesianAMRPatch *,const MEDCouplingCartesianAMRPatch *>((*it).first,(*it).second));
+ if(it.first->getMesh()->getFather()==mesh && it.second->getMesh()->getFather()==mesh)
+ itemsToSync.push_back(std::pair<const MEDCouplingCartesianAMRPatch *,const MEDCouplingCartesianAMRPatch *>(it.first,it.second));
}
const MEDCouplingGridCollection *curLev(_levs[level+1]);
if(!curLev)
*/
void MEDCouplingAMRAttribute::synchronizeAllGhostZonesAtASpecifiedLevel(mcIdType level)
{
- mcIdType maxLev(getNumberOfLevels());
+ mcIdType const maxLev(getNumberOfLevels());
if(level<0 || level>=maxLev)
throw INTERP_KERNEL::Exception("MEDCouplingAMRAttribute::synchronizeAllGhostZonesAtASpecifiedLevel : the specified level must be in [0,maxLevel) !");
if(level==0)
*/
void MEDCouplingAMRAttribute::synchronizeAllGhostZonesAtASpecifiedLevelUsingOnlyFather(mcIdType level)
{
- mcIdType maxLev(getNumberOfLevels());
+ mcIdType const maxLev(getNumberOfLevels());
if(level<=0 || level>=maxLev)
throw INTERP_KERNEL::Exception("MEDCouplingAMRAttribute::synchronizeAllGhostZonesAtASpecifiedLevelUsingOnlyFather : the specified level must be in (0,maxLevel) !");
const MEDCouplingGridCollection *fine(_levs[level]),*coarse(_levs[level-1]);
void MEDCouplingAMRAttribute::alloc()
{
_tlc.resetState();
- for(std::vector< MCAuto<MEDCouplingGridCollection> >::iterator it=_levs.begin();it!=_levs.end();it++)
+ for(auto & _lev : _levs)
{
- MEDCouplingGridCollection *elt(*it);
+ MEDCouplingGridCollection *elt(_lev);
if(elt)
elt->alloc(_ghost_lev);
else
void MEDCouplingAMRAttribute::dealloc()
{
_tlc.checkConst();
- for(std::vector< MCAuto<MEDCouplingGridCollection> >::iterator it=_levs.begin();it!=_levs.end();it++)
+ for(auto & _lev : _levs)
{
- MEDCouplingGridCollection *elt(*it);
+ MEDCouplingGridCollection *elt(_lev);
if(elt)
elt->dealloc();
else
bool MEDCouplingAMRAttribute::changeGodFather(MEDCouplingCartesianAMRMesh *gf)
{
- bool ret(MEDCouplingDataForGodFather::changeGodFather(gf));
+ bool const ret(MEDCouplingDataForGodFather::changeGodFather(gf));
return ret;
}
std::vector<const BigMemoryObject *> MEDCouplingAMRAttribute::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
- for(std::vector< MCAuto<MEDCouplingGridCollection> >::const_iterator it=_levs.begin();it!=_levs.end();it++)
- ret.push_back((const MEDCouplingGridCollection *)*it);
+ for(const auto & _lev : _levs)
+ ret.push_back((const MEDCouplingGridCollection *)_lev);
return ret;
}
MEDCouplingAMRAttribute::MEDCouplingAMRAttribute(MEDCouplingCartesianAMRMesh *gf, const std::vector< std::pair<std::string,int> >& fieldNames, mcIdType ghostLev):MEDCouplingDataForGodFather(gf),_ghost_lev(ghostLev)
{
//gf non empty, checked by constructor
- mcIdType maxLev(gf->getMaxNumberOfLevelsRelativeToThis());
+ mcIdType const maxLev(gf->getMaxNumberOfLevelsRelativeToThis());
_levs.resize(maxLev);
for(mcIdType i=0;i<maxLev;i++)
{
std::vector<MEDCouplingCartesianAMRPatchGen *> patches(gf->retrieveGridsAt(i));
- std::size_t sz(patches.size());
+ std::size_t const sz(patches.size());
std::vector< MCAuto<MEDCouplingCartesianAMRPatchGen> > patchesSafe(patches.size());
for(std::size_t j=0;j<sz;j++)
patchesSafe[j]=patches[j];
_cross_lev_neighbors.resize(_levs.size());
if(_levs.empty())
throw INTERP_KERNEL::Exception("constructor of MEDCouplingAMRAttribute : not any levels in this !");
- std::size_t sz(_levs.size());
+ std::size_t const sz(_levs.size());
for(std::size_t i=1;i<sz;i++)
{
const MEDCouplingGridCollection *fine(_levs[i]);
{
MEDCouplingCartesianAMRPatch::FindNeighborsOfSubPatchesOf(_ghost_lev,(*it).first,(*it).second,_mixed_lev_neighbors);
std::vector< std::vector < std::pair<const MEDCouplingCartesianAMRPatch *,const MEDCouplingCartesianAMRPatch *> > > neighs2(MEDCouplingCartesianAMRPatch::FindNeighborsOfSubPatchesOfSameLev(_ghost_lev,(*it).first,(*it).second));
- std::size_t fullLev(i+neighs2.size());
+ std::size_t const fullLev(i+neighs2.size());
if(fullLev>=sz)
throw INTERP_KERNEL::Exception("constructor of MEDCouplingAMRAttribute : internal error ! something is wrong in computation of cross level neighbors !");
std::size_t ii(i+1);
for(std::size_t i=0;i<sz;i++)
{
const std::vector< std::pair<const MEDCouplingCartesianAMRPatch *,const MEDCouplingCartesianAMRPatch *> >& neigh2(other._neighbors[i]);
- std::size_t sz2(neigh2.size());
+ std::size_t const sz2(neigh2.size());
std::vector< std::pair<const MEDCouplingCartesianAMRPatch *,const MEDCouplingCartesianAMRPatch *> >& neigh3(_neighbors[i]);
for(std::size_t j=0;j<sz2;j++)
{
for(std::size_t i=0;i<sz;i++)
{
const std::vector< std::pair<const MEDCouplingCartesianAMRPatch *,const MEDCouplingCartesianAMRPatch *> >& neigh2(other._cross_lev_neighbors[i]);
- std::size_t sz2(neigh2.size());
+ std::size_t const sz2(neigh2.size());
std::vector< std::pair<const MEDCouplingCartesianAMRPatch *,const MEDCouplingCartesianAMRPatch *> >& neigh3(_cross_lev_neighbors[i]);
for(std::size_t j=0;j<sz2;j++)
{
const DataArrayDoubleCollection& MEDCouplingAMRAttribute::findCollectionAttachedTo(const MEDCouplingCartesianAMRMeshGen *m) const
{
- for(std::vector< MCAuto<MEDCouplingGridCollection> >::const_iterator it=_levs.begin();it!=_levs.end();it++)
+ for(const auto & _lev : _levs)
{
- const MEDCouplingGridCollection *elt(*it);
+ const MEDCouplingGridCollection *elt(_lev);
if(elt)
{
mcIdType tmp(-1);
void MEDCouplingAMRAttribute::synchronizeFineToCoarseByOneLevel(mcIdType level)
{
- mcIdType nbl(getNumberOfLevels());
+ mcIdType const nbl(getNumberOfLevels());
if(level<=0 || level>=nbl)
throw INTERP_KERNEL::Exception("MEDCouplingAMRAttribute::synchronizeFineToCoarseByOneLevel : the input level must be in ]0,nb_of_levels[ !");
const MEDCouplingGridCollection *fine(_levs[level]),*coarse(_levs[level-1]);
void MEDCouplingAMRAttribute::synchronizeCoarseToFineByOneLevel(mcIdType level)
{
- mcIdType nbl(getNumberOfLevels());
+ mcIdType const nbl(getNumberOfLevels());
if(level<0 || level>=nbl-1)
throw INTERP_KERNEL::Exception("MEDCouplingAMRAttribute::synchronizeFineToCoarseByOneLevel : the input level must be in [0,nb_of_levels[ !");
const MEDCouplingGridCollection *fine(_levs[level+1]),*coarse(_levs[level]);
#ifndef __MEDCOUPLINGAMRATTRIBUTE_HXX__
#define __MEDCOUPLINGAMRATTRIBUTE_HXX__
+#include "MCType.hxx"
+#include "MCAuto.hxx"
#include "MEDCoupling.hxx"
#include "MEDCouplingNatureOfFieldEnum"
#include "MEDCouplingCartesianAMRMesh.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingTimeLabel.hxx"
+#include <vector>
+#include <utility>
+#include <string>
+#include <cstddef>
namespace MEDCoupling
{
private:
DataArrayDoubleCollection(const std::vector< std::pair<std::string,int> >& fieldNames);
DataArrayDoubleCollection(const DataArrayDoubleCollection& other);
- std::size_t getHeapMemorySizeWithoutChildren() const;
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- void updateTime() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ void updateTime() const override;
static void CheckDiscriminantNames(const std::vector<std::string>& names);
static bool IsConservativeNature(NatureOfField n);
static void CheckSameNatures(NatureOfField n1, NatureOfField n2);
private:
MEDCouplingGridCollection(const std::vector<const MEDCouplingCartesianAMRMeshGen *>& ms, const std::vector< std::pair<std::string,int> >& fieldNames);
MEDCouplingGridCollection(const MEDCouplingGridCollection& other, const MEDCouplingCartesianAMRMeshGen *newGf, const MEDCouplingCartesianAMRMeshGen *oldGf);
- std::size_t getHeapMemorySizeWithoutChildren() const;
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- void updateTime() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ void updateTime() const override;
private:
std::vector< std::pair<const MEDCouplingCartesianAMRMeshGen *,MCAuto<DataArrayDoubleCollection> > > _map_of_dadc;
};
//
MEDCOUPLING_EXPORT MEDCouplingAMRAttribute *projectTo(MEDCouplingCartesianAMRMesh *targetGF) const;
//
- MEDCOUPLING_EXPORT void synchronizeFineToCoarse();
- MEDCOUPLING_EXPORT void synchronizeFineToCoarseBetween(mcIdType fromLev, mcIdType toLev);
- MEDCOUPLING_EXPORT void synchronizeCoarseToFine();
- MEDCOUPLING_EXPORT void synchronizeCoarseToFineBetween(mcIdType fromLev, mcIdType toLev);
- MEDCOUPLING_EXPORT void synchronizeAllGhostZones();
- MEDCOUPLING_EXPORT void synchronizeAllGhostZonesOfDirectChidrenOf(const MEDCouplingCartesianAMRMeshGen *mesh);
- MEDCOUPLING_EXPORT void synchronizeAllGhostZonesAtASpecifiedLevel(mcIdType level);
- MEDCOUPLING_EXPORT void synchronizeAllGhostZonesAtASpecifiedLevelUsingOnlyFather(mcIdType level);
+ MEDCOUPLING_EXPORT void synchronizeFineToCoarse() override;
+ MEDCOUPLING_EXPORT void synchronizeFineToCoarseBetween(mcIdType fromLev, mcIdType toLev) override;
+ MEDCOUPLING_EXPORT void synchronizeCoarseToFine() override;
+ MEDCOUPLING_EXPORT void synchronizeCoarseToFineBetween(mcIdType fromLev, mcIdType toLev) override;
+ MEDCOUPLING_EXPORT void synchronizeAllGhostZones() override;
+ MEDCOUPLING_EXPORT void synchronizeAllGhostZonesOfDirectChidrenOf(const MEDCouplingCartesianAMRMeshGen *mesh) override;
+ MEDCOUPLING_EXPORT void synchronizeAllGhostZonesAtASpecifiedLevel(mcIdType level) override;
+ MEDCOUPLING_EXPORT void synchronizeAllGhostZonesAtASpecifiedLevelUsingOnlyFather(mcIdType level) override;
//
- MEDCOUPLING_EXPORT void alloc();
- MEDCOUPLING_EXPORT void dealloc();
- MEDCOUPLING_EXPORT bool changeGodFather(MEDCouplingCartesianAMRMesh *gf);
+ MEDCOUPLING_EXPORT void alloc() override;
+ MEDCOUPLING_EXPORT void dealloc() override;
+ MEDCOUPLING_EXPORT bool changeGodFather(MEDCouplingCartesianAMRMesh *gf) override;
//
- MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- MEDCOUPLING_EXPORT void updateTime() const;
+ MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ MEDCOUPLING_EXPORT void updateTime() const override;
private:
MEDCouplingAMRAttribute(MEDCouplingCartesianAMRMesh *gf, const std::vector< std::pair<std::string,int> >& fieldNames, mcIdType ghostLev);
MEDCouplingAMRAttribute(const MEDCouplingAMRAttribute& other, bool deepCpyGF);
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingCMesh.hxx"
+#include "MCAuto.hxx"
+#include "MCType.hxx"
+#include "MCIdType.hxx"
#include "MEDCouplingMemArray.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "MEDCouplingCurveLinearMesh.hxx"
#include "InterpKernelAutoPtr.hxx"
+#include "MEDCouplingStructuredMesh.hxx"
+#include "MEDCouplingMesh.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include <cstddef>
#include <functional>
#include <algorithm>
+#include <iterator>
+#include <ostream>
#include <sstream>
-#include <numeric>
+#include <string>
+#include <vector>
+#include <utility>
using namespace MEDCoupling;
-MEDCouplingCMesh::MEDCouplingCMesh():_x_array(0),_y_array(0),_z_array(0)
+MEDCouplingCMesh::MEDCouplingCMesh():_x_array(nullptr),_y_array(nullptr),_z_array(nullptr)
{
}
if(other._x_array)
_x_array=other._x_array->deepCopy();
else
- _x_array=0;
+ _x_array=nullptr;
if(other._y_array)
_y_array=other._y_array->deepCopy();
else
- _y_array=0;
+ _y_array=nullptr;
if(other._z_array)
_z_array=other._z_array->deepCopy();
else
- _z_array=0;
+ _z_array=nullptr;
}
else
{
MEDCouplingCMesh *MEDCouplingCMesh::New(const std::string& meshName)
{
- MEDCouplingCMesh *ret(new MEDCouplingCMesh);
+ auto *ret(new MEDCouplingCMesh);
ret->setName(meshName);
return ret;
}
MEDCouplingCurveLinearMesh *MEDCouplingCMesh::buildCurveLinear() const
{
checkConsistencyLight();
- std::size_t dim(getSpaceDimension());
+ std::size_t const dim(getSpaceDimension());
MCAuto<MEDCouplingCurveLinearMesh> ret(MEDCouplingCurveLinearMesh::New());
ret->MEDCouplingStructuredMesh::operator=(*this);
INTERP_KERNEL::AutoPtr<mcIdType> ngs(new mcIdType[dim]);
void MEDCouplingCMesh::copyTinyStringsFrom(const MEDCouplingMesh *other)
{
MEDCouplingStructuredMesh::copyTinyStringsFrom(other);
- const MEDCouplingCMesh *otherC(dynamic_cast<const MEDCouplingCMesh *>(other));
+ const auto *otherC(dynamic_cast<const MEDCouplingCMesh *>(other));
if(!otherC)
throw INTERP_KERNEL::Exception("MEDCouplingCMesh::copyTinyStringsFrom : meshes have not same type !");
if(_x_array && otherC->_x_array)
{
if(!other)
throw INTERP_KERNEL::Exception("MEDCouplingCMesh::isEqualIfNotWhy : input other pointer is null !");
- const MEDCouplingCMesh *otherC=dynamic_cast<const MEDCouplingCMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingCMesh *>(other);
if(!otherC)
{
reason="mesh given in input is not castable in MEDCouplingCMesh !";
std::ostringstream oss; oss.precision(15);
for(int i=0;i<3;i++)
{
- if((thisArr[i]!=0 && otherArr[i]==0) || (thisArr[i]==0 && otherArr[i]!=0))
+ if((thisArr[i]!=nullptr && otherArr[i]==nullptr) || (thisArr[i]==nullptr && otherArr[i]!=nullptr))
{
oss << "Only one CMesh between the two this and other has its coordinates of rank" << i << " defined !";
reason=oss.str();
bool MEDCouplingCMesh::isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const
{
- const MEDCouplingCMesh *otherC=dynamic_cast<const MEDCouplingCMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingCMesh *>(other);
if(!otherC)
return false;
const DataArrayDouble *thisArr[3]={_x_array,_y_array,_z_array};
const DataArrayDouble *otherArr[3]={otherC->_x_array,otherC->_y_array,otherC->_z_array};
for(int i=0;i<3;i++)
{
- if((thisArr[i]!=0 && otherArr[i]==0) || (thisArr[i]==0 && otherArr[i]!=0))
+ if((thisArr[i]!=nullptr && otherArr[i]==nullptr) || (thisArr[i]==nullptr && otherArr[i]!=nullptr))
return false;
if(thisArr[i])
if(!thisArr[i]->isEqualWithoutConsideringStr(*otherArr[i],prec))
return true;
}
-void MEDCouplingCMesh::checkDeepEquivalWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
- DataArrayIdType *&cellCor, DataArrayIdType *&nodeCor) const
+void MEDCouplingCMesh::checkDeepEquivalWith(const MEDCouplingMesh *other, int /*cellCompPol*/, double prec,
+ DataArrayIdType *& /*cellCor*/, DataArrayIdType *& /*nodeCor*/) const
{
if(!isEqualWithoutConsideringStr(other,prec))
throw INTERP_KERNEL::Exception("MEDCouplingCMesh::checkDeepEquivalWith : Meshes are not the same !");
* Nothing is done here (except to check that the other is a MEDCoupling::MEDCouplingCMesh instance too).
* The user intend that the nodes are the same, so by construction of MEDCoupling::MEDCouplingCMesh, \a this and \a other are the same !
*/
-void MEDCouplingCMesh::checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
- DataArrayIdType *&cellCor) const
+void MEDCouplingCMesh::checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *other, int /*cellCompPol*/, double prec,
+ DataArrayIdType *& /*cellCor*/) const
{
if(!isEqualWithoutConsideringStr(other,prec))
throw INTERP_KERNEL::Exception("MEDCouplingCMesh::checkDeepEquivalOnSameNodesWith : Meshes are not the same !");
MEDCouplingStructuredMesh *MEDCouplingCMesh::buildStructuredSubPart(const std::vector< std::pair<mcIdType,mcIdType> >& cellPart) const
{
checkConsistencyLight();
- int dim(getSpaceDimension());
+ int const dim(getSpaceDimension());
if(dim!=ToIdType(cellPart.size()))
{
std::ostringstream oss; oss << "MEDCouplingCMesh::buildStructuredSubPart : the space dimension is " << dim << " and cell part size is " << cellPart.size() << " !";
void MEDCouplingCMesh::getCoordinatesOfNode(mcIdType nodeId, std::vector<double>& coo) const
{
mcIdType tmp[3];
- int spaceDim=getSpaceDimension();
+ int const spaceDim=getSpaceDimension();
getSplitNodeValues(tmp);
const DataArrayDouble *tabs[3]={getCoordsAt(0),getCoordsAt(1),getCoordsAt(2)};
mcIdType tmp2[3];
ret << "Cartesian mesh with name : \"" << getName() << "\"\n";
ret << "Description of mesh : \"" << getDescription() << "\"\n";
int tmpp1,tmpp2;
- double tt=getTime(tmpp1,tmpp2);
+ double const tt=getTime(tmpp1,tmpp2);
ret << "Time attached to the mesh [unit] : " << tt << " [" << getTimeUnit() << "]\n";
ret << "Iteration : " << tmpp1 << " Order : " << tmpp2 << "\n";
ret << "Space dimension : " << getSpaceDimension() << "\n\nArrays :\n________\n\n";
void MEDCouplingCMesh::getBoundingBox(double *bbox) const
{
- int dim=getSpaceDimension();
+ int const dim=getSpaceDimension();
int j=0;
for (int idim=0; idim<dim; idim++)
{
if(c)
{
const double *coords=c->getConstPointer();
- mcIdType nb=ToIdType(c->getNbOfElems());
+ mcIdType const nb=ToIdType(c->getNbOfElems());
bbox[2*j]=coords[0];
bbox[2*j+1]=coords[nb-1];
j++;
* and one time . The caller is to delete this field using decrRef() as it is no
* more needed.
*/
-MEDCouplingFieldDouble *MEDCouplingCMesh::getMeasureField(bool isAbs) const
+MEDCouplingFieldDouble *MEDCouplingCMesh::getMeasureField(bool /*isAbs*/) const
{
std::string name="MeasureOfMesh_";
name+=getName();
- mcIdType nbelem=ToIdType(getNumberOfCells());
+ mcIdType const nbelem=ToIdType(getNumberOfCells());
MEDCouplingFieldDouble *field=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
field->setName(name);
DataArrayDouble* array=DataArrayDouble::New();
field->synchronizeTimeWithMesh();
mcIdType tmp[3];
getSplitCellValues(tmp);
- int dim=getSpaceDimension();
- const double **thisArr=new const double *[dim];
+ int const dim=getSpaceDimension();
+ const auto **thisArr=new const double *[dim];
const DataArrayDouble *thisArr2[3]={_x_array,_y_array,_z_array};
for(int i=0;i<dim;i++)
thisArr[i]=thisArr2[i]->getConstPointer();
/*!
* not implemented yet !
*/
-MEDCouplingFieldDouble *MEDCouplingCMesh::getMeasureFieldOnNode(bool isAbs) const
+MEDCouplingFieldDouble *MEDCouplingCMesh::getMeasureFieldOnNode(bool /*isAbs*/) const
{
throw INTERP_KERNEL::Exception("MEDCouplingCMesh::getMeasureFieldOnNode : not implemented yet !");
//return 0;
mcIdType MEDCouplingCMesh::getCellContainingPoint(const double *pos, double eps) const
{
- int dim=getSpaceDimension();
+ int const dim=getSpaceDimension();
mcIdType ret=0;
mcIdType coeff=1;
for(int i=0;i<dim;i++)
{
const double *d=getCoordsAt(i)->getConstPointer();
- mcIdType nbOfNodes=getCoordsAt(i)->getNbOfElems();
- double ref=pos[i];
+ mcIdType const nbOfNodes=getCoordsAt(i)->getNbOfElems();
+ double const ref=pos[i];
const double *w=std::find_if(d,d+nbOfNodes,std::bind(std::greater_equal<double>(),std::placeholders::_1,ref));
mcIdType w2=ToIdType(std::distance(d,w));
if(w2<nbOfNodes)
void MEDCouplingCMesh::getCellsContainingPoint(const double *pos, double eps, std::vector<mcIdType>& elts) const
{
- mcIdType ret(getCellContainingPoint(pos,eps));
+ mcIdType const ret(getCellContainingPoint(pos,eps));
elts.push_back(ret);
}
-void MEDCouplingCMesh::rotate(const double *center, const double *vector, double angle)
+void MEDCouplingCMesh::rotate(const double * /*center*/, const double * /*vector*/, double /*angle*/)
{
throw INTERP_KERNEL::Exception("No rotation available on CMesh : Traduce it to untructured mesh to apply it !");
}
if(c)
{
double *coords=c->getPointer();
- mcIdType lgth=ToIdType(c->getNbOfElems());
+ mcIdType const lgth=ToIdType(c->getNbOfElems());
std::transform(coords,coords+lgth,coords,std::bind(std::minus<double>(),std::placeholders::_1,point[i]));
std::transform(coords,coords+lgth,coords,std::bind(std::multiplies<double>(),std::placeholders::_1,factor));
std::transform(coords,coords+lgth,coords,std::bind(std::plus<double>(),std::placeholders::_1,point[i]));
updateTime();
}
-MEDCouplingMesh *MEDCouplingCMesh::mergeMyselfWith(const MEDCouplingMesh *other) const
+MEDCouplingMesh *MEDCouplingCMesh::mergeMyselfWith(const MEDCouplingMesh * /*other*/) const
{
//not implemented yet !
- return 0;
+ return nullptr;
}
/*!
DataArrayDouble *MEDCouplingCMesh::getCoordinatesAndOwner() const
{
MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
- int spaceDim(getSpaceDimension());
- mcIdType nbNodes(getNumberOfNodes());
+ int const spaceDim(getSpaceDimension());
+ mcIdType const nbNodes(getNumberOfNodes());
ret->alloc(nbNodes,spaceDim);
double *pt(ret->getPointer());
mcIdType tmp[3];
DataArrayDouble *MEDCouplingCMesh::computeCellCenterOfMass() const
{
DataArrayDouble *ret=DataArrayDouble::New();
- int spaceDim=getSpaceDimension();
- mcIdType nbCells=ToIdType(getNumberOfCells());
+ int const spaceDim=getSpaceDimension();
+ mcIdType const nbCells=ToIdType(getNumberOfCells());
ret->alloc(nbCells,spaceDim);
double *pt=ret->getPointer();
mcIdType tmp[3];
std::vector<double> tabsPtr[3];
for(int j=0;j<spaceDim;j++)
{
- mcIdType sz=tabs[j]->getNbOfElems()-1;
+ mcIdType const sz=tabs[j]->getNbOfElems()-1;
ret->setInfoOnComponent(j,tabs[j]->getInfoOnComponent(0));
const double *srcPtr=tabs[j]->getConstPointer();
tabsPtr[j].insert(tabsPtr[j].end(),srcPtr,srcPtr+sz);
return MEDCouplingCMesh::computeCellCenterOfMass();
}
-void MEDCouplingCMesh::renumberCells(const mcIdType *old2NewBg, bool check)
+void MEDCouplingCMesh::renumberCells(const mcIdType * /*old2NewBg*/, bool /*check*/)
{
throw INTERP_KERNEL::Exception("Functionality of renumbering cell not available for CMesh !");
}
void MEDCouplingCMesh::getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const
{
int it,order;
- double time=getTime(it,order);
+ double const time=getTime(it,order);
tinyInfo.clear();
tinyInfoD.clear();
littleStrings.clear();
littleStrings.push_back(getDescription());
littleStrings.push_back(getTimeUnit());
const DataArrayDouble *thisArr[3]={_x_array,_y_array,_z_array};
- for(int i=0;i<3;i++)
+ for(auto & i : thisArr)
{
mcIdType val=-1;
std::string st;
- if(thisArr[i])
+ if(i)
{
- val=thisArr[i]->getNumberOfTuples();
- st=thisArr[i]->getInfoOnComponent(0);
+ val=i->getNumberOfTuples();
+ st=i->getInfoOnComponent(0);
}
tinyInfo.push_back(val);
littleStrings.push_back(st);
tinyInfoD.push_back(time);
}
-void MEDCouplingCMesh::resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const
+void MEDCouplingCMesh::resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& /*littleStrings*/) const
{
a1->alloc(0,1);
mcIdType sum=0;
a1->alloc(0,1);
const DataArrayDouble *thisArr[3]={_x_array,_y_array,_z_array};
mcIdType sz=0;
- for(int i=0;i<3;i++)
+ for(auto & i : thisArr)
{
- if(thisArr[i])
- sz+=thisArr[i]->getNumberOfTuples();
+ if(i)
+ sz+=i->getNumberOfTuples();
}
a2=DataArrayDouble::New();
a2->alloc(sz,1);
double *a2Ptr=a2->getPointer();
- for(int i=0;i<3;i++)
- if(thisArr[i])
- a2Ptr=std::copy(thisArr[i]->getConstPointer(),thisArr[i]->getConstPointer()+thisArr[i]->getNumberOfTuples(),a2Ptr);
+ for(auto & i : thisArr)
+ if(i)
+ a2Ptr=std::copy(i->getConstPointer(),i->getConstPointer()+i->getNumberOfTuples(),a2Ptr);
}
-void MEDCouplingCMesh::unserialization(const std::vector<double>& tinyInfoD, const std::vector<mcIdType>& tinyInfo, const DataArrayIdType *a1, DataArrayDouble *a2,
+void MEDCouplingCMesh::unserialization(const std::vector<double>& tinyInfoD, const std::vector<mcIdType>& tinyInfo, const DataArrayIdType * /*a1*/, DataArrayDouble *a2,
const std::vector<std::string>& littleStrings)
{
setName(littleStrings[0]);
{
std::ostringstream extent;
DataArrayDouble *thisArr[3]={_x_array,_y_array,_z_array};
- for(int i=0;i<3;i++)
+ for(auto & i : thisArr)
{
- if(thisArr[i])
- { extent << "0 " << thisArr[i]->getNumberOfTuples()-1 << " "; }
+ if(i)
+ { extent << "0 " << i->getNumberOfTuples()-1 << " "; }
else
{ extent << "0 0 "; }
}
ofs << " <CellData>\n" << cellData << std::endl;
ofs << " </CellData>\n";
ofs << " <Coordinates>\n";
- for(int i=0;i<3;i++)
+ for(auto & i : thisArr)
{
- if(thisArr[i])
- thisArr[i]->writeVTK(ofs,8,"Array",byteData);
+ if(i)
+ i->writeVTK(ofs,8,"Array",byteData);
else
{
MCAuto<DataArrayDouble> coo=DataArrayDouble::New(); coo->alloc(1,1);
mcIdType nbOfCells=1,nbOfNodes=1;
for(int i=0;i<3;i++)
{
- isDef[i]=thisArr[i]!=0;
+ isDef[i]=thisArr[i]!=nullptr;
if(isDef[i])
{
- char tmp=(char)((int)('X')+i);
+ char const tmp=(char)((int)('X')+i);
stream2[i] << tmp << " positions array ";
if(!thisArr[i]->isAllocated())
stream2[i] << "set but not allocated.";
else
{
- std::size_t nbCompo=thisArr[i]->getNumberOfComponents();
+ std::size_t const nbCompo=thisArr[i]->getNumberOfComponents();
if(nbCompo==1)
{
- mcIdType nbTuples=thisArr[i]->getNumberOfTuples();
+ mcIdType const nbTuples=thisArr[i]->getNumberOfTuples();
if(nbTuples<1)
{ stream2[i] << "set and allocated - WARNING number of elements < 1 !"; nbOfCells=-1; nbOfNodes=-1; }
else
#ifndef __PARAMEDMEM_MEDCOUPLINGCMESH_HXX__
#define __PARAMEDMEM_MEDCOUPLINGCMESH_HXX__
+#include "MCType.hxx"
#include "MEDCoupling.hxx"
+#include "MEDCouplingMesh.hxx"
+#include "MEDCouplingRefCountObject.hxx"
#include "MEDCouplingStructuredMesh.hxx"
+#include <string>
+#include <cstddef>
+#include <vector>
+#include <utility>
+#include <ostream>
namespace MEDCoupling
{
MEDCOUPLING_EXPORT static MEDCouplingCMesh *New();
MEDCOUPLING_EXPORT static MEDCouplingCMesh *New(const std::string& meshName);
MEDCOUPLING_EXPORT std::string getClassName() const override { return std::string("MEDCouplingCMesh"); }
- MEDCOUPLING_EXPORT MEDCouplingCMesh *deepCopy() const;
- MEDCOUPLING_EXPORT MEDCouplingCMesh *clone(bool recDeepCpy) const;
- MEDCOUPLING_EXPORT const DataArrayDouble *getDirectAccessOfCoordsArrIfInStructure() const;
+ MEDCOUPLING_EXPORT MEDCouplingCMesh *deepCopy() const override;
+ MEDCOUPLING_EXPORT MEDCouplingCMesh *clone(bool recDeepCpy) const override;
+ MEDCOUPLING_EXPORT const DataArrayDouble *getDirectAccessOfCoordsArrIfInStructure() const override;
MEDCOUPLING_EXPORT MEDCouplingCurveLinearMesh *buildCurveLinear() const;
- MEDCOUPLING_EXPORT void updateTime() const;
- MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- MEDCOUPLING_EXPORT MEDCouplingMeshType getType() const { return CARTESIAN; }
- MEDCOUPLING_EXPORT void copyTinyStringsFrom(const MEDCouplingMesh *other);
- MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const;
- MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const;
+ MEDCOUPLING_EXPORT void updateTime() const override;
+ MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ MEDCOUPLING_EXPORT MEDCouplingMeshType getType() const override { return CARTESIAN; }
+ MEDCOUPLING_EXPORT void copyTinyStringsFrom(const MEDCouplingMesh *other) override;
+ MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const override;
+ MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const override;
MEDCOUPLING_EXPORT void checkDeepEquivalWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
- DataArrayIdType *&cellCor, DataArrayIdType *&nodeCor) const;
+ DataArrayIdType *&cellCor, DataArrayIdType *&nodeCor) const override;
MEDCOUPLING_EXPORT void checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
- DataArrayIdType *&cellCor) const;
- MEDCOUPLING_EXPORT void checkConsistencyLight() const;
- MEDCOUPLING_EXPORT void checkConsistency(double eps=1e-12) const;
- MEDCOUPLING_EXPORT int getSpaceDimension() const;
- MEDCOUPLING_EXPORT void getCoordinatesOfNode(mcIdType nodeId, std::vector<double>& coo) const;
- MEDCOUPLING_EXPORT std::string simpleRepr() const;
- MEDCOUPLING_EXPORT std::string advancedRepr() const;
+ DataArrayIdType *&cellCor) const override;
+ MEDCOUPLING_EXPORT void checkConsistencyLight() const override;
+ MEDCOUPLING_EXPORT void checkConsistency(double eps=1e-12) const override;
+ MEDCOUPLING_EXPORT int getSpaceDimension() const override;
+ MEDCOUPLING_EXPORT void getCoordinatesOfNode(mcIdType nodeId, std::vector<double>& coo) const override;
+ MEDCOUPLING_EXPORT std::string simpleRepr() const override;
+ MEDCOUPLING_EXPORT std::string advancedRepr() const override;
MEDCOUPLING_EXPORT const DataArrayDouble *getCoordsAt(int i) const;
MEDCOUPLING_EXPORT DataArrayDouble *getCoordsAt(int i);
MEDCOUPLING_EXPORT void setCoordsAt(int i, const DataArrayDouble *arr);
MEDCOUPLING_EXPORT void setCoords(const DataArrayDouble *coordsX,
- const DataArrayDouble *coordsY=0,
- const DataArrayDouble *coordsZ=0);
+ const DataArrayDouble *coordsY=nullptr,
+ const DataArrayDouble *coordsZ=nullptr);
// tools
- MEDCOUPLING_EXPORT void getBoundingBox(double *bbox) const;
- MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureField(bool isAbs) const;
- MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureFieldOnNode(bool isAbs) const;
- MEDCOUPLING_EXPORT mcIdType getCellContainingPoint(const double *pos, double eps) const;
- MEDCOUPLING_EXPORT void getCellsContainingPoint(const double *pos, double eps, std::vector<mcIdType>& elts) const;
- MEDCOUPLING_EXPORT void rotate(const double *center, const double *vector, double angle);
- MEDCOUPLING_EXPORT void translate(const double *vector);
- MEDCOUPLING_EXPORT void scale(const double *point, double factor);
- MEDCOUPLING_EXPORT MEDCouplingMesh *mergeMyselfWith(const MEDCouplingMesh *other) const;
- MEDCOUPLING_EXPORT DataArrayDouble *getCoordinatesAndOwner() const;
- MEDCOUPLING_EXPORT DataArrayDouble *computeCellCenterOfMass() const;
- MEDCOUPLING_EXPORT DataArrayDouble *computeIsoBarycenterOfNodesPerCell() const;
- MEDCOUPLING_EXPORT void renumberCells(const mcIdType *old2NewBg, bool check=true);
+ MEDCOUPLING_EXPORT void getBoundingBox(double *bbox) const override;
+ MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureField(bool isAbs) const override;
+ MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureFieldOnNode(bool isAbs) const override;
+ MEDCOUPLING_EXPORT mcIdType getCellContainingPoint(const double *pos, double eps) const override;
+ MEDCOUPLING_EXPORT void getCellsContainingPoint(const double *pos, double eps, std::vector<mcIdType>& elts) const override;
+ MEDCOUPLING_EXPORT void rotate(const double *center, const double *vector, double angle) override;
+ MEDCOUPLING_EXPORT void translate(const double *vector) override;
+ MEDCOUPLING_EXPORT void scale(const double *point, double factor) override;
+ MEDCOUPLING_EXPORT MEDCouplingMesh *mergeMyselfWith(const MEDCouplingMesh *other) const override;
+ MEDCOUPLING_EXPORT DataArrayDouble *getCoordinatesAndOwner() const override;
+ MEDCOUPLING_EXPORT DataArrayDouble *computeCellCenterOfMass() const override;
+ MEDCOUPLING_EXPORT DataArrayDouble *computeIsoBarycenterOfNodesPerCell() const override;
+ MEDCOUPLING_EXPORT void renumberCells(const mcIdType *old2NewBg, bool check=true) override;
//some useful methods
- MEDCOUPLING_EXPORT void getNodeGridStructure(mcIdType *res) const;
- MEDCOUPLING_EXPORT std::vector<mcIdType> getNodeGridStructure() const;
- MEDCouplingStructuredMesh *buildStructuredSubPart(const std::vector< std::pair<mcIdType,mcIdType> >& cellPart) const;
+ MEDCOUPLING_EXPORT void getNodeGridStructure(mcIdType *res) const override;
+ MEDCOUPLING_EXPORT std::vector<mcIdType> getNodeGridStructure() const override;
+ MEDCouplingStructuredMesh *buildStructuredSubPart(const std::vector< std::pair<mcIdType,mcIdType> >& cellPart) const override;
//serialisation-unserialization
- MEDCOUPLING_EXPORT void getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const;
- MEDCOUPLING_EXPORT void resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const;
- MEDCOUPLING_EXPORT void serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const;
+ MEDCOUPLING_EXPORT void getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const override;
+ MEDCOUPLING_EXPORT void resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const override;
+ MEDCOUPLING_EXPORT void serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const override;
MEDCOUPLING_EXPORT void unserialization(const std::vector<double>& tinyInfoD, const std::vector<mcIdType>& tinyInfo, const DataArrayIdType *a1, DataArrayDouble *a2,
- const std::vector<std::string>& littleStrings);
- MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const;
- MEDCOUPLING_EXPORT std::string getVTKFileExtension() const;
+ const std::vector<std::string>& littleStrings) override;
+ MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const override;
+ MEDCOUPLING_EXPORT std::string getVTKFileExtension() const override;
private:
MEDCouplingCMesh();
MEDCouplingCMesh(const MEDCouplingCMesh& other, bool deepCpy);
- ~MEDCouplingCMesh();
- void writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData, DataArrayByte *byteData) const;
- std::string getVTKDataSetType() const;
+ ~MEDCouplingCMesh() override;
+ void writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData, DataArrayByte *byteData) const override;
+ std::string getVTKDataSetType() const override;
private:
DataArrayDouble *_x_array;
DataArrayDouble *_y_array;
// Author : Anthony Geay
#include "MEDCouplingCartesianAMRMesh.hxx"
+#include "MCIdType.hxx"
+#include "MCType.hxx"
+#include "MCAuto.hxx"
+#include "BoxSplittingOptions.hxx"
#include "MEDCouplingAMRAttribute.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "MEDCoupling1GTUMesh.hxx"
#include "MEDCouplingIMesh.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingMesh.hxx"
+#include "MEDCouplingStructuredMesh.hxx"
#include "MEDCouplingUMesh.hxx"
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <cstdlib>
+#include <functional>
+#include <iterator>
#include <limits>
+#include <ostream>
#include <sstream>
-#include <numeric>
+#include <utility>
+#include <string>
+#include <vector>
using namespace MEDCoupling;
const MEDCouplingCartesianAMRMeshGen *com(FindCommonAncestor(this,other,lev));//check that factors are OK
if(lev==0)
return isInMyNeighborhood(other,ghostLev);
- std::vector<mcIdType> offset(ComputeOffsetFromTwoToOne(com,lev,this,other));
+ std::vector<mcIdType> const offset(ComputeOffsetFromTwoToOne(com,lev,this,other));
const std::vector< std::pair<mcIdType,mcIdType> >& thisp(getBLTRRange());
std::vector< std::pair<mcIdType,mcIdType> > otherp(other->getBLTRRange());
otherp=MEDCouplingStructuredMesh::TranslateCompactFrmt(otherp,offset);
if(!fath)
throw INTERP_KERNEL::Exception("MEDCouplingCartesianAMRPatch::getBLTRRangeRelativeToGF : not valid 2 !");
std::vector<mcIdType> factors(fath->getFactors());
- std::size_t sz(ret.size());
+ std::size_t const sz(ret.size());
for(std::size_t ii=0;ii<sz;ii++)
{
ret[ii].first*=factors[ii];
fath=oldFather->getFather();
while(fath)
{
- mcIdType pos(fath->getPatchIdFromChildMesh(oldFather));
+ mcIdType const pos(fath->getPatchIdFromChildMesh(oldFather));
const MEDCouplingCartesianAMRPatch *p(fath->getPatch(pos));
const std::vector< std::pair<mcIdType,mcIdType> >& tmp(p->getBLTRRange());
const std::vector<mcIdType>& factors2(fath->getFactors());
std::transform(factors.begin(),factors.end(),factors2.begin(),factors.begin(),std::multiplies<mcIdType>());
for(std::size_t ii=0;ii<sz;ii++)
{
- mcIdType delta(ret[ii].second-ret[ii].first);
+ mcIdType const delta(ret[ii].second-ret[ii].first);
ret[ii].first+=tmp[ii].first*factors[ii];
ret[ii].second=ret[ii].first+delta;
}
bool MEDCouplingCartesianAMRPatch::IsInMyNeighborhood(mcIdType ghostLev, const std::vector< std::pair<mcIdType,mcIdType> >& p1, const std::vector< std::pair<mcIdType,mcIdType> >& p2)
{
- std::size_t thispsize(p1.size());
+ std::size_t const thispsize(p1.size());
if(thispsize!=p2.size())
throw INTERP_KERNEL::Exception("MEDCouplingCartesianAMRPatch::isInMyNeighborhood : the dimensions must be the same !");
for(std::size_t i=0;i<thispsize;i++)
{
std::vector< std::pair<const MEDCouplingCartesianAMRPatch *,const MEDCouplingCartesianAMRPatch *> > retTmp;
std::vector<const MEDCouplingCartesianAMRPatch *> p1Work2,p2Work2;
- for(std::vector<const MEDCouplingCartesianAMRPatch *>::const_iterator it1=p1Work.begin();it1!=p1Work.end();it1++)
+ for(auto it1 : p1Work)
{
- for(std::vector<const MEDCouplingCartesianAMRPatch *>::const_iterator it2=p2Work.begin();it2!=p2Work.end();it2++)
+ for(auto it2 : p2Work)
{
- if((*it1)->isInMyNeighborhoodExt(*it2,ghostLev>0?1:0))//1 not ghostLev ! It is not a bug ( I hope :) ) ! Because as \a this is a refinement of \a other ghostLev is supposed to be <= factors
- retTmp.push_back(std::pair<const MEDCouplingCartesianAMRPatch *,const MEDCouplingCartesianAMRPatch *>(*it1,*it2));
+ if(it1->isInMyNeighborhoodExt(it2,ghostLev>0?1:0))//1 not ghostLev ! It is not a bug ( I hope :) ) ! Because as \a this is a refinement of \a other ghostLev is supposed to be <= factors
+ retTmp.push_back(std::pair<const MEDCouplingCartesianAMRPatch *,const MEDCouplingCartesianAMRPatch *>(it1,it2));
}
- std::vector<const MEDCouplingCartesianAMRPatch *> tmp1((*it1)->getMesh()->getPatches());
+ std::vector<const MEDCouplingCartesianAMRPatch *> tmp1(it1->getMesh()->getPatches());
p1Work2.insert(p1Work2.end(),tmp1.begin(),tmp1.end());
}
- for(std::vector<const MEDCouplingCartesianAMRPatch *>::const_iterator it2=p2Work.begin();it2!=p2Work.end();it2++)
+ for(auto it2 : p2Work)
{
- std::vector<const MEDCouplingCartesianAMRPatch *> tmp2((*it2)->getMesh()->getPatches());
+ std::vector<const MEDCouplingCartesianAMRPatch *> tmp2(it2->getMesh()->getPatches());
p2Work2.insert(p2Work2.end(),tmp2.begin(),tmp2.end());
}
ret.push_back(retTmp);
while(!p1Work.empty())
{
std::vector<const MEDCouplingCartesianAMRPatch *> p1Work2;
- for(std::vector<const MEDCouplingCartesianAMRPatch *>::const_iterator it0=p1Work.begin();it0!=p1Work.end();it0++)
+ for(auto it0 : p1Work)
{
- if((*it0)->isInMyNeighborhoodDiffLev(p2,ghostLev))
- ret.push_back(std::pair<const MEDCouplingCartesianAMRPatch *,const MEDCouplingCartesianAMRPatch *>(*it0,p2));
- std::vector<const MEDCouplingCartesianAMRPatch *> tmp2((*it0)->getMesh()->getPatches());
+ if(it0->isInMyNeighborhoodDiffLev(p2,ghostLev))
+ ret.push_back(std::pair<const MEDCouplingCartesianAMRPatch *,const MEDCouplingCartesianAMRPatch *>(it0,p2));
+ std::vector<const MEDCouplingCartesianAMRPatch *> tmp2(it0->getMesh()->getPatches());
p1Work2.insert(p1Work2.end(),tmp2.begin(),tmp2.end());
}
p1Work=p1Work2;
std::vector< std::pair<mcIdType,mcIdType> > p2BLTR(p2->getBLTRRange());//p2BLTR=[(0,1),(0,5)]
mcIdType lev(0);
const MEDCouplingCartesianAMRMeshGen *ca(FindCommonAncestor(p1,p2,lev));
- std::vector<mcIdType> offset(ComputeOffsetFromTwoToOne(ca,lev,p1,p2));//[12,4]
+ std::vector<mcIdType> const offset(ComputeOffsetFromTwoToOne(ca,lev,p1,p2));//[12,4]
p2BLTR=MEDCouplingStructuredMesh::TranslateCompactFrmt(p2BLTR,offset);//p2BLTR=[(12,13),(4,9)]
UpdateNeighborsOfOneWithTwoInternal(ghostLev,p1->getMesh()->getFather()->getFactors(),p1BLTR,p2BLTR,dataOnP1,dataOnP2);
}
std::vector<mcIdType> dimsP2NotRefined(p2->computeCellGridSt());
std::vector<mcIdType> dimsP2Refined(dimsP2NotRefined);
std::transform(dimsP2NotRefined.begin(),dimsP2NotRefined.end(),factors.begin(),dimsP2Refined.begin(),std::multiplies<mcIdType>());
- std::vector< std::pair<mcIdType,mcIdType> > p2RefinedAbs(MEDCouplingStructuredMesh::GetCompactFrmtFromDimensions(dimsP2NotRefined));
+ std::vector< std::pair<mcIdType,mcIdType> > const p2RefinedAbs(MEDCouplingStructuredMesh::GetCompactFrmtFromDimensions(dimsP2NotRefined));
std::vector<mcIdType> dimsP2RefinedGhost(dimsP2Refined.size());
std::transform(dimsP2Refined.begin(),dimsP2Refined.end(),dimsP2RefinedGhost.begin(),std::bind(std::plus<mcIdType>(),std::placeholders::_1,2*ghostLev));
MCAuto<DataArrayDouble> fineP2(DataArrayDouble::New()); fineP2->alloc(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(dimsP2RefinedGhost),dataOnP2->getNumberOfComponents());
MEDCouplingIMesh::SpreadCoarseToFineGhost(dataOnP2,dimsP2NotRefined,fineP2,p2RefinedAbs,factors,ghostLev);
if(isConservative)
{
- mcIdType fact(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(factors));
+ mcIdType const fact(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(factors));
std::transform(fineP2->begin(),fineP2->end(),fineP2->getPointer(),std::bind(std::multiplies<double>(),std::placeholders::_1,1./((double)fact)));
}
//
* This method has 3 outputs. 2 two first are the resp the position of \a p1 and \a p2 relative to \a p1. And \a factToApplyOn2 is the coeff of refinement to be applied on \a p2 to be virtually
* on the same level as \a p1.
*/
-void MEDCouplingCartesianAMRPatch::ComputeZonesOfTwoRelativeToOneDiffLev(mcIdType ghostLev, const MEDCouplingCartesianAMRPatch *p1, const MEDCouplingCartesianAMRPatch *p2, std::vector< std::pair<mcIdType,mcIdType> >& p1Zone, std::vector< std::pair<mcIdType,mcIdType> >& p2Zone, std::vector<mcIdType>& factToApplyOn2)
+void MEDCouplingCartesianAMRPatch::ComputeZonesOfTwoRelativeToOneDiffLev(mcIdType /*ghostLev*/, const MEDCouplingCartesianAMRPatch *p1, const MEDCouplingCartesianAMRPatch *p2, std::vector< std::pair<mcIdType,mcIdType> >& p1Zone, std::vector< std::pair<mcIdType,mcIdType> >& p2Zone, std::vector<mcIdType>& factToApplyOn2)
{
std::vector<const MEDCouplingCartesianAMRMeshGen *> ancestorsOfThis;
- const MEDCouplingCartesianAMRMeshGen *work(p1->getMesh()),*work2(0);
+ const MEDCouplingCartesianAMRMeshGen *work(p1->getMesh()),*work2(nullptr);
ancestorsOfThis.push_back(work);
while(work)
{
if(work)
{
levOther++;
- std::vector<const MEDCouplingCartesianAMRMeshGen *>::iterator it(std::find(ancestorsOfThis.begin(),ancestorsOfThis.end(),work));
+ auto const it(std::find(ancestorsOfThis.begin(),ancestorsOfThis.end(),work));
if(it!=ancestorsOfThis.end())
{
levThis=std::distance(ancestorsOfThis.begin(),it);
const MEDCouplingCartesianAMRMeshGen *comAncestor(ancestorsOfThis[levThis]);
mcIdType idThis(comAncestor->getPatchIdFromChildMesh(ancestorsOfThis[levThis-1])),idOther(comAncestor->getPatchIdFromChildMesh(work2));
const MEDCouplingCartesianAMRPatch *thisp(comAncestor->getPatch(idThis)),*otherp(comAncestor->getPatch(idOther));
- std::vector<mcIdType> offset(ComputeOffsetFromTwoToOne(comAncestor,ToIdType(levOther),thisp,otherp));
+ std::vector<mcIdType> const offset(ComputeOffsetFromTwoToOne(comAncestor,ToIdType(levOther),thisp,otherp));
p1Zone=thisp->getBLTRRange(); p2Zone=MEDCouplingStructuredMesh::TranslateCompactFrmt(otherp->getBLTRRange(),offset);
factToApplyOn2.resize(p1Zone.size()); std::fill(factToApplyOn2.begin(),factToApplyOn2.end(),1);
//
- std::size_t nbOfTurn(levThis-levOther);
+ std::size_t const nbOfTurn(levThis-levOther);
for(std::size_t i=0;i<nbOfTurn;i++)
{
std::vector< std::pair<mcIdType,mcIdType> > tmp0;
curAncestor=ancestorsOfThis[levThis-1-i];
const std::vector<mcIdType>& factors(curAncestor->getFactors());
std::transform(factToApplyOn2.begin(),factToApplyOn2.end(),factors.begin(),factToApplyOn2.begin(),std::multiplies<mcIdType>());
- mcIdType tmpId(curAncestor->getPatchIdFromChildMesh(ancestorsOfThis[levThis-2-i]));
+ mcIdType const tmpId(curAncestor->getPatchIdFromChildMesh(ancestorsOfThis[levThis-2-i]));
p1Zone=curAncestor->getPatch(tmpId)->getBLTRRange();
}
}
{
const MEDCouplingCartesianAMRMeshGen *f1(p1->_mesh),*f2(p2->_mesh);
lev=0;
- while(f1!=f2 || f1==0 || f2==0)
+ while(f1!=f2 || f1==nullptr || f2==nullptr)
{
f1=f1->getFather(); f2=f2->getFather();
if(f1->getFactors()!=f2->getFactors())
return f1;
}
-std::vector<mcIdType> MEDCouplingCartesianAMRPatch::ComputeOffsetFromTwoToOne(const MEDCouplingCartesianAMRMeshGen *comAncestor, mcIdType lev, const MEDCouplingCartesianAMRPatch *p1, const MEDCouplingCartesianAMRPatch *p2)
+std::vector<mcIdType> MEDCouplingCartesianAMRPatch::ComputeOffsetFromTwoToOne(const MEDCouplingCartesianAMRMeshGen * /*comAncestor*/, mcIdType lev, const MEDCouplingCartesianAMRPatch *p1, const MEDCouplingCartesianAMRPatch *p2)
{
if(lev<=0)
throw INTERP_KERNEL::Exception("MEDCouplingCartesianAMRPatch::ComputeOffsetFromTwoToOne : this method is useful only for lev > 0 !");
- mcIdType zeLev(lev-1);
- mcIdType dim(p1->getMesh()->getSpaceDimension());
+ mcIdType const zeLev(lev-1);
+ mcIdType const dim(p1->getMesh()->getSpaceDimension());
if(p2->getMesh()->getSpaceDimension()!=dim)
throw INTERP_KERNEL::Exception("MEDCouplingCartesianAMRPatch::ComputeOffsetFromTwoToOne : dimension must be the same !");
std::vector< mcIdType > ret(dim,0);
for(mcIdType i=0;i<zeLev;i++)
{
const MEDCouplingCartesianAMRMeshGen *f1(p1->_mesh),*f2(p2->_mesh);
- const MEDCouplingCartesianAMRPatch *p1h(0),*p2h(0);
+ const MEDCouplingCartesianAMRPatch *p1h(nullptr),*p2h(nullptr);
for(mcIdType j=0;j<lev-i;j++)
{
const MEDCouplingCartesianAMRMeshGen *f1tmp(f1->getFather()),*f2tmp(f2->getFather());
void MEDCouplingCartesianAMRPatch::UpdateNeighborsOfOneWithTwoInternal(mcIdType ghostLev, const std::vector<mcIdType>& factors, const std::vector< std::pair<mcIdType,mcIdType> >&p1 ,const std::vector< std::pair<mcIdType,mcIdType> >&p2, DataArrayDouble *dataOnP1, const DataArrayDouble *dataOnP2)
{//p1=[(1,4),(2,4)] p2=[(4,5),(3,4)]
- mcIdType dim(ToIdType(factors.size()));
+ mcIdType const dim(ToIdType(factors.size()));
std::vector<mcIdType> dimsCoarse(MEDCouplingStructuredMesh::GetDimensionsFromCompactFrmt(p1));//[3,2]
std::transform(dimsCoarse.begin(),dimsCoarse.end(),factors.begin(),dimsCoarse.begin(),std::multiplies<mcIdType>());//[12,8]
std::transform(dimsCoarse.begin(),dimsCoarse.end(),dimsCoarse.begin(),std::bind(std::plus<mcIdType>(),std::placeholders::_1,2*ghostLev));//[14,10]
- std::vector< std::pair<mcIdType,mcIdType> > rangeCoarse(MEDCouplingStructuredMesh::GetCompactFrmtFromDimensions(dimsCoarse));//[(0,14),(0,10)]
- std::vector<mcIdType> fakeFactors(dim,1);
+ std::vector< std::pair<mcIdType,mcIdType> > const rangeCoarse(MEDCouplingStructuredMesh::GetCompactFrmtFromDimensions(dimsCoarse));//[(0,14),(0,10)]
+ std::vector<mcIdType> const fakeFactors(dim,1);
//
std::vector< std::pair<mcIdType,mcIdType> > tmp0,tmp1,tmp2;
MEDCouplingStructuredMesh::ChangeReferenceFromGlobalOfCompactFrmt(p1,p2,tmp0,false);//tmp0=[(3,4),(1,2)]
ApplyFactorsOnCompactFrmt(tmp0,factors);//tmp0=[(12,16),(4,8)]
MEDCouplingStructuredMesh::ApplyGhostOnCompactFrmt(tmp0,ghostLev);//tmp0=[(13,17),(5,9)]
- std::vector< std::pair<mcIdType,mcIdType> > interstRange(MEDCouplingStructuredMesh::IntersectRanges(tmp0,rangeCoarse));//interstRange=[(13,14),(5,9)]
+ std::vector< std::pair<mcIdType,mcIdType> > const interstRange(MEDCouplingStructuredMesh::IntersectRanges(tmp0,rangeCoarse));//interstRange=[(13,14),(5,9)]
MEDCouplingStructuredMesh::ChangeReferenceFromGlobalOfCompactFrmt(p2,p1,tmp1,false);//tmp1=[(-3,0),(-1,1)]
ApplyFactorsOnCompactFrmt(tmp1,factors);//tmp1=[(-12,-4),(-4,0)]
MEDCouplingStructuredMesh::ChangeReferenceToGlobalOfCompactFrmt(tmp1,interstRange,tmp2,false);//tmp2=[(1,2),(1,5)]
*/
void MEDCouplingCartesianAMRPatch::ApplyFactorsOnCompactFrmt(std::vector< std::pair<mcIdType,mcIdType> >& partBeforeFact, const std::vector<mcIdType>& factors)
{
- std::size_t sz(factors.size());
+ std::size_t const sz(factors.size());
if(sz!=partBeforeFact.size())
throw INTERP_KERNEL::Exception("MEDCouplingCartesianAMRPatch::ApplyFactorsOnCompactFrmt : size of input vectors must be the same !");
for(std::size_t i=0;i<sz;i++)
{
if(ghostSize<0)
throw INTERP_KERNEL::Exception("MEDCouplingCartesianAMRPatch::ApplyAllGhostOnCompactFrmt : ghost size must be >= 0 !");
- std::size_t sz(partBeforeFact.size());
+ std::size_t const sz(partBeforeFact.size());
for(std::size_t i=0;i<sz;i++)
{
partBeforeFact[i].first-=ghostSize;
mcIdType MEDCouplingCartesianAMRMeshGen::getMaxNumberOfLevelsRelativeToThis() const
{
mcIdType ret(1);
- for(std::vector< MCAuto<MEDCouplingCartesianAMRPatch> >::const_iterator it=_patches.begin();it!=_patches.end();it++)
- ret=std::max(ret,(*it)->getMaxNumberOfLevelsRelativeToThis()+1);
+ for(const auto & _patche : _patches)
+ ret=std::max(ret,_patche->getMaxNumberOfLevelsRelativeToThis()+1);
return ret;
}
mcIdType MEDCouplingCartesianAMRMeshGen::getNumberOfCellsRecursiveWithOverlap() const
{
mcIdType ret=_mesh->getNumberOfCells();
- for(std::vector< MCAuto<MEDCouplingCartesianAMRPatch> >::const_iterator it=_patches.begin();it!=_patches.end();it++)
+ for(const auto & _patche : _patches)
{
- ret+=(*it)->getNumberOfCellsRecursiveWithOverlap();
+ ret+=_patche->getNumberOfCellsRecursiveWithOverlap();
}
return ret;
}
mcIdType MEDCouplingCartesianAMRMeshGen::getNumberOfCellsRecursiveWithoutOverlap() const
{
mcIdType ret=_mesh->getNumberOfCells();
- for(std::vector< MCAuto<MEDCouplingCartesianAMRPatch> >::const_iterator it=_patches.begin();it!=_patches.end();it++)
+ for(const auto & _patche : _patches)
{
- ret-=(*it)->getNumberOfOverlapedCellsForFather();
- ret+=(*it)->getNumberOfCellsRecursiveWithoutOverlap();
+ ret-=_patche->getNumberOfOverlapedCellsForFather();
+ ret+=_patche->getNumberOfCellsRecursiveWithoutOverlap();
}
return ret;
}
*/
const MEDCouplingCartesianAMRPatch *MEDCouplingCartesianAMRMeshGen::getPatchAtPosition(const std::vector<mcIdType>& pos) const
{
- std::size_t sz(pos.size());
+ std::size_t const sz(pos.size());
if(sz==0)
throw INTERP_KERNEL::Exception("MEDCouplingCartesianAMRMeshGen::getPatchAtPosition : empty input -> no patch by definition !");
- mcIdType patchId(pos[0]);
+ mcIdType const patchId(pos[0]);
const MEDCouplingCartesianAMRPatch *elt(getPatch(patchId));
if(sz==1)
return elt;
if(!elt || !elt->getMesh())
throw INTERP_KERNEL::Exception("MEDCouplingCartesianAMRMeshGen::getPatchAtPosition : NULL element found during walk !");
- std::vector<mcIdType> pos2(pos.begin()+1,pos.end());
+ std::vector<mcIdType> const pos2(pos.begin()+1,pos.end());
return elt->getMesh()->getPatchAtPosition(pos2);
}
const MEDCouplingCartesianAMRMeshGen *MEDCouplingCartesianAMRMeshGen::getMeshAtPosition(const std::vector<mcIdType>& pos) const
{
- std::size_t sz(pos.size());
+ std::size_t const sz(pos.size());
if(sz==0)
return this;
- mcIdType patchId(pos[0]);
+ mcIdType const patchId(pos[0]);
const MEDCouplingCartesianAMRPatch *elt(getPatch(patchId));
if(sz==1)
{
}
if(!elt || !elt->getMesh())
throw INTERP_KERNEL::Exception("MEDCouplingCartesianAMRMeshGen::getPatchAtPosition : NULL element found during walk !");
- std::vector<mcIdType> pos2(pos.begin()+1,pos.end());
+ std::vector<mcIdType> const pos2(pos.begin()+1,pos.end());
return elt->getMesh()->getMeshAtPosition(pos2);
}
MCAuto<MEDCouplingIMesh> mesh(static_cast<MEDCouplingIMesh *>(_mesh->buildStructuredSubPart(bottomLeftTopRight)));
mesh->refineWithFactor(factors);
MCAuto<MEDCouplingCartesianAMRMeshSub> zeMesh(new MEDCouplingCartesianAMRMeshSub(this,mesh));
- MCAuto<MEDCouplingCartesianAMRPatch> elt(new MEDCouplingCartesianAMRPatch(zeMesh,bottomLeftTopRight));
+ MCAuto<MEDCouplingCartesianAMRPatch> const elt(new MEDCouplingCartesianAMRPatch(zeMesh,bottomLeftTopRight));
_patches.push_back(elt);
declareAsNew();
}
class InternalPatch : public RefCountObjectOnly
{
public:
- InternalPatch():_nb_of_true(0) { }
+ InternalPatch() = default;
mcIdType getDimension() const { return ToIdType(_part.size()); }
double getEfficiency() const { return (double)_nb_of_true/(double)_crit.size(); }
mcIdType getNumberOfCells() const { return ToIdType(_crit.size()); }
MCAuto<InternalPatch> extractPart(const std::vector< std::pair<mcIdType,mcIdType> >&partInGlobal) const;
MCAuto<InternalPatch> deepCopy() const;
protected:
- ~InternalPatch() { }
+ ~InternalPatch() override = default;
private:
- mutable mcIdType _nb_of_true;
+ mutable mcIdType _nb_of_true{0};
std::vector<bool> _crit;
//! _part is global
std::vector< std::pair<mcIdType,mcIdType> > _part;
void InternalPatch::zipToFitOnCriterion(mcIdType minPatchLgth)
{
- std::vector<mcIdType> cgs(computeCGS());
+ std::vector<mcIdType> const cgs(computeCGS());
std::vector<bool> newCrit;
std::vector< std::pair<mcIdType,mcIdType> > newPart,newPart2;
- mcIdType newNbOfTrue(MEDCouplingStructuredMesh::FindMinimalPartOf(minPatchLgth,cgs,_crit,newCrit,newPart));
+ mcIdType const newNbOfTrue(MEDCouplingStructuredMesh::FindMinimalPartOf(minPatchLgth,cgs,_crit,newCrit,newPart));
MEDCouplingStructuredMesh::ChangeReferenceToGlobalOfCompactFrmt(_part,newPart,newPart2);
if(newNbOfTrue!=_nb_of_true)
throw INTERP_KERNEL::Exception("InternalPatch::zipToFitOnCrit : internal error !");
MCAuto<InternalPatch> InternalPatch::extractPart(const std::vector< std::pair<mcIdType,mcIdType> >&partInGlobal) const
{
MCAuto<InternalPatch> ret(new InternalPatch);
- std::vector<mcIdType> cgs(computeCGS());
+ std::vector<mcIdType> const cgs(computeCGS());
std::vector< std::pair<mcIdType,mcIdType> > newPart;
MEDCouplingStructuredMesh::ChangeReferenceFromGlobalOfCompactFrmt(_part,partInGlobal,newPart);
MEDCouplingStructuredMesh::ExtractFieldOfBoolFrom(cgs,_crit,newPart,ret->getCriterion());
void DissectBigPatch(const INTERP_KERNEL::BoxSplittingOptions& bso, const InternalPatch *patchToBeSplit, mcIdType axisId, mcIdType largestLength, mcIdType& cutPlace)
{
- mcIdType minimumPatchLength(bso.getMinimumPatchLength());
+ mcIdType const minimumPatchLength(bso.getMinimumPatchLength());
std::vector<double> ratio(largestLength-minimumPatchLength,std::numeric_limits<double>::max());
mcIdType index_min = -1;
double minSemiEfficiencyRatio(std::numeric_limits<double>::max());
bool FindHole(const INTERP_KERNEL::BoxSplittingOptions& bso, const InternalPatch *patchToBeSplit, mcIdType axisId, mcIdType& cutPlace)
{
cutPlace=-1;
- mcIdType minimumPatchLength(bso.getMinimumPatchLength());
+ mcIdType const minimumPatchLength(bso.getMinimumPatchLength());
const mcIdType dim(patchToBeSplit->getDimension());
std::vector< std::vector<mcIdType> > signatures(patchToBeSplit->computeSignature());
for(mcIdType id=0;id<dim;id++)
{
const std::vector<mcIdType>& signature(signatures[id]);
std::vector<mcIdType> hole;
- std::vector<double> distance;
- mcIdType len(ToIdType(signature.size()));
+ std::vector<double> const distance;
+ mcIdType const len(ToIdType(signature.size()));
for(mcIdType i=minimumPatchLength-1;i<len-minimumPatchLength;i++)
if(signature[i]==0)
hole.push_back(i);
mcIdType closestHoleToMiddle(hole[0]);
mcIdType oldDistanceToMiddle(std::abs(hole[0]-len/2));
mcIdType newDistanceToMiddle(oldDistanceToMiddle);
- for(std::size_t i=0;i<hole.size();i++)
+ for(long const i : hole)
{
- newDistanceToMiddle=std::abs(hole[i]-len/2);
+ newDistanceToMiddle=std::abs(i-len/2);
if(newDistanceToMiddle < oldDistanceToMiddle)
{
oldDistanceToMiddle = newDistanceToMiddle;
- closestHoleToMiddle = hole[i];
+ closestHoleToMiddle = i;
}
}
cutPlace=closestHoleToMiddle+patchToBeSplit->getConstPart()[axisId].first;
}
if ( zero_cross.size() > 0 )
{
- mcIdType max_cross=*max_element(edge.begin(),edge.end()) ;
+ mcIdType const max_cross=*max_element(edge.begin(),edge.end()) ;
for (std::size_t i=0;i<edge.size();i++)
if (edge[i]==max_cross)
max_cross_list.push_back(zero_cross[i]+1) ;
- double center(static_cast<double>(signature.size())/2.0);
- for (std::size_t i=0;i<max_cross_list.size();i++)
- distance.push_back(fabs(FromIdType<double>(max_cross_list[i])+1-center));
+ double const center(static_cast<double>(signature.size())/2.0);
+ for (long const i : max_cross_list)
+ distance.push_back(fabs(FromIdType<double>(i)+1-center));
- double distance_min=*min_element(distance.begin(),distance.end()) ;
- mcIdType pos_distance_min=ToIdType(find(distance.begin(),distance.end(),distance_min)-distance.begin());
- mcIdType best_place = max_cross_list[pos_distance_min] + part[id].first ;
+ double const distance_min=*min_element(distance.begin(),distance.end()) ;
+ mcIdType const pos_distance_min=ToIdType(find(distance.begin(),distance.end(),distance_min)-distance.begin());
+ mcIdType const best_place = max_cross_list[pos_distance_min] + part[id].first ;
if ( max_cross >=0 )
{
zeroCrossDims[id] = best_place ;
if (zeroCrossVals[0]==max_cross_dims && zeroCrossVals[1]==max_cross_dims )
{
- mcIdType nl_left(part[0].second-part[0].first);
- mcIdType nc_left(part[1].second-part[1].first);
+ mcIdType const nl_left(part[0].second-part[0].first);
+ mcIdType const nc_left(part[1].second-part[1].first);
if ( nl_left >= nc_left )
max_cross_dims = 0 ;
else
void DealWithCut(double minPatchLgth, const InternalPatch *patchToBeSplit, int axisId, mcIdType cutPlace, std::vector<MCAuto<InternalPatch> >& listOfPatches)
{
MCAuto<InternalPatch> leftPart,rightPart;
- std::vector< std::pair<mcIdType,mcIdType> > rect(patchToBeSplit->getConstPart());
+ std::vector< std::pair<mcIdType,mcIdType> > const rect(patchToBeSplit->getConstPart());
std::vector< std::pair<mcIdType,mcIdType> > leftRect(rect),rightRect(rect);
leftRect[axisId].second=cutPlace+1;
rightRect[axisId].first=cutPlace+1;
*/
void MEDCouplingCartesianAMRMeshGen::createPatchesFromCriterion(const INTERP_KERNEL::BoxSplittingOptions& bso, const std::vector<bool>& criterion, const std::vector<mcIdType>& factors)
{
- mcIdType nbCells(getNumberOfCellsAtCurrentLevel());
+ mcIdType const nbCells(getNumberOfCellsAtCurrentLevel());
if(nbCells!=ToIdType(criterion.size()))
throw INTERP_KERNEL::Exception("MEDCouplingCartesianAMRMeshGen::createPatchesFromCriterion : the number of tuples of criterion array must be equal to the number of cells at the current level !");
_patches.clear();
- std::vector<mcIdType> cgs(_mesh->getCellGridStructure());
+ std::vector<mcIdType> const cgs(_mesh->getCellGridStructure());
std::vector< MCAuto<InternalPatch> > listOfPatches,listOfPatchesOK;
//
MCAuto<InternalPatch> p(new InternalPatch);
while(!listOfPatches.empty())
{
std::vector< MCAuto<InternalPatch> > listOfPatchesTmp;
- for(std::vector< MCAuto<InternalPatch> >::iterator it=listOfPatches.begin();it!=listOfPatches.end();it++)
+ for(auto & listOfPatche : listOfPatches)
{
//
int axisId;
mcIdType largestLength,cutPlace;
- MEDCouplingStructuredMesh::FindTheWidestAxisOfGivenRangeInCompactFrmt((*it)->getConstPart(),axisId,largestLength);
- if((*it)->getEfficiency()>=bso.getEfficiencyThreshold() && ((*it)->getNumberOfCells()>bso.getMaximumNbOfCellsInPatch() || largestLength>bso.getMaximumPatchLength()))
+ MEDCouplingStructuredMesh::FindTheWidestAxisOfGivenRangeInCompactFrmt(listOfPatche->getConstPart(),axisId,largestLength);
+ if(listOfPatche->getEfficiency()>=bso.getEfficiencyThreshold() && (listOfPatche->getNumberOfCells()>bso.getMaximumNbOfCellsInPatch() || largestLength>bso.getMaximumPatchLength()))
{
- DissectBigPatch(bso,*it,axisId,largestLength,cutPlace);
- DealWithCut(bso.getMinimumPatchLength(),*it,axisId,cutPlace,listOfPatchesTmp);
+ DissectBigPatch(bso,listOfPatche,axisId,largestLength,cutPlace);
+ DealWithCut(bso.getMinimumPatchLength(),listOfPatche,axisId,cutPlace,listOfPatchesTmp);
continue;
}//action 1
- if(FindHole(bso,*it,axisId,cutPlace))//axisId overwritten here if FindHole equal to true !
- { DealWithCut(bso.getMinimumPatchLength(),*it,axisId,cutPlace,listOfPatchesTmp); continue; }//action 2
- if(FindInflection(bso,*it,cutPlace,axisId))//axisId overwritten here if cutFound equal to true !
- { DealWithCut(bso.getMinimumPatchLength(),*it,axisId,cutPlace,listOfPatchesTmp); continue; }//action 3
- if(TryAction4(bso,*it,axisId,largestLength,cutPlace))
- { DealWithCut(bso.getMinimumPatchLength(),*it,axisId,cutPlace,listOfPatchesTmp); continue; }//action 4
+ if(FindHole(bso,listOfPatche,axisId,cutPlace))//axisId overwritten here if FindHole equal to true !
+ { DealWithCut(bso.getMinimumPatchLength(),listOfPatche,axisId,cutPlace,listOfPatchesTmp); continue; }//action 2
+ if(FindInflection(bso,listOfPatche,cutPlace,axisId))//axisId overwritten here if cutFound equal to true !
+ { DealWithCut(bso.getMinimumPatchLength(),listOfPatche,axisId,cutPlace,listOfPatchesTmp); continue; }//action 3
+ if(TryAction4(bso,listOfPatche,axisId,largestLength,cutPlace))
+ { DealWithCut(bso.getMinimumPatchLength(),listOfPatche,axisId,cutPlace,listOfPatchesTmp); continue; }//action 4
else
- listOfPatchesOK.push_back(DealWithNoCut(*it));
+ listOfPatchesOK.push_back(DealWithNoCut(listOfPatche));
}
listOfPatches=listOfPatchesTmp;
}
- for(std::vector< MCAuto<InternalPatch> >::const_iterator it=listOfPatchesOK.begin();it!=listOfPatchesOK.end();it++)
- addPatch((*it)->getConstPart(),factors);
+ for(const auto & it : listOfPatchesOK)
+ addPatch(it->getConstPart(),factors);
declareAsNew();
}
{
if(!criterion || !criterion->isAllocated())
throw INTERP_KERNEL::Exception("MEDCouplingCartesianAMRMeshGen::createPatchesFromCriterion : the criterion DataArrayByte instance must be allocated and not NULL !");
- std::vector<bool> crit(criterion->toVectorOfBool());//check that criterion has one component.
+ std::vector<bool> const crit(criterion->toVectorOfBool());//check that criterion has one component.
createPatchesFromCriterion(bso,crit,factors);
declareAsNew();
}
{
if(!criterion)
throw INTERP_KERNEL::Exception("MEDCouplingCartesianAMRMeshGen::createPatchesFromCriterion : null criterion pointer !");
- std::vector<bool> inp(criterion->toVectorOfBool(eps));
+ std::vector<bool> const inp(criterion->toVectorOfBool(eps));
createPatchesFromCriterion(bso,inp,factors);
}
mcIdType MEDCouplingCartesianAMRMeshGen::getPatchIdFromChildMesh(const MEDCouplingCartesianAMRMeshGen *mesh) const
{
mcIdType ret(0);
- for(std::vector< MCAuto<MEDCouplingCartesianAMRPatch> >::const_iterator it=_patches.begin();it!=_patches.end();it++,ret++)
+ for(auto it=_patches.begin();it!=_patches.end();it++,ret++)
{
if((*it)->getMesh()==mesh)
return ret;
std::vector< const MEDCouplingCartesianAMRPatch *> MEDCouplingCartesianAMRMeshGen::getPatches() const
{
- std::size_t sz(_patches.size());
+ std::size_t const sz(_patches.size());
std::vector< const MEDCouplingCartesianAMRPatch *> ret(sz);
for(std::size_t i=0;i<sz;i++)
ret[i]=_patches[i];
MEDCouplingIMesh::SpreadCoarseToFine(cellFieldOnThis,_mesh->getCellGridStructure(),cellFieldOnPatch,patch->getBLTRRange(),getFactors());
if(isConservative)
{
- mcIdType fact(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(getFactors()));
+ mcIdType const fact(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(getFactors()));
std::transform(cellFieldOnPatch->begin(),cellFieldOnPatch->end(),cellFieldOnPatch->getPointer(),std::bind(std::multiplies<double>(),std::placeholders::_1,1./((double)fact)));
}
}
MEDCouplingIMesh::SpreadCoarseToFineGhost(cellFieldOnThis,_mesh->getCellGridStructure(),cellFieldOnPatch,patch->getBLTRRange(),getFactors(),ghostLev);
if(isConservative)
{
- mcIdType fact(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(getFactors()));
+ mcIdType const fact(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(getFactors()));
std::transform(cellFieldOnPatch->begin(),cellFieldOnPatch->end(),cellFieldOnPatch->getPointer(),std::bind(std::multiplies<double>(),std::placeholders::_1,1./((double)fact)));
}
}
*/
void MEDCouplingCartesianAMRMeshGen::fillCellFieldOnPatchGhostAdv(mcIdType patchId, const DataArrayDouble *cellFieldOnThis, mcIdType ghostLev, const std::vector<const DataArrayDouble *>& arrsOnPatches, bool isConservative) const
{
- mcIdType nbp(getNumberOfPatches());
+ mcIdType const nbp(getNumberOfPatches());
if(nbp!=ToIdType(arrsOnPatches.size()))
{
std::ostringstream oss; oss << "MEDCouplingCartesianAMRMesh::fillCellFieldOnPatchGhostAdv : there are " << nbp << " patches in this and " << arrsOnPatches.size() << " arrays in the last parameter !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- DataArrayDouble *theFieldToFill(const_cast<DataArrayDouble *>(arrsOnPatches[patchId]));
+ auto *theFieldToFill(const_cast<DataArrayDouble *>(arrsOnPatches[patchId]));
// first, do as usual
fillCellFieldOnPatchGhost(patchId,cellFieldOnThis,theFieldToFill,ghostLev,isConservative);
fillCellFieldOnPatchOnlyGhostAdv(patchId,ghostLev,arrsOnPatches);
*/
void MEDCouplingCartesianAMRMeshGen::fillCellFieldOnPatchOnlyGhostAdv(mcIdType patchId, mcIdType ghostLev, const std::vector<const DataArrayDouble *>& arrsOnPatches) const
{
- mcIdType nbp(getNumberOfPatches());
+ mcIdType const nbp(getNumberOfPatches());
if(nbp!=ToIdType(arrsOnPatches.size()))
{
std::ostringstream oss; oss << "MEDCouplingCartesianAMRMesh::fillCellFieldOnPatchOnlyGhostAdv : there are " << nbp << " patches in this and " << arrsOnPatches.size() << " arrays in the last parameter !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
const MEDCouplingCartesianAMRPatch *refP(getPatch(patchId));
- DataArrayDouble *theFieldToFill(const_cast<DataArrayDouble *>(arrsOnPatches[patchId]));
- std::vector<mcIdType> ids(getPatchIdsInTheNeighborhoodOf(patchId,ghostLev));
- for(std::vector<mcIdType>::const_iterator it=ids.begin();it!=ids.end();it++)
+ auto *theFieldToFill(const_cast<DataArrayDouble *>(arrsOnPatches[patchId]));
+ std::vector<mcIdType> const ids(getPatchIdsInTheNeighborhoodOf(patchId,ghostLev));
+ for(long const id : ids)
{
- const MEDCouplingCartesianAMRPatch *otherP(getPatch(*it));
- MEDCouplingCartesianAMRPatch::UpdateNeighborsOfOneWithTwo(ghostLev,_factors,refP,otherP,theFieldToFill,arrsOnPatches[*it]);
+ const MEDCouplingCartesianAMRPatch *otherP(getPatch(id));
+ MEDCouplingCartesianAMRPatch::UpdateNeighborsOfOneWithTwo(ghostLev,_factors,refP,otherP,theFieldToFill,arrsOnPatches[id]);
}
}
MEDCouplingIMesh::CondenseFineToCoarse(_mesh->getCellGridStructure(),cellFieldOnPatch,patch->getBLTRRange(),getFactors(),cellFieldOnThis);
if(!isConservative)
{
- mcIdType fact(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(getFactors()));
+ mcIdType const fact(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(getFactors()));
MEDCouplingStructuredMesh::MultiplyPartOf(_mesh->getCellGridStructure(),patch->getBLTRRange(),1./((double)fact),cellFieldOnThis);
}
}
MEDCouplingIMesh::CondenseFineToCoarseGhost(_mesh->getCellGridStructure(),cellFieldOnPatch,patch->getBLTRRange(),getFactors(),cellFieldOnThis,ghostLev);
if(!isConservative)
{
- mcIdType fact(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(getFactors()));
+ mcIdType const fact(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(getFactors()));
MEDCouplingStructuredMesh::MultiplyPartOfByGhost(_mesh->getCellGridStructure(),patch->getBLTRRange(),ghostLev,1./((double)fact),cellFieldOnThis);
}
}
*/
DataArrayIdType *MEDCouplingCartesianAMRMeshGen::findPatchesInTheNeighborhoodOf(mcIdType patchId, mcIdType ghostLev) const
{
- mcIdType nbp(getNumberOfPatches());
+ mcIdType const nbp(getNumberOfPatches());
MCAuto<DataArrayIdType> ret(DataArrayIdType::New()); ret->alloc(0,1);
for(mcIdType i=0;i<nbp;i++)
{
{
MCAuto<MEDCouplingUMesh> part(_mesh->buildUnstructured());
std::vector<bool> bs(_mesh->getNumberOfCells(),false);
- std::vector<mcIdType> cgs(_mesh->getCellGridStructure());
+ std::vector<mcIdType> const cgs(_mesh->getCellGridStructure());
std::vector< MCAuto<MEDCouplingUMesh> > msSafe(_patches.size()+1);
std::size_t ii(0);
- for(std::vector< MCAuto<MEDCouplingCartesianAMRPatch> >::const_iterator it=_patches.begin();it!=_patches.end();it++,ii++)
+ for(auto it=_patches.begin();it!=_patches.end();it++,ii++)
{
MEDCouplingStructuredMesh::SwitchOnIdsFrom(cgs,(*it)->getBLTRRange(),bs);
msSafe[ii+1]=(*it)->getMesh()->buildUnstructured();
{
std::vector<const MEDCoupling1SGTUMesh *> cells;
std::vector< MCAuto<MEDCoupling1SGTUMesh> > cellsSafe;
- for(std::vector< MCAuto<MEDCouplingCartesianAMRPatch> >::const_iterator it=_patches.begin();it!=_patches.end();it++)
+ for(const auto & _patche : _patches)
{
- const MEDCouplingCartesianAMRPatch *patch(*it);
+ const MEDCouplingCartesianAMRPatch *patch(_patche);
if(patch)
{
- MCAuto<MEDCouplingIMesh> cell(patch->getMesh()->getImageMesh()->asSingleCell());
+ MCAuto<MEDCouplingIMesh> const cell(patch->getMesh()->getImageMesh()->asSingleCell());
MCAuto<MEDCoupling1SGTUMesh> cell1SGT(cell->build1SGTUnstructured());
cellsSafe.push_back(cell1SGT); cells.push_back(cell1SGT);
}
{
std::vector<const MEDCoupling1SGTUMesh *> patches;
std::vector< MCAuto<MEDCoupling1SGTUMesh> > patchesSafe;
- for(std::vector< MCAuto<MEDCouplingCartesianAMRPatch> >::const_iterator it=_patches.begin();it!=_patches.end();it++)
+ for(const auto & _patche : _patches)
{
- const MEDCouplingCartesianAMRPatch *patch(*it);
+ const MEDCouplingCartesianAMRPatch *patch(_patche);
if(patch)
{
MCAuto<MEDCoupling1SGTUMesh> patchMesh(patch->getMesh()->getImageMesh()->build1SGTUnstructured());
throw INTERP_KERNEL::Exception("MEDCouplingCartesianAMRMeshGen::buildCellFieldOnRecurseWithoutOverlapWithoutGhost : array is empty ! Should never happen !");
//
std::vector<bool> bs(_mesh->getNumberOfCells(),false);
- std::vector<mcIdType> cgs(_mesh->getCellGridStructure());
+ std::vector<mcIdType> const cgs(_mesh->getCellGridStructure());
std::vector< MCAuto<MEDCouplingFieldDouble> > msSafe(_patches.size()+1);
std::size_t ii(0);
- for(std::vector< MCAuto<MEDCouplingCartesianAMRPatch> >::const_iterator it=_patches.begin();it!=_patches.end();it++,ii++)
+ for(auto it=_patches.begin();it!=_patches.end();it++,ii++)
{
MEDCouplingStructuredMesh::SwitchOnIdsFrom(cgs,(*it)->getBLTRRange(),bs);
- std::vector<const DataArrayDouble *> tmpArrs(extractSubTreeFromGlobalFlatten((*it)->getMesh(),recurseArrs));
+ std::vector<const DataArrayDouble *> const tmpArrs(extractSubTreeFromGlobalFlatten((*it)->getMesh(),recurseArrs));
msSafe[ii+1]=(*it)->getMesh()->buildCellFieldOnRecurseWithoutOverlapWithoutGhost(ghostSz,tmpArrs);
}
MCAuto<DataArrayIdType> eltsOff(DataArrayIdType::BuildListOfSwitchedOff(bs));
std::vector<mcIdType> MEDCouplingCartesianAMRMeshGen::getPatchIdsInTheNeighborhoodOf(mcIdType patchId, mcIdType ghostLev) const
{
std::vector<mcIdType> ret;
- mcIdType nbp(getNumberOfPatches());
+ mcIdType const nbp(getNumberOfPatches());
//
for(mcIdType i=0;i<nbp;i++)
{
const MEDCouplingIMesh *mesh(other._mesh);
if(mesh)
_mesh=static_cast<MEDCouplingIMesh *>(mesh->deepCopy());
- std::size_t sz(other._patches.size());
+ std::size_t const sz(other._patches.size());
for(std::size_t i=0;i<sz;i++)
{
const MEDCouplingCartesianAMRPatch *patch(other._patches[i]);
void MEDCouplingCartesianAMRMeshGen::checkPatchId(mcIdType patchId) const
{
- mcIdType sz(getNumberOfPatches());
+ mcIdType const sz(getNumberOfPatches());
if(patchId<0 || patchId>=sz)
{
std::ostringstream oss; oss << "MEDCouplingCartesianAMRMeshGen::checkPatchId : invalid patchId (" << patchId << ") ! Must be in [0," << sz << ") !";
{
if(lev==0)
{
- const MEDCouplingCartesianAMRMesh *thisc(dynamic_cast<const MEDCouplingCartesianAMRMesh *>(this));//tony
+ const auto *thisc(dynamic_cast<const MEDCouplingCartesianAMRMesh *>(this));//tony
MCAuto<MEDCouplingCartesianAMRPatchGF> elt(new MEDCouplingCartesianAMRPatchGF(const_cast<MEDCouplingCartesianAMRMesh *>(thisc)));
grids.push_back(DynamicCastSafe<MEDCouplingCartesianAMRPatchGF,MEDCouplingCartesianAMRPatchGen>(elt));
}
else if(lev==1)
{
- for(std::vector< MCAuto<MEDCouplingCartesianAMRPatch> >::const_iterator it=_patches.begin();it!=_patches.end();it++)
+ for(const auto & _patche : _patches)
{
- const MEDCouplingCartesianAMRPatch *pt(*it);
+ const MEDCouplingCartesianAMRPatch *pt(_patche);
if(pt)
{
- MCAuto<MEDCouplingCartesianAMRPatch> tmp1(*it);
+ MCAuto<MEDCouplingCartesianAMRPatch> tmp1(_patche);
grids.push_back(DynamicCastSafe<MEDCouplingCartesianAMRPatch,MEDCouplingCartesianAMRPatchGen>(tmp1));
}
}
}
else
{
- for(std::vector< MCAuto<MEDCouplingCartesianAMRPatch> >::const_iterator it=_patches.begin();it!=_patches.end();it++)
+ for(const auto & _patche : _patches)
{
- const MEDCouplingCartesianAMRPatch *pt(*it);
+ const MEDCouplingCartesianAMRPatch *pt(_patche);
if(pt)
pt->getMesh()->retrieveGridsAtInternal(lev-1,grids);
}
else
{
ghostLevInPatchRef=(ghostLev-1)/factors[0]+1;
- for(std::size_t i=0;i<factors.size();i++)
- ghostLevInPatchRef=std::max(ghostLevInPatchRef,(ghostLev-1)/factors[i]+1);
+ for(long const factor : factors)
+ ghostLevInPatchRef=std::max(ghostLevInPatchRef,(ghostLev-1)/factor+1);
}
return ghostLevInPatchRef;
}
*/
std::vector<const DataArrayDouble *> MEDCouplingCartesianAMRMeshGen::extractSubTreeFromGlobalFlatten(const MEDCouplingCartesianAMRMeshGen *head, const std::vector<const DataArrayDouble *>& all) const
{
- mcIdType maxLev(getMaxNumberOfLevelsRelativeToThis());
+ mcIdType const maxLev(getMaxNumberOfLevelsRelativeToThis());
std::vector<const DataArrayDouble *> ret;
std::vector<const MEDCouplingCartesianAMRMeshGen *> meshes(1,this);
std::size_t kk(0);
for(mcIdType i=0;i<maxLev;i++)
{
std::vector<const MEDCouplingCartesianAMRMeshGen *> meshesTmp;
- for(std::vector<const MEDCouplingCartesianAMRMeshGen *>::const_iterator it=meshes.begin();it!=meshes.end();it++)
+ for(auto meshe : meshes)
{
- if((*it)==head || head->isObjectInTheProgeny(*it))
+ if(meshe==head || head->isObjectInTheProgeny(meshe))
ret.push_back(all[kk]);
kk++;
- std::vector< const MEDCouplingCartesianAMRPatch *> ps((*it)->getPatches());
- for(std::vector< const MEDCouplingCartesianAMRPatch *>::const_iterator it0=ps.begin();it0!=ps.end();it0++)
+ std::vector< const MEDCouplingCartesianAMRPatch *> const ps(meshe->getPatches());
+ for(auto p : ps)
{
- const MEDCouplingCartesianAMRMeshGen *mesh((*it0)->getMesh());
+ const MEDCouplingCartesianAMRMeshGen *mesh(p->getMesh());
meshesTmp.push_back(mesh);
}
}
void MEDCouplingCartesianAMRMeshGen::dumpPatchesOf(const std::string& varName, std::ostream& oss) const
{
std::size_t j(0);
- for(std::vector< MCAuto<MEDCouplingCartesianAMRPatch> >::const_iterator it=_patches.begin();it!=_patches.end();it++)
+ for(const auto & _patche : _patches)
{
- const MEDCouplingCartesianAMRPatch *patch(*it);
+ const MEDCouplingCartesianAMRPatch *patch(_patche);
if(patch)
{
std::ostringstream oss2; oss2 << varName << ".addPatch([";
const std::vector< std::pair<mcIdType,mcIdType> >& bltr(patch->getBLTRRange());
- std::size_t sz(bltr.size());
+ std::size_t const sz(bltr.size());
for(std::size_t i=0;i<sz;i++)
{
oss2 << "(" << bltr[i].first << "," << bltr[i].second << ")";
{
std::vector<const BigMemoryObject *> ret;
ret.push_back((const MEDCouplingIMesh *)_mesh);
- for(std::vector< MCAuto<MEDCouplingCartesianAMRPatch> >::const_iterator it=_patches.begin();it!=_patches.end();it++)
- ret.push_back((const MEDCouplingCartesianAMRPatch*)*it);
+ for(const auto & _patche : _patches)
+ ret.push_back((const MEDCouplingCartesianAMRPatch*)_patche);
return ret;
}
{
if((const MEDCouplingIMesh *)_mesh)
updateTimeWith(*_mesh);
- for(std::vector< MCAuto<MEDCouplingCartesianAMRPatch> >::const_iterator it=_patches.begin();it!=_patches.end();it++)
+ for(const auto & _patche : _patches)
{
- const MEDCouplingCartesianAMRPatch *elt(*it);
+ const MEDCouplingCartesianAMRPatch *elt(_patche);
if(!elt)
continue;
const MEDCouplingCartesianAMRMeshGen *mesh(elt->getMesh());
void MEDCouplingCartesianAMRMeshSub::detachFromFather()
{
- _father=0;
+ _father=nullptr;
declareAsNew();
}
std::vector< std::pair<mcIdType,mcIdType> > MEDCouplingCartesianAMRMeshSub::positionRelativeToGodFather(std::vector<mcIdType>& st) const
{
st=_father->getFactors();
- std::size_t dim(st.size());
+ std::size_t const dim(st.size());
std::vector<mcIdType> prev(st);
- mcIdType id(_father->getPatchIdFromChildMesh(this));
+ mcIdType const id(_father->getPatchIdFromChildMesh(this));
const MEDCouplingCartesianAMRPatch *p(_father->getPatch(id));
std::vector< std::pair<mcIdType,mcIdType> > ret(p->getBLTRRange());
std::vector<mcIdType> delta(MEDCouplingStructuredMesh::GetDimensionsFromCompactFrmt(ret)),start(dim);
const MEDCouplingCartesianAMRMeshGen *it(_father);
while(!dynamic_cast<const MEDCouplingCartesianAMRMesh *>(it))
{
- const MEDCouplingCartesianAMRMeshSub *itc(static_cast<const MEDCouplingCartesianAMRMeshSub *>(it));
- mcIdType id2(itc->_father->getPatchIdFromChildMesh(itc));
+ const auto *itc(static_cast<const MEDCouplingCartesianAMRMeshSub *>(it));
+ mcIdType const id2(itc->_father->getPatchIdFromChildMesh(itc));
const MEDCouplingCartesianAMRPatch *p2(itc->_father->getPatch(id2));
const std::vector< std::pair<mcIdType,mcIdType> >& start2(p2->getBLTRRange());
std::vector<mcIdType> tmp(dim);
{
if(this==ref)
return 0;
- if(_father==0)
+ if(_father==nullptr)
throw INTERP_KERNEL::Exception("MEDCouplingCartesianAMRMeshSub::getAbsoluteLevelRelativeTo : ref is not in the progeny of this !");
else
return _father->getAbsoluteLevelRelativeTo(ref)+1;
return ;
if(!_father)
throw INTERP_KERNEL::Exception("MEDCouplingCartesianAMRMeshSub::getPositionRelativeToInternal : ref is not in the progeny of this !");
- mcIdType myId(_father->getPatchIdFromChildMesh(this));
+ mcIdType const myId(_father->getPatchIdFromChildMesh(this));
ret.push_back(myId);
_father->getPositionRelativeToInternal(ref,ret);
}
const MEDCouplingCartesianAMRMeshGen *MEDCouplingCartesianAMRMesh::getFather() const
{
//I'm god father ! No father !
- return 0;
+ return nullptr;
}
const MEDCouplingCartesianAMRMeshGen *MEDCouplingCartesianAMRMesh::getGodFather() const
*/
void MEDCouplingCartesianAMRMesh::createPatchesFromCriterionML(const std::vector<const INTERP_KERNEL::BoxSplittingOptions *>& bso, const DataArrayDouble *criterion, const std::vector< std::vector<mcIdType> >& factors, double eps)
{
- std::size_t nbOfLevs(bso.size());
+ std::size_t const nbOfLevs(bso.size());
if(nbOfLevs!=factors.size())
throw INTERP_KERNEL::Exception("MEDCouplingCartesianAMRMesh::createPatchesFromCriterionML : size of vectors must be the same !");
if(nbOfLevs==0)
throw INTERP_KERNEL::Exception("MEDCouplingCartesianAMRMesh::createPatchesFromCriterionML : presence of a NULL BoxSplittingOptions in input vector !");
//
std::vector<MEDCouplingCartesianAMRPatchGen *> elts(retrieveGridsAt(ToIdType((i))));
- std::size_t sz(elts.size());
+ std::size_t const sz(elts.size());
std::vector< MCAuto<MEDCouplingCartesianAMRPatchGen> > elts2(sz);
std::vector< MCAuto<DataArrayDouble> > elts3(sz);
for(std::size_t ii=0;ii<sz;ii++)
std::vector< std::pair<std::string,int> > fieldNames(1); fieldNames[0].first=TMP_STR; fieldNames[0].second=1;
MCAuto<MEDCouplingAMRAttribute> att(MEDCouplingAMRAttribute::New(this,fieldNames,0));
att->alloc();
- DataArrayDouble *tmpDa(const_cast<DataArrayDouble *>(att->getFieldOn(this,TMP_STR)));
+ auto *tmpDa(const_cast<DataArrayDouble *>(att->getFieldOn(this,TMP_STR)));
tmpDa->deepCopyFrom(*criterion);
att->synchronizeCoarseToFine();
for(std::size_t ii=0;ii<sz;ii++)
const DataArrayDouble *critOnLeaf(att->getFieldOn(const_cast<MEDCouplingCartesianAMRMeshGen *>(elts[ii]->getMesh()),TMP_STR));
elts3[ii]=const_cast<DataArrayDouble *>(critOnLeaf); elts3[ii]->incrRef();
}
- att=0;
+ att=nullptr;
for(std::size_t ii=0;ii<sz;ii++)
const_cast<MEDCouplingCartesianAMRMeshGen *>(elts[ii]->getMesh())->createPatchesFromCriterion(*bso[i],elts3[ii],factors[i],eps);
}
}
-MEDCouplingCartesianAMRMesh::MEDCouplingCartesianAMRMesh(const MEDCouplingCartesianAMRMesh& other):MEDCouplingCartesianAMRMeshGen(other)
-{
-}
+MEDCouplingCartesianAMRMesh::MEDCouplingCartesianAMRMesh(const MEDCouplingCartesianAMRMesh& other)
+= default;
MEDCouplingCartesianAMRMesh::MEDCouplingCartesianAMRMesh(const std::string& meshName, int spaceDim, const mcIdType *nodeStrctStart, const mcIdType *nodeStrctStop,
const double *originStart, const double *originStop, const double *dxyzStart, const double *dxyzStop):MEDCouplingCartesianAMRMeshGen(meshName,spaceDim,nodeStrctStart,nodeStrctStop,originStart,originStop,dxyzStart,dxyzStop)
}
MEDCouplingCartesianAMRMesh::~MEDCouplingCartesianAMRMesh()
-{
-}
+= default;
#include "MCType.hxx"
#include "BoxSplittingOptions.hxx"
-#include "InterpKernelException.hxx"
+#include <vector>
+#include <utility>
+#include <string>
+#include <cstddef>
+#include <ostream>
namespace MEDCoupling
{
const MEDCouplingCartesianAMRMeshGen *getMeshSafe() const;
MEDCouplingCartesianAMRMeshGen *getMeshSafe();
private:
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
protected:
MCAuto<MEDCouplingCartesianAMRMeshGen> _mesh;
};
public:
MEDCouplingCartesianAMRPatch(MEDCouplingCartesianAMRMeshGen *mesh, const std::vector< std::pair<mcIdType,mcIdType> >& bottomLeftTopRight);
std::string getClassName() const override { return std::string("MEDCouplingCartesianAMRPatch"); }
- MEDCouplingCartesianAMRPatch *deepCopy(MEDCouplingCartesianAMRMeshGen *father) const;
+ MEDCouplingCartesianAMRPatch *deepCopy(MEDCouplingCartesianAMRMeshGen *father) const override;
// direct forward to _mesh
MEDCOUPLING_EXPORT void addPatch(const std::vector< std::pair<mcIdType,mcIdType> >& bottomLeftTopRight, const std::vector<mcIdType>& factors);
// end of direct forward to _mesh
private:
static void ComputeZonesOfTwoRelativeToOneDiffLev(mcIdType ghostLev, const MEDCouplingCartesianAMRPatch *p1, const MEDCouplingCartesianAMRPatch *p2, std::vector< std::pair<mcIdType,mcIdType> >& p1Zone, std::vector< std::pair<mcIdType,mcIdType> >& p2Zone, std::vector<mcIdType>& factToApplyOn2);
private:
- std::size_t getHeapMemorySizeWithoutChildren() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
static const MEDCouplingCartesianAMRMeshGen *FindCommonAncestor(const MEDCouplingCartesianAMRPatch *p1, const MEDCouplingCartesianAMRPatch *p2, mcIdType& lev);
static std::vector<mcIdType> ComputeOffsetFromTwoToOne(const MEDCouplingCartesianAMRMeshGen *comAncestor, mcIdType lev, const MEDCouplingCartesianAMRPatch *p1, const MEDCouplingCartesianAMRPatch *p2);
static void UpdateNeighborsOfOneWithTwoInternal(mcIdType ghostLev, const std::vector<mcIdType>& factors, const std::vector< std::pair<mcIdType,mcIdType> >&p1 ,const std::vector< std::pair<mcIdType,mcIdType> >&p2, DataArrayDouble *dataOnP1, const DataArrayDouble *dataOnP2);
public:
MEDCouplingCartesianAMRPatchGF(MEDCouplingCartesianAMRMesh *mesh);
std::string getClassName() const override { return std::string("MEDCouplingCartesianAMRPatchGF"); }
- MEDCouplingCartesianAMRPatchGF *deepCopy(MEDCouplingCartesianAMRMeshGen *father) const;
+ MEDCouplingCartesianAMRPatchGF *deepCopy(MEDCouplingCartesianAMRMeshGen *father) const override;
private:
- std::size_t getHeapMemorySizeWithoutChildren() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
private:
MEDCouplingCartesianAMRPatchGF(const MEDCouplingCartesianAMRPatchGF& other, MEDCouplingCartesianAMRMeshGen *father);
};
public:
virtual void getPositionRelativeToInternal(const MEDCouplingCartesianAMRMeshGen *ref, std::vector<mcIdType>& ret) const = 0;
protected:
- MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- MEDCOUPLING_EXPORT void updateTime() const;
+ MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ MEDCOUPLING_EXPORT void updateTime() const override;
protected:
MCAuto<MEDCouplingIMesh> _mesh;
std::vector< MCAuto<MEDCouplingCartesianAMRPatch> > _patches;
public:
MEDCouplingCartesianAMRMeshSub(MEDCouplingCartesianAMRMeshGen *father, MEDCouplingIMesh *mesh);
MEDCOUPLING_EXPORT std::string getClassName() const override { return std::string("MEDCouplingCartesianAMRMeshSub"); }
- MEDCOUPLING_EXPORT const MEDCouplingCartesianAMRMeshGen *getFather() const;
- MEDCOUPLING_EXPORT const MEDCouplingCartesianAMRMeshGen *getGodFather() const;
- MEDCOUPLING_EXPORT mcIdType getAbsoluteLevel() const;
- MEDCOUPLING_EXPORT void detachFromFather();
- MEDCOUPLING_EXPORT std::vector< std::pair<mcIdType,mcIdType> > positionRelativeToGodFather(std::vector<mcIdType>& st) const;
- MEDCOUPLING_EXPORT mcIdType getAbsoluteLevelRelativeTo(const MEDCouplingCartesianAMRMeshGen *ref) const;
+ MEDCOUPLING_EXPORT const MEDCouplingCartesianAMRMeshGen *getFather() const override;
+ MEDCOUPLING_EXPORT const MEDCouplingCartesianAMRMeshGen *getGodFather() const override;
+ MEDCOUPLING_EXPORT mcIdType getAbsoluteLevel() const override;
+ MEDCOUPLING_EXPORT void detachFromFather() override;
+ MEDCOUPLING_EXPORT std::vector< std::pair<mcIdType,mcIdType> > positionRelativeToGodFather(std::vector<mcIdType>& st) const override;
+ MEDCOUPLING_EXPORT mcIdType getAbsoluteLevelRelativeTo(const MEDCouplingCartesianAMRMeshGen *ref) const override;
private:
MEDCouplingCartesianAMRMeshSub(const MEDCouplingCartesianAMRMeshSub& other, MEDCouplingCartesianAMRMeshGen *father);
- MEDCouplingCartesianAMRMeshSub *deepCopy(MEDCouplingCartesianAMRMeshGen *father) const;
- void getPositionRelativeToInternal(const MEDCouplingCartesianAMRMeshGen *ref, std::vector<mcIdType>& ret) const;
+ MEDCouplingCartesianAMRMeshSub *deepCopy(MEDCouplingCartesianAMRMeshGen *father) const override;
+ void getPositionRelativeToInternal(const MEDCouplingCartesianAMRMeshGen *ref, std::vector<mcIdType>& ret) const override;
protected:
MEDCouplingCartesianAMRMeshGen *_father;
};
const double *originStart, const double *originStop, const double *dxyzStart, const double *dxyzStop);
MEDCOUPLING_EXPORT static MEDCouplingCartesianAMRMesh *New(MEDCouplingIMesh *mesh);
MEDCOUPLING_EXPORT std::string getClassName() const override { return std::string("MEDCouplingCartesianAMRMesh"); }
- MEDCOUPLING_EXPORT const MEDCouplingCartesianAMRMeshGen *getFather() const;
- MEDCOUPLING_EXPORT const MEDCouplingCartesianAMRMeshGen *getGodFather() const;
- MEDCOUPLING_EXPORT mcIdType getAbsoluteLevel() const;
- MEDCOUPLING_EXPORT void detachFromFather();
- MEDCOUPLING_EXPORT std::vector< std::pair<mcIdType,mcIdType> > positionRelativeToGodFather(std::vector<mcIdType>& st) const;
- MEDCOUPLING_EXPORT mcIdType getAbsoluteLevelRelativeTo(const MEDCouplingCartesianAMRMeshGen *ref) const;
- MEDCOUPLING_EXPORT std::vector<MEDCouplingCartesianAMRPatchGen *> retrieveGridsAt(mcIdType absoluteLev) const;
- MEDCouplingCartesianAMRMesh *deepCopy(MEDCouplingCartesianAMRMeshGen *father) const;
+ MEDCOUPLING_EXPORT const MEDCouplingCartesianAMRMeshGen *getFather() const override;
+ MEDCOUPLING_EXPORT const MEDCouplingCartesianAMRMeshGen *getGodFather() const override;
+ MEDCOUPLING_EXPORT mcIdType getAbsoluteLevel() const override;
+ MEDCOUPLING_EXPORT void detachFromFather() override;
+ MEDCOUPLING_EXPORT std::vector< std::pair<mcIdType,mcIdType> > positionRelativeToGodFather(std::vector<mcIdType>& st) const override;
+ MEDCOUPLING_EXPORT mcIdType getAbsoluteLevelRelativeTo(const MEDCouplingCartesianAMRMeshGen *ref) const override;
+ MEDCOUPLING_EXPORT std::vector<MEDCouplingCartesianAMRPatchGen *> retrieveGridsAt(mcIdType absoluteLev) const override;
+ MEDCouplingCartesianAMRMesh *deepCopy(MEDCouplingCartesianAMRMeshGen *father) const override;
MEDCOUPLING_EXPORT void createPatchesFromCriterionML(const std::vector<const INTERP_KERNEL::BoxSplittingOptions *>& bso, const DataArrayDouble *criterion, const std::vector< std::vector<mcIdType> >& factors, double eps);
private:
- void getPositionRelativeToInternal(const MEDCouplingCartesianAMRMeshGen *ref, std::vector<mcIdType>& ret) const;
+ void getPositionRelativeToInternal(const MEDCouplingCartesianAMRMeshGen *ref, std::vector<mcIdType>& ret) const override;
MEDCouplingCartesianAMRMesh(const MEDCouplingCartesianAMRMesh& other);
MEDCouplingCartesianAMRMesh(const std::string& meshName, int spaceDim, const mcIdType *nodeStrctStart, const mcIdType *nodeStrctStop,
const double *originStart, const double *originStop, const double *dxyzStart, const double *dxyzStop);
MEDCouplingCartesianAMRMesh(MEDCouplingIMesh *mesh);
- MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- ~MEDCouplingCartesianAMRMesh();
+ MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ ~MEDCouplingCartesianAMRMesh() override;
};
}
// Author : Anthony Geay (EDF R&D)
#include "MEDCouplingCurveLinearMesh.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingMesh.hxx"
+#include "MCIdType.hxx"
+#include "MCAuto.hxx"
#include "MEDCouplingPointSet.hxx"
#include "MEDCouplingMemArray.hxx"
#include "MEDCouplingFieldDouble.hxx"
+#include "MEDCouplingStructuredMesh.hxx"
+#include "NormalizedUnstructuredMesh.hxx"
+#include "NormalizedGeometricTypes"
+#include "MEDCouplingRefCountObject.hxx"
#include "VolSurfUser.txx"
#include "PointLocatorAlgos.txx"
+#include <cstddef>
#include <functional>
#include <algorithm>
+#include <iterator>
+#include <ostream>
#include <sstream>
-#include <numeric>
+#include <string>
+#include <vector>
+#include <utility>
using namespace MEDCoupling;
-MEDCouplingCurveLinearMesh::MEDCouplingCurveLinearMesh():_coords(0),_structure(0)
+MEDCouplingCurveLinearMesh::MEDCouplingCurveLinearMesh():_coords(nullptr),_structure(0)
{
}
}
MEDCouplingCurveLinearMesh::~MEDCouplingCurveLinearMesh()
-{
-}
+= default;
MEDCouplingCurveLinearMesh *MEDCouplingCurveLinearMesh::New()
{
MEDCouplingCurveLinearMesh *MEDCouplingCurveLinearMesh::New(const std::string& meshName)
{
- MEDCouplingCurveLinearMesh *ret=new MEDCouplingCurveLinearMesh;
+ auto *ret=new MEDCouplingCurveLinearMesh;
ret->setName(meshName);
return ret;
}
*/
void MEDCouplingCurveLinearMesh::copyTinyStringsFrom(const MEDCouplingMesh *other)
{
- const MEDCouplingCurveLinearMesh *otherC=dynamic_cast<const MEDCouplingCurveLinearMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingCurveLinearMesh *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::copyTinyStringsFrom : meshes have not same type !");
MEDCouplingStructuredMesh::copyTinyStringsFrom(other);
{
if(!other)
throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::isEqualIfNotWhy : input other pointer is null !");
- const MEDCouplingCurveLinearMesh *otherC=dynamic_cast<const MEDCouplingCurveLinearMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingCurveLinearMesh *>(other);
if(!otherC)
{
reason="mesh given in input is not castable in MEDCouplingCurveLinearMesh !";
if(!MEDCouplingStructuredMesh::isEqualIfNotWhy(other,prec,reason))
return false;
std::ostringstream oss; oss.precision(15);
- if(((const DataArrayDouble *)_coords && ((const DataArrayDouble *)otherC->_coords)==0) || (((const DataArrayDouble *)_coords)==0 && (const DataArrayDouble *)otherC->_coords))
+ if(((const DataArrayDouble *)_coords && ((const DataArrayDouble *)otherC->_coords)==nullptr) || (((const DataArrayDouble *)_coords)==nullptr && (const DataArrayDouble *)otherC->_coords))
{
oss << "Only one CurveLinearMesh between the two this and other has its coordinates defined !";
reason=oss.str();
bool MEDCouplingCurveLinearMesh::isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const
{
- const MEDCouplingCurveLinearMesh *otherC=dynamic_cast<const MEDCouplingCurveLinearMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingCurveLinearMesh *>(other);
if(!otherC)
return false;
- if(((const DataArrayDouble *)_coords && ((const DataArrayDouble *)otherC->_coords)==0) || (((const DataArrayDouble *)_coords)==0 && (const DataArrayDouble *)otherC->_coords))
+ if(((const DataArrayDouble *)_coords && ((const DataArrayDouble *)otherC->_coords)==nullptr) || (((const DataArrayDouble *)_coords)==nullptr && (const DataArrayDouble *)otherC->_coords))
return false;
if((const DataArrayDouble *)_coords)
{
return true;
}
-void MEDCouplingCurveLinearMesh::checkDeepEquivalWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
- DataArrayIdType *&cellCor, DataArrayIdType *&nodeCor) const
+void MEDCouplingCurveLinearMesh::checkDeepEquivalWith(const MEDCouplingMesh *other, int /*cellCompPol*/, double prec,
+ DataArrayIdType *& /*cellCor*/, DataArrayIdType *& /*nodeCor*/) const
{
if(!isEqualWithoutConsideringStr(other,prec))
throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::checkDeepEquivalWith : Meshes are not the same !");
* Nothing is done here (except to check that the other is a MEDCoupling::MEDCouplingCurveLinearMesh instance too).
* The user intend that the nodes are the same, so by construction of MEDCoupling::MEDCouplingCurveLinearMesh, \a this and \a other are the same !
*/
-void MEDCouplingCurveLinearMesh::checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
- DataArrayIdType *&cellCor) const
+void MEDCouplingCurveLinearMesh::checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *other, int /*cellCompPol*/, double prec,
+ DataArrayIdType *& /*cellCor*/) const
{
if(!isEqualWithoutConsideringStr(other,prec))
throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::checkDeepEquivalOnSameNodesWith : Meshes are not the same !");
mcIdType nbOfNodes=1;
if(sz<1)
throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::checkConsistencyLight : structure should have a lgth of size 1 at least !");
- for(std::vector<mcIdType>::const_iterator it=_structure.begin();it!=_structure.end();it++,i++)
+ for(auto it=_structure.begin();it!=_structure.end();it++,i++)
{
if((*it)<1)
{ std::ostringstream oss; oss << "MEDCouplingCurveLinearMesh::checkConsistencyLight : At pos #" << i << " of structure value is " << *it << "should be >= 1 !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); }
}
}
-void MEDCouplingCurveLinearMesh::checkConsistency(double eps) const
+void MEDCouplingCurveLinearMesh::checkConsistency(double /*eps*/) const
{
checkConsistencyLight();
}
{
if(!((const DataArrayDouble *)_coords))
throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::getCoordinatesOfNode : Coordinates not set !");
- std::size_t nbOfCompo=_coords->getNumberOfComponents();
+ std::size_t const nbOfCompo=_coords->getNumberOfComponents();
if(nodeId>=0 && nodeId<_coords->getNumberOfTuples())
coo.insert(coo.end(),_coords->begin()+nodeId*nbOfCompo,_coords->begin()+(nodeId+1)*nbOfCompo);
else
ret << "Curve linear mesh with name : \"" << getName() << "\"\n";
ret << "Description of mesh : \"" << getDescription() << "\"\n";
int tmpp1,tmpp2;
- double tt=getTime(tmpp1,tmpp2);
+ double const tt=getTime(tmpp1,tmpp2);
ret << "Time attached to the mesh [unit] : " << tt << " [" << getTimeUnit() << "]\n";
ret << "Iteration : " << tmpp1 << " Order : " << tmpp2 << "\n";
ret << "The nodal structure of curve linear mesh is : [";
void MEDCouplingCurveLinearMesh::setNodeGridStructure(const mcIdType *gridStructBg, const mcIdType *gridStructEnd)
{
- std::size_t sz=std::distance(gridStructBg,gridStructEnd);
+ std::size_t const sz=std::distance(gridStructBg,gridStructEnd);
if(sz>=1 && sz<=3)
{
_structure.resize(0);
MEDCouplingStructuredMesh *MEDCouplingCurveLinearMesh::buildStructuredSubPart(const std::vector< std::pair<mcIdType,mcIdType> >& cellPart) const
{
checkConsistencyLight();
- int dim(getSpaceDimension());
+ int const dim(getSpaceDimension());
std::vector<mcIdType> dims(getMeshDimension());
if(dim!=ToIdType(cellPart.size()))
{
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
std::vector< std::pair<mcIdType,mcIdType> > nodePartFormat(cellPart);
- for(std::vector< std::pair<mcIdType,mcIdType> >::iterator it=nodePartFormat.begin();it!=nodePartFormat.end();it++)
- (*it).second++;
+ for(auto & it : nodePartFormat)
+ it.second++;
MCAuto<DataArrayIdType> tmp1(BuildExplicitIdsFrom(getNodeGridStructure(),nodePartFormat));
MCAuto<MEDCouplingCurveLinearMesh> ret(dynamic_cast<MEDCouplingCurveLinearMesh *>(deepCopy()));
const DataArrayDouble *coo(ret->getCoords());
MEDCouplingFieldDouble *MEDCouplingCurveLinearMesh::getMeasureField(bool isAbs) const
{
checkConsistencyLight();
- int meshDim=getMeshDimension();
+ int const meshDim=getMeshDimension();
std::string name="MeasureOfMesh_"; name+=getName();
MCAuto<MEDCouplingFieldDouble> field=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
field->setName(name); field->setMesh(const_cast<MEDCouplingCurveLinearMesh *>(this)); field->synchronizeTimeWithMesh();
*/
void MEDCouplingCurveLinearMesh::getMeasureFieldMeshDim1(bool isAbs, MEDCouplingFieldDouble *field) const
{
- mcIdType nbnodes=getNumberOfNodes();
- int spaceDim=getSpaceDimension();
+ mcIdType const nbnodes=getNumberOfNodes();
+ int const spaceDim=getSpaceDimension();
MCAuto<DataArrayDouble> arr=DataArrayDouble::New(); field->setArray(arr);
if(nbnodes==0)
{ arr->alloc(0,1); return; }
*/
void MEDCouplingCurveLinearMesh::getMeasureFieldMeshDim2(bool isAbs, MEDCouplingFieldDouble *field) const
{
- mcIdType nbcells=getNumberOfCells();
- int spaceDim=getSpaceDimension();
+ mcIdType const nbcells=getNumberOfCells();
+ int const spaceDim=getSpaceDimension();
if(spaceDim!=2 && spaceDim!=3)
throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::getMeasureFieldMeshDim2 : with meshDim 2 only space dimension 2 and 3 are possible !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::New(); field->setArray(arr);
arr->alloc(nbcells,1);
double *pt=arr->getPointer();
const double *coords=_coords->begin();
- mcIdType nX=_structure[0]-1;
+ mcIdType const nX=_structure[0]-1;
mcIdType conn[4];
for(mcIdType i=0;i<nbcells;i++,pt++)
{
*/
void MEDCouplingCurveLinearMesh::getMeasureFieldMeshDim3(bool isAbs, MEDCouplingFieldDouble *field) const
{
- mcIdType nbcells=getNumberOfCells();
- int spaceDim=getSpaceDimension();
+ mcIdType const nbcells=getNumberOfCells();
+ int const spaceDim=getSpaceDimension();
if(spaceDim!=3)
throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::getMeasureFieldMeshDim3 : with meshDim 3 only space dimension 3 is possible !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::New(); field->setArray(arr);
double *pt=arr->getPointer();
const double *coords=_coords->begin();
mcIdType nX=_structure[0]-1,nY=(_structure[0]-1)*(_structure[1]-1);
- mcIdType nY1=_structure[0]*_structure[1];
+ mcIdType const nY1=_structure[0]*_structure[1];
mcIdType conn[8];
for(mcIdType i=0;i<nbcells;i++,pt++)
{
- mcIdType cz=i/nY;
- mcIdType cy=(i-cz*nY)/nX;
- mcIdType cx=(i-cz*nY)-nX*cy;
+ mcIdType const cz=i/nY;
+ mcIdType const cy=(i-cz*nY)/nX;
+ mcIdType const cx=(i-cz*nY)-nX*cy;
conn[0]=cz*nY1+cy*(nX+1)+cx; conn[1]=cz*nY1+(cy+1)*(nX+1)+cx; conn[2]=cz*nY1+(cy+1)*(nX+1)+1+cx; conn[3]=cz*nY1+cy*(nX+1)+cx+1;
conn[4]=(cz+1)*nY1+cy*(nX+1)+cx; conn[5]=(cz+1)*nY1+(cy+1)*(nX+1)+cx; conn[6]=(cz+1)*nY1+(cy+1)*(nX+1)+1+cx; conn[7]=(cz+1)*nY1+cy*(nX+1)+cx+1;
*pt=INTERP_KERNEL::computeVolSurfOfCell2<mcIdType,INTERP_KERNEL::ALL_C_MODE>(INTERP_KERNEL::NORM_HEXA8,conn,8,coords,3);
/*!
* not implemented yet !
*/
-MEDCouplingFieldDouble *MEDCouplingCurveLinearMesh::getMeasureFieldOnNode(bool isAbs) const
+MEDCouplingFieldDouble *MEDCouplingCurveLinearMesh::getMeasureFieldOnNode(bool /*isAbs*/) const
{
throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::getMeasureFieldOnNode : not implemented yet !");
}
throw INTERP_KERNEL::Exception("Expected a cmesh with meshDim == 2 !");
MEDCouplingFieldDouble *ret=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME);
DataArrayDouble *array=DataArrayDouble::New();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
array->alloc(nbOfCells,3);
double *vals=array->getPointer();
for(mcIdType i=0;i<nbOfCells;i++)
public:
static const int MY_SPACEDIM=SPACEDIMM;
static const int MY_MESHDIM=8;
- typedef mcIdType MyConnType;
+ using MyConnType = mcIdType;
static const INTERP_KERNEL::NumberingPolicy My_numPol=INTERP_KERNEL::ALL_C_MODE;
// begin
// useless, but for windows compilation ...
- const double* getCoordinatesPtr() const { return 0; }
- const mcIdType* getConnectivityPtr() const { return 0; }
- const mcIdType* getConnectivityIndexPtr() const { return 0; }
+ const double* getCoordinatesPtr() const { return nullptr; }
+ const mcIdType* getConnectivityPtr() const { return nullptr; }
+ const mcIdType* getConnectivityIndexPtr() const { return nullptr; }
INTERP_KERNEL::NormalizedCellType getTypeOfElement(mcIdType) const { return (INTERP_KERNEL::NormalizedCellType)0; }
// end
};
mcIdType MEDCouplingCurveLinearMesh::getCellContainingPoint(const double *pos, double eps) const
{
checkConsistencyLight();
- int spaceDim=getSpaceDimension();
+ int const spaceDim=getSpaceDimension();
const double *coords=_coords->getConstPointer();
mcIdType nodeId=-1;
_coords->distanceToTuple(pos,pos+spaceDim,nodeId);
if(nodeId<0)
throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::getCellContainingPoint : internal problem 1 !");
mcIdType conn[8];
- mcIdType nbOfNodes=getNumberOfNodes();
+ mcIdType const nbOfNodes=getNumberOfNodes();
if(nbOfNodes==1)
throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::getCellContainingPoint : No cells in this !");
switch(getMeshDimension())
{
if(spaceDim==3)
{
- mcIdType nY=_structure[0]*_structure[1];
- mcIdType nz=nodeId/_structure[1]; mcIdType ny=(nodeId-nz*nY)/_structure[0]; mcIdType nx=(nodeId-nz*nY)-_structure[0]*ny;
+ mcIdType const nY=_structure[0]*_structure[1];
+ mcIdType const nz=nodeId/_structure[1]; mcIdType const ny=(nodeId-nz*nY)/_structure[0]; mcIdType const nx=(nodeId-nz*nY)-_structure[0]*ny;
if(nx>0 && ny>0 && nz>0)
{
conn[0]=nx-1+_structure[0]*(ny-1)+nY*(nz-1); conn[1]=nx-1+_structure[2]*ny+nY*(nz-1); conn[2]=nx+_structure[2]*ny+nY*(nz-1); conn[3]=nx+_structure[0]*(ny-1)+nY*(nz-1);
{
if(!((DataArrayDouble *)_coords))
throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::rotate : no coordinates set !");
- int spaceDim=getSpaceDimension();
- mcIdType nbNodes(_coords->getNumberOfTuples());
+ int const spaceDim=getSpaceDimension();
+ mcIdType const nbNodes(_coords->getNumberOfTuples());
double *coords=_coords->getPointer();
if(spaceDim==3)
DataArrayDouble::Rotate3DAlg(center,vector,angle,nbNodes,coords,coords);
if(!((DataArrayDouble *)_coords))
throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::translate : no coordinates set !");
double *coords=_coords->getPointer();
- mcIdType nbNodes=getNumberOfNodes();
- int dim=getSpaceDimension();
+ mcIdType const nbNodes=getNumberOfNodes();
+ int const dim=getSpaceDimension();
for(mcIdType i=0; i<nbNodes; i++)
for(int idim=0; idim<dim;idim++)
coords[i*dim+idim]+=vector[idim];
if(!((DataArrayDouble *)_coords))
throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::scale : no coordinates set !");
double *coords=_coords->getPointer();
- mcIdType nbNodes(_coords->getNumberOfTuples());
- std::size_t dim(_coords->getNumberOfComponents());
+ mcIdType const nbNodes(_coords->getNumberOfTuples());
+ std::size_t const dim(_coords->getNumberOfComponents());
for(mcIdType i=0;i<nbNodes;i++)
{
std::transform(coords+i*dim,coords+(i+1)*dim,point,coords+i*dim,std::minus<double>());
updateTime();
}
-MEDCouplingMesh *MEDCouplingCurveLinearMesh::mergeMyselfWith(const MEDCouplingMesh *other) const
+MEDCouplingMesh *MEDCouplingCurveLinearMesh::mergeMyselfWith(const MEDCouplingMesh * /*other*/) const
{
throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::mergeMyselfWith : not available for CurveLinear Mesh !");
}
DataArrayDouble *MEDCouplingCurveLinearMesh::getCoordinatesAndOwner() const
{
- DataArrayDouble *ret=const_cast<DataArrayDouble *>((const DataArrayDouble *)_coords);
+ auto *ret=const_cast<DataArrayDouble *>((const DataArrayDouble *)_coords);
if(ret)
ret->incrRef();
return ret;
{
checkConsistencyLight();
MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- int spaceDim=getSpaceDimension();
- int meshDim=getMeshDimension();
- mcIdType nbOfCells=getNumberOfCells();
+ int const spaceDim=getSpaceDimension();
+ int const meshDim=getMeshDimension();
+ mcIdType const nbOfCells=getNumberOfCells();
ret->alloc(nbOfCells,spaceDim);
ret->copyStringInfoFrom(*getCoords());
switch(meshDim)
*/
void MEDCouplingCurveLinearMesh::getBarycenterAndOwnerMeshDim3(DataArrayDouble *bary) const
{
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
double *ptToFill=bary->getPointer();
const double *coor=_coords->getConstPointer();
if(getSpaceDimension()!=3)
throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::getBarycenterAndOwnerMeshDim3 : with meshDim 3 only space dimension 3 is possible !");
mcIdType nX=_structure[0]-1,nY=(_structure[0]-1)*(_structure[1]-1);
- mcIdType nY1=_structure[0]*_structure[1];
+ mcIdType const nY1=_structure[0]*_structure[1];
mcIdType conn[8];
for(mcIdType i=0;i<nbOfCells;i++)
{
- mcIdType cz=i/nY;
- mcIdType cy=(i-cz*nY)/nX;
- mcIdType cx=(i-cz*nY)-nX*cy;
+ mcIdType const cz=i/nY;
+ mcIdType const cy=(i-cz*nY)/nX;
+ mcIdType const cx=(i-cz*nY)-nX*cy;
conn[0]=cz*nY1+cy*(nX+1)+cx+1; conn[1]=cz*nY1+cy*(nX+1)+cx; conn[2]=cz*nY1+(cy+1)*(nX+1)+cx; conn[3]=cz*nY1+(cy+1)*(nX+1)+1+cx;
conn[4]=(cz+1)*nY1+cy*(nX+1)+cx+1; conn[5]=(cz+1)*nY1+cy*(nX+1)+cx; conn[6]=(cz+1)*nY1+(cy+1)*(nX+1)+cx; conn[7]=(cz+1)*nY1+(cy+1)*(nX+1)+1+cx;
INTERP_KERNEL::computeBarycenter2<mcIdType,INTERP_KERNEL::ALL_C_MODE>(INTERP_KERNEL::NORM_HEXA8,conn,8,coor,3,ptToFill);
*/
void MEDCouplingCurveLinearMesh::getBarycenterAndOwnerMeshDim2(DataArrayDouble *bary) const
{
- mcIdType nbcells=getNumberOfCells();
- int spaceDim=getSpaceDimension();
+ mcIdType const nbcells=getNumberOfCells();
+ int const spaceDim=getSpaceDimension();
double *ptToFill=bary->getPointer();
const double *coor=_coords->getConstPointer();
if(spaceDim!=2 && spaceDim!=3)
throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::getBarycenterAndOwnerMeshDim2 : with meshDim 2 only space dimension 2 and 3 are possible !");
- mcIdType nX=_structure[0]-1;
+ mcIdType const nX=_structure[0]-1;
mcIdType conn[4];
for(mcIdType i=0;i<nbcells;i++)
{
*/
void MEDCouplingCurveLinearMesh::getBarycenterAndOwnerMeshDim1(DataArrayDouble *bary) const
{
- int spaceDim=getSpaceDimension();
+ int const spaceDim=getSpaceDimension();
std::transform(_coords->begin()+spaceDim,_coords->end(),_coords->begin(),bary->getPointer(),std::plus<double>());
std::transform(bary->begin(),bary->end(),bary->getPointer(),std::bind(std::multiplies<double>(),std::placeholders::_1,0.5));
}
-void MEDCouplingCurveLinearMesh::renumberCells(const mcIdType *old2NewBg, bool check)
+void MEDCouplingCurveLinearMesh::renumberCells(const mcIdType * /*old2NewBg*/, bool /*check*/)
{
throw INTERP_KERNEL::Exception("Functionality of renumbering cell not available for CurveLinear Mesh !");
}
std::copy(_coords->begin(),_coords->end(),a2->getPointer());
}
-void MEDCouplingCurveLinearMesh::unserialization(const std::vector<double>& tinyInfoD, const std::vector<mcIdType>& tinyInfo, const DataArrayIdType *a1, DataArrayDouble *a2,
+void MEDCouplingCurveLinearMesh::unserialization(const std::vector<double>& tinyInfoD, const std::vector<mcIdType>& tinyInfo, const DataArrayIdType * /*a1*/, DataArrayDouble *a2,
const std::vector<std::string>& littleStrings)
{
setName(littleStrings[0]);
void MEDCouplingCurveLinearMesh::writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData, DataArrayByte *byteData) const
{
std::ostringstream extent;
- std::size_t meshDim=_structure.size();
+ std::size_t const meshDim=_structure.size();
if(meshDim==0 || meshDim>3)
throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::writeVTKLL : meshDim invalid ! must be in [1,2,3] !");
for(std::size_t i=0;i<3;i++)
- { mcIdType val=i<meshDim?_structure[i]-1:0; extent << "0 " << val << " "; }
+ { mcIdType const val=i<meshDim?_structure[i]-1:0; extent << "0 " << val << " "; }
ofs << " <" << getVTKDataSetType() << " WholeExtent=\"" << extent.str() << "\">\n";
ofs << " <Piece Extent=\"" << extent.str() << "\">\n";
ofs << " <PointData>\n" << pointData << std::endl;
{
stream << "MEDCouplingCurveLinearMesh C++ instance at " << this << ". Name : \"" << getName() << "\".";
stream << " Nodal structure : [";
- std::size_t s_size=_structure.size();
+ std::size_t const s_size=_structure.size();
for(std::size_t i=0;i<s_size;i++)
{
- char tmp=(char)((int)('X')+i);
+ char const tmp=(char)((int)('X')+i);
stream << " " << tmp << "=" << _structure[i];
if(i!=s_size-1)
stream << ", ";
{ stream << std::endl << "No coordinates set !"; return ; }
if(!coo->isAllocated())
{ stream << std::endl << "Coordinates set but not allocated !"; return ; }
- std::size_t nbOfCompo(coo->getNumberOfComponents());
+ std::size_t const nbOfCompo(coo->getNumberOfComponents());
std::size_t nbOfCompoExp(-1);
try
{
#ifndef __PARAMEDMEM_MEDCOUPLINGCURVELINEARMESH_HXX__
#define __PARAMEDMEM_MEDCOUPLINGCURVELINEARMESH_HXX__
+#include "MCType.hxx"
#include "MEDCoupling.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingMesh.hxx"
#include "MEDCouplingStructuredMesh.hxx"
#include "MCAuto.hxx"
+#include <string>
+#include <cstddef>
+#include <vector>
+#include <utility>
+#include <ostream>
namespace MEDCoupling
{
MEDCOUPLING_EXPORT static MEDCouplingCurveLinearMesh *New();
MEDCOUPLING_EXPORT static MEDCouplingCurveLinearMesh *New(const std::string& meshName);
MEDCOUPLING_EXPORT std::string getClassName() const override { return std::string("MEDCouplingCurveLinearMesh"); }
- MEDCOUPLING_EXPORT MEDCouplingCurveLinearMesh *deepCopy() const;
- MEDCOUPLING_EXPORT MEDCouplingCurveLinearMesh *clone(bool recDeepCpy) const;
- MEDCOUPLING_EXPORT void updateTime() const;
- MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- MEDCOUPLING_EXPORT MEDCouplingMeshType getType() const { return CURVE_LINEAR; }
- MEDCOUPLING_EXPORT void copyTinyStringsFrom(const MEDCouplingMesh *other);
- MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const;
- MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const;
+ MEDCOUPLING_EXPORT MEDCouplingCurveLinearMesh *deepCopy() const override;
+ MEDCOUPLING_EXPORT MEDCouplingCurveLinearMesh *clone(bool recDeepCpy) const override;
+ MEDCOUPLING_EXPORT void updateTime() const override;
+ MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ MEDCOUPLING_EXPORT MEDCouplingMeshType getType() const override { return CURVE_LINEAR; }
+ MEDCOUPLING_EXPORT void copyTinyStringsFrom(const MEDCouplingMesh *other) override;
+ MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const override;
+ MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const override;
MEDCOUPLING_EXPORT void checkDeepEquivalWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
- DataArrayIdType *&cellCor, DataArrayIdType *&nodeCor) const;
+ DataArrayIdType *&cellCor, DataArrayIdType *&nodeCor) const override;
MEDCOUPLING_EXPORT void checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
- DataArrayIdType *&cellCor) const;
- MEDCOUPLING_EXPORT void checkConsistencyLight() const;
- MEDCOUPLING_EXPORT void checkConsistency(double eps=1e-12) const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfCells() const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfNodes() const;
- MEDCOUPLING_EXPORT int getSpaceDimension() const;
- MEDCOUPLING_EXPORT void getCoordinatesOfNode(mcIdType nodeId, std::vector<double>& coo) const;
- MEDCOUPLING_EXPORT std::string simpleRepr() const;
- MEDCOUPLING_EXPORT std::string advancedRepr() const;
- MEDCOUPLING_EXPORT const DataArrayDouble *getDirectAccessOfCoordsArrIfInStructure() const;
+ DataArrayIdType *&cellCor) const override;
+ MEDCOUPLING_EXPORT void checkConsistencyLight() const override;
+ MEDCOUPLING_EXPORT void checkConsistency(double eps=1e-12) const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfCells() const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfNodes() const override;
+ MEDCOUPLING_EXPORT int getSpaceDimension() const override;
+ MEDCOUPLING_EXPORT void getCoordinatesOfNode(mcIdType nodeId, std::vector<double>& coo) const override;
+ MEDCOUPLING_EXPORT std::string simpleRepr() const override;
+ MEDCOUPLING_EXPORT std::string advancedRepr() const override;
+ MEDCOUPLING_EXPORT const DataArrayDouble *getDirectAccessOfCoordsArrIfInStructure() const override;
MEDCOUPLING_EXPORT DataArrayDouble *getCoords();
MEDCOUPLING_EXPORT const DataArrayDouble *getCoords() const;
MEDCOUPLING_EXPORT void setCoords(const DataArrayDouble *coords);
MEDCOUPLING_EXPORT void setNodeGridStructure(const mcIdType *gridStructBg, const mcIdType *gridStructEnd);
- MEDCOUPLING_EXPORT std::vector<mcIdType> getNodeGridStructure() const;
- MEDCOUPLING_EXPORT MEDCouplingStructuredMesh *buildStructuredSubPart(const std::vector< std::pair<mcIdType,mcIdType> >& cellPart) const;
+ MEDCOUPLING_EXPORT std::vector<mcIdType> getNodeGridStructure() const override;
+ MEDCOUPLING_EXPORT MEDCouplingStructuredMesh *buildStructuredSubPart(const std::vector< std::pair<mcIdType,mcIdType> >& cellPart) const override;
// tools
- MEDCOUPLING_EXPORT void getBoundingBox(double *bbox) const;
- MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureField(bool isAbs) const;
- MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureFieldOnNode(bool isAbs) const;
- MEDCOUPLING_EXPORT MEDCouplingFieldDouble *buildOrthogonalField() const;
- MEDCOUPLING_EXPORT mcIdType getCellContainingPoint(const double *pos, double eps) const;
- MEDCOUPLING_EXPORT void getCellsContainingPoint(const double *pos, double eps, std::vector<mcIdType>& elts) const;
- MEDCOUPLING_EXPORT void rotate(const double *center, const double *vector, double angle);
- MEDCOUPLING_EXPORT void translate(const double *vector);
- MEDCOUPLING_EXPORT void scale(const double *point, double factor);
- MEDCOUPLING_EXPORT MEDCouplingMesh *mergeMyselfWith(const MEDCouplingMesh *other) const;
- MEDCOUPLING_EXPORT DataArrayDouble *getCoordinatesAndOwner() const;
- MEDCOUPLING_EXPORT DataArrayDouble *computeCellCenterOfMass() const;
- MEDCOUPLING_EXPORT DataArrayDouble *computeIsoBarycenterOfNodesPerCell() const;
- MEDCOUPLING_EXPORT void renumberCells(const mcIdType *old2NewBg, bool check=true);
+ MEDCOUPLING_EXPORT void getBoundingBox(double *bbox) const override;
+ MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureField(bool isAbs) const override;
+ MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureFieldOnNode(bool isAbs) const override;
+ MEDCOUPLING_EXPORT MEDCouplingFieldDouble *buildOrthogonalField() const override;
+ MEDCOUPLING_EXPORT mcIdType getCellContainingPoint(const double *pos, double eps) const override;
+ MEDCOUPLING_EXPORT void getCellsContainingPoint(const double *pos, double eps, std::vector<mcIdType>& elts) const override;
+ MEDCOUPLING_EXPORT void rotate(const double *center, const double *vector, double angle) override;
+ MEDCOUPLING_EXPORT void translate(const double *vector) override;
+ MEDCOUPLING_EXPORT void scale(const double *point, double factor) override;
+ MEDCOUPLING_EXPORT MEDCouplingMesh *mergeMyselfWith(const MEDCouplingMesh *other) const override;
+ MEDCOUPLING_EXPORT DataArrayDouble *getCoordinatesAndOwner() const override;
+ MEDCOUPLING_EXPORT DataArrayDouble *computeCellCenterOfMass() const override;
+ MEDCOUPLING_EXPORT DataArrayDouble *computeIsoBarycenterOfNodesPerCell() const override;
+ MEDCOUPLING_EXPORT void renumberCells(const mcIdType *old2NewBg, bool check=true) override;
//some useful methods
- MEDCOUPLING_EXPORT void getNodeGridStructure(mcIdType *res) const;
+ MEDCOUPLING_EXPORT void getNodeGridStructure(mcIdType *res) const override;
//serialisation-unserialization
- MEDCOUPLING_EXPORT void getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const;
- MEDCOUPLING_EXPORT void resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const;
- MEDCOUPLING_EXPORT void serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const;
+ MEDCOUPLING_EXPORT void getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const override;
+ MEDCOUPLING_EXPORT void resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const override;
+ MEDCOUPLING_EXPORT void serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const override;
MEDCOUPLING_EXPORT void unserialization(const std::vector<double>& tinyInfoD, const std::vector<mcIdType>& tinyInfo, const DataArrayIdType *a1, DataArrayDouble *a2,
- const std::vector<std::string>& littleStrings);
- MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const;
- MEDCOUPLING_EXPORT std::string getVTKFileExtension() const;
+ const std::vector<std::string>& littleStrings) override;
+ MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const override;
+ MEDCOUPLING_EXPORT std::string getVTKFileExtension() const override;
private:
void getMeasureFieldMeshDim1(bool isAbs, MEDCouplingFieldDouble *field) const;
void getMeasureFieldMeshDim2(bool isAbs, MEDCouplingFieldDouble *field) const;
private:
MEDCouplingCurveLinearMesh();
MEDCouplingCurveLinearMesh(const MEDCouplingCurveLinearMesh& other, bool deepCpy);
- ~MEDCouplingCurveLinearMesh();
- void writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData, DataArrayByte *byteData) const;
- std::string getVTKDataSetType() const;
+ ~MEDCouplingCurveLinearMesh() override;
+ void writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData, DataArrayByte *byteData) const override;
+ std::string getVTKDataSetType() const override;
private:
MCAuto<DataArrayDouble> _coords;
std::vector<mcIdType> _structure;
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingDefinitionTime.hxx"
+#include "MCIdType.hxx"
+#include "MCAuto.hxx"
#include "MEDCouplingFieldDouble.hxx"
+#include "MEDCouplingRefCountObject.hxx"
#include <cmath>
+#include <vector>
+#include <ostream>
+#include <cstddef>
using namespace MEDCoupling;
}
}
-bool MEDCouplingDefinitionTimeSlice::isEqual(const MEDCouplingDefinitionTimeSlice& other, double eps) const
+bool MEDCouplingDefinitionTimeSlice::isEqual(const MEDCouplingDefinitionTimeSlice& other, double /*eps*/) const
{
if(_mesh_id!=other._mesh_id)
return false;
MEDCouplingDefinitionTimeSlice::MEDCouplingDefinitionTimeSlice(const MEDCouplingFieldDouble *f, int meshId, int arrId, int fieldId):_mesh_id(meshId),_array_id(arrId),_field_id(fieldId)
{
int tmp1,tmp2;
- double t1=f->getStartTime(tmp1,tmp2);
- double t2=f->getEndTime(tmp1,tmp2);
+ double const t1=f->getStartTime(tmp1,tmp2);
+ double const t2=f->getEndTime(tmp1,tmp2);
if(t2<t1)
throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTimeSlice : End time strictly before Start time ...");
}
bool MEDCouplingDefinitionTimeSlice::isFullyIncludedInMe(const MEDCouplingDefinitionTimeSlice *other, double eps) const
{
- double t1=getStartTime();
- double t2=getEndTime();
- double o1=other->getStartTime();
- double o2=other->getEndTime();
+ double const t1=getStartTime();
+ double const t2=getEndTime();
+ double const o1=other->getStartTime();
+ double const o2=other->getEndTime();
return o1>t1-eps && o2<t2+eps;
}
bool MEDCouplingDefinitionTimeSlice::isOverllapingWithMe(const MEDCouplingDefinitionTimeSlice *other, double eps) const
{
- double t1=getStartTime();
- double t2=getEndTime();
- double o1=other->getStartTime();
- double o2=other->getEndTime();
+ double const t1=getStartTime();
+ double const t2=getEndTime();
+ double const o1=other->getStartTime();
+ double const o2=other->getEndTime();
return (o1<t1+eps && o2<t1+eps) || (o1>t2-eps && o2>t2-eps);
}
bool MEDCouplingDefinitionTimeSlice::isAfterMe(const MEDCouplingDefinitionTimeSlice *other, double eps) const
{
- double t2=getEndTime();
- double o1=other->getStartTime();
- double o2=other->getEndTime();
+ double const t2=getEndTime();
+ double const o1=other->getStartTime();
+ double const o2=other->getEndTime();
return (o1>t2-eps && o2>t2-eps);
}
bool MEDCouplingDefinitionTimeSlice::isBeforeMe(const MEDCouplingDefinitionTimeSlice *other, double eps) const
{
- double t1=getStartTime();
- double o1=other->getStartTime();
- double o2=other->getEndTime();
+ double const t1=getStartTime();
+ double const o1=other->getStartTime();
+ double const o2=other->getEndTime();
return (o1<t1+eps && o2<t1+eps);
}
MEDCouplingDefinitionTimeSliceInst *MEDCouplingDefinitionTimeSliceInst::New(const std::vector<int>& tiI, const std::vector<double>& tiD)
{
- MEDCouplingDefinitionTimeSliceInst *ret=new MEDCouplingDefinitionTimeSliceInst;
+ auto *ret=new MEDCouplingDefinitionTimeSliceInst;
ret->unserialize(tiI,tiD);
return ret;
}
{
if(!MEDCouplingDefinitionTimeSlice::isEqual(other,eps))
return false;
- const MEDCouplingDefinitionTimeSliceInst *otherC=dynamic_cast<const MEDCouplingDefinitionTimeSliceInst *>(&other);
+ const auto *otherC=dynamic_cast<const MEDCouplingDefinitionTimeSliceInst *>(&other);
if(!otherC)
return false;
return fabs(otherC->_instant-_instant)<eps;
ret[0]=_instant;
}
-void MEDCouplingDefinitionTimeSliceInst::getIdsOnTime(double tm, double eps, int& meshId, int& arrId, int& arrIdInField, int& fieldId) const
+void MEDCouplingDefinitionTimeSliceInst::getIdsOnTime(double /*tm*/, double /*eps*/, int& meshId, int& arrId, int& arrIdInField, int& fieldId) const
{
meshId=_mesh_id;
arrId=_array_id;
MEDCouplingDefinitionTimeSliceInst::MEDCouplingDefinitionTimeSliceInst(const MEDCouplingFieldDouble *f, int meshId, int arrId, int fieldId):MEDCouplingDefinitionTimeSlice(f,meshId,arrId,fieldId)
{
int tmp1,tmp2;
- double t1=f->getStartTime(tmp1,tmp2);
- double t2=f->getEndTime(tmp1,tmp2);
- double eps=f->getTimeTolerance();
+ double const t1=f->getStartTime(tmp1,tmp2);
+ double const t2=f->getEndTime(tmp1,tmp2);
+ double const eps=f->getTimeTolerance();
if(fabs(t1-t2)>eps)
throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTimeSliceInst : times differs in this");
_instant=t1;
MEDCouplingDefinitionTimeSliceCstOnTI *MEDCouplingDefinitionTimeSliceCstOnTI::New(const std::vector<int>& tiI, const std::vector<double>& tiD)
{
- MEDCouplingDefinitionTimeSliceCstOnTI *ret=new MEDCouplingDefinitionTimeSliceCstOnTI;
+ auto *ret=new MEDCouplingDefinitionTimeSliceCstOnTI;
ret->unserialize(tiI,tiD);
return ret;
}
{
if(!MEDCouplingDefinitionTimeSlice::isEqual(other,eps))
return false;
- const MEDCouplingDefinitionTimeSliceCstOnTI *otherC=dynamic_cast<const MEDCouplingDefinitionTimeSliceCstOnTI *>(&other);
+ const auto *otherC=dynamic_cast<const MEDCouplingDefinitionTimeSliceCstOnTI *>(&other);
if(!otherC)
return false;
if(fabs(otherC->_start-_start)>eps)
ret[0]=(_start+_end)/2.;
}
-void MEDCouplingDefinitionTimeSliceCstOnTI::getIdsOnTime(double tm, double eps, int& meshId, int& arrId, int& arrIdInField, int& fieldId) const
+void MEDCouplingDefinitionTimeSliceCstOnTI::getIdsOnTime(double /*tm*/, double /*eps*/, int& meshId, int& arrId, int& arrIdInField, int& fieldId) const
{
meshId=_mesh_id;
arrId=_array_id;
MEDCouplingDefinitionTimeSliceCstOnTI::MEDCouplingDefinitionTimeSliceCstOnTI(const MEDCouplingFieldDouble *f, int meshId, int arrId, int fieldId):MEDCouplingDefinitionTimeSlice(f,meshId,arrId,fieldId)
{
int tmp1,tmp2;
- double t1=f->getStartTime(tmp1,tmp2);
- double t2=f->getEndTime(tmp1,tmp2);
+ double const t1=f->getStartTime(tmp1,tmp2);
+ double const t2=f->getEndTime(tmp1,tmp2);
_start=t1;
_end=t2;
}
MEDCouplingDefinitionTimeSliceLT *MEDCouplingDefinitionTimeSliceLT::New(const std::vector<int>& tiI, const std::vector<double>& tiD)
{
- MEDCouplingDefinitionTimeSliceLT *ret=new MEDCouplingDefinitionTimeSliceLT;
+ auto *ret=new MEDCouplingDefinitionTimeSliceLT;
ret->unserialize(tiI,tiD);
return ret;
}
{
if(!MEDCouplingDefinitionTimeSlice::isEqual(other,eps))
return false;
- const MEDCouplingDefinitionTimeSliceLT *otherC=dynamic_cast<const MEDCouplingDefinitionTimeSliceLT *>(&other);
+ const auto *otherC=dynamic_cast<const MEDCouplingDefinitionTimeSliceLT *>(&other);
if(!otherC)
return false;
if(_array_id_end!=otherC->_array_id_end)
MEDCouplingDefinitionTimeSliceLT::MEDCouplingDefinitionTimeSliceLT(const MEDCouplingFieldDouble *f, int meshId, int arrId, int arr2Id, int fieldId):MEDCouplingDefinitionTimeSlice(f,meshId,arrId,fieldId),_array_id_end(arr2Id)
{
int tmp1,tmp2;
- double t1=f->getStartTime(tmp1,tmp2);
- double t2=f->getEndTime(tmp1,tmp2);
+ double const t1=f->getStartTime(tmp1,tmp2);
+ double const t2=f->getEndTime(tmp1,tmp2);
_start=t1;
_end=t2;
}
MEDCouplingDefinitionTime::MEDCouplingDefinitionTime(const std::vector<const MEDCouplingFieldDouble *>& fs, const std::vector<int>& meshRefs, const std::vector<std::vector<int> >& arrRefs)
{
- std::size_t sz=fs.size();
+ std::size_t const sz=fs.size();
if(sz!=arrRefs.size())
throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTime constructor : internal error ! should never happen !");
_slices.resize(sz);
void MEDCouplingDefinitionTime::assign(const MEDCouplingDefinitionTime& other)
{
- std::size_t sz=other._slices.size();
+ std::size_t const sz=other._slices.size();
_slices.resize(sz);
for(std::size_t i=0;i<sz;i++)
_slices[i]=other._slices[i]->copy();
bool MEDCouplingDefinitionTime::isEqual(const MEDCouplingDefinitionTime& other) const
{
- std::size_t sz=_slices.size();
+ std::size_t const sz=_slices.size();
if(sz!=other._slices.size())
return false;
for(std::size_t i=0;i<sz;i++)
{
std::vector<int> ids;
int id=0;
- for(std::vector< MCAuto<MEDCouplingDefinitionTimeSlice> >::const_iterator it=_slices.begin();it!=_slices.end();it++,id++)
+ for(auto it=_slices.begin();it!=_slices.end();it++,id++)
if((*it)->isContaining(tm,_eps))
ids.push_back(id);
if(ids.empty())
throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTime::getIdsOnTime : No matching slice for such time !");
- std::size_t sz=ids.size();
+ std::size_t const sz=ids.size();
if(sz>2)
throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTime::getIdsOnTime : Too many slices match this time !");
//
std::vector<double> MEDCouplingDefinitionTime::getHotSpotsTime() const
{
std::vector<double> ret;
- for(std::vector< MCAuto<MEDCouplingDefinitionTimeSlice> >::const_iterator it=_slices.begin();it!=_slices.end();it++)
+ for(const auto & _slice : _slices)
{
std::vector<double> tmp;
- (*it)->getHotSpotsTime(tmp);
+ _slice->getHotSpotsTime(tmp);
if(!ret.empty())
{
if(fabs(ret.back()-tmp.front())>_eps)
void MEDCouplingDefinitionTime::appendRepr(std::ostream& stream) const
{
stream << "Time definition :\n";
- for(std::vector< MCAuto<MEDCouplingDefinitionTimeSlice> >::const_iterator it=_slices.begin();it!=_slices.end();it++)
+ for(const auto & _slice : _slices)
{
stream << " - ";
- (*it)->appendRepr(stream);
+ _slice->appendRepr(stream);
stream << std::endl;
}
}
void MEDCouplingDefinitionTime::getTinySerializationInformation(std::vector<int>& tinyInfoI, std::vector<double>& tinyInfoD) const
{
- int sz=(int)_slices.size();
+ int const sz=(int)_slices.size();
tinyInfoD.resize(1);
tinyInfoD[0]=_eps;
tinyInfoI.resize(3*sz+2);
void MEDCouplingDefinitionTime::unserialize(const std::vector<int>& tinyInfoI, const std::vector<double>& tinyInfoD)
{
- int sz=tinyInfoI[0];
+ int const sz=tinyInfoI[0];
_slices.resize(sz);
_eps=tinyInfoD[0];
int offset1=0;
int offset2=1;
for(int i=0;i<sz;i++)
{
- TypeOfTimeDiscretization ty=(TypeOfTimeDiscretization) tinyInfoI[i+2];
- int sz1=tinyInfoI[i+sz+2];
- int sz2=tinyInfoI[i+2*sz+2];
- std::vector<int> tmp1(tinyInfoI.begin()+3*sz+2+offset1,tinyInfoI.begin()+3*sz+2+offset1+sz1);
- std::vector<double> tmp2(tinyInfoD.begin()+offset2,tinyInfoD.begin()+offset2+sz2);
+ auto const ty=(TypeOfTimeDiscretization) tinyInfoI[i+2];
+ int const sz1=tinyInfoI[i+sz+2];
+ int const sz2=tinyInfoI[i+2*sz+2];
+ std::vector<int> const tmp1(tinyInfoI.begin()+3*sz+2+offset1,tinyInfoI.begin()+3*sz+2+offset1+sz1);
+ std::vector<double> const tmp2(tinyInfoD.begin()+offset2,tinyInfoD.begin()+offset2+sz2);
MEDCouplingDefinitionTimeSlice *pt=MEDCouplingDefinitionTimeSlice::New(ty,tmp1,tmp2);
_slices[i]=pt;
offset1+=sz1;
#ifndef __PARAMEDMEM_MEDCOUPLINGDEFINITIONTIME_HXX__
#define __PARAMEDMEM_MEDCOUPLINGDEFINITIONTIME_HXX__
+#include "MEDCoupling.hxx"
#include "MEDCouplingRefCountObject.hxx"
#include "MCAuto.hxx"
-#include "InterpKernelException.hxx"
+#include <ostream>
+#include <cstddef>
+#include <string>
#include <vector>
-#include <sstream>
namespace MEDCoupling
{
MEDCOUPLING_EXPORT virtual double getEndTime() const = 0;
MEDCOUPLING_EXPORT virtual void getTinySerializationInformation(std::vector<int>& tiI, std::vector<double>& tiD) const = 0;
MEDCOUPLING_EXPORT virtual TypeOfTimeDiscretization getTimeType() const = 0;
- MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
MEDCOUPLING_EXPORT bool isFullyIncludedInMe(const MEDCouplingDefinitionTimeSlice *other, double eps) const;
MEDCOUPLING_EXPORT bool isOverllapingWithMe(const MEDCouplingDefinitionTimeSlice *other, double eps) const;
MEDCOUPLING_EXPORT bool isAfterMe(const MEDCouplingDefinitionTimeSlice *other, double eps) const;
public:
static MEDCouplingDefinitionTimeSliceInst *New(const std::vector<int>& tiI, const std::vector<double>& tiD);
MEDCOUPLING_EXPORT std::string getClassName() const override { return std::string("MEDCouplingDefinitionTimeSliceInst"); }
- MEDCouplingDefinitionTimeSlice *copy() const;
- bool isEqual(const MEDCouplingDefinitionTimeSlice& other, double eps) const;
- void getHotSpotsTime(std::vector<double>& ret) const;
- void getIdsOnTime(double tm, double eps, int& meshId, int& arrId, int& arrIdInField, int& fieldId) const;
- bool isContaining(double tmp, double eps) const;
- void appendRepr(std::ostream& stream) const;
- double getStartTime() const;
- double getEndTime() const;
- void getTinySerializationInformation(std::vector<int>& tiI, std::vector<double>& tiD) const;
+ MEDCouplingDefinitionTimeSlice *copy() const override;
+ bool isEqual(const MEDCouplingDefinitionTimeSlice& other, double eps) const override;
+ void getHotSpotsTime(std::vector<double>& ret) const override;
+ void getIdsOnTime(double tm, double eps, int& meshId, int& arrId, int& arrIdInField, int& fieldId) const override;
+ bool isContaining(double tmp, double eps) const override;
+ void appendRepr(std::ostream& stream) const override;
+ double getStartTime() const override;
+ double getEndTime() const override;
+ void getTinySerializationInformation(std::vector<int>& tiI, std::vector<double>& tiD) const override;
void unserialize(const std::vector<int>& tiI, const std::vector<double>& tiD);
- TypeOfTimeDiscretization getTimeType() const;
+ TypeOfTimeDiscretization getTimeType() const override;
public:
MEDCouplingDefinitionTimeSliceInst(const MEDCouplingFieldDouble *f, int meshId, int arrId, int fieldId);
protected:
public:
static MEDCouplingDefinitionTimeSliceCstOnTI *New(const std::vector<int>& tiI, const std::vector<double>& tiD);
MEDCOUPLING_EXPORT std::string getClassName() const override { return std::string("MEDCouplingDefinitionTimeSliceCstOnTI"); }
- MEDCouplingDefinitionTimeSlice *copy() const;
- bool isEqual(const MEDCouplingDefinitionTimeSlice& other, double eps) const;
- void getHotSpotsTime(std::vector<double>& ret) const;
- void getIdsOnTime(double tm, double eps, int& meshId, int& arrId, int& arrIdInField, int& fieldId) const;
- bool isContaining(double tmp, double eps) const;
- void appendRepr(std::ostream& stream) const;
- double getStartTime() const;
- double getEndTime() const;
- void getTinySerializationInformation(std::vector<int>& tiI, std::vector<double>& tiD) const;
+ MEDCouplingDefinitionTimeSlice *copy() const override;
+ bool isEqual(const MEDCouplingDefinitionTimeSlice& other, double eps) const override;
+ void getHotSpotsTime(std::vector<double>& ret) const override;
+ void getIdsOnTime(double tm, double eps, int& meshId, int& arrId, int& arrIdInField, int& fieldId) const override;
+ bool isContaining(double tmp, double eps) const override;
+ void appendRepr(std::ostream& stream) const override;
+ double getStartTime() const override;
+ double getEndTime() const override;
+ void getTinySerializationInformation(std::vector<int>& tiI, std::vector<double>& tiD) const override;
void unserialize(const std::vector<int>& tiI, const std::vector<double>& tiD);
- TypeOfTimeDiscretization getTimeType() const;
+ TypeOfTimeDiscretization getTimeType() const override;
public:
MEDCouplingDefinitionTimeSliceCstOnTI(const MEDCouplingFieldDouble *f, int meshId, int arrId, int fieldId);
protected:
public:
static MEDCouplingDefinitionTimeSliceLT *New(const std::vector<int>& tiI, const std::vector<double>& tiD);
std::string getClassName() const override { return std::string("MEDCouplingDefinitionTimeSliceLT"); }
- MEDCouplingDefinitionTimeSlice *copy() const;
- bool isEqual(const MEDCouplingDefinitionTimeSlice& other, double eps) const;
- void getHotSpotsTime(std::vector<double>& ret) const;
- void getIdsOnTime(double tm, double eps, int& meshId, int& arrId, int& arrIdInField, int& fieldId) const;
- bool isContaining(double tmp, double eps) const;
- void appendRepr(std::ostream& stream) const;
- double getStartTime() const;
- double getEndTime() const;
- int getEndId() const;
- void getTinySerializationInformation(std::vector<int>& tiI, std::vector<double>& tiD) const;
+ MEDCouplingDefinitionTimeSlice *copy() const override;
+ bool isEqual(const MEDCouplingDefinitionTimeSlice& other, double eps) const override;
+ void getHotSpotsTime(std::vector<double>& ret) const override;
+ void getIdsOnTime(double tm, double eps, int& meshId, int& arrId, int& arrIdInField, int& fieldId) const override;
+ bool isContaining(double tmp, double eps) const override;
+ void appendRepr(std::ostream& stream) const override;
+ double getStartTime() const override;
+ double getEndTime() const override;
+ int getEndId() const override;
+ void getTinySerializationInformation(std::vector<int>& tiI, std::vector<double>& tiD) const override;
void unserialize(const std::vector<int>& tiI, const std::vector<double>& tiD);
- TypeOfTimeDiscretization getTimeType() const;
+ TypeOfTimeDiscretization getTimeType() const override;
public:
MEDCouplingDefinitionTimeSliceLT(const MEDCouplingFieldDouble *f, int meshId, int arrId, int arr2Id, int fieldId);
protected:
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingField.hxx"
+#include "MCType.hxx"
+#include "MCIdType.hxx"
#include "MEDCouplingMesh.hxx"
#include "MEDCouplingFieldDiscretization.hxx"
+#include "MEDCouplingNatureOfField.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
+#include "NormalizedGeometricTypes"
+#include <cstddef>
+#include <set>
#include <sstream>
+#include <string>
+#include <vector>
using namespace MEDCoupling;
reason.insert(0,"Spatial discretizations differ :");
return false;
}
- if(_mesh==0 && other->_mesh==0)
+ if(_mesh==nullptr && other->_mesh==nullptr)
return true;
- if(_mesh==0 || other->_mesh==0)
+ if(_mesh==nullptr || other->_mesh==nullptr)
{
reason="Only one field between the two this and other has its underlying mesh defined !";
return false;
}
if(_mesh==other->_mesh)
return true;
- bool ret=_mesh->isEqualIfNotWhy(other->_mesh,meshPrec,reason);
+ bool const ret=_mesh->isEqualIfNotWhy(other->_mesh,meshPrec,reason);
if(!ret)
reason.insert(0,"Underlying meshes of fields differ for the following reason : ");
return ret;
return false;
if(_nature!=other->_nature)
return false;
- if(_mesh==0 && other->_mesh==0)
+ if(_mesh==nullptr && other->_mesh==nullptr)
return true;
- if(_mesh==0 || other->_mesh==0)
+ if(_mesh==nullptr || other->_mesh==nullptr)
return false;
if(_mesh==other->_mesh)
return true;
_mesh->decrRef();
}
-MEDCouplingField::MEDCouplingField(MEDCouplingFieldDiscretization *type, NatureOfField nature):_nature(nature),_mesh(0),_type(type)
+MEDCouplingField::MEDCouplingField(MEDCouplingFieldDiscretization *type, NatureOfField nature):_nature(nature),_mesh(nullptr),_type(type)
{
}
-MEDCouplingField::MEDCouplingField(TypeOfField type):_nature(NoNature),_mesh(0),_type(MEDCouplingFieldDiscretization::New(type))
+MEDCouplingField::MEDCouplingField(TypeOfField type):_nature(NoNature),_mesh(nullptr),_type(MEDCouplingFieldDiscretization::New(type))
{
}
MEDCouplingField::MEDCouplingField(const MEDCouplingField& other, bool deepCopy):RefCountObject(other),_name(other._name),_desc(other._desc),_nature(other._nature),
- _mesh(0),_type(0)
+ _mesh(nullptr),_type(nullptr)
{
if(other._mesh)
{
void MEDCouplingField::setDiscretization(MEDCouplingFieldDiscretization *newDisc)
{
- bool needUpdate=(const MEDCouplingFieldDiscretization *)_type!=newDisc;
+ bool const needUpdate=(const MEDCouplingFieldDiscretization *)_type!=newDisc;
_type=newDisc;
if(newDisc)
newDisc->incrRef();
#ifndef __PARAMEDMEM_MEDCOUPLINGFIELD_HXX__
#define __PARAMEDMEM_MEDCOUPLINGFIELD_HXX__
+#include "MCType.hxx"
#include "MEDCoupling.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
#include "MEDCouplingTimeLabel.hxx"
-#include "MEDCouplingNatureOfField.hxx"
#include "MEDCouplingRefCountObject.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
#include "MCAuto.hxx"
#include "MEDCouplingFieldDiscretization.hxx"
-#include "InterpKernelException.hxx"
+#include "NormalizedGeometricTypes"
+#include <set>
+#include <cstddef>
+#include <ostream>
#include <string>
#include <vector>
MEDCOUPLING_EXPORT mcIdType getGaussLocalizationIdOfOneCell(mcIdType cellId) const;
MEDCOUPLING_EXPORT void getCellIdsHavingGaussLocalization(int locId, std::vector<mcIdType>& cellIds) const;
MEDCOUPLING_EXPORT const MEDCouplingGaussLocalization& getGaussLocalization(int locId) const;
- MEDCOUPLING_EXPORT void updateTime() const;
- MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDCOUPLING_EXPORT void updateTime() const override;
+ MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
// for MED file RW
MEDCOUPLING_EXPORT mcIdType getNumberOfTuplesExpectedRegardingCode(const std::vector<mcIdType>& code, const std::vector<const DataArrayIdType *>& idsPerType) const;
MEDCOUPLING_EXPORT virtual void reprQuickOverview(std::ostream& stream) const = 0;
MEDCOUPLING_EXPORT MEDCouplingField(TypeOfField type);
MEDCOUPLING_EXPORT MEDCouplingField(const MEDCouplingField& other, bool deepCopy=true);
MEDCOUPLING_EXPORT MEDCouplingField(MEDCouplingFieldDiscretization *type, NatureOfField nature=NoNature);
- MEDCOUPLING_EXPORT virtual ~MEDCouplingField();
+ MEDCOUPLING_EXPORT ~MEDCouplingField() override;
MEDCOUPLING_EXPORT bool isEqualIfNotWhyProtected(const MEDCouplingField *other, double meshPrec, std::string& reason) const;
MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStrProtected(const MEDCouplingField *other, double meshPrec) const;
protected:
// Author : Anthony Geay (EDF R&D)
#include "MEDCouplingFieldDiscretization.hxx"
+#include "MCIdType.hxx"
+#include "MCType.hxx"
#include "MEDCouplingFieldDiscretizationOnNodesFE.hxx"
#include "MEDCouplingCMesh.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingGaussLocalization.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
#include "MEDCouplingUMesh.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "MCAuto.hxx"
#include "InterpKernelGaussCoords.hxx"
#include "InterpKernelMatrixTools.hxx"
#include "InterpKernelDenseMatrix.hxx"
+#include "NormalizedGeometricTypes"
-#include <set>
-#include <list>
+#include <cstddef>
+#include <cmath>
+#include <cstdlib>
+#include <iterator>
+#include <ostream>
#include <limits>
+#include <set>
#include <sstream>
#include <numeric>
#include <algorithm>
#include <functional>
+#include <string>
+#include <vector>
using namespace MEDCoupling;
/*!
* For all field discretization excepted GaussPts the [ \a startCellIds, \a endCellIds ) has no impact on the cloned instance.
*/
-MEDCouplingFieldDiscretization *MEDCouplingFieldDiscretization::clonePart(const mcIdType *startCellIds, const mcIdType *endCellIds) const
+MEDCouplingFieldDiscretization *MEDCouplingFieldDiscretization::clonePart(const mcIdType * /*startCellIds*/, const mcIdType * /*endCellIds*/) const
{
return clone();
}
/*!
* For all field discretization excepted GaussPts the slice( \a beginCellId, \a endCellIds, \a stepCellId ) has no impact on the cloned instance.
*/
-MEDCouplingFieldDiscretization *MEDCouplingFieldDiscretization::clonePartRange(mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds) const
+MEDCouplingFieldDiscretization *MEDCouplingFieldDiscretization::clonePartRange(mcIdType /*beginCellIds*/, mcIdType /*endCellIds*/, mcIdType /*stepCellIds*/) const
{
return clone();
}
void MEDCouplingFieldDiscretization::normL1(const MEDCouplingMesh *mesh, const DataArrayDouble *arr, double *res) const
{
MCAuto<MEDCouplingFieldDouble> vol=getMeasureField(mesh,true);
- std::size_t nbOfCompo=arr->getNumberOfComponents();
- mcIdType nbOfElems=getNumberOfTuples(mesh);
+ std::size_t const nbOfCompo=arr->getNumberOfComponents();
+ mcIdType const nbOfElems=getNumberOfTuples(mesh);
std::fill(res,res+nbOfCompo,0.);
const double *arrPtr=arr->getConstPointer();
const double *volPtr=vol->getArray()->getConstPointer();
double deno=0.;
for(mcIdType i=0;i<nbOfElems;i++)
{
- double v=fabs(volPtr[i]);
+ double const v=fabs(volPtr[i]);
for(std::size_t j=0;j<nbOfCompo;j++)
res[j]+=fabs(arrPtr[i*nbOfCompo+j])*v;
deno+=v;
void MEDCouplingFieldDiscretization::normL2(const MEDCouplingMesh *mesh, const DataArrayDouble *arr, double *res) const
{
MCAuto<MEDCouplingFieldDouble> vol=getMeasureField(mesh,true);
- std::size_t nbOfCompo=arr->getNumberOfComponents();
- mcIdType nbOfElems=getNumberOfTuples(mesh);
+ std::size_t const nbOfCompo=arr->getNumberOfComponents();
+ mcIdType const nbOfElems=getNumberOfTuples(mesh);
std::fill(res,res+nbOfCompo,0.);
const double *arrPtr=arr->getConstPointer();
const double *volPtr=vol->getArray()->getConstPointer();
double deno=0.;
for(mcIdType i=0;i<nbOfElems;i++)
{
- double v=fabs(volPtr[i]);
+ double const v=fabs(volPtr[i]);
for(std::size_t j=0;j<nbOfCompo;j++)
res[j]+=arrPtr[i*nbOfCompo+j]*arrPtr[i*nbOfCompo+j]*v;
deno+=v;
if(!arr)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretization::integral : input array is NULL !");
MCAuto<MEDCouplingFieldDouble> vol=getMeasureField(mesh,isWAbs);
- std::size_t nbOfCompo(arr->getNumberOfComponents());
- mcIdType nbOfElems(getNumberOfTuples(mesh));
+ std::size_t const nbOfCompo(arr->getNumberOfComponents());
+ mcIdType const nbOfElems(getNumberOfTuples(mesh));
if(nbOfElems!=arr->getNumberOfTuples())
{
std::ostringstream oss; oss << "MEDCouplingFieldDiscretization::integral : field is not correct ! number of tuples in array is " << arr->getNumberOfTuples();
*
* \sa MEDCouplingFieldDiscretization::buildSubMeshData
*/
-MEDCouplingMesh *MEDCouplingFieldDiscretization::buildSubMeshDataRange(const MEDCouplingMesh *mesh, mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds, mcIdType& beginOut, mcIdType& endOut, mcIdType& stepOut, DataArrayIdType *&di) const
+MEDCouplingMesh *MEDCouplingFieldDiscretization::buildSubMeshDataRange(const MEDCouplingMesh *mesh, mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds, mcIdType& /*beginOut*/, mcIdType& /*endOut*/, mcIdType& /*stepOut*/, DataArrayIdType *&di) const
{
MCAuto<DataArrayIdType> da=DataArrayIdType::Range(beginCellIds,endCellIds,stepCellIds);
return buildSubMeshData(mesh,da->begin(),da->end(),di);
void MEDCouplingFieldDiscretization::getSerializationIntArray(DataArrayIdType *& arr) const
{
- arr=0;
+ arr=nullptr;
}
/*!
{
}
-void MEDCouplingFieldDiscretization::resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *& arr)
+void MEDCouplingFieldDiscretization::resizeForUnserialization(const std::vector<mcIdType>& /*tinyInfo*/, DataArrayIdType *& arr)
{
- arr=0;
+ arr=nullptr;
}
/*!
{
}
-double MEDCouplingFieldDiscretization::getIJK(const MEDCouplingMesh *mesh, const DataArrayDouble *da, mcIdType cellId, mcIdType nodeIdInCell, int compoId) const
+double MEDCouplingFieldDiscretization::getIJK(const MEDCouplingMesh * /*mesh*/, const DataArrayDouble * /*da*/, mcIdType /*cellId*/, mcIdType /*nodeIdInCell*/, int /*compoId*/) const
{
throw INTERP_KERNEL::Exception("getIJK Invalid ! only for GaussPoint and GaussNE discretizations !");
}
-void MEDCouplingFieldDiscretization::setGaussLocalizationOnType(const MEDCouplingMesh *m, INTERP_KERNEL::NormalizedCellType type, const std::vector<double>& refCoo,
- const std::vector<double>& gsCoo, const std::vector<double>& wg)
+void MEDCouplingFieldDiscretization::setGaussLocalizationOnType(const MEDCouplingMesh * /*m*/, INTERP_KERNEL::NormalizedCellType /*type*/, const std::vector<double>& /*refCoo*/,
+ const std::vector<double>& /*gsCoo*/, const std::vector<double>& /*wg*/)
{
throw INTERP_KERNEL::Exception("Invalid method for the corresponding field discretization : available only for GaussPoint discretization !");
}
-void MEDCouplingFieldDiscretization::setGaussLocalizationOnCells(const MEDCouplingMesh *m, const mcIdType *begin, const mcIdType *end, const std::vector<double>& refCoo,
- const std::vector<double>& gsCoo, const std::vector<double>& wg)
+void MEDCouplingFieldDiscretization::setGaussLocalizationOnCells(const MEDCouplingMesh * /*m*/, const mcIdType * /*begin*/, const mcIdType * /*end*/, const std::vector<double>& /*refCoo*/,
+ const std::vector<double>& /*gsCoo*/, const std::vector<double>& /*wg*/)
{
throw INTERP_KERNEL::Exception("Invalid method for the corresponding field discretization : available only for GaussPoint discretization !");
}
throw INTERP_KERNEL::Exception("Invalid method for the corresponding field discretization : available only for GaussPoint discretization !");
}
-MEDCouplingGaussLocalization& MEDCouplingFieldDiscretization::getGaussLocalization(mcIdType locId)
+MEDCouplingGaussLocalization& MEDCouplingFieldDiscretization::getGaussLocalization(mcIdType /*locId*/)
{
throw INTERP_KERNEL::Exception("Invalid method for the corresponding field discretization : available only for GaussPoint discretization !");
}
-const MEDCouplingGaussLocalization& MEDCouplingFieldDiscretization::getGaussLocalization(mcIdType locId) const
+const MEDCouplingGaussLocalization& MEDCouplingFieldDiscretization::getGaussLocalization(mcIdType /*locId*/) const
{
throw INTERP_KERNEL::Exception("Invalid method for the corresponding field discretization : available only for GaussPoint discretization !");
}
throw INTERP_KERNEL::Exception("Invalid method for the corresponding field discretization : available only for GaussPoint discretization !");
}
-mcIdType MEDCouplingFieldDiscretization::getGaussLocalizationIdOfOneCell(mcIdType cellId) const
+mcIdType MEDCouplingFieldDiscretization::getGaussLocalizationIdOfOneCell(mcIdType /*cellId*/) const
{
throw INTERP_KERNEL::Exception("Invalid method for the corresponding field discretization : available only for GaussPoint discretization !");
}
-mcIdType MEDCouplingFieldDiscretization::getGaussLocalizationIdOfOneType(INTERP_KERNEL::NormalizedCellType type) const
+mcIdType MEDCouplingFieldDiscretization::getGaussLocalizationIdOfOneType(INTERP_KERNEL::NormalizedCellType /*type*/) const
{
throw INTERP_KERNEL::Exception("Invalid method for the corresponding field discretization : available only for GaussPoint discretization !");
}
-std::set<mcIdType> MEDCouplingFieldDiscretization::getGaussLocalizationIdsOfOneType(INTERP_KERNEL::NormalizedCellType type) const
+std::set<mcIdType> MEDCouplingFieldDiscretization::getGaussLocalizationIdsOfOneType(INTERP_KERNEL::NormalizedCellType /*type*/) const
{
throw INTERP_KERNEL::Exception("Invalid method for the corresponding field discretization : available only for GaussPoint discretization !");
}
-void MEDCouplingFieldDiscretization::getCellIdsHavingGaussLocalization(mcIdType locId, std::vector<mcIdType>& cellIds) const
+void MEDCouplingFieldDiscretization::getCellIdsHavingGaussLocalization(mcIdType /*locId*/, std::vector<mcIdType>& /*cellIds*/) const
{
throw INTERP_KERNEL::Exception("Invalid method for the corresponding field discretization : available only for GaussPoint discretization !");
}
{
if(!arr)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretization::RenumberEntitiesFromO2NArr : input array is NULL !");
- mcIdType oldNbOfElems=arr->getNumberOfTuples();
- std::size_t nbOfComp=arr->getNumberOfComponents();
- mcIdType newNbOfTuples=newNbOfEntity;
+ mcIdType const oldNbOfElems=arr->getNumberOfTuples();
+ std::size_t const nbOfComp=arr->getNumberOfComponents();
+ mcIdType const newNbOfTuples=newNbOfEntity;
MCAuto<DataArrayDouble> arrCpy=arr->deepCopy();
const double *ptSrc=arrCpy->getConstPointer();
arr->reAlloc(newNbOfTuples);
INTERP_KERNEL::AutoPtr<double> tmp=new double[nbOfComp];
for(mcIdType i=0;i<oldNbOfElems;i++)
{
- mcIdType newNb=old2NewPtr[i];
+ mcIdType const newNb=old2NewPtr[i];
if(newNb>=0)//if newNb<0 the node is considered as out.
{
if(std::find_if(ptToFill+newNb*nbOfComp,ptToFill+(newNb+1)*nbOfComp,std::bind(std::not_equal_to<double>(),std::placeholders::_1,std::numeric_limits<double>::max()))
}
}
-void MEDCouplingFieldDiscretization::RenumberEntitiesFromN2OArr(const mcIdType *new2OldPtr, mcIdType new2OldSz, DataArrayDouble *arr, const std::string& msg)
+void MEDCouplingFieldDiscretization::RenumberEntitiesFromN2OArr(const mcIdType *new2OldPtr, mcIdType new2OldSz, DataArrayDouble *arr, const std::string& /*msg*/)
{
- std::size_t nbOfComp=arr->getNumberOfComponents();
+ std::size_t const nbOfComp=arr->getNumberOfComponents();
MCAuto<DataArrayDouble> arrCpy=arr->deepCopy();
const double *ptSrc=arrCpy->getConstPointer();
arr->reAlloc(new2OldSz);
double *ptToFill=arr->getPointer();
for(mcIdType i=0;i<new2OldSz;i++)
{
- mcIdType oldNb=new2OldPtr[i];
+ mcIdType const oldNb=new2OldPtr[i];
std::copy(ptSrc+oldNb*nbOfComp,ptSrc+(oldNb+1)*nbOfComp,ptToFill+i*nbOfComp);
}
}
MEDCouplingFieldDiscretization::~MEDCouplingFieldDiscretization()
-{
-}
+= default;
TypeOfField MEDCouplingFieldDiscretizationP0::getEnum() const
{
return REPR;
}
-bool MEDCouplingFieldDiscretizationP0::isEqualIfNotWhy(const MEDCouplingFieldDiscretization *other, double eps, std::string& reason) const
+bool MEDCouplingFieldDiscretizationP0::isEqualIfNotWhy(const MEDCouplingFieldDiscretization *other, double /*eps*/, std::string& reason) const
{
if(!other)
{
reason="other spatial discretization is NULL, and this spatial discretization (P0) is defined.";
return false;
}
- const MEDCouplingFieldDiscretizationP0 *otherC=dynamic_cast<const MEDCouplingFieldDiscretizationP0 *>(other);
- bool ret=otherC!=0;
+ const auto *otherC=dynamic_cast<const MEDCouplingFieldDiscretizationP0 *>(other);
+ bool const ret=otherC!=nullptr;
if(!ret)
reason="Spatial discrtization of this is ON_CELLS, which is not the case of other.";
return ret;
{
if(code.size()%3!=0)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationP0::getNumberOfTuplesExpectedRegardingCode : invalid input code !");
- mcIdType nbOfSplit=ToIdType(idsPerType.size());
- mcIdType nbOfTypes=ToIdType(code.size()/3);
+ mcIdType const nbOfSplit=ToIdType(idsPerType.size());
+ mcIdType const nbOfTypes=ToIdType(code.size()/3);
mcIdType ret=0;
for(mcIdType i=0;i<nbOfTypes;i++)
{
- mcIdType nbOfEltInChunk=code[3*i+1];
+ mcIdType const nbOfEltInChunk=code[3*i+1];
if(nbOfEltInChunk<0)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationP0::getNumberOfTuplesExpectedRegardingCode : invalid input code ! presence of negative value in a type !");
- mcIdType pos=code[3*i+2];
+ mcIdType const pos=code[3*i+2];
if(pos!=-1)
{
if(pos<0 || pos>=nbOfSplit)
{
if(!mesh)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationP0::getOffsetArr : NULL input mesh !");
- std::size_t nbOfTuples=mesh->getNumberOfCells();
+ std::size_t const nbOfTuples=mesh->getNumberOfCells();
DataArrayIdType *ret=DataArrayIdType::New();
ret->alloc(nbOfTuples+1,1);
ret->iota(0);
const mcIdType *array=old2NewBg;
if(check)
array=DataArrayIdType::CheckAndPreparePermutation(old2NewBg,old2NewBg+mesh->getNumberOfCells());
- for(std::vector<DataArray *>::const_iterator it=arrays.begin();it!=arrays.end();it++)
+ for(auto it : arrays)
{
- if(*it)
- (*it)->renumberInPlace(array);
+ if(it)
+ it->renumberInPlace(array);
}
if(check)
free(const_cast<mcIdType *>(array));
{
if(!mesh)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationP0::getValueOn : NULL input mesh !");
- mcIdType id=mesh->getCellContainingPoint(loc,_precision);
+ mcIdType const id=mesh->getCellContainingPoint(loc,_precision);
if(id==-1)
throw INTERP_KERNEL::Exception("Specified point is detected outside of mesh : unable to apply P0::getValueOn !");
arr->getTuple(id,res);
void MEDCouplingFieldDiscretizationP0::getValueOnPos(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, mcIdType i, mcIdType j, mcIdType k, double *res) const
{
- const MEDCouplingCMesh *meshC=dynamic_cast<const MEDCouplingCMesh *>(mesh);
+ const auto *meshC=dynamic_cast<const MEDCouplingCMesh *>(mesh);
if(!meshC)
throw INTERP_KERNEL::Exception("P0::getValueOnPos is only accessible for structured meshes !");
- mcIdType id=meshC->getCellIdFromPos(i,j,k);
+ mcIdType const id=meshC->getCellIdFromPos(i,j,k);
arr->getTuple(id,res);
}
MCAuto<DataArrayIdType> eltsArr,eltsIndexArr;
mesh->getCellsContainingPoints(loc,nbOfPoints,_precision,eltsArr,eltsIndexArr);
const mcIdType *elts(eltsArr->begin()),*eltsIndex(eltsIndexArr->begin());
- int spaceDim=mesh->getSpaceDimension();
- std::size_t nbOfComponents=arr->getNumberOfComponents();
+ int const spaceDim=mesh->getSpaceDimension();
+ std::size_t const nbOfComponents=arr->getNumberOfComponents();
MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
ret->alloc(nbOfPoints,nbOfComponents);
double *ptToFill=ret->getPointer();
{
}
-void MEDCouplingFieldDiscretizationP0::renumberValuesOnCells(double epsOnVals, const MEDCouplingMesh *mesh, const mcIdType *old2New, mcIdType newSz, DataArrayDouble *arr) const
+void MEDCouplingFieldDiscretizationP0::renumberValuesOnCells(double epsOnVals, const MEDCouplingMesh * /*mesh*/, const mcIdType *old2New, mcIdType newSz, DataArrayDouble *arr) const
{
RenumberEntitiesFromO2NArr(epsOnVals,old2New,newSz,arr,"Cell");
}
-void MEDCouplingFieldDiscretizationP0::renumberValuesOnCellsR(const MEDCouplingMesh *mesh, const mcIdType *new2old, mcIdType newSz, DataArrayDouble *arr) const
+void MEDCouplingFieldDiscretizationP0::renumberValuesOnCellsR(const MEDCouplingMesh * /*mesh*/, const mcIdType *new2old, mcIdType newSz, DataArrayDouble *arr) const
{
RenumberEntitiesFromN2OArr(new2old,newSz,arr,"Cell");
}
* \return a newly allocated array containing ids to select into the DataArrayDouble of the field.
*
*/
-DataArrayIdType *MEDCouplingFieldDiscretizationP0::computeTupleIdsToSelectFromCellIds(const MEDCouplingMesh *mesh, const mcIdType *startCellIds, const mcIdType *endCellIds) const
+DataArrayIdType *MEDCouplingFieldDiscretizationP0::computeTupleIdsToSelectFromCellIds(const MEDCouplingMesh * /*mesh*/, const mcIdType *startCellIds, const mcIdType *endCellIds) const
{
MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
ret->alloc(std::distance(startCellIds,endCellIds),1);
if(!mesh)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationP0::buildSubMeshDataRange : NULL input mesh !");
MCAuto<MEDCouplingMesh> ret=mesh->buildPartRange(beginCellIds,endCellIds,stepCellIds);
- di=0; beginOut=beginCellIds; endOut=endCellIds; stepOut=stepCellIds;
+ di=nullptr; beginOut=beginCellIds; endOut=endCellIds; stepOut=stepCellIds;
return ret.retn();
}
{
if(code.size()%3!=0)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationOnNodes::getNumberOfTuplesExpectedRegardingCode : invalid input code !");
- mcIdType nbOfSplit=ToIdType(idsPerType.size());
- mcIdType nbOfTypes=ToIdType(code.size()/3);
+ mcIdType const nbOfSplit=ToIdType(idsPerType.size());
+ mcIdType const nbOfTypes=ToIdType(code.size()/3);
mcIdType ret=0;
for(mcIdType i=0;i<nbOfTypes;i++)
{
- mcIdType nbOfEltInChunk=code[3*i+1];
+ mcIdType const nbOfEltInChunk=code[3*i+1];
if(nbOfEltInChunk<0)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationOnNodes::getNumberOfTuplesExpectedRegardingCode : invalid input code ! presence of negative value in a type !");
- mcIdType pos=code[3*i+2];
+ mcIdType const pos=code[3*i+2];
if(pos!=-1)
{
if(pos<0 || pos>=nbOfSplit)
{
if(!mesh)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationNodes::getOffsetArr : NULL input mesh !");
- mcIdType nbOfTuples=mesh->getNumberOfNodes();
+ mcIdType const nbOfTuples=mesh->getNumberOfNodes();
DataArrayIdType *ret=DataArrayIdType::New();
ret->alloc(nbOfTuples+1,1);
ret->iota(0);
if(!mesh)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationOnNodes::computeMeshRestrictionFromTupleIds : NULL input mesh !");
MCAuto<DataArrayIdType> ret1=mesh->getCellIdsFullyIncludedInNodeIds(tupleIdsBg,tupleIdsEnd);
- const MEDCouplingUMesh *meshc=dynamic_cast<const MEDCouplingUMesh *>(mesh);
+ const auto *meshc=dynamic_cast<const MEDCouplingUMesh *>(mesh);
if(!meshc)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationOnNodes::computeMeshRestrictionFromTupleIds : trying to subpart field on nodes by node ids ! Your mesh has to be unstructured !");
MCAuto<MEDCouplingUMesh> meshPart=static_cast<MEDCouplingUMesh *>(meshc->buildPartOfMySelf(ret1->begin(),ret1->end(),true));
{
if(!mesh)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationNodes::buildSubMeshData : NULL input mesh !");
- DataArrayIdType *diTmp=0;
+ DataArrayIdType *diTmp=nullptr;
MCAuto<MEDCouplingMesh> ret=mesh->buildPartAndReduceNodes(start,end,diTmp);
MCAuto<DataArrayIdType> diTmpSafe(diTmp);
MCAuto<DataArrayIdType> di2=diTmpSafe->invertArrayO2N2N2O(ret->getNumberOfNodes());
{
if(!mesh)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationOnNodes::buildSubMeshDataRange : NULL input mesh !");
- DataArrayIdType *diTmp=0;
+ DataArrayIdType *diTmp=nullptr;
MCAuto<MEDCouplingMesh> ret=mesh->buildPartRangeAndReduceNodes(beginCellIds,endCellIds,stepCellIds,beginOut,endOut,stepOut,diTmp);
if(diTmp)
{
void MEDCouplingFieldDiscretizationOnNodes::getValueOnPos(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, mcIdType i, mcIdType j, mcIdType k, double *res) const
{
- const MEDCouplingCMesh *meshC=dynamic_cast<const MEDCouplingCMesh *>(mesh);
+ const auto *meshC=dynamic_cast<const MEDCouplingCMesh *>(mesh);
if(!meshC)
throw INTERP_KERNEL::Exception("OnNodes::getValueOnPos(i,j,k) is only accessible for structured meshes !");
- mcIdType id=meshC->getNodeIdFromPos(i,j,k);
+ mcIdType const id=meshC->getNodeIdFromPos(i,j,k);
arr->getTuple(id,res);
}
return REPR;
}
-bool MEDCouplingFieldDiscretizationP1::isEqualIfNotWhy(const MEDCouplingFieldDiscretization *other, double eps, std::string& reason) const
+bool MEDCouplingFieldDiscretizationP1::isEqualIfNotWhy(const MEDCouplingFieldDiscretization *other, double /*eps*/, std::string& reason) const
{
if(!other)
{
reason="other spatial discretization is NULL, and this spatial discretization (P1) is defined.";
return false;
}
- const MEDCouplingFieldDiscretizationP1 *otherC=dynamic_cast<const MEDCouplingFieldDiscretizationP1 *>(other);
- bool ret=otherC!=0;
+ const auto *otherC=dynamic_cast<const MEDCouplingFieldDiscretizationP1 *>(other);
+ bool const ret=otherC!=nullptr;
if(!ret)
reason="Spatial discrtization of this is ON_NODES, which is not the case of other.";
return ret;
{
if(!mesh)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationP1::getValueOn : NULL input mesh !");
- mcIdType id=mesh->getCellContainingPoint(loc,_precision);
+ mcIdType const id=mesh->getCellContainingPoint(loc,_precision);
if(id==-1)
throw INTERP_KERNEL::Exception("Specified point is detected outside of mesh : unable to apply P1::getValueOn !");
- INTERP_KERNEL::NormalizedCellType type=mesh->getTypeOfCell(id);
+ INTERP_KERNEL::NormalizedCellType const type=mesh->getTypeOfCell(id);
if(type!=INTERP_KERNEL::NORM_SEG2 && type!=INTERP_KERNEL::NORM_TRI3 && type!=INTERP_KERNEL::NORM_TETRA4)
throw INTERP_KERNEL::Exception("P1 getValueOn is not specified for not simplex cells !");
getValueInCell(mesh,id,arr,loc,res);
std::vector<mcIdType> conn;
std::vector<double> coo;
mesh->getNodeIdsOfCell(cellId,conn);
- for(std::vector<mcIdType>::const_iterator iter=conn.begin();iter!=conn.end();iter++)
- mesh->getCoordinatesOfNode(*iter,coo);
- int spaceDim=mesh->getSpaceDimension();
- std::size_t nbOfNodes=conn.size();
+ for(long const iter : conn)
+ mesh->getCoordinatesOfNode(iter,coo);
+ int const spaceDim=mesh->getSpaceDimension();
+ std::size_t const nbOfNodes=conn.size();
std::vector<const double *> vec(nbOfNodes);
for(std::size_t i=0;i<nbOfNodes;i++)
vec[i]=&coo[i*spaceDim];
INTERP_KERNEL::AutoPtr<double> tmp=new double[nbOfNodes];
- INTERP_KERNEL::NormalizedCellType ct(mesh->getTypeOfCell(cellId));
+ INTERP_KERNEL::NormalizedCellType const ct(mesh->getTypeOfCell(cellId));
INTERP_KERNEL::barycentric_coords(ct,vec,loc,tmp);
- std::size_t sz=arr->getNumberOfComponents();
+ std::size_t const sz=arr->getNumberOfComponents();
INTERP_KERNEL::AutoPtr<double> tmp2=new double[sz];
std::fill(res,res+sz,0.);
for(std::size_t i=0;i<nbOfNodes;i++)
MCAuto<DataArrayIdType> eltsArr,eltsIndexArr;
mesh->getCellsContainingPoints(loc,nbOfPoints,_precision,eltsArr,eltsIndexArr);
const mcIdType *elts(eltsArr->begin()),*eltsIndex(eltsIndexArr->begin());
- int spaceDim=mesh->getSpaceDimension();
- std::size_t nbOfComponents=arr->getNumberOfComponents();
+ int const spaceDim=mesh->getSpaceDimension();
+ std::size_t const nbOfComponents=arr->getNumberOfComponents();
MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
ret->alloc(nbOfPoints,nbOfComponents);
double *ptToFill=ret->getPointer();
return EasyAggregate<MEDCouplingFieldDiscretizationP1>(fds);
}
-MEDCouplingFieldDiscretizationPerCell::MEDCouplingFieldDiscretizationPerCell():_discr_per_cell(0)
+MEDCouplingFieldDiscretizationPerCell::MEDCouplingFieldDiscretizationPerCell():_discr_per_cell(nullptr)
{
}
/*!
* This constructor deep copies MEDCoupling::DataArrayIdType instance from other (if any).
*/
-MEDCouplingFieldDiscretizationPerCell::MEDCouplingFieldDiscretizationPerCell(const MEDCouplingFieldDiscretizationPerCell& other, const mcIdType *startCellIds, const mcIdType *endCellIds):_discr_per_cell(0)
+MEDCouplingFieldDiscretizationPerCell::MEDCouplingFieldDiscretizationPerCell(const MEDCouplingFieldDiscretizationPerCell& other, const mcIdType *startCellIds, const mcIdType *endCellIds):_discr_per_cell(nullptr)
{
DataArrayIdType *arr=other._discr_per_cell;
if(arr)
{
- if(startCellIds==0 && endCellIds==0)
+ if(startCellIds==nullptr && endCellIds==nullptr)
_discr_per_cell=arr->deepCopy();
else
_discr_per_cell=arr->selectByTupleIdSafe(startCellIds,endCellIds);
}
}
-MEDCouplingFieldDiscretizationPerCell::MEDCouplingFieldDiscretizationPerCell(const MEDCouplingFieldDiscretizationPerCell& other, mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds):_discr_per_cell(0)
+MEDCouplingFieldDiscretizationPerCell::MEDCouplingFieldDiscretizationPerCell(const MEDCouplingFieldDiscretizationPerCell& other, mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds):_discr_per_cell(nullptr)
{
DataArrayIdType *arr=other._discr_per_cell;
if(arr)
std::size_t MEDCouplingFieldDiscretizationPerCell::getHeapMemorySizeWithoutChildren() const
{
- std::size_t ret(MEDCouplingFieldDiscretization::getHeapMemorySizeWithoutChildren());
+ std::size_t const ret(MEDCouplingFieldDiscretization::getHeapMemorySizeWithoutChildren());
return ret;
}
return ret;
}
-void MEDCouplingFieldDiscretizationPerCell::checkCoherencyBetween(const MEDCouplingMesh *mesh, const DataArray *da) const
+void MEDCouplingFieldDiscretizationPerCell::checkCoherencyBetween(const MEDCouplingMesh *mesh, const DataArray * /*da*/) const
{
if(!_discr_per_cell)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationPerCell has no discretization per cell !");
if(!mesh)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationPerCell::checkCoherencyBetween : NULL input mesh or DataArray !");
- mcIdType nbOfTuples(_discr_per_cell->getNumberOfTuples());
+ mcIdType const nbOfTuples(_discr_per_cell->getNumberOfTuples());
if(nbOfTuples!=mesh->getNumberOfCells())
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationPerCell has a discretization per cell but it's not matching the underlying mesh !");
}
-bool MEDCouplingFieldDiscretizationPerCell::isEqualIfNotWhy(const MEDCouplingFieldDiscretization *other, double eps, std::string& reason) const
+bool MEDCouplingFieldDiscretizationPerCell::isEqualIfNotWhy(const MEDCouplingFieldDiscretization *other, double /*eps*/, std::string& reason) const
{
if(!other)
{
reason="other spatial discretization is NULL, and this spatial discretization (PerCell) is defined.";
return false;
}
- const MEDCouplingFieldDiscretizationPerCell *otherC=dynamic_cast<const MEDCouplingFieldDiscretizationPerCell *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingFieldDiscretizationPerCell *>(other);
if(!otherC)
{
reason="Spatial discretization of this is ON_GAUSS, which is not the case of other.";
return false;
}
- if(_discr_per_cell==0)
- return otherC->_discr_per_cell==0;
- if(otherC->_discr_per_cell==0)
+ if(_discr_per_cell==nullptr)
+ return otherC->_discr_per_cell==nullptr;
+ if(otherC->_discr_per_cell==nullptr)
return false;
- bool ret=_discr_per_cell->isEqualIfNotWhy(*otherC->_discr_per_cell,reason);
+ bool const ret=_discr_per_cell->isEqualIfNotWhy(*otherC->_discr_per_cell,reason);
if(!ret)
reason.insert(0,"Field discretization per cell DataArrayIdType given the discid per cell :");
return ret;
}
-bool MEDCouplingFieldDiscretizationPerCell::isEqualWithoutConsideringStr(const MEDCouplingFieldDiscretization *other, double eps) const
+bool MEDCouplingFieldDiscretizationPerCell::isEqualWithoutConsideringStr(const MEDCouplingFieldDiscretization *other, double /*eps*/) const
{
- const MEDCouplingFieldDiscretizationPerCell *otherC=dynamic_cast<const MEDCouplingFieldDiscretizationPerCell *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingFieldDiscretizationPerCell *>(other);
if(!otherC)
return false;
- if(_discr_per_cell==0)
- return otherC->_discr_per_cell==0;
- if(otherC->_discr_per_cell==0)
+ if(_discr_per_cell==nullptr)
+ return otherC->_discr_per_cell==nullptr;
+ if(otherC->_discr_per_cell==nullptr)
return false;
return _discr_per_cell->isEqualWithoutConsideringStr(*otherC->_discr_per_cell);
}
*/
void MEDCouplingFieldDiscretizationPerCell::renumberCells(const mcIdType *old2NewBg, bool check)
{
- mcIdType nbCells=_discr_per_cell->getNumberOfTuples();
+ mcIdType const nbCells=_discr_per_cell->getNumberOfTuples();
const mcIdType *array=old2NewBg;
if(check)
array=DataArrayIdType::CheckAndPreparePermutation(old2NewBg,old2NewBg+nbCells);
if(!_discr_per_cell)
{
_discr_per_cell=DataArrayIdType::New();
- mcIdType nbTuples=mesh->getNumberOfCells();
+ mcIdType const nbTuples=mesh->getNumberOfCells();
_discr_per_cell->alloc(nbTuples,1);
mcIdType *ptr=_discr_per_cell->getPointer();
std::fill(ptr,ptr+nbTuples,DFT_INVALID_LOCID_VALUE);
}
MEDCouplingFieldDiscretizationGauss::MEDCouplingFieldDiscretizationGauss()
-{
-}
+= default;
MEDCouplingFieldDiscretizationGauss::MEDCouplingFieldDiscretizationGauss(const MEDCouplingFieldDiscretizationGauss& other, const mcIdType *startCellIds, const mcIdType *endCellIds):MEDCouplingFieldDiscretizationPerCell(other,startCellIds,endCellIds),_loc(other._loc)
{
reason="other spatial discretization is NULL, and this spatial discretization (Gauss) is defined.";
return false;
}
- const MEDCouplingFieldDiscretizationGauss *otherC=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(other);
if(!otherC)
{
reason="Spatial discrtization of this is ON_GAUSS, which is not the case of other.";
reason="Gauss spatial discretization : localization sizes differ";
return false;
}
- std::size_t sz=_loc.size();
+ std::size_t const sz=_loc.size();
for(std::size_t i=0;i<sz;i++)
if(!_loc[i].isEqual(otherC->_loc[i],eps))
{
bool MEDCouplingFieldDiscretizationGauss::isEqualWithoutConsideringStr(const MEDCouplingFieldDiscretization *other, double eps) const
{
- const MEDCouplingFieldDiscretizationGauss *otherC=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(other);
if(!otherC)
return false;
if(!MEDCouplingFieldDiscretizationPerCell::isEqualWithoutConsideringStr(other,eps))
return false;
if(_loc.size()!=otherC->_loc.size())
return false;
- std::size_t sz=_loc.size();
+ std::size_t const sz=_loc.size();
for(std::size_t i=0;i<sz;i++)
if(!_loc[i].isEqual(otherC->_loc[i],eps))
return false;
}
oss << "Presence of " << _loc.size() << " localizations." << std::endl;
int i=0;
- for(std::vector<MEDCouplingGaussLocalization>::const_iterator it=_loc.begin();it!=_loc.end();it++,i++)
+ for(auto it=_loc.begin();it!=_loc.end();it++,i++)
{
oss << "+++++ Localization #" << i << " +++++" << std::endl;
oss << (*it).getStringRepr();
{
std::size_t ret(MEDCouplingFieldDiscretizationPerCell::getHeapMemorySizeWithoutChildren());
ret+=_loc.capacity()*sizeof(MEDCouplingGaussLocalization);
- for(std::vector<MEDCouplingGaussLocalization>::const_iterator it=_loc.begin();it!=_loc.end();it++)
- ret+=(*it).getMemorySize();
+ for(const auto & it : _loc)
+ ret+=it.getMemorySize();
return ret;
}
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationGauss::getNumberOfTuplesExpectedRegardingCode");
if(code.size()%3!=0)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationGauss::getNumberOfTuplesExpectedRegardingCode : invalid input code !");
- mcIdType nbOfSplit=ToIdType(idsPerType.size());
- mcIdType nbOfTypes=ToIdType(code.size()/3);
+ mcIdType const nbOfSplit=ToIdType(idsPerType.size());
+ mcIdType const nbOfTypes=ToIdType(code.size()/3);
mcIdType ret(0);
for(mcIdType i=0;i<nbOfTypes;i++)
{
- mcIdType nbOfEltInChunk=code[3*i+1];
+ mcIdType const nbOfEltInChunk=code[3*i+1];
if(nbOfEltInChunk<0)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationGauss::getNumberOfTuplesExpectedRegardingCode : invalid input code ! presence of negative value in a type !");
- mcIdType pos=code[3*i+2];
+ mcIdType const pos=code[3*i+2];
if(pos!=-1)
{
if(pos<0 || pos>=nbOfSplit)
std::ostringstream oss; oss << "MEDCouplingFieldDiscretizationGauss::getNumberOfTuplesExpectedRegardingCode : input code points to " << ret << " cells whereas discretization percell array lgth is " << _discr_per_cell->getNumberOfTuples() << " !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- return getNumberOfTuples(0);//0 is not an error ! It is to be sure that input mesh is not used
+ return getNumberOfTuples(nullptr);//0 is not an error ! It is to be sure that input mesh is not used
}
mcIdType MEDCouplingFieldDiscretizationGauss::getNumberOfTuples(const MEDCouplingMesh *) const
{
mcIdType ret=0;
- if (_discr_per_cell == 0)
+ if (_discr_per_cell == nullptr)
throw INTERP_KERNEL::Exception("Discretization is not initialized!");
const mcIdType *dcPtr=_discr_per_cell->getConstPointer();
- mcIdType nbOfTuples=_discr_per_cell->getNumberOfTuples();
- mcIdType maxSz=ToIdType(_loc.size());
+ mcIdType const nbOfTuples=_discr_per_cell->getNumberOfTuples();
+ mcIdType const maxSz=ToIdType(_loc.size());
for(const mcIdType *w=dcPtr;w!=dcPtr+nbOfTuples;w++)
{
if(*w>=0 && *w<maxSz)
{
if(!mesh)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationGauss::getOffsetArr : NULL input mesh !");
- mcIdType nbOfTuples=mesh->getNumberOfCells();
+ mcIdType const nbOfTuples=mesh->getNumberOfCells();
MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
ret->alloc(nbOfTuples+1,1);
mcIdType *retPtr(ret->getPointer());
const mcIdType *start(_discr_per_cell->begin());
if(_discr_per_cell->getNumberOfTuples()!=nbOfTuples)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationGauss::getOffsetArr : mismatch between the mesh and the discretization ids array length !");
- mcIdType maxPossible=ToIdType(_loc.size());
+ mcIdType const maxPossible=ToIdType(_loc.size());
retPtr[0]=0;
for(mcIdType i=0;i<nbOfTuples;i++,start++)
{
const mcIdType *array=old2NewBg;
if(check)
array=DataArrayIdType::CheckAndPreparePermutation(old2NewBg,old2NewBg+mesh->getNumberOfCells());
- mcIdType nbOfCells=_discr_per_cell->getNumberOfTuples();
- mcIdType nbOfTuples=getNumberOfTuples(0);
+ mcIdType const nbOfCells=_discr_per_cell->getNumberOfTuples();
+ mcIdType const nbOfTuples=getNumberOfTuples(nullptr);
const mcIdType *dcPtr=_discr_per_cell->getConstPointer();
- mcIdType *array2=new mcIdType[nbOfTuples];//stores the final conversion array old2New to give to arrays in renumberInPlace.
- mcIdType *array3=new mcIdType[nbOfCells];//store for each cell in present dcp array (already renumbered) the offset needed by each cell in new numbering.
+ auto *array2=new mcIdType[nbOfTuples];//stores the final conversion array old2New to give to arrays in renumberInPlace.
+ auto *array3=new mcIdType[nbOfCells];//store for each cell in present dcp array (already renumbered) the offset needed by each cell in new numbering.
array3[0]=0;
for(mcIdType i=1;i<nbOfCells;i++)
array3[i]=array3[i-1]+_loc[dcPtr[i-1]].getNumberOfGaussPt();
mcIdType j=0;
for(mcIdType i=0;i<nbOfCells;i++)
{
- mcIdType nbOfGaussPt=_loc[dcPtr[array[i]]].getNumberOfGaussPt();
+ mcIdType const nbOfGaussPt=_loc[dcPtr[array[i]]].getNumberOfGaussPt();
for(mcIdType k=0;k<nbOfGaussPt;k++,j++)
array2[j]=array3[array[i]]+k;
}
delete [] array3;
- for(std::vector<DataArray *>::const_iterator it=arrays.begin();it!=arrays.end();it++)
- if(*it)
- (*it)->renumberInPlace(array2);
+ for(auto array : arrays)
+ if(array)
+ array->renumberInPlace(array2);
delete [] array2;
if(check)
free(const_cast<mcIdType*>(array));
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationGauss::getLocalizationOfDiscValues : NULL input mesh !");
checkNoOrphanCells();
MCAuto<MEDCouplingUMesh> umesh=mesh->buildUnstructured();//in general do nothing
- mcIdType nbOfTuples=getNumberOfTuples(mesh);
+ mcIdType const nbOfTuples=getNumberOfTuples(mesh);
MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- int spaceDim=mesh->getSpaceDimension();
+ int const spaceDim=mesh->getSpaceDimension();
ret->alloc(nbOfTuples,spaceDim);
std::vector< mcIdType > locIds;
std::vector<DataArrayIdType *> parts=splitIntoSingleGaussDicrPerCellType(locIds);
INTERP_KERNEL::GaussCoords calculator;
//
const MEDCouplingGaussLocalization& cli(_loc[locIds[i]]);//curLocInfo
- INTERP_KERNEL::NormalizedCellType typ(cli.getType());
+ INTERP_KERNEL::NormalizedCellType const typ(cli.getType());
const std::vector<double>& wg(cli.getWeights());
calculator.addGaussInfo(typ,INTERP_KERNEL::CellModel::GetCellModel(typ).getDimension(),
&cli.getGaussCoords()[0],ToIdType(wg.size()),&cli.getRefCoords()[0],
INTERP_KERNEL::CellModel::GetCellModel(typ).getNumberOfNodes());
//
- for(const mcIdType *w=parts2[i]->begin();w!=parts2[i]->end();w++)
- calculator.calculateCoords(cli.getType(),coords,spaceDim,conn+connI[*w]+1,valsToFill+spaceDim*(ptrOffsets[*w]));
+ for(long const w : *parts2[i])
+ calculator.calculateCoords(cli.getType(),coords,spaceDim,conn+connI[w]+1,valsToFill+spaceDim*(ptrOffsets[w]));
}
ret->copyStringInfoFrom(*umesh->getCoords());
return ret.retn();
tinyInfo.push_back(-1);
else
tinyInfo.push_back(_loc[0].getDimension());
- for(std::vector<MEDCouplingGaussLocalization>::const_iterator iter=_loc.begin();iter!=_loc.end();iter++)
- (*iter).pushTinySerializationIntInfo(tinyInfo);
+ for(const auto & iter : _loc)
+ iter.pushTinySerializationIntInfo(tinyInfo);
}
void MEDCouplingFieldDiscretizationGauss::getTinySerializationDbleInformation(std::vector<double>& tinyInfo) const
{
- for(std::vector<MEDCouplingGaussLocalization>::const_iterator iter=_loc.begin();iter!=_loc.end();iter++)
- (*iter).pushTinySerializationDblInfo(tinyInfo);
+ for(const auto & iter : _loc)
+ iter.pushTinySerializationDblInfo(tinyInfo);
}
void MEDCouplingFieldDiscretizationGauss::getSerializationIntArray(DataArrayIdType *& arr) const
{
- arr=0;
+ arr=nullptr;
if(_discr_per_cell)
arr=_discr_per_cell;
}
void MEDCouplingFieldDiscretizationGauss::resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *& arr)
{
- mcIdType val=tinyInfo[0];
+ mcIdType const val=tinyInfo[0];
if(val>=0)
{
_discr_per_cell=DataArrayIdType::New();
_discr_per_cell->alloc(val,1);
}
else
- _discr_per_cell=0;
+ _discr_per_cell=nullptr;
arr=_discr_per_cell;
commonUnserialization(tinyInfo);
}
void MEDCouplingFieldDiscretizationGauss::checkForUnserialization(const std::vector<mcIdType>& tinyInfo, const DataArrayIdType *arr)
{
static const char MSG[]="MEDCouplingFieldDiscretizationGauss::checkForUnserialization : expect to have one not null DataArrayIdType !";
- mcIdType val=tinyInfo[0];
+ mcIdType const val=tinyInfo[0];
if(val>=0)
{
if(!arr)
_discr_per_cell->incrRef();
}
else
- _discr_per_cell=0;
+ _discr_per_cell=nullptr;
commonUnserialization(tinyInfo);
}
void MEDCouplingFieldDiscretizationGauss::finishUnserialization(const std::vector<double>& tinyInfo)
{
- double *tmp=new double[tinyInfo.size()];
+ auto *tmp=new double[tinyInfo.size()];
std::copy(tinyInfo.begin(),tinyInfo.end(),tmp);
const double *work=tmp;
- for(std::vector<MEDCouplingGaussLocalization>::iterator iter=_loc.begin();iter!=_loc.end();iter++)
- work=(*iter).fillWithValues(work);
+ for(auto & iter : _loc)
+ work=iter.fillWithValues(work);
delete [] tmp;
}
-double MEDCouplingFieldDiscretizationGauss::getIJK(const MEDCouplingMesh *mesh, const DataArrayDouble *da, mcIdType cellId, mcIdType nodeIdInCell, int compoId) const
+double MEDCouplingFieldDiscretizationGauss::getIJK(const MEDCouplingMesh * /*mesh*/, const DataArrayDouble *da, mcIdType cellId, mcIdType nodeIdInCell, int compoId) const
{
- mcIdType offset=getOffsetOfCell(cellId);
+ mcIdType const offset=getOffsetOfCell(cellId);
return da->getIJ(offset+nodeIdInCell,compoId);
}
if(!mesh || !da)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationGauss::checkCoherencyBetween : NULL input mesh or DataArray !");
MEDCouplingFieldDiscretizationPerCell::checkCoherencyBetween(mesh,da);
- for(std::vector<MEDCouplingGaussLocalization>::const_iterator iter=_loc.begin();iter!=_loc.end();iter++)
- (*iter).checkConsistencyLight();
- mcIdType nbOfDesc=ToIdType(_loc.size());
- mcIdType nbOfCells=mesh->getNumberOfCells();
+ for(const auto & iter : _loc)
+ iter.checkConsistencyLight();
+ mcIdType const nbOfDesc=ToIdType(_loc.size());
+ mcIdType const nbOfCells=mesh->getNumberOfCells();
const mcIdType *dc=_discr_per_cell->getConstPointer();
for(mcIdType i=0;i<nbOfCells;i++)
{
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
}
- mcIdType nbOfTuples(getNumberOfTuples(mesh));
+ mcIdType const nbOfTuples(getNumberOfTuples(mesh));
if(nbOfTuples!=da->getNumberOfTuples())
{
std::ostringstream oss; oss << "Invalid number of tuples in the array : expecting " << nbOfTuples << " having " << da->getNumberOfTuples() << " !";
}
}
-MEDCouplingFieldDouble *MEDCouplingFieldDiscretizationGauss::getMeasureField(const MEDCouplingMesh *mesh, bool isAbs) const
+MEDCouplingFieldDouble *MEDCouplingFieldDiscretizationGauss::getMeasureField(const MEDCouplingMesh *mesh, bool /*isAbs*/) const
{
if(!mesh)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationGauss::getMeasureField : mesh instance specified is NULL !");
ret->setArray(arr);
double *arrPtr=arr->getPointer();
const mcIdType *offsetPtr=offset->getConstPointer();
- mcIdType maxGaussLoc=ToIdType(_loc.size());
+ mcIdType const maxGaussLoc=ToIdType(_loc.size());
std::vector<mcIdType> locIds;
std::vector<DataArrayIdType *> ids=splitIntoSingleGaussDicrPerCellType(locIds);
std::vector< MCAuto<DataArrayIdType> > ids2(ids.size()); std::copy(ids.begin(),ids.end(),ids2.begin());
for(std::size_t i=0;i<locIds.size();i++)
{
const DataArrayIdType *curIds=ids[i];
- mcIdType locId=locIds[i];
+ mcIdType const locId=locIds[i];
if(locId>=0 && locId<maxGaussLoc)
{
const MEDCouplingGaussLocalization& loc=_loc[locId];
- mcIdType nbOfGaussPt=loc.getNumberOfGaussPt();
- INTERP_KERNEL::AutoPtr<double> weights=new double[nbOfGaussPt];
- for(const mcIdType *cellId=curIds->begin();cellId!=curIds->end();cellId++)
+ mcIdType const nbOfGaussPt=loc.getNumberOfGaussPt();
+ INTERP_KERNEL::AutoPtr<double> const weights=new double[nbOfGaussPt];
+ for(long const curId : *curIds)
{
std::vector<mcIdType> conn;
- umesh->getNodeIdsOfCell(*cellId,conn);
+ umesh->getNodeIdsOfCell(curId,conn);
std::vector<double> ptsInCell; ptsInCell.reserve(conn.size()*loc.getDimension());
std::for_each( conn.cbegin(), conn.cend(), [spaceDim,coordsOfMesh,&ptsInCell](mcIdType c) { ptsInCell.insert(ptsInCell.end(),coordsOfMesh+c*spaceDim,coordsOfMesh+(c+1)*spaceDim); } );
- std::size_t nbPtsInCell(ptsInCell.size()/spaceDim);
+ std::size_t const nbPtsInCell(ptsInCell.size()/spaceDim);
INTERP_KERNEL::DenseMatrix jacobian(spaceDim,meshDim);
MCAuto<DataArrayDouble> shapeFunc = loc.getDerivativeOfShapeFunctionValues();
for(mcIdType iGPt = 0 ; iGPt < nbOfGaussPt ; ++iGPt)
res += ptsInCell[spaceDim*k+i] * shapeFunc->getIJ(iGPt,meshDim*k+j);
jacobian[ i ][ j ] = res;
}
- arrPtr[offsetPtr[*cellId]+iGPt]=std::abs( jacobian.toJacobian() )*loc.getWeight(FromIdType<int>(iGPt));
+ arrPtr[offsetPtr[curId]+iGPt]=std::abs( jacobian.toJacobian() )*loc.getWeight(FromIdType<int>(iGPt));
}
}
}
return ret.retn();
}
-void MEDCouplingFieldDiscretizationGauss::getValueOn(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, const double *loc, double *res) const
+void MEDCouplingFieldDiscretizationGauss::getValueOn(const DataArrayDouble * /*arr*/, const MEDCouplingMesh * /*mesh*/, const double * /*loc*/, double * /*res*/) const
{
throw INTERP_KERNEL::Exception("Not implemented yet !");
}
-void MEDCouplingFieldDiscretizationGauss::getValueOnPos(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, mcIdType i, mcIdType j, mcIdType k, double *res) const
+void MEDCouplingFieldDiscretizationGauss::getValueOnPos(const DataArrayDouble * /*arr*/, const MEDCouplingMesh * /*mesh*/, mcIdType /*i*/, mcIdType /*j*/, mcIdType /*k*/, double * /*res*/) const
{
throw INTERP_KERNEL::Exception("getValueOnPos(i,j,k) : Not applicable for Gauss points !");
}
-DataArrayDouble *MEDCouplingFieldDiscretizationGauss::getValueOnMulti(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, const double *loc, mcIdType nbOfPoints) const
+DataArrayDouble *MEDCouplingFieldDiscretizationGauss::getValueOnMulti(const DataArrayDouble * /*arr*/, const MEDCouplingMesh * /*mesh*/, const double * /*loc*/, mcIdType /*nbOfPoints*/) const
{
throw INTERP_KERNEL::Exception("getValueOnMulti : Not implemented yet for gauss points !");
}
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationGauss::buildSubMeshDataRange : NULL input mesh !");
if(!_discr_per_cell)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationGauss::buildSubMeshDataRange : no discretization array set !");
- di=0; beginOut=0; endOut=0; stepOut=stepCellIds;
+ di=nullptr; beginOut=0; endOut=0; stepOut=stepCellIds;
const char msg[]="MEDCouplingFieldDiscretizationGauss::buildSubMeshDataRange : cell #";
- mcIdType nbOfTuples=_discr_per_cell->getNumberOfTuples();
+ mcIdType const nbOfTuples=_discr_per_cell->getNumberOfTuples();
const mcIdType *w=_discr_per_cell->begin();
- mcIdType nbMaxOfLocId=ToIdType(_loc.size());
+ mcIdType const nbMaxOfLocId=ToIdType(_loc.size());
for(mcIdType i=0;i<nbOfTuples;i++,w++)
{
if(*w!=DFT_INVALID_LOCID_VALUE)
{
if(*w>=0 && *w<nbMaxOfLocId)
{
- mcIdType delta=_loc[*w].getNumberOfGaussPt();
+ mcIdType const delta=_loc[*w].getNumberOfGaussPt();
if(i<beginCellIds)
beginOut+=delta;
endOut+=delta;
if(!mesh)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationGauss::computeTupleIdsToSelectFromCellIds : null mesh !");
MCAuto<DataArrayIdType> nbOfNodesPerCell=buildNbOfGaussPointPerCellField();//check of _discr_per_cell not NULL pointer
- mcIdType nbOfCells(mesh->getNumberOfCells());
+ mcIdType const nbOfCells(mesh->getNumberOfCells());
if(_discr_per_cell->getNumberOfTuples()!=nbOfCells)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationGauss::computeTupleIdsToSelectFromCellIds : mismatch of nb of tuples of cell ids array and number of cells !");
nbOfNodesPerCell->computeOffsetsFull();
{
}
-void MEDCouplingFieldDiscretizationGauss::renumberValuesOnCells(double epsOnVals, const MEDCouplingMesh *mesh, const mcIdType *old2New, mcIdType newSz, DataArrayDouble *arr) const
+void MEDCouplingFieldDiscretizationGauss::renumberValuesOnCells(double /*epsOnVals*/, const MEDCouplingMesh * /*mesh*/, const mcIdType * /*old2New*/, mcIdType /*newSz*/, DataArrayDouble * /*arr*/) const
{
throw INTERP_KERNEL::Exception("Not implemented yet !");
}
-void MEDCouplingFieldDiscretizationGauss::renumberValuesOnCellsR(const MEDCouplingMesh *mesh, const mcIdType *new2old, mcIdType newSz, DataArrayDouble *arr) const
+void MEDCouplingFieldDiscretizationGauss::renumberValuesOnCellsR(const MEDCouplingMesh * /*mesh*/, const mcIdType * /*new2old*/, mcIdType /*newSz*/, DataArrayDouble * /*arr*/) const
{
throw INTERP_KERNEL::Exception("Number of cells has changed and becomes higher with some cells that have been split ! Unable to conserve the Gauss field !");
}
std::size_t i(0);
for(auto it=fds.begin();it!=fds.end();++it,++i)
{
- const MEDCouplingFieldDiscretizationGauss *itc(dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(*it));
+ const auto *itc(dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(*it));
if(!itc)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationGauss::aggregate : same field discretization expected for all input discretizations !");
//
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
buildDiscrPerCellIfNecessary(mesh);
- mcIdType id=ToIdType(_loc.size());
- MEDCouplingGaussLocalization elt(type,refCoo,gsCoo,wg);
+ mcIdType const id=ToIdType(_loc.size());
+ MEDCouplingGaussLocalization const elt(type,refCoo,gsCoo,wg);
_loc.push_back(elt);
mcIdType *ptr=_discr_per_cell->getPointer();
- mcIdType nbCells=mesh->getNumberOfCells();
+ mcIdType const nbCells=mesh->getNumberOfCells();
for(mcIdType i=0;i<nbCells;i++)
if(mesh->getTypeOfCell(i)==type)
ptr[i]=id;
buildDiscrPerCellIfNecessary(mesh);
if(std::distance(begin,end)<1)
throw INTERP_KERNEL::Exception("Size of [begin,end) must be equal or greater than 1 !");
- INTERP_KERNEL::NormalizedCellType type=mesh->getTypeOfCell(*begin);
- MEDCouplingGaussLocalization elt(type,refCoo,gsCoo,wg);
- mcIdType id=ToIdType(_loc.size());
+ INTERP_KERNEL::NormalizedCellType const type=mesh->getTypeOfCell(*begin);
+ MEDCouplingGaussLocalization const elt(type,refCoo,gsCoo,wg);
+ mcIdType const id=ToIdType(_loc.size());
mcIdType *ptr=_discr_per_cell->getPointer();
for(const mcIdType *w=begin+1;w!=end;w++)
{
if(_discr_per_cell)
{
_discr_per_cell->decrRef();
- _discr_per_cell=0;
+ _discr_per_cell=nullptr;
}
_loc.clear();
}
{
if(locId<0)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationGauss::setGaussLocalization : localization id has to be >=0 !");
- mcIdType sz=ToIdType(_loc.size());
- MEDCouplingGaussLocalization gLoc(INTERP_KERNEL::NORM_ERROR);
+ mcIdType const sz=ToIdType(_loc.size());
+ MEDCouplingGaussLocalization const gLoc(INTERP_KERNEL::NORM_ERROR);
if(locId>=sz)
_loc.resize(locId+1,gLoc);
_loc[locId]=loc;
{
if(newSz<0)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationGauss::resizeLocalizationVector : new size has to be >=0 !");
- MEDCouplingGaussLocalization gLoc(INTERP_KERNEL::NORM_ERROR);
+ MEDCouplingGaussLocalization const gLoc(INTERP_KERNEL::NORM_ERROR);
_loc.resize(newSz,gLoc);
}
{
if(!_discr_per_cell)
throw INTERP_KERNEL::Exception("No Gauss localization still set !");
- mcIdType locId=_discr_per_cell->begin()[cellId];
+ mcIdType const locId=_discr_per_cell->begin()[cellId];
if(locId<0)
throw INTERP_KERNEL::Exception("No Gauss localization set for the specified cell !");
return locId;
mcIdType MEDCouplingFieldDiscretizationGauss::getGaussLocalizationIdOfOneType(INTERP_KERNEL::NormalizedCellType type) const
{
- std::set<mcIdType> ret=getGaussLocalizationIdsOfOneType(type);
+ std::set<mcIdType> const ret=getGaussLocalizationIdsOfOneType(type);
if(ret.empty())
throw INTERP_KERNEL::Exception("No gauss discretization found for the specified type !");
if(ret.size()>1)
throw INTERP_KERNEL::Exception("No Gauss localization still set !");
std::set<mcIdType> ret;
mcIdType id=0;
- for(std::vector<MEDCouplingGaussLocalization>::const_iterator iter=_loc.begin();iter!=_loc.end();iter++,id++)
+ for(auto iter=_loc.begin();iter!=_loc.end();iter++,id++)
if((*iter).getType()==type)
ret.insert(id);
return ret;
{
if(locId<0 || locId>=ToIdType(_loc.size()))
throw INTERP_KERNEL::Exception("Invalid locId given : must be in range [0:getNbOfGaussLocalization()) !");
- mcIdType nbOfTuples=_discr_per_cell->getNumberOfTuples();
+ mcIdType const nbOfTuples=_discr_per_cell->getNumberOfTuples();
const mcIdType *ptr=_discr_per_cell->getConstPointer();
for(mcIdType i=0;i<nbOfTuples;i++)
if(ptr[i]==locId)
{
if(!_discr_per_cell)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationGauss::buildNbOfGaussPointPerCellField : no discretization array set !");
- mcIdType nbOfTuples=_discr_per_cell->getNumberOfTuples();
+ mcIdType const nbOfTuples=_discr_per_cell->getNumberOfTuples();
MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
const mcIdType *w=_discr_per_cell->begin();
ret->alloc(nbOfTuples,1);
mcIdType *valsToFill=ret->getPointer();
- mcIdType nbMaxOfLocId=ToIdType(_loc.size());
+ mcIdType const nbMaxOfLocId=ToIdType(_loc.size());
for(mcIdType i=0;i<nbOfTuples;i++,w++)
if(*w!=DFT_INVALID_LOCID_VALUE)
{
void MEDCouplingFieldDiscretizationGauss::zipGaussLocalizations()
{
const mcIdType *start=_discr_per_cell->begin();
- mcIdType nbOfTuples=_discr_per_cell->getNumberOfTuples();
+ mcIdType const nbOfTuples=_discr_per_cell->getNumberOfTuples();
INTERP_KERNEL::AutoPtr<mcIdType> tmp=new mcIdType[_loc.size()];
std::fill((mcIdType *)tmp,(mcIdType *)tmp+_loc.size(),-2);
for(const mcIdType *w=start;w!=start+nbOfTuples;w++)
void MEDCouplingFieldDiscretizationGauss::commonUnserialization(const std::vector<mcIdType>& tinyInfo)
{
- mcIdType nbOfLoc=tinyInfo[1];
+ mcIdType const nbOfLoc=tinyInfo[1];
_loc.clear();
- mcIdType dim=tinyInfo[2];
+ mcIdType const dim=tinyInfo[2];
mcIdType delta=-1;
if(nbOfLoc>0)
delta=(ToIdType(tinyInfo.size())-3)/nbOfLoc;
for(mcIdType i=0;i<nbOfLoc;i++)
{
- std::vector<mcIdType> tmp(tinyInfo.begin()+3+i*delta,tinyInfo.begin()+3+(i+1)*delta);
- MEDCouplingGaussLocalization elt=MEDCouplingGaussLocalization::BuildNewInstanceFromTinyInfo(dim,tmp);
+ std::vector<mcIdType> const tmp(tinyInfo.begin()+3+i*delta,tinyInfo.begin()+3+(i+1)*delta);
+ MEDCouplingGaussLocalization const elt=MEDCouplingGaussLocalization::BuildNewInstanceFromTinyInfo(dim,tmp);
_loc.push_back(elt);
}
}
MEDCouplingFieldDiscretizationGaussNE::MEDCouplingFieldDiscretizationGaussNE()
-{
-}
+= default;
TypeOfField MEDCouplingFieldDiscretizationGaussNE::getEnum() const
{
return REPR;
}
-bool MEDCouplingFieldDiscretizationGaussNE::isEqualIfNotWhy(const MEDCouplingFieldDiscretization *other, double eps, std::string& reason) const
+bool MEDCouplingFieldDiscretizationGaussNE::isEqualIfNotWhy(const MEDCouplingFieldDiscretization *other, double /*eps*/, std::string& reason) const
{
if(!other)
{
reason="other spatial discretization is NULL, and this spatial discretization (GaussNE) is defined.";
return false;
}
- const MEDCouplingFieldDiscretizationGaussNE *otherC=dynamic_cast<const MEDCouplingFieldDiscretizationGaussNE *>(other);
- bool ret=otherC!=0;
+ const auto *otherC=dynamic_cast<const MEDCouplingFieldDiscretizationGaussNE *>(other);
+ bool const ret=otherC!=nullptr;
if(!ret)
reason="Spatial discrtization of this is ON_GAUSS_NE, which is not the case of other.";
return ret;
{
if(code.size()%3!=0)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationGaussNE::getNumberOfTuplesExpectedRegardingCode : invalid input code !");
- mcIdType nbOfSplit=ToIdType(idsPerType.size());
- mcIdType nbOfTypes=ToIdType(code.size()/3);
+ mcIdType const nbOfSplit=ToIdType(idsPerType.size());
+ mcIdType const nbOfTypes=ToIdType(code.size()/3);
mcIdType ret(0);
for(mcIdType i=0;i<nbOfTypes;i++)
{
std::ostringstream oss; oss << "MEDCouplingFieldDiscretizationGaussNE::getNumberOfTuplesExpectedRegardingCode : At pos #" << i << " the geometric type " << cm.getRepr() << " is dynamic ! There are not managed by GAUSS_NE field discretization !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- mcIdType nbOfEltInChunk=code[3*i+1];
+ mcIdType const nbOfEltInChunk=code[3*i+1];
if(nbOfEltInChunk<0)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationGaussNE::getNumberOfTuplesExpectedRegardingCode : invalid input code ! presence of negative value in a type !");
- mcIdType pos=code[3*i+2];
+ mcIdType const pos=code[3*i+2];
if(pos!=-1)
{
if(pos<0 || pos>=nbOfSplit)
if(!mesh)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationGaussNE::getNumberOfTuples : NULL input mesh !");
mcIdType ret=0;
- mcIdType nbOfCells=mesh->getNumberOfCells();
+ mcIdType const nbOfCells=mesh->getNumberOfCells();
for(mcIdType i=0;i<nbOfCells;i++)
{
- INTERP_KERNEL::NormalizedCellType type=mesh->getTypeOfCell(i);
+ INTERP_KERNEL::NormalizedCellType const type=mesh->getTypeOfCell(i);
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
if(cm.isDynamic())
throw INTERP_KERNEL::Exception("Not implemented yet Gauss node on elements for polygons and polyedrons !");
{
if(!mesh)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationGaussNE::getOffsetArr : NULL input mesh !");
- mcIdType nbOfTuples=mesh->getNumberOfCells();
+ mcIdType const nbOfTuples=mesh->getNumberOfCells();
DataArrayIdType *ret=DataArrayIdType::New();
ret->alloc(nbOfTuples+1,1);
mcIdType *retPtr=ret->getPointer();
retPtr[0]=0;
for(mcIdType i=0;i<nbOfTuples;i++)
{
- INTERP_KERNEL::NormalizedCellType type=mesh->getTypeOfCell(i);
+ INTERP_KERNEL::NormalizedCellType const type=mesh->getTypeOfCell(i);
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
if(cm.isDynamic())
throw INTERP_KERNEL::Exception("Not implemented yet Gauss node on elements for polygons and polyedrons !");
const mcIdType *array=old2NewBg;
if(check)
array=DataArrayIdType::CheckAndPreparePermutation(old2NewBg,old2NewBg+mesh->getNumberOfCells());
- mcIdType nbOfCells=mesh->getNumberOfCells();
- mcIdType nbOfTuples=getNumberOfTuples(mesh);
- mcIdType *array2=new mcIdType[nbOfTuples];//stores the final conversion array old2New to give to arrays in renumberInPlace.
- mcIdType *array3=new mcIdType[nbOfCells];//store for each cell in after renumbering the offset needed by each cell in new numbering.
+ mcIdType const nbOfCells=mesh->getNumberOfCells();
+ mcIdType const nbOfTuples=getNumberOfTuples(mesh);
+ auto *array2=new mcIdType[nbOfTuples];//stores the final conversion array old2New to give to arrays in renumberInPlace.
+ auto *array3=new mcIdType[nbOfCells];//store for each cell in after renumbering the offset needed by each cell in new numbering.
array3[0]=0;
for(mcIdType i=1;i<nbOfCells;i++)
{
- INTERP_KERNEL::NormalizedCellType type=mesh->getTypeOfCell(ToIdType(std::distance(array,std::find(array,array+nbOfCells,i-1))));
+ INTERP_KERNEL::NormalizedCellType const type=mesh->getTypeOfCell(ToIdType(std::distance(array,std::find(array,array+nbOfCells,i-1))));
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
array3[i]=array3[i-1]+cm.getNumberOfNodes();
}
mcIdType j=0;
for(mcIdType i=0;i<nbOfCells;i++)
{
- INTERP_KERNEL::NormalizedCellType type=mesh->getTypeOfCell(i);
+ INTERP_KERNEL::NormalizedCellType const type=mesh->getTypeOfCell(i);
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
for(mcIdType k=0;k<ToIdType(cm.getNumberOfNodes());k++,j++)
array2[j]=array3[array[i]]+k;
}
delete [] array3;
- for(std::vector<DataArray *>::const_iterator it=arrays.begin();it!=arrays.end();it++)
- if(*it)
- (*it)->renumberInPlace(array2);
+ for(auto array : arrays)
+ if(array)
+ array->renumberInPlace(array2);
delete [] array2;
if(check)
free(const_cast<mcIdType *>(array));
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationGaussNE::getLocalizationOfDiscValues : NULL input mesh !");
MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
MCAuto<MEDCouplingUMesh> umesh=mesh->buildUnstructured();//in general do nothing
- mcIdType nbOfTuples=getNumberOfTuples(umesh);
- int spaceDim=mesh->getSpaceDimension();
+ mcIdType const nbOfTuples=getNumberOfTuples(umesh);
+ int const spaceDim=mesh->getSpaceDimension();
ret->alloc(nbOfTuples,spaceDim);
const double *coords=umesh->getCoords()->begin();
const mcIdType *connI=umesh->getNodalConnectivityIndex()->getConstPointer();
const mcIdType *conn=umesh->getNodalConnectivity()->getConstPointer();
- mcIdType nbCells=umesh->getNumberOfCells();
+ mcIdType const nbCells=umesh->getNumberOfCells();
double *retPtr=ret->getPointer();
for(mcIdType i=0;i<nbCells;i++,connI++)
for(const mcIdType *w=conn+connI[0]+1;w!=conn+connI[1];w++)
{
if(!mesh || !arr)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationGaussNE::integral : input mesh or array is null !");
- std::size_t nbOfCompo=arr->getNumberOfComponents();
+ std::size_t const nbOfCompo=arr->getNumberOfComponents();
std::fill(res,res+nbOfCompo,0.);
//
MCAuto<MEDCouplingFieldDouble> vol=mesh->getMeasureField(isWAbs);
- std::set<INTERP_KERNEL::NormalizedCellType> types=mesh->getAllGeoTypes();
+ std::set<INTERP_KERNEL::NormalizedCellType> const types=mesh->getAllGeoTypes();
MCAuto<DataArrayIdType> nbOfNodesPerCell=mesh->computeNbOfNodesPerCell();
nbOfNodesPerCell->computeOffsetsFull();
const double *arrPtr=arr->begin(),*volPtr=vol->getArray()->begin();
- for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=types.begin();it!=types.end();it++)
+ for(auto type : types)
{
std::size_t wArrSz=-1;
- const double *wArr=GetWeightArrayFromGeometricType(*it,wArrSz);
+ const double *wArr=GetWeightArrayFromGeometricType(type,wArrSz);
INTERP_KERNEL::AutoPtr<double> wArr2=new double[wArrSz];
- double sum=std::accumulate(wArr,wArr+wArrSz,0.);
+ double const sum=std::accumulate(wArr,wArr+wArrSz,0.);
std::transform(wArr,wArr+wArrSz,(double *)wArr2,std::bind(std::multiplies<double>(),std::placeholders::_1,1./sum));
- MCAuto<DataArrayIdType> ids=mesh->giveCellsWithType(*it);
+ MCAuto<DataArrayIdType> ids=mesh->giveCellsWithType(type);
MCAuto<DataArrayIdType> ids2=ids->buildExplicitArrByRanges(nbOfNodesPerCell);
const mcIdType *ptIds2=ids2->begin(),*ptIds=ids->begin();
- mcIdType nbOfCellsWithCurGeoType=ids->getNumberOfTuples();
+ mcIdType const nbOfCellsWithCurGeoType=ids->getNumberOfTuples();
for(mcIdType i=0;i<nbOfCellsWithCurGeoType;i++,ptIds++,ptIds2+=wArrSz)
{
for(std::size_t k=0;k<nbOfCompo;k++)
{
case INTERP_KERNEL::NORM_POINT1:
lgth=0;
- return 0;
+ return nullptr;
case INTERP_KERNEL::NORM_SEG2:
lgth=sizeof(REF_SEG2)/sizeof(double);
return REF_SEG2;
case INTERP_KERNEL::NORM_POINT1:
{
lgth=0;
- return 0;
+ return nullptr;
}
case INTERP_KERNEL::NORM_SEG2:
{
mcIdType offset=0;
for(mcIdType i=0;i<cellId;i++)
{
- INTERP_KERNEL::NormalizedCellType type=mesh->getTypeOfCell(i);
+ INTERP_KERNEL::NormalizedCellType const type=mesh->getTypeOfCell(i);
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
offset+=cm.getNumberOfNodes();
}
void MEDCouplingFieldDiscretizationGaussNE::checkCoherencyBetween(const MEDCouplingMesh *mesh, const DataArray *da) const
{
- mcIdType nbOfTuples(getNumberOfTuples(mesh));
+ mcIdType const nbOfTuples(getNumberOfTuples(mesh));
if(nbOfTuples!=da->getNumberOfTuples())
{
std::ostringstream oss; oss << "Invalid number of tuples in the array : expecting " << nbOfTuples << " !";
MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(ON_GAUSS_NE);
ret->setMesh(mesh);
//
- std::set<INTERP_KERNEL::NormalizedCellType> types=mesh->getAllGeoTypes();
+ std::set<INTERP_KERNEL::NormalizedCellType> const types=mesh->getAllGeoTypes();
MCAuto<DataArrayIdType> nbOfNodesPerCell=mesh->computeNbOfNodesPerCell();
- mcIdType nbTuples=nbOfNodesPerCell->accumulate((std::size_t)0);
+ mcIdType const nbTuples=nbOfNodesPerCell->accumulate((std::size_t)0);
nbOfNodesPerCell->computeOffsetsFull();
MCAuto<DataArrayDouble> arr=DataArrayDouble::New(); arr->alloc(nbTuples,1);
ret->setArray(arr);
double *arrPtr=arr->getPointer();
- for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=types.begin();it!=types.end();it++)
+ for(auto type : types)
{
std::size_t wArrSz=-1;
- const double *wArr=GetWeightArrayFromGeometricType(*it,wArrSz);
+ const double *wArr=GetWeightArrayFromGeometricType(type,wArrSz);
INTERP_KERNEL::AutoPtr<double> wArr2=new double[wArrSz];
- double sum=std::accumulate(wArr,wArr+wArrSz,0.);
+ double const sum=std::accumulate(wArr,wArr+wArrSz,0.);
std::transform(wArr,wArr+wArrSz,(double *)wArr2,std::bind(std::multiplies<double>(),std::placeholders::_1,1./sum));
- MCAuto<DataArrayIdType> ids=mesh->giveCellsWithType(*it);
+ MCAuto<DataArrayIdType> ids=mesh->giveCellsWithType(type);
MCAuto<DataArrayIdType> ids2=ids->buildExplicitArrByRanges(nbOfNodesPerCell);
const mcIdType *ptIds2=ids2->begin(),*ptIds=ids->begin();
- mcIdType nbOfCellsWithCurGeoType=ids->getNumberOfTuples();
+ mcIdType const nbOfCellsWithCurGeoType=ids->getNumberOfTuples();
for(mcIdType i=0;i<nbOfCellsWithCurGeoType;i++,ptIds++)
for(std::size_t j=0;j<wArrSz;j++,ptIds2++)
arrPtr[*ptIds2]=wArr2[j]*volPtr[*ptIds];
return ret.retn();
}
-void MEDCouplingFieldDiscretizationGaussNE::getValueOn(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, const double *loc, double *res) const
+void MEDCouplingFieldDiscretizationGaussNE::getValueOn(const DataArrayDouble * /*arr*/, const MEDCouplingMesh * /*mesh*/, const double * /*loc*/, double * /*res*/) const
{
throw INTERP_KERNEL::Exception("Not implemented yet !");
}
-void MEDCouplingFieldDiscretizationGaussNE::getValueOnPos(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, mcIdType i, mcIdType j, mcIdType k, double *res) const
+void MEDCouplingFieldDiscretizationGaussNE::getValueOnPos(const DataArrayDouble * /*arr*/, const MEDCouplingMesh * /*mesh*/, mcIdType /*i*/, mcIdType /*j*/, mcIdType /*k*/, double * /*res*/) const
{
throw INTERP_KERNEL::Exception("getValueOnPos(i,j,k) : Not applicable for Gauss points !");
}
-DataArrayDouble *MEDCouplingFieldDiscretizationGaussNE::getValueOnMulti(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, const double *loc, mcIdType nbOfPoints) const
+DataArrayDouble *MEDCouplingFieldDiscretizationGaussNE::getValueOnMulti(const DataArrayDouble * /*arr*/, const MEDCouplingMesh * /*mesh*/, const double * /*loc*/, mcIdType /*nbOfPoints*/) const
{
throw INTERP_KERNEL::Exception("getValueOnMulti : Not implemented for Gauss NE !");
}
return MEDCouplingFieldDiscretization::buildSubMeshDataRange(mesh,beginCellIds,endCellIds,stepCellIds,beginOut,endOut,stepOut,di);
if(!mesh)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationGaussNE::buildSubMeshDataRange : NULL input mesh !");
- mcIdType nbOfCells=mesh->getNumberOfCells();
- di=0; beginOut=0; endOut=0; stepOut=stepCellIds;
+ mcIdType const nbOfCells=mesh->getNumberOfCells();
+ di=nullptr; beginOut=0; endOut=0; stepOut=stepCellIds;
const char msg[]="MEDCouplingFieldDiscretizationGaussNE::buildSubMeshDataRange : cell #";
for(mcIdType i=0;i<nbOfCells;i++)
{
- INTERP_KERNEL::NormalizedCellType type=mesh->getTypeOfCell(i);
+ INTERP_KERNEL::NormalizedCellType const type=mesh->getTypeOfCell(i);
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
if(cm.isDynamic())
{ std::ostringstream oss; oss << msg << i << " presence of dynamic cell (polygons and polyedrons) ! Not implemented !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); }
- mcIdType delta=cm.getNumberOfNodes();
+ mcIdType const delta=cm.getNumberOfNodes();
if(i<beginCellIds)
beginOut+=delta;
endOut+=delta;
{
}
-void MEDCouplingFieldDiscretizationGaussNE::renumberValuesOnCells(double epsOnVals, const MEDCouplingMesh *mesh, const mcIdType *old2New, mcIdType newSz, DataArrayDouble *arr) const
+void MEDCouplingFieldDiscretizationGaussNE::renumberValuesOnCells(double /*epsOnVals*/, const MEDCouplingMesh * /*mesh*/, const mcIdType * /*old2New*/, mcIdType /*newSz*/, DataArrayDouble * /*arr*/) const
{
throw INTERP_KERNEL::Exception("Not implemented yet !");
}
return EasyAggregate<MEDCouplingFieldDiscretizationGaussNE>(fds);
}
-void MEDCouplingFieldDiscretizationGaussNE::renumberValuesOnCellsR(const MEDCouplingMesh *mesh, const mcIdType *new2old, mcIdType newSz, DataArrayDouble *arr) const
+void MEDCouplingFieldDiscretizationGaussNE::renumberValuesOnCellsR(const MEDCouplingMesh * /*mesh*/, const mcIdType * /*new2old*/, mcIdType /*newSz*/, DataArrayDouble * /*arr*/) const
{
throw INTERP_KERNEL::Exception("Not implemented yet !");
}
stream << "Gauss points on nodes per element spatial discretization.";
}
-MEDCouplingFieldDiscretizationGaussNE::MEDCouplingFieldDiscretizationGaussNE(const MEDCouplingFieldDiscretizationGaussNE& other):MEDCouplingFieldDiscretization(other)
-{
-}
+MEDCouplingFieldDiscretizationGaussNE::MEDCouplingFieldDiscretizationGaussNE(const MEDCouplingFieldDiscretizationGaussNE& other)
+= default;
TypeOfField MEDCouplingFieldDiscretizationKriging::getEnum() const
{
throw INTERP_KERNEL::Exception("Invalid nature for Kriging field : expected IntensiveMaximum !");
}
-bool MEDCouplingFieldDiscretizationKriging::isEqualIfNotWhy(const MEDCouplingFieldDiscretization *other, double eps, std::string& reason) const
+bool MEDCouplingFieldDiscretizationKriging::isEqualIfNotWhy(const MEDCouplingFieldDiscretization *other, double /*eps*/, std::string& reason) const
{
if(!other)
{
reason="other spatial discretization is NULL, and this spatial discretization (Kriginig) is defined.";
return false;
}
- const MEDCouplingFieldDiscretizationKriging *otherC=dynamic_cast<const MEDCouplingFieldDiscretizationKriging *>(other);
- bool ret=otherC!=0;
+ const auto *otherC=dynamic_cast<const MEDCouplingFieldDiscretizationKriging *>(other);
+ bool const ret=otherC!=nullptr;
if(!ret)
reason="Spatial discrtization of this is ON_NODES_KR, which is not the case of other.";
return ret;
}
-MEDCouplingFieldDouble *MEDCouplingFieldDiscretizationKriging::getMeasureField(const MEDCouplingMesh *mesh, bool isAbs) const
+MEDCouplingFieldDouble *MEDCouplingFieldDiscretizationKriging::getMeasureField(const MEDCouplingMesh *mesh, bool /*isAbs*/) const
{
if(!mesh)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationKriging::getMeasureField : mesh instance specified is NULL !");
{
if(!arr || !arr->isAllocated())
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationKriging::getValueOnMulti : input array is null or not allocated !");
- mcIdType nbOfRows=getNumberOfMeshPlaces(mesh);
+ mcIdType const nbOfRows=getNumberOfMeshPlaces(mesh);
if(arr->getNumberOfTuples()!=nbOfRows)
{
std::ostringstream oss; oss << "MEDCouplingFieldDiscretizationKriging::getValueOnMulti : input array does not have correct number of tuples ! Excepted " << nbOfRows << " having " << arr->getNumberOfTuples() << " !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
mcIdType nbCols(-1);
- std::size_t nbCompo=arr->getNumberOfComponents();
+ std::size_t const nbCompo=arr->getNumberOfComponents();
MCAuto<DataArrayDouble> m(computeEvaluationMatrixOnGivenPts(mesh,loc,nbOfTargetPoints,nbCols));
MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
ret->alloc(nbOfTargetPoints,nbCompo);
MCAuto<DataArrayDouble> matrixInv(computeInverseMatrix(mesh,isDrift,nbRows));
//
MCAuto<DataArrayDouble> coords=getLocalizationOfDiscValues(mesh);
- mcIdType nbOfPts(coords->getNumberOfTuples());
- std::size_t dimension(coords->getNumberOfComponents());
+ mcIdType const nbOfPts(coords->getNumberOfTuples());
+ std::size_t const dimension(coords->getNumberOfComponents());
MCAuto<DataArrayDouble> locArr=DataArrayDouble::New();
locArr->useArray(loc,false,DeallocType::CPP_DEALLOC,nbOfTargetPoints,dimension);
nbCols=nbOfPts;
if(!mesh)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationKriging::computeMatrix : NULL input mesh !");
MCAuto<DataArrayDouble> coords(getLocalizationOfDiscValues(mesh));
- mcIdType nbOfPts(coords->getNumberOfTuples());
+ mcIdType const nbOfPts(coords->getNumberOfTuples());
MCAuto<DataArrayDouble> matrix(coords->buildEuclidianDistanceDenseMatrix());
operateOnDenseMatrix(mesh->getSpaceDimension(),nbOfPts*nbOfPts,matrix->getPointer());
// Drift
{
for(mcIdType i=0;i<nbOfElems;i++)
{
- double val=matrixPtr[i];
+ double const val=matrixPtr[i];
matrixPtr[i]=val*val*val;
}
}
{
for(mcIdType i=0;i<nbOfElems;i++)
{
- double val=matrixPtr[i];
+ double const val=matrixPtr[i];
if(val!=0.)
matrixPtr[i]=val*val*log(val);
}
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationKriging::PerformDriftRect : invalid input dense matrix ! Must be allocated not NULL and with exactly one component !");
if(!arr || !arr->isAllocated())
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationKriging::PerformDriftRect : invalid input array of coordiantes ! Must be allocated and not NULL !");
- std::size_t spaceDimension(arr->getNumberOfComponents());
+ std::size_t const spaceDimension(arr->getNumberOfComponents());
mcIdType nbOfPts(arr->getNumberOfTuples()),nbOfEltInMatrx(matr->getNumberOfTuples());
delta=ToIdType(spaceDimension)+1;
- mcIdType nbOfCols(nbOfEltInMatrx/nbOfPts);
+ mcIdType const nbOfCols(nbOfEltInMatrx/nbOfPts);
if(nbOfEltInMatrx%nbOfPts!=0)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationKriging::PerformDriftRect : size of input dense matrix and input arrays mismatch ! NbOfElems in matrix % nb of tuples in array must be equal to 0 !");
MCAuto<DataArrayDouble> ret(DataArrayDouble::New()); ret->alloc(nbOfPts*(nbOfCols+delta));
*/
DataArrayDouble *MEDCouplingFieldDiscretizationKriging::performDrift(const DataArrayDouble *matr, const DataArrayDouble *arr, mcIdType& delta) const
{
- std::size_t spaceDimension(arr->getNumberOfComponents());
+ std::size_t const spaceDimension(arr->getNumberOfComponents());
delta=ToIdType(spaceDimension)+1;
- mcIdType szOfMatrix(arr->getNumberOfTuples());
+ mcIdType const szOfMatrix(arr->getNumberOfTuples());
if(szOfMatrix*szOfMatrix!=matr->getNumberOfTuples())
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationKriging::performDrift : invalid size");
MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
#ifndef __PARAMEDMEM_MEDCOUPLINGFIELDDISCRETIZATION_HXX__
#define __PARAMEDMEM_MEDCOUPLINGFIELDDISCRETIZATION_HXX__
+#include "MCType.hxx"
#include "MEDCoupling.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
#include "MEDCouplingRefCountObject.hxx"
#include "InterpKernelException.hxx"
#include "MEDCouplingTimeLabel.hxx"
-#include "MEDCouplingNatureOfField.hxx"
#include "MEDCouplingGaussLocalization.hxx"
#include "MCAuto.hxx"
+#include "NormalizedGeometricTypes"
+#include <cstddef>
+#include <ostream>
#include <set>
+#include <string>
#include <vector>
namespace MEDCoupling
MEDCOUPLING_EXPORT static MEDCouplingFieldDiscretization *New(TypeOfField type);
MEDCOUPLING_EXPORT double getPrecision() const { return _precision; }
MEDCOUPLING_EXPORT void setPrecision(double val) { _precision=val; }
- MEDCOUPLING_EXPORT void updateTime() const;
- MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDCOUPLING_EXPORT void updateTime() const override;
+ MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
MEDCOUPLING_EXPORT static TypeOfField GetTypeOfFieldFromStringRepr(const std::string& repr);
MEDCOUPLING_EXPORT static std::string GetTypeOfFieldRepr(TypeOfField type);
MEDCOUPLING_EXPORT virtual TypeOfField getEnum() const = 0;
MEDCOUPLING_EXPORT virtual void getCellIdsHavingGaussLocalization(mcIdType locId, std::vector<mcIdType>& cellIds) const;
MEDCOUPLING_EXPORT virtual const MEDCouplingGaussLocalization& getGaussLocalization(mcIdType locId) const;
MEDCOUPLING_EXPORT virtual void reprQuickOverview(std::ostream& stream) const = 0;
- MEDCOUPLING_EXPORT virtual ~MEDCouplingFieldDiscretization();
+ MEDCOUPLING_EXPORT ~MEDCouplingFieldDiscretization() override;
protected:
MEDCOUPLING_EXPORT MEDCouplingFieldDiscretization();
MEDCOUPLING_EXPORT static void RenumberEntitiesFromO2NArr(double epsOnVals, const mcIdType *old2NewPtr, mcIdType newNbOfEntity, DataArrayDouble *arr, const std::string& msg);
class MEDCouplingFieldDiscretizationP0 : public MEDCouplingFieldDiscretization
{
public:
- MEDCOUPLING_EXPORT TypeOfField getEnum() const;
+ MEDCOUPLING_EXPORT TypeOfField getEnum() const override;
MEDCOUPLING_EXPORT std::string getClassName() const override { return std::string("MEDCouplingFieldDiscretizationP0"); }
MEDCOUPLING_EXPORT MEDCouplingFieldDiscretization *clone() const override;
- MEDCOUPLING_EXPORT std::string getStringRepr() const;
- MEDCOUPLING_EXPORT const char *getRepr() const;
+ MEDCOUPLING_EXPORT std::string getStringRepr() const override;
+ MEDCOUPLING_EXPORT const char *getRepr() const override;
MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingFieldDiscretization *other, double eps, std::string& reason) const override;
- MEDCOUPLING_EXPORT mcIdType getNumberOfTuplesExpectedRegardingCode(const std::vector<mcIdType>& code, const std::vector<const DataArrayIdType *>& idsPerType) const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfTuples(const MEDCouplingMesh *mesh) const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfMeshPlaces(const MEDCouplingMesh *mesh) const;
- MEDCOUPLING_EXPORT DataArrayIdType *getOffsetArr(const MEDCouplingMesh *mesh) const;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfTuplesExpectedRegardingCode(const std::vector<mcIdType>& code, const std::vector<const DataArrayIdType *>& idsPerType) const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfTuples(const MEDCouplingMesh *mesh) const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfMeshPlaces(const MEDCouplingMesh *mesh) const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *getOffsetArr(const MEDCouplingMesh *mesh) const override;
MEDCOUPLING_EXPORT void renumberArraysForCell(const MEDCouplingMesh *mesh, const std::vector<DataArray *>& arrays,
- const mcIdType *old2NewBg, bool check);
- MEDCOUPLING_EXPORT DataArrayDouble *getLocalizationOfDiscValues(const MEDCouplingMesh *mesh) const;
+ const mcIdType *old2NewBg, bool check) override;
+ MEDCOUPLING_EXPORT DataArrayDouble *getLocalizationOfDiscValues(const MEDCouplingMesh *mesh) const override;
MEDCOUPLING_EXPORT void checkCompatibilityWithNature(NatureOfField nat) const override;
MEDCOUPLING_EXPORT void computeMeshRestrictionFromTupleIds(const MEDCouplingMesh *mesh, const mcIdType *tupleIdsBg, const mcIdType *tupleIdsEnd,
- DataArrayIdType *&cellRestriction, DataArrayIdType *&trueTupleRestriction) const;
- MEDCOUPLING_EXPORT void checkCoherencyBetween(const MEDCouplingMesh *mesh, const DataArray *da) const;
+ DataArrayIdType *&cellRestriction, DataArrayIdType *&trueTupleRestriction) const override;
+ MEDCOUPLING_EXPORT void checkCoherencyBetween(const MEDCouplingMesh *mesh, const DataArray *da) const override;
MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureField(const MEDCouplingMesh *mesh, bool isAbs) const override;
MEDCOUPLING_EXPORT void getValueOn(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, const double *loc, double *res) const override;
- MEDCOUPLING_EXPORT void getValueOnPos(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, mcIdType i, mcIdType j, mcIdType k, double *res) const;
+ MEDCOUPLING_EXPORT void getValueOnPos(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, mcIdType i, mcIdType j, mcIdType k, double *res) const override;
MEDCOUPLING_EXPORT DataArrayDouble *getValueOnMulti(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, const double *loc, mcIdType nbOfPoints) const override;
- MEDCOUPLING_EXPORT void renumberValuesOnNodes(double epsOnVals, const mcIdType *old2New, mcIdType newNbOfNodes, DataArrayDouble *arr) const;
- MEDCOUPLING_EXPORT void renumberValuesOnCells(double epsOnVals, const MEDCouplingMesh *mesh, const mcIdType *old2New, mcIdType newSz, DataArrayDouble *arr) const;
- MEDCOUPLING_EXPORT void renumberValuesOnCellsR(const MEDCouplingMesh *mesh, const mcIdType *new2old, mcIdType newSz, DataArrayDouble *arr) const;
+ MEDCOUPLING_EXPORT void renumberValuesOnNodes(double epsOnVals, const mcIdType *old2New, mcIdType newNbOfNodes, DataArrayDouble *arr) const override;
+ MEDCOUPLING_EXPORT void renumberValuesOnCells(double epsOnVals, const MEDCouplingMesh *mesh, const mcIdType *old2New, mcIdType newSz, DataArrayDouble *arr) const override;
+ MEDCOUPLING_EXPORT void renumberValuesOnCellsR(const MEDCouplingMesh *mesh, const mcIdType *new2old, mcIdType newSz, DataArrayDouble *arr) const override;
MEDCOUPLING_EXPORT MCAuto<MEDCouplingFieldDiscretization> aggregate(std::vector<const MEDCouplingFieldDiscretization *>& fds) const override;
- MEDCOUPLING_EXPORT MEDCouplingMesh *buildSubMeshData(const MEDCouplingMesh *mesh, const mcIdType *start, const mcIdType *end, DataArrayIdType *&di) const;
- MEDCOUPLING_EXPORT MEDCouplingMesh *buildSubMeshDataRange(const MEDCouplingMesh *mesh, mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds, mcIdType& beginOut, mcIdType& endOut, mcIdType& stepOut, DataArrayIdType *&di) const;
- MEDCOUPLING_EXPORT DataArrayIdType *computeTupleIdsToSelectFromCellIds(const MEDCouplingMesh *mesh, const mcIdType *startCellIds, const mcIdType *endCellIds) const;
- MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const;
+ MEDCOUPLING_EXPORT MEDCouplingMesh *buildSubMeshData(const MEDCouplingMesh *mesh, const mcIdType *start, const mcIdType *end, DataArrayIdType *&di) const override;
+ MEDCOUPLING_EXPORT MEDCouplingMesh *buildSubMeshDataRange(const MEDCouplingMesh *mesh, mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds, mcIdType& beginOut, mcIdType& endOut, mcIdType& stepOut, DataArrayIdType *&di) const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *computeTupleIdsToSelectFromCellIds(const MEDCouplingMesh *mesh, const mcIdType *startCellIds, const mcIdType *endCellIds) const override;
+ MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const override;
public:
static const char REPR[];
static constexpr TypeOfField TYPE = ON_CELLS;
class MEDCouplingFieldDiscretizationOnNodes : public MEDCouplingFieldDiscretization
{
public:
- MEDCOUPLING_EXPORT mcIdType getNumberOfTuples(const MEDCouplingMesh *mesh) const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfTuplesExpectedRegardingCode(const std::vector<mcIdType>& code, const std::vector<const DataArrayIdType *>& idsPerType) const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfMeshPlaces(const MEDCouplingMesh *mesh) const;
- MEDCOUPLING_EXPORT DataArrayIdType *getOffsetArr(const MEDCouplingMesh *mesh) const;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfTuples(const MEDCouplingMesh *mesh) const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfTuplesExpectedRegardingCode(const std::vector<mcIdType>& code, const std::vector<const DataArrayIdType *>& idsPerType) const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfMeshPlaces(const MEDCouplingMesh *mesh) const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *getOffsetArr(const MEDCouplingMesh *mesh) const override;
MEDCOUPLING_EXPORT void renumberArraysForCell(const MEDCouplingMesh *mesh, const std::vector<DataArray *>& arrays,
- const mcIdType *old2NewBg, bool check);
- MEDCOUPLING_EXPORT DataArrayDouble *getLocalizationOfDiscValues(const MEDCouplingMesh *mesh) const;
+ const mcIdType *old2NewBg, bool check) override;
+ MEDCOUPLING_EXPORT DataArrayDouble *getLocalizationOfDiscValues(const MEDCouplingMesh *mesh) const override;
MEDCOUPLING_EXPORT void computeMeshRestrictionFromTupleIds(const MEDCouplingMesh *mesh, const mcIdType *tupleIdsBg, const mcIdType *tupleIdsEnd,
- DataArrayIdType *&cellRestriction, DataArrayIdType *&trueTupleRestriction) const;
- MEDCOUPLING_EXPORT void checkCoherencyBetween(const MEDCouplingMesh *mesh, const DataArray *da) const;
- MEDCOUPLING_EXPORT MEDCouplingMesh *buildSubMeshData(const MEDCouplingMesh *mesh, const mcIdType *start, const mcIdType *end, DataArrayIdType *&di) const;
- MEDCOUPLING_EXPORT MEDCouplingMesh *buildSubMeshDataRange(const MEDCouplingMesh *mesh, mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds, mcIdType& beginOut, mcIdType& endOut, mcIdType& stepOut, DataArrayIdType *&di) const;
- MEDCOUPLING_EXPORT DataArrayIdType *computeTupleIdsToSelectFromCellIds(const MEDCouplingMesh *mesh, const mcIdType *startCellIds, const mcIdType *endCellIds) const;
- MEDCOUPLING_EXPORT void renumberValuesOnNodes(double epsOnVals, const mcIdType *old2New, mcIdType newNbOfNodes, DataArrayDouble *arr) const;
- MEDCOUPLING_EXPORT void renumberValuesOnCells(double epsOnVals, const MEDCouplingMesh *mesh, const mcIdType *old2New, mcIdType newSz, DataArrayDouble *arr) const;
- MEDCOUPLING_EXPORT void renumberValuesOnCellsR(const MEDCouplingMesh *mesh, const mcIdType *new2old, mcIdType newSz, DataArrayDouble *arr) const;
+ DataArrayIdType *&cellRestriction, DataArrayIdType *&trueTupleRestriction) const override;
+ MEDCOUPLING_EXPORT void checkCoherencyBetween(const MEDCouplingMesh *mesh, const DataArray *da) const override;
+ MEDCOUPLING_EXPORT MEDCouplingMesh *buildSubMeshData(const MEDCouplingMesh *mesh, const mcIdType *start, const mcIdType *end, DataArrayIdType *&di) const override;
+ MEDCOUPLING_EXPORT MEDCouplingMesh *buildSubMeshDataRange(const MEDCouplingMesh *mesh, mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds, mcIdType& beginOut, mcIdType& endOut, mcIdType& stepOut, DataArrayIdType *&di) const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *computeTupleIdsToSelectFromCellIds(const MEDCouplingMesh *mesh, const mcIdType *startCellIds, const mcIdType *endCellIds) const override;
+ MEDCOUPLING_EXPORT void renumberValuesOnNodes(double epsOnVals, const mcIdType *old2New, mcIdType newNbOfNodes, DataArrayDouble *arr) const override;
+ MEDCOUPLING_EXPORT void renumberValuesOnCells(double epsOnVals, const MEDCouplingMesh *mesh, const mcIdType *old2New, mcIdType newSz, DataArrayDouble *arr) const override;
+ MEDCOUPLING_EXPORT void renumberValuesOnCellsR(const MEDCouplingMesh *mesh, const mcIdType *new2old, mcIdType newSz, DataArrayDouble *arr) const override;
public:
- MEDCOUPLING_EXPORT void getValueOnPos(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, mcIdType i, mcIdType j, mcIdType k, double *res) const;
+ MEDCOUPLING_EXPORT void getValueOnPos(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, mcIdType i, mcIdType j, mcIdType k, double *res) const override;
};
class MEDCouplingFieldDiscretizationP1 : public MEDCouplingFieldDiscretizationOnNodes
{
public:
- MEDCOUPLING_EXPORT TypeOfField getEnum() const;
+ MEDCOUPLING_EXPORT TypeOfField getEnum() const override;
MEDCOUPLING_EXPORT std::string getClassName() const override { return std::string("MEDCouplingFieldDiscretizationP1"); }
MEDCOUPLING_EXPORT MEDCouplingFieldDiscretization *clone() const override;
- MEDCOUPLING_EXPORT std::string getStringRepr() const;
- MEDCOUPLING_EXPORT const char *getRepr() const;
+ MEDCOUPLING_EXPORT std::string getStringRepr() const override;
+ MEDCOUPLING_EXPORT const char *getRepr() const override;
MEDCOUPLING_EXPORT void checkCompatibilityWithNature(NatureOfField nat) const override;
MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingFieldDiscretization *other, double eps, std::string& reason) const override;
MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureField(const MEDCouplingMesh *mesh, bool isAbs) const override;
MEDCOUPLING_EXPORT void getValueOn(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, const double *loc, double *res) const override;
MEDCOUPLING_EXPORT DataArrayDouble *getValueOnMulti(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, const double *loc, mcIdType nbOfPoints) const override;
- MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const;
+ MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const override;
MEDCOUPLING_EXPORT MCAuto<MEDCouplingFieldDiscretization> aggregate(std::vector<const MEDCouplingFieldDiscretization *>& fds) const override;
public:
static const char REPR[];
MEDCouplingFieldDiscretizationPerCell(const MEDCouplingFieldDiscretizationPerCell& other, const mcIdType *startCellIds, const mcIdType *endCellIds);
MEDCouplingFieldDiscretizationPerCell(const MEDCouplingFieldDiscretizationPerCell& other, mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds);
MEDCouplingFieldDiscretizationPerCell(DataArrayIdType *dpc);
- ~MEDCouplingFieldDiscretizationPerCell();
- void updateTime() const;
- std::size_t getHeapMemorySizeWithoutChildren() const;
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- void checkCoherencyBetween(const MEDCouplingMesh *mesh, const DataArray *da) const;
+ ~MEDCouplingFieldDiscretizationPerCell() override;
+ void updateTime() const override;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ void checkCoherencyBetween(const MEDCouplingMesh *mesh, const DataArray *da) const override;
bool isEqualIfNotWhy(const MEDCouplingFieldDiscretization *other, double eps, std::string& reason) const override;
- bool isEqualWithoutConsideringStr(const MEDCouplingFieldDiscretization *other, double eps) const;
- void renumberCells(const mcIdType *old2NewBg, bool check);
+ bool isEqualWithoutConsideringStr(const MEDCouplingFieldDiscretization *other, double eps) const override;
+ void renumberCells(const mcIdType *old2NewBg, bool check) override;
protected:
void buildDiscrPerCellIfNecessary(const MEDCouplingMesh *mesh);
protected:
{
public:
MEDCOUPLING_EXPORT MEDCouplingFieldDiscretizationGauss();
- MEDCOUPLING_EXPORT TypeOfField getEnum() const;
+ MEDCOUPLING_EXPORT TypeOfField getEnum() const override;
MEDCOUPLING_EXPORT std::string getClassName() const override { return std::string("MEDCouplingFieldDiscretizationGauss"); }
MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingFieldDiscretization *other, double eps, std::string& reason) const override;
- MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingFieldDiscretization *other, double eps) const;
+ MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingFieldDiscretization *other, double eps) const override;
MEDCOUPLING_EXPORT MEDCouplingFieldDiscretization *clone() const override;
- MEDCOUPLING_EXPORT MEDCouplingFieldDiscretization *clonePart(const mcIdType *startCellIds, const mcIdType *endCellIds) const;
- MEDCOUPLING_EXPORT MEDCouplingFieldDiscretization *clonePartRange(mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds) const;
- MEDCOUPLING_EXPORT std::string getStringRepr() const;
- MEDCOUPLING_EXPORT const char *getRepr() const;
- MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfTuplesExpectedRegardingCode(const std::vector<mcIdType>& code, const std::vector<const DataArrayIdType *>& idsPerType) const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfTuples(const MEDCouplingMesh *mesh) const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfMeshPlaces(const MEDCouplingMesh *mesh) const;
- MEDCOUPLING_EXPORT DataArrayIdType *getOffsetArr(const MEDCouplingMesh *mesh) const;
+ MEDCOUPLING_EXPORT MEDCouplingFieldDiscretization *clonePart(const mcIdType *startCellIds, const mcIdType *endCellIds) const override;
+ MEDCOUPLING_EXPORT MEDCouplingFieldDiscretization *clonePartRange(mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds) const override;
+ MEDCOUPLING_EXPORT std::string getStringRepr() const override;
+ MEDCOUPLING_EXPORT const char *getRepr() const override;
+ MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfTuplesExpectedRegardingCode(const std::vector<mcIdType>& code, const std::vector<const DataArrayIdType *>& idsPerType) const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfTuples(const MEDCouplingMesh *mesh) const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfMeshPlaces(const MEDCouplingMesh *mesh) const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *getOffsetArr(const MEDCouplingMesh *mesh) const override;
MEDCOUPLING_EXPORT void renumberArraysForCell(const MEDCouplingMesh *mesh, const std::vector<DataArray *>& arrays,
- const mcIdType *old2NewBg, bool check);
- MEDCOUPLING_EXPORT DataArrayDouble *getLocalizationOfDiscValues(const MEDCouplingMesh *mesh) const;
+ const mcIdType *old2NewBg, bool check) override;
+ MEDCOUPLING_EXPORT DataArrayDouble *getLocalizationOfDiscValues(const MEDCouplingMesh *mesh) const override;
MEDCOUPLING_EXPORT void computeMeshRestrictionFromTupleIds(const MEDCouplingMesh *mesh, const mcIdType *tupleIdsBg, const mcIdType *tupleIdsEnd,
- DataArrayIdType *&cellRestriction, DataArrayIdType *&trueTupleRestriction) const;
+ DataArrayIdType *&cellRestriction, DataArrayIdType *&trueTupleRestriction) const override;
MEDCOUPLING_EXPORT void checkCompatibilityWithNature(NatureOfField nat) const override;
- MEDCOUPLING_EXPORT void getTinySerializationIntInformation(std::vector<mcIdType>& tinyInfo) const;
- MEDCOUPLING_EXPORT void getTinySerializationDbleInformation(std::vector<double>& tinyInfo) const;
- MEDCOUPLING_EXPORT void finishUnserialization(const std::vector<double>& tinyInfo);
- MEDCOUPLING_EXPORT void getSerializationIntArray(DataArrayIdType *& arr) const;
- MEDCOUPLING_EXPORT void resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *& arr);
- MEDCOUPLING_EXPORT void checkForUnserialization(const std::vector<mcIdType>& tinyInfo, const DataArrayIdType *arr);
- MEDCOUPLING_EXPORT double getIJK(const MEDCouplingMesh *mesh, const DataArrayDouble *da, mcIdType cellId, mcIdType nodeIdInCell, int compoId) const;
- MEDCOUPLING_EXPORT void checkCoherencyBetween(const MEDCouplingMesh *mesh, const DataArray *da) const;
+ MEDCOUPLING_EXPORT void getTinySerializationIntInformation(std::vector<mcIdType>& tinyInfo) const override;
+ MEDCOUPLING_EXPORT void getTinySerializationDbleInformation(std::vector<double>& tinyInfo) const override;
+ MEDCOUPLING_EXPORT void finishUnserialization(const std::vector<double>& tinyInfo) override;
+ MEDCOUPLING_EXPORT void getSerializationIntArray(DataArrayIdType *& arr) const override;
+ MEDCOUPLING_EXPORT void resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *& arr) override;
+ MEDCOUPLING_EXPORT void checkForUnserialization(const std::vector<mcIdType>& tinyInfo, const DataArrayIdType *arr) override;
+ MEDCOUPLING_EXPORT double getIJK(const MEDCouplingMesh *mesh, const DataArrayDouble *da, mcIdType cellId, mcIdType nodeIdInCell, int compoId) const override;
+ MEDCOUPLING_EXPORT void checkCoherencyBetween(const MEDCouplingMesh *mesh, const DataArray *da) const override;
MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureField(const MEDCouplingMesh *mesh, bool isAbs) const override;
MEDCOUPLING_EXPORT void getValueOn(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, const double *loc, double *res) const override;
- MEDCOUPLING_EXPORT void getValueOnPos(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, mcIdType i, mcIdType j, mcIdType k, double *res) const;
+ MEDCOUPLING_EXPORT void getValueOnPos(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, mcIdType i, mcIdType j, mcIdType k, double *res) const override;
MEDCOUPLING_EXPORT DataArrayDouble *getValueOnMulti(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, const double *loc, mcIdType nbOfPoints) const override;
- MEDCOUPLING_EXPORT MEDCouplingMesh *buildSubMeshData(const MEDCouplingMesh *mesh, const mcIdType *start, const mcIdType *end, DataArrayIdType *&di) const;
- MEDCOUPLING_EXPORT MEDCouplingMesh *buildSubMeshDataRange(const MEDCouplingMesh *mesh, mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds, mcIdType& beginOut, mcIdType& endOut, mcIdType& stepOut, DataArrayIdType *&di) const;
- MEDCOUPLING_EXPORT DataArrayIdType *computeTupleIdsToSelectFromCellIds(const MEDCouplingMesh *mesh, const mcIdType *startCellIds, const mcIdType *endCellIds) const;
- MEDCOUPLING_EXPORT void renumberValuesOnNodes(double epsOnVals, const mcIdType *old2New, mcIdType newNbOfNodes, DataArrayDouble *arr) const;
- MEDCOUPLING_EXPORT void renumberValuesOnCells(double epsOnVals, const MEDCouplingMesh *mesh, const mcIdType *old2New, mcIdType newSz, DataArrayDouble *arr) const;
- MEDCOUPLING_EXPORT void renumberValuesOnCellsR(const MEDCouplingMesh *mesh, const mcIdType *new2old, mcIdType newSz, DataArrayDouble *arr) const;
+ MEDCOUPLING_EXPORT MEDCouplingMesh *buildSubMeshData(const MEDCouplingMesh *mesh, const mcIdType *start, const mcIdType *end, DataArrayIdType *&di) const override;
+ MEDCOUPLING_EXPORT MEDCouplingMesh *buildSubMeshDataRange(const MEDCouplingMesh *mesh, mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds, mcIdType& beginOut, mcIdType& endOut, mcIdType& stepOut, DataArrayIdType *&di) const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *computeTupleIdsToSelectFromCellIds(const MEDCouplingMesh *mesh, const mcIdType *startCellIds, const mcIdType *endCellIds) const override;
+ MEDCOUPLING_EXPORT void renumberValuesOnNodes(double epsOnVals, const mcIdType *old2New, mcIdType newNbOfNodes, DataArrayDouble *arr) const override;
+ MEDCOUPLING_EXPORT void renumberValuesOnCells(double epsOnVals, const MEDCouplingMesh *mesh, const mcIdType *old2New, mcIdType newSz, DataArrayDouble *arr) const override;
+ MEDCOUPLING_EXPORT void renumberValuesOnCellsR(const MEDCouplingMesh *mesh, const mcIdType *new2old, mcIdType newSz, DataArrayDouble *arr) const override;
MEDCOUPLING_EXPORT MCAuto<MEDCouplingFieldDiscretization> aggregate(std::vector<const MEDCouplingFieldDiscretization *>& fds) const override;
MEDCOUPLING_EXPORT void setGaussLocalizationOnType(const MEDCouplingMesh *mesh, INTERP_KERNEL::NormalizedCellType type, const std::vector<double>& refCoo,
- const std::vector<double>& gsCoo, const std::vector<double>& wg);
+ const std::vector<double>& gsCoo, const std::vector<double>& wg) override;
MEDCOUPLING_EXPORT void setGaussLocalizationOnCells(const MEDCouplingMesh *mesh, const mcIdType *begin, const mcIdType *end, const std::vector<double>& refCoo,
- const std::vector<double>& gsCoo, const std::vector<double>& wg);
- MEDCOUPLING_EXPORT void clearGaussLocalizations();
+ const std::vector<double>& gsCoo, const std::vector<double>& wg) override;
+ MEDCOUPLING_EXPORT void clearGaussLocalizations() override;
MEDCOUPLING_EXPORT void setGaussLocalization(mcIdType locId, const MEDCouplingGaussLocalization& loc);
MEDCOUPLING_EXPORT void resizeLocalizationVector(mcIdType newSz);
- MEDCOUPLING_EXPORT MEDCouplingGaussLocalization& getGaussLocalization(mcIdType locId);
- MEDCOUPLING_EXPORT mcIdType getNbOfGaussLocalization() const;
- MEDCOUPLING_EXPORT mcIdType getGaussLocalizationIdOfOneCell(mcIdType cellId) const;
- MEDCOUPLING_EXPORT mcIdType getGaussLocalizationIdOfOneType(INTERP_KERNEL::NormalizedCellType type) const;
- MEDCOUPLING_EXPORT std::set<mcIdType> getGaussLocalizationIdsOfOneType(INTERP_KERNEL::NormalizedCellType type) const;
- MEDCOUPLING_EXPORT void getCellIdsHavingGaussLocalization(mcIdType locId, std::vector<mcIdType>& cellIds) const;
- MEDCOUPLING_EXPORT const MEDCouplingGaussLocalization& getGaussLocalization(mcIdType locId) const;
+ MEDCOUPLING_EXPORT MEDCouplingGaussLocalization& getGaussLocalization(mcIdType locId) override;
+ MEDCOUPLING_EXPORT mcIdType getNbOfGaussLocalization() const override;
+ MEDCOUPLING_EXPORT mcIdType getGaussLocalizationIdOfOneCell(mcIdType cellId) const override;
+ MEDCOUPLING_EXPORT mcIdType getGaussLocalizationIdOfOneType(INTERP_KERNEL::NormalizedCellType type) const override;
+ MEDCOUPLING_EXPORT std::set<mcIdType> getGaussLocalizationIdsOfOneType(INTERP_KERNEL::NormalizedCellType type) const override;
+ MEDCOUPLING_EXPORT void getCellIdsHavingGaussLocalization(mcIdType locId, std::vector<mcIdType>& cellIds) const override;
+ MEDCOUPLING_EXPORT const MEDCouplingGaussLocalization& getGaussLocalization(mcIdType locId) const override;
MEDCOUPLING_EXPORT DataArrayIdType *buildNbOfGaussPointPerCellField() const;
- MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const;
+ MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const override;
protected:
- MEDCouplingFieldDiscretizationGauss(const MEDCouplingFieldDiscretizationGauss& other, const mcIdType *startCellIds=0, const mcIdType *endCellIds=0);
+ MEDCouplingFieldDiscretizationGauss(const MEDCouplingFieldDiscretizationGauss& other, const mcIdType *startCellIds=nullptr, const mcIdType *endCellIds=nullptr);
MEDCouplingFieldDiscretizationGauss(const MEDCouplingFieldDiscretizationGauss& other, mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds);
MEDCouplingFieldDiscretizationGauss(DataArrayIdType *dpc, const std::vector<MEDCouplingGaussLocalization>& loc):MEDCouplingFieldDiscretizationPerCell(dpc),_loc(loc) { }
void zipGaussLocalizations();
{
public:
MEDCOUPLING_EXPORT MEDCouplingFieldDiscretizationGaussNE();
- MEDCOUPLING_EXPORT TypeOfField getEnum() const;
+ MEDCOUPLING_EXPORT TypeOfField getEnum() const override;
MEDCOUPLING_EXPORT std::string getClassName() const override { return std::string("MEDCouplingFieldDiscretizationGaussNE"); }
MEDCOUPLING_EXPORT MEDCouplingFieldDiscretization *clone() const override;
- MEDCOUPLING_EXPORT std::string getStringRepr() const;
- MEDCOUPLING_EXPORT const char *getRepr() const;
+ MEDCOUPLING_EXPORT std::string getStringRepr() const override;
+ MEDCOUPLING_EXPORT const char *getRepr() const override;
MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingFieldDiscretization *other, double eps, std::string& reason) const override;
- MEDCOUPLING_EXPORT mcIdType getNumberOfTuplesExpectedRegardingCode(const std::vector<mcIdType>& code, const std::vector<const DataArrayIdType *>& idsPerType) const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfTuples(const MEDCouplingMesh *mesh) const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfMeshPlaces(const MEDCouplingMesh *mesh) const;
- MEDCOUPLING_EXPORT DataArrayIdType *getOffsetArr(const MEDCouplingMesh *mesh) const;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfTuplesExpectedRegardingCode(const std::vector<mcIdType>& code, const std::vector<const DataArrayIdType *>& idsPerType) const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfTuples(const MEDCouplingMesh *mesh) const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfMeshPlaces(const MEDCouplingMesh *mesh) const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *getOffsetArr(const MEDCouplingMesh *mesh) const override;
MEDCOUPLING_EXPORT void renumberArraysForCell(const MEDCouplingMesh *mesh, const std::vector<DataArray *>& arrays,
- const mcIdType *old2NewBg, bool check);
- MEDCOUPLING_EXPORT DataArrayDouble *getLocalizationOfDiscValues(const MEDCouplingMesh *mesh) const;
- MEDCOUPLING_EXPORT void integral(const MEDCouplingMesh *mesh, const DataArrayDouble *arr, bool isWAbs, double *res) const;
+ const mcIdType *old2NewBg, bool check) override;
+ MEDCOUPLING_EXPORT DataArrayDouble *getLocalizationOfDiscValues(const MEDCouplingMesh *mesh) const override;
+ MEDCOUPLING_EXPORT void integral(const MEDCouplingMesh *mesh, const DataArrayDouble *arr, bool isWAbs, double *res) const override;
MEDCOUPLING_EXPORT void computeMeshRestrictionFromTupleIds(const MEDCouplingMesh *mesh, const mcIdType *tupleIdsBg, const mcIdType *tupleIdsEnd,
- DataArrayIdType *&cellRestriction, DataArrayIdType *&trueTupleRestriction) const;
+ DataArrayIdType *&cellRestriction, DataArrayIdType *&trueTupleRestriction) const override;
MEDCOUPLING_EXPORT void checkCompatibilityWithNature(NatureOfField nat) const override;
- MEDCOUPLING_EXPORT double getIJK(const MEDCouplingMesh *mesh, const DataArrayDouble *da, mcIdType cellId, mcIdType nodeIdInCell, int compoId) const;
- MEDCOUPLING_EXPORT void checkCoherencyBetween(const MEDCouplingMesh *mesh, const DataArray *da) const;
+ MEDCOUPLING_EXPORT double getIJK(const MEDCouplingMesh *mesh, const DataArrayDouble *da, mcIdType cellId, mcIdType nodeIdInCell, int compoId) const override;
+ MEDCOUPLING_EXPORT void checkCoherencyBetween(const MEDCouplingMesh *mesh, const DataArray *da) const override;
MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureField(const MEDCouplingMesh *mesh, bool isAbs) const override;
MEDCOUPLING_EXPORT void getValueOn(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, const double *loc, double *res) const override;
- MEDCOUPLING_EXPORT void getValueOnPos(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, mcIdType i, mcIdType j, mcIdType k, double *res) const;
+ MEDCOUPLING_EXPORT void getValueOnPos(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, mcIdType i, mcIdType j, mcIdType k, double *res) const override;
MEDCOUPLING_EXPORT DataArrayDouble *getValueOnMulti(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, const double *loc, mcIdType nbOfPoints) const override;
- MEDCOUPLING_EXPORT MEDCouplingMesh *buildSubMeshData(const MEDCouplingMesh *mesh, const mcIdType *start, const mcIdType *end, DataArrayIdType *&di) const;
- MEDCOUPLING_EXPORT MEDCouplingMesh *buildSubMeshDataRange(const MEDCouplingMesh *mesh, mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds, mcIdType& beginOut, mcIdType& endOut, mcIdType& stepOut, DataArrayIdType *&di) const;
- MEDCOUPLING_EXPORT DataArrayIdType *computeTupleIdsToSelectFromCellIds(const MEDCouplingMesh *mesh, const mcIdType *startCellIds, const mcIdType *endCellIds) const;
- MEDCOUPLING_EXPORT void renumberValuesOnNodes(double epsOnVals, const mcIdType *old2New, mcIdType newNbOfNodes, DataArrayDouble *arr) const;
- MEDCOUPLING_EXPORT void renumberValuesOnCells(double epsOnVals, const MEDCouplingMesh *mesh, const mcIdType *old2New, mcIdType newSz, DataArrayDouble *arr) const;
- MEDCOUPLING_EXPORT void renumberValuesOnCellsR(const MEDCouplingMesh *mesh, const mcIdType *new2old, mcIdType newSz, DataArrayDouble *arr) const;
+ MEDCOUPLING_EXPORT MEDCouplingMesh *buildSubMeshData(const MEDCouplingMesh *mesh, const mcIdType *start, const mcIdType *end, DataArrayIdType *&di) const override;
+ MEDCOUPLING_EXPORT MEDCouplingMesh *buildSubMeshDataRange(const MEDCouplingMesh *mesh, mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds, mcIdType& beginOut, mcIdType& endOut, mcIdType& stepOut, DataArrayIdType *&di) const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *computeTupleIdsToSelectFromCellIds(const MEDCouplingMesh *mesh, const mcIdType *startCellIds, const mcIdType *endCellIds) const override;
+ MEDCOUPLING_EXPORT void renumberValuesOnNodes(double epsOnVals, const mcIdType *old2New, mcIdType newNbOfNodes, DataArrayDouble *arr) const override;
+ MEDCOUPLING_EXPORT void renumberValuesOnCells(double epsOnVals, const MEDCouplingMesh *mesh, const mcIdType *old2New, mcIdType newSz, DataArrayDouble *arr) const override;
+ MEDCOUPLING_EXPORT void renumberValuesOnCellsR(const MEDCouplingMesh *mesh, const mcIdType *new2old, mcIdType newSz, DataArrayDouble *arr) const override;
MEDCOUPLING_EXPORT MCAuto<MEDCouplingFieldDiscretization> aggregate(std::vector<const MEDCouplingFieldDiscretization *>& fds) const override;
- MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const;
+ MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const override;
MEDCOUPLING_EXPORT static const double *GetWeightArrayFromGeometricType(INTERP_KERNEL::NormalizedCellType geoType, std::size_t& lgth);
MEDCOUPLING_EXPORT static const double *GetRefCoordsFromGeometricType(INTERP_KERNEL::NormalizedCellType geoType, std::size_t& lgth);
MEDCOUPLING_EXPORT static const double *GetLocsFromGeometricType(INTERP_KERNEL::NormalizedCellType geoType, std::size_t& lgth);
class MEDCouplingFieldDiscretizationKriging : public MEDCouplingFieldDiscretizationOnNodes
{
public:
- MEDCOUPLING_EXPORT TypeOfField getEnum() const;
+ MEDCOUPLING_EXPORT TypeOfField getEnum() const override;
MEDCOUPLING_EXPORT std::string getClassName() const override { return std::string("MEDCouplingFieldDiscretizationKriging"); }
- MEDCOUPLING_EXPORT const char *getRepr() const;
+ MEDCOUPLING_EXPORT const char *getRepr() const override;
MEDCOUPLING_EXPORT MEDCouplingFieldDiscretization *clone() const override;
- MEDCOUPLING_EXPORT std::string getStringRepr() const;
+ MEDCOUPLING_EXPORT std::string getStringRepr() const override;
MEDCOUPLING_EXPORT void checkCompatibilityWithNature(NatureOfField nat) const override;
MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingFieldDiscretization *other, double eps, std::string& reason) const override;
MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureField(const MEDCouplingMesh *mesh, bool isAbs) const override;
MEDCOUPLING_EXPORT void getValueOn(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, const double *loc, double *res) const override;
MEDCOUPLING_EXPORT DataArrayDouble *getValueOnMulti(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, const double *loc, mcIdType nbOfPoints) const override;
- MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const;
+ MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const override;
MEDCOUPLING_EXPORT MCAuto<MEDCouplingFieldDiscretization> aggregate(std::vector<const MEDCouplingFieldDiscretization *>& fds) const override;
public://specific part
MEDCOUPLING_EXPORT DataArrayDouble *computeEvaluationMatrixOnGivenPts(const MEDCouplingMesh *mesh, const double *loc, mcIdType nbOfTargetPoints, mcIdType& nbCols) const;
// Author : Anthony Geay (EDF R&D)
#include "MEDCouplingFieldDiscretizationOnNodesFE.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingFieldDiscretization.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
+#include "MEDCouplingMesh.hxx"
+#include "MEDCouplingGaussLocalization.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MCType.hxx"
#include "MEDCouplingNormalizedUnstructuredMesh.txx"
+#include "BBTreeStandAlone.txx"
+#include "InterpKernelException.hxx"
#include "InterpKernelDenseMatrix.hxx"
#include "InterpKernelRootsMultiDim.hxx"
#include "MEDCouplingUMesh.hxx"
-#include "InterpolationHelper.txx"
#include "InterpKernelGaussCoords.hxx"
+#include "NormalizedGeometricTypes"
+#include "InterpolationHelper.txx"
-#include <sstream>
+#include <algorithm>
+#include <ostream>
+#include <cstddef>
+#include <limits>
+#include <functional>
+#include <string>
+#include <vector>
using namespace MEDCoupling;
return EasyAggregate<MEDCouplingFieldDiscretizationOnNodesFE>(fds);
}
-bool MEDCouplingFieldDiscretizationOnNodesFE::isEqualIfNotWhy(const MEDCouplingFieldDiscretization *other, double eps, std::string& reason) const
+bool MEDCouplingFieldDiscretizationOnNodesFE::isEqualIfNotWhy(const MEDCouplingFieldDiscretization *other, double /*eps*/, std::string& reason) const
{
if(!other)
{
reason="other spatial discretization is NULL, and this spatial discretization (Node FE) is defined.";
return false;
}
- const MEDCouplingFieldDiscretizationOnNodesFE *otherC=dynamic_cast<const MEDCouplingFieldDiscretizationOnNodesFE *>(other);
- bool ret=otherC!=0;
+ const auto *otherC=dynamic_cast<const MEDCouplingFieldDiscretizationOnNodesFE *>(other);
+ bool const ret=otherC!=nullptr;
if(!ret)
reason="Spatial discrtization of this is ON_NODES_FE, which is not the case of other.";
return ret;
throw INTERP_KERNEL::Exception("Invalid nature for NodeFE field : expected IntensiveMaximum !");
}
-MEDCouplingFieldDouble *MEDCouplingFieldDiscretizationOnNodesFE::getMeasureField(const MEDCouplingMesh *mesh, bool isAbs) const
+MEDCouplingFieldDouble *MEDCouplingFieldDiscretizationOnNodesFE::getMeasureField(const MEDCouplingMesh *mesh, bool /*isAbs*/) const
{
if(!mesh)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDiscretizationOnNodesFE::getMeasureField : mesh instance specified is NULL !");
_pts_in_cell(ptsInCell),_point(point) { }
std::vector<double> operator()(const std::vector<double>& x)
{
- MEDCouplingGaussLocalization gl(_gl->getType(),_gl->getRefCoords(),x,{1.0});
+ MEDCouplingGaussLocalization const gl(_gl->getType(),_gl->getRefCoords(),x,{1.0});
MCAuto<DataArrayDouble> shapeFunc = gl.getShapeFunctionValues();
const double *shapeFuncPtr( shapeFunc->begin() );
std::vector<double> ret(3,0);
bool IsInside3D(const MEDCouplingGaussLocalization& gl, const std::vector<double>& ptsInCell, const double locInReal[3], double locInRef[3])
{
constexpr double EPS_IN_OUT = 1e-12;
- std::size_t nbPtsInCell(ptsInCell.size()/3);
+ std::size_t const nbPtsInCell(ptsInCell.size()/3);
bool ret(false);
const double *refCoo(gl.getRefCoords().data());
- INTERP_KERNEL::NormalizedCellType ct(gl.getType());
+ INTERP_KERNEL::NormalizedCellType const ct(gl.getType());
Functor func(gl,nbPtsInCell,ptsInCell.data(),locInReal);
auto myJacobian = [&gl,nbPtsInCell,ptsInCell](const std::vector<double>& x, const std::vector<double>&, INTERP_KERNEL::DenseMatrix& jacobian)
{
- MEDCouplingGaussLocalization mygl(gl.getType(),gl.getRefCoords(),x,{1.0});
+ MEDCouplingGaussLocalization const mygl(gl.getType(),gl.getRefCoords(),x,{1.0});
MCAuto<DataArrayDouble> shapeFunc = mygl.getDerivativeOfShapeFunctionValues();
for(std::size_t i = 0 ; i < 3 ; ++i)
for(std::size_t j = 0 ; j < 3 ; ++j)
std::function<void(const MEDCouplingGaussLocalization&, const std::vector<mcIdType>&)> customFunc)
{
const double *coordsOfMesh( umesh->getCoords()->begin() );
- MEDCouplingNormalizedUnstructuredMesh<3,3> mesh_wrapper(umesh);
- BBTreeStandAlone<3,mcIdType> tree( INTERP_KERNEL::BuildBBTree( mesh_wrapper ) );
+ MEDCouplingNormalizedUnstructuredMesh<3,3> const mesh_wrapper(umesh);
+ BBTreeStandAlone<3,mcIdType> tree( (INTERP_KERNEL::BuildBBTree( mesh_wrapper )) );
for(mcIdType iPt = 0 ; iPt < nbOfPts ; ++iPt)
{
std::vector<mcIdType> elems;
bool found(false);
for(auto cellId = elems.cbegin() ; cellId != elems.cend() && !found ; ++cellId)
{
- INTERP_KERNEL::NormalizedCellType gt( umesh->getTypeOfCell(*cellId) );
+ INTERP_KERNEL::NormalizedCellType const gt( umesh->getTypeOfCell(*cellId) );
std::vector<mcIdType> conn;
umesh->getNodeIdsOfCell(*cellId,conn);
MCAuto<DataArrayDouble> refCoo( MEDCouplingGaussLocalization::GetDefaultReferenceCoordinatesOf(gt) );
- std::vector<double> refCooCpp(refCoo->begin(),refCoo->end());
+ std::vector<double> const refCooCpp(refCoo->begin(),refCoo->end());
std::vector<double> gsCoo(ptsCoo + iPt*3,ptsCoo + (iPt+1)*3);
MEDCouplingGaussLocalization gl(gt,refCooCpp,{0,0,0},{1.});
std::vector<double> ptsInCell; ptsInCell.reserve(conn.size()*gl.getDimension());
const MEDCouplingUMesh *MEDCouplingFieldDiscretizationOnNodesFE::checkConfig3D(const MEDCouplingMesh *mesh) const
{
- const MEDCouplingUMesh *umesh( dynamic_cast<const MEDCouplingUMesh *>(mesh) );
+ const auto *umesh( dynamic_cast<const MEDCouplingUMesh *>(mesh) );
if( !umesh )
THROW_IK_EXCEPTION("getValueOn : not implemented yet for type != MEDCouplingUMesh !");
if(umesh->getSpaceDimension() != 3 || umesh->getMeshDimension() != 3)
{
if(!arr || !arr->isAllocated())
throw INTERP_KERNEL::Exception("getValueOnMulti : input array is null or not allocated !");
- mcIdType nbOfRows=getNumberOfMeshPlaces(mesh);
+ mcIdType const nbOfRows=getNumberOfMeshPlaces(mesh);
if(arr->getNumberOfTuples()!=nbOfRows)
{
THROW_IK_EXCEPTION( "getValueOnMulti : input array does not have correct number of tuples ! Excepted " << nbOfRows << " having " << arr->getNumberOfTuples() << " !")
}
const MEDCouplingUMesh *umesh = checkConfig3D(mesh);
- std::size_t nbCompo( arr->getNumberOfComponents() );
+ std::size_t const nbCompo( arr->getNumberOfComponents() );
MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
ret->alloc(nbOfTargetPoints,nbCompo);
double *res( ret->getPointer() );
ret->alloc(nbOfPoints,3);
double *retPtr(ret->getPointer() );
- auto arrayFeeder = [&retPtr](const MEDCouplingGaussLocalization& gl, const std::vector<mcIdType>& conn)
+ auto arrayFeeder = [&retPtr](const MEDCouplingGaussLocalization& gl, const std::vector<mcIdType>& /*conn*/)
{
std::vector<double> resVector( gl.getGaussCoords() );
{
#pragma once
+#include "MEDCoupling.hxx"
+#include "MCAuto.hxx"
+#include "MCType.hxx"
#include "MEDCouplingFieldDiscretization.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
+#include "MEDCouplingGaussLocalization.hxx"
#include <functional>
+#include <string>
+#include <ostream>
+#include <vector>
namespace MEDCoupling
{
// Author : Anthony Geay (EDF R&D)
#include "MEDCouplingFieldDouble.hxx"
-#include "MEDCouplingFieldTemplate.hxx"
#include "MEDCouplingFieldT.txx"
+#include "MCAuto.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingField.hxx"
+#include "MCIdType.hxx"
+#include "CellModel.hxx"
+#include "MEDCouplingFieldTemplate.hxx"
#include "MEDCouplingFieldInt32.hxx"
#include "MEDCouplingFieldInt64.hxx"
#include "MEDCouplingFieldFloat.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingPointSet.hxx"
+#include "MEDCouplingTraits.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
+#include "MEDCouplingGaussLocalization.hxx"
+#include "MEDCouplingMemArray.hxx"
#include "MEDCouplingUMesh.hxx"
#include "MEDCouplingTimeDiscretization.hxx"
#include "MEDCouplingFieldDiscretization.hxx"
-#include "MCAuto.txx"
#include "MEDCouplingVoronoi.hxx"
-#include "MEDCouplingNatureOfField.hxx"
-#include "MEDCouplingMemArray.txx"
+#include "MCAuto.txx"
#include "InterpKernelAutoPtr.hxx"
#include "InterpKernelGaussCoords.hxx"
+#include "NormalizedGeometricTypes"
+#include <cstddef>
+#include <set>
#include <sstream>
#include <limits>
#include <algorithm>
#include <functional>
+#include <string>
+#include <vector>
using namespace MEDCoupling;
MEDCouplingFieldDouble *MEDCouplingFieldDouble::nodeToCellDiscretization() const
{
checkConsistencyLight();
- TypeOfField tf(getTypeOfField());
+ TypeOfField const tf(getTypeOfField());
if(tf!=ON_NODES)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::nodeToCellDiscretization : this field is expected to be on ON_NODES !");
MCAuto<MEDCouplingFieldDouble> ret(clone(false));
MCAuto<MEDCouplingFieldDiscretizationP0> nsp(new MEDCouplingFieldDiscretizationP0);
ret->setDiscretization(nsp);
const MEDCouplingMesh *m(getMesh());//m is non empty thanks to checkConsistencyLight call
- mcIdType nbCells=ToIdType(m->getNumberOfCells());
+ mcIdType const nbCells=ToIdType(m->getNumberOfCells());
std::vector<DataArrayDouble *> arrs(getArrays());
- std::size_t sz(arrs.size());
+ std::size_t const sz(arrs.size());
std::vector< MCAuto<DataArrayDouble> > outArrsSafe(sz); std::vector<DataArrayDouble *> outArrs(sz);
for(std::size_t j=0;j<sz;j++)
{
- std::size_t nbCompo(arrs[j]->getNumberOfComponents());
+ std::size_t const nbCompo(arrs[j]->getNumberOfComponents());
outArrsSafe[j]=DataArrayDouble::New(); outArrsSafe[j]->alloc(nbCells,nbCompo);
outArrsSafe[j]->copyStringInfoFrom(*arrs[j]);
outArrs[j]=outArrsSafe[j];
std::vector<mcIdType> nodeIds;
m->getNodeIdsOfCell(i,nodeIds);
std::fill(pt,pt+nbCompo,0.);
- std::size_t nbNodesInCell(nodeIds.size());
+ std::size_t const nbNodesInCell(nodeIds.size());
for(std::size_t k=0;k<nbNodesInCell;k++)
std::transform(srcPt+nodeIds[k]*nbCompo,srcPt+(nodeIds[k]+1)*nbCompo,pt,pt,std::plus<double>());
if(nbNodesInCell!=0)
MEDCouplingFieldDouble *MEDCouplingFieldDouble::cellToNodeDiscretization() const
{
checkConsistencyLight();
- TypeOfField tf(getTypeOfField());
+ TypeOfField const tf(getTypeOfField());
if(tf!=ON_CELLS)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::cellToNodeDiscretization : this field is expected to be on ON_CELLS !");
MCAuto<MEDCouplingFieldDouble> ret(clone(false));
MCAuto<DataArrayIdType> rn(DataArrayIdType::New()),rni(DataArrayIdType::New());
m->getReverseNodalConnectivity(rn,rni);
MCAuto<DataArrayIdType> rni2(rni->deltaShiftIndex());
- MCAuto<DataArrayDouble> rni3(rni2->convertToDblArr()); rni2=0;
+ MCAuto<DataArrayDouble> rni3(rni2->convertToDblArr()); rni2=nullptr;
std::vector<DataArrayDouble *> arrs(getArrays());
- std::size_t sz(arrs.size());
+ std::size_t const sz(arrs.size());
std::vector< MCAuto<DataArrayDouble> > outArrsSafe(sz); std::vector<DataArrayDouble *> outArrs(sz);
for(std::size_t j=0;j<sz;j++)
{
MCAuto<DataArrayDouble> tmp(arrs[j]->selectByTupleIdSafe(rn->begin(),rn->end()));
- outArrsSafe[j]=(tmp->accumulatePerChunck(rni->begin(),rni->end())); tmp=0;
+ outArrsSafe[j]=(tmp->accumulatePerChunck(rni->begin(),rni->end())); tmp=nullptr;
outArrsSafe[j]->divideEqual(rni3);
outArrsSafe[j]->copyStringInfoFrom(*arrs[j]);
outArrs[j]=outArrsSafe[j];
std::string MEDCouplingFieldDouble::writeVTK(const std::string& fileName, bool isBinary) const
{
- std::vector<const MEDCouplingFieldDouble *> fs(1,this);
+ std::vector<const MEDCouplingFieldDouble *> const fs(1,this);
return MEDCouplingFieldDouble::WriteVTK(fileName,fs,isBinary);
}
{
if(!MEDCouplingField::areCompatibleForMerge(other))
return false;
- const MEDCouplingFieldDouble *otherC(dynamic_cast<const MEDCouplingFieldDouble *>(other));
+ const auto *otherC(dynamic_cast<const MEDCouplingFieldDouble *>(other));
if(!otherC)
return false;
if(!timeDiscr()->areCompatible(otherC->timeDiscr()))
*/
void MEDCouplingFieldDouble::renumberNodes(const mcIdType *old2NewBg, double eps)
{
- const MEDCouplingPointSet *meshC=dynamic_cast<const MEDCouplingPointSet *>(_mesh);
+ const auto *meshC=dynamic_cast<const MEDCouplingPointSet *>(_mesh);
if(!meshC)
throw INTERP_KERNEL::Exception("Invalid mesh to apply renumberNodes on it !");
- mcIdType nbOfNodes=meshC->getNumberOfNodes();
+ mcIdType const nbOfNodes=meshC->getNumberOfNodes();
MCAuto<MEDCouplingPointSet> meshC2((MEDCouplingPointSet *)meshC->deepCopy());
- mcIdType newNbOfNodes=*std::max_element(old2NewBg,old2NewBg+nbOfNodes)+1;
+ mcIdType const newNbOfNodes=*std::max_element(old2NewBg,old2NewBg+nbOfNodes)+1;
renumberNodesWithoutMesh(old2NewBg,newNbOfNodes,eps);
meshC2->renumberNodes(old2NewBg,newNbOfNodes);
setMesh(meshC2);
throw INTERP_KERNEL::Exception("Expecting a spatial discretization to be able to operate a renumbering !");
std::vector<DataArrayDouble *> arrays;
timeDiscr()->getArrays(arrays);
- for(std::vector<DataArrayDouble *>::const_iterator iter=arrays.begin();iter!=arrays.end();iter++)
- if(*iter)
- _type->renumberValuesOnNodes(eps,old2NewBg,newNbOfNodes,*iter);
+ for(auto array : arrays)
+ if(array)
+ _type->renumberValuesOnNodes(eps,old2NewBg,newNbOfNodes,array);
}
/*!
*/
DataArrayIdType *MEDCouplingFieldDouble::findIdsInRange(double vmin, double vmax) const
{
- if(getArray()==0)
+ if(getArray()==nullptr)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::findIdsInRange : no default array set !");
return getArray()->findIdsInRange(vmin,vmax);
}
{
MCAuto<MEDCouplingFieldTemplate> tmp(MEDCouplingFieldTemplate::New(*self));
int t1,t2;
- double t0(self->getTime(t1,t2));
+ double const t0(self->getTime(t1,t2));
MCAuto<typename Traits<U>::FieldType > ret(Traits<U>::FieldType::New(*tmp,self->getTimeDiscretization()));
ret->setTime(t0,t1,t2);
if(self->getArray())
*/
double MEDCouplingFieldDouble::accumulate(int compId) const
{
- if(getArray()==0)
+ if(getArray()==nullptr)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::accumulate : no default array defined !");
return getArray()->accumulate(compId);
}
*/
void MEDCouplingFieldDouble::accumulate(double *res) const
{
- if(getArray()==0)
+ if(getArray()==nullptr)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::accumulate : no default array defined !");
getArray()->accumulate(res);
}
timeDiscr()->getArrays(arrays);
double ret(-std::numeric_limits<double>::max());
bool isExistingArr=false;
- for(std::vector<DataArrayDouble *>::const_iterator iter=arrays.begin();iter!=arrays.end();iter++)
+ for(auto array : arrays)
{
- if(*iter)
+ if(array)
{
isExistingArr=true;
mcIdType loc;
- ret=std::max(ret,(*iter)->getMaxValue(loc));
+ ret=std::max(ret,array->getMaxValue(loc));
}
}
if(!isExistingArr)
timeDiscr()->getArrays(arrays);
double ret(-std::numeric_limits<double>::max());
bool isExistingArr=false;
- tupleIds=0;
+ tupleIds=nullptr;
MCAuto<DataArrayIdType> ret1;
- for(std::vector<DataArrayDouble *>::const_iterator iter=arrays.begin();iter!=arrays.end();iter++)
+ for(auto array : arrays)
{
- if(*iter)
+ if(array)
{
isExistingArr=true;
DataArrayIdType *tmp;
- ret=std::max(ret,(*iter)->getMaxValue2(tmp));
- MCAuto<DataArrayIdType> tmpSafe(tmp);
+ ret=std::max(ret,array->getMaxValue2(tmp));
+ MCAuto<DataArrayIdType> const tmpSafe(tmp);
if(!((const DataArrayIdType *)ret1))
ret1=tmpSafe;
}
timeDiscr()->getArrays(arrays);
double ret(std::numeric_limits<double>::max());
bool isExistingArr=false;
- for(std::vector<DataArrayDouble *>::const_iterator iter=arrays.begin();iter!=arrays.end();iter++)
+ for(auto array : arrays)
{
- if(*iter)
+ if(array)
{
isExistingArr=true;
mcIdType loc;
- ret=std::min(ret,(*iter)->getMinValue(loc));
+ ret=std::min(ret,array->getMinValue(loc));
}
}
if(!isExistingArr)
timeDiscr()->getArrays(arrays);
double ret(-std::numeric_limits<double>::max());
bool isExistingArr=false;
- tupleIds=0;
+ tupleIds=nullptr;
MCAuto<DataArrayIdType> ret1;
- for(std::vector<DataArrayDouble *>::const_iterator iter=arrays.begin();iter!=arrays.end();iter++)
+ for(auto array : arrays)
{
- if(*iter)
+ if(array)
{
isExistingArr=true;
DataArrayIdType *tmp;
- ret=std::max(ret,(*iter)->getMinValue2(tmp));
- MCAuto<DataArrayIdType> tmpSafe(tmp);
+ ret=std::max(ret,array->getMinValue2(tmp));
+ MCAuto<DataArrayIdType> const tmpSafe(tmp);
if(!((const DataArrayIdType *)ret1))
ret1=tmpSafe;
}
*/
double MEDCouplingFieldDouble::getAverageValue() const
{
- if(getArray()==0)
+ if(getArray()==nullptr)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::getAverageValue : no default array defined !");
return getArray()->getAverageValue();
}
*/
double MEDCouplingFieldDouble::norm2() const
{
- if(getArray()==0)
+ if(getArray()==nullptr)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::norm2 : no default array defined !");
return getArray()->norm2();
}
*/
void MEDCouplingFieldDouble::getWeightedAverageValue(double *res, bool isWAbs) const
{
- if(getArray()==0)
+ if(getArray()==nullptr)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::getWeightedAverageValue : no default array defined !");
MCAuto<MEDCouplingFieldDouble> w=buildMeasureField(isWAbs);
- double deno=w->getArray()->accumulate((std::size_t)0);
+ double const deno=w->getArray()->accumulate((std::size_t)0);
MCAuto<DataArrayDouble> arr=getArray()->deepCopy();
arr->multiplyEqual(w->getArray());
arr->accumulate(res);
- std::size_t nCompo = getArray()->getNumberOfComponents();
+ std::size_t const nCompo = getArray()->getNumberOfComponents();
std::transform(res,res+nCompo,res,std::bind(std::multiplies<double>(),std::placeholders::_1,1./deno));
}
*/
double MEDCouplingFieldDouble::getWeightedAverageValue(int compId, bool isWAbs) const
{
- std::size_t nbComps=getArray()->getNumberOfComponents();
+ std::size_t const nbComps=getArray()->getNumberOfComponents();
if(compId<0 || compId>=ToIdType(nbComps))
{
std::ostringstream oss; oss << "MEDCouplingFieldDouble::getWeightedAverageValue : Invalid compId specified : No such nb of components ! Should be in [0," << nbComps << ") !";
throw INTERP_KERNEL::Exception("No mesh underlying this field to perform normL1 !");
if(_type.isNull())
throw INTERP_KERNEL::Exception("No spatial discretization underlying this field to perform normL1 !");
- std::size_t nbComps=getArray()->getNumberOfComponents();
+ std::size_t const nbComps=getArray()->getNumberOfComponents();
if(compId<0 || compId>=ToIdType(nbComps))
{
std::ostringstream oss; oss << "MEDCouplingFieldDouble::normL1 : Invalid compId specified : No such nb of components ! Should be in [0," << nbComps << ") !";
throw INTERP_KERNEL::Exception("No mesh underlying this field to perform normL2");
if(_type.isNull())
throw INTERP_KERNEL::Exception("No spatial discretization underlying this field to perform normL2 !");
- std::size_t nbComps=getArray()->getNumberOfComponents();
+ std::size_t const nbComps=getArray()->getNumberOfComponents();
if(compId<0 || compId>=ToIdType(nbComps))
{
std::ostringstream oss; oss << "MEDCouplingFieldDouble::normL2 : Invalid compId specified : No such nb of components ! Should be in [0," << nbComps << ") !";
*/
double MEDCouplingFieldDouble::normMax(int compId) const
{
- if(getArray()==0)
+ if(getArray()==nullptr)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::normMax : no default array defined !");
- std::size_t nbComps=getArray()->getNumberOfComponents();
+ std::size_t const nbComps=getArray()->getNumberOfComponents();
if(compId<0 || compId>=ToIdType(nbComps))
{
std::ostringstream oss; oss << "MEDCouplingFieldDouble::normMax : Invalid compId specified : No such nb of components ! Should be in [0," << nbComps << ") !";
*/
void MEDCouplingFieldDouble::normMax(double *res) const
{
- if(getArray()==0)
+ if(getArray()==nullptr)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::normMax : no default array defined !");
getArray()->normMaxPerComponent(res);
}
throw INTERP_KERNEL::Exception("No mesh underlying this field to perform integral");
if(_type.isNull())
throw INTERP_KERNEL::Exception("No spatial discretization underlying this field to perform integral !");
- std::size_t nbComps=getArray()->getNumberOfComponents();
+ std::size_t const nbComps=getArray()->getNumberOfComponents();
if(compId<0 || compId>=ToIdType(nbComps))
{
std::ostringstream oss; oss << "MEDCouplingFieldDouble::integral : Invalid compId specified : No such nb of components ! Should be in [0," << nbComps << ") !";
*/
void MEDCouplingFieldDouble::getValueOn(const double *spaceLoc, double time, double *res) const
{
- std::vector< const DataArrayDouble *> arrs=timeDiscr()->getArraysForTime(time);
+ std::vector< const DataArrayDouble *> const arrs=timeDiscr()->getArraysForTime(time);
if(!_mesh)
throw INTERP_KERNEL::Exception("No mesh underlying this field to perform getValueOn");
if(_type.isNull())
throw INTERP_KERNEL::Exception("No spatial discretization underlying this field to perform getValueOn !");
std::vector<double> res2;
- for(std::vector< const DataArrayDouble *>::const_iterator iter=arrs.begin();iter!=arrs.end();iter++)
+ for(auto arr : arrs)
{
- std::size_t sz=res2.size();
- res2.resize(sz+(*iter)->getNumberOfComponents());
- _type->getValueOn(*iter,_mesh,spaceLoc,&res2[sz]);
+ std::size_t const sz=res2.size();
+ res2.resize(sz+arr->getNumberOfComponents());
+ _type->getValueOn(arr,_mesh,spaceLoc,&res2[sz]);
}
timeDiscr()->getValueForTime(time,res2,res);
}
throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::operator= : no mesh defined !");
if(_type.isNull())
throw INTERP_KERNEL::Exception("No spatial discretization underlying this field to perform operator = !");
- mcIdType nbOfTuple=_type->getNumberOfTuples(_mesh);
+ mcIdType const nbOfTuple=_type->getNumberOfTuples(_mesh);
timeDiscr()->setOrCreateUniformValueOnAllComponents(nbOfTuple,value);
return *this;
}
throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::applyFunc : no mesh defined !");
if(_type.isNull())
throw INTERP_KERNEL::Exception("No spatial discretization underlying this field to perform applyFunc !");
- mcIdType nbOfTuple=_type->getNumberOfTuples(_mesh);
+ mcIdType const nbOfTuple=_type->getNumberOfTuples(_mesh);
timeDiscr()->setUniformValue(nbOfTuple,nbOfComp,val);
}
*/
std::size_t MEDCouplingFieldDouble::getNumberOfComponents() const
{
- if(getArray()==0)
+ if(getArray()==nullptr)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::getNumberOfComponents : No array specified !");
return getArray()->getNumberOfComponents();
}
*/
mcIdType MEDCouplingFieldDouble::getNumberOfValues() const
{
- if(getArray()==0)
+ if(getArray()==nullptr)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::getNumberOfValues : No array specified !");
return getArray()->getNbOfElems();
}
*/
void MEDCouplingFieldDouble::changeUnderlyingMesh(const MEDCouplingMesh *other, int levOfCheck, double precOnMesh, double eps)
{
- if(_mesh==0 || other==0)
+ if(_mesh==nullptr || other==nullptr)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::changeUnderlyingMesh : is expected to operate on not null meshes !");
- DataArrayIdType *cellCor=0,*nodeCor=0;
+ DataArrayIdType *cellCor=nullptr,*nodeCor=nullptr;
other->checkGeoEquivalWith(_mesh,levOfCheck,precOnMesh,cellCor,nodeCor);
MCAuto<DataArrayIdType> cellCor2(cellCor),nodeCor2(nodeCor);
if(cellCor)
*/
bool MEDCouplingFieldDouble::mergeNodes(double eps, double epsOnVals)
{
- const MEDCouplingPointSet *meshC=dynamic_cast<const MEDCouplingPointSet *>(_mesh);
+ const auto *meshC=dynamic_cast<const MEDCouplingPointSet *>(_mesh);
if(!meshC)
throw INTERP_KERNEL::Exception("Invalid support mesh to apply mergeNodes on it : must be a MEDCouplingPointSet one !");
if(_type.isNull())
return ret;
std::vector<DataArrayDouble *> arrays;
timeDiscr()->getArrays(arrays);
- for(std::vector<DataArrayDouble *>::const_iterator iter=arrays.begin();iter!=arrays.end();iter++)
- if(*iter)
- _type->renumberValuesOnNodes(epsOnVals,arr->getConstPointer(),meshC2->getNumberOfNodes(),*iter);
+ for(auto array : arrays)
+ if(array)
+ _type->renumberValuesOnNodes(epsOnVals,arr->getConstPointer(),meshC2->getNumberOfNodes(),array);
setMesh(meshC2);
return true;
}
*/
bool MEDCouplingFieldDouble::mergeNodesCenter(double eps, double epsOnVals)
{
- const MEDCouplingPointSet *meshC=dynamic_cast<const MEDCouplingPointSet *>(_mesh);
+ const auto *meshC=dynamic_cast<const MEDCouplingPointSet *>(_mesh);
if(!meshC)
throw INTERP_KERNEL::Exception("Invalid support mesh to apply mergeNodes on it : must be a MEDCouplingPointSet one !");
if(_type.isNull())
return ret;
std::vector<DataArrayDouble *> arrays;
timeDiscr()->getArrays(arrays);
- for(std::vector<DataArrayDouble *>::const_iterator iter=arrays.begin();iter!=arrays.end();iter++)
- if(*iter)
- _type->renumberValuesOnNodes(epsOnVals,arr->getConstPointer(),meshC2->getNumberOfNodes(),*iter);
+ for(auto array : arrays)
+ if(array)
+ _type->renumberValuesOnNodes(epsOnVals,arr->getConstPointer(),meshC2->getNumberOfNodes(),array);
setMesh(meshC2);
return true;
}
*/
bool MEDCouplingFieldDouble::zipCoords(double epsOnVals)
{
- const MEDCouplingPointSet *meshC=dynamic_cast<const MEDCouplingPointSet *>(_mesh);
+ const auto *meshC=dynamic_cast<const MEDCouplingPointSet *>(_mesh);
if(!meshC)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::zipCoords : Invalid support mesh to apply zipCoords on it : must be a MEDCouplingPointSet one !");
if(_type.isNull())
throw INTERP_KERNEL::Exception("No spatial discretization underlying this field to perform zipCoords !");
MCAuto<MEDCouplingPointSet> meshC2((MEDCouplingPointSet *)meshC->deepCopy());
- mcIdType oldNbOfNodes=meshC2->getNumberOfNodes();
+ mcIdType const oldNbOfNodes=meshC2->getNumberOfNodes();
MCAuto<DataArrayIdType> arr=meshC2->zipCoordsTraducer();
if(meshC2->getNumberOfNodes()!=oldNbOfNodes)
{
std::vector<DataArrayDouble *> arrays;
timeDiscr()->getArrays(arrays);
- for(std::vector<DataArrayDouble *>::const_iterator iter=arrays.begin();iter!=arrays.end();iter++)
- if(*iter)
- _type->renumberValuesOnNodes(epsOnVals,arr->getConstPointer(),meshC2->getNumberOfNodes(),*iter);
+ for(auto array : arrays)
+ if(array)
+ _type->renumberValuesOnNodes(epsOnVals,arr->getConstPointer(),meshC2->getNumberOfNodes(),array);
setMesh(meshC2);
return true;
}
*/
bool MEDCouplingFieldDouble::zipConnectivity(int compType, double epsOnVals)
{
- const MEDCouplingUMesh *meshC=dynamic_cast<const MEDCouplingUMesh *>(_mesh);
+ const auto *meshC=dynamic_cast<const MEDCouplingUMesh *>(_mesh);
if(!meshC)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::zipConnectivity : Invalid support mesh to apply zipCoords on it : must be a MEDCouplingPointSet one !");
if(_type.isNull())
throw INTERP_KERNEL::Exception("No spatial discretization underlying this field to perform zipConnectivity !");
MCAuto<MEDCouplingUMesh> meshC2((MEDCouplingUMesh *)meshC->deepCopy());
- mcIdType oldNbOfCells(meshC2->getNumberOfCells());
+ mcIdType const oldNbOfCells(meshC2->getNumberOfCells());
MCAuto<DataArrayIdType> arr=meshC2->zipConnectivityTraducer(compType);
if(meshC2->getNumberOfCells()!=oldNbOfCells)
{
std::vector<DataArrayDouble *> arrays;
timeDiscr()->getArrays(arrays);
- for(std::vector<DataArrayDouble *>::const_iterator iter=arrays.begin();iter!=arrays.end();iter++)
- if(*iter)
- _type->renumberValuesOnCells(epsOnVals,meshC,arr->getConstPointer(),ToIdType(meshC2->getNumberOfCells()),*iter);
+ for(auto array : arrays)
+ if(array)
+ _type->renumberValuesOnCells(epsOnVals,meshC,arr->getConstPointer(),ToIdType(meshC2->getNumberOfCells()),array);
setMesh(meshC2);
return true;
}
const MCAuto<MEDCouplingUMesh> umesh(mesh->buildUnstructured());
MCAuto<MEDCouplingFieldDouble> ret(clone(false));
ret->setMesh(umesh);
- DataArrayIdType *cellIds=0;
+ DataArrayIdType *cellIds=nullptr;
MCAuto<MEDCouplingUMesh> mesh2=umesh->buildSlice3D(origin,vec,eps,cellIds);
- MCAuto<DataArrayIdType> cellIds2=cellIds;
+ MCAuto<DataArrayIdType> const cellIds2=cellIds;
ret->setMesh(mesh2);
- MCAuto<DataArrayIdType> tupleIds=computeTupleIdsToSelectFromCellIds(cellIds->begin(),cellIds->end());
+ MCAuto<DataArrayIdType> const tupleIds=computeTupleIdsToSelectFromCellIds(cellIds->begin(),cellIds->end());
std::vector<DataArrayDouble *> arrays;
timeDiscr()->getArrays(arrays);
int i=0;
throw INTERP_KERNEL::Exception("No underlying mesh on this field to perform simplexize !");
if(_type.isNull())
throw INTERP_KERNEL::Exception("No spatial discretization underlying this field to perform simplexize !");
- std::size_t oldNbOfCells=_mesh->getNumberOfCells();
+ std::size_t const oldNbOfCells=_mesh->getNumberOfCells();
MCAuto<MEDCouplingMesh> meshC2(_mesh->deepCopy());
MCAuto<DataArrayIdType> arr=meshC2->simplexize(policy);
- std::size_t newNbOfCells=meshC2->getNumberOfCells();
+ std::size_t const newNbOfCells=meshC2->getNumberOfCells();
if(oldNbOfCells==newNbOfCells)
return false;
std::vector<DataArrayDouble *> arrays;
timeDiscr()->getArrays(arrays);
- for(std::vector<DataArrayDouble *>::const_iterator iter=arrays.begin();iter!=arrays.end();iter++)
- if(*iter)
- _type->renumberValuesOnCellsR(_mesh,arr->getConstPointer(),ToIdType(arr->getNbOfElems()),*iter);
+ for(auto array : arrays)
+ if(array)
+ _type->renumberValuesOnCellsR(_mesh,arr->getConstPointer(),ToIdType(arr->getNbOfElems()),array);
setMesh(meshC2);
return true;
}
if(!mesh)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::convertQuadraticCellsToLinear : null mesh !");
MCAuto<MEDCouplingUMesh> umesh(mesh->buildUnstructured());
- std::set<INTERP_KERNEL::NormalizedCellType> gt(umesh->getAllGeoTypes());
+ std::set<INTERP_KERNEL::NormalizedCellType> const gt(umesh->getAllGeoTypes());
MCAuto<MEDCouplingFieldDouble> ret(MEDCouplingFieldDouble::New(ON_GAUSS_PT));
//
const MEDCouplingFieldDiscretization *disc(getDiscretization());
- const MEDCouplingFieldDiscretizationGauss *disc2(dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc));
+ const auto *disc2(dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc));
if(!disc2)
throw INTERP_KERNEL::Exception("convertQuadraticCellsToLinear : Not a ON_GAUSS_PT field");
- std::set<INTERP_KERNEL::NormalizedCellType> gt2(umesh->getAllGeoTypes());
+ std::set<INTERP_KERNEL::NormalizedCellType> const gt2(umesh->getAllGeoTypes());
std::vector< MCAuto<DataArrayIdType> > cellIdsV;
std::vector< MCAuto<MEDCouplingUMesh> > meshesV;
std::vector< MEDCouplingGaussLocalization > glV;
bool isZipReq(false);
- for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=gt.begin();it!=gt.end();it++)
+ for(auto it : gt)
{
- const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(*it));
- MCAuto<DataArrayIdType> cellIds(umesh->giveCellsWithType(*it));
+ const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(it));
+ MCAuto<DataArrayIdType> cellIds(umesh->giveCellsWithType(it));
cellIdsV.push_back(cellIds);
MCAuto<MEDCouplingUMesh> part(umesh->buildPartOfMySelf(cellIds->begin(),cellIds->end()));
- mcIdType id(disc2->getGaussLocalizationIdOfOneType(*it));
+ mcIdType const id(disc2->getGaussLocalizationIdOfOneType(it));
const MEDCouplingGaussLocalization& gl(disc2->getGaussLocalization(id));
if(!cm.isQuadratic())
{
{
isZipReq=true;
part->convertQuadraticCellsToLinear();
- INTERP_KERNEL::GaussInfo gi(*it,gl.getGaussCoords(),gl.getNumberOfGaussPt(),gl.getRefCoords(),gl.getNumberOfPtsInRefCell());
- INTERP_KERNEL::GaussInfo gi2(gi.convertToLinear());
- MEDCouplingGaussLocalization gl2(gi2.getGeoType(),gi2.getRefCoords(),gi2.getGaussCoords(),gl.getWeights());
+ INTERP_KERNEL::GaussInfo const gi(it,gl.getGaussCoords(),gl.getNumberOfGaussPt(),gl.getRefCoords(),gl.getNumberOfPtsInRefCell());
+ INTERP_KERNEL::GaussInfo const gi2(gi.convertToLinear());
+ MEDCouplingGaussLocalization const gl2(gi2.getGeoType(),gi2.getRefCoords(),gi2.getGaussCoords(),gl.getWeights());
glV.push_back(gl2);
}
meshesV.push_back(part);
umesh->zipCoords();
ret->setArray(const_cast<DataArrayDouble *>(getArray()));
ret->setMesh(umesh);
- for(std::vector< MEDCouplingGaussLocalization >::const_iterator it=glV.begin();it!=glV.end();it++)
- ret->setGaussLocalizationOnType((*it).getType(),(*it).getRefCoords(),(*it).getGaussCoords(),(*it).getWeights());
+ for(const auto & it : glV)
+ ret->setGaussLocalizationOnType(it.getType(),it.getRefCoords(),it.getGaussCoords(),it.getWeights());
ret->copyAllTinyAttrFrom(this);
ret->checkConsistencyLight();
return ret;
std::vector< MCAuto<MEDCouplingUMesh> > ms(a.size());
std::vector< const MEDCouplingUMesh *> ms2(a.size());
std::vector< const MEDCouplingTimeDiscretization *> tds(a.size());
- std::vector< const MEDCouplingFieldDouble *>::const_iterator it=a.begin();
+ auto it=a.begin();
std::vector<const MEDCouplingFieldDiscretization *> fds(a.size());
const MEDCouplingFieldDouble *ref((*it++));
if(!ref)
if(a[i]->getMesh())
{ ms[i]=a[i]->getMesh()->buildUnstructured(); ms2[i]=ms[i]; }
else
- { ms[i]=0; ms2[i]=0; }
+ { ms[i]=nullptr; ms2[i]=nullptr; }
tds[i]=a[i]->timeDiscr();
fds[i]=a[i]->getDiscretization();
}
throw INTERP_KERNEL::Exception("Fields are not compatible. Unable to apply DotFields on them! Check support mesh, and spatial and time discretisation.");
MEDCouplingTimeDiscretization *td(f1->timeDiscr()->dot(f2->timeDiscr()));
td->copyTinyAttrFrom(*f1->timeDiscr());
- MEDCouplingFieldDouble *ret(new MEDCouplingFieldDouble(NoNature,td,f1->_type->clone()));
+ auto *ret(new MEDCouplingFieldDouble(NoNature,td,f1->_type->clone()));
ret->setMesh(f1->getMesh());
return ret;
}
{
if(fs.empty())
return std::string();
- std::size_t nfs=fs.size();
+ std::size_t const nfs=fs.size();
if(!fs[0])
throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::WriteVTK : 1st instance of field is NULL !");
const MEDCouplingMesh *m=fs[0]->getMesh();
for(std::size_t i=0;i<nfs;i++)
{
const MEDCouplingFieldDouble *cur=fs[i];
- std::string name(cur->getName());
+ std::string const name(cur->getName());
if(name.empty())
{
std::ostringstream oss; oss << "MEDCouplingFieldDouble::WriteVTK : Field in pos #" << i << " has no name !";
throw INTERP_KERNEL::Exception(oss.str());
}
- TypeOfField typ=cur->getTypeOfField();
+ TypeOfField const typ=cur->getTypeOfField();
if(typ==ON_CELLS)
cur->getArray()->writeVTK(coss,8,cur->getName(),byteArr);
else if(typ==ON_NODES)
MCAuto<MEDCouplingFieldDouble> fieldToWO;
const MEDCouplingMesh *inpMeshBase(getMesh());
MCAuto<MEDCouplingUMesh> inpMesh(inpMeshBase->buildUnstructured());
- std::string meshName(inpMesh->getName());
+ std::string const meshName(inpMesh->getName());
if(!inpMesh->isPresenceOfQuadratic())
fieldToWO=clone(false);
else
inpMeshBase=fieldToWO->getMesh();
inpMesh=inpMeshBase->buildUnstructured();
}
- mcIdType nbCells(inpMesh->getNumberOfCells());
+ mcIdType const nbCells(inpMesh->getNumberOfCells());
const MEDCouplingFieldDiscretization *disc(fieldToWO->getDiscretization());
- const MEDCouplingFieldDiscretizationGauss *disc2(dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc));
+ const auto *disc2(dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc));
if(!disc2)
throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::voronoize2D : Not a ON_GAUSS_PT field");
- mcIdType nbLocs(disc2->getNbOfGaussLocalization());
+ mcIdType const nbLocs(disc2->getNbOfGaussLocalization());
std::vector< MCAuto<MEDCouplingUMesh> > cells(nbCells);
for(mcIdType i=0;i<nbLocs;i++)
{
MCAuto<DataArrayDouble> coo2(DataArrayDouble::NewFromStdVector(coo));
coo2->rearrange(vor->getDimension());
//
- MCAuto<MEDCouplingUMesh> coo3(MEDCouplingUMesh::Build0DMeshFromCoords(coo2));
+ MCAuto<MEDCouplingUMesh> const coo3(MEDCouplingUMesh::Build0DMeshFromCoords(coo2));
//
MCAuto<MEDCouplingUMesh> vorCellsForCurDisc(vor->doIt(mesh,coo2,eps));
std::vector<mcIdType> ids;
MCAuto<MEDCouplingUMesh> subMesh(inpMesh->buildPartOfMySelf(&ids[0],&ids[0]+ids.size()));
ptsInReal=gl.localizePtsInRefCooForEachCell(vorCellsForCurDisc->getCoords(),subMesh);
}
- mcIdType nbPtsPerCell(vorCellsForCurDisc->getNumberOfNodes());
+ mcIdType const nbPtsPerCell(vorCellsForCurDisc->getNumberOfNodes());
for(mcIdType j=0;j<ToIdType(ids.size());j++)
{
MCAuto<MEDCouplingUMesh> elt(vorCellsForCurDisc->clone(false));
onCells->setTimeUnit(getTimeUnit());
{
int b,c;
- double a(getTime(b,c));
+ double const a(getTime(b,c));
onCells->setTime(a,b,c);
}
onCells->setName(getName());
{
MEDCouplingTimeDiscretizationTemplate<double> *ret(_time_discr);
if(!ret)
- return 0;
- MEDCouplingTimeDiscretization *retc(dynamic_cast<MEDCouplingTimeDiscretization *>(ret));
+ return nullptr;
+ auto *retc(dynamic_cast<MEDCouplingTimeDiscretization *>(ret));
if(!retc)
throw INTERP_KERNEL::Exception("Field Double Null invalid type of time discr !");
return retc;
{
const MEDCouplingTimeDiscretizationTemplate<double> *ret(_time_discr);
if(!ret)
- return 0;
- const MEDCouplingTimeDiscretization *retc(dynamic_cast<const MEDCouplingTimeDiscretization *>(ret));
+ return nullptr;
+ const auto *retc(dynamic_cast<const MEDCouplingTimeDiscretization *>(ret));
if(!retc)
throw INTERP_KERNEL::Exception("Field Double Null invalid type of time discr !");
return retc;
#ifndef __MEDCOUPLINGFIELDDOUBLE_HXX__
#define __MEDCOUPLINGFIELDDOUBLE_HXX__
+#include "MCType.hxx"
+#include "MCAuto.hxx"
#include "MEDCoupling.hxx"
+#include "MEDCouplingField.hxx"
+#include "MEDCouplingFieldDiscretization.hxx"
#include "MEDCouplingFieldT.hxx"
#include "MEDCouplingMemArray.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include <string>
+#include "MEDCouplingTraits.hxx"
+#include <vector>
+#include <cstddef>
+#include "MEDCouplingTimeDiscretization.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
namespace MEDCoupling
{
MEDCOUPLING_EXPORT void synchronizeTimeWithSupport();
MEDCOUPLING_EXPORT std::string advancedRepr() const;
MEDCOUPLING_EXPORT std::string writeVTK(const std::string& fileName, bool isBinary=true) const;
- MEDCOUPLING_EXPORT bool areCompatibleForMerge(const MEDCouplingField *other) const;
+ MEDCOUPLING_EXPORT bool areCompatibleForMerge(const MEDCouplingField *other) const override;
MEDCOUPLING_EXPORT bool areCompatibleForMeld(const MEDCouplingFieldDouble *other) const;
MEDCOUPLING_EXPORT void renumberNodes(const mcIdType *old2NewBg, double eps=1e-15);
MEDCOUPLING_EXPORT void renumberNodesWithoutMesh(const mcIdType *old2NewBg, mcIdType newNbOfNodes, double eps=1e-15);
MEDCOUPLING_EXPORT DataArrayIdType *findIdsInRange(double vmin, double vmax) const;
MEDCOUPLING_EXPORT MEDCouplingFieldDouble *deepCopy() const;
- MEDCOUPLING_EXPORT MEDCouplingFieldDouble *clone(bool recDeepCpy) const;
+ MEDCOUPLING_EXPORT MEDCouplingFieldDouble *clone(bool recDeepCpy) const override;
MEDCOUPLING_EXPORT MEDCouplingFieldDouble *buildNewTimeReprFromThis(TypeOfTimeDiscretization td, bool deepCpy) const;
MEDCOUPLING_EXPORT MEDCouplingFieldDouble *nodeToCellDiscretization() const;
MEDCOUPLING_EXPORT MEDCouplingFieldDouble *cellToNodeDiscretization() const;
MEDCOUPLING_EXPORT std::size_t getNumberOfComponents() const;
MEDCOUPLING_EXPORT mcIdType getNumberOfTuples() const;
MEDCOUPLING_EXPORT mcIdType getNumberOfValues() const;
- MEDCOUPLING_EXPORT void updateTime() const;
- MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDCOUPLING_EXPORT void updateTime() const override;
+ MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
//
MEDCOUPLING_EXPORT void changeUnderlyingMesh(const MEDCouplingMesh *other, int levOfCheck, double precOnMesh, double eps=1e-15);
MEDCOUPLING_EXPORT void substractInPlaceDM(const MEDCouplingFieldDouble *f, int levOfCheck, double precOnMesh, double eps=1e-15);
MEDCOUPLING_EXPORT const MEDCouplingTimeDiscretization *getTimeDiscretizationUnderGround() const { return timeDiscr(); }
MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *getTimeDiscretizationUnderGround() { return timeDiscr(); }
protected:
- ~MEDCouplingFieldDouble() { }
+ ~MEDCouplingFieldDouble() override = default;
private:
MEDCOUPLING_EXPORT MEDCouplingFieldDouble(TypeOfField type, TypeOfTimeDiscretization td);
MEDCOUPLING_EXPORT MEDCouplingFieldDouble(const MEDCouplingFieldTemplate& ft, TypeOfTimeDiscretization td);
#include "MEDCouplingFieldFloat.hxx"
#include "MEDCouplingFieldT.txx"
+#include "MEDCouplingFieldDiscretization.hxx"
+#include "MCAuto.hxx"
+#include "MCType.hxx"
#include "MEDCouplingFieldDouble.hxx"
-#include "MEDCouplingFieldInt.hxx"
+#include "MEDCouplingFieldInt32.hxx"
#include "MEDCouplingFieldInt64.hxx"
#include "MEDCouplingFieldTemplate.hxx"
#include "MEDCouplingMesh.hxx"
-#include "MEDCouplingMemArray.txx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingTimeDiscretization.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
+#include "MEDCouplingTraits.hxx"
using namespace MEDCoupling;
#define __MEDCOUPLINGFIELDFLOAT_HXX__
#include "MEDCoupling.hxx"
+#include "MEDCouplingFieldDiscretization.hxx"
#include "MEDCouplingFieldT.hxx"
-#include "MEDCouplingMemArray.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingTraits.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
+#include "MEDCouplingTimeDiscretization.hxx"
#include <string>
MEDCOUPLING_EXPORT static MEDCouplingFieldFloat *New(TypeOfField type, TypeOfTimeDiscretization td=ONE_TIME);
MEDCOUPLING_EXPORT static MEDCouplingFieldFloat *New(const MEDCouplingFieldTemplate& ft, TypeOfTimeDiscretization td=ONE_TIME);
MEDCOUPLING_EXPORT MEDCouplingFieldFloat *deepCopy() const;
- MEDCOUPLING_EXPORT MEDCouplingFieldFloat *clone(bool recDeepCpy) const;
+ MEDCOUPLING_EXPORT MEDCouplingFieldFloat *clone(bool recDeepCpy) const override;
MEDCOUPLING_EXPORT MEDCouplingFieldDouble *convertToDblField() const;
MEDCOUPLING_EXPORT MEDCouplingFieldInt32 *convertToIntField() const;
MEDCOUPLING_EXPORT MEDCouplingFieldInt64 *convertToInt64Field() const;
MEDCouplingFieldFloat(const MEDCouplingFieldFloat& other, bool deepCpy);
MEDCouplingFieldFloat(NatureOfField n, MEDCouplingTimeDiscretizationFloat *td, MEDCouplingFieldDiscretization *type);
MEDCouplingFieldFloat(const MEDCouplingFieldTemplate& ft, TypeOfTimeDiscretization td);
- ~MEDCouplingFieldFloat() { }
+ ~MEDCouplingFieldFloat() override = default;
};
}
// Author : Yann Pora (EDF R&D)
#include "MEDCouplingFieldInt32.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingFieldDiscretization.hxx"
+#include "MCAuto.hxx"
#include "MEDCouplingFieldInt64.hxx"
#include "MEDCouplingFieldT.txx"
#include "MEDCouplingFieldDouble.hxx"
#include "MEDCouplingFieldFloat.hxx"
#include "MEDCouplingFieldTemplate.hxx"
#include "MEDCouplingMesh.hxx"
-#include "MEDCouplingMemArray.txx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingTimeDiscretization.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
+#include "MEDCouplingTraits.hxx"
using namespace MEDCoupling;
{
MCAuto<MEDCouplingFieldTemplate> tmp(MEDCouplingFieldTemplate::New(*self));
int t1,t2;
- double t0(self->getTime(t1,t2));
+ double const t0(self->getTime(t1,t2));
MCAuto<typename Traits<U>::FieldType > ret(Traits<U>::FieldType::New(*tmp,self->getTimeDiscretization()));
ret->setTime(t0,t1,t2);
if(self->getArray())
MEDCouplingFieldFloat *MEDCouplingFieldInt32::convertToFloatField() const
{
return ConvertToUField<float>(this);
-}
\ No newline at end of file
+}
#pragma once
+#include "MCType.hxx"
#include "MEDCoupling.hxx"
+#include "MEDCouplingFieldDiscretization.hxx"
#include "MEDCouplingFieldT.hxx"
-#include "MEDCouplingMemArray.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingTraits.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
+#include "MEDCouplingTimeDiscretization.hxx"
#include <string>
MEDCOUPLING_EXPORT static MEDCouplingFieldInt32 *New(TypeOfField type, TypeOfTimeDiscretization td=ONE_TIME);
MEDCOUPLING_EXPORT static MEDCouplingFieldInt32 *New(const MEDCouplingFieldTemplate& ft, TypeOfTimeDiscretization td=ONE_TIME);
MEDCOUPLING_EXPORT MEDCouplingFieldInt32 *deepCopy() const;
- MEDCOUPLING_EXPORT MEDCouplingFieldInt32 *clone(bool recDeepCpy) const;
+ MEDCOUPLING_EXPORT MEDCouplingFieldInt32 *clone(bool recDeepCpy) const override;
MEDCOUPLING_EXPORT MEDCouplingFieldDouble *convertToDblField() const;
MEDCOUPLING_EXPORT MEDCouplingFieldFloat *convertToFloatField() const;
MEDCOUPLING_EXPORT MEDCouplingFieldInt64 *convertToInt64Field() const;
MEDCouplingFieldInt32(const MEDCouplingFieldInt32& other, bool deepCopy);
MEDCouplingFieldInt32(NatureOfField n, MEDCouplingTimeDiscretizationInt32 *td, MEDCouplingFieldDiscretization *type);
MEDCouplingFieldInt32(const MEDCouplingFieldTemplate& ft, TypeOfTimeDiscretization td);
- ~MEDCouplingFieldInt32() { }
+ ~MEDCouplingFieldInt32() override = default;
};
}
#include "MEDCouplingFieldInt64.hxx"
#include "MEDCouplingFieldT.txx"
+#include "MCType.hxx"
+#include "MEDCouplingFieldDiscretization.hxx"
+#include "MCAuto.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "MEDCouplingFieldTemplate.hxx"
#include "MEDCouplingMesh.hxx"
-#include "MEDCouplingMemArray.txx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingTimeDiscretization.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
using namespace MEDCoupling;
{
MCAuto<MEDCouplingFieldTemplate> tmp(MEDCouplingFieldTemplate::New(*this));
int t1,t2;
- double t0(getTime(t1,t2));
+ double const t0(getTime(t1,t2));
MCAuto<MEDCouplingFieldDouble> ret(MEDCouplingFieldDouble::New(*tmp,getTimeDiscretization()));
ret->setTime(t0,t1,t2);
if(getArray())
#pragma once
+#include "MCType.hxx"
#include "MEDCoupling.hxx"
+#include "MEDCouplingFieldDiscretization.hxx"
#include "MEDCouplingFieldT.hxx"
-#include "MEDCouplingMemArray.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
+#include "MEDCouplingTimeDiscretization.hxx"
#include <string>
MEDCOUPLING_EXPORT static MEDCouplingFieldInt64 *New(TypeOfField type, TypeOfTimeDiscretization td=ONE_TIME);
MEDCOUPLING_EXPORT static MEDCouplingFieldInt64 *New(const MEDCouplingFieldTemplate& ft, TypeOfTimeDiscretization td=ONE_TIME);
MEDCOUPLING_EXPORT MEDCouplingFieldInt64 *deepCopy() const;
- MEDCOUPLING_EXPORT MEDCouplingFieldInt64 *clone(bool recDeepCpy) const;
+ MEDCOUPLING_EXPORT MEDCouplingFieldInt64 *clone(bool recDeepCpy) const override;
MEDCOUPLING_EXPORT MEDCouplingFieldDouble *convertToDblField() const;
MEDCOUPLING_EXPORT std::string getClassName() const override { return std::string("MEDCouplingFieldInt64"); }
protected:
MEDCouplingFieldInt64(const MEDCouplingFieldInt64& other, bool deepCopy);
MEDCouplingFieldInt64(NatureOfField n, MEDCouplingTimeDiscretizationInt64 *td, MEDCouplingFieldDiscretization *type);
MEDCouplingFieldInt64(const MEDCouplingFieldTemplate& ft, TypeOfTimeDiscretization td);
- ~MEDCouplingFieldInt64() { }
+ ~MEDCouplingFieldInt64() override = default;
};
}
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingFieldOverTime.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingDefinitionTime.hxx"
#include "MEDCouplingMesh.hxx"
+#include "MEDCouplingMultiFields.hxx"
+#include "MEDCouplingRefCountObject.hxx"
#include <cmath>
+#include <iterator>
+#include <sstream>
+#include <string>
+#include <vector>
using namespace MEDCoupling;
double MEDCouplingFieldOverTime::getTimeTolerance() const
{
- std::vector< MCAuto<MEDCouplingFieldDouble> >::const_iterator it=_fs.begin();
+ auto it=_fs.begin();
if(_fs.empty())
throw INTERP_KERNEL::Exception("MEDCouplingFieldOverTime::getTimeTolerance : empty set !");
for(;it!=_fs.end();it++)
- if((const MEDCouplingFieldDouble *)(*it)!=0)
+ if((const MEDCouplingFieldDouble *)(*it)!=nullptr)
return (*it)->getTimeTolerance();
throw INTERP_KERNEL::Exception("MEDCouplingFieldOverTime::getTimeTolerance : only empty fields in this !");
}
void MEDCouplingFieldOverTime::checkConsistencyLight() const
{
MEDCouplingMultiFields::checkConsistencyLight();
- std::vector< MCAuto<MEDCouplingFieldDouble> >::const_iterator it=_fs.begin();
+ auto it=_fs.begin();
for(;it!=_fs.end();it++)
if((*it)->getTimeDiscretization()==NO_TIME)
{
const MEDCouplingFieldDouble& ref=*(*(it++));
int tt1,tt2;
double reft=ref.getEndTime(tt1,tt2);
- double eps=getTimeTolerance();
+ double const eps=getTimeTolerance();
int id=1;
for(;it!=_fs.end();it++,id++)
{
std::ostringstream oss; oss << "Field slice at rank #" << id << " is not compatible with the first !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- double curt=(*it)->getStartTime(tt1,tt2);
+ double const curt=(*it)->getStartTime(tt1,tt2);
if(curt<reft-eps)
throw INTERP_KERNEL::Exception("MEDCouplingFieldOverTime::checkConsistencyLight : fields are NOT sorted properly in ascending time !");
reft=(*it)->getEndTime(tt1,tt2);
{ ret << "Current instance is INVALID !\n"; }
try
{
- MEDCouplingDefinitionTime dt=getDefinitionTimeZone();
+ MEDCouplingDefinitionTime const dt=getDefinitionTimeZone();
dt.appendRepr(ret);
}
catch(INTERP_KERNEL::Exception& /*e*/)
{
if(!MEDCouplingMultiFields::isEqual(other,meshPrec,valsPrec))
return false;
- const MEDCouplingFieldOverTime *otherC=dynamic_cast<const MEDCouplingFieldOverTime *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingFieldOverTime *>(other);
if(!otherC)
return false;
// to implement
{
if(!MEDCouplingMultiFields::isEqualWithoutConsideringStr(other,meshPrec,valsPrec))
return false;
- const MEDCouplingFieldOverTime *otherC=dynamic_cast<const MEDCouplingFieldOverTime *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingFieldOverTime *>(other);
if(!otherC)
return false;
// to implement
{
std::vector< std::vector<int> > tmp;
getDifferentArrays(tmp);
- std::vector<const MEDCouplingFieldDouble *> tmp2(_fs.begin(),_fs.end());
+ std::vector<const MEDCouplingFieldDouble *> const tmp2(_fs.begin(),_fs.end());
std::vector<int> tmp3;
getDifferentMeshes(tmp3);
return MEDCouplingDefinitionTime(tmp2,tmp3,tmp);
}
MEDCouplingFieldOverTime::MEDCouplingFieldOverTime()
-{
-}
+= default;
#ifndef __PARAMEDMEM_MEDCOUPLINGFIELDOVERTIME_HXX__
#define __PARAMEDMEM_MEDCOUPLINGFIELDOVERTIME_HXX__
+#include "MEDCoupling.hxx"
#include "MEDCouplingMultiFields.hxx"
#include "MEDCouplingDefinitionTime.hxx"
#include "MEDCouplingFieldDouble.hxx"
+#include <string>
#include <vector>
namespace MEDCoupling
{
public:
MEDCOUPLING_EXPORT static MEDCouplingFieldOverTime *New(const std::vector<MEDCouplingFieldDouble *>& fs);
- MEDCOUPLING_EXPORT void checkConsistencyLight() const;
+ MEDCOUPLING_EXPORT void checkConsistencyLight() const override;
MEDCOUPLING_EXPORT double getTimeTolerance() const;
- MEDCOUPLING_EXPORT std::string simpleRepr() const;
- MEDCOUPLING_EXPORT bool isEqual(const MEDCouplingMultiFields *other, double meshPrec, double valsPrec) const;
- MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingMultiFields *other, double meshPrec, double valsPrec) const;
+ MEDCOUPLING_EXPORT std::string simpleRepr() const override;
+ MEDCOUPLING_EXPORT bool isEqual(const MEDCouplingMultiFields *other, double meshPrec, double valsPrec) const override;
+ MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingMultiFields *other, double meshPrec, double valsPrec) const override;
//void getIdsToFetch(double time, int& fieldId, int& arrId, int& meshId) const;
//void setFieldOnId(int fieldId, MEDCouplingFieldDouble *f);
//void dispatchPointers();
- MEDCOUPLING_EXPORT std::vector<MEDCouplingMesh *> getMeshes() const;
- MEDCOUPLING_EXPORT std::vector<MEDCouplingMesh *> getDifferentMeshes(std::vector<int>& refs) const;
- MEDCOUPLING_EXPORT std::vector<DataArrayDouble *> getArrays() const;
- MEDCOUPLING_EXPORT std::vector<DataArrayDouble *> getDifferentArrays(std::vector< std::vector<int> >& refs) const;
+ MEDCOUPLING_EXPORT std::vector<MEDCouplingMesh *> getMeshes() const override;
+ MEDCOUPLING_EXPORT std::vector<MEDCouplingMesh *> getDifferentMeshes(std::vector<int>& refs) const override;
+ MEDCOUPLING_EXPORT std::vector<DataArrayDouble *> getArrays() const override;
+ MEDCOUPLING_EXPORT std::vector<DataArrayDouble *> getDifferentArrays(std::vector< std::vector<int> >& refs) const override;
MEDCOUPLING_EXPORT MEDCouplingDefinitionTime getDefinitionTimeZone() const;
protected:
MEDCOUPLING_EXPORT MEDCouplingFieldOverTime();
#pragma once
+#include "MEDCoupling.hxx"
+#include "MCType.hxx"
#include "MEDCouplingField.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingFieldDiscretization.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
#include "MEDCouplingTraits.hxx"
#include "MEDCouplingTimeDiscretization.hxx"
-#include <sstream>
+#include <cstddef>
+#include <ostream>
+#include <vector>
+#include <string>
namespace MEDCoupling
{
MEDCouplingFieldT(const MEDCouplingField& other, MEDCouplingTimeDiscretizationTemplate<T> *timeDiscr, bool deepCopy=true);
MEDCouplingFieldT(TypeOfField type, MEDCouplingTimeDiscretizationTemplate<T> *timeDiscr);
MEDCouplingFieldT(MEDCouplingFieldDiscretization *type, NatureOfField n, MEDCouplingTimeDiscretizationTemplate<T> *timeDiscr);
- ~MEDCouplingFieldT();
+ ~MEDCouplingFieldT() override;
public:
MEDCOUPLING_EXPORT TypeOfTimeDiscretization getTimeDiscretization() const;
MEDCOUPLING_EXPORT virtual typename Traits<T>::FieldType *clone(bool recDeepCpy) const = 0;
- MEDCOUPLING_EXPORT void checkConsistencyLight() const;
+ MEDCOUPLING_EXPORT void checkConsistencyLight() const override;
MEDCOUPLING_EXPORT typename Traits<T>::FieldType *cloneWithMesh(bool recDeepCpy) const;
MEDCOUPLING_EXPORT typename Traits<T>::FieldType *buildSubPart(const DataArrayIdType *part) const;
MEDCOUPLING_EXPORT typename Traits<T>::FieldType *buildSubPart(const mcIdType *partBg, const mcIdType *partEnd) const;
MEDCOUPLING_EXPORT virtual bool isEqual(const MEDCouplingFieldT<T> *other, double meshPrec, T valsPrec) const;
MEDCOUPLING_EXPORT virtual bool isEqualIfNotWhy(const MEDCouplingFieldT<T> *other, double meshPrec, T valsPrec, std::string& reason) const;
MEDCOUPLING_EXPORT virtual bool isEqualWithoutConsideringStr(const MEDCouplingFieldT<T> *other, double meshPrec, T valsPrec) const;
- MEDCOUPLING_EXPORT void copyTinyStringsFrom(const MEDCouplingField *other);
- MEDCOUPLING_EXPORT bool areStrictlyCompatible(const MEDCouplingField *other) const;
- MEDCOUPLING_EXPORT bool areStrictlyCompatibleForMulDiv(const MEDCouplingField *other) const;
+ MEDCOUPLING_EXPORT void copyTinyStringsFrom(const MEDCouplingField *other) override;
+ MEDCOUPLING_EXPORT bool areStrictlyCompatible(const MEDCouplingField *other) const override;
+ MEDCOUPLING_EXPORT bool areStrictlyCompatibleForMulDiv(const MEDCouplingField *other) const override;
MEDCOUPLING_EXPORT std::string simpleRepr() const;
- MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const;
+ MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const override;
// specific
MEDCOUPLING_EXPORT bool areCompatibleForMul(const MEDCouplingField *other) const;
MEDCOUPLING_EXPORT bool areCompatibleForDiv(const MEDCouplingField *other) const;
#ifndef __MEDCOUPLINGFIELDT_TXX__
#define __MEDCOUPLINGFIELDT_TXX__
-#include "MEDCouplingTimeDiscretization.hxx"
+#include "MCAuto.hxx"
+#include "InterpKernelException.hxx"
+#include "MEDCouplingFieldT.hxx"
#include "MEDCouplingMesh.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingNatureOfField.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
+#include "MEDCouplingField.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingTraits.hxx"
+
+#include <sstream>
+#include <vector>
+#include <string>
+#include <cstddef>
+#include <iostream>
namespace MEDCoupling
{
+ class DataArray;
+
template<class T>
MEDCouplingFieldT<T>::MEDCouplingFieldT(const MEDCouplingFieldT<T>& other, bool deepCopy):MEDCouplingField(other,deepCopy),_time_discr(other._time_discr->performCopyOrIncrRef(deepCopy))
{
// Author : Anthony Geay (EDF R&D)
#include "MEDCouplingFieldTemplate.hxx"
+#include "MCIdType.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingField.hxx"
+#include "MCType.hxx"
#include "MEDCouplingMesh.hxx"
#include "MEDCouplingFieldInt32.hxx"
#include "MEDCouplingFieldInt64.hxx"
#include "MEDCouplingFieldFloat.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "MEDCouplingFieldDiscretization.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingNatureOfField.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
+#include <ostream>
#include <sstream>
+#include <string>
+#include <vector>
using namespace MEDCoupling;
void MEDCouplingFieldTemplate::checkConsistencyLight() const
{
- if(_mesh==0)
+ if(_mesh==nullptr)
throw INTERP_KERNEL::Exception("MEDCouplingFieldTemplate::checkConsistencyLight : Empty mesh !");
}
{
if(!((const MEDCouplingFieldDiscretization *)_type))
throw INTERP_KERNEL::Exception("No spatial discretization underlying this field to perform resizeForUnserialization !");
- dataInt=0;
- std::vector<mcIdType> tinyInfoITmp(tinyInfoI.begin()+2,tinyInfoI.end());
+ dataInt=nullptr;
+ std::vector<mcIdType> const tinyInfoITmp(tinyInfoI.begin()+2,tinyInfoI.end());
_type->resizeForUnserialization(tinyInfoITmp,dataInt);
}
void MEDCouplingFieldTemplate::reprQuickOverview(std::ostream& stream) const
{
stream << "MEDCouplingFieldTemplate C++ instance at " << this << ". Name : \"" << _name << "\"." << std::endl;
- const char *nat=0;
+ const char *nat=nullptr;
try
{
nat=MEDCouplingNatureOfField::GetRepr(_nature);
{
std::ostringstream oss;
_mesh->reprQuickOverview(oss);
- std::string tmp(oss.str());
+ std::string const tmp(oss.str());
stream << "\nMesh info : " << tmp.substr(0,tmp.find('\n'));
}
}
MCAuto<MEDCouplingFieldTemplate> MEDCouplingFieldTemplate::clone(bool recDeepCpy) const
{
- MCAuto<MEDCouplingFieldTemplate> ret(new MEDCouplingFieldTemplate(*this,recDeepCpy));
+ MCAuto<MEDCouplingFieldTemplate> const ret(new MEDCouplingFieldTemplate(*this,recDeepCpy));
return ret;
}
#pragma once
+#include "MEDCoupling.hxx"
+#include "MCAuto.hxx"
+#include "MCType.hxx"
#include "MEDCouplingField.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include <string>
+#include <vector>
+#include <ostream>
namespace MEDCoupling
{
MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingFieldTemplate *other, double meshPrec) const;
MEDCOUPLING_EXPORT std::string simpleRepr() const;
MEDCOUPLING_EXPORT std::string advancedRepr() const;
- MEDCOUPLING_EXPORT void checkConsistencyLight() const;
+ MEDCOUPLING_EXPORT void checkConsistencyLight() const override;
MEDCOUPLING_EXPORT MCAuto<MEDCouplingFieldTemplate> clone(bool recDeepCpy) const;
//
MEDCOUPLING_EXPORT void getTinySerializationIntInformation(std::vector<mcIdType>& tinyInfo) const;
MEDCOUPLING_EXPORT void finishUnserialization(const std::vector<mcIdType>& tinyInfoI, const std::vector<double>& tinyInfoD, const std::vector<std::string>& tinyInfoS);
MEDCOUPLING_EXPORT void serialize(DataArrayIdType *&dataInt) const;
//
- MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const;
+ MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const override;
private:
MEDCouplingFieldTemplate(const MEDCouplingFieldDouble& f, bool isChecked=true);
MEDCouplingFieldTemplate(const MEDCouplingFieldFloat& f, bool isChecked=true);
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingGaussLocalization.hxx"
+#include "InterpKernelException.hxx"
#include "InterpKernelGaussCoords.hxx"
+#include "MCAuto.hxx"
+#include "MCIdType.hxx"
+#include "MCType.hxx"
#include "MEDCoupling1GTUMesh.hxx"
+#include "MEDCouplingMemArray.hxx"
#include "MEDCouplingUMesh.hxx"
#include "CellModel.hxx"
+#include "NormalizedGeometricTypes"
#include <cmath>
-#include <numeric>
-#include <sstream>
+#include <cstddef>
+#include <ostream>
#include <iterator>
+#include <functional>
+#include <sstream>
#include <algorithm>
+#include <string>
+#include <vector>
using namespace MEDCoupling;
void MEDCouplingGaussLocalization::checkConsistencyLight() const
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_type);
- int nbNodes=cm.getNumberOfNodes();
- int dim=cm.getDimension();
+ int const nbNodes=cm.getNumberOfNodes();
+ int const dim=cm.getDimension();
if(!cm.isDynamic())
{
if(ToIdType(_ref_coord.size())!=nbNodes*dim)
const INTERP_KERNEL::CellModel& cm = INTERP_KERNEL::CellModel::GetCellModel(_type);
return ((int)_ref_coord.size()) / ((int)cm.getDimension());
}
- int dim( getDimension() );
+ int const dim( getDimension() );
return (int)_ref_coord.size()/dim;
}
double MEDCouplingGaussLocalization::getRefCoord(int ptIdInCell, int comp) const
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_type);
- int nbNodes=cm.getNumberOfNodes();
- int dim=cm.getDimension();
+ int const nbNodes=cm.getNumberOfNodes();
+ int const dim=cm.getDimension();
if(ptIdInCell<0 || ptIdInCell>=nbNodes)
throw INTERP_KERNEL::Exception("ptIdInCell specified is invalid : must be in [0;nbNodesPerCell) !");
if(comp<0 || comp>=dim)
double MEDCouplingGaussLocalization::getGaussCoord(int gaussPtIdInCell, int comp) const
{
- int dim=checkCoherencyOfRequest(gaussPtIdInCell,comp);
+ int const dim=checkCoherencyOfRequest(gaussPtIdInCell,comp);
return _gauss_coord[gaussPtIdInCell*dim+comp];
}
ptsInRefCoo->checkAllocated();
mesh->checkConsistencyLight();
//
- mcIdType nbCells=mesh->getNumberOfCells();
+ mcIdType const nbCells=mesh->getNumberOfCells();
const double *coords(mesh->getCoords()->begin());
const mcIdType *connI(mesh->getNodalConnectivityIndex()->begin()),*conn(mesh->getNodalConnectivity()->begin());
//
- mcIdType nbPts(ptsInRefCoo->getNumberOfTuples());
- INTERP_KERNEL::NormalizedCellType typ(getType());
+ mcIdType const nbPts(ptsInRefCoo->getNumberOfTuples());
+ INTERP_KERNEL::NormalizedCellType const typ(getType());
int dim(INTERP_KERNEL::CellModel::GetCellModel(typ).getDimension()),outDim(mesh->getSpaceDimension());
MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
ret->alloc(nbPts*nbCells,outDim);
double *retPtr(ret->getPointer());
for(int iGaussPt = 0 ; iGaussPt < nbGaussPt ; ++iGaussPt)
{
- std::vector<double> curGaussPt(_gauss_coord.begin()+iGaussPt*dim,_gauss_coord.begin()+(iGaussPt+1)*dim);
+ std::vector<double> const curGaussPt(_gauss_coord.begin()+iGaussPt*dim,_gauss_coord.begin()+(iGaussPt+1)*dim);
INTERP_KERNEL::GaussInfo gi(_type,curGaussPt,1,_ref_coord,nbPtsRefCell);
gi.initLocalInfo();
const double *funcVal( gi.getFunctionValues(0) );
double *retPtr(ret->getPointer());
for(int iGaussPt = 0 ; iGaussPt < nbGaussPt ; ++iGaussPt)
{
- std::vector<double> curGaussPt(_gauss_coord.begin()+iGaussPt*dim,_gauss_coord.begin()+(iGaussPt+1)*dim);
+ std::vector<double> const curGaussPt(_gauss_coord.begin()+iGaussPt*dim,_gauss_coord.begin()+(iGaussPt+1)*dim);
INTERP_KERNEL::GaussInfo gi(_type,curGaussPt,1,_ref_coord,nbPtsRefCell);
gi.initLocalInfo();
const double *devOfFuncVal( gi.getDerivativeOfShapeFunctionAt(0) );
void MEDCouplingGaussLocalization::setRefCoord(int ptIdInCell, int comp, double newVal)
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_type);
- int nbNodes=cm.getNumberOfNodes();
- int dim=cm.getDimension();
+ int const nbNodes=cm.getNumberOfNodes();
+ int const dim=cm.getDimension();
if(ptIdInCell<0 || ptIdInCell>=nbNodes)
throw INTERP_KERNEL::Exception("ptIdInCell specified is invalid : must be in [0;nbNodesPerCell) !");
if(comp<0 || comp>=dim)
void MEDCouplingGaussLocalization::setGaussCoord(int gaussPtIdInCell, int comp, double newVal)
{
- int dim=checkCoherencyOfRequest(gaussPtIdInCell,comp);
+ int const dim=checkCoherencyOfRequest(gaussPtIdInCell,comp);
_gauss_coord[gaussPtIdInCell*dim+comp]=newVal;
}
int MEDCouplingGaussLocalization::checkCoherencyOfRequest(mcIdType gaussPtIdInCell, int comp) const
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_type);
- int dim=cm.getDimension();
- mcIdType nbGsPts=getNumberOfGaussPt();
+ int const dim=cm.getDimension();
+ mcIdType const nbGsPts=getNumberOfGaussPt();
if(gaussPtIdInCell<0 || gaussPtIdInCell>=nbGsPts)
throw INTERP_KERNEL::Exception("gaussPtIdInCell specified is invalid : must be in [0:nbGsPts) !");
if(comp<0 || comp>=dim)
bool MEDCouplingGaussLocalization::AreAlmostEqual(const std::vector<double>& v1, const std::vector<double>& v2, double eps)
{
- std::size_t sz=v1.size();
+ std::size_t const sz=v1.size();
if(sz!=v2.size())
return false;
std::vector<double> tmp(sz);
std::vector<double> retCpp(INTERP_KERNEL::GaussInfo::GetDefaultReferenceCoordinatesOf(type));
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
auto nbDim(cm.getDimension());
- std::size_t sz(retCpp.size());
+ std::size_t const sz(retCpp.size());
MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
if( sz%std::size_t(nbDim) != 0 )
THROW_IK_EXCEPTION("GetDefaultReferenceCoordinatesOf : unexpected size of defaut array : " << sz << " % " << nbDim << " != 0 !");
#ifndef __PARAMEDMEM_MEDCOUPLINGGAUSSLOCALIZATION_HXX__
#define __PARAMEDMEM_MEDCOUPLINGGAUSSLOCALIZATION_HXX__
+#include "MCType.hxx"
+#include "MCAuto.hxx"
#include "MEDCoupling.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
#include "MEDCouplingMemArray.hxx"
-#include "InterpKernelException.hxx"
+#include "NormalizedGeometricTypes"
+#include <string>
+#include <cstddef>
#include <vector>
namespace MEDCoupling
// Author : Anthony Geay (EDF R&D)
#include "MEDCouplingIMesh.hxx"
+#include "MCType.hxx"
+#include "MCAuto.hxx"
+#include "MCIdType.hxx"
#include "MEDCouplingCMesh.hxx"
-#include "MEDCouplingMemArray.hxx"
+#include "MEDCouplingMemArray.txx"
#include "MEDCouplingFieldDouble.hxx"
+#include "MEDCouplingStructuredMesh.hxx"
+#include "MEDCouplingMesh.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include <cmath>
+#include <cstddef>
#include <functional>
#include <algorithm>
+#include <iterator>
+#include <ostream>
#include <sstream>
#include <numeric>
+#include <vector>
+#include <utility>
using namespace MEDCoupling;
}
MEDCouplingIMesh::~MEDCouplingIMesh()
-{
-}
+= default;
MEDCouplingIMesh *MEDCouplingIMesh::New()
{
if(ghostLev<0)
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::buildWithGhost : the ghostLev must be >= 0 !");
checkConsistencyLight();
- int spaceDim(getSpaceDimension());
+ int const spaceDim(getSpaceDimension());
double origin[3],dxyz[3];
mcIdType structure[3];
for(int i=0;i<spaceDim;i++)
void MEDCouplingIMesh::setNodeStruct(const mcIdType *nodeStrctStart, const mcIdType *nodeStrctStop)
{
checkSpaceDimension();
- mcIdType sz((mcIdType)std::distance(nodeStrctStart,nodeStrctStop));
+ auto sz((mcIdType)std::distance(nodeStrctStart,nodeStrctStop));
if(sz!=_space_dim)
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::setNodeStruct : input vector of node structure has not the right size ! Or change space dimension before calling it !");
std::copy(nodeStrctStart,nodeStrctStop,_structure);
void MEDCouplingIMesh::setOrigin(const double *originStart, const double *originStop)
{
checkSpaceDimension();
- mcIdType sz(ToIdType(std::distance(originStart,originStop)));
+ mcIdType const sz(ToIdType(std::distance(originStart,originStop)));
if(sz!=_space_dim)
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::setOrigin : input vector of origin vector has not the right size ! Or change space dimension before calling it !");
std::copy(originStart,originStop,_origin);
void MEDCouplingIMesh::setDXYZ(const double *dxyzStart, const double *dxyzStop)
{
checkSpaceDimension();
- mcIdType sz(ToIdType(std::distance(dxyzStart,dxyzStop)));
+ mcIdType const sz(ToIdType(std::distance(dxyzStart,dxyzStop)));
if(sz!=_space_dim)
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::setDXYZ : input vector of dxyz vector has not the right size ! Or change space dimension before calling it !");
std::copy(dxyzStart,dxyzStop,_dxyz);
double MEDCouplingIMesh::getMeasureOfAnyCell() const
{
checkConsistencyLight();
- int dim(getSpaceDimension());
+ int const dim(getSpaceDimension());
double ret(1.);
for(int i=0;i<dim;i++)
ret*=fabs(_dxyz[i]);
try
{ ret->copyTinyInfoFrom(this); }
catch(INTERP_KERNEL::Exception& ) { }
- int spaceDim(getSpaceDimension());
+ int const spaceDim(getSpaceDimension());
std::vector<std::string> infos(buildInfoOnComponents());
for(int i=0;i<spaceDim;i++)
{
std::ostringstream oss; oss << "MEDCouplingIMesh::refineWithFactor : factor for axis #" << i << " (" << factors[i] << ")is invalid ! Must be > 0 !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- mcIdType factAbs(std::abs(factors[i]));
- double fact2(1./(double)factors[i]);
+ mcIdType const factAbs(std::abs(factors[i]));
+ double const fact2(1./(double)factors[i]);
structure[i]=(_structure[i]-1)*factAbs+1;
dxyz[i]=fact2*_dxyz[i];
}
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::CondenseFineToCoarse : All input vectors (dimension) must have the same size !");
if(!coarseDA || !coarseDA->isAllocated() || !fineDA || !fineDA->isAllocated())
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::CondenseFineToCoarse : the parameters 1 or 3 are NULL or not allocated !");
- std::size_t meshDim(coarseSt.size());
+ std::size_t const meshDim(coarseSt.size());
mcIdType nbOfTuplesInCoarseExp(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(coarseSt)),nbOfTuplesInFineExp(MEDCouplingStructuredMesh::DeduceNumberOfGivenRangeInCompactFrmt(fineLocInCoarse));
- std::size_t nbCompo=fineDA->getNumberOfComponents();
+ std::size_t const nbCompo=fineDA->getNumberOfComponents();
if(coarseDA->getNumberOfComponents()!=nbCompo)
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::CondenseFineToCoarse : the number of components of fine DA and coarse one mismatches !");
if(meshDim!=fineLocInCoarse.size() || meshDim!=facts.size())
std::ostringstream oss; oss << "MEDCouplingIMesh::CondenseFineToCoarse : Expecting " << nbOfTuplesInCoarseExp << " tuples having " << coarseDA->getNumberOfTuples() << " !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- mcIdType nbTuplesFine(fineDA->getNumberOfTuples());
+ mcIdType const nbTuplesFine(fineDA->getNumberOfTuples());
if(nbOfTuplesInFineExp==0)
{
if(nbTuplesFine==0)
}
if(nbTuplesFine%nbOfTuplesInFineExp!=0)
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::CondenseFineToCoarse : Invalid nb of tuples in fine DataArray regarding its structure !");
- mcIdType fact(std::accumulate(facts.begin(),facts.end(),1,std::multiplies<mcIdType>()));
+ mcIdType const fact(std::accumulate(facts.begin(),facts.end(),1,std::multiplies<mcIdType>()));
if(nbTuplesFine!=fact*nbOfTuplesInFineExp)
{
std::ostringstream oss; oss << "MEDCouplingIMesh::CondenseFineToCoarse : Invalid number of tuples (" << nbTuplesFine << ") of fine dataarray is invalid ! Must be " << fact*nbOfTuplesInFineExp << "!";
if(!coarseDA || !coarseDA->isAllocated() || !fineDA || !fineDA->isAllocated())
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::CondenseFineToCoarseGhost : the parameters 1 or 3 are NULL or not allocated !");
std::vector<mcIdType> coarseStG(coarseSt.size()); std::transform(coarseSt.begin(),coarseSt.end(),coarseStG.begin(),std::bind(std::plus<mcIdType>(),std::placeholders::_1,2*ghostSize));
- std::size_t meshDim(coarseSt.size());
- mcIdType nbOfTuplesInCoarseExp(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(coarseStG));
- std::size_t nbCompo(fineDA->getNumberOfComponents());
+ std::size_t const meshDim(coarseSt.size());
+ mcIdType const nbOfTuplesInCoarseExp(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(coarseStG));
+ std::size_t const nbCompo(fineDA->getNumberOfComponents());
if(coarseDA->getNumberOfComponents()!=nbCompo)
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::CondenseFineToCoarseGhost : the number of components of fine DA and coarse one mismatches !");
if(meshDim!=fineLocInCoarse.size() || meshDim!=facts.size())
}
case 2:
{
- mcIdType nxwg(coarseSt[0]+2*ghostSize);
+ mcIdType const nxwg(coarseSt[0]+2*ghostSize);
mcIdType kk(fineLocInCoarse[0].first+ghostSize+nxwg*(fineLocInCoarse[1].first+ghostSize)),fact1(facts[1]),fact0(facts[0]);
inPtr+=(dims[0]*fact0+2*ghostSize)*ghostSize*nbCompo;
for(int j=0;j<dims[1];j++)
inPtr+=ghostSize*(dims[0]*fact0+2*ghostSize)*nbCompo;
for(int j=0;j<dims[1];j++)
{
- mcIdType kky(j*nxwg);
+ mcIdType const kky(j*nxwg);
for(mcIdType jfact=0;jfact<fact1;jfact++)
{
inPtr+=ghostSize*nbCompo;
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFine : All input vectors (dimension) must have the same size !");
if(!coarseDA || !coarseDA->isAllocated() || !fineDA || !fineDA->isAllocated())
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFine : the parameters 1 or 3 are NULL or not allocated !");
- std::size_t meshDim(coarseSt.size());
+ std::size_t const meshDim(coarseSt.size());
mcIdType nbOfTuplesInCoarseExp(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(coarseSt)),nbOfTuplesInFineExp(MEDCouplingStructuredMesh::DeduceNumberOfGivenRangeInCompactFrmt(fineLocInCoarse));
- std::size_t nbCompo=fineDA->getNumberOfComponents();
+ std::size_t const nbCompo=fineDA->getNumberOfComponents();
if(coarseDA->getNumberOfComponents()!=nbCompo)
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFine : the number of components of fine DA and coarse one mismatches !");
if(meshDim!=fineLocInCoarse.size() || meshDim!=facts.size())
std::ostringstream oss; oss << "MEDCouplingIMesh::SpreadCoarseToFine : Expecting " << nbOfTuplesInCoarseExp << " tuples having " << coarseDA->getNumberOfTuples() << " !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- mcIdType nbTuplesFine(fineDA->getNumberOfTuples());
+ mcIdType const nbTuplesFine(fineDA->getNumberOfTuples());
if(nbTuplesFine%nbOfTuplesInFineExp!=0)
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFine : Invalid nb of tuples in fine DataArray regarding its structure !");
- mcIdType fact(std::accumulate(facts.begin(),facts.end(),1,std::multiplies<mcIdType>()));
+ mcIdType const fact(std::accumulate(facts.begin(),facts.end(),1,std::multiplies<mcIdType>()));
if(nbTuplesFine!=fact*nbOfTuplesInFineExp)
{
std::ostringstream oss; oss << "MEDCouplingIMesh::SpreadCoarseToFine : Invalid number of tuples (" << nbTuplesFine << ") of fine dataarray is invalid ! Must be " << fact*nbOfTuplesInFineExp << "!";
if(!coarseDA || !coarseDA->isAllocated() || !fineDA || !fineDA->isAllocated())
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFineGhost : the parameters 1 or 3 are NULL or not allocated !");
std::vector<mcIdType> coarseStG(coarseSt.size()); std::transform(coarseSt.begin(),coarseSt.end(),coarseStG.begin(),std::bind(std::plus<mcIdType>(),std::placeholders::_1,2*ghostSize));
- std::size_t meshDim(coarseSt.size());
- mcIdType nbOfTuplesInCoarseExp(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(coarseStG));
- std::size_t nbCompo=fineDA->getNumberOfComponents();
+ std::size_t const meshDim(coarseSt.size());
+ mcIdType const nbOfTuplesInCoarseExp(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(coarseStG));
+ std::size_t const nbCompo=fineDA->getNumberOfComponents();
if(coarseDA->getNumberOfComponents()!=nbCompo)
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFineGhost : the number of components of fine DA and coarse one mismatches !");
if(meshDim!=fineLocInCoarse.size() || meshDim!=facts.size())
if(!coarseDA || !coarseDA->isAllocated() || !fineDA || !fineDA->isAllocated())
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFineGhostZone : the parameters 1 or 3 are NULL or not allocated !");
std::vector<mcIdType> coarseStG(coarseSt.size()); std::transform(coarseSt.begin(),coarseSt.end(),coarseStG.begin(),std::bind(std::plus<mcIdType>(),std::placeholders::_1,2*ghostSize));
- std::size_t meshDim(coarseSt.size());
- mcIdType nbOfTuplesInCoarseExp(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(coarseStG));
- std::size_t nbCompo=fineDA->getNumberOfComponents();
+ std::size_t const meshDim(coarseSt.size());
+ mcIdType const nbOfTuplesInCoarseExp(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(coarseStG));
+ std::size_t const nbCompo=fineDA->getNumberOfComponents();
if(coarseDA->getNumberOfComponents()!=nbCompo)
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFineGhostZone : the number of components of fine DA and coarse one mismatches !");
if(meshDim!=fineLocInCoarse.size() || meshDim!=facts.size())
*/
void MEDCouplingIMesh::copyTinyStringsFrom(const MEDCouplingMesh *other)
{
- const MEDCouplingIMesh *otherC=dynamic_cast<const MEDCouplingIMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingIMesh *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::copyTinyStringsFrom : meshes have not same type !");
MEDCouplingStructuredMesh::copyTinyStringsFrom(other);
{
if(!other)
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::isEqualIfNotWhy : input other pointer is null !");
- const MEDCouplingIMesh *otherC(dynamic_cast<const MEDCouplingIMesh *>(other));
+ const auto *otherC(dynamic_cast<const MEDCouplingIMesh *>(other));
if(!otherC)
{
reason="mesh given in input is not castable in MEDCouplingIMesh !";
bool MEDCouplingIMesh::isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const
{
- const MEDCouplingIMesh *otherC=dynamic_cast<const MEDCouplingIMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingIMesh *>(other);
if(!otherC)
return false;
std::string tmp;
bool MEDCouplingIMesh::isEqualWithoutConsideringStrInternal(const MEDCouplingMesh *other, double prec, std::string& reason) const
{
- const MEDCouplingIMesh *otherC=dynamic_cast<const MEDCouplingIMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingIMesh *>(other);
if(!otherC)
return false;
if(_space_dim!=otherC->_space_dim)
return true;
}
-void MEDCouplingIMesh::checkDeepEquivalWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
- DataArrayIdType *&cellCor, DataArrayIdType *&nodeCor) const
+void MEDCouplingIMesh::checkDeepEquivalWith(const MEDCouplingMesh *other, int /*cellCompPol*/, double prec,
+ DataArrayIdType *& /*cellCor*/, DataArrayIdType *& /*nodeCor*/) const
{
if(!isEqualWithoutConsideringStr(other,prec))
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::checkDeepEquivalWith : Meshes are not the same !");
* Nothing is done here (except to check that the other is a MEDCoupling::MEDCouplingIMesh instance too).
* The user intend that the nodes are the same, so by construction of MEDCoupling::MEDCouplingIMesh, \a this and \a other are the same !
*/
-void MEDCouplingIMesh::checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
- DataArrayIdType *&cellCor) const
+void MEDCouplingIMesh::checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *other, int /*cellCompPol*/, double prec,
+ DataArrayIdType *& /*cellCor*/) const
{
if(!isEqualWithoutConsideringStr(other,prec))
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::checkDeepEquivalOnSameNodesWith : Meshes are not the same !");
}
}
-void MEDCouplingIMesh::checkConsistency(double eps) const
+void MEDCouplingIMesh::checkConsistency(double /*eps*/) const
{
checkConsistencyLight();
}
MEDCouplingStructuredMesh *MEDCouplingIMesh::buildStructuredSubPart(const std::vector< std::pair<mcIdType,mcIdType> >& cellPart) const
{
checkConsistencyLight();
- int dim(getSpaceDimension());
+ int const dim(getSpaceDimension());
if(dim!=ToIdType(cellPart.size()))
{
std::ostringstream oss; oss << "MEDCouplingIMesh::buildStructuredSubPart : the space dimension is " << dim << " and cell part size is " << cellPart.size() << " !";
for(int i=0;i<dim;i++)
{
mcIdType startNode(cellPart[i].first),endNode(cellPart[i].second+1);
- mcIdType myDelta(endNode-startNode);
+ mcIdType const myDelta(endNode-startNode);
if(startNode<0 || startNode>=_structure[i])
{
std::ostringstream oss; oss << "MEDCouplingIMesh::buildStructuredSubPart : At dimension #" << i << " the start node id is " << startNode << " it should be in [0," << _structure[i] << ") !";
void MEDCouplingIMesh::getCoordinatesOfNode(mcIdType nodeId, std::vector<double>& coo) const
{
mcIdType tmp[3];
- int spaceDim(getSpaceDimension());
+ int const spaceDim(getSpaceDimension());
getSplitNodeValues(tmp);
mcIdType tmp2[3];
GetPosFromId(nodeId,spaceDim,tmp,tmp2);
ret << "Image grid with name : \"" << getName() << "\"\n";
ret << "Description of mesh : \"" << getDescription() << "\"\n";
int tmpp1,tmpp2;
- double tt(getTime(tmpp1,tmpp2));
- int spaceDim(_space_dim);
+ double const tt(getTime(tmpp1,tmpp2));
+ int const spaceDim(_space_dim);
ret << "Time attached to the mesh [unit] : " << tt << " [" << getTimeUnit() << "]\n";
ret << "Iteration : " << tmpp1 << " Order : " << tmpp2 << "\n";
ret << "Space dimension : " << spaceDim << "\n";
void MEDCouplingIMesh::getBoundingBox(double *bbox) const
{
checkConsistencyLight();
- int dim(getSpaceDimension());
+ int const dim(getSpaceDimension());
for(int idim=0; idim<dim; idim++)
{
bbox[2*idim]=_origin[idim];
* and one time . The caller is to delete this field using decrRef() as it is no
* more needed.
*/
-MEDCouplingFieldDouble *MEDCouplingIMesh::getMeasureField(bool isAbs) const
+MEDCouplingFieldDouble *MEDCouplingIMesh::getMeasureField(bool /*isAbs*/) const
{
checkConsistencyLight();
std::string name="MeasureOfMesh_";
name+=getName();
- std::size_t nbelem=getNumberOfCells();
+ std::size_t const nbelem=getNumberOfCells();
MEDCouplingFieldDouble *field(MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME));
field->setName(name);
DataArrayDouble* array(DataArrayDouble::New());
/*!
* not implemented yet !
*/
-MEDCouplingFieldDouble *MEDCouplingIMesh::getMeasureFieldOnNode(bool isAbs) const
+MEDCouplingFieldDouble *MEDCouplingIMesh::getMeasureFieldOnNode(bool /*isAbs*/) const
{
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::getMeasureFieldOnNode : not implemented yet !");
//return 0;
}
-mcIdType MEDCouplingIMesh::getCellContainingPoint(const double *pos, double eps) const
+mcIdType MEDCouplingIMesh::getCellContainingPoint(const double *pos, double /*eps*/) const
{
mcIdType dim(getSpaceDimension()),ret(0),coeff(1);
for(mcIdType i=0;i<dim;i++)
{
- mcIdType nbOfCells(_structure[i]-1);
- double ref(pos[i]);
- mcIdType tmp(ToIdType((ref-_origin[i])/_dxyz[i]));
+ mcIdType const nbOfCells(_structure[i]-1);
+ double const ref(pos[i]);
+ mcIdType const tmp(ToIdType((ref-_origin[i])/_dxyz[i]));
if(tmp>=0 && tmp<nbOfCells)
{
ret+=coeff*tmp;
void MEDCouplingIMesh::getCellsContainingPoint(const double *pos, double eps, std::vector<mcIdType>& elts) const
{
- mcIdType ret(getCellContainingPoint(pos,eps));
+ mcIdType const ret(getCellContainingPoint(pos,eps));
elts.push_back(ret);
}
-void MEDCouplingIMesh::rotate(const double *center, const double *vector, double angle)
+void MEDCouplingIMesh::rotate(const double * /*center*/, const double * /*vector*/, double /*angle*/)
{
throw INTERP_KERNEL::Exception("No rotation available on IMesh : Traduce it to unstructured mesh to apply it !");
}
void MEDCouplingIMesh::translate(const double *vector)
{
checkSpaceDimension();
- int dim(getSpaceDimension());
+ int const dim(getSpaceDimension());
std::transform(_origin,_origin+dim,vector,_origin,std::plus<double>());
declareAsNew();
}
void MEDCouplingIMesh::scale(const double *point, double factor)
{
checkSpaceDimension();
- int dim(getSpaceDimension());
+ int const dim(getSpaceDimension());
std::transform(_origin,_origin+dim,point,_origin,std::minus<double>());
std::transform(_origin,_origin+dim,_origin,std::bind(std::multiplies<double>(),std::placeholders::_1,factor));
std::transform(_dxyz,_dxyz+dim,_dxyz,std::bind(std::multiplies<double>(),std::placeholders::_1,factor));
declareAsNew();
}
-MEDCouplingMesh *MEDCouplingIMesh::mergeMyselfWith(const MEDCouplingMesh *other) const
+MEDCouplingMesh *MEDCouplingIMesh::mergeMyselfWith(const MEDCouplingMesh * /*other*/) const
{
//not implemented yet !
- return 0;
+ return nullptr;
}
/*!
{
checkConsistencyLight();
MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
- int spaceDim(getSpaceDimension());
- mcIdType nbNodes(getNumberOfNodes());
+ int const spaceDim(getSpaceDimension());
+ mcIdType const nbNodes(getNumberOfNodes());
ret->alloc(nbNodes,spaceDim);
double *pt(ret->getPointer());
ret->setInfoOnComponents(buildInfoOnComponents());
{
checkConsistencyLight();
MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
- int spaceDim(getSpaceDimension());
+ int const spaceDim(getSpaceDimension());
mcIdType nbCells(ToIdType(getNumberOfCells())),tmp[3],tmp2[3];
ret->alloc(nbCells,spaceDim);
double *pt(ret->getPointer()),shiftOrigin[3];
return MEDCouplingIMesh::computeCellCenterOfMass();
}
-void MEDCouplingIMesh::renumberCells(const mcIdType *old2NewBg, bool check)
+void MEDCouplingIMesh::renumberCells(const mcIdType * /*old2NewBg*/, bool /*check*/)
{
throw INTERP_KERNEL::Exception("Functionality of renumbering cell not available for IMesh !");
}
void MEDCouplingIMesh::getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const
{
int it,order;
- double time(getTime(it,order));
+ double const time(getTime(it,order));
tinyInfo.clear();
tinyInfoD.clear();
littleStrings.clear();
tinyInfoD.insert(tinyInfoD.end(),_origin,_origin+3);
}
-void MEDCouplingIMesh::resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const
+void MEDCouplingIMesh::resizeForUnserialization(const std::vector<mcIdType>& /*tinyInfo*/, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& /*littleStrings*/) const
{
a1->alloc(0,1);
a2->alloc(0,1);
a2->alloc(0,1);
}
-void MEDCouplingIMesh::unserialization(const std::vector<double>& tinyInfoD, const std::vector<mcIdType>& tinyInfo, const DataArrayIdType *a1, DataArrayDouble *a2,
+void MEDCouplingIMesh::unserialization(const std::vector<double>& tinyInfoD, const std::vector<mcIdType>& tinyInfo, const DataArrayIdType * /*a1*/, DataArrayDouble * /*a2*/,
const std::vector<std::string>& littleStrings)
{
setName(littleStrings[0]);
declareAsNew();
}
-void MEDCouplingIMesh::writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData, DataArrayByte *byteData) const
+void MEDCouplingIMesh::writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData, DataArrayByte * /*byteData*/) const
{
checkConsistencyLight();
std::ostringstream extent,origin,spacing;
bool isPb(false);
for(int i=0;i<_space_dim;i++)
{
- char tmp=(char)((int)('X')+i);
- mcIdType tmpNodes(_structure[i]);
+ char const tmp=(char)((int)('X')+i);
+ mcIdType const tmpNodes(_structure[i]);
stream1 << "- Axis " << tmp << " : " << tmpNodes << " nodes (orig=" << _origin[i] << ", inter=" << _dxyz[i] << ").";
if(i!=_space_dim-1)
stream1 << std::endl;
std::vector<std::string> MEDCouplingIMesh::buildInfoOnComponents() const
{
checkSpaceDimension();
- int dim(getSpaceDimension());
+ int const dim(getSpaceDimension());
std::vector<std::string> ret(dim);
for(int i=0;i<dim;i++)
{
std::ostringstream oss;
- char tmp=(char)((int)('X')+i); oss << tmp;
+ char const tmp=(char)((int)('X')+i); oss << tmp;
ret[i]=DataArray::BuildInfoFromVarAndUnit(oss.str(),_axis_unit);
}
return ret;
return val;
if(order!=2 && order!=3)
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::FindIntRoot : the order available are 0,1,2 or 3 !");
- double valf((double)val);
+ auto const valf((double)val);
if(order==2)
{
- double retf(sqrt(valf));
- int ret((int)retf);
+ double const retf(sqrt(valf));
+ int const ret((int)retf);
if(ret*ret!=val)
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::FindIntRoot : the input val is not a perfect square root !");
return ret;
}
else//order==3
{
- double retf(std::pow(val,0.3333333333333333));
+ double const retf(std::pow(val,0.3333333333333333));
int ret((int)retf),ret2(ret+1);
if(ret*ret*ret!=val && ret2*ret2*ret2!=val)
throw INTERP_KERNEL::Exception("MEDCouplingIMesh::FindIntRoot : the input val is not a perfect cublic root !");
{
for(mcIdType ig=0;ig<ghostSize;ig++)
outPtr2=std::copy(inPtr+kk*nbCompo,inPtr+(kk+1)*nbCompo,outPtr2);
- mcIdType kk0(kk+1+dims[0]);//1 not ghost. We make the hypothesis that factors is >= ghostlev
+ mcIdType const kk0(kk+1+dims[0]);//1 not ghost. We make the hypothesis that factors is >= ghostlev
outPtr2+=fact0*nbCompo*dims[0];
for(mcIdType ig=0;ig<ghostSize;ig++)
outPtr2=std::copy(inPtr+kk0*nbCompo,inPtr+(kk0+1)*nbCompo,outPtr2);
#ifndef __PARAMEDMEM_MEDCOUPLINGIMESH_HXX__
#define __PARAMEDMEM_MEDCOUPLINGIMESH_HXX__
+#include "MCType.hxx"
#include "MEDCoupling.hxx"
+#include "MEDCouplingMesh.hxx"
+#include "MEDCouplingRefCountObject.hxx"
#include "MEDCouplingStructuredMesh.hxx"
+#include <string>
+#include <vector>
+#include <utility>
+#include <cstddef>
+#include <ostream>
namespace MEDCoupling
{
MEDCOUPLING_EXPORT static void SpreadCoarseToFineGhost(const DataArrayDouble *coarseDA, const std::vector<mcIdType>& coarseSt, DataArrayDouble *fineDA, const std::vector< std::pair<mcIdType,mcIdType> >& fineLocInCoarse, const std::vector<mcIdType>& facts, mcIdType ghostSize);
MEDCOUPLING_EXPORT static void SpreadCoarseToFineGhostZone(const DataArrayDouble *coarseDA, const std::vector<mcIdType>& coarseSt, DataArrayDouble *fineDA, const std::vector< std::pair<mcIdType,mcIdType> >& fineLocInCoarse, const std::vector<mcIdType>& facts, mcIdType ghostSize);
//
- MEDCOUPLING_EXPORT MEDCouplingIMesh *deepCopy() const;
- MEDCOUPLING_EXPORT MEDCouplingIMesh *clone(bool recDeepCpy) const;
- MEDCOUPLING_EXPORT const DataArrayDouble *getDirectAccessOfCoordsArrIfInStructure() const;
+ MEDCOUPLING_EXPORT MEDCouplingIMesh *deepCopy() const override;
+ MEDCOUPLING_EXPORT MEDCouplingIMesh *clone(bool recDeepCpy) const override;
+ MEDCOUPLING_EXPORT const DataArrayDouble *getDirectAccessOfCoordsArrIfInStructure() const override;
MEDCOUPLING_EXPORT MEDCouplingIMesh *buildWithGhost(mcIdType ghostLev) const;
- MEDCOUPLING_EXPORT void updateTime() const;
- MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- MEDCOUPLING_EXPORT MEDCouplingMeshType getType() const { return IMAGE_GRID; }
- MEDCOUPLING_EXPORT void copyTinyStringsFrom(const MEDCouplingMesh *other);
- MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const;
- MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const;
+ MEDCOUPLING_EXPORT void updateTime() const override;
+ MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ MEDCOUPLING_EXPORT MEDCouplingMeshType getType() const override { return IMAGE_GRID; }
+ MEDCOUPLING_EXPORT void copyTinyStringsFrom(const MEDCouplingMesh *other) override;
+ MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const override;
+ MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const override;
MEDCOUPLING_EXPORT void checkDeepEquivalWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
- DataArrayIdType *&cellCor, DataArrayIdType *&nodeCor) const;
+ DataArrayIdType *&cellCor, DataArrayIdType *&nodeCor) const override;
MEDCOUPLING_EXPORT void checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
- DataArrayIdType *&cellCor) const;
- MEDCOUPLING_EXPORT void checkConsistencyLight() const;
- MEDCOUPLING_EXPORT void checkConsistency(double eps=1e-12) const;
- MEDCOUPLING_EXPORT int getSpaceDimension() const;
- MEDCOUPLING_EXPORT void getCoordinatesOfNode(mcIdType nodeId, std::vector<double>& coo) const;
- MEDCOUPLING_EXPORT std::string simpleRepr() const;
- MEDCOUPLING_EXPORT std::string advancedRepr() const;
+ DataArrayIdType *&cellCor) const override;
+ MEDCOUPLING_EXPORT void checkConsistencyLight() const override;
+ MEDCOUPLING_EXPORT void checkConsistency(double eps=1e-12) const override;
+ MEDCOUPLING_EXPORT int getSpaceDimension() const override;
+ MEDCOUPLING_EXPORT void getCoordinatesOfNode(mcIdType nodeId, std::vector<double>& coo) const override;
+ MEDCOUPLING_EXPORT std::string simpleRepr() const override;
+ MEDCOUPLING_EXPORT std::string advancedRepr() const override;
// tools
- MEDCOUPLING_EXPORT void getBoundingBox(double *bbox) const;
- MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureField(bool isAbs) const;
- MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureFieldOnNode(bool isAbs) const;
- MEDCOUPLING_EXPORT mcIdType getCellContainingPoint(const double *pos, double eps) const;
- MEDCOUPLING_EXPORT void getCellsContainingPoint(const double *pos, double eps, std::vector<mcIdType>& elts) const;
- MEDCOUPLING_EXPORT void rotate(const double *center, const double *vector, double angle);
- MEDCOUPLING_EXPORT void translate(const double *vector);
- MEDCOUPLING_EXPORT void scale(const double *point, double factor);
- MEDCOUPLING_EXPORT MEDCouplingMesh *mergeMyselfWith(const MEDCouplingMesh *other) const;
- MEDCOUPLING_EXPORT DataArrayDouble *getCoordinatesAndOwner() const;
- MEDCOUPLING_EXPORT DataArrayDouble *computeCellCenterOfMass() const;
- MEDCOUPLING_EXPORT DataArrayDouble *computeIsoBarycenterOfNodesPerCell() const;
- MEDCOUPLING_EXPORT void renumberCells(const mcIdType *old2NewBg, bool check=true);
+ MEDCOUPLING_EXPORT void getBoundingBox(double *bbox) const override;
+ MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureField(bool isAbs) const override;
+ MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureFieldOnNode(bool isAbs) const override;
+ MEDCOUPLING_EXPORT mcIdType getCellContainingPoint(const double *pos, double eps) const override;
+ MEDCOUPLING_EXPORT void getCellsContainingPoint(const double *pos, double eps, std::vector<mcIdType>& elts) const override;
+ MEDCOUPLING_EXPORT void rotate(const double *center, const double *vector, double angle) override;
+ MEDCOUPLING_EXPORT void translate(const double *vector) override;
+ MEDCOUPLING_EXPORT void scale(const double *point, double factor) override;
+ MEDCOUPLING_EXPORT MEDCouplingMesh *mergeMyselfWith(const MEDCouplingMesh *other) const override;
+ MEDCOUPLING_EXPORT DataArrayDouble *getCoordinatesAndOwner() const override;
+ MEDCOUPLING_EXPORT DataArrayDouble *computeCellCenterOfMass() const override;
+ MEDCOUPLING_EXPORT DataArrayDouble *computeIsoBarycenterOfNodesPerCell() const override;
+ MEDCOUPLING_EXPORT void renumberCells(const mcIdType *old2NewBg, bool check=true) override;
//some useful methods
- MEDCOUPLING_EXPORT void getNodeGridStructure(mcIdType *res) const;
- MEDCOUPLING_EXPORT std::vector<mcIdType> getNodeGridStructure() const;
- MEDCouplingStructuredMesh *buildStructuredSubPart(const std::vector< std::pair<mcIdType,mcIdType> >& cellPart) const;
+ MEDCOUPLING_EXPORT void getNodeGridStructure(mcIdType *res) const override;
+ MEDCOUPLING_EXPORT std::vector<mcIdType> getNodeGridStructure() const override;
+ MEDCouplingStructuredMesh *buildStructuredSubPart(const std::vector< std::pair<mcIdType,mcIdType> >& cellPart) const override;
//serialisation-unserialization
- MEDCOUPLING_EXPORT void getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const;
- MEDCOUPLING_EXPORT void resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const;
- MEDCOUPLING_EXPORT void serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const;
+ MEDCOUPLING_EXPORT void getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const override;
+ MEDCOUPLING_EXPORT void resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const override;
+ MEDCOUPLING_EXPORT void serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const override;
MEDCOUPLING_EXPORT void unserialization(const std::vector<double>& tinyInfoD, const std::vector<mcIdType>& tinyInfo, const DataArrayIdType *a1, DataArrayDouble *a2,
- const std::vector<std::string>& littleStrings);
- MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const;
- MEDCOUPLING_EXPORT std::string getVTKFileExtension() const;
+ const std::vector<std::string>& littleStrings) override;
+ MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const override;
+ MEDCOUPLING_EXPORT std::string getVTKFileExtension() const override;
private:
MEDCouplingIMesh();
MEDCouplingIMesh(const MEDCouplingIMesh& other, bool deepCopy);
- ~MEDCouplingIMesh();
- void writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData, DataArrayByte *byteData) const;
- std::string getVTKDataSetType() const;
+ ~MEDCouplingIMesh() override;
+ void writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData, DataArrayByte *byteData) const override;
+ std::string getVTKDataSetType() const override;
bool isEqualWithoutConsideringStrInternal(const MEDCouplingMesh *other, double prec, std::string& reason) const;
std::vector<std::string> buildInfoOnComponents() const;
void checkSpaceDimension() const;
// Author : Anthony Geay (EDF R&D)
#include "MEDCouplingMap.txx"
+#include "MCIdType.hxx"
using namespace MEDCoupling;
#ifndef __MEDCOUPLING_MEDCOUPLINGMAP_HXX__
#define __MEDCOUPLING_MEDCOUPLINGMAP_HXX__
-#include "MEDCoupling.hxx"
#include "MCAuto.hxx"
#include "MCType.hxx"
#include "MEDCouplingTimeLabel.hxx"
#include "MEDCouplingRefCountObject.hxx"
-#include "InterpKernelException.hxx"
+#include <cstddef>
#include <map>
+#include <string>
+#include <vector>
namespace MEDCoupling
{
std::string getClassName() const override { return std::string("MapKeyVal"); }
std::map<ID,T>& data() { return _m; }
const std::map<ID,T>& data() const { return _m; }
- std::size_t getHeapMemorySizeWithoutChildren() const;
- std::vector<const BigMemoryObject*> getDirectChildrenWithNull() const;
- void updateTime() const { }
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ std::vector<const BigMemoryObject*> getDirectChildrenWithNull() const override;
+ void updateTime() const override { }
private:
MapKeyVal() { }
- ~MapKeyVal() { }
+ ~MapKeyVal() override = default;
private:
std::map<ID,T> _m;
};
#ifndef __MEDCOUPLING_MEDCOUPLINGMAP_TXX__
#define __MEDCOUPLING_MEDCOUPLINGMAP_TXX__
+#include "MCAuto.hxx"
#include "MEDCouplingMap.hxx"
+#include <cstddef>
+#include <utility>
+#include <vector>
+#include "MEDCouplingRefCountObject.hxx"
namespace MEDCoupling
{
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingMappedExtrudedMesh.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingMesh.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MCIdType.hxx"
#include "MEDCouplingUMesh.hxx"
#include "MEDCouplingCMesh.hxx"
#include "MEDCouplingMemArray.hxx"
#include "CellModel.hxx"
#include "InterpolationUtils.hxx"
+#include "NormalizedGeometricTypes"
+#include <cstddef>
#include <limits>
+#include <list>
#include <algorithm>
#include <functional>
#include <iterator>
+#include <ostream>
#include <sstream>
#include <cmath>
-#include <list>
#include <set>
+#include <vector>
+#include <string>
using namespace MEDCoupling;
*/
void MEDCouplingMappedExtrudedMesh::copyTinyStringsFrom(const MEDCouplingMesh *other)
{
- const MEDCouplingMappedExtrudedMesh *otherC=dynamic_cast<const MEDCouplingMappedExtrudedMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingMappedExtrudedMesh *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh::copyTinyStringsFrom : meshes have not same type !");
MEDCouplingMesh::copyTinyStringsFrom(other);
}
MEDCouplingMappedExtrudedMesh::MEDCouplingMappedExtrudedMesh(const MEDCouplingUMesh *mesh3D, const MEDCouplingUMesh *mesh2D, mcIdType cell2DId)
-try:_mesh2D(const_cast<MEDCouplingUMesh *>(mesh2D)),_mesh1D(MEDCouplingUMesh::New()),_mesh3D_ids(0),_cell_2D_id(cell2DId)
+try:_mesh2D(const_cast<MEDCouplingUMesh *>(mesh2D)),_mesh1D(MEDCouplingUMesh::New()),_mesh3D_ids(nullptr),_cell_2D_id(cell2DId)
{
if(_mesh2D.isNotNull())
_mesh2D->incrRef();
throw e;
}
-MEDCouplingMappedExtrudedMesh::MEDCouplingMappedExtrudedMesh(const MEDCouplingCMesh *mesh3D):_mesh1D(MEDCouplingUMesh::New()),_mesh3D_ids(0),_cell_2D_id(0)
+MEDCouplingMappedExtrudedMesh::MEDCouplingMappedExtrudedMesh(const MEDCouplingCMesh *mesh3D):_mesh1D(MEDCouplingUMesh::New()),_mesh3D_ids(nullptr),_cell_2D_id(0)
{
if(!mesh3D)
throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh contrct : null input pointer !");
setName(mesh3D->getName()); setDescription(mesh3D->getDescription());
}
-MEDCouplingMappedExtrudedMesh::MEDCouplingMappedExtrudedMesh():_mesh2D(0),_mesh1D(0),_mesh3D_ids(0),_cell_2D_id(-1)
+MEDCouplingMappedExtrudedMesh::MEDCouplingMappedExtrudedMesh():_mesh2D(nullptr),_mesh1D(nullptr),_mesh3D_ids(nullptr),_cell_2D_id(-1)
{
}
{
if(!other)
throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh::isEqualIfNotWhy : input other pointer is null !");
- const MEDCouplingMappedExtrudedMesh *otherC=dynamic_cast<const MEDCouplingMappedExtrudedMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingMappedExtrudedMesh *>(other);
std::ostringstream oss;
if(!otherC)
{
bool MEDCouplingMappedExtrudedMesh::isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const
{
- const MEDCouplingMappedExtrudedMesh *otherC=dynamic_cast<const MEDCouplingMappedExtrudedMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingMappedExtrudedMesh *>(other);
if(!otherC)
return false;
if(!_mesh2D->isEqualWithoutConsideringStr(otherC->_mesh2D,prec))
return true;
}
-void MEDCouplingMappedExtrudedMesh::checkDeepEquivalWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
- DataArrayIdType *&cellCor, DataArrayIdType *&nodeCor) const
+void MEDCouplingMappedExtrudedMesh::checkDeepEquivalWith(const MEDCouplingMesh * /*other*/, int /*cellCompPol*/, double /*prec*/,
+ DataArrayIdType *& /*cellCor*/, DataArrayIdType *& /*nodeCor*/) const
{
throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh::checkDeepEquivalWith : not implemented yet !");
}
-void MEDCouplingMappedExtrudedMesh::checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
- DataArrayIdType *&cellCor) const
+void MEDCouplingMappedExtrudedMesh::checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh * /*other*/, int /*cellCompPol*/, double /*prec*/,
+ DataArrayIdType *& /*cellCor*/) const
{
throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh::checkDeepEquivalOnSameNodesWith : not implemented yet !");
}
INTERP_KERNEL::NormalizedCellType MEDCouplingMappedExtrudedMesh::getTypeOfCell(mcIdType cellId) const
{
const mcIdType *ids(_mesh3D_ids->begin());
- std::size_t nbOf3DCells(_mesh3D_ids->getNumberOfTuples());
+ std::size_t const nbOf3DCells(_mesh3D_ids->getNumberOfTuples());
const mcIdType *where(std::find(ids,ids+nbOf3DCells,cellId));
if(where==ids+nbOf3DCells)
throw INTERP_KERNEL::Exception("Invalid cellId specified >= getNumberOfCells() !");
- std::size_t nbOfCells2D(_mesh2D->getNumberOfCells());
- std::size_t locId((std::distance(ids,where))%nbOfCells2D);
- INTERP_KERNEL::NormalizedCellType tmp(_mesh2D->getTypeOfCell(ToIdType(locId)));
+ std::size_t const nbOfCells2D(_mesh2D->getNumberOfCells());
+ std::size_t const locId((std::distance(ids,where))%nbOfCells2D);
+ INTERP_KERNEL::NormalizedCellType const tmp(_mesh2D->getTypeOfCell(ToIdType(locId)));
return INTERP_KERNEL::CellModel::GetCellModel(tmp).getExtrudedType();
}
std::set<INTERP_KERNEL::NormalizedCellType> MEDCouplingMappedExtrudedMesh::getAllGeoTypes() const
{
- std::set<INTERP_KERNEL::NormalizedCellType> ret2D(_mesh2D->getAllGeoTypes());
+ std::set<INTERP_KERNEL::NormalizedCellType> const ret2D(_mesh2D->getAllGeoTypes());
std::set<INTERP_KERNEL::NormalizedCellType> ret;
- for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=ret2D.begin();it!=ret2D.end();it++)
- ret.insert(INTERP_KERNEL::CellModel::GetCellModel(*it).getExtrudedType());
+ for(auto it : ret2D)
+ ret.insert(INTERP_KERNEL::CellModel::GetCellModel(it).getExtrudedType());
return ret;
}
DataArrayIdType *MEDCouplingMappedExtrudedMesh::giveCellsWithType(INTERP_KERNEL::NormalizedCellType type) const
{
const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(type));
- INTERP_KERNEL::NormalizedCellType revExtTyp(cm.getReverseExtrudedType());
+ INTERP_KERNEL::NormalizedCellType const revExtTyp(cm.getReverseExtrudedType());
MCAuto<DataArrayIdType> ret(DataArrayIdType::New());
if(revExtTyp==INTERP_KERNEL::NORM_ERROR)
{
return ret.retn();
}
MCAuto<DataArrayIdType> tmp(_mesh2D->giveCellsWithType(revExtTyp));
- mcIdType nbOfLevs=_mesh1D->getNumberOfCells();
- mcIdType nbOfCells2D=_mesh2D->getNumberOfCells();
- mcIdType nbOfTuples(tmp->getNumberOfTuples());
+ mcIdType const nbOfLevs=_mesh1D->getNumberOfCells();
+ mcIdType const nbOfCells2D=_mesh2D->getNumberOfCells();
+ mcIdType const nbOfTuples(tmp->getNumberOfTuples());
ret->alloc(nbOfLevs*nbOfTuples,1);
mcIdType *pt(ret->getPointer());
for(int i=0;i<nbOfLevs;i++,pt+=nbOfTuples)
DataArrayIdType *MEDCouplingMappedExtrudedMesh::computeNbOfNodesPerCell() const
{
MCAuto<DataArrayIdType> ret2D(_mesh2D->computeNbOfNodesPerCell());
- mcIdType nbOfLevs=_mesh1D->getNumberOfCells();
- mcIdType nbOfCells2D=_mesh2D->getNumberOfCells();
+ mcIdType const nbOfLevs=_mesh1D->getNumberOfCells();
+ mcIdType const nbOfCells2D=_mesh2D->getNumberOfCells();
MCAuto<DataArrayIdType> ret3D(DataArrayIdType::New()); ret3D->alloc(nbOfLevs*nbOfCells2D,1);
mcIdType *pt(ret3D->getPointer());
for(int i=0;i<nbOfLevs;i++,pt+=nbOfCells2D)
DataArrayIdType *MEDCouplingMappedExtrudedMesh::computeNbOfFacesPerCell() const
{
MCAuto<DataArrayIdType> ret2D(_mesh2D->computeNbOfNodesPerCell());
- mcIdType nbOfLevs=_mesh1D->getNumberOfCells();
- mcIdType nbOfCells2D=_mesh2D->getNumberOfCells();
+ mcIdType const nbOfLevs=_mesh1D->getNumberOfCells();
+ mcIdType const nbOfCells2D=_mesh2D->getNumberOfCells();
MCAuto<DataArrayIdType> ret3D(DataArrayIdType::New()); ret3D->alloc(nbOfLevs*nbOfCells2D,1);
mcIdType *pt(ret3D->getPointer());
for(int i=0;i<nbOfLevs;i++,pt+=nbOfCells2D)
mcIdType MEDCouplingMappedExtrudedMesh::getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType type) const
{
mcIdType ret(0);
- mcIdType nbOfCells2D(_mesh2D->getNumberOfCells());
+ mcIdType const nbOfCells2D(_mesh2D->getNumberOfCells());
for(mcIdType i=0;i<nbOfCells2D;i++)
{
- INTERP_KERNEL::NormalizedCellType t(_mesh2D->getTypeOfCell(i));
+ INTERP_KERNEL::NormalizedCellType const t(_mesh2D->getTypeOfCell(i));
if(INTERP_KERNEL::CellModel::GetCellModel(t).getExtrudedType()==type)
ret++;
}
void MEDCouplingMappedExtrudedMesh::getNodeIdsOfCell(mcIdType cellId, std::vector<mcIdType>& conn) const
{
- mcIdType nbOfCells2D(_mesh2D->getNumberOfCells());
- mcIdType nbOfNodes2D(_mesh2D->getNumberOfNodes());
- mcIdType locId(cellId%nbOfCells2D);
- mcIdType lev(cellId/nbOfCells2D);
+ mcIdType const nbOfCells2D(_mesh2D->getNumberOfCells());
+ mcIdType const nbOfNodes2D(_mesh2D->getNumberOfNodes());
+ mcIdType const locId(cellId%nbOfCells2D);
+ mcIdType const lev(cellId/nbOfCells2D);
std::vector<mcIdType> tmp,tmp2;
_mesh2D->getNodeIdsOfCell(locId,tmp);
tmp2=tmp;
void MEDCouplingMappedExtrudedMesh::getCoordinatesOfNode(mcIdType nodeId, std::vector<double>& coo) const
{
- mcIdType nbOfNodes2D(_mesh2D->getNumberOfNodes());
- mcIdType locId(nodeId%nbOfNodes2D);
- mcIdType lev(nodeId/nbOfNodes2D);
+ mcIdType const nbOfNodes2D(_mesh2D->getNumberOfNodes());
+ mcIdType const locId(nodeId%nbOfNodes2D);
+ mcIdType const lev(nodeId/nbOfNodes2D);
std::vector<double> tmp,tmp2;
_mesh2D->getCoordinatesOfNode(locId,tmp);
tmp2=tmp;
- int spaceDim(_mesh1D->getSpaceDimension());
+ int const spaceDim(_mesh1D->getSpaceDimension());
const double *z(_mesh1D->getCoords()->begin());
std::transform(tmp.begin(),tmp.end(),z+lev*spaceDim,tmp.begin(),std::plus<double>());
std::transform(tmp2.begin(),tmp2.end(),z+(lev+1)*spaceDim,tmp2.begin(),std::plus<double>());
ret << "3D Extruded mesh from a 2D Surf Mesh with name : \"" << getName() << "\"\n";
ret << "Description of mesh : \"" << getDescription() << "\"\n";
int tmpp1,tmpp2;
- double tt=getTime(tmpp1,tmpp2);
+ double const tt=getTime(tmpp1,tmpp2);
ret << "Time attached to the mesh [unit] : " << tt << " [" << getTimeUnit() << "]\n";
ret << "Iteration : " << tmpp1 << " Order : " << tmpp2 << "\n";
ret << "Cell id where 1D mesh has been deduced : " << _cell_2D_id << "\n";
ret << "3D Extruded mesh from a 2D Surf Mesh with name : \"" << getName() << "\"\n";
ret << "Description of mesh : \"" << getDescription() << "\"\n";
int tmpp1,tmpp2;
- double tt=getTime(tmpp1,tmpp2);
+ double const tt=getTime(tmpp1,tmpp2);
ret << "Time attached to the mesh (unit) : " << tt << " (" << getTimeUnit() << ")\n";
ret << "Iteration : " << tmpp1 << " Order : " << tmpp2 << "\n";
ret << "Cell id where 1D mesh has been deduced : " << _cell_2D_id << "\n";
{
}
-void MEDCouplingMappedExtrudedMesh::checkConsistency(double eps) const
+void MEDCouplingMappedExtrudedMesh::checkConsistency(double /*eps*/) const
{
checkConsistencyLight();
}
double bbox2D[6];
_mesh2D->getBoundingBox(bbox2D);
const double *nodes1D(_mesh1D->getCoords()->begin());
- mcIdType nbOfNodes1D(_mesh1D->getNumberOfNodes());
+ mcIdType const nbOfNodes1D(_mesh1D->getNumberOfNodes());
double bbox1DMin[3],bbox1DMax[3],tmp[3];
std::fill(bbox1DMin,bbox1DMin+3,std::numeric_limits<double>::max());
std::fill(bbox1DMax,bbox1DMax+3,-(std::numeric_limits<double>::max()));
std::transform(nodes1D+3*i,nodes1D+3*(i+1),bbox1DMax,bbox1DMax,static_cast<const double& (*)(const double&, const double&)>(std::max<double>));
}
std::transform(bbox1DMax,bbox1DMax+3,bbox1DMin,tmp,std::minus<double>());
- mcIdType id=ToIdType(std::distance(tmp,std::max_element(tmp,tmp+3)));
+ mcIdType const id=ToIdType(std::distance(tmp,std::max_element(tmp,tmp+3)));
bbox[0]=bbox1DMin[0]; bbox[1]=bbox1DMax[0];
bbox[2]=bbox1DMin[1]; bbox[3]=bbox1DMax[1];
bbox[4]=bbox1DMin[2]; bbox[5]=bbox1DMax[2];
updateTimeWith(*_mesh1D);
}
-void MEDCouplingMappedExtrudedMesh::renumberCells(const mcIdType *old2NewBg, bool check)
+void MEDCouplingMappedExtrudedMesh::renumberCells(const mcIdType * /*old2NewBg*/, bool /*check*/)
{
throw INTERP_KERNEL::Exception("Functionality of renumbering cells unavailable for ExtrudedMesh");
}
return ret.retn();
}
-MEDCouplingFieldDouble *MEDCouplingMappedExtrudedMesh::getMeasureFieldOnNode(bool isAbs) const
+MEDCouplingFieldDouble *MEDCouplingMappedExtrudedMesh::getMeasureFieldOnNode(bool /*isAbs*/) const
{
//not implemented yet
- return 0;
+ return nullptr;
}
MEDCouplingFieldDouble *MEDCouplingMappedExtrudedMesh::buildOrthogonalField() const
throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh::buildOrthogonalField : This method has no sense for MEDCouplingMappedExtrudedMesh that is 3D !");
}
-mcIdType MEDCouplingMappedExtrudedMesh::getCellContainingPoint(const double *pos, double eps) const
+mcIdType MEDCouplingMappedExtrudedMesh::getCellContainingPoint(const double * /*pos*/, double /*eps*/) const
{
throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh::getCellContainingPoint : not implemented yet !");
}
-void MEDCouplingMappedExtrudedMesh::getCellsContainingPoint(const double *pos, double eps, std::vector<mcIdType>& elts) const
+void MEDCouplingMappedExtrudedMesh::getCellsContainingPoint(const double * /*pos*/, double /*eps*/, std::vector<mcIdType>& /*elts*/) const
{
throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh::getCellsContainingPoint : not implemented yet !");
}
MEDCouplingMappedExtrudedMesh::~MEDCouplingMappedExtrudedMesh()
-{
-}
+= default;
void MEDCouplingMappedExtrudedMesh::computeExtrusion(const MEDCouplingUMesh *mesh3D)
{
const char errMsg1[]="2D mesh is empty unable to compute extrusion !";
const char errMsg2[]="Coords between 2D and 3D meshes are not the same ! Try MEDCouplingPointSet::tryToShareSameCoords method";
const char errMsg3[]="No chance to find extrusion pattern in mesh3D,mesh2D couple because nbCells3D%nbCells2D!=0 !";
- if(_mesh2D.isNull() || mesh3D==0)
+ if(_mesh2D.isNull() || mesh3D==nullptr)
throw INTERP_KERNEL::Exception(errMsg1);
if(_mesh2D->getCoords()!=mesh3D->getCoords())
throw INTERP_KERNEL::Exception(errMsg2);
const mcIdType *revDesc3D, const mcIdType *revDescIndx3D,
bool computeMesh1D)
{
- mcIdType nbOf2DCells=_mesh2D->getNumberOfCells();
+ mcIdType const nbOf2DCells=_mesh2D->getNumberOfCells();
mcIdType start(revDescIndx3D[idIn3DDesc]);
mcIdType end(revDescIndx3D[idIn3DDesc+1]);
if(end-start!=1)
const mcIdType *desc3D, const mcIdType *descIndx3D,
const mcIdType *conn2D, const mcIdType *conn2DIndx)
{
- mcIdType start(descIndx3D[current3DCell]);
- mcIdType end(descIndx3D[current3DCell+1]);
- bool found=false;
+ mcIdType const start(descIndx3D[current3DCell]);
+ mcIdType const end(descIndx3D[current3DCell+1]);
+ bool const found=false;
for(const mcIdType *candidate2D=desc3D+start;candidate2D!=desc3D+end && !found;candidate2D++)
{
if(*candidate2D!=current2DCell)
double *zoneToUpdate(_mesh1D->getCoords()->getPointer()+lev1DId*3);
std::fill(zoneToUpdate,zoneToUpdate+3,0.);
const double *coords(_mesh2D->getCoords()->begin());
- for(std::vector<mcIdType>::const_iterator iter=nodalConnec.begin();iter!=nodalConnec.end();iter++)
- std::transform(zoneToUpdate,zoneToUpdate+3,coords+3*(*iter),zoneToUpdate,std::plus<double>());
+ for(long const iter : nodalConnec)
+ std::transform(zoneToUpdate,zoneToUpdate+3,coords+3*iter,zoneToUpdate,std::plus<double>());
std::transform(zoneToUpdate,zoneToUpdate+3,zoneToUpdate,std::bind(std::multiplies<double>(),std::placeholders::_1,(1./(double)nodalConnec.size())));
}
mcIdType MEDCouplingMappedExtrudedMesh::FindCorrespCellByNodalConn(const std::vector<mcIdType>& nodalConnec, const mcIdType *revNodalPtr, const mcIdType *revNodalIndxPtr)
{
- std::vector<mcIdType>::const_iterator iter=nodalConnec.begin();
+ auto iter=nodalConnec.begin();
std::set<mcIdType> s1(revNodalPtr+revNodalIndxPtr[*iter],revNodalPtr+revNodalIndxPtr[*iter+1]);
iter++;
for(;iter!=nodalConnec.end();iter++)
{
- std::set<mcIdType> s2(revNodalPtr+revNodalIndxPtr[*iter],revNodalPtr+revNodalIndxPtr[*iter+1]);
+ std::set<mcIdType> const s2(revNodalPtr+revNodalIndxPtr[*iter],revNodalPtr+revNodalIndxPtr[*iter+1]);
std::set<mcIdType> s3;
std::set_intersection(s1.begin(),s1.end(),s2.begin(),s2.end(),std::insert_iterator< std::set<mcIdType> >(s3,s3.end()));
s1=s3;
m1->getCoordinatesOfNode(c[0],ref);
m1->getCoordinatesOfNode(c[1],ref2);
std::transform(ref2.begin(),ref2.end(),ref.begin(),v,std::minus<double>());
- double n=INTERP_KERNEL::norm<3>(v);
+ double const n=INTERP_KERNEL::norm<3>(v);
std::transform(v,v+3,v,std::bind(std::multiplies<double>(),std::placeholders::_1,1/n));
m1->project1D(&ref[0],v,eps,m1r->getCoords()->getPointer());
m2->project1D(&ref[0],v,eps,m2r->getCoords()->getPointer());
throw INTERP_KERNEL::Exception("Not implemented yet !");
}
-DataArrayIdType *MEDCouplingMappedExtrudedMesh::checkTypeConsistencyAndContig(const std::vector<mcIdType>& code, const std::vector<const DataArrayIdType *>& idsPerType) const
+DataArrayIdType *MEDCouplingMappedExtrudedMesh::checkTypeConsistencyAndContig(const std::vector<mcIdType>& /*code*/, const std::vector<const DataArrayIdType *>& /*idsPerType*/) const
{
throw INTERP_KERNEL::Exception("Not implemented yet !");
}
-void MEDCouplingMappedExtrudedMesh::splitProfilePerType(const DataArrayIdType *profile, std::vector<mcIdType>& code, std::vector<DataArrayIdType *>& idsInPflPerType, std::vector<DataArrayIdType *>& idsPerType, bool smartPflKiller) const
+void MEDCouplingMappedExtrudedMesh::splitProfilePerType(const DataArrayIdType * /*profile*/, std::vector<mcIdType>& /*code*/, std::vector<DataArrayIdType *>& /*idsInPflPerType*/, std::vector<DataArrayIdType *>& /*idsPerType*/, bool /*smartPflKiller*/) const
{
throw INTERP_KERNEL::Exception("Not implemented yet !");
}
-MEDCouplingMesh *MEDCouplingMappedExtrudedMesh::buildPart(const mcIdType *start, const mcIdType *end) const
+MEDCouplingMesh *MEDCouplingMappedExtrudedMesh::buildPart(const mcIdType * /*start*/, const mcIdType * /*end*/) const
{
// not implemented yet !
- return 0;
+ return nullptr;
}
-MEDCouplingMesh *MEDCouplingMappedExtrudedMesh::buildPartAndReduceNodes(const mcIdType *start, const mcIdType *end, DataArrayIdType*& arr) const
+MEDCouplingMesh *MEDCouplingMappedExtrudedMesh::buildPartAndReduceNodes(const mcIdType * /*start*/, const mcIdType * /*end*/, DataArrayIdType*& /*arr*/) const
{
// not implemented yet !
- return 0;
+ return nullptr;
}
-DataArrayIdType *MEDCouplingMappedExtrudedMesh::simplexize(int policy)
+DataArrayIdType *MEDCouplingMappedExtrudedMesh::simplexize(int /*policy*/)
{
throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh::simplexize : unavailable for such a type of mesh : Extruded !");
}
-MEDCouplingMesh *MEDCouplingMappedExtrudedMesh::mergeMyselfWith(const MEDCouplingMesh *other) const
+MEDCouplingMesh *MEDCouplingMappedExtrudedMesh::mergeMyselfWith(const MEDCouplingMesh * /*other*/) const
{
// not implemented yet !
- return 0;
+ return nullptr;
}
DataArrayDouble *MEDCouplingMappedExtrudedMesh::getCoordinatesAndOwner() const
const DataArrayDouble *arr1D(_mesh1D->getCoords());
MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
ret->alloc(getNumberOfNodes(),3);
- mcIdType nbOf1DLev(_mesh1D->getNumberOfNodes());
- mcIdType nbOf2DNodes(_mesh2D->getNumberOfNodes());
+ mcIdType const nbOf1DLev(_mesh1D->getNumberOfNodes());
+ mcIdType const nbOf2DNodes(_mesh2D->getNumberOfNodes());
const double *ptSrc(arr2D->begin());
double *pt(ret->getPointer());
std::copy(ptSrc,ptSrc+3*nbOf2DNodes,pt);
void MEDCouplingMappedExtrudedMesh::computeExtrusionAlg(const MEDCouplingUMesh *mesh3D)
{
_mesh3D_ids->alloc(mesh3D->getNumberOfCells(),1);
- mcIdType nbOf1DLev=mesh3D->getNumberOfCells()/_mesh2D->getNumberOfCells();
+ mcIdType const nbOf1DLev=mesh3D->getNumberOfCells()/_mesh2D->getNumberOfCells();
_mesh1D->setMeshDimension(1);
_mesh1D->allocateCells(nbOf1DLev);
mcIdType tmpConn[2];
const mcIdType *revNodalIndx2DPtr(revNodalIndx2D->begin());
const mcIdType *descP(desc->begin()),*descIndxP(descIndx->begin()),*revDescP(revDesc->begin()),*revDescIndxP(revDescIndx->begin());
//
- mcIdType nbOf2DCells=_mesh2D->getNumberOfCells();
+ mcIdType const nbOf2DCells=_mesh2D->getNumberOfCells();
for(mcIdType i=0;i<nbOf2DCells;i++)
{
mcIdType idInSubMesh;
- std::vector<mcIdType> nodalConnec(nodal2D+nodal2DIndx[i]+1,nodal2D+nodal2DIndx[i+1]);
+ std::vector<mcIdType> const nodalConnec(nodal2D+nodal2DIndx[i]+1,nodal2D+nodal2DIndx[i+1]);
try
{
idInSubMesh=FindCorrespCellByNodalConn(nodalConnec,revNodal2DPtr,revNodalIndx2DPtr);
}
}
-void MEDCouplingMappedExtrudedMesh::getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const
+void MEDCouplingMappedExtrudedMesh::getTinySerializationInformation(std::vector<double>& /*tinyInfoD*/, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const
{
std::vector<mcIdType> tinyInfo1;
std::vector<std::string> ls1;
void MEDCouplingMappedExtrudedMesh::resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const
{
- std::size_t sz=tinyInfo.size();
- mcIdType sz1=tinyInfo[sz-2];
- std::vector<mcIdType> ti1(tinyInfo.begin(),tinyInfo.begin()+sz1);
- std::vector<mcIdType> ti2(tinyInfo.begin()+sz1,tinyInfo.end()-3);
+ std::size_t const sz=tinyInfo.size();
+ mcIdType const sz1=tinyInfo[sz-2];
+ std::vector<mcIdType> const ti1(tinyInfo.begin(),tinyInfo.begin()+sz1);
+ std::vector<mcIdType> const ti2(tinyInfo.begin()+sz1,tinyInfo.end()-3);
MEDCouplingUMesh *um=MEDCouplingUMesh::New();
DataArrayIdType *a1tmp=DataArrayIdType::New();
DataArrayDouble *a2tmp=DataArrayDouble::New();
void MEDCouplingMappedExtrudedMesh::serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const
{
a1=DataArrayIdType::New(); a2=DataArrayDouble::New();
- DataArrayIdType *a1_1=0,*a1_2=0;
- DataArrayDouble *a2_1=0,*a2_2=0;
+ DataArrayIdType *a1_1=nullptr,*a1_2=nullptr;
+ DataArrayDouble *a2_1=nullptr,*a2_2=nullptr;
_mesh2D->serialize(a1_1,a2_1);
_mesh1D->serialize(a1_2,a2_2);
a1->alloc(a1_1->getNbOfElems()+a1_2->getNbOfElems()+_mesh3D_ids->getNbOfElems(),1);
a2_2->decrRef();
}
-void MEDCouplingMappedExtrudedMesh::unserialization(const std::vector<double>& tinyInfoD, const std::vector<mcIdType>& tinyInfo, const DataArrayIdType *a1, DataArrayDouble *a2, const std::vector<std::string>& littleStrings)
+void MEDCouplingMappedExtrudedMesh::unserialization(const std::vector<double>& /*tinyInfoD*/, const std::vector<mcIdType>& tinyInfo, const DataArrayIdType *a1, DataArrayDouble *a2, const std::vector<std::string>& littleStrings)
{
setName(littleStrings[littleStrings.size()-2]);
setDescription(littleStrings.back());
- std::size_t sz=tinyInfo.size();
- mcIdType sz1=tinyInfo[sz-2];
+ std::size_t const sz=tinyInfo.size();
+ mcIdType const sz1=tinyInfo[sz-2];
_cell_2D_id=tinyInfo[sz-3];
- std::vector<mcIdType> ti1(tinyInfo.begin(),tinyInfo.begin()+sz1);
- std::vector<mcIdType> ti2(tinyInfo.begin()+sz1,tinyInfo.end()-3);
+ std::vector<mcIdType> const ti1(tinyInfo.begin(),tinyInfo.begin()+sz1);
+ std::vector<mcIdType> const ti2(tinyInfo.begin()+sz1,tinyInfo.end()-3);
DataArrayIdType *a1tmp=DataArrayIdType::New();
DataArrayDouble *a2tmp=DataArrayDouble::New();
const mcIdType *a1Ptr=a1->begin();
a2Ptr+=a2tmp->getNbOfElems();
a1Ptr+=a1tmp->getNbOfElems();
ls2.insert(ls2.end(),littleStrings.begin(),littleStrings.begin()+ls1.size());
- std::vector<double> d1(1);
+ std::vector<double> const d1(1);
_mesh2D->unserialization(d1,ti1,a1tmp,a2tmp,ls2);
a1tmp->decrRef(); a2tmp->decrRef();
//
a1tmp->decrRef(); a2tmp->decrRef();
//
_mesh3D_ids=DataArrayIdType::New();
- mcIdType szIds=ToIdType(std::distance(a1Ptr,a1->begin()))+a1->getNbOfElems();
+ mcIdType const szIds=ToIdType(std::distance(a1Ptr,a1->begin()))+a1->getNbOfElems();
_mesh3D_ids->alloc(szIds,1);
std::copy(a1Ptr,a1Ptr+szIds,_mesh3D_ids->getPointer());
}
#ifndef __PARAMEDMEM_MEDCOUPLINGEXTRUDEDMESH_HXX__
#define __PARAMEDMEM_MEDCOUPLINGEXTRUDEDMESH_HXX__
+#include "MCType.hxx"
+#include "MCAuto.hxx"
#include "MEDCoupling.hxx"
#include "MEDCouplingMesh.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "NormalizedGeometricTypes"
+#include <set>
+#include <string>
+#include <cstddef>
+#include <ostream>
#include <vector>
namespace MEDCoupling
MEDCOUPLING_EXPORT static MEDCouplingMappedExtrudedMesh *New(const MEDCouplingCMesh *mesh3D);
MEDCOUPLING_EXPORT static MEDCouplingMappedExtrudedMesh *New();
MEDCOUPLING_EXPORT std::string getClassName() const override { return std::string("MEDCouplingMappedExtrudedMesh"); }
- MEDCOUPLING_EXPORT MEDCouplingMeshType getType() const;
- MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- MEDCOUPLING_EXPORT void copyTinyStringsFrom(const MEDCouplingMesh *other);
- MEDCOUPLING_EXPORT mcIdType getNumberOfCells() const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfNodes() const;
- MEDCOUPLING_EXPORT int getSpaceDimension() const;
- MEDCOUPLING_EXPORT int getMeshDimension() const;
- MEDCOUPLING_EXPORT MEDCouplingMappedExtrudedMesh *deepCopy() const;
- MEDCOUPLING_EXPORT MEDCouplingMappedExtrudedMesh *clone(bool recDeepCpy) const;
- MEDCOUPLING_EXPORT const DataArrayDouble *getDirectAccessOfCoordsArrIfInStructure() const;
- MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const;
- MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const;
+ MEDCOUPLING_EXPORT MEDCouplingMeshType getType() const override;
+ MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ MEDCOUPLING_EXPORT void copyTinyStringsFrom(const MEDCouplingMesh *other) override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfCells() const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfNodes() const override;
+ MEDCOUPLING_EXPORT int getSpaceDimension() const override;
+ MEDCOUPLING_EXPORT int getMeshDimension() const override;
+ MEDCOUPLING_EXPORT MEDCouplingMappedExtrudedMesh *deepCopy() const override;
+ MEDCOUPLING_EXPORT MEDCouplingMappedExtrudedMesh *clone(bool recDeepCpy) const override;
+ MEDCOUPLING_EXPORT const DataArrayDouble *getDirectAccessOfCoordsArrIfInStructure() const override;
+ MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const override;
+ MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const override;
MEDCOUPLING_EXPORT void checkDeepEquivalWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
- DataArrayIdType *&cellCor, DataArrayIdType *&nodeCor) const;
+ DataArrayIdType *&cellCor, DataArrayIdType *&nodeCor) const override;
MEDCOUPLING_EXPORT void checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
- DataArrayIdType *&cellCor) const;
- MEDCOUPLING_EXPORT INTERP_KERNEL::NormalizedCellType getTypeOfCell(mcIdType cellId) const;
- MEDCOUPLING_EXPORT std::set<INTERP_KERNEL::NormalizedCellType> getAllGeoTypes() const;
- MEDCOUPLING_EXPORT DataArrayIdType *giveCellsWithType(INTERP_KERNEL::NormalizedCellType type) const;
- MEDCOUPLING_EXPORT DataArrayIdType *computeNbOfNodesPerCell() const;
- MEDCOUPLING_EXPORT DataArrayIdType *computeNbOfFacesPerCell() const;
- MEDCOUPLING_EXPORT DataArrayIdType *computeEffectiveNbOfNodesPerCell() const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType type) const;
- MEDCOUPLING_EXPORT void getNodeIdsOfCell(mcIdType cellId, std::vector<mcIdType>& conn) const;
- MEDCOUPLING_EXPORT void getCoordinatesOfNode(mcIdType nodeId, std::vector<double>& coo) const;
- MEDCOUPLING_EXPORT std::string simpleRepr() const;
- MEDCOUPLING_EXPORT std::string advancedRepr() const;
- MEDCOUPLING_EXPORT void checkConsistencyLight() const;
- MEDCOUPLING_EXPORT void checkConsistency(double eps=1e-12) const;
- MEDCOUPLING_EXPORT void getBoundingBox(double *bbox) const;
- MEDCOUPLING_EXPORT void updateTime() const;
- MEDCOUPLING_EXPORT void renumberCells(const mcIdType *old2NewBg, bool check=true);
+ DataArrayIdType *&cellCor) const override;
+ MEDCOUPLING_EXPORT INTERP_KERNEL::NormalizedCellType getTypeOfCell(mcIdType cellId) const override;
+ MEDCOUPLING_EXPORT std::set<INTERP_KERNEL::NormalizedCellType> getAllGeoTypes() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *giveCellsWithType(INTERP_KERNEL::NormalizedCellType type) const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *computeNbOfNodesPerCell() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *computeNbOfFacesPerCell() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *computeEffectiveNbOfNodesPerCell() const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType type) const override;
+ MEDCOUPLING_EXPORT void getNodeIdsOfCell(mcIdType cellId, std::vector<mcIdType>& conn) const override;
+ MEDCOUPLING_EXPORT void getCoordinatesOfNode(mcIdType nodeId, std::vector<double>& coo) const override;
+ MEDCOUPLING_EXPORT std::string simpleRepr() const override;
+ MEDCOUPLING_EXPORT std::string advancedRepr() const override;
+ MEDCOUPLING_EXPORT void checkConsistencyLight() const override;
+ MEDCOUPLING_EXPORT void checkConsistency(double eps=1e-12) const override;
+ MEDCOUPLING_EXPORT void getBoundingBox(double *bbox) const override;
+ MEDCOUPLING_EXPORT void updateTime() const override;
+ MEDCOUPLING_EXPORT void renumberCells(const mcIdType *old2NewBg, bool check=true) override;
MEDCOUPLING_EXPORT MEDCouplingUMesh *getMesh2D() const { return _mesh2D.iAmATrollConstCast(); }
MEDCOUPLING_EXPORT MEDCouplingUMesh *getMesh1D() const { return _mesh1D.iAmATrollConstCast(); }
MEDCOUPLING_EXPORT DataArrayIdType *getMesh3DIds() const { return _mesh3D_ids.iAmATrollConstCast(); }
MEDCOUPLING_EXPORT MEDCouplingUMesh *build3DUnstructuredMesh() const;
- MEDCOUPLING_EXPORT MEDCouplingUMesh *buildUnstructured() const;
- MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureField(bool) const;
- MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureFieldOnNode(bool) const;
- MEDCOUPLING_EXPORT MEDCouplingFieldDouble *buildOrthogonalField() const;
- MEDCOUPLING_EXPORT mcIdType getCellContainingPoint(const double *pos, double eps) const;
- MEDCOUPLING_EXPORT void getCellsContainingPoint(const double *pos, double eps, std::vector<mcIdType>& elts) const;
+ MEDCOUPLING_EXPORT MEDCouplingUMesh *buildUnstructured() const override;
+ MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureField(bool) const override;
+ MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureFieldOnNode(bool) const override;
+ MEDCOUPLING_EXPORT MEDCouplingFieldDouble *buildOrthogonalField() const override;
+ MEDCOUPLING_EXPORT mcIdType getCellContainingPoint(const double *pos, double eps) const override;
+ MEDCOUPLING_EXPORT void getCellsContainingPoint(const double *pos, double eps, std::vector<mcIdType>& elts) const override;
MEDCOUPLING_EXPORT static mcIdType FindCorrespCellByNodalConn(const std::vector<mcIdType>& nodalConnec,
const mcIdType *revNodalPtr, const mcIdType *revNodalIndxPtr);
MEDCOUPLING_EXPORT static void Project1DMeshes(const MEDCouplingUMesh *m1, const MEDCouplingUMesh *m2, double eps,
MEDCouplingUMesh *&m1r, MEDCouplingUMesh *&m2r, double *v);
- MEDCOUPLING_EXPORT void rotate(const double *center, const double *vector, double angle);
- MEDCOUPLING_EXPORT void translate(const double *vector);
- MEDCOUPLING_EXPORT void scale(const double *point, double factor);
- MEDCOUPLING_EXPORT std::vector<mcIdType> getDistributionOfTypes() const;
- MEDCOUPLING_EXPORT DataArrayIdType *checkTypeConsistencyAndContig(const std::vector<mcIdType>& code, const std::vector<const DataArrayIdType *>& idsPerType) const;
- MEDCOUPLING_EXPORT void splitProfilePerType(const DataArrayIdType *profile, std::vector<mcIdType>& code, std::vector<DataArrayIdType *>& idsInPflPerType, std::vector<DataArrayIdType *>& idsPerType, bool smartPflKiller=true) const;
- MEDCOUPLING_EXPORT MEDCouplingMesh *buildPart(const mcIdType *start, const mcIdType *end) const;
- MEDCOUPLING_EXPORT MEDCouplingMesh *buildPartAndReduceNodes(const mcIdType *start, const mcIdType *end, DataArrayIdType*& arr) const;
- MEDCOUPLING_EXPORT DataArrayIdType *simplexize(int policy);
- MEDCOUPLING_EXPORT MEDCouplingMesh *mergeMyselfWith(const MEDCouplingMesh *other) const;
- MEDCOUPLING_EXPORT DataArrayDouble *getCoordinatesAndOwner() const;
- MEDCOUPLING_EXPORT DataArrayDouble *computeCellCenterOfMass() const;
- MEDCOUPLING_EXPORT DataArrayDouble *computeIsoBarycenterOfNodesPerCell() const;
- MEDCOUPLING_EXPORT void getReverseNodalConnectivity(DataArrayIdType *revNodal, DataArrayIdType *revNodalIndx) const;
+ MEDCOUPLING_EXPORT void rotate(const double *center, const double *vector, double angle) override;
+ MEDCOUPLING_EXPORT void translate(const double *vector) override;
+ MEDCOUPLING_EXPORT void scale(const double *point, double factor) override;
+ MEDCOUPLING_EXPORT std::vector<mcIdType> getDistributionOfTypes() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *checkTypeConsistencyAndContig(const std::vector<mcIdType>& code, const std::vector<const DataArrayIdType *>& idsPerType) const override;
+ MEDCOUPLING_EXPORT void splitProfilePerType(const DataArrayIdType *profile, std::vector<mcIdType>& code, std::vector<DataArrayIdType *>& idsInPflPerType, std::vector<DataArrayIdType *>& idsPerType, bool smartPflKiller=true) const override;
+ MEDCOUPLING_EXPORT MEDCouplingMesh *buildPart(const mcIdType *start, const mcIdType *end) const override;
+ MEDCOUPLING_EXPORT MEDCouplingMesh *buildPartAndReduceNodes(const mcIdType *start, const mcIdType *end, DataArrayIdType*& arr) const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *simplexize(int policy) override;
+ MEDCOUPLING_EXPORT MEDCouplingMesh *mergeMyselfWith(const MEDCouplingMesh *other) const override;
+ MEDCOUPLING_EXPORT DataArrayDouble *getCoordinatesAndOwner() const override;
+ MEDCOUPLING_EXPORT DataArrayDouble *computeCellCenterOfMass() const override;
+ MEDCOUPLING_EXPORT DataArrayDouble *computeIsoBarycenterOfNodesPerCell() const override;
+ MEDCOUPLING_EXPORT void getReverseNodalConnectivity(DataArrayIdType *revNodal, DataArrayIdType *revNodalIndx) const override;
//Serialization unserialisation
- MEDCOUPLING_EXPORT void getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const;
- MEDCOUPLING_EXPORT void resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const;
- MEDCOUPLING_EXPORT void serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const;
+ MEDCOUPLING_EXPORT void getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const override;
+ MEDCOUPLING_EXPORT void resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const override;
+ MEDCOUPLING_EXPORT void serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const override;
MEDCOUPLING_EXPORT void unserialization(const std::vector<double>& tinyInfoD, const std::vector<mcIdType>& tinyInfo, const DataArrayIdType *a1, DataArrayDouble *a2,
- const std::vector<std::string>& littleStrings);
- MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const;
- MEDCOUPLING_EXPORT std::string getVTKFileExtension() const;
+ const std::vector<std::string>& littleStrings) override;
+ MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const override;
+ MEDCOUPLING_EXPORT std::string getVTKFileExtension() const override;
MEDCOUPLING_EXPORT mcIdType get2DCellIdForExtrusion() const { return _cell_2D_id; }
private:
MEDCouplingMappedExtrudedMesh(const MEDCouplingUMesh *mesh3D, const MEDCouplingUMesh *mesh2D, mcIdType cell2DId);
const mcIdType *desc3D, const mcIdType *descIndx3D,
const mcIdType *conn2D, const mcIdType *conn2DIndx);
void computeBaryCenterOfFace(const std::vector<mcIdType>& nodalConnec, mcIdType lev1DId);
- ~MEDCouplingMappedExtrudedMesh();
- void writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData, DataArrayByte *byteData) const;
- std::string getVTKDataSetType() const;
+ ~MEDCouplingMappedExtrudedMesh() override;
+ void writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData, DataArrayByte *byteData) const override;
+ std::string getVTKDataSetType() const override;
private:
MCAuto<MEDCouplingUMesh> _mesh2D;
MCAuto<MEDCouplingUMesh> _mesh1D;
#include "MEDCouplingMatrix.hxx"
#include "InterpKernelMatrixTools.hxx"
-
+#include "MCType.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MCIdType.hxx"
+
+#include <cstddef>
+#include <algorithm>
+#include <cstdlib>
#include <sstream>
+#include <vector>
+#include <utility>
+#include <string>
using namespace MEDCoupling;
}
DenseMatrix::~DenseMatrix()
-{
-}
+= default;
DenseMatrix::DenseMatrix(mcIdType nbRows, mcIdType nbCols):_nb_rows(nbRows),_nb_cols(nbCols),_data(DataArrayDouble::New())
{
if(_nb_rows<0 || _nb_cols<0)
throw INTERP_KERNEL::Exception("constructor of DenseMatrix : number of rows and number of cols must be > 0 both !");
- mcIdType nbOfTuples(_nb_rows*_nb_cols);
+ mcIdType const nbOfTuples(_nb_rows*_nb_cols);
_data->alloc(nbOfTuples,1);
}
#ifndef __PARAMEDMEM_MEDCOUPLINGMATRIX_HXX__
#define __PARAMEDMEM_MEDCOUPLINGMATRIX_HXX__
+#include "MCType.hxx"
#include "MEDCoupling.hxx"
#include "MEDCouplingTimeLabel.hxx"
#include "MEDCouplingRefCountObject.hxx"
#include "MEDCouplingMemArray.hxx"
#include "MCAuto.hxx"
-#include "InterpKernelException.hxx"
+#include <string>
+#include <cstddef>
+#include <vector>
namespace MEDCoupling
{
MEDCOUPLING_EXPORT std::string getClassName() const override { return std::string("DenseMatrix"); }
MEDCOUPLING_EXPORT DenseMatrix *deepCopy() const;
MEDCOUPLING_EXPORT DenseMatrix *shallowCpy() const;
- MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- MEDCOUPLING_EXPORT void updateTime() const;
+ MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ MEDCOUPLING_EXPORT void updateTime() const override;
//
MEDCOUPLING_EXPORT mcIdType getNumberOfRows() const { return _nb_rows; }
MEDCOUPLING_EXPORT mcIdType getNumberOfCols() const { return _nb_cols; }
MEDCOUPLING_EXPORT const DataArrayDouble *getData() const { return _data; }
MEDCOUPLING_EXPORT DataArrayDouble *getData() { return _data; }
private:
- ~DenseMatrix();
+ ~DenseMatrix() override;
DenseMatrix(mcIdType nbRows, mcIdType nbCols);
DenseMatrix(DataArrayDouble *array, mcIdType nbRows, mcIdType nbCols);
mcIdType getNumberOfRowsExt(mcIdType nbRows) const;
#include "MEDCouplingMemArray.txx"
#include "BBTree.txx"
+#include "BBTreePts.txx"
#include "GenMathFormulae.hxx"
#include "InterpKernelAutoPtr.hxx"
+#include "InterpKernelException.hxx"
#include "InterpKernelExprParser.hxx"
-#include "InterpKernelAutoPtr.hxx"
#include "InterpKernelGeo2DEdgeArcCircle.hxx"
-#include "InterpKernelAutoPtr.hxx"
#include "InterpKernelGeo2DNode.hxx"
#include "InterpKernelGeo2DEdgeLin.hxx"
-
+#include "MEDCoupling.hxx"
+#include "MCIdType.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MCAuto.hxx"
+#include "InterpKernelGeo2DPrecision.hxx"
+#include "InterpolationUtils.hxx"
+
+#include <cstddef>
+#include <ostream>
+#include <iterator>
+#include <cstdint>
#include <set>
#include <cmath>
#include <limits>
#include <numeric>
#include <algorithm>
#include <functional>
+#include <string>
+#include <vector>
+#include <sstream>
-typedef double (*MYFUNCPTR)(double);
+using MYFUNCPTR = double (*)(double);
using namespace MEDCoupling;
void DataArrayDouble::findCommonTuplesAlg(const double *bbox, mcIdType nbNodes, mcIdType limitNodeId, double prec, DataArrayIdType *c, DataArrayIdType *cI) const
{
const double *coordsPtr=getConstPointer();
- BBTreePts<SPACEDIM,mcIdType> myTree(bbox,0,0,nbNodes,prec);
+ BBTreePts<SPACEDIM,mcIdType> const myTree(bbox,nullptr,0,nbNodes,prec);
std::vector<bool> isDone(nbNodes);
for(mcIdType i=0;i<nbNodes;i++)
{
if(intersectingElems.size()>1)
{
std::vector<mcIdType> commonNodes;
- for(std::vector<mcIdType>::const_iterator it=intersectingElems.begin();it!=intersectingElems.end();it++)
- if(*it!=i)
- if(*it>=limitNodeId)
+ for(long const intersectingElem : intersectingElems)
+ if(intersectingElem!=i)
+ if(intersectingElem>=limitNodeId)
{
- commonNodes.push_back(*it);
- isDone[*it]=true;
+ commonNodes.push_back(intersectingElem);
+ isDone[intersectingElem]=true;
}
if(!commonNodes.empty())
{
}
template<int SPACEDIM>
-void DataArrayDouble::FindTupleIdsNearTuplesAlg(const BBTreePts<SPACEDIM,mcIdType>& myTree, const double *pos, mcIdType nbOfTuples, double eps,
+void DataArrayDouble::FindTupleIdsNearTuplesAlg(const BBTreePts<SPACEDIM,mcIdType>& myTree, const double *pos, mcIdType nbOfTuples, double /*eps*/,
DataArrayIdType *c, DataArrayIdType *cI)
{
for(mcIdType i=0;i<nbOfTuples;i++)
std::vector<mcIdType> intersectingElems;
myTree.getElementsAroundPoint(pos+i*SPACEDIM,intersectingElems);
std::vector<mcIdType> commonNodes;
- for(std::vector<mcIdType>::const_iterator it=intersectingElems.begin();it!=intersectingElems.end();it++)
- commonNodes.push_back(*it);
+ for(long const intersectingElem : intersectingElems)
+ commonNodes.push_back(intersectingElem);
cI->pushBackSilent(cI->back()+ToIdType(commonNodes.size()));
c->insertAtTheEnd(commonNodes.begin(),commonNodes.end());
}
}
template<int SPACEDIM>
-void DataArrayDouble::FindClosestTupleIdAlg(const BBTreePts<SPACEDIM,mcIdType>& myTree, double dist, const double *pos, mcIdType nbOfTuples, const double *thisPt, mcIdType thisNbOfTuples, mcIdType *res)
+void DataArrayDouble::FindClosestTupleIdAlg(const BBTreePts<SPACEDIM,mcIdType>& myTree, double dist, const double *pos, mcIdType nbOfTuples, const double * /*thisPt*/, mcIdType /*thisNbOfTuples*/, mcIdType *res)
{
double distOpt = std::max(dist, std::numeric_limits<double>::epsilon());
const double *p(pos);
while(true)
{
mcIdType elem=-1;
- double ret=myTree.getElementsAroundPoint2(p,distOpt,elem);
+ double const ret=myTree.getElementsAroundPoint2(p,distOpt,elem);
if(ret!=std::numeric_limits<double>::max())
{
distOpt=std::max(ret,1e-4);
std::size_t DataArray::getHeapMemorySizeWithoutChildren() const
{
- std::size_t sz1=_name.capacity();
- std::size_t sz2=_info_on_compo.capacity();
+ std::size_t const sz1=_name.capacity();
+ std::size_t const sz2=_info_on_compo.capacity();
std::size_t sz3=0;
- for(std::vector<std::string>::const_iterator it=_info_on_compo.begin();it!=_info_on_compo.end();it++)
- sz3+=(*it).capacity();
+ for(const auto & it : _info_on_compo)
+ sz3+=it.capacity();
return sz1+sz2+sz3;
}
void DataArray::copyPartOfStringInfoFrom(const DataArray& other, const std::vector<std::size_t>& compoIds)
{
- std::size_t nbOfCompoOth=other.getNumberOfComponents();
- std::size_t newNbOfCompo=compoIds.size();
+ std::size_t const nbOfCompoOth=other.getNumberOfComponents();
+ std::size_t const newNbOfCompo=compoIds.size();
for(std::size_t i=0;i<newNbOfCompo;i++)
if(compoIds[i]>=nbOfCompoOth)
{
{
if(compoIds.size()!=other.getNumberOfComponents())
throw INTERP_KERNEL::Exception("Given compoIds has not the same size as number of components of given array !");
- std::size_t partOfCompoToSet=compoIds.size();
- std::size_t nbOfCompo=getNumberOfComponents();
+ std::size_t const partOfCompoToSet=compoIds.size();
+ std::size_t const nbOfCompo=getNumberOfComponents();
for(std::size_t i=0;i<partOfCompoToSet;i++)
if(compoIds[i]>=nbOfCompo)
{
if(_info_on_compo!=other._info_on_compo)
{
oss << "Components DataArray mismatch : \nThis components=";
- for(std::vector<std::string>::const_iterator it=_info_on_compo.begin();it!=_info_on_compo.end();it++)
- oss << "\"" << *it << "\",";
+ for(const auto & it : _info_on_compo)
+ oss << "\"" << it << "\",";
oss << "\nOther components=";
- for(std::vector<std::string>::const_iterator it=other._info_on_compo.begin();it!=other._info_on_compo.end();it++)
- oss << "\"" << *it << "\",";
+ for(const auto & it : other._info_on_compo)
+ oss << "\"" << it << "\",";
reason=oss.str();
return false;
}
{
stream << "Number of components : "<< getNumberOfComponents() << "\n";
stream << "Info of these components : ";
- for(std::vector<std::string>::const_iterator iter=_info_on_compo.begin();iter!=_info_on_compo.end();iter++)
- stream << "\"" << *iter << "\" ";
+ for(const auto & iter : _info_on_compo)
+ stream << "\"" << iter << "\" ";
stream << "\n";
}
{
if(!aBase)
throw INTERP_KERNEL::Exception("DataArray::setPartOfValuesBase3 : input aBase object is NULL !");
- DataArrayDouble *this1(dynamic_cast<DataArrayDouble *>(this));
- DataArrayIdType *this2(dynamic_cast<DataArrayIdType *>(this));
- DataArrayChar *this3(dynamic_cast<DataArrayChar *>(this));
- const DataArrayDouble *a1(dynamic_cast<const DataArrayDouble *>(aBase));
- const DataArrayIdType *a2(dynamic_cast<const DataArrayIdType *>(aBase));
- const DataArrayChar *a3(dynamic_cast<const DataArrayChar *>(aBase));
+ auto *this1(dynamic_cast<DataArrayDouble *>(this));
+ auto *this2(dynamic_cast<DataArrayIdType *>(this));
+ auto *this3(dynamic_cast<DataArrayChar *>(this));
+ const auto *a1(dynamic_cast<const DataArrayDouble *>(aBase));
+ const auto *a2(dynamic_cast<const DataArrayIdType *>(aBase));
+ const auto *a3(dynamic_cast<const DataArrayChar *>(aBase));
if(this1 && a1)
{
this1->setPartOfValues3(a1,bgTuples,endTuples,bgComp,endComp,stepComp,strictCompoCompare);
std::vector<std::string> DataArray::getVarsOnComponent() const
{
- std::size_t nbOfCompo=_info_on_compo.size();
+ std::size_t const nbOfCompo=_info_on_compo.size();
std::vector<std::string> ret(nbOfCompo);
for(std::size_t i=0;i<nbOfCompo;i++)
ret[i]=getVarOnComponent(i);
std::vector<std::string> DataArray::getUnitsOnComponent() const
{
- std::size_t nbOfCompo=_info_on_compo.size();
+ std::size_t const nbOfCompo=_info_on_compo.size();
std::vector<std::string> ret(nbOfCompo);
for(std::size_t i=0;i<nbOfCompo;i++)
ret[i]=getUnitOnComponent(i);
*/
std::vector<std::string> DataArray::SplitStringInChuncks(const std::string st, std::size_t sz)
{
- std::size_t len = st.length();
- std::size_t nbOfCompo(len/sz);
+ std::size_t const len = st.length();
+ std::size_t const nbOfCompo(len/sz);
if( nbOfCompo*sz != len)
{
THROW_IK_EXCEPTION("DataArray::SplitStringInChuncks : Length of input string (" << len << ") is not equal to " << nbOfCompo << "*" << sz << " !");
for(std::size_t i = 0 ; i < nbOfCompo ; ++i)
{
std::string part = st.substr(i*sz,sz);
- std::size_t p3=part.find_last_not_of(" \t");
+ std::size_t const p3=part.find_last_not_of(" \t");
part = part.substr(0,p3+1);
ret[i] = part;
}
*/
std::string DataArray::GetVarNameFromInfo(const std::string& info)
{
- std::size_t p1=info.find_last_of('[');
- std::size_t p2=info.find_last_of(']');
+ std::size_t const p1=info.find_last_of('[');
+ std::size_t const p2=info.find_last_of(']');
if(p1==std::string::npos || p2==std::string::npos)
return info;
if(p1>p2)
return info;
if(p1==0)
return std::string();
- std::size_t p3=info.find_last_not_of(' ',p1-1);
+ std::size_t const p3=info.find_last_not_of(' ',p1-1);
return info.substr(0,p3+1);
}
*/
std::string DataArray::GetUnitFromInfo(const std::string& info)
{
- std::size_t p1=info.find_last_of('[');
- std::size_t p2=info.find_last_of(']');
+ std::size_t const p1=info.find_last_of('[');
+ std::size_t const p2=info.find_last_of(']');
if(p1==std::string::npos || p2==std::string::npos)
return std::string();
if(p1>p2)
DataArray *DataArray::Aggregate(const std::vector<const DataArray *>& arrs)
{
std::vector<const DataArray *> arr2;
- for(std::vector<const DataArray *>::const_iterator it=arrs.begin();it!=arrs.end();it++)
- if(*it)
- arr2.push_back(*it);
+ for(auto arr : arrs)
+ if(arr)
+ arr2.push_back(arr);
if(arr2.empty())
throw INTERP_KERNEL::Exception("DataArray::Aggregate : only null instance in input vector !");
std::vector<const DataArrayDouble *> arrd;
std::vector<const DataArrayIdType *> arri;
std::vector<const DataArrayChar *> arrc;
- for(std::vector<const DataArray *>::const_iterator it=arr2.begin();it!=arr2.end();it++)
+ for(auto it : arr2)
{
- const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(*it);
+ const auto *a=dynamic_cast<const DataArrayDouble *>(it);
if(a)
{ arrd.push_back(a); continue; }
- const DataArrayIdType *b=dynamic_cast<const DataArrayIdType *>(*it);
+ const auto *b=dynamic_cast<const DataArrayIdType *>(it);
if(b)
{ arri.push_back(b); continue; }
- const DataArrayChar *c=dynamic_cast<const DataArrayChar *>(*it);
+ const auto *c=dynamic_cast<const DataArrayChar *>(it);
if(c)
{ arrc.push_back(c); continue; }
throw INTERP_KERNEL::Exception("DataArray::Aggregate : presence of not null instance in inuput that is not in [DataArrayDouble, DataArrayInt, DataArrayChar] !");
checkAllocated();
if(getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("DataArrayDouble::isMonotonic : only supported with 'this' array with ONE component !");
- mcIdType nbOfElements(getNumberOfTuples());
+ mcIdType const nbOfElements(getNumberOfTuples());
const double *ptr=getConstPointer();
if(nbOfElements==0)
return true;
double ref=ptr[0];
- double absEps=fabs(eps);
+ double const absEps=fabs(eps);
if(increasing)
{
for(mcIdType i=1;i<nbOfElements;i++)
{
static const char SPACE[4]={' ',' ',' ',' '};
checkAllocated();
- std::string idt(indent,' ');
+ std::string const idt(indent,' ');
ofs.precision(17);
ofs << idt << "<DataArray type=\"Float32\" Name=\"" << nameInFile << "\" NumberOfComponents=\"" << getNumberOfComponents() << "\"";
//
bool areAllEmpty(true);
- for(std::vector<std::string>::const_iterator it=_info_on_compo.begin();it!=_info_on_compo.end();it++)
- if(!(*it).empty())
+ for(const auto & it : _info_on_compo)
+ if(!it.empty())
areAllEmpty=false;
if(!areAllEmpty)
for(std::size_t i=0;i<_info_on_compo.size();i++)
for(const double *src=begin();src!=end();src++,pt++)
*pt=float(*src);
const char *data(reinterpret_cast<const char *>((float *)tmp));
- std::size_t sz(getNbOfElems()*sizeof(float));
+ std::size_t const sz(getNbOfElems()*sizeof(float));
byteArr->insertAtTheEnd(data,data+sz);
byteArr->insertAtTheEnd(SPACE,SPACE+4);
}
void DataArrayDouble::reprCppStream(const std::string& varName, std::ostream& stream) const
{
- mcIdType nbTuples=getNumberOfTuples();
- std::size_t nbComp=getNumberOfComponents();
+ mcIdType const nbTuples=getNumberOfTuples();
+ std::size_t const nbComp=getNumberOfComponents();
const double *data(getConstPointer());
stream.precision(17);
stream << "DataArrayDouble *" << varName << "=DataArrayDouble::New();" << std::endl;
stream << "DataArrayDouble C++ instance at " << this << ". ";
if(isAllocated())
{
- std::size_t nbOfCompo(_info_on_compo.size());
+ std::size_t const nbOfCompo(_info_on_compo.size());
if(nbOfCompo>=1)
{
- mcIdType nbOfTuples(getNumberOfTuples());
+ mcIdType const nbOfTuples(getNumberOfTuples());
stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
}
void DataArrayDouble::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const
{
const double *data=begin();
- mcIdType nbOfTuples(getNumberOfTuples());
- std::size_t nbOfCompo(_info_on_compo.size());
+ mcIdType const nbOfTuples(getNumberOfTuples());
+ std::size_t const nbOfCompo(_info_on_compo.size());
std::ostringstream oss2; oss2 << "[";
oss2.precision(17);
std::string oss2Str(oss2.str());
else
oss2 << *data++;
if(i!=nbOfTuples-1) oss2 << ", ";
- std::string oss3Str(oss2.str());
+ std::string const oss3Str(oss2.str());
if(oss3Str.length()<maxNbOfByteInRepr)
oss2Str=oss3Str;
else
if(getNumberOfComponents()!=other->getNumberOfComponents())
throw INTERP_KERNEL::Exception("DataArrayDouble::areIncludedInMe : the number of components does not match !");
MCAuto<DataArrayDouble> a=DataArrayDouble::Aggregate(this,other);
- DataArrayIdType *c=0,*ci=0;
+ DataArrayIdType *c=nullptr,*ci=nullptr;
a->findCommonTuples(prec,getNumberOfTuples(),c,ci);
MCAuto<DataArrayIdType> cSafe(c),ciSafe(ci);
mcIdType newNbOfTuples=-1;
void DataArrayDouble::findCommonTuples(double prec, mcIdType limitTupleId, DataArrayIdType *&comm, DataArrayIdType *&commIndex) const
{
checkAllocated();
- std::size_t nbOfCompo=getNumberOfComponents();
+ std::size_t const nbOfCompo=getNumberOfComponents();
if ((nbOfCompo<1) || (nbOfCompo>4)) //test before work
throw INTERP_KERNEL::Exception("DataArrayDouble::findCommonTuples : Unexpected spacedim of coords. Must be 1, 2, 3 or 4.");
- mcIdType nbOfTuples(getNumberOfTuples());
+ mcIdType const nbOfTuples(getNumberOfTuples());
//
MCAuto<DataArrayIdType> c(DataArrayIdType::New()),cI(DataArrayIdType::New()); c->alloc(0,1); cI->pushBackSilent(0);
switch(nbOfCompo)
double DataArrayDouble::minimalDistanceTo(const DataArrayDouble *other, mcIdType& thisTupleId, mcIdType& otherTupleId) const
{
MCAuto<DataArrayIdType> part1=findClosestTupleId(other);
- std::size_t nbOfCompo=getNumberOfComponents();
- mcIdType otherNbTuples=other->getNumberOfTuples();
+ std::size_t const nbOfCompo=getNumberOfComponents();
+ mcIdType const otherNbTuples=other->getNumberOfTuples();
const double *thisPt(begin()),*otherPt(other->begin());
const mcIdType *part1Pt(part1->begin());
double ret=std::numeric_limits<double>::max();
if(!other)
throw INTERP_KERNEL::Exception("DataArrayDouble::findClosestTupleId : other instance is NULL !");
checkAllocated(); other->checkAllocated();
- std::size_t nbOfCompo(getNumberOfComponents());
+ std::size_t const nbOfCompo(getNumberOfComponents());
if(nbOfCompo!=other->getNumberOfComponents())
{
std::ostringstream oss; oss << "DataArrayDouble::findClosestTupleId : number of components in this is " << nbOfCompo;
oss << ", whereas number of components in other is " << other->getNumberOfComponents() << "! Should be equal !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- mcIdType nbOfTuples(other->getNumberOfTuples());
- mcIdType thisNbOfTuples(getNumberOfTuples());
+ mcIdType const nbOfTuples(other->getNumberOfTuples());
+ mcIdType const thisNbOfTuples(getNumberOfTuples());
MCAuto<DataArrayIdType> ret=DataArrayIdType::New(); ret->alloc(nbOfTuples,1);
double bounds[6];
getMinMaxPerComponent(bounds);
{
double xDelta(fabs(bounds[1]-bounds[0])),yDelta(fabs(bounds[3]-bounds[2])),zDelta(fabs(bounds[5]-bounds[4]));
double delta=std::max(xDelta,yDelta); delta=std::max(delta,zDelta);
- double characSize=pow((delta*delta*delta)/((double)thisNbOfTuples),1./3.);
- BBTreePts<3,mcIdType> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
+ double const characSize=pow((delta*delta*delta)/((double)thisNbOfTuples),1./3.);
+ BBTreePts<3,mcIdType> const myTree(begin(),nullptr,0,getNumberOfTuples(),characSize*1e-12);
FindClosestTupleIdAlg<3>(myTree,3.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
break;
}
case 2:
{
double xDelta(fabs(bounds[1]-bounds[0])),yDelta(fabs(bounds[3]-bounds[2]));
- double delta=std::max(xDelta,yDelta);
- double characSize=sqrt(delta/(double)thisNbOfTuples);
- BBTreePts<2,mcIdType> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
+ double const delta=std::max(xDelta,yDelta);
+ double const characSize=sqrt(delta/(double)thisNbOfTuples);
+ BBTreePts<2,mcIdType> const myTree(begin(),nullptr,0,getNumberOfTuples(),characSize*1e-12);
FindClosestTupleIdAlg<2>(myTree,2.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
break;
}
case 1:
{
- double characSize=fabs(bounds[1]-bounds[0])/FromIdType<double>(thisNbOfTuples);
- BBTreePts<1,mcIdType> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
+ double const characSize=fabs(bounds[1]-bounds[0])/FromIdType<double>(thisNbOfTuples);
+ BBTreePts<1,mcIdType> const myTree(begin(),nullptr,0,getNumberOfTuples(),characSize*1e-12);
FindClosestTupleIdAlg<1>(myTree,1.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
break;
}
throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : input array is NULL !");
if(!isAllocated() || !otherBBoxFrmt->isAllocated())
throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : this and input array must be allocated !");
- std::size_t nbOfComp(getNumberOfComponents());
- mcIdType nbOfTuples(getNumberOfTuples());
+ std::size_t const nbOfComp(getNumberOfComponents());
+ mcIdType const nbOfTuples(getNumberOfTuples());
if(nbOfComp!=otherBBoxFrmt->getNumberOfComponents())
{
std::ostringstream oss; oss << "DataArrayDouble::computeNbOfInteractionsWith : this number of components (" << nbOfComp << ") must be equal to the number of components of input array (" << otherBBoxFrmt->getNumberOfComponents() << ") !";
{
case 3:
{
- BBTree<3,mcIdType> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
+ BBTree<3,mcIdType> bbt(otherBBoxFrmt->begin(),nullptr,0,otherBBoxFrmt->getNumberOfTuples(),eps);
for(mcIdType i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
*retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
break;
}
case 2:
{
- BBTree<2,mcIdType> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
+ BBTree<2,mcIdType> bbt(otherBBoxFrmt->begin(),nullptr,0,otherBBoxFrmt->getNumberOfTuples(),eps);
for(mcIdType i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
*retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
break;
}
case 1:
{
- BBTree<1,mcIdType> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
+ BBTree<1,mcIdType> bbt(otherBBoxFrmt->begin(),nullptr,0,otherBBoxFrmt->getNumberOfTuples(),eps);
for(mcIdType i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
*retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
break;
DataArrayDouble *DataArrayDouble::getDifferentValues(double prec, mcIdType limitTupleId) const
{
checkAllocated();
- DataArrayIdType *c0=0,*cI0=0;
+ DataArrayIdType *c0=nullptr,*cI0=nullptr;
findCommonTuples(prec,limitTupleId,c0,cI0);
MCAuto<DataArrayIdType> c(c0),cI(cI0);
mcIdType newNbOfTuples=-1;
throw INTERP_KERNEL::Exception("DataArrayDouble::setSelectedComponents : input DataArrayDouble is NULL !");
checkAllocated();
copyPartOfStringInfoFrom2(compoIds,*a);
- std::size_t partOfCompoSz=compoIds.size();
- std::size_t nbOfCompo=getNumberOfComponents();
- mcIdType nbOfTuples=std::min(getNumberOfTuples(),a->getNumberOfTuples());
+ std::size_t const partOfCompoSz=compoIds.size();
+ std::size_t const nbOfCompo=getNumberOfComponents();
+ mcIdType const nbOfTuples=std::min(getNumberOfTuples(),a->getNumberOfTuples());
const double *ac=a->getConstPointer();
double *nc=getPointer();
for(mcIdType i=0;i<nbOfTuples;i++)
void DataArrayDouble::checkNoNullValues() const
{
const double *tmp=getConstPointer();
- mcIdType nbOfElems=getNbOfElems();
+ mcIdType const nbOfElems=getNbOfElems();
const double *where=std::find(tmp,tmp+nbOfElems,0.);
if(where!=tmp+nbOfElems)
throw INTERP_KERNEL::Exception("A value 0.0 have been detected !");
void DataArrayDouble::getMinMaxPerComponent(double *bounds) const
{
checkAllocated();
- std::size_t dim=getNumberOfComponents();
+ std::size_t const dim=getNumberOfComponents();
for (std::size_t idim=0; idim<dim; idim++)
{
bounds[idim*2]=std::numeric_limits<double>::max();
bounds[idim*2+1]=-std::numeric_limits<double>::max();
}
const double *ptr=getConstPointer();
- mcIdType nbOfTuples=getNumberOfTuples();
+ mcIdType const nbOfTuples=getNumberOfTuples();
for(mcIdType i=0;i<nbOfTuples;i++)
{
for(std::size_t idim=0;idim<dim;idim++)
{
checkAllocated();
const double *dataPtr=getConstPointer();
- std::size_t nbOfCompo=getNumberOfComponents();
- mcIdType nbTuples=getNumberOfTuples();
+ std::size_t const nbOfCompo=getNumberOfComponents();
+ mcIdType const nbTuples=getNumberOfTuples();
MCAuto<DataArrayDouble> bbox=DataArrayDouble::New();
bbox->alloc(nbTuples,2*nbOfCompo);
double *bboxPtr=bbox->getPointer();
throw INTERP_KERNEL::Exception("DataArrayDouble::computeTupleIdsNearTuples : input pointer other is null !");
checkAllocated();
other->checkAllocated();
- std::size_t nbOfCompo=getNumberOfComponents();
- std::size_t otherNbOfCompo=other->getNumberOfComponents();
+ std::size_t const nbOfCompo=getNumberOfComponents();
+ std::size_t const otherNbOfCompo=other->getNumberOfComponents();
if(nbOfCompo!=otherNbOfCompo)
throw INTERP_KERNEL::Exception("DataArrayDouble::computeTupleIdsNearTuples : number of components should be equal between this and other !");
- mcIdType nbOfTuplesOther=other->getNumberOfTuples();
- mcIdType nbOfTuples=getNumberOfTuples();
+ mcIdType const nbOfTuplesOther=other->getNumberOfTuples();
+ mcIdType const nbOfTuples=getNumberOfTuples();
MCAuto<DataArrayIdType> cArr(DataArrayIdType::New()),cIArr(DataArrayIdType::New()); cArr->alloc(0,1); cIArr->pushBackSilent(0);
switch(nbOfCompo)
{
case 3:
{
- BBTreePts<3,mcIdType> myTree(begin(),0,0,nbOfTuples,eps);
+ BBTreePts<3,mcIdType> const myTree(begin(),nullptr,0,nbOfTuples,eps);
FindTupleIdsNearTuplesAlg<3>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
break;
}
case 2:
{
- BBTreePts<2,mcIdType> myTree(begin(),0,0,nbOfTuples,eps);
+ BBTreePts<2,mcIdType> const myTree(begin(),nullptr,0,nbOfTuples,eps);
FindTupleIdsNearTuplesAlg<2>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
break;
}
case 1:
{
- BBTreePts<1,mcIdType> myTree(begin(),0,0,nbOfTuples,eps);
+ BBTreePts<1,mcIdType> const myTree(begin(),nullptr,0,nbOfTuples,eps);
FindTupleIdsNearTuplesAlg<1>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
break;
}
void DataArrayDouble::recenterForMaxPrecision(double eps)
{
checkAllocated();
- std::size_t dim=getNumberOfComponents();
+ std::size_t const dim=getNumberOfComponents();
std::vector<double> bounds(2*dim);
getMinMaxPerComponent(&bounds[0]);
for(std::size_t i=0;i<dim;i++)
{
- double delta=bounds[2*i+1]-bounds[2*i];
- double offset=(bounds[2*i]+bounds[2*i+1])/2.;
+ double const delta=bounds[2*i+1]-bounds[2*i];
+ double const offset=(bounds[2*i]+bounds[2*i+1])/2.;
if(delta>eps)
applyLin(1./delta,-offset/delta,i);
else
double DataArrayDouble::getMaxValue2(DataArrayIdType*& tupleIds) const
{
mcIdType tmp;
- tupleIds=0;
- double ret=getMaxValue(tmp);
+ tupleIds=nullptr;
+ double const ret=getMaxValue(tmp);
tupleIds=findIdsInRange(ret,ret);
return ret;
}
double DataArrayDouble::getMinValue2(DataArrayIdType*& tupleIds) const
{
mcIdType tmp;
- tupleIds=0;
- double ret=getMinValue(tmp);
+ tupleIds=nullptr;
+ double const ret=getMinValue(tmp);
tupleIds=findIdsInRange(ret,ret);
return ret;
}
if(getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("DataArrayDouble::count : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
const double *vals=begin();
- mcIdType nbOfTuples=getNumberOfTuples();
+ mcIdType const nbOfTuples=getNumberOfTuples();
for(mcIdType i=0;i<nbOfTuples;i++,vals++)
if(fabs(*vals-value)<=eps)
ret++;
{
if(getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("DataArrayDouble::getAverageValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
- mcIdType nbOfTuples(getNumberOfTuples());
+ mcIdType const nbOfTuples(getNumberOfTuples());
if(nbOfTuples<=0)
throw INTERP_KERNEL::Exception("DataArrayDouble::getAverageValue : array exists but number of tuples must be > 0 !");
const double *vals=getConstPointer();
- double ret=std::accumulate(vals,vals+nbOfTuples,0.);
+ double const ret=std::accumulate(vals,vals+nbOfTuples,0.);
return ret/FromIdType<double>(nbOfTuples);
}
{
checkAllocated();
double ret=0.;
- std::size_t nbOfElems=getNbOfElems();
+ std::size_t const nbOfElems=getNbOfElems();
const double *pt=getConstPointer();
for(std::size_t i=0;i<nbOfElems;i++,pt++)
ret+=(*pt)*(*pt);
{
checkAllocated();
double ret(-1.);
- std::size_t nbOfElems(getNbOfElems());
+ std::size_t const nbOfElems(getNbOfElems());
const double *pt(getConstPointer());
for(std::size_t i=0;i<nbOfElems;i++,pt++)
{
- double val(std::abs(*pt));
+ double const val(std::abs(*pt));
if(val>ret)
ret=val;
}
void DataArrayDouble::normMaxPerComponent(double * res) const
{
checkAllocated();
- mcIdType nbOfTuples(getNumberOfTuples());
- std::size_t nbOfCompos(getNumberOfComponents());
+ mcIdType const nbOfTuples(getNumberOfTuples());
+ std::size_t const nbOfCompos(getNumberOfComponents());
std::fill(res, res+nbOfCompos, -1.0);
const double *pt(getConstPointer());
for(mcIdType i=0;i<nbOfTuples;i++)
for (std::size_t j=0; j<nbOfCompos; j++, pt++)
{
- double val(std::abs(*pt));
+ double const val(std::abs(*pt));
if(val>res[j])
res[j]=val;
}
{
checkAllocated();
double ret(std::numeric_limits<double>::max());
- std::size_t nbOfElems(getNbOfElems());
+ std::size_t const nbOfElems(getNbOfElems());
const double *pt(getConstPointer());
for(std::size_t i=0;i<nbOfElems;i++,pt++)
{
- double val(std::abs(*pt));
+ double const val(std::abs(*pt));
if(val<ret)
ret=val;
}
{
checkAllocated();
const double *ptr=getConstPointer();
- mcIdType nbTuple(getNumberOfTuples());
- std::size_t nbComps(getNumberOfComponents());
+ mcIdType const nbTuple(getNumberOfTuples());
+ std::size_t const nbComps(getNumberOfComponents());
std::fill(res,res+nbComps,0.);
for(mcIdType i=0;i<nbTuple;i++)
std::transform(ptr+i*nbComps,ptr+(i+1)*nbComps,res,res,std::plus<double>());
double DataArrayDouble::distanceToTuple(const double *tupleBg, const double *tupleEnd, mcIdType& tupleId) const
{
checkAllocated();
- mcIdType nbTuple(getNumberOfTuples());
- std::size_t nbComps(getNumberOfComponents());
+ mcIdType const nbTuple(getNumberOfTuples());
+ std::size_t const nbComps(getNumberOfComponents());
if(nbComps!=(std::size_t)std::distance(tupleBg,tupleEnd))
{ std::ostringstream oss; oss << "DataArrayDouble::distanceToTuple : size of input tuple is " << std::distance(tupleBg,tupleEnd) << " should be equal to the number of components in this : " << nbComps << " !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); }
if(nbTuple==0)
{
checkAllocated();
const double *ptr=getConstPointer();
- mcIdType nbTuple(getNumberOfTuples());
- std::size_t nbComps(getNumberOfComponents());
+ mcIdType const nbTuple(getNumberOfTuples());
+ std::size_t const nbComps(getNumberOfComponents());
if(compId>=nbComps)
throw INTERP_KERNEL::Exception("DataArrayDouble::accumulate : Invalid compId specified : No such nb of components !");
double ret=0.;
if(!bgOfIndex || !endOfIndex)
throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : input pointer NULL !");
checkAllocated();
- std::size_t nbCompo(getNumberOfComponents());
- mcIdType nbOfTuples(getNumberOfTuples());
+ std::size_t const nbCompo(getNumberOfComponents());
+ mcIdType const nbOfTuples(getNumberOfTuples());
std::size_t sz=std::distance(bgOfIndex,endOfIndex);
if(sz<1)
throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : invalid size of input index array !");
{
checkAllocated();
checkNbOfComps(1,"DataArrayDouble::cumSum : this is expected to be single component");
- mcIdType nbOfTuple(getNumberOfTuples());
+ mcIdType const nbOfTuple(getNumberOfTuples());
MCAuto<DataArrayDouble> ret(DataArrayDouble::New()); ret->alloc(nbOfTuple+1,1);
double *ptr(ret->getPointer());
ptr[0]=0.;
DataArrayDouble *DataArrayDouble::fromPolarToCart() const
{
checkAllocated();
- std::size_t nbOfComp(getNumberOfComponents());
+ std::size_t const nbOfComp(getNumberOfComponents());
if(nbOfComp!=2)
throw INTERP_KERNEL::Exception("DataArrayDouble::fromPolarToCart : must be an array with exactly 2 components !");
- mcIdType nbOfTuple(getNumberOfTuples());
+ mcIdType const nbOfTuple(getNumberOfTuples());
DataArrayDouble *ret(DataArrayDouble::New());
ret->alloc(nbOfTuple,2);
double *w(ret->getPointer());
DataArrayDouble *DataArrayDouble::fromCylToCart() const
{
checkAllocated();
- std::size_t nbOfComp(getNumberOfComponents());
+ std::size_t const nbOfComp(getNumberOfComponents());
if(nbOfComp!=3)
throw INTERP_KERNEL::Exception("DataArrayDouble::fromCylToCart : must be an array with exactly 3 components !");
- mcIdType nbOfTuple(getNumberOfTuples());
+ mcIdType const nbOfTuple(getNumberOfTuples());
DataArrayDouble *ret(DataArrayDouble::New());
ret->alloc(getNumberOfTuples(),3);
double *w(ret->getPointer());
DataArrayDouble *DataArrayDouble::fromSpherToCart() const
{
checkAllocated();
- std::size_t nbOfComp(getNumberOfComponents());
+ std::size_t const nbOfComp(getNumberOfComponents());
if(nbOfComp!=3)
throw INTERP_KERNEL::Exception("DataArrayDouble::fromSpherToCart : must be an array with exactly 3 components !");
- mcIdType nbOfTuple(getNumberOfTuples());
+ mcIdType const nbOfTuple(getNumberOfTuples());
DataArrayDouble *ret(DataArrayDouble::New());
ret->alloc(getNumberOfTuples(),3);
double *w(ret->getPointer());
DataArrayDouble *DataArrayDouble::cartesianize(MEDCouplingAxisType atOfThis) const
{
checkAllocated();
- std::size_t nbOfComp(getNumberOfComponents());
+ std::size_t const nbOfComp(getNumberOfComponents());
MCAuto<DataArrayDouble> ret;
switch(atOfThis)
{
{
MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
checkAllocated();
- std::size_t nbOfComp(getNumberOfComponents());
- mcIdType nbTuples(getNumberOfTuples());
+ std::size_t const nbOfComp(getNumberOfComponents());
+ mcIdType const nbTuples(getNumberOfTuples());
if(nbOfComp!=2)
throw INTERP_KERNEL::Exception("DataArrayDouble::fromCartToPolar : must be an array with exactly 2 components !");
ret->alloc(nbTuples,2);
{
MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
checkAllocated();
- std::size_t nbOfComp(getNumberOfComponents());
- mcIdType nbTuples(getNumberOfTuples());
+ std::size_t const nbOfComp(getNumberOfComponents());
+ mcIdType const nbTuples(getNumberOfTuples());
if(nbOfComp!=3)
throw INTERP_KERNEL::Exception("DataArrayDouble::fromCartToCyl : must be an array with exactly 3 components !");
ret->alloc(nbTuples,3);
{
MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
checkAllocated();
- std::size_t nbOfComp(getNumberOfComponents());
- mcIdType nbTuples(getNumberOfTuples());
+ std::size_t const nbOfComp(getNumberOfComponents());
+ mcIdType const nbTuples(getNumberOfTuples());
if(nbOfComp!=3)
throw INTERP_KERNEL::Exception("DataArrayDouble::fromCartToSpher : must be an array with exactly 3 components !");
ret->alloc(nbTuples,3);
throw INTERP_KERNEL::Exception("DataArrayDouble::fromCartToCylGiven : input coords are NULL !");
MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
checkAllocated(); coords->checkAllocated();
- std::size_t nbOfComp(getNumberOfComponents());
- mcIdType nbTuples(getNumberOfTuples());
+ std::size_t const nbOfComp(getNumberOfComponents());
+ mcIdType const nbTuples(getNumberOfTuples());
if(nbOfComp!=3)
throw INTERP_KERNEL::Exception("DataArrayDouble::fromCartToCylGiven : must be an array with exactly 3 components !");
if(coords->getNumberOfComponents()!=3)
if(coords->getNumberOfTuples()!=nbTuples)
throw INTERP_KERNEL::Exception("DataArrayDouble::fromCartToCylGiven : coords array must have the same number of tuples !");
ret->alloc(nbTuples,nbOfComp);
- double magOfVect(sqrt(vect[0]*vect[0]+vect[1]*vect[1]+vect[2]*vect[2]));
+ double const magOfVect(sqrt(vect[0]*vect[0]+vect[1]*vect[1]+vect[2]*vect[2]));
if(magOfVect<1e-12)
throw INTERP_KERNEL::Exception("DataArrayDouble::fromCartToCylGiven : magnitude of vect is too low !");
double Ur[3],Uteta[3],Uz[3],*retPtr(ret->getPointer());
{
std::transform(coo,coo+3,center,Ur,std::minus<double>());
Uteta[0]=Uz[1]*Ur[2]-Uz[2]*Ur[1]; Uteta[1]=Uz[2]*Ur[0]-Uz[0]*Ur[2]; Uteta[2]=Uz[0]*Ur[1]-Uz[1]*Ur[0];
- double magOfTeta(sqrt(Uteta[0]*Uteta[0]+Uteta[1]*Uteta[1]+Uteta[2]*Uteta[2]));
+ double const magOfTeta(sqrt(Uteta[0]*Uteta[0]+Uteta[1]*Uteta[1]+Uteta[2]*Uteta[2]));
std::transform(Uteta,Uteta+3,Uteta,std::bind(std::multiplies<double>(),std::placeholders::_1,1./magOfTeta));
Ur[0]=Uteta[1]*Uz[2]-Uteta[2]*Uz[1]; Ur[1]=Uteta[2]*Uz[0]-Uteta[0]*Uz[2]; Ur[2]=Uteta[0]*Uz[1]-Uteta[1]*Uz[0];
retPtr[0]=Ur[0]*vectField[0]+Ur[1]*vectField[1]+Ur[2]*vectField[2];
DataArrayDouble *DataArrayDouble::doublyContractedProduct() const
{
checkAllocated();
- std::size_t nbOfComp(getNumberOfComponents());
+ std::size_t const nbOfComp(getNumberOfComponents());
if(nbOfComp!=6)
throw INTERP_KERNEL::Exception("DataArrayDouble::doublyContractedProduct : must be an array with exactly 6 components !");
DataArrayDouble *ret=DataArrayDouble::New();
- mcIdType nbOfTuple=getNumberOfTuples();
+ mcIdType const nbOfTuple=getNumberOfTuples();
ret->alloc(nbOfTuple,1);
const double *src=getConstPointer();
double *dest=ret->getPointer();
{
checkAllocated();
DataArrayDouble *ret=DataArrayDouble::New();
- mcIdType nbOfTuple=getNumberOfTuples();
+ mcIdType const nbOfTuple=getNumberOfTuples();
ret->alloc(nbOfTuple,1);
const double *src=getConstPointer();
double *dest=ret->getPointer();
DataArrayDouble *DataArrayDouble::eigenValues() const
{
checkAllocated();
- std::size_t nbOfComp=getNumberOfComponents();
+ std::size_t const nbOfComp=getNumberOfComponents();
if(nbOfComp!=6)
throw INTERP_KERNEL::Exception("DataArrayDouble::eigenValues : must be an array with exactly 6 components !");
DataArrayDouble *ret=DataArrayDouble::New();
- mcIdType nbOfTuple=getNumberOfTuples();
+ mcIdType const nbOfTuple=getNumberOfTuples();
ret->alloc(nbOfTuple,3);
const double *src=getConstPointer();
double *dest=ret->getPointer();
DataArrayDouble *DataArrayDouble::eigenVectors() const
{
checkAllocated();
- std::size_t nbOfComp=getNumberOfComponents();
+ std::size_t const nbOfComp=getNumberOfComponents();
if(nbOfComp!=6)
throw INTERP_KERNEL::Exception("DataArrayDouble::eigenVectors : must be an array with exactly 6 components !");
DataArrayDouble *ret=DataArrayDouble::New();
- mcIdType nbOfTuple=getNumberOfTuples();
+ mcIdType const nbOfTuple=getNumberOfTuples();
ret->alloc(nbOfTuple,9);
const double *src=getConstPointer();
double *dest=ret->getPointer();
DataArrayDouble *DataArrayDouble::inverse() const
{
checkAllocated();
- std::size_t nbOfComp=getNumberOfComponents();
+ std::size_t const nbOfComp=getNumberOfComponents();
if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
throw INTERP_KERNEL::Exception("DataArrayDouble::inversion : must be an array with 4,6 or 9 components !");
DataArrayDouble *ret=DataArrayDouble::New();
- mcIdType nbOfTuple=getNumberOfTuples();
+ mcIdType const nbOfTuple=getNumberOfTuples();
ret->alloc(nbOfTuple,nbOfComp);
const double *src=getConstPointer();
double *dest=ret->getPointer();
if(nbOfComp==6)
for(mcIdType i=0;i<nbOfTuple;i++,dest+=6,src+=6)
{
- double det=src[0]*src[1]*src[2]+2.*src[4]*src[5]*src[3]-src[0]*src[4]*src[4]-src[2]*src[3]*src[3]-src[1]*src[5]*src[5];
+ double const det=src[0]*src[1]*src[2]+2.*src[4]*src[5]*src[3]-src[0]*src[4]*src[4]-src[2]*src[3]*src[3]-src[1]*src[5]*src[5];
dest[0]=(src[1]*src[2]-src[4]*src[4])/det;
dest[1]=(src[0]*src[2]-src[5]*src[5])/det;
dest[2]=(src[0]*src[1]-src[3]*src[3])/det;
else if(nbOfComp==4)
for(mcIdType i=0;i<nbOfTuple;i++,dest+=4,src+=4)
{
- double det=src[0]*src[3]-src[1]*src[2];
+ double const det=src[0]*src[3]-src[1]*src[2];
dest[0]=src[3]/det;
dest[1]=-src[1]/det;
dest[2]=-src[2]/det;
else
for(mcIdType i=0;i<nbOfTuple;i++,dest+=9,src+=9)
{
- double det=src[0]*src[4]*src[8]+src[1]*src[5]*src[6]+src[2]*src[3]*src[7]-src[0]*src[5]*src[7]-src[1]*src[3]*src[8]-src[2]*src[4]*src[6];
+ double const det=src[0]*src[4]*src[8]+src[1]*src[5]*src[6]+src[2]*src[3]*src[7]-src[0]*src[5]*src[7]-src[1]*src[3]*src[8]-src[2]*src[4]*src[6];
dest[0]=(src[4]*src[8]-src[7]*src[5])/det;
dest[1]=(src[7]*src[2]-src[1]*src[8])/det;
dest[2]=(src[1]*src[5]-src[4]*src[2])/det;
DataArrayDouble *DataArrayDouble::trace() const
{
checkAllocated();
- std::size_t nbOfComp=getNumberOfComponents();
+ std::size_t const nbOfComp=getNumberOfComponents();
if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
throw INTERP_KERNEL::Exception("DataArrayDouble::trace : must be an array with 4,6 or 9 components !");
DataArrayDouble *ret=DataArrayDouble::New();
- mcIdType nbOfTuple=getNumberOfTuples();
+ mcIdType const nbOfTuple=getNumberOfTuples();
ret->alloc(nbOfTuple,1);
const double *src=getConstPointer();
double *dest=ret->getPointer();
DataArrayDouble *DataArrayDouble::deviator() const
{
checkAllocated();
- std::size_t nbOfComp=getNumberOfComponents();
+ std::size_t const nbOfComp=getNumberOfComponents();
if(nbOfComp!=6)
throw INTERP_KERNEL::Exception("DataArrayDouble::deviator : must be an array with exactly 6 components !");
DataArrayDouble *ret=DataArrayDouble::New();
- mcIdType nbOfTuple=getNumberOfTuples();
+ mcIdType const nbOfTuple=getNumberOfTuples();
ret->alloc(nbOfTuple,6);
const double *src=getConstPointer();
double *dest=ret->getPointer();
for(mcIdType i=0;i<nbOfTuple;i++,dest+=6,src+=6)
{
- double tr=(src[0]+src[1]+src[2])/3.;
+ double const tr=(src[0]+src[1]+src[2])/3.;
dest[0]=src[0]-tr;
dest[1]=src[1]-tr;
dest[2]=src[2]-tr;
DataArrayDouble *DataArrayDouble::magnitude() const
{
checkAllocated();
- std::size_t nbOfComp=getNumberOfComponents();
+ std::size_t const nbOfComp=getNumberOfComponents();
DataArrayDouble *ret=DataArrayDouble::New();
- mcIdType nbOfTuple=getNumberOfTuples();
+ mcIdType const nbOfTuple=getNumberOfTuples();
ret->alloc(nbOfTuple,1);
const double *src=getConstPointer();
double *dest=ret->getPointer();
DataArrayDouble *DataArrayDouble::operatePerTuple(std::function<double(const double *bg, const double *endd)> func) const
{
checkAllocated();
- std::size_t nbOfComp(getNumberOfComponents());
+ std::size_t const nbOfComp(getNumberOfComponents());
MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- mcIdType nbOfTuple(getNumberOfTuples());
+ mcIdType const nbOfTuple(getNumberOfTuples());
ret->alloc(nbOfTuple,1);
const double *src=getConstPointer();
double *dest=ret->getPointer();
DataArrayDouble *DataArrayDouble::maxPerTupleWithCompoId(DataArrayIdType* &compoIdOfMaxPerTuple) const
{
checkAllocated();
- std::size_t nbOfComp(getNumberOfComponents());
+ std::size_t const nbOfComp(getNumberOfComponents());
MCAuto<DataArrayDouble> ret0=DataArrayDouble::New();
MCAuto<DataArrayIdType> ret1=DataArrayIdType::New();
- mcIdType nbOfTuple=getNumberOfTuples();
+ mcIdType const nbOfTuple=getNumberOfTuples();
ret0->alloc(nbOfTuple,1); ret1->alloc(nbOfTuple,1);
const double *src=getConstPointer();
double *dest=ret0->getPointer(); mcIdType *dest1=ret1->getPointer();
DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrix() const
{
checkAllocated();
- std::size_t nbOfComp(getNumberOfComponents());
- mcIdType nbOfTuples(getNumberOfTuples());
+ std::size_t const nbOfComp(getNumberOfComponents());
+ mcIdType const nbOfTuples(getNumberOfTuples());
const double *inData=getConstPointer();
MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
ret->alloc(nbOfTuples*nbOfTuples,1);
{
double dist=0.;
for(std::size_t k=0;k<nbOfComp;k++)
- { double delta=inData[i*nbOfComp+k]-inData[j*nbOfComp+k]; dist+=delta*delta; }
+ { double const delta=inData[i*nbOfComp+k]-inData[j*nbOfComp+k]; dist+=delta*delta; }
dist=sqrt(dist);
outData[i*nbOfTuples+j]=dist;
outData[j*nbOfTuples+i]=dist;
throw INTERP_KERNEL::Exception("DataArrayDouble::buildEuclidianDistanceDenseMatrixWith : input parameter is null !");
checkAllocated();
other->checkAllocated();
- std::size_t nbOfComp(getNumberOfComponents());
- std::size_t otherNbOfComp(other->getNumberOfComponents());
+ std::size_t const nbOfComp(getNumberOfComponents());
+ std::size_t const otherNbOfComp(other->getNumberOfComponents());
if(nbOfComp!=otherNbOfComp)
{
std::ostringstream oss; oss << "DataArrayDouble::buildEuclidianDistanceDenseMatrixWith : this nb of compo=" << nbOfComp << " and other nb of compo=" << otherNbOfComp << ". It should match !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- mcIdType nbOfTuples(getNumberOfTuples());
- mcIdType otherNbOfTuples(other->getNumberOfTuples());
+ mcIdType const nbOfTuples(getNumberOfTuples());
+ mcIdType const otherNbOfTuples(other->getNumberOfTuples());
const double *inData=getConstPointer();
const double *inDataOther=other->getConstPointer();
MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
{
double dist=0.;
for(std::size_t k=0;k<nbOfComp;k++)
- { double delta=inDataOther[k]-inData[j*nbOfComp+k]; dist+=delta*delta; }
+ { double const delta=inDataOther[k]-inData[j*nbOfComp+k]; dist+=delta*delta; }
dist=sqrt(dist);
outData[i*nbOfTuples+j]=dist;
}
void DataArrayDouble::asArcOfCircle(double center[2], double& radius, double& ang) const
{
checkAllocated();
- INTERP_KERNEL::QuadraticPlanarPrecision arcPrec(1e-14);
+ INTERP_KERNEL::QuadraticPlanarPrecision const arcPrec(1e-14);
if(getNumberOfTuples()!=3 && getNumberOfComponents()!=2)
throw INTERP_KERNEL::Exception("DataArrayDouble::asArcCircle : this method expects");
const double *pt(begin());
MCAuto<INTERP_KERNEL::Node> n0(new INTERP_KERNEL::Node(pt[0],pt[1])),n1(new INTERP_KERNEL::Node(pt[2],pt[3])),n2(new INTERP_KERNEL::Node(pt[4],pt[5]));
{
INTERP_KERNEL::AutoCppPtr<INTERP_KERNEL::EdgeLin> e1(new INTERP_KERNEL::EdgeLin(n0,n2)),e2(new INTERP_KERNEL::EdgeLin(n2,n1));
- INTERP_KERNEL::SegSegIntersector inters(*e1,*e2);
- bool colinearity(inters.areColinears());
+ INTERP_KERNEL::SegSegIntersector const inters(*e1,*e2);
+ bool const colinearity(inters.areColinears());
if(colinearity)
throw INTERP_KERNEL::Exception("DataArrayDouble::asArcOfCircle : 3 points in this have been detected as colinear !");
}
{
checkAllocated();
double *pt=getPointer();
- mcIdType nbOfTuple(getNumberOfTuples());
- std::size_t nbOfComp(getNumberOfComponents());
+ mcIdType const nbOfTuple(getNumberOfTuples());
+ std::size_t const nbOfComp(getNumberOfComponents());
if(asc)
for(mcIdType i=0;i<nbOfTuple;i++,pt+=nbOfComp)
std::sort(pt,pt+nbOfComp);
{
checkAllocated();
double *ptr=getPointer();
- std::size_t nbOfElems=getNbOfElems();
+ std::size_t const nbOfElems=getNbOfElems();
for(std::size_t i=0;i<nbOfElems;i++,ptr++)
{
if(std::abs(*ptr)>std::numeric_limits<double>::min())
{
checkAllocated();
double *ptr=getPointer();
- std::size_t nbOfElems=getNbOfElems();
- int val2=(int)val;
- bool isInt=((double)val2)==val;
+ std::size_t const nbOfElems=getNbOfElems();
+ int const val2=(int)val;
+ bool const isInt=((double)val2)==val;
if(!isInt)
{
for(std::size_t i=0;i<nbOfElems;i++,ptr++)
if(val<0.)
throw INTERP_KERNEL::Exception("DataArrayDouble::applyRPow : the input value has to be >= 0 !");
double *ptr=getPointer();
- std::size_t nbOfElems=getNbOfElems();
+ std::size_t const nbOfElems=getNbOfElems();
for(std::size_t i=0;i<nbOfElems;i++,ptr++)
*ptr=pow(val,*ptr);
declareAsNew();
{
checkAllocated();
DataArrayDouble *newArr=DataArrayDouble::New();
- mcIdType nbOfTuples(getNumberOfTuples());
- std::size_t oldNbOfComp(getNumberOfComponents());
+ mcIdType const nbOfTuples(getNumberOfTuples());
+ std::size_t const oldNbOfComp(getNumberOfComponents());
newArr->alloc(nbOfTuples,nbOfComp);
const double *ptr=getConstPointer();
double *ptrToFill=newArr->getPointer();
expr.parse();
std::set<std::string> vars;
expr.getTrueSetOfVars(vars);
- std::vector<std::string> varsV(vars.begin(),vars.end());
+ std::vector<std::string> const varsV(vars.begin(),vars.end());
return applyFuncNamedCompo(nbOfComp,varsV,func,isSafe);
}
*/
DataArrayDouble *DataArrayDouble::applyFunc(const std::string& func, bool isSafe) const
{
- std::size_t nbOfComp(getNumberOfComponents());
+ std::size_t const nbOfComp(getNumberOfComponents());
if(nbOfComp<=0)
throw INTERP_KERNEL::Exception("DataArrayDouble::applyFunc : output number of component must be > 0 !");
checkAllocated();
- mcIdType nbOfTuples(getNumberOfTuples());
+ mcIdType const nbOfTuples(getNumberOfTuples());
MCAuto<DataArrayDouble> newArr(DataArrayDouble::New());
newArr->alloc(nbOfTuples,nbOfComp);
INTERP_KERNEL::ExprParser expr(func);
newArr->rearrange(nbOfComp);
return newArr.retn();
}
- std::vector<std::string> vars2(vars.begin(),vars.end());
+ std::vector<std::string> const vars2(vars.begin(),vars.end());
double buff,*ptrToFill(newArr->getPointer());
const double *ptr(begin());
std::vector<double> stck;
*/
void DataArrayDouble::applyFuncOnThis(const std::string& func, bool isSafe)
{
- std::size_t nbOfComp(getNumberOfComponents());
+ std::size_t const nbOfComp(getNumberOfComponents());
if(nbOfComp<=0)
throw INTERP_KERNEL::Exception("DataArrayDouble::applyFuncOnThis : output number of component must be > 0 !");
checkAllocated();
- mcIdType nbOfTuples(getNumberOfTuples());
+ mcIdType const nbOfTuples(getNumberOfTuples());
INTERP_KERNEL::ExprParser expr(func);
expr.parse();
std::set<std::string> vars;
if(vars.empty())
{
expr.prepareFastEvaluator();
- std::vector<std::string> compInfo(getInfoOnComponents());
+ std::vector<std::string> const compInfo(getInfoOnComponents());
rearrange(1);
fillWithValue(expr.evaluateDouble());
rearrange(nbOfComp);
setInfoOnComponents(compInfo);
return ;
}
- std::vector<std::string> vars2(vars.begin(),vars.end());
+ std::vector<std::string> const vars2(vars.begin(),vars.end());
double buff,*ptrToFill(getPointer());
const double *ptr(begin());
std::vector<double> stck;
if(nbOfComp<=0)
throw INTERP_KERNEL::Exception("DataArrayDouble::applyFuncNamedCompo : output number of component must be > 0 !");
std::vector<std::string> varsOrder2(varsOrder);
- std::size_t oldNbOfComp(getNumberOfComponents());
+ std::size_t const oldNbOfComp(getNumberOfComponents());
for(std::size_t i=varsOrder.size();i<oldNbOfComp;i++)
varsOrder2.push_back(std::string());
checkAllocated();
- mcIdType nbOfTuples(getNumberOfTuples());
+ mcIdType const nbOfTuples(getNumberOfTuples());
INTERP_KERNEL::ExprParser expr(func);
expr.parse();
std::set<std::string> vars;
*((void **)&funcPtr)=funcStr;//he he...
//
double *ptr=getPointer();
- std::size_t nbOfComp=getNumberOfComponents();
- mcIdType nbOfTuples=getNumberOfTuples();
- std::size_t nbOfElems=nbOfTuples*nbOfComp;
+ std::size_t const nbOfComp=getNumberOfComponents();
+ mcIdType const nbOfTuples=getNumberOfTuples();
+ std::size_t const nbOfElems=nbOfTuples*nbOfComp;
for(std::size_t i=0;i<nbOfElems;i++,ptr++)
*ptr=funcPtr(*ptr);
declareAsNew();
*((void **)&funcPtr)=funcStr;//he he...
//
double *ptr=getPointer();
- std::size_t nbOfComp=getNumberOfComponents();
- mcIdType nbOfTuples=getNumberOfTuples();
- std::size_t nbOfElems=nbOfTuples*nbOfComp;
+ std::size_t const nbOfComp=getNumberOfComponents();
+ mcIdType const nbOfTuples=getNumberOfTuples();
+ std::size_t const nbOfElems=nbOfTuples*nbOfComp;
for(std::size_t i=0;i<nbOfElems;i++,ptr++)
*ptr=funcPtr(*ptr);
declareAsNew();
checkAllocated();
if(getNumberOfComponents()!=3)
throw INTERP_KERNEL::Exception("DataArrayDouble::symmetry3DPlane : this is excepted to have 3 components !");
- mcIdType nbTuples(getNumberOfTuples());
+ mcIdType const nbTuples(getNumberOfTuples());
MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
ret->alloc(nbTuples,3);
Symmetry3DPlane(point,normalVector,nbTuples,begin(),ret->getPointer());
throw INTERP_KERNEL::Exception("DataArrayDouble::findIdsInRange : this must have exactly one component !");
const double *cptr(begin());
MCAuto<DataArrayIdType> ret(DataArrayIdType::New()); ret->alloc(0,1);
- mcIdType nbOfTuples(getNumberOfTuples());
+ mcIdType const nbOfTuples(getNumberOfTuples());
for(mcIdType i=0;i<nbOfTuples;i++,cptr++)
if(*cptr>=vmin && *cptr<=vmax)
ret->pushBackSilent(i);
throw INTERP_KERNEL::Exception("DataArrayDouble::findIdsNotInRange : this must have exactly one component !");
const double *cptr(begin());
MCAuto<DataArrayIdType> ret(DataArrayIdType::New()); ret->alloc(0,1);
- mcIdType nbOfTuples(getNumberOfTuples());
+ mcIdType const nbOfTuples(getNumberOfTuples());
for(mcIdType i=0;i<nbOfTuples;i++,cptr++)
if(*cptr<vmin || *cptr>vmax)
ret->pushBackSilent(i);
DataArrayDouble *DataArrayDouble::Aggregate(const std::vector<const DataArrayDouble *>& arr)
{
std::vector<const DataArrayDouble *> a;
- for(std::vector<const DataArrayDouble *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
- if(*it4)
- a.push_back(*it4);
+ for(auto it4 : arr)
+ if(it4)
+ a.push_back(it4);
if(a.empty())
throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : input list must contain at least one NON EMPTY DataArrayDouble !");
std::vector<const DataArrayDouble *>::const_iterator it=a.begin();
- std::size_t nbOfComp((*it)->getNumberOfComponents());
+ std::size_t const nbOfComp((*it)->getNumberOfComponents());
mcIdType nbt=(*it++)->getNumberOfTuples();
for(mcIdType i=1;it!=a.end();it++,i++)
{
throw INTERP_KERNEL::Exception("DataArrayDouble::Dot : input DataArrayDouble instance is NULL !");
a1->checkAllocated();
a2->checkAllocated();
- std::size_t nbOfComp(a1->getNumberOfComponents());
+ std::size_t const nbOfComp(a1->getNumberOfComponents());
if(nbOfComp!=a2->getNumberOfComponents())
throw INTERP_KERNEL::Exception("Nb of components mismatch for array Dot !");
- mcIdType nbOfTuple(a1->getNumberOfTuples());
+ mcIdType const nbOfTuple(a1->getNumberOfTuples());
if(nbOfTuple!=a2->getNumberOfTuples())
throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Dot !");
DataArrayDouble *ret=DataArrayDouble::New();
{
if(!a1 || !a2)
throw INTERP_KERNEL::Exception("DataArrayDouble::CrossProduct : input DataArrayDouble instance is NULL !");
- std::size_t nbOfComp(a1->getNumberOfComponents());
+ std::size_t const nbOfComp(a1->getNumberOfComponents());
if(nbOfComp!=a2->getNumberOfComponents())
throw INTERP_KERNEL::Exception("Nb of components mismatch for array crossProduct !");
if(nbOfComp!=3)
throw INTERP_KERNEL::Exception("Nb of components must be equal to 3 for array crossProduct !");
- mcIdType nbOfTuple(a1->getNumberOfTuples());
+ mcIdType const nbOfTuple(a1->getNumberOfTuples());
if(nbOfTuple!=a2->getNumberOfTuples())
throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array crossProduct !");
DataArrayDouble *ret=DataArrayDouble::New();
{
if(!a1 || !a2)
throw INTERP_KERNEL::Exception("DataArrayDouble::Max : input DataArrayDouble instance is NULL !");
- std::size_t nbOfComp(a1->getNumberOfComponents());
+ std::size_t const nbOfComp(a1->getNumberOfComponents());
if(nbOfComp!=a2->getNumberOfComponents())
throw INTERP_KERNEL::Exception("Nb of components mismatch for array Max !");
- mcIdType nbOfTuple(a1->getNumberOfTuples());
+ mcIdType const nbOfTuple(a1->getNumberOfTuples());
if(nbOfTuple!=a2->getNumberOfTuples())
throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Max !");
MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
ret->alloc(nbOfTuple,nbOfComp);
double *retPtr(ret->getPointer());
const double *a1Ptr(a1->begin()),*a2Ptr(a2->begin());
- std::size_t nbElem(nbOfTuple*nbOfComp);
+ std::size_t const nbElem(nbOfTuple*nbOfComp);
for(std::size_t i=0;i<nbElem;i++)
retPtr[i]=std::max(a1Ptr[i],a2Ptr[i]);
ret->copyStringInfoFrom(*a1);
{
if(!a1 || !a2)
throw INTERP_KERNEL::Exception("DataArrayDouble::Min : input DataArrayDouble instance is NULL !");
- std::size_t nbOfComp(a1->getNumberOfComponents());
+ std::size_t const nbOfComp(a1->getNumberOfComponents());
if(nbOfComp!=a2->getNumberOfComponents())
throw INTERP_KERNEL::Exception("Nb of components mismatch for array min !");
- mcIdType nbOfTuple(a1->getNumberOfTuples());
+ mcIdType const nbOfTuple(a1->getNumberOfTuples());
if(nbOfTuple!=a2->getNumberOfTuples())
throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array min !");
MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
ret->alloc(nbOfTuple,nbOfComp);
double *retPtr(ret->getPointer());
const double *a1Ptr(a1->begin()),*a2Ptr(a2->begin());
- std::size_t nbElem(nbOfTuple*nbOfComp);
+ std::size_t const nbElem(nbOfTuple*nbOfComp);
for(std::size_t i=0;i<nbElem;i++)
retPtr[i]=std::min(a1Ptr[i],a2Ptr[i]);
ret->copyStringInfoFrom(*a1);
{
if(!a1 || !a2)
throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : at least one of input instances is null !");
- mcIdType nbOfTuple=a1->getNumberOfTuples();
- mcIdType nbOfTuple2=a2->getNumberOfTuples();
- std::size_t nbOfComp=a1->getNumberOfComponents();
- std::size_t nbOfComp2=a2->getNumberOfComponents();
+ mcIdType const nbOfTuple=a1->getNumberOfTuples();
+ mcIdType const nbOfTuple2=a2->getNumberOfTuples();
+ std::size_t const nbOfComp=a1->getNumberOfComponents();
+ std::size_t const nbOfComp2=a2->getNumberOfComponents();
if(nbOfTuple!=nbOfTuple2)
throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : number of tuples mismatches !");
if(nbOfComp!=1 || nbOfComp2!=1)
{
if(!other)
throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : input instance is null !");
- mcIdType nbOfTuple=getNumberOfTuples();
- mcIdType nbOfTuple2=other->getNumberOfTuples();
- std::size_t nbOfComp=getNumberOfComponents();
- std::size_t nbOfComp2=other->getNumberOfComponents();
+ mcIdType const nbOfTuple=getNumberOfTuples();
+ mcIdType const nbOfTuple2=other->getNumberOfTuples();
+ std::size_t const nbOfComp=getNumberOfComponents();
+ std::size_t const nbOfComp2=other->getNumberOfComponents();
if(nbOfTuple!=nbOfTuple2)
throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : number of tuples mismatches !");
if(nbOfComp!=1 || nbOfComp2!=1)
checkAllocated();
if(getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("DataArrayDouble::toVectorOfBool : must be applied on single component array !");
- mcIdType nbt(getNumberOfTuples());
+ mcIdType const nbt(getNumberOfTuples());
std::vector<bool> ret(nbt);
const double *pt(begin());
for(mcIdType i=0;i<nbt;i++)
{
if(isAllocated())
{
- std::size_t nbOfCompo(getNumberOfComponents());
+ std::size_t const nbOfCompo(getNumberOfComponents());
tinyInfo.resize(nbOfCompo+1);
tinyInfo[0]=getName();
for(std::size_t i=0;i<nbOfCompo;i++)
*/
bool DataArrayDouble::resizeForUnserialization(const std::vector<mcIdType>& tinyInfoI)
{
- mcIdType nbOfTuple=tinyInfoI[0];
- mcIdType nbOfComp=tinyInfoI[1];
+ mcIdType const nbOfTuple=tinyInfoI[0];
+ mcIdType const nbOfComp=tinyInfoI[1];
if(nbOfTuple!=-1 || nbOfComp!=-1)
{
alloc(nbOfTuple,nbOfComp);
/*!
* Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
*/
-void DataArrayDouble::finishUnserialization(const std::vector<mcIdType>& tinyInfoI, const std::vector<std::string>& tinyInfoS)
+void DataArrayDouble::finishUnserialization(const std::vector<mcIdType>& /*tinyInfoI*/, const std::vector<std::string>& tinyInfoS)
{
setName(tinyInfoS[0]);
if(isAllocated())
{
- std::size_t nbOfCompo(getNumberOfComponents());
+ std::size_t const nbOfCompo(getNumberOfComponents());
for(std::size_t i=0;i<nbOfCompo;i++)
setInfoOnComponent(i,tinyInfoS[i+1]);
}
{
if(!center || !vect)
throw INTERP_KERNEL::Exception("DataArrayDouble::Rotate3DAlg : null vector in input !");
- double sina(sin(angle));
- double cosa(cos(angle));
+ double const sina(sin(angle));
+ double const cosa(cos(angle));
double vectorNorm[3];
double matrix[9];
double matrixTmp[9];
- double norm(sqrt(vect[0]*vect[0]+vect[1]*vect[1]+vect[2]*vect[2]));
+ double const norm(sqrt(vect[0]*vect[0]+vect[1]*vect[1]+vect[2]*vect[2]));
if(norm<std::numeric_limits<double>::min())
throw INTERP_KERNEL::Exception("DataArrayDouble::Rotate3DAlg : magnitude of input vector is too close of 0. !");
std::transform(vect,vect+3,vectorNorm,std::bind(std::multiplies<double>(),std::placeholders::_1,1/norm));
*/
void DataArrayDouble::Rotate2DAlg(const double *center, double angle, mcIdType nbNodes, const double *coordsIn, double *coordsOut)
{
- double cosa=cos(angle);
- double sina=sin(angle);
+ double const cosa=cos(angle);
+ double const sina=sin(angle);
double matrix[4];
matrix[0]=cosa; matrix[1]=-sina; matrix[2]=sina; matrix[3]=cosa;
double tmp[2];
#include "MEDCouplingMap.hxx"
#include "BBTreePts.txx"
+#include <cstddef>
+#include <ostream>
#include <string>
+#include <utility>
#include <vector>
-#include <iterator>
#include <functional>
namespace MEDCoupling
class MEDCouplingPointer
{
public:
- MEDCouplingPointer():_internal(0),_external(0) { }
+ MEDCouplingPointer():_internal(nullptr),_external(nullptr) { }
void null() { _internal=0; _external=0; }
bool isNull() const { return _internal==0 && _external==0; }
void setInternal(T *pointer);
void setExternal(const T *pointer);
const T *getConstPointer() const { if(_internal) return _internal; else return _external; }
const T *getConstPointerLoc(std::size_t offset) const { if(_internal) return _internal+offset; else return _external+offset; }
- T *getPointer() { if(_internal) return _internal; if(_external) throw INTERP_KERNEL::Exception("Trying to write on an external pointer."); else return 0; }
+ T *getPointer() { if(_internal) return _internal; if(_external) throw INTERP_KERNEL::Exception("Trying to write on an external pointer."); else return nullptr; }
private:
T *_internal;
const T *_external;
class MemArray
{
public:
- typedef void (*Deallocator)(void *,void *);
+ using Deallocator = void (*)(void *, void *);
public:
- MemArray():_nb_of_elem(0),_nb_of_elem_alloc(0),_ownership(false),_dealloc(0),_param_for_deallocator(0) { }
+ MemArray() = default;
MemArray(const MemArray<T>& other);
bool isNull() const { return _pointer.isNull(); }
const T *getConstPointerLoc(std::size_t offset) const { return _pointer.getConstPointerLoc(offset); }
static void DestroyPointer(T *pt, Deallocator dealloc, void *param);
static Deallocator BuildFromType(DeallocType type);
private:
- std::size_t _nb_of_elem;
- std::size_t _nb_of_elem_alloc;
- bool _ownership;
+ std::size_t _nb_of_elem{0};
+ std::size_t _nb_of_elem_alloc{0};
+ bool _ownership{false};
MEDCouplingPointer<T> _pointer;
- Deallocator _dealloc;
- void *_param_for_deallocator;
+ Deallocator _dealloc{nullptr};
+ void *_param_for_deallocator{nullptr};
};
template <class T> class DataArrayTools
class MEDCOUPLING_EXPORT DataArray : public RefCountObject, public TimeLabel
{
public:
- std::size_t getHeapMemorySizeWithoutChildren() const;
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
void setName(const std::string& name);
void copyStringInfoFrom(const DataArray& other);
void copyPartOfStringInfoFrom(const DataArray& other, const std::vector<std::size_t>& compoIds);
virtual void reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const = 0;
protected:
DataArray() { }
- ~DataArray() { }
+ ~DataArray() override = default;
protected:
static void CheckValueInRange(mcIdType ref, mcIdType value, const std::string& msg);
static void CheckValueInRangeEx(mcIdType value, mcIdType start, mcIdType end, const std::string& msg);
class DataArrayTemplate : public DataArray
{
public:
- typedef T Type;
+ using Type = T;
public:
static MCAuto< typename Traits<T>::ArrayTypeCh > NewFromStdVector(const typename std::vector<T>& v);
static MCAuto< typename Traits<T>::ArrayTypeCh > NewFromArray(const T *arrBegin, const T *arrEnd);
std::for_each(this->begin(),this->end(),[&comma,&oss](const T& elt) { oss << comma << elt; comma[0]=','; } );
oss << std::endl;
}
- std::size_t getHeapMemorySizeWithoutChildren() const;
- void updateTime() const { }
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ void updateTime() const override { }
//
- mcIdType getNumberOfTuples() const { return ToIdType(_info_on_compo.empty()?0:_mem.getNbOfElem()/getNumberOfComponents()); }
- mcIdType getNbOfElems() const { return ToIdType(_mem.getNbOfElem()); }
+ mcIdType getNumberOfTuples() const override { return ToIdType(_info_on_compo.empty()?0:_mem.getNbOfElem()/getNumberOfComponents()); }
+ mcIdType getNbOfElems() const override { return ToIdType(_mem.getNbOfElem()); }
bool empty() const;
- void *getVoidStarPointer() { return getPointer(); }
+ void *getVoidStarPointer() override { return getPointer(); }
const T *getConstPointer() const { return _mem.getConstPointer(); }
const T *begin() const { return getConstPointer(); }
const T *end() const { return getConstPointer()+getNbOfElems(); }
T *rwBegin() { return getPointer(); }
T *rwEnd() { return getPointer()+getNbOfElems(); }
- void alloc(std::size_t nbOfTuple, std::size_t nbOfCompo=1);
+ void alloc(std::size_t nbOfTuple, std::size_t nbOfCompo=1) override;
void useArray(const T *array, bool ownership, DeallocType type, std::size_t nbOfTuple, std::size_t nbOfCompo);
void useExternalArrayWithRWAccess(const T *array, std::size_t nbOfTuple, std::size_t nbOfCompo);
T getIJSafe(std::size_t tupleId, std::size_t compoId) const;
T *getPointerSilent() { return _mem.getPointer(); }
void pack() const;
bool isAllocated() const override;
- void checkAllocated() const;
- void desallocate();
+ void checkAllocated() const override;
+ void desallocate() override;
void reserve(std::size_t nbOfElems);
- void rearrange(std::size_t newNbOfCompo);
+ void rearrange(std::size_t newNbOfCompo) override;
void transpose();
void pushBackSilent(T val);
template<class InputIterator>
T popBackSilent();
T front() const;
T back() const;
- std::size_t getNbOfElemAllocated() const { return _mem.getNbOfElemAllocated(); }
+ std::size_t getNbOfElemAllocated() const override { return _mem.getNbOfElemAllocated(); }
void allocIfNecessary(std::size_t nbOfTuple, std::size_t nbOfCompo);
void deepCopyFrom(const DataArrayTemplate<T>& other);
void reverse();
void fillWithValue(T val);
- void reAlloc(std::size_t newNbOfTuple);
- void renumberInPlace(const mcIdType *old2New);
- void renumberInPlaceR(const mcIdType *new2Old);
+ void reAlloc(std::size_t newNbOfTuple) override;
+ void renumberInPlace(const mcIdType *old2New) override;
+ void renumberInPlaceR(const mcIdType *new2Old) override;
void sort(bool asc=true);
typename Traits<T>::ArrayType *renumber(const mcIdType *old2New) const;
typename Traits<T>::ArrayType *renumberR(const mcIdType *new2Old) const;
typename Traits<T>::ArrayType *changeNbOfComponents(std::size_t newNbOfComp, T dftValue) const;
typename Traits<T>::ArrayType *subArray(mcIdType tupleIdBg, mcIdType tupleIdEnd=-1) const;
MCAuto<typename Traits<T>::ArrayTypeCh> selectPartDef(const PartDefinition* pd) const;
- void circularPermutation(mcIdType nbOfShift=1);
- void circularPermutationPerTuple(mcIdType nbOfShift=1);
- void reversePerTuple();
+ void circularPermutation(mcIdType nbOfShift=1) override;
+ void circularPermutationPerTuple(mcIdType nbOfShift=1) override;
+ void reversePerTuple() override;
void setPartOfValues1(const typename Traits<T>::ArrayType *a, mcIdType bgTuples, mcIdType endTuples, mcIdType stepTuples, mcIdType bgComp, mcIdType endComp, mcIdType stepComp, bool strictCompoCompare=true);
void setPartOfValuesSimple1(T a, mcIdType bgTuples, mcIdType endTuples, mcIdType stepTuples, mcIdType bgComp, mcIdType endComp, mcIdType stepComp);
void setPartOfValues2(const typename Traits<T>::ArrayType *a, const mcIdType *bgTuples, const mcIdType *endTuples, const mcIdType *bgComp, const mcIdType *endComp, bool strictCompoCompare=true);
void setPartOfValues4(const typename Traits<T>::ArrayType *a, mcIdType bgTuples, mcIdType endTuples, mcIdType stepTuples, const mcIdType *bgComp, const mcIdType *endComp, bool strictCompoCompare=true);
void setPartOfValuesSimple4(T a, mcIdType bgTuples, mcIdType endTuples, mcIdType stepTuples, const mcIdType *bgComp, const mcIdType *endComp);
void setPartOfValuesAdv(const typename Traits<T>::ArrayType *a, const DataArrayIdType *tuplesSelec);
- void setContigPartOfSelectedValues(mcIdType tupleIdStart, const DataArray *aBase, const DataArrayIdType *tuplesSelec);
- void setContigPartOfSelectedValuesSlice(mcIdType tupleIdStart, const DataArray *aBase, mcIdType bg, mcIdType end2, mcIdType step);
+ void setContigPartOfSelectedValues(mcIdType tupleIdStart, const DataArray *aBase, const DataArrayIdType *tuplesSelec) override;
+ void setContigPartOfSelectedValuesSlice(mcIdType tupleIdStart, const DataArray *aBase, mcIdType bg, mcIdType end2, mcIdType step) override;
T getMaxValue(mcIdType& tupleId) const;
T getMaxValueInArray() const;
T getMaxAbsValue(std::size_t& tupleId) const;
typename Traits<T>::ArrayType *performCopyOrIncrRef(bool dCpy) const;
typename Traits<T>::ArrayType *sumPerTuple() const;
void iota(T init=(T)0);
- void reprStream(std::ostream& stream) const;
- void reprZipStream(std::ostream& stream) const;
+ void reprStream(std::ostream& stream) const override;
+ void reprZipStream(std::ostream& stream) const override;
void reprNotTooLongStream(std::ostream& stream) const;
- void reprWithoutNameStream(std::ostream& stream) const;
- void reprZipWithoutNameStream(std::ostream& stream) const;
+ void reprWithoutNameStream(std::ostream& stream) const override;
+ void reprZipWithoutNameStream(std::ostream& stream) const override;
void reprNotTooLongWithoutNameStream(std::ostream& stream) const;
std::string repr() const;
std::string reprZip() const;
public:
static DataArrayFloat *New();
public:// abstract method overload
- DataArrayFloat *deepCopy() const;
+ DataArrayFloat *deepCopy() const override;
DataArrayFloat *copySorted(bool asc=true) const override { return this->copySortedImpl(asc); }
std::string getClassName() const override { return std::string("DataArrayFloat"); }
- DataArrayFloat *buildNewEmptyInstance() const { return DataArrayFloat::New(); }
- DataArrayFloat *selectByTupleRanges(const std::vector<std::pair<mcIdType,mcIdType> >& ranges) const { return DataArrayTemplateFP<float>::mySelectByTupleRanges(ranges); }
- DataArrayFloat *keepSelectedComponents(const std::vector<std::size_t>& compoIds) const { return DataArrayTemplateFP<float>::myKeepSelectedComponents(compoIds); }
- DataArrayFloat *selectByTupleId(const mcIdType *new2OldBg, const mcIdType *new2OldEnd) const { return this->mySelectByTupleId(new2OldBg,new2OldEnd); }
- DataArrayFloat *selectByTupleIdSafe(const mcIdType *new2OldBg, const mcIdType *new2OldEnd) const { return DataArrayTemplateFP<float>::mySelectByTupleIdSafe(new2OldBg,new2OldEnd); }
- DataArrayFloat *selectByTupleIdSafeSlice(mcIdType bg, mcIdType end2, mcIdType step) const { return DataArrayTemplateFP<float>::mySelectByTupleIdSafeSlice(bg,end2,step); }
- void reprCppStream(const std::string& varName, std::ostream& stream) const;
- void reprQuickOverview(std::ostream& stream) const;
- void reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const;
+ DataArrayFloat *buildNewEmptyInstance() const override { return DataArrayFloat::New(); }
+ DataArrayFloat *selectByTupleRanges(const std::vector<std::pair<mcIdType,mcIdType> >& ranges) const override { return DataArrayTemplateFP<float>::mySelectByTupleRanges(ranges); }
+ DataArrayFloat *keepSelectedComponents(const std::vector<std::size_t>& compoIds) const override { return DataArrayTemplateFP<float>::myKeepSelectedComponents(compoIds); }
+ DataArrayFloat *selectByTupleId(const mcIdType *new2OldBg, const mcIdType *new2OldEnd) const override { return this->mySelectByTupleId(new2OldBg,new2OldEnd); }
+ DataArrayFloat *selectByTupleIdSafe(const mcIdType *new2OldBg, const mcIdType *new2OldEnd) const override { return DataArrayTemplateFP<float>::mySelectByTupleIdSafe(new2OldBg,new2OldEnd); }
+ DataArrayFloat *selectByTupleIdSafeSlice(mcIdType bg, mcIdType end2, mcIdType step) const override { return DataArrayTemplateFP<float>::mySelectByTupleIdSafeSlice(bg,end2,step); }
+ void reprCppStream(const std::string& varName, std::ostream& stream) const override;
+ void reprQuickOverview(std::ostream& stream) const override;
+ void reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const override;
public:// non abstract but essential
bool isEqual(const DataArrayFloat& other, float prec) const;
bool isEqualIfNotWhy(const DataArrayFloat& other, float prec, std::string& reason) const;
public:
DataArrayFloatIterator *iterator();
private:
- ~DataArrayFloat() { }
+ ~DataArrayFloat() override = default;
DataArrayFloat() { }
};
}
public:
static DataArrayDouble *New();
double doubleValue() const;
- DataArrayDouble *deepCopy() const;
+ DataArrayDouble *deepCopy() const override;
DataArrayDouble *copySorted(bool asc=true) const override { return this->copySortedImpl(asc); }
std::string getClassName() const override { return std::string("DataArrayDouble"); }
- DataArrayDouble *buildNewEmptyInstance() const { return DataArrayDouble::New(); }
+ DataArrayDouble *buildNewEmptyInstance() const override { return DataArrayDouble::New(); }
void checkMonotonic(bool increasing, double eps) const;
bool isMonotonic(bool increasing, double eps) const;
void writeVTK(std::ostream& ofs, mcIdType indent, const std::string& nameInFile, DataArrayByte *byteArr) const;
- void reprCppStream(const std::string& varName, std::ostream& stream) const;
- void reprQuickOverview(std::ostream& stream) const;
- void reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const;
+ void reprCppStream(const std::string& varName, std::ostream& stream) const override;
+ void reprQuickOverview(std::ostream& stream) const override;
+ void reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const override;
bool isEqual(const DataArrayDouble& other, double prec) const;
bool isEqualIfNotWhy(const DataArrayDouble& other, double prec, std::string& reason) const;
bool isEqualWithoutConsideringStr(const DataArrayDouble& other, double prec) const;
- DataArrayDouble *selectByTupleId(const mcIdType *new2OldBg, const mcIdType *new2OldEnd) const { return this->mySelectByTupleId(new2OldBg,new2OldEnd); }
+ DataArrayDouble *selectByTupleId(const mcIdType *new2OldBg, const mcIdType *new2OldEnd) const override { return this->mySelectByTupleId(new2OldBg,new2OldEnd); }
DataArrayDouble *selectByTupleId(const DataArrayIdType& di) const { return this->mySelectByTupleId(di); }
- DataArrayDouble *selectByTupleIdSafe(const mcIdType *new2OldBg, const mcIdType *new2OldEnd) const { return DataArrayTemplateFP<double>::mySelectByTupleIdSafe(new2OldBg,new2OldEnd); }
- DataArrayDouble *keepSelectedComponents(const std::vector<std::size_t>& compoIds) const { return DataArrayTemplateFP<double>::myKeepSelectedComponents(compoIds); }
- DataArrayDouble *selectByTupleIdSafeSlice(mcIdType bg, mcIdType end2, mcIdType step) const { return DataArrayTemplateFP<double>::mySelectByTupleIdSafeSlice(bg,end2,step); }
- DataArrayDouble *selectByTupleRanges(const std::vector<std::pair<mcIdType,mcIdType> >& ranges) const { return DataArrayTemplateFP<double>::mySelectByTupleRanges(ranges); }
+ DataArrayDouble *selectByTupleIdSafe(const mcIdType *new2OldBg, const mcIdType *new2OldEnd) const override { return DataArrayTemplateFP<double>::mySelectByTupleIdSafe(new2OldBg,new2OldEnd); }
+ DataArrayDouble *keepSelectedComponents(const std::vector<std::size_t>& compoIds) const override { return DataArrayTemplateFP<double>::myKeepSelectedComponents(compoIds); }
+ DataArrayDouble *selectByTupleIdSafeSlice(mcIdType bg, mcIdType end2, mcIdType step) const override { return DataArrayTemplateFP<double>::mySelectByTupleIdSafeSlice(bg,end2,step); }
+ DataArrayDouble *selectByTupleRanges(const std::vector<std::pair<mcIdType,mcIdType> >& ranges) const override { return DataArrayTemplateFP<double>::mySelectByTupleRanges(ranges); }
bool areIncludedInMe(const DataArrayDouble *other, double prec, DataArrayIdType *&tupleIds) const;
void findCommonTuples(double prec, mcIdType limitTupleId, DataArrayIdType *&comm, DataArrayIdType *&commIndex) const;
double minimalDistanceTo(const DataArrayDouble *other, mcIdType& thisTupleId, mcIdType& otherTupleId) const;
private:
DataArrayDouble *operatePerTuple(std::function<double(const double *bg, const double *endd)> func) const;
private:
- ~DataArrayDouble() { }
+ ~DataArrayDouble() override = default;
DataArrayDouble() { }
};
}
void checkStrictlyMonotonic(bool increasing) const;
bool isStrictlyMonotonic(bool increasing) const;
mcIdType getHashCode() const;
- void reprCppStream(const std::string& varName, std::ostream& stream) const;
- void reprQuickOverview(std::ostream& stream) const;
- void reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const;
+ void reprCppStream(const std::string& varName, std::ostream& stream) const override;
+ void reprQuickOverview(std::ostream& stream) const override;
+ void reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const override;
void writeVTK(std::ostream& ofs, mcIdType indent, const std::string& type, const std::string& nameInFile, DataArrayByte *byteArr) const;
void transformWithIndArr(const T *indArrBg, const T *indArrEnd);
void transformWithIndArr(const MapKeyVal<T, T>& m);
template<class ALG>
void switchOnTupleAlg(T val, std::vector<bool>& vec, ALG algo) const;
protected:
- ~DataArrayDiscrete() { }
+ ~DataArrayDiscrete() override = default;
};
template<class T>
public:
bool isFittingWith(const std::vector<bool>& v) const;
protected:
- ~DataArrayDiscreteSigned() { }
+ ~DataArrayDiscreteSigned() override = default;
};
class DataArrayInt32Iterator;
{
friend class DataArrayDiscrete<Int32>;
public:
- DataArrayInt32 *deepCopy() const;
+ DataArrayInt32 *deepCopy() const override;
DataArrayInt32 *copySorted(bool asc=true) const override { return this->copySortedImpl(asc); }
- DataArrayInt32 *buildNewEmptyInstance() const { return DataArrayInt32::New(); }
+ DataArrayInt32 *buildNewEmptyInstance() const override { return DataArrayInt32::New(); }
MCAuto<DataArrayInt64> convertToInt64Arr() const;
public:
- DataArrayInt32 *selectByTupleId(const mcIdType *new2OldBg, const mcIdType *new2OldEnd) const { return this->mySelectByTupleId(new2OldBg,new2OldEnd); }
+ DataArrayInt32 *selectByTupleId(const mcIdType *new2OldBg, const mcIdType *new2OldEnd) const override { return this->mySelectByTupleId(new2OldBg,new2OldEnd); }
DataArrayInt32 *selectByTupleId(const DataArrayIdType& di) const { return this->mySelectByTupleId(di); }
- DataArrayInt32 *selectByTupleIdSafe(const mcIdType *new2OldBg, const mcIdType *new2OldEnd) const { return this->mySelectByTupleIdSafe(new2OldBg,new2OldEnd); }
- DataArrayInt32 *keepSelectedComponents(const std::vector<std::size_t>& compoIds) const { return this->myKeepSelectedComponents(compoIds); }
- DataArrayInt32 *selectByTupleIdSafeSlice(mcIdType bg, mcIdType end2, mcIdType step) const { return this->mySelectByTupleIdSafeSlice(bg,end2,step); }
- DataArrayInt32 *selectByTupleRanges(const std::vector<std::pair<mcIdType,mcIdType> >& ranges) const { return this->mySelectByTupleRanges(ranges); }
+ DataArrayInt32 *selectByTupleIdSafe(const mcIdType *new2OldBg, const mcIdType *new2OldEnd) const override { return this->mySelectByTupleIdSafe(new2OldBg,new2OldEnd); }
+ DataArrayInt32 *keepSelectedComponents(const std::vector<std::size_t>& compoIds) const override { return this->myKeepSelectedComponents(compoIds); }
+ DataArrayInt32 *selectByTupleIdSafeSlice(mcIdType bg, mcIdType end2, mcIdType step) const override { return this->mySelectByTupleIdSafeSlice(bg,end2,step); }
+ DataArrayInt32 *selectByTupleRanges(const std::vector<std::pair<mcIdType,mcIdType> >& ranges) const override { return this->mySelectByTupleRanges(ranges); }
std::string getClassName() const override { return std::string("DataArrayInt32"); }
public:
DataArrayInt32Iterator *iterator();
private:
- ~DataArrayInt32() { }
+ ~DataArrayInt32() override = default;
DataArrayInt32() { }
};
{
friend class DataArrayDiscrete<Int64>;
public:
- DataArrayInt64 *deepCopy() const;
+ DataArrayInt64 *deepCopy() const override;
DataArrayInt64 *copySorted(bool asc=true) const override { return this->copySortedImpl(asc); }
- DataArrayInt64 *buildNewEmptyInstance() const { return DataArrayInt64::New(); }//ok
+ DataArrayInt64 *buildNewEmptyInstance() const override { return DataArrayInt64::New(); }//ok
MCAuto<DataArrayInt32> convertToInt32Arr() const;
public:
- DataArrayInt64 *selectByTupleId(const mcIdType *new2OldBg, const mcIdType *new2OldEnd) const { return this->mySelectByTupleId(new2OldBg,new2OldEnd); }
+ DataArrayInt64 *selectByTupleId(const mcIdType *new2OldBg, const mcIdType *new2OldEnd) const override { return this->mySelectByTupleId(new2OldBg,new2OldEnd); }
DataArrayInt64 *selectByTupleId(const DataArrayIdType& di) const { return this->mySelectByTupleId(di); }
- DataArrayInt64 *selectByTupleIdSafe(const mcIdType *new2OldBg, const mcIdType *new2OldEnd) const { return DataArrayTemplate<Int64>::mySelectByTupleIdSafe(new2OldBg,new2OldEnd); }
- DataArrayInt64 *keepSelectedComponents(const std::vector<std::size_t>& compoIds) const { return DataArrayTemplate<Int64>::myKeepSelectedComponents(compoIds); }
- DataArrayInt64 *selectByTupleIdSafeSlice(mcIdType bg, mcIdType end2, mcIdType step) const { return DataArrayTemplate<Int64>::mySelectByTupleIdSafeSlice(bg,end2,step); }
- DataArrayInt64 *selectByTupleRanges(const std::vector<std::pair<mcIdType,mcIdType> >& ranges) const { return DataArrayTemplate<Int64>::mySelectByTupleRanges(ranges); }
+ DataArrayInt64 *selectByTupleIdSafe(const mcIdType *new2OldBg, const mcIdType *new2OldEnd) const override { return DataArrayTemplate<Int64>::mySelectByTupleIdSafe(new2OldBg,new2OldEnd); }
+ DataArrayInt64 *keepSelectedComponents(const std::vector<std::size_t>& compoIds) const override { return DataArrayTemplate<Int64>::myKeepSelectedComponents(compoIds); }
+ DataArrayInt64 *selectByTupleIdSafeSlice(mcIdType bg, mcIdType end2, mcIdType step) const override { return DataArrayTemplate<Int64>::mySelectByTupleIdSafeSlice(bg,end2,step); }
+ DataArrayInt64 *selectByTupleRanges(const std::vector<std::pair<mcIdType,mcIdType> >& ranges) const override { return DataArrayTemplate<Int64>::mySelectByTupleRanges(ranges); }
std::string getClassName() const override { return std::string("DataArrayInt64"); }
public:
DataArrayInt64Iterator *iterator();
private:
- ~DataArrayInt64() { }
+ ~DataArrayInt64() override = default;
DataArrayInt64() { }
};
}
std::string repr() const;
std::string reprZip() const;
DataArrayInt *convertToIntArr() const;
- DataArrayChar *selectByTupleId(const mcIdType *new2OldBg, const mcIdType *new2OldEnd) const { return this->mySelectByTupleId(new2OldBg,new2OldEnd); }
+ DataArrayChar *selectByTupleId(const mcIdType *new2OldBg, const mcIdType *new2OldEnd) const override { return this->mySelectByTupleId(new2OldBg,new2OldEnd); }
DataArrayChar *selectByTupleId(const DataArrayIdType& di) const { return this->mySelectByTupleId(di); }
- DataArrayChar *selectByTupleIdSafe(const mcIdType *new2OldBg, const mcIdType *new2OldEnd) const { return DataArrayTemplate<char>::mySelectByTupleIdSafe(new2OldBg,new2OldEnd); }
- DataArrayChar *keepSelectedComponents(const std::vector<std::size_t>& compoIds) const { return DataArrayTemplate<char>::myKeepSelectedComponents(compoIds); }
- DataArrayChar *selectByTupleIdSafeSlice(mcIdType bg, mcIdType end2, mcIdType step) const { return DataArrayTemplate<char>::mySelectByTupleIdSafeSlice(bg,end2,step); }
+ DataArrayChar *selectByTupleIdSafe(const mcIdType *new2OldBg, const mcIdType *new2OldEnd) const override { return DataArrayTemplate<char>::mySelectByTupleIdSafe(new2OldBg,new2OldEnd); }
+ DataArrayChar *keepSelectedComponents(const std::vector<std::size_t>& compoIds) const override { return DataArrayTemplate<char>::myKeepSelectedComponents(compoIds); }
+ DataArrayChar *selectByTupleIdSafeSlice(mcIdType bg, mcIdType end2, mcIdType step) const override { return DataArrayTemplate<char>::mySelectByTupleIdSafeSlice(bg,end2,step); }
bool isUniform(char val) const;
void meldWith(const DataArrayChar *other);
- DataArray *selectByTupleRanges(const std::vector<std::pair<mcIdType,mcIdType> >& ranges) const { return DataArrayTemplate<char>::mySelectByTupleRanges(ranges); }
+ DataArray *selectByTupleRanges(const std::vector<std::pair<mcIdType,mcIdType> >& ranges) const override { return DataArrayTemplate<char>::mySelectByTupleRanges(ranges); }
DataArrayIdType *findIdsEqual(char val) const;
DataArrayIdType *findIdsNotEqual(char val) const;
mcIdType findIdSequence(const std::vector<char>& vals) const;
{
public:
static DataArrayByte *New();
- DataArrayChar *buildEmptySpecializedDAChar() const;
+ DataArrayChar *buildEmptySpecializedDAChar() const override;
DataArrayByteIterator *iterator();
- DataArrayByte *deepCopy() const;
+ DataArrayByte *deepCopy() const override;
DataArrayByte *copySorted(bool asc=true) const override { return this->copySortedImpl(asc); }
DataArrayByte *performCopyOrIncrRef(bool deepCopy) const;
- DataArrayByte *buildNewEmptyInstance() const { return DataArrayByte::New(); }
+ DataArrayByte *buildNewEmptyInstance() const override { return DataArrayByte::New(); }
char byteValue() const;
- void reprStream(std::ostream& stream) const;
- void reprZipStream(std::ostream& stream) const;
- void reprWithoutNameStream(std::ostream& stream) const;
- void reprZipWithoutNameStream(std::ostream& stream) const;
- void reprCppStream(const std::string& varName, std::ostream& stream) const;
- void reprQuickOverview(std::ostream& stream) const;
- void reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const;
- bool isEqualIfNotWhy(const DataArrayChar& other, std::string& reason) const;
+ void reprStream(std::ostream& stream) const override;
+ void reprZipStream(std::ostream& stream) const override;
+ void reprWithoutNameStream(std::ostream& stream) const override;
+ void reprZipWithoutNameStream(std::ostream& stream) const override;
+ void reprCppStream(const std::string& varName, std::ostream& stream) const override;
+ void reprQuickOverview(std::ostream& stream) const override;
+ void reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const override;
+ bool isEqualIfNotWhy(const DataArrayChar& other, std::string& reason) const override;
std::vector<bool> toVectorOfBool() const;
std::string getClassName() const override { return std::string("DataArrayByte"); }
private:
- ~DataArrayByte() { }
+ ~DataArrayByte() override = default;
DataArrayByte() { }
};
static DataArrayAsciiChar *New();
static DataArrayAsciiChar *New(const std::string& st);
static DataArrayAsciiChar *New(const std::vector<std::string>& vst, char defaultChar);
- DataArrayChar *buildEmptySpecializedDAChar() const;
+ DataArrayChar *buildEmptySpecializedDAChar() const override;
DataArrayAsciiCharIterator *iterator();
- DataArrayAsciiChar *deepCopy() const;
+ DataArrayAsciiChar *deepCopy() const override;
DataArrayAsciiChar *copySorted(bool asc=true) const override { (void)asc;throw INTERP_KERNEL::Exception("DataArrayAsciiChar::copySorted : not implemented for DataArrayByte"); }
DataArrayAsciiChar *performCopyOrIncrRef(bool deepCopy) const;
- DataArrayAsciiChar *buildNewEmptyInstance() const { return DataArrayAsciiChar::New(); }
+ DataArrayAsciiChar *buildNewEmptyInstance() const override { return DataArrayAsciiChar::New(); }
char asciiCharValue() const;
- void reprStream(std::ostream& stream) const;
- void reprZipStream(std::ostream& stream) const;
- void reprWithoutNameStream(std::ostream& stream) const;
- void reprZipWithoutNameStream(std::ostream& stream) const;
- void reprCppStream(const std::string& varName, std::ostream& stream) const;
- void reprQuickOverview(std::ostream& stream) const;
- void reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const;
- bool isEqualIfNotWhy(const DataArrayChar& other, std::string& reason) const;
+ void reprStream(std::ostream& stream) const override;
+ void reprZipStream(std::ostream& stream) const override;
+ void reprWithoutNameStream(std::ostream& stream) const override;
+ void reprZipWithoutNameStream(std::ostream& stream) const override;
+ void reprCppStream(const std::string& varName, std::ostream& stream) const override;
+ void reprQuickOverview(std::ostream& stream) const override;
+ void reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const override;
+ bool isEqualIfNotWhy(const DataArrayChar& other, std::string& reason) const override;
std::string getClassName() const override { return std::string("DataArrayAsciiChar"); }
private:
- ~DataArrayAsciiChar() { }
+ ~DataArrayAsciiChar() override = default;
DataArrayAsciiChar() { }
DataArrayAsciiChar(const std::string& st);
DataArrayAsciiChar(const std::vector<std::string>& vst, char defaultChar);
{
public:
DataArrayDoubleIterator(DataArrayDouble *da);
- ~DataArrayDoubleIterator() { }
+ ~DataArrayDoubleIterator() = default;
};
class MEDCOUPLING_EXPORT DataArrayDoubleTuple : public DataArrayTuple<double>
{
public:
DataArrayFloatIterator(DataArrayFloat *da);
- ~DataArrayFloatIterator() { }
+ ~DataArrayFloatIterator() = default;
};
class MEDCOUPLING_EXPORT DataArrayFloatTuple : public DataArrayTuple<float>
{
public:
DataArrayInt32Iterator(DataArrayInt32 *da);
- ~DataArrayInt32Iterator() { }
+ ~DataArrayInt32Iterator() = default;
};
class MEDCOUPLING_EXPORT DataArrayInt64Iterator : public DataArrayIterator<Int64>
{
public:
DataArrayInt64Iterator(DataArrayInt64 *da);
- ~DataArrayInt64Iterator() { }
+ ~DataArrayInt64Iterator() = default;
};
class MEDCOUPLING_EXPORT DataArrayInt32Tuple : public DataArrayTuple<Int32>
DataArrayInt64 *buildDAInt(std::size_t nbOfTuples, std::size_t nbOfCompo) const;
};
- typedef DataArrayInt32Tuple DataArrayIntTuple;
+ using DataArrayIntTuple = DataArrayInt32Tuple;
class DataArrayAsciiCharTuple;
#ifndef __PARAMEDMEM_MEDCOUPLINGMEMARRAY_TXX__
#define __PARAMEDMEM_MEDCOUPLINGMEMARRAY_TXX__
+#include "MCType.hxx"
+#include "MEDCouplingMap.txx"
#include "MEDCouplingMemArray.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingTraits.hxx"
#include "InterpKernelException.hxx"
-#include "InterpolationUtils.hxx"
#include "MEDCouplingPartDefinition.hxx"
#include "InterpKernelAutoPtr.hxx"
#include "MCAuto.hxx"
-#include "MEDCouplingMap.txx"
+#include <ostream>
+#include <iterator>
+#include <cstdint>
+#include <limits>
+#include <functional>
+#include <map>
#include <set>
+#include <cstddef>
#include <sstream>
#include <cstdlib>
#include <numeric>
#include <algorithm>
-#include <iterator>
+#include <string>
+#include <vector>
+#include <utility>
namespace MEDCoupling
{
void MEDCouplingPointer<T>::setInternal(T *pointer)
{
_internal=pointer;
- _external=0;
+ _external=nullptr;
}
template<class T>
}
template<class T>
- MemArray<T>::MemArray(const MemArray<T>& other):_nb_of_elem(0),_nb_of_elem_alloc(0),_ownership(false),_dealloc(0),_param_for_deallocator(0)
+ MemArray<T>::MemArray(const MemArray<T>& other)
{
if(!other._pointer.isNull())
{
stream << "No data";
stream << "\n";
stream << "Data content :\n";
- bool ret=!_pointer.isNull();
+ bool const ret=!_pointer.isNull();
if(!ret)
stream << "No data !\n";
return ret;
const T *data=getConstPointer();
if(_nb_of_elem!=0 && sl!=0)
{
- std::size_t nbOfTuples=_nb_of_elem/std::abs(sl);
+ std::size_t const nbOfTuples=_nb_of_elem/std::abs(sl);
for(std::size_t i=0;i<nbOfTuples;i++)
{
stream << "Tuple #" << i << " : ";
{
if(_nb_of_elem!=0 && sl!=0)
{
- std::size_t nbOfTuples=_nb_of_elem/std::abs(sl);
+ std::size_t const nbOfTuples=_nb_of_elem/std::abs(sl);
for(std::size_t i=0;i<nbOfTuples;i++)
{
stream << "|";
std::sort(pt,pt+_nb_of_elem);
else
{
- typename std::reverse_iterator<T *> it1(pt+_nb_of_elem);
- typename std::reverse_iterator<T *> it2(pt);
+ typename std::reverse_iterator<T *> const it1(pt+_nb_of_elem);
+ typename std::reverse_iterator<T *> const it2(pt);
std::sort(it1,it2);
}
}
_nb_of_elem_alloc=newNbOfElements;
_ownership=true;
_dealloc=CDeallocator;
- _param_for_deallocator=0;
+ _param_for_deallocator=nullptr;
}
/*!
_nb_of_elem_alloc=newNbOfElements;
_ownership=true;
_dealloc=CDeallocator;
- _param_for_deallocator=0;
+ _param_for_deallocator=nullptr;
}
template<class T>
- void MemArray<T>::CPPDeallocator(void *pt, void *param)
+ void MemArray<T>::CPPDeallocator(void *pt, void * /*param*/)
{
delete [] reinterpret_cast<T*>(pt);
}
template<class T>
- void MemArray<T>::CDeallocator(void *pt, void *param)
+ void MemArray<T>::CDeallocator(void *pt, void * /*param*/)
{
free(pt);
}
template<class T>
void MemArray<T>::COffsetDeallocator(void *pt, void *param)
{
- int64_t *offset(reinterpret_cast<int64_t *>(param));
+ auto *offset(reinterpret_cast<int64_t *>(param));
char *ptcast(reinterpret_cast<char *>(pt));
free(ptcast+*offset);
}
DestroyPointer(const_cast<T *>(_pointer.getConstPointer()),_dealloc,_param_for_deallocator);//Do not use getPointer because in case of _external
_pointer.null();
_ownership=false;
- _dealloc=NULL;
- _param_for_deallocator=NULL;
+ _dealloc=nullptr;
+ _param_for_deallocator=nullptr;
_nb_of_elem=0;
_nb_of_elem_alloc=0;
}
if(_tuple_id<_nb_tuple)
{
_tuple_id++;
- typename Traits<T>::ArrayTuple *ret=new typename Traits<T>::ArrayTuple(_pt,_nb_comp);
+ auto *ret=new typename Traits<T>::ArrayTuple(_pt,_nb_comp);
_pt+=_nb_comp;
return ret;
}
template<class T>
bool DataArrayTemplate<T>::isAllocated() const
{
- return getConstPointer()!=0;
+ return getConstPointer()!=nullptr;
}
/*!
mcIdType nbOfTuples(other.getNumberOfTuples());
std::size_t nbOfComp(other.getNumberOfComponents());
allocIfNecessary(nbOfTuples,nbOfComp);
- std::size_t nbOfElems(nbOfTuples*nbOfComp);
+ std::size_t const nbOfElems(nbOfTuples*nbOfComp);
T *pt(getPointer());
const T *ptI(other.begin());
for(std::size_t i=0;i<nbOfElems;i++)
void DataArrayTemplate<T>::renumberInPlace(const mcIdType *old2New)
{
checkAllocated();
- mcIdType nbTuples(getNumberOfTuples());
- std::size_t nbOfCompo(getNumberOfComponents());
+ mcIdType const nbTuples(getNumberOfTuples());
+ std::size_t const nbOfCompo(getNumberOfComponents());
T *tmp(new T[nbTuples*nbOfCompo]);
const T *iptr(begin());
for(mcIdType i=0;i<nbTuples;i++)
{
- mcIdType v=old2New[i];
+ mcIdType const v=old2New[i];
if(v>=0 && v<nbTuples)
std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),tmp+nbOfCompo*v);
else
void DataArrayTemplate<T>::renumberInPlaceR(const mcIdType *new2Old)
{
checkAllocated();
- mcIdType nbTuples(getNumberOfTuples());
- std::size_t nbOfCompo(getNumberOfComponents());
+ mcIdType const nbTuples(getNumberOfTuples());
+ std::size_t const nbOfCompo(getNumberOfComponents());
T *tmp(new T[nbTuples*nbOfCompo]);
const T *iptr(begin());
for(mcIdType i=0;i<nbTuples;i++)
{
- mcIdType v=new2Old[i];
+ mcIdType const v=new2Old[i];
if(v>=0 && v<nbTuples)
std::copy(iptr+nbOfCompo*v,iptr+nbOfCompo*(v+1),tmp+nbOfCompo*i);
else
T *optr=ret->getPointer();
for(mcIdType i=0;i<nbTuples;i++)
{
- mcIdType w=old2New[i];
+ mcIdType const w=old2New[i];
if(w>=0)
std::copy(iptr+i*nbOfCompo,iptr+(i+1)*nbOfCompo,optr+w*nbOfCompo);
}
checkAllocated();
MCAuto<DataArray> ret0(buildNewEmptyInstance());
MCAuto< typename Traits<T>::ArrayType > ret(DynamicCastSafe<DataArray,typename Traits<T>::ArrayType>(ret0));
- std::size_t nbComp(getNumberOfComponents());
+ std::size_t const nbComp(getNumberOfComponents());
ret->alloc(std::distance(new2OldBg,new2OldEnd),nbComp);
ret->copyStringInfoFrom(*this);
T *pt(ret->getPointer());
if(!pd)
throw INTERP_KERNEL::Exception("DataArrayTemplate<T>::selectPartDef : null input pointer !");
MCAuto<typename Traits<T>::ArrayTypeCh> ret(Traits<T>::ArrayTypeCh::New());
- const SlicePartDefinition *spd(dynamic_cast<const SlicePartDefinition *>(pd));
+ const auto *spd(dynamic_cast<const SlicePartDefinition *>(pd));
if(spd)
{
mcIdType a,b,c;
return DynamicCastSafe<DataArray,typename Traits<T>::ArrayTypeCh>(ret2);
}
}
- const DataArrayPartDefinition *dpd(dynamic_cast<const DataArrayPartDefinition *>(pd));
+ const auto *dpd(dynamic_cast<const DataArrayPartDefinition *>(pd));
if(dpd)
{
MCAuto<DataArrayIdType> arr(dpd->toDAI());
checkAllocated();
MCAuto<DataArray> ret0(buildNewEmptyInstance());
MCAuto< typename Traits<T>::ArrayType > ret(DynamicCastSafe<DataArray,typename Traits<T>::ArrayType>(ret0));
- std::size_t nbComp(getNumberOfComponents());
- mcIdType oldNbOfTuples(getNumberOfTuples());
+ std::size_t const nbComp(getNumberOfComponents());
+ mcIdType const oldNbOfTuples(getNumberOfTuples());
ret->alloc(std::distance(new2OldBg,new2OldEnd),nbComp);
ret->copyStringInfoFrom(*this);
T *pt(ret->getPointer());
std::ostringstream oss; oss << Traits<T>::ArrayTypeName << "::rearrange : input newNbOfCompo must be > 0 !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- std::size_t nbOfElems=getNbOfElems();
+ std::size_t const nbOfElems=getNbOfElems();
if(nbOfElems%newNbOfCompo!=0)
{
std::ostringstream oss; oss << Traits<T>::ArrayTypeName << "::rearrange : nbOfElems%newNbOfCompo!=0 !";
T *nc(ret->getPointer());
mcIdType nbOfTuples=getNumberOfTuples();
std::size_t oldNbOfComp=getNumberOfComponents();
- std::size_t dim(std::min(oldNbOfComp,newNbOfComp));
+ std::size_t const dim(std::min(oldNbOfComp,newNbOfComp));
for(mcIdType i=0;i<nbOfTuples;i++)
{
std::size_t j=0;
checkAllocated();
MCAuto<DataArray> ret0(buildNewEmptyInstance());
MCAuto< typename Traits<T>::ArrayType > ret(DynamicCastSafe<DataArray,typename Traits<T>::ArrayType>(ret0));
- std::size_t newNbOfCompo=compoIds.size();
- std::size_t oldNbOfCompo=getNumberOfComponents();
- for(std::vector<std::size_t>::const_iterator it=compoIds.begin();it!=compoIds.end();it++)
- if((*it)>=oldNbOfCompo) // (*it) >= 0 (it is a size_t)
+ std::size_t const newNbOfCompo=compoIds.size();
+ std::size_t const oldNbOfCompo=getNumberOfComponents();
+ for(unsigned long const compoId : compoIds)
+ if(compoId>=oldNbOfCompo) // (*it) >= 0 (it is a size_t)
{
- std::ostringstream oss; oss << Traits<T>::ArrayTypeName << "::keepSelectedComponents : invalid requested component : " << *it << " whereas it should be in [0," << oldNbOfCompo << ") !";
+ std::ostringstream oss; oss << Traits<T>::ArrayTypeName << "::keepSelectedComponents : invalid requested component : " << compoId << " whereas it should be in [0," << oldNbOfCompo << ") !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- mcIdType nbOfTuples(getNumberOfTuples());
+ mcIdType const nbOfTuples(getNumberOfTuples());
ret->alloc(nbOfTuples,newNbOfCompo);
ret->copyPartOfStringInfoFrom(*this,compoIds);
const T *oldc(getConstPointer());
checkAllocated();
MCAuto<DataArray> ret0(buildNewEmptyInstance());
MCAuto< typename Traits<T>::ArrayType > ret(DynamicCastSafe<DataArray,typename Traits<T>::ArrayType>(ret0));
- std::size_t nbComp(getNumberOfComponents());
+ std::size_t const nbComp(getNumberOfComponents());
std::ostringstream oss; oss << Traits<T>::ArrayTypeName << "::selectByTupleIdSafeSlice : ";
- mcIdType newNbOfTuples(GetNumberOfItemGivenBESRelative(bg,end2,step,oss.str()));
+ mcIdType const newNbOfTuples(GetNumberOfItemGivenBESRelative(bg,end2,step,oss.str()));
ret->alloc(newNbOfTuples,nbComp);
T *pt(ret->getPointer());
const T *srcPt(getConstPointer()+bg*nbComp);
{
const char msg[]="DataArrayTemplate::setPartOfValuesSimple1";
checkAllocated();
- mcIdType newNbOfTuples(DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg));
- mcIdType newNbOfComp(DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg));
+ mcIdType const newNbOfTuples(DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg));
+ mcIdType const newNbOfComp(DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg));
std::size_t nbComp(getNumberOfComponents());
mcIdType nbOfTuples(getNumberOfTuples());
DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
{
const char msg[]="DataArrayTemplate::setPartOfValuesSimple3";
checkAllocated();
- std::size_t newNbOfComp(DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg));
+ std::size_t const newNbOfComp(DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg));
std::size_t nbComp(getNumberOfComponents());
mcIdType nbOfTuples(getNumberOfTuples());
DataArray::CheckValueInRangeEx(ToIdType(nbComp),bgComp,endComp,"invalid component value");
{
const char msg[]="DataArrayTemplate::setPartOfValuesSimple4";
checkAllocated();
- mcIdType newNbOfTuples(DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg));
+ mcIdType const newNbOfTuples(DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg));
std::size_t nbComp(getNumberOfComponents());
for(const mcIdType *z=bgComp;z!=endComp;z++)
DataArray::CheckValueInRange(ToIdType(nbComp),*z,"invalid component id");
{
if(!aBase || !tuplesSelec)
throw INTERP_KERNEL::Exception("DataArrayTemplate::setContigPartOfSelectedValues : input DataArray is NULL !");
- const typename Traits<T>::ArrayType *a(dynamic_cast<const typename Traits<T>::ArrayType *>(aBase));
+ const auto *a(dynamic_cast<const typename Traits<T>::ArrayType *>(aBase));
if(!a)
throw INTERP_KERNEL::Exception("DataArrayTemplate::setContigPartOfSelectedValues : input DataArray aBase is not a DataArrayDouble !");
checkAllocated();
a->checkAllocated();
tuplesSelec->checkAllocated();
- std::size_t nbOfComp(getNumberOfComponents());
+ std::size_t const nbOfComp(getNumberOfComponents());
if(nbOfComp!=a->getNumberOfComponents())
throw INTERP_KERNEL::Exception("DataArrayTemplate::setContigPartOfSelectedValues : This and a do not have the same number of components !");
if(tuplesSelec->getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("DataArrayTemplate::setContigPartOfSelectedValues : Expecting to have a tuple selector DataArrayInt instance with exactly 1 component !");
- mcIdType thisNt(getNumberOfTuples());
- mcIdType aNt(a->getNumberOfTuples());
- mcIdType nbOfTupleToWrite(tuplesSelec->getNumberOfTuples());
+ mcIdType const thisNt(getNumberOfTuples());
+ mcIdType const aNt(a->getNumberOfTuples());
+ mcIdType const nbOfTupleToWrite(tuplesSelec->getNumberOfTuples());
T *valsToSet(getPointer()+tupleIdStart*nbOfComp);
if(tupleIdStart+nbOfTupleToWrite>thisNt)
throw INTERP_KERNEL::Exception("DataArrayTemplate::setContigPartOfSelectedValues : invalid number range of values to write !");
std::ostringstream oss; oss << Traits<T>::ArrayTypeName << "::setContigPartOfSelectedValuesSlice : input DataArray is NULL !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- const typename Traits<T>::ArrayType *a(dynamic_cast<const typename Traits<T>::ArrayType *>(aBase));
+ const auto *a(dynamic_cast<const typename Traits<T>::ArrayType *>(aBase));
if(!a)
throw INTERP_KERNEL::Exception("DataArrayTemplate::setContigPartOfSelectedValuesSlice : input DataArray aBase is not a DataArrayDouble !");
checkAllocated();
a->checkAllocated();
- std::size_t nbOfComp(getNumberOfComponents());
+ std::size_t const nbOfComp(getNumberOfComponents());
const char msg[]="DataArrayDouble::setContigPartOfSelectedValuesSlice";
- mcIdType nbOfTupleToWrite(DataArray::GetNumberOfItemGivenBES(bg,end2,step,msg));
+ mcIdType const nbOfTupleToWrite(DataArray::GetNumberOfItemGivenBES(bg,end2,step,msg));
if(nbOfComp!=a->getNumberOfComponents())
throw INTERP_KERNEL::Exception("DataArrayTemplate::setContigPartOfSelectedValuesSlice : This and a do not have the same number of components !");
- mcIdType thisNt(getNumberOfTuples());
- mcIdType aNt(a->getNumberOfTuples());
+ mcIdType const thisNt(getNumberOfTuples());
+ mcIdType const aNt(a->getNumberOfTuples());
T *valsToSet(getPointer()+tupleIdStart*nbOfComp);
if(tupleIdStart+nbOfTupleToWrite>thisNt)
throw INTERP_KERNEL::Exception("DataArrayTemplate::setContigPartOfSelectedValuesSlice : invalid number range of values to write !");
typename Traits<T>::ArrayType *DataArrayTemplate<T>::mySelectByTupleRanges(const std::vector<std::pair<mcIdType,mcIdType> >& ranges) const
{
checkAllocated();
- std::size_t nbOfComp(getNumberOfComponents());
- mcIdType nbOfTuplesThis(getNumberOfTuples());
+ std::size_t const nbOfComp(getNumberOfComponents());
+ mcIdType const nbOfTuplesThis(getNumberOfTuples());
if(ranges.empty())
{
MCAuto<DataArray> ret0(buildNewEmptyInstance());
}
mcIdType ref(ranges.front().first),nbOfTuples(0);
bool isIncreasing(true);
- for(std::vector<std::pair<mcIdType,mcIdType> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
+ for(auto it=ranges.begin();it!=ranges.end();it++)
{
if((*it).first<=(*it).second)
{
ret->copyStringInfoFrom(*this);
const T *src(getConstPointer());
T *work(ret->getPointer());
- for(std::vector<std::pair<mcIdType,mcIdType> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
- work=std::copy(src+(*it).first*nbOfComp,src+(*it).second*nbOfComp,work);
+ for(const auto & range : ranges)
+ work=std::copy(src+range.first*nbOfComp,src+range.second*nbOfComp,work);
return ret.retn();
}
void DataArrayTemplate<T>::circularPermutation(mcIdType nbOfShift)
{
checkAllocated();
- std::size_t nbOfCompo(getNumberOfComponents());
- mcIdType nbTuples(getNumberOfTuples());
- mcIdType effNbSh(EffectiveCircPerm(nbOfShift,nbTuples));
+ std::size_t const nbOfCompo(getNumberOfComponents());
+ mcIdType const nbTuples(getNumberOfTuples());
+ mcIdType const effNbSh(EffectiveCircPerm(nbOfShift,nbTuples));
if(effNbSh==0)
return ;
T *work(getPointer());
void DataArrayTemplate<T>::circularPermutationPerTuple(mcIdType nbOfShift)
{
checkAllocated();
- std::size_t nbOfCompo(getNumberOfComponents());
- mcIdType nbTuples(getNumberOfTuples());
- mcIdType effNbSh(EffectiveCircPerm(nbOfShift,ToIdType(nbOfCompo)));
+ std::size_t const nbOfCompo(getNumberOfComponents());
+ mcIdType const nbTuples(getNumberOfTuples());
+ mcIdType const effNbSh(EffectiveCircPerm(nbOfShift,ToIdType(nbOfCompo)));
if(effNbSh==0)
return ;
T *work(getPointer());
void DataArrayTemplate<T>::reversePerTuple()
{
checkAllocated();
- std::size_t nbOfCompo(getNumberOfComponents());
- mcIdType nbTuples(getNumberOfTuples());
+ std::size_t const nbOfCompo(getNumberOfComponents());
+ mcIdType const nbTuples(getNumberOfTuples());
if(nbOfCompo<=1)
return ;
T *work(getPointer());
mcIdType *retToFill(ret->getPointer());
for(mcIdType i=0;i<nbTuple;i++)
{
- std::map<mcIdType,mcIdType>::const_iterator it=mm.find(ToIdType(pt[i]));
+ auto it=mm.find(ToIdType(pt[i]));
if(it==mm.end())
{
std::ostringstream oss; oss << "DataArrayInt::buildPermutationArr : Arrays mismatch : element (" << pt[i] << ") in 'other' not findable in 'this' !";
throw INTERP_KERNEL::Exception("DataArrayInt::indicesOfSubPart : some elements appears more than once !");
for(mcIdType i=0;i<nbTuples;i++,retPt++,pt++)
{
- std::map<mcIdType,mcIdType>::const_iterator it(m.find(ToIdType(*pt)));
+ auto it(m.find(ToIdType(*pt)));
if(it!=m.end())
*retPt=(*it).second;
else
template<class T>
void DataArrayDiscrete<T>::reprCppStream(const std::string& varName, std::ostream& stream) const
{
- mcIdType nbTuples(this->getNumberOfTuples());
- std::size_t nbComp(this->getNumberOfComponents());
+ mcIdType const nbTuples(this->getNumberOfTuples());
+ std::size_t const nbComp(this->getNumberOfComponents());
const T *data(this->getConstPointer());
stream << Traits<T>::ArrayTypeName << " *" << varName << "=" << Traits<T>::ArrayTypeName << "::New();" << std::endl;
if(nbTuples*nbComp>=1)
stream << Traits<T>::ArrayTypeName << " C++ instance at " << this << ". ";
if(this->isAllocated())
{
- std::size_t nbOfCompo(this->getNumberOfComponents());
+ std::size_t const nbOfCompo(this->getNumberOfComponents());
if(nbOfCompo>=1)
{
- mcIdType nbOfTuples(this->getNumberOfTuples());
+ mcIdType const nbOfTuples(this->getNumberOfTuples());
stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
}
void DataArrayDiscrete<T>::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const
{
const T *data(this->begin());
- mcIdType nbOfTuples(this->getNumberOfTuples());
- std::size_t nbOfCompo(this->getNumberOfComponents());
+ mcIdType const nbOfTuples(this->getNumberOfTuples());
+ std::size_t const nbOfCompo(this->getNumberOfComponents());
std::ostringstream oss2; oss2 << "[";
std::string oss2Str(oss2.str());
bool isFinished=true;
else
oss2 << *data++;
if(i!=nbOfTuples-1) oss2 << ", ";
- std::string oss3Str(oss2.str());
+ std::string const oss3Str(oss2.str());
if(oss3Str.length()<maxNbOfByteInRepr)
oss2Str=oss3Str;
else
{
rintstart res=std::find_if(bg,end2,std::bind(std::less_equal<T>(),std::placeholders::_1,work[i]));
std::size_t pos=std::distance(bg,res);
- std::size_t pos2=nbOfCast-pos;
+ std::size_t const pos2=nbOfCast-pos;
if(pos2<nbOfCast)
{
ret1Ptr[i]=static_cast<T>(pos2);
MCAuto<DataArrayIdType> ret(DataArrayIdType::New());
ret->alloc(nbOfTuples,1);
mcIdType *retPtr=ret->getPointer();
- for(std::vector< std::vector<mcIdType> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++)
- retPtr=std::copy((*it1).begin(),(*it1).end(),retPtr);
+ for(const auto & it1 : tmp)
+ retPtr=std::copy(it1.begin(),it1.end(),retPtr);
arr=ret.retn();
arrI=retI.retn();
}
this->checkAllocated();
a->checkAllocated();
this->copyPartOfStringInfoFrom2(compoIds,*a);
- std::size_t partOfCompoSz=compoIds.size();
+ std::size_t const partOfCompoSz=compoIds.size();
std::size_t nbOfCompo = this->getNumberOfComponents();
mcIdType nbOfTuples=std::min(this->getNumberOfTuples(),a->getNumberOfTuples());
const T *ac=a->getConstPointer();
tmp[*w]=true;
else
throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : an element is not in valid range : [0,nbOfElement) !");
- std::size_t nbOfRetVal=std::count(tmp.begin(),tmp.end(),false);
+ std::size_t const nbOfRetVal=std::count(tmp.begin(),tmp.end(),false);
DataArrayIdType *ret=DataArrayIdType::New();
ret->alloc(nbOfRetVal,1);
mcIdType j=0;
this->setName(tinyInfoS[0]);
if(this->isAllocated())
{
- mcIdType nbOfCompo=tinyInfoI[1];
+ mcIdType const nbOfCompo=tinyInfoI[1];
for(mcIdType i=0;i<nbOfCompo;i++)
this->setInfoOnComponent(i,tinyInfoS[i+1]);
}
mcIdType *DataArrayDiscrete<T>::CheckAndPreparePermutation(const T *start, const T *end)
{
std::size_t sz=std::distance(start,end);
- mcIdType *ret=(mcIdType *)malloc(sz*sizeof(mcIdType));
+ auto *ret=(mcIdType *)malloc(sz*sizeof(mcIdType));
T *work=new T[sz];
std::copy(start,end,work);
std::sort(work,work+sz);
arrIn->checkAllocated(); arrIndxIn->checkAllocated();
if(arrIn->getNumberOfComponents()!=1 || arrIndxIn->getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("DataArrayInt::ExtractFromIndexedArrays : input arrays must have exactly one component !");
- std::size_t sz=std::distance(idsOfSelectBg,idsOfSelectEnd);
+ std::size_t const sz=std::distance(idsOfSelectBg,idsOfSelectEnd);
const T *arrInPtr=arrIn->begin();
const mcIdType *arrIndxPtr=arrIndxIn->begin();
- mcIdType nbOfGrps=arrIndxIn->getNumberOfTuples()-1;
+ mcIdType const nbOfGrps=arrIndxIn->getNumberOfTuples()-1;
if(nbOfGrps<0)
throw INTERP_KERNEL::Exception("DataArrayInt::ExtractFromIndexedArrays : The format of \"arrIndxIn\" is invalid ! Its nb of tuples should be >=1 !");
mcIdType maxSizeOfArr(arrIn->getNumberOfTuples());
arrIn->checkAllocated(); arrIndxIn->checkAllocated();
if(arrIn->getNumberOfComponents()!=1 || arrIndxIn->getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("DataArrayInt::ExtractFromIndexedArraysSlice : input arrays must have exactly one component !");
- mcIdType sz=DataArray::GetNumberOfItemGivenBESRelative(idsOfSelectStart,idsOfSelectStop,idsOfSelectStep,"MEDCouplingUMesh::ExtractFromIndexedArraysSlice : Input slice ");
+ mcIdType const sz=DataArray::GetNumberOfItemGivenBESRelative(idsOfSelectStart,idsOfSelectStop,idsOfSelectStep,"MEDCouplingUMesh::ExtractFromIndexedArraysSlice : Input slice ");
const T *arrInPtr=arrIn->begin();
const mcIdType *arrIndxPtr=arrIndxIn->begin();
- mcIdType nbOfGrps=arrIndxIn->getNumberOfTuples()-1;
+ mcIdType const nbOfGrps=arrIndxIn->getNumberOfTuples()-1;
if(nbOfGrps<0)
throw INTERP_KERNEL::Exception("DataArrayInt::ExtractFromIndexedArraysSlice : The format of \"arrIndxIn\" is invalid ! Its nb of tuples should be >=1 !");
mcIdType maxSizeOfArr(arrIn->getNumberOfTuples());
const DataArrayType *srcArr, const DataArrayIdType *srcArrIndex,
DataArrayType* &arrOut, DataArrayIdType* &arrIndexOut)
{
- if(arrIn==0 || arrIndxIn==0 || srcArr==0 || srcArrIndex==0)
+ if(arrIn==0 || arrIndxIn==nullptr || srcArr==0 || srcArrIndex==nullptr)
throw INTERP_KERNEL::Exception("DataArrayInt::SetPartOfIndexedArrays : presence of null pointer in input parameter !");
MCAuto<DataArrayType> arro=DataArrayType::New();
MCAuto<DataArrayIdType> arrIo=DataArrayIdType::New();
- mcIdType nbOfTuples=arrIndxIn->getNumberOfTuples()-1;
+ mcIdType const nbOfTuples=arrIndxIn->getNumberOfTuples()-1;
std::vector<bool> v(nbOfTuples,true);
mcIdType offset=0;
const mcIdType *arrIndxInPtr=arrIndxIn->begin();
}
else
{
- std::size_t pos=std::distance(idsOfSelectBg,std::find(idsOfSelectBg,idsOfSelectEnd,ii));
+ std::size_t const pos=std::distance(idsOfSelectBg,std::find(idsOfSelectBg,idsOfSelectEnd,ii));
arroPtr=std::copy(srcArrPtr+srcArrIndexPtr[pos],srcArrPtr+srcArrIndexPtr[pos+1],arroPtr);
*arrIoPtr=arrIoPtr[-1]+(srcArrIndexPtr[pos+1]-srcArrIndexPtr[pos]);
}
const DataArrayType *srcArr, const DataArrayIdType *srcArrIndex,
DataArrayType* &arrOut, DataArrayIdType* &arrIndexOut)
{
- if(arrIn==0 || arrIndxIn==0 || srcArr==0 || srcArrIndex==0)
+ if(arrIn==0 || arrIndxIn==nullptr || srcArr==0 || srcArrIndex==nullptr)
throw INTERP_KERNEL::Exception("DataArrayInt::SetPartOfIndexedArraysSlice : presence of null pointer in input parameter !");
MCAuto<DataArrayType> arro=DataArrayType::New();
MCAuto<DataArrayIdType> arrIo=DataArrayIdType::New();
- mcIdType nbOfTuples=arrIndxIn->getNumberOfTuples()-1;
+ mcIdType const nbOfTuples=arrIndxIn->getNumberOfTuples()-1;
mcIdType offset=0;
const mcIdType *arrIndxInPtr=arrIndxIn->begin();
const mcIdType *srcArrIndexPtr=srcArrIndex->begin();
- mcIdType nbOfElemsToSet=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"DataArrayInt::SetPartOfIndexedArraysSlice : ");
+ mcIdType const nbOfElemsToSet=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"DataArrayInt::SetPartOfIndexedArraysSlice : ");
mcIdType it=start;
for(mcIdType i=0;i<nbOfElemsToSet;i++,srcArrIndexPtr++,it+=step)
{
T *arroPtr=arro->getPointer();
for(mcIdType ii=0;ii<nbOfTuples;ii++,arrIoPtr++)
{
- mcIdType pos=DataArray::GetPosOfItemGivenBESRelativeNoThrow(ii,start,end,step);
+ mcIdType const pos=DataArray::GetPosOfItemGivenBESRelativeNoThrow(ii,start,end,step);
if(pos<0)
{
arroPtr=std::copy(arrInPtr+arrIndxInPtr[ii],arrInPtr+arrIndxInPtr[ii+1],arroPtr);
DataArrayType *arrInOut, const DataArrayIdType *arrIndxIn,
const DataArrayType *srcArr, const DataArrayIdType *srcArrIndex)
{
- if(arrInOut==0 || arrIndxIn==0 || srcArr==0 || srcArrIndex==0)
+ if(arrInOut==0 || arrIndxIn==nullptr || srcArr==0 || srcArrIndex==nullptr)
throw INTERP_KERNEL::Exception("DataArrayInt::SetPartOfIndexedArraysSameIdx : presence of null pointer in input parameter !");
- mcIdType nbOfTuples=arrIndxIn->getNumberOfTuples()-1;
+ mcIdType const nbOfTuples=arrIndxIn->getNumberOfTuples()-1;
const mcIdType *arrIndxInPtr=arrIndxIn->begin();
const mcIdType *srcArrIndexPtr=srcArrIndex->begin();
T *arrInOutPtr=arrInOut->getPointer();
DataArrayType *arrInOut, const DataArrayIdType *arrIndxIn,
const DataArrayType *srcArr, const DataArrayIdType *srcArrIndex)
{
- if(arrInOut==0 || arrIndxIn==0 || srcArr==0 || srcArrIndex==0)
+ if(arrInOut==0 || arrIndxIn==nullptr || srcArr==0 || srcArrIndex==nullptr)
throw INTERP_KERNEL::Exception("DataArrayInt::SetPartOfIndexedArraysSameIdxSlice : presence of null pointer in input parameter !");
- mcIdType nbOfTuples=arrIndxIn->getNumberOfTuples()-1;
+ mcIdType const nbOfTuples=arrIndxIn->getNumberOfTuples()-1;
const mcIdType *arrIndxInPtr=arrIndxIn->begin();
const mcIdType *srcArrIndexPtr=srcArrIndex->begin();
T *arrInOutPtr=arrInOut->getPointer();
const T *srcArrPtr=srcArr->begin();
- mcIdType nbOfElemsToSet=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"DataArrayInt::SetPartOfIndexedArraysSameIdxSlice : ");
+ mcIdType const nbOfElemsToSet=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"DataArrayInt::SetPartOfIndexedArraysSameIdxSlice : ");
mcIdType it=start;
for(mcIdType i=0;i<nbOfElemsToSet;i++,srcArrIndexPtr++,it+=step)
{
if(offsetForRemoval<0)
throw INTERP_KERNEL::Exception("DataArrayInt::RemoveIdsFromIndexedArrays : offsetForRemoval should be >=0 !");
std::set<T> s(idsToRemoveBg,idsToRemoveEnd);
- mcIdType nbOfGrps=arrIndx->getNumberOfTuples()-1;
+ mcIdType const nbOfGrps=arrIndx->getNumberOfTuples()-1;
mcIdType *arrIPtr=arrIndx->getPointer();
*arrIPtr++=0;
mcIdType previousArrI=0;
ret->alloc(nbOfOldTuples,1);
mcIdType *pt=ret->getPointer();
std::fill(pt,pt+nbOfOldTuples,-1);
- mcIdType nbOfGrps=ToIdType(std::distance(arrIBg,arrIEnd))-1;
+ mcIdType const nbOfGrps=ToIdType(std::distance(arrIBg,arrIEnd))-1;
const mcIdType *cIPtr=arrIBg;
for(mcIdType i=0;i<nbOfGrps;i++)
pt[arr[cIPtr[i]]]=-(i+2);
pt[iNode]=newNb++;
else
{
- mcIdType grpId=-(pt[iNode]+2);
+ mcIdType const grpId=-(pt[iNode]+2);
for(mcIdType j=cIPtr[grpId];j<cIPtr[grpId+1];j++)
{
if(arr[j]>=0 && arr[j]<nbOfOldTuples)
{
const T *ptr=(*iter)->getConstPointer();
std::size_t nbOfElem=(*iter)->getNbOfElems();
- mcIdType sfid=fid;
+ mcIdType const sfid=fid;
for(mcIdType j=0;j<sfid;j++)
{
bool found=false;
class OpSwitchedOn
{
public:
- OpSwitchedOn(T *pt):_pt(pt),_cnt(0) { }
+ OpSwitchedOn(T *pt):_pt(pt) { }
void operator()(const bool& b) { if(b) *_pt++=FromIdType<T>(_cnt); _cnt++; }
private:
T *_pt;
- MEDCoupling::mcIdType _cnt;
+ MEDCoupling::mcIdType _cnt{0};
};
template <class T>
class OpSwitchedOff
{
public:
- OpSwitchedOff(T *pt):_pt(pt),_cnt(0) { }
+ OpSwitchedOff(T *pt):_pt(pt) { }
void operator()(const bool& b) { if(!b) *_pt++=FromIdType<T>(_cnt); _cnt++; }
private:
T *_pt;
- MEDCoupling::mcIdType _cnt;
+ MEDCoupling::mcIdType _cnt{0};
};
}
/// @endcond
const T *w(this->begin()),*end2(this->end());
T refVal=-std::numeric_limits<T>::max();
T i=0;
- std::vector<bool>::const_iterator it(v.begin());
+ auto it(v.begin());
for(;it!=v.end();it++,i++)
{
if(*it)
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingMemArray.txx"
+#include "MCIdType.hxx"
+#include "MCType.hxx"
#include "MCAuto.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include <cstddef>
+#include <cstdlib>
+#include <iterator>
+#include <ostream>
#include <set>
#include <cmath>
-#include <limits>
#include <numeric>
#include <algorithm>
-#include <functional>
+#include <string>
+#include <sstream>
+#include <vector>
using namespace MEDCoupling;
mcIdType DataArrayChar::getHashCode() const
{
checkAllocated();
- std::size_t nbOfElems=getNbOfElems();
- std::size_t ret=nbOfElems*65536;
+ std::size_t const nbOfElems=getNbOfElems();
+ std::size_t const ret=nbOfElems*65536;
std::size_t delta=3;
if(nbOfElems>48)
delta=nbOfElems/8;
checkAllocated();
DataArrayInt *ret=DataArrayInt::New();
ret->alloc(getNumberOfTuples(),getNumberOfComponents());
- std::size_t nbOfVals=getNbOfElems();
+ std::size_t const nbOfVals=getNbOfElems();
const char *src=getConstPointer();
int *dest=ret->getPointer();
std::copy(src,src+nbOfVals,dest);
checkAllocated();
if(getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("DataArrayChar::isUniform : must be applied on DataArrayChar with only one component, you can call 'rearrange' method before !");
- mcIdType nbOfTuples=getNumberOfTuples();
+ mcIdType const nbOfTuples=getNumberOfTuples();
const char *w=getConstPointer();
const char *end2=w+nbOfTuples;
for(;w!=end2;w++)
throw INTERP_KERNEL::Exception("DataArrayChar::meldWith : DataArrayChar pointer in input is NULL !");
checkAllocated();
other->checkAllocated();
- mcIdType nbOfTuples=getNumberOfTuples();
+ mcIdType const nbOfTuples=getNumberOfTuples();
if(nbOfTuples!=other->getNumberOfTuples())
throw INTERP_KERNEL::Exception("DataArrayChar::meldWith : mismatch of number of tuples !");
- std::size_t nbOfComp1=getNumberOfComponents();
- std::size_t nbOfComp2=other->getNumberOfComponents();
+ std::size_t const nbOfComp1=getNumberOfComponents();
+ std::size_t const nbOfComp2=other->getNumberOfComponents();
char *newArr=(char *)malloc(nbOfTuples*(nbOfComp1+nbOfComp2)*sizeof(char));
char *w=newArr;
const char *inp1=getConstPointer();
throw INTERP_KERNEL::Exception("DataArrayChar::findIdsEqual : the array must have only one component, you can call 'rearrange' method before !");
const char *cptr=getConstPointer();
MCAuto<DataArrayIdType> ret(DataArrayIdType::New()); ret->alloc(0,1);
- mcIdType nbOfTuples=getNumberOfTuples();
+ mcIdType const nbOfTuples=getNumberOfTuples();
for(mcIdType i=0;i<nbOfTuples;i++,cptr++)
if(*cptr==val)
ret->pushBackSilent(i);
throw INTERP_KERNEL::Exception("DataArrayChar::findIdsNotEqual : the array must have only one component, you can call 'rearrange' method before !");
const char *cptr=getConstPointer();
MCAuto<DataArrayIdType> ret(DataArrayIdType::New()); ret->alloc(0,1);
- mcIdType nbOfTuples=getNumberOfTuples();
+ mcIdType const nbOfTuples=getNumberOfTuples();
for(mcIdType i=0;i<nbOfTuples;i++,cptr++)
if(*cptr!=val)
ret->pushBackSilent(i);
if(getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("DataArrayChar::findIdSequence : works only for DataArrayChar instance with one component !");
const char *cptr=getConstPointer();
- std::size_t nbOfVals=getNbOfElems();
+ std::size_t const nbOfVals=getNbOfElems();
const char *loc=std::search(cptr,cptr+nbOfVals,vals.begin(),vals.end());
if(loc!=cptr+nbOfVals)
return ToIdType(std::distance(cptr,loc));
mcIdType DataArrayChar::findIdFirstEqualTuple(const std::vector<char>& tupl) const
{
checkAllocated();
- std::size_t nbOfCompo=getNumberOfComponents();
+ std::size_t const nbOfCompo=getNumberOfComponents();
if(nbOfCompo==0)
throw INTERP_KERNEL::Exception("DataArrayChar::findIdFirstEqualTuple : 0 components in 'this' !");
if(nbOfCompo!=tupl.size())
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
const char *cptr=getConstPointer();
- std::size_t nbOfVals=getNbOfElems();
+ std::size_t const nbOfVals=getNbOfElems();
for(const char *work=cptr;work!=cptr+nbOfVals;)
{
work=std::search(work,cptr+nbOfVals,tupl.begin(),tupl.end());
if(getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("DataArrayChar::presenceOfValue : the array must have only one component, you can call 'rearrange' method before !");
const char *cptr=getConstPointer();
- mcIdType nbOfTuples=getNumberOfTuples();
+ mcIdType const nbOfTuples=getNumberOfTuples();
const char *ret=std::find(cptr,cptr+nbOfTuples,value);
if(ret!=cptr+nbOfTuples)
return ToIdType(std::distance(cptr,ret));
throw INTERP_KERNEL::Exception("DataArrayChar::findIdFirstEqual : the array must have only one component, you can call 'rearrange' method before !");
std::set<char> vals2(vals.begin(),vals.end());
const char *cptr=getConstPointer();
- mcIdType nbOfTuples=getNumberOfTuples();
+ mcIdType const nbOfTuples=getNumberOfTuples();
for(const char *w=cptr;w!=cptr+nbOfTuples;w++)
if(vals2.find(*w)!=vals2.end())
return ToIdType(std::distance(cptr,w));
throw INTERP_KERNEL::Exception("DataArrayChar::findIdsInRange : this must have exactly one component !");
const char *cptr=getConstPointer();
MCAuto<DataArrayIdType> ret=DataArrayIdType::New(); ret->alloc(0,1);
- mcIdType nbOfTuples=getNumberOfTuples();
+ mcIdType const nbOfTuples=getNumberOfTuples();
for(mcIdType i=0;i<nbOfTuples;i++,cptr++)
if(*cptr>=vmin && *cptr<vmax)
ret->pushBackSilent(i);
DataArrayChar *DataArrayChar::Aggregate(const std::vector<const DataArrayChar *>& arr)
{
std::vector<const DataArrayChar *> a;
- for(std::vector<const DataArrayChar *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
- if(*it4)
- a.push_back(*it4);
+ for(auto it4 : arr)
+ if(it4)
+ a.push_back(it4);
if(a.empty())
throw INTERP_KERNEL::Exception("DataArrayChar::Aggregate : input list must be NON EMPTY !");
std::vector<const DataArrayChar *>::const_iterator it=a.begin();
- std::size_t nbOfComp((*it)->getNumberOfComponents());
+ std::size_t const nbOfComp((*it)->getNumberOfComponents());
mcIdType nbt=(*it++)->getNumberOfTuples();
for(;it!=a.end();it++)
{
DataArrayChar *DataArrayChar::Meld(const std::vector<const DataArrayChar *>& arr)
{
std::vector<const DataArrayChar *> a;
- for(std::vector<const DataArrayChar *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
- if(*it4)
- a.push_back(*it4);
+ for(auto it4 : arr)
+ if(it4)
+ a.push_back(it4);
if(a.empty())
throw INTERP_KERNEL::Exception("DataArrayChar::Meld : array must be NON empty !");
std::vector<const DataArrayChar *>::const_iterator it;
for(it=a.begin();it!=a.end();it++)
(*it)->checkAllocated();
it=a.begin();
- mcIdType nbOfTuples=(*it)->getNumberOfTuples();
+ mcIdType const nbOfTuples=(*it)->getNumberOfTuples();
std::vector<std::size_t> nbc(a.size());
std::vector<const char *> pts(a.size());
nbc[0]=(*it)->getNumberOfComponents();
nbc[i]=(*it)->getNumberOfComponents();
pts[i]=(*it)->getConstPointer();
}
- std::size_t totalNbOfComp=std::accumulate(nbc.begin(),nbc.end(),(std::size_t)0);
+ std::size_t const totalNbOfComp=std::accumulate(nbc.begin(),nbc.end(),(std::size_t)0);
DataArrayChar *ret=a[0]->buildEmptySpecializedDAChar();
ret->alloc(nbOfTuples,totalNbOfComp);
char *retPtr=ret->getPointer();
if(_mem.reprHeader(ToIdType(getNumberOfComponents()),stream))
{
const char *data=begin();
- mcIdType nbOfTuples=getNumberOfTuples();
- std::size_t nbCompo=getNumberOfComponents();
+ mcIdType const nbOfTuples=getNumberOfTuples();
+ std::size_t const nbCompo=getNumberOfComponents();
for(mcIdType i=0;i<nbOfTuples;i++,data+=nbCompo)
{
stream << "Tuple #" << i << " : ";
void DataArrayByte::reprCppStream(const std::string& varName, std::ostream& stream) const
{
- mcIdType nbTuples=getNumberOfTuples();
- std::size_t nbComp=getNumberOfComponents();
+ mcIdType const nbTuples=getNumberOfTuples();
+ std::size_t const nbComp=getNumberOfComponents();
const char *data=getConstPointer();
stream << "DataArrayByte *" << varName << "=DataArrayByte::New();" << std::endl;
if(nbTuples*nbComp>=1)
stream << "DataArrayByte C++ instance at " << this << ". ";
if(isAllocated())
{
- std::size_t nbOfCompo=_info_on_compo.size();
+ std::size_t const nbOfCompo=_info_on_compo.size();
if(nbOfCompo>=1)
{
- mcIdType nbOfTuples=getNumberOfTuples();
+ mcIdType const nbOfTuples=getNumberOfTuples();
stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
}
void DataArrayByte::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const
{
const char *data=begin();
- mcIdType nbOfTuples=getNumberOfTuples();
- std::size_t nbOfCompo=_info_on_compo.size();
+ mcIdType const nbOfTuples=getNumberOfTuples();
+ std::size_t const nbOfCompo=_info_on_compo.size();
std::ostringstream oss2; oss2 << "[";
std::string oss2Str(oss2.str());
bool isFinished=true;
else
{ oss2 << (int)*data; data++; }
if(i!=nbOfTuples-1) oss2 << ", ";
- std::string oss3Str(oss2.str());
+ std::string const oss3Str(oss2.str());
if(oss3Str.length()<maxNbOfByteInRepr)
oss2Str=oss3Str;
else
bool DataArrayByte::isEqualIfNotWhy(const DataArrayChar& other, std::string& reason) const
{
- const DataArrayByte *otherC=dynamic_cast<const DataArrayByte *>(&other);
+ const auto *otherC=dynamic_cast<const DataArrayByte *>(&other);
if(!otherC)
{ reason="this is of type DataArrayByte whereas other is not a DataArrayByte instance"; return false; }
return DataArrayChar::isEqualIfNotWhy(other,reason);
checkAllocated();
if(getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("DataArrayByte::toVectorOfBool : this method can be used only if this has one component !");
- mcIdType nbt(getNumberOfTuples());
+ mcIdType const nbt(getNumberOfTuples());
std::vector<bool> ret(nbt,false);
const char *pt(begin());
for(mcIdType i=0;i<nbt;i++,pt++)
return ret;
}
-DataArrayByteIterator::DataArrayByteIterator(DataArrayByte *da):_da(da),_pt(0),_tuple_id(0),_nb_comp(0),_nb_tuple(0)
+DataArrayByteIterator::DataArrayByteIterator(DataArrayByte *da):_da(da),_pt(nullptr),_tuple_id(0),_nb_comp(0),_nb_tuple(0)
{
if(_da)
{
if(_tuple_id<_nb_tuple)
{
_tuple_id++;
- DataArrayByteTuple *ret=new DataArrayByteTuple(_pt,_nb_comp);
+ auto *ret=new DataArrayByteTuple(_pt,_nb_comp);
_pt+=_nb_comp;
return ret;
}
else
- return 0;
+ return nullptr;
}
DataArrayByteTuple::DataArrayByteTuple(char *pt, std::size_t nbOfComp):_pt(pt),_nb_of_compo(nbOfComp)
*/
DataArrayAsciiChar::DataArrayAsciiChar(const std::string& st)
{
- std::size_t lgth=st.length();
+ std::size_t const lgth=st.length();
if(lgth==0)
throw INTERP_KERNEL::Exception("DataArrayAsciiChar constructor with string ! Size of input string is null !");
alloc(1,lgth);
if(vst.empty())
throw INTERP_KERNEL::Exception("DataArrayAsciiChar constructor with vector of strings ! Empty array !");
std::size_t nbCompo=0;
- for(std::vector<std::string>::const_iterator it=vst.begin();it!=vst.end();it++)
- nbCompo=std::max(nbCompo,(*it).length());
+ for(const auto & it : vst)
+ nbCompo=std::max(nbCompo,it.length());
if(nbCompo==0)
throw INTERP_KERNEL::Exception("DataArrayAsciiChar constructor with vector of strings ! All strings in not empty vector are empty !");
- std::size_t nbTuples=vst.size();
+ std::size_t const nbTuples=vst.size();
alloc(nbTuples,nbCompo);
char *pt=getPointer();
for(std::size_t i=0;i<nbTuples;i++,pt+=nbCompo)
{
const std::string& tmp=vst[i];
- std::size_t sz=tmp.length();
+ std::size_t const sz=tmp.length();
std::copy(tmp.begin(),tmp.begin()+sz,pt);
std::fill(pt+sz,pt+nbCompo,defaultChar);
}
if(_mem.reprHeader(ToIdType(getNumberOfComponents()),stream))
{
const char *data=begin();
- mcIdType nbOfTuples=getNumberOfTuples();
- std::size_t nbCompo=getNumberOfComponents();
+ mcIdType const nbOfTuples=getNumberOfTuples();
+ std::size_t const nbCompo=getNumberOfComponents();
for(mcIdType i=0;i<nbOfTuples;i++,data+=nbCompo)
{
stream << "Tuple #" << i << " : \"";
void DataArrayAsciiChar::reprCppStream(const std::string& varName, std::ostream& stream) const
{
- mcIdType nbTuples=getNumberOfTuples();
- std::size_t nbComp=getNumberOfComponents();
+ mcIdType const nbTuples=getNumberOfTuples();
+ std::size_t const nbComp=getNumberOfComponents();
const char *data=getConstPointer();
stream << "DataArrayAsciiChar *" << varName << "=DataArrayAsciiChar::New();" << std::endl;
if(nbTuples*nbComp>=1)
stream << "DataArrayAsciiChar C++ instance at " << this << ". ";
if(isAllocated())
{
- std::size_t nbOfCompo=_info_on_compo.size();
+ std::size_t const nbOfCompo=_info_on_compo.size();
if(nbOfCompo>=1)
{
- mcIdType nbOfTuples=getNumberOfTuples();
+ mcIdType const nbOfTuples=getNumberOfTuples();
stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
}
void DataArrayAsciiChar::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const
{
const char *data=begin();
- mcIdType nbOfTuples=getNumberOfTuples();
- std::size_t nbOfCompo=_info_on_compo.size();
+ mcIdType const nbOfTuples=getNumberOfTuples();
+ std::size_t const nbOfCompo=_info_on_compo.size();
std::ostringstream oss2; oss2 << "[";
std::string oss2Str(oss2.str());
bool isFinished=true;
oss2 << ")";
}
if(i!=nbOfTuples-1) oss2 << ", ";
- std::string oss3Str(oss2.str());
+ std::string const oss3Str(oss2.str());
if(oss3Str.length()<maxNbOfByteInRepr)
oss2Str=oss3Str;
else
bool DataArrayAsciiChar::isEqualIfNotWhy(const DataArrayChar& other, std::string& reason) const
{
- const DataArrayAsciiChar *otherC=dynamic_cast<const DataArrayAsciiChar *>(&other);
+ const auto *otherC=dynamic_cast<const DataArrayAsciiChar *>(&other);
if(!otherC)
{ reason="this is of type DataArrayAsciiChar whereas other is not a DataArrayAsciiChar instance"; return false; }
return DataArrayChar::isEqualIfNotWhy(other,reason);
}
-DataArrayAsciiCharIterator::DataArrayAsciiCharIterator(DataArrayAsciiChar *da):_da(da),_pt(0),_tuple_id(0),_nb_comp(0),_nb_tuple(0)
+DataArrayAsciiCharIterator::DataArrayAsciiCharIterator(DataArrayAsciiChar *da):_da(da),_pt(nullptr),_tuple_id(0),_nb_comp(0),_nb_tuple(0)
{
if(_da)
{
if(_tuple_id<_nb_tuple)
{
_tuple_id++;
- DataArrayAsciiCharTuple *ret=new DataArrayAsciiCharTuple(_pt,_nb_comp);
+ auto *ret=new DataArrayAsciiCharTuple(_pt,_nb_comp);
_pt+=_nb_comp;
return ret;
}
else
- return 0;
+ return nullptr;
}
DataArrayAsciiCharTuple::DataArrayAsciiCharTuple(char *pt, std::size_t nbOfComp):_pt(pt),_nb_of_compo(nbOfComp)
// Author : Anthony Geay (EDF R&D)
#include "MEDCouplingMemArray.txx"
+#include "MCType.hxx"
+#include <string>
+#include <ostream>
+#include <cstddef>
+#include <algorithm>
+#include <iterator>
+#include <sstream>
using namespace MEDCoupling;
void DataArrayFloat::reprCppStream(const std::string& varName, std::ostream& stream) const
{
- mcIdType nbTuples(getNumberOfTuples());
- std::size_t nbComp(getNumberOfComponents());
+ mcIdType const nbTuples(getNumberOfTuples());
+ std::size_t const nbComp(getNumberOfComponents());
const float *data(begin());
stream.precision(7);
stream << "DataArrayFloat *" << varName << "=DataArrayFloat::New();" << std::endl;
stream << "DataArrayFloat C++ instance at " << this << ". ";
if(isAllocated())
{
- std::size_t nbOfCompo=_info_on_compo.size();
+ std::size_t const nbOfCompo=_info_on_compo.size();
if(nbOfCompo>=1)
{
- mcIdType nbOfTuples=getNumberOfTuples();
+ mcIdType const nbOfTuples=getNumberOfTuples();
stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
}
void DataArrayFloat::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const
{
const float *data(begin());
- mcIdType nbOfTuples(getNumberOfTuples());
- std::size_t nbOfCompo=_info_on_compo.size();
+ mcIdType const nbOfTuples(getNumberOfTuples());
+ std::size_t const nbOfCompo=_info_on_compo.size();
std::ostringstream oss2; oss2 << "[";
oss2.precision(7);
std::string oss2Str(oss2.str());
else
oss2 << *data++;
if(i!=nbOfTuples-1) oss2 << ", ";
- std::string oss3Str(oss2.str());
+ std::string const oss3Str(oss2.str());
if(oss3Str.length()<maxNbOfByteInRepr)
oss2Str=oss3Str;
else
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingMesh.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MCType.hxx"
+#include "CellModel.hxx"
+#include "MCIdType.hxx"
#include "MEDCouplingUMesh.hxx"
-#include "MEDCouplingMemArray.txx"
#include "MEDCouplingFieldDouble.hxx"
#include "MEDCouplingFieldDiscretization.hxx"
#include "MCAuto.hxx"
+#include "NormalizedGeometricTypes"
+#include <cstddef>
+#include <algorithm>
+#include <ostream>
+#include <ios>
#include <set>
#include <cmath>
#include <sstream>
#include <fstream>
-#include <iterator>
+#include <vector>
using namespace MEDCoupling;
return getType()==CARTESIAN;
}
-bool MEDCouplingMesh::isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const
+bool MEDCouplingMesh::isEqualIfNotWhy(const MEDCouplingMesh *other, double /*prec*/, std::string& reason) const
{
if(!other)
throw INTERP_KERNEL::Exception("MEDCouplingMesh::isEqualIfNotWhy : other instance is NULL !");
void MEDCouplingMesh::checkGeoEquivalWith(const MEDCouplingMesh *other, int levOfCheck, double prec,
DataArrayIdType *&cellCor, DataArrayIdType *&nodeCor) const
{
- cellCor=0;
- nodeCor=0;
+ cellCor=nullptr;
+ nodeCor=nullptr;
if(this==other)
return ;
switch(levOfCheck)
{
std::vector<mcIdType> crest;
std::set<mcIdType> p(partBg,partEnd);
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
for(mcIdType i=0;i<nbOfCells;i++)
{
std::vector<mcIdType> conn;
/*!
* This method checks fastly that \a this and \a other are equal. All common checks are done here.
*/
-void MEDCouplingMesh::checkFastEquivalWith(const MEDCouplingMesh *other, double prec) const
+void MEDCouplingMesh::checkFastEquivalWith(const MEDCouplingMesh *other, double /*prec*/) const
{
if(!other)
throw INTERP_KERNEL::Exception("MEDCouplingMesh::checkFastEquivalWith : input mesh is null !");
{
if(beginCellIds==0 && endCellIds==getNumberOfCells() && stepCellIds==1)
{
- MEDCouplingMesh *ret(const_cast<MEDCouplingMesh *>(this));
+ auto *ret(const_cast<MEDCouplingMesh *>(this));
ret->incrRef();
return ret;
}
*
* \sa MEDCouplingMesh::buildPartAndReduceNodes
*/
-MEDCouplingMesh *MEDCouplingMesh::buildPartRangeAndReduceNodes(mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds, mcIdType& beginOut, mcIdType& endOut, mcIdType& stepOut, DataArrayIdType*& arr) const
+MEDCouplingMesh *MEDCouplingMesh::buildPartRangeAndReduceNodes(mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds, mcIdType& /*beginOut*/, mcIdType& /*endOut*/, mcIdType& /*stepOut*/, DataArrayIdType*& arr) const
{
MCAuto<DataArrayIdType> cellIds=DataArrayIdType::Range(beginCellIds,endCellIds,stepCellIds);
return buildPartAndReduceNodes(cellIds->begin(),cellIds->end(),arr);
{
eltsIndex=DataArrayIdType::New(); elts=DataArrayIdType::New(); eltsIndex->alloc(nbOfPoints+1,1); eltsIndex->setIJ(0,0,0); elts->alloc(0,1);
mcIdType *eltsIndexPtr(eltsIndex->getPointer());
- int spaceDim(getSpaceDimension());
+ int const spaceDim(getSpaceDimension());
const double *work(pos);
for(mcIdType i=0;i<nbOfPoints;i++,work+=spaceDim)
{
MCAuto<DataArrayDouble> volXCenter( DataArrayDouble::Multiply(cellCenters,vol->getArray()) );
MCAuto<DataArrayDouble> ret(DataArrayDouble::New()); ret->alloc(1, this->getSpaceDimension());
volXCenter->accumulate( ret->getPointer() );
- double volOfMesh(vol->accumulate(0));
+ double const volOfMesh(vol->accumulate(0));
ret->applyLin(1.0/volOfMesh,0.0);
return ret;
}
void MEDCouplingMesh::SplitExtension(const std::string& fileName, std::string& baseName, std::string& extension)
{
- std::size_t pos(fileName.find_last_of('.'));
+ std::size_t const pos(fileName.find_last_of('.'));
if(pos==std::string::npos)
{
baseName=fileName;
#include "MCType.hxx"
#include "MEDCouplingTimeLabel.hxx"
#include "MEDCouplingRefCountObject.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
#include "MCAuto.hxx"
+#include "NormalizedGeometricTypes"
-#include "InterpKernelException.hxx"
+#include <cstddef>
+#include <ostream>
#include <set>
+#include <string>
#include <vector>
namespace MEDCoupling
class MEDCouplingMesh : public RefCountObject, public TimeLabel
{
public:
- MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
+ MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
MEDCOUPLING_EXPORT void setName(const std::string& name) { _name=name; }
MEDCOUPLING_EXPORT std::string getName() const { return _name; }
MEDCOUPLING_EXPORT void setDescription(const std::string& descr) { _description=descr; }
MEDCOUPLING_EXPORT MEDCouplingMesh();
MEDCOUPLING_EXPORT MEDCouplingMesh(const MEDCouplingMesh& other);
MEDCOUPLING_EXPORT virtual std::string getVTKDataSetType() const = 0;
- MEDCOUPLING_EXPORT virtual ~MEDCouplingMesh() { }
+ MEDCOUPLING_EXPORT ~MEDCouplingMesh() override = default;
private:
std::string _name;
std::string _description;
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingMultiFields.hxx"
+#include "MCAuto.hxx"
+#include "MCIdType.hxx"
+#include "MCType.hxx"
#include "MEDCouplingFieldTemplate.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "MEDCouplingMesh.hxx"
-#include "MCAuto.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include <cstddef>
+#include <iterator>
#include <sstream>
#include <algorithm>
+#include <string>
+#include <vector>
using namespace MEDCoupling;
return new MEDCouplingMultiFields(*this);
}
-bool MEDCouplingMultiFields::isEqual(const MEDCouplingMultiFields *other, double meshPrec, double valsPrec) const
+bool MEDCouplingMultiFields::isEqual(const MEDCouplingMultiFields *other, double meshPrec, double valsPrec) const
{
- std::size_t sz=_fs.size();
+ std::size_t const sz=_fs.size();
if(sz!=other->_fs.size())
return false;
for(std::size_t i=0;i<sz;i++)
const MEDCouplingFieldDouble *f2=other->_fs[i];
if(f1!=f2)
{
- if(f1==0 || f2==0)
+ if(f1==nullptr || f2==nullptr)
return false;
if(!_fs[i]->isEqual(other->_fs[i],meshPrec,valsPrec))
return false;
}
}
std::vector<int> refs1,refs2;
- std::vector<MEDCouplingMesh *> ms1=getDifferentMeshes(refs1);
- std::vector<MEDCouplingMesh *> ms2=other->getDifferentMeshes(refs2);
+ std::vector<MEDCouplingMesh *> const ms1=getDifferentMeshes(refs1);
+ std::vector<MEDCouplingMesh *> const ms2=other->getDifferentMeshes(refs2);
if(ms1.size()!=ms2.size())
return false;
if(refs1!=refs2)
return false;
std::vector< std::vector<int> > refs3,refs4;
- std::vector<DataArrayDouble *> das1=getDifferentArrays(refs3);
- std::vector<DataArrayDouble *> das2=getDifferentArrays(refs4);
+ std::vector<DataArrayDouble *> const das1=getDifferentArrays(refs3);
+ std::vector<DataArrayDouble *> const das2=getDifferentArrays(refs4);
if(das1.size()!=das2.size())
return false;
if(refs3!=refs4)
std::string MEDCouplingMultiFields::getName() const
{
- std::vector< MCAuto<MEDCouplingFieldDouble> >::const_iterator it=_fs.begin();
+ auto it=_fs.begin();
for(;it!=_fs.end();it++)
if((const MEDCouplingFieldDouble *)(*it))
return (*it)->getName();
std::string MEDCouplingMultiFields::getDescription() const
{
- std::vector< MCAuto<MEDCouplingFieldDouble> >::const_iterator it=_fs.begin();
+ auto it=_fs.begin();
for(;it!=_fs.end();it++)
if((const MEDCouplingFieldDouble *)(*it))
return (*it)->getDescription();
std::string MEDCouplingMultiFields::getTimeUnit() const
{
- std::vector< MCAuto<MEDCouplingFieldDouble> >::const_iterator it=_fs.begin();
+ auto it=_fs.begin();
for(;it!=_fs.end();it++)
if((const MEDCouplingFieldDouble *)(*it))
return (*it)->getTimeUnit();
double MEDCouplingMultiFields::getTimeResolution() const
{
- std::vector< MCAuto<MEDCouplingFieldDouble> >::const_iterator it=_fs.begin();
+ auto it=_fs.begin();
for(;it!=_fs.end();it++)
if((const MEDCouplingFieldDouble *)(*it))
return (*it)->getTimeTolerance();
return simpleRepr();
}
-bool MEDCouplingMultiFields::isEqualWithoutConsideringStr(const MEDCouplingMultiFields *other, double meshPrec, double valsPrec) const
+bool MEDCouplingMultiFields::isEqualWithoutConsideringStr(const MEDCouplingMultiFields *other, double meshPrec, double valsPrec) const
{
- std::size_t sz=_fs.size();
+ std::size_t const sz=_fs.size();
if(sz!=other->_fs.size())
return false;
for(std::size_t i=0;i<sz;i++)
void MEDCouplingMultiFields::updateTime() const
{
- std::vector< MCAuto<MEDCouplingFieldDouble> >::const_iterator it=_fs.begin();
+ auto it=_fs.begin();
for(;it!=_fs.end();it++)
if((const MEDCouplingFieldDouble *)(*it))
(*it)->updateTime();
std::vector<const BigMemoryObject *> MEDCouplingMultiFields::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
- for(std::vector< MCAuto<MEDCouplingFieldDouble> >::const_iterator it=_fs.begin();it!=_fs.end();it++)
- ret.push_back((const MEDCouplingFieldDouble *)*it);
+ for(const auto & _f : _fs)
+ ret.push_back((const MEDCouplingFieldDouble *)_f);
return ret;
}
std::vector<MEDCouplingMesh *> MEDCouplingMultiFields::getMeshes() const
{
std::vector<MEDCouplingMesh *> ms;
- for(std::vector< MCAuto<MEDCouplingFieldDouble> >::const_iterator it=_fs.begin();it!=_fs.end();it++)
+ for(const auto & _f : _fs)
{
- const MEDCouplingMesh *m=0;
- if((const MEDCouplingFieldDouble *)(*it))
- m=(*it)->getMesh();
+ const MEDCouplingMesh *m=nullptr;
+ if((const MEDCouplingFieldDouble *)_f)
+ m=_f->getMesh();
ms.push_back(const_cast<MEDCouplingMesh *>(m));
}
return ms;
refs.resize(_fs.size());
std::vector<MEDCouplingMesh *> ms;
int id=0;
- for(std::vector< MCAuto<MEDCouplingFieldDouble> >::const_iterator it=_fs.begin();it!=_fs.end();it++,id++)
+ for(auto it=_fs.begin();it!=_fs.end();it++,id++)
{
- const MEDCouplingMesh *m=0;
+ const MEDCouplingMesh *m=nullptr;
if((const MEDCouplingFieldDouble *)(*it))
m=(*it)->getMesh();
if(m)
{
- std::vector<MEDCouplingMesh *>::iterator it2=std::find(ms.begin(),ms.end(),m);
+ auto const it2=std::find(ms.begin(),ms.end(),m);
if(it2==ms.end())
{
ms.push_back(const_cast<MEDCouplingMesh *>(m));
std::vector<DataArrayDouble *> MEDCouplingMultiFields::getArrays() const
{
std::vector<DataArrayDouble *> tmp;
- for(std::vector< MCAuto<MEDCouplingFieldDouble> >::const_iterator it=_fs.begin();it!=_fs.end();it++)
+ for(const auto & _f : _fs)
{
- std::vector<DataArrayDouble *> tmp2=(*it)->getArrays();
+ std::vector<DataArrayDouble *> tmp2=_f->getArrays();
tmp.insert(tmp.end(),tmp2.begin(),tmp2.end());
}
return tmp;
refs.resize(_fs.size());
int id=0;
std::vector<DataArrayDouble *> ret;
- for(std::vector< MCAuto<MEDCouplingFieldDouble> >::const_iterator it=_fs.begin();it!=_fs.end();it++,id++)
+ for(auto it=_fs.begin();it!=_fs.end();it++,id++)
{
std::vector<DataArrayDouble *> tmp2;
if((const MEDCouplingFieldDouble *)(*it))
{
if(*it2)
{
- std::vector<DataArrayDouble *>::iterator it3=std::find(ret.begin(),ret.end(),*it2);
+ auto const it3=std::find(ret.begin(),ret.end(),*it2);
if(it3==ret.end())
{
ret.push_back(*it2);
void MEDCouplingMultiFields::checkConsistencyLight() const
{
- std::vector< MCAuto<MEDCouplingFieldDouble> >::const_iterator it=_fs.begin();
+ auto it=_fs.begin();
for(;it!=_fs.end();it++)
{
- if((const MEDCouplingFieldDouble *)(*it)==0)
+ if((const MEDCouplingFieldDouble *)(*it)==nullptr)
throw INTERP_KERNEL::Exception("MEDCouplingMultiFields::checkConsistencyLight : There is an empty Field in array...");
(*it)->checkConsistencyLight();
}
MEDCouplingMultiFields::MEDCouplingMultiFields(const std::vector<MEDCouplingFieldDouble *>& fs):_fs(fs.size())
{
int id=0;
- for(std::vector< MEDCouplingFieldDouble * >::const_iterator it=fs.begin();it!=fs.end();it++,id++)
+ for(auto it=fs.begin();it!=fs.end();it++,id++)
{
if(*it)
(*it)->incrRef();
*/
MEDCouplingMultiFields::MEDCouplingMultiFields(const MEDCouplingMultiFields& other):RefCountObject(other)
{
- std::size_t sz=other._fs.size();
+ std::size_t const sz=other._fs.size();
_fs.resize(sz);
std::vector<int> refs;
std::vector< std::vector<int> > refs2;
std::vector<MEDCouplingMesh *> ms=other.getDifferentMeshes(refs);
- std::size_t msLgh=ms.size();
+ std::size_t const msLgh=ms.size();
std::vector< MCAuto<MEDCouplingMesh> > ms2(msLgh);
for(std::size_t i=0;i<msLgh;i++)
ms2[i]=ms[i]->deepCopy();
std::vector<DataArrayDouble *> das=other.getDifferentArrays(refs2);
- std::size_t dasLgth=das.size();
+ std::size_t const dasLgth=das.size();
std::vector< MCAuto<DataArrayDouble> > das2(dasLgth);
for(std::size_t i=0;i<dasLgth;i++)
das2[i]=das[i]->deepCopy();
tmp->decrRef();
if(refs[i]!=-1)
_fs[i]->setMesh(ms2[refs[i]]);
- std::size_t nbOfArr=refs2[i].size();
+ std::size_t const nbOfArr=refs2[i].size();
std::vector<DataArrayDouble *> tmp2(nbOfArr);
for(std::size_t j=0;j<nbOfArr;j++)
{
if(refs2[i][j]!=-1)
tmp2[j]=das2[refs2[i][j]];
else
- tmp2[j]=0;
+ tmp2[j]=nullptr;
}
_fs[i]->setArrays(tmp2);
std::vector<mcIdType> tinyInfo;
}
MEDCouplingMultiFields::MEDCouplingMultiFields()
-{
-}
+= default;
void MEDCouplingMultiFields::getTinySerializationInformation(std::vector<mcIdType>& tinyInfo, std::vector<double>& tinyInfo2, int& nbOfDiffMeshes, int& nbOfDiffArr) const
{
std::vector<int> refs;
- std::vector<MEDCouplingMesh *> ms=getDifferentMeshes(refs);
+ std::vector<MEDCouplingMesh *> const ms=getDifferentMeshes(refs);
nbOfDiffMeshes=(int)ms.size();
std::vector< std::vector<int> > refs2;
- std::vector<DataArrayDouble *> fs=getDifferentArrays(refs2);
+ std::vector<DataArrayDouble *> const fs=getDifferentArrays(refs2);
nbOfDiffArr=(int)fs.size();
//
- mcIdType sz=ToIdType(refs.size());//==_fs.size()
+ mcIdType const sz=ToIdType(refs.size());//==_fs.size()
mcIdType sz2=0;
for(mcIdType i=0;i<sz;i++)
sz2+=ToIdType(refs2[i].size());
//
tinyInfo2.clear();
- std::vector<int> doubleDaInd(sz);
+ std::vector<int> const doubleDaInd(sz);
std::vector<int> timeDiscrInt;
tinyInfo.resize(sz2+5*sz+3);
tinyInfo[0]=sz;
tinyInfo2.insert(tinyInfo2.end(),tmp.begin(),tmp.end());
timeDiscrInt.insert(timeDiscrInt.end(),tmp2.begin(),tmp2.end());
}
- mcIdType sz3=ToIdType(timeDiscrInt.size());
+ mcIdType const sz3=ToIdType(timeDiscrInt.size());
tinyInfo[2]=sz3;
//
for(mcIdType i=0;i<sz;i++)
const std::vector<MEDCouplingFieldTemplate *>& ft, const std::vector<MEDCouplingMesh *>& ms,
const std::vector<DataArrayDouble *>& das)
{
- mcIdType sz=tinyInfoI[0];
+ mcIdType const sz=tinyInfoI[0];
_fs.resize(sz);
- mcIdType sz2=tinyInfoI[1];
+ mcIdType const sz2=tinyInfoI[1];
// dealing with ft with no mesh set.
for(mcIdType i=0;i<sz;i++)
{
- mcIdType meshId=tinyInfoI[3+i];
+ mcIdType const meshId=tinyInfoI[3+i];
if(meshId!=-1)
ft[i]->setMesh(ms[meshId]);
}
for(mcIdType i=0;i<sz;i++)
{
_fs[i]=MEDCouplingFieldDouble::New(*ft[i],(TypeOfTimeDiscretization)tinyInfoI[2*sz+3+i]);
- mcIdType sz3=tinyInfoI[sz+i+3];
+ mcIdType const sz3=tinyInfoI[sz+i+3];
std::vector<DataArrayDouble *> tmp(sz3);
for(mcIdType j=0;j<sz3;j++,k++)
{
- mcIdType daId=tinyInfoI[5*sz+k+3];
+ mcIdType const daId=tinyInfoI[5*sz+k+3];
if(daId!=-1)
tmp[j]=das[daId];
else
- tmp[j]=0;
+ tmp[j]=nullptr;
}
_fs[i]->setArrays(tmp);
// time discr tiny info
- mcIdType lgthI=tinyInfoI[4*sz+3+i];
- mcIdType lgthD=tinyInfoI[3*sz+3+i];
+ mcIdType const lgthI=tinyInfoI[4*sz+3+i];
+ mcIdType const lgthD=tinyInfoI[3*sz+3+i];
//
- std::vector<mcIdType> tdInfoI(tinyInfoI.begin()+sz2+5*sz+3+offI,tinyInfoI.begin()+sz2+5*sz+3+offI+lgthI);
- std::vector<double> tdInfoD(tinyInfoD.begin()+offD,tinyInfoD.begin()+offD+lgthD);
+ std::vector<mcIdType> const tdInfoI(tinyInfoI.begin()+sz2+5*sz+3+offI,tinyInfoI.begin()+sz2+5*sz+3+offI+lgthI);
+ std::vector<double> const tdInfoD(tinyInfoD.begin()+offD,tinyInfoD.begin()+offD+lgthD);
_fs[i]->getTimeDiscretizationUnderGround()->finishUnserialization2(tdInfoI,tdInfoD);
//
offI+=lgthI;
#ifndef __PARAMEDMEM_MEDCOUPLINGMULTIFIELDS_HXX__
#define __PARAMEDMEM_MEDCOUPLINGMULTIFIELDS_HXX__
+#include "MEDCoupling.hxx"
#include "MEDCouplingRefCountObject.hxx"
#include "MEDCouplingTimeLabel.hxx"
#include "MCAuto.hxx"
#include "MCType.hxx"
-#include "InterpKernelException.hxx"
+#include <string>
+#include <cstddef>
#include <vector>
namespace MEDCoupling
MEDCOUPLING_EXPORT virtual std::vector<MEDCouplingMesh *> getDifferentMeshes(std::vector<int>& refs) const;
MEDCOUPLING_EXPORT virtual std::vector<DataArrayDouble *> getArrays() const;
MEDCOUPLING_EXPORT virtual std::vector<DataArrayDouble *> getDifferentArrays(std::vector< std::vector<int> >& refs) const;
- MEDCOUPLING_EXPORT void updateTime() const;
- MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDCOUPLING_EXPORT void updateTime() const override;
+ MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
MEDCOUPLING_EXPORT void getTinySerializationInformation(std::vector<mcIdType>& tinyInfo, std::vector<double>& tinyInfo2, int& nbOfDiffMeshes, int& nbOfDiffArr) const;
MEDCOUPLING_EXPORT void finishUnserialization(const std::vector<mcIdType>& tinyInfoI, const std::vector<double>& tinyInfoD,
const std::vector<MEDCouplingFieldTemplate *>& ft, const std::vector<MEDCouplingMesh *>& ms,
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingNatureOfField.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
+#include "InterpKernelException.hxx"
#include <algorithm>
+#include <cstddef>
+#include <iterator>
#include <sstream>
+#include <string>
namespace MEDCoupling
{
oss << GetAllPossibilitiesStr() << " !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- std::size_t pos2=std::distance(POS_OF_NATUREOFFIELD,pos);
+ std::size_t const pos2=std::distance(POS_OF_NATUREOFFIELD,pos);
return REPR_OF_NATUREOFFIELD[pos2];
}
const int *pos=std::find(POS_OF_NATUREOFFIELD,POS_OF_NATUREOFFIELD+NB_OF_POSSIBILITIES,(int)nat);
if(pos==POS_OF_NATUREOFFIELD+NB_OF_POSSIBILITIES)
return std::string("Unrecognized nature of field !");
- std::size_t pos2=std::distance(POS_OF_NATUREOFFIELD,pos);
+ std::size_t const pos2=std::distance(POS_OF_NATUREOFFIELD,pos);
return std::string(REPR_OF_NATUREOFFIELD[pos2]);
}
#include "MEDCoupling.hxx"
#include "MEDCouplingNatureOfFieldEnum"
-#include "InterpKernelException.hxx"
+#include <string>
namespace MEDCoupling
{
#ifndef __PARAMEDMEM_MEDCOUPLINGNORMALIZEDCARTESIANMESH_HXX__
#define __PARAMEDMEM_MEDCOUPLINGNORMALIZEDCARTESIANMESH_HXX__
+#include "MCIdType.hxx"
#include "NormalizedUnstructuredMesh.hxx"
namespace MEDCoupling
public:
static const int MY_SPACEDIM=SPACEDIM;
static const int MY_MESHDIM=SPACEDIM;
- typedef mcIdType MyConnType;
+ using MyConnType = int;
static const INTERP_KERNEL::NumberingPolicy My_numPol=INTERP_KERNEL::ALL_C_MODE;
public:
MEDCouplingNormalizedCartesianMesh(const MEDCoupling::MEDCouplingCMesh *mesh);
// Author : Edward AGAPOV (eap)
//
+#include "MCIdType.hxx"
#include "MEDCouplingNormalizedCartesianMesh.hxx"
#include "MEDCouplingCMesh.hxx"
+#include "MEDCouplingMemArray.hxx"
template<int SPACEDIM>
MEDCouplingNormalizedCartesianMesh<SPACEDIM>::MEDCouplingNormalizedCartesianMesh(const MEDCoupling::MEDCouplingCMesh *mesh):_mesh(mesh)
#ifndef __PARAMEDMEM_MEDCOUPLINGNORMALIZEDUNSTRUCTUREDMESH_HXX__
#define __PARAMEDMEM_MEDCOUPLINGNORMALIZEDUNSTRUCTUREDMESH_HXX__
+#include "MCIdType.hxx"
#include "NormalizedUnstructuredMesh.hxx"
-#include "MCType.hxx"
+#include "NormalizedGeometricTypes"
namespace MEDCoupling
{
#define __MEDCOUPLINGNORMALIZEDUNSTRUCTUREDMESH_TXX__
#include "MEDCouplingNormalizedUnstructuredMesh.hxx"
-#include "InterpKernelAssert.hxx"
+#include "MCIdType.hxx"
+#include "InterpKernelAssert.hxx"
#include "MEDCouplingUMesh.hxx"
#include "MEDCoupling1GTUMesh.hxx"
#include "MEDCouplingMemArray.hxx"
+#include "NormalizedGeometricTypes"
+#include <algorithm>
#include <limits>
template<int SPACEDIM,int MESHDIM>
{
delete [] _conn_for_interp;
delete [] _conn_index_for_interp;
- _conn_for_interp=0;
- _conn_index_for_interp=0;
+ _conn_for_interp=nullptr;
+ _conn_index_for_interp=nullptr;
}
template<int SPACEDIM,int MESHDIM>
void MEDCouplingNormalizedUnstructuredMesh<SPACEDIM,MESHDIM>::prepare()
{
IKAssert(_mesh->getSpaceDimension()==SPACEDIM);
- const MEDCoupling::MEDCouplingUMesh *m1(dynamic_cast<const MEDCoupling::MEDCouplingUMesh *>(_mesh));
+ const auto *m1(dynamic_cast<const MEDCoupling::MEDCouplingUMesh *>(_mesh));
if(m1)
{
- mcIdType nbOfCell=ToIdType(m1->getNumberOfCells());
- mcIdType initialConnSize=ToIdType(m1->getNodalConnectivity()->getNbOfElems());
+ mcIdType const nbOfCell=ToIdType(m1->getNumberOfCells());
+ mcIdType const initialConnSize=ToIdType(m1->getNodalConnectivity()->getNbOfElems());
_conn_for_interp=new mcIdType[initialConnSize-nbOfCell];
_conn_index_for_interp=new mcIdType[nbOfCell+1];
_conn_index_for_interp[0]=0;
mcIdType *work_conn_index_for_interp=_conn_index_for_interp;
for(mcIdType i=0;i<nbOfCell;i++)
{
- mcIdType nbOfValsToCopy=work_conn_index[1]-work_conn_index[0]-1;
+ mcIdType const nbOfValsToCopy=work_conn_index[1]-work_conn_index[0]-1;
work_conn_for_interp=std::copy(work_conn,work_conn+nbOfValsToCopy,work_conn_for_interp);
work_conn_index_for_interp[1]=work_conn_index_for_interp[0]+nbOfValsToCopy;
work_conn_index++;
}
return ;
}
- const MEDCoupling::MEDCoupling1DGTUMesh *m2(dynamic_cast<const MEDCoupling::MEDCoupling1DGTUMesh *>(_mesh));
+ const auto *m2(dynamic_cast<const MEDCoupling::MEDCoupling1DGTUMesh *>(_mesh));
if(m2)
{
- mcIdType nbOfCell=ToIdType(m2->getNumberOfCells());
+ mcIdType const nbOfCell=ToIdType(m2->getNumberOfCells());
_conn_index_for_interp=new mcIdType[nbOfCell+1];
const mcIdType *conni(m2->getNodalConnectivityIndex()->begin());
std::copy(conni,conni+nbOfCell+1,_conn_index_for_interp);
std::copy(m2->getNodalConnectivity()->begin(),m2->getNodalConnectivity()->end(),_conn_for_interp);
return ;
}
- const MEDCoupling::MEDCoupling1SGTUMesh *m3(dynamic_cast<const MEDCoupling::MEDCoupling1SGTUMesh *>(_mesh));
+ const auto *m3(dynamic_cast<const MEDCoupling::MEDCoupling1SGTUMesh *>(_mesh));
if(m3)
{
mcIdType nbOfCell=ToIdType(m3->getNumberOfCells()),nbNodesPerCell(m3->getNumberOfNodesPerCell());
// Author : Anthony Geay (EDF R&D)
#include "MEDCouplingPartDefinition.hxx"
-
+#include "MCType.hxx"
+#include "MCAuto.hxx"
+#include "MCIdType.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingMemArray.hxx"
+
+#include <algorithm>
+#include <cstddef>
#include <functional>
#include <sstream>
+#include <vector>
+#include <string>
using namespace MEDCoupling;
}
PartDefinition::~PartDefinition()
-{
-}
+= default;
DataArrayPartDefinition *DataArrayPartDefinition::New(DataArrayIdType *listOfIds)
{
what="DataArrayPartDefinition::isEqual : other is null, this is not null !";
return false;
}
- const DataArrayPartDefinition *otherC(dynamic_cast<const DataArrayPartDefinition *>(other));
+ const auto *otherC(dynamic_cast<const DataArrayPartDefinition *>(other));
if(!otherC)
{
what="DataArrayPartDefinition::isEqual : other is not DataArrayPartDefinition !";
return false;
}
std::string what1;
- bool ret(arr0->isEqualIfNotWhy(*arr1,what1));
+ bool const ret(arr0->isEqualIfNotWhy(*arr1,what1));
if(!ret)
{
what=std::string("DataArrayPartDefinition::isEqual : arrays are not equal :\n")+what1;
const PartDefinition *otherPt(&other);
if(!otherPt)
throw INTERP_KERNEL::Exception("DataArrayPartDefinition::operator+ : NULL input !");
- const DataArrayPartDefinition *other1(dynamic_cast<const DataArrayPartDefinition *>(otherPt));
+ const auto *other1(dynamic_cast<const DataArrayPartDefinition *>(otherPt));
if(other1)
return add1(other1);
- const SlicePartDefinition *other2(dynamic_cast<const SlicePartDefinition *>(otherPt));
+ const auto *other2(dynamic_cast<const SlicePartDefinition *>(otherPt));
if(other2)
return add2(other2);
throw INTERP_KERNEL::Exception("DataArrayPartDefinition::operator+ : unrecognized type in input !");
throw INTERP_KERNEL::Exception("DataArrayPartDefinition::composeWith : input PartDef must be not NULL !");
checkConsistencyLight();
other->checkConsistencyLight();
- const SlicePartDefinition *spd(dynamic_cast<const SlicePartDefinition *>(other));
+ const auto *spd(dynamic_cast<const SlicePartDefinition *>(other));
if(spd)
{//special case for optim
mcIdType a(0),b(0),c(0);
}
}
-void DataArrayPartDefinition::serialize(std::vector<mcIdType>& tinyInt, std::vector< MCAuto<DataArrayIdType> >& bigArraysI) const
+void DataArrayPartDefinition::serialize(std::vector<mcIdType>& /*tinyInt*/, std::vector< MCAuto<DataArrayIdType> >& bigArraysI) const
{
bigArraysI.push_back(_arr);
}
{
checkInternalArrayOK();
const DataArrayIdType *arr(_arr);
- DataArrayIdType *arr2(const_cast<DataArrayIdType *>(arr));
+ auto *arr2(const_cast<DataArrayIdType *>(arr));
arr2->incrRef();
return arr2;
}
}
DataArrayPartDefinition::~DataArrayPartDefinition()
-{
-}
+= default;
SlicePartDefinition *SlicePartDefinition::New(mcIdType start, mcIdType stop, mcIdType step)
{
what="SlicePartDefinition::isEqual : other is null, this is not null !";
return false;
}
- const SlicePartDefinition *otherC(dynamic_cast<const SlicePartDefinition *>(other));
+ const auto *otherC(dynamic_cast<const SlicePartDefinition *>(other));
if(!otherC)
{
what="SlicePartDefinition::isEqual : other is not SlicePartDefinition !";
return false;
}
- bool ret((_start==otherC->_start) && (_stop==otherC->_stop) && (_step==otherC->_step));
+ bool const ret((_start==otherC->_start) && (_stop==otherC->_stop) && (_step==otherC->_step));
if(!ret)
{
what="SlicePartDefinition::isEqual : values are not the same !";
const PartDefinition *otherPt(&other);
if(!otherPt)
throw INTERP_KERNEL::Exception("DataArrayPartDefinition::operator+ : NULL input !");
- const DataArrayPartDefinition *other1(dynamic_cast<const DataArrayPartDefinition *>(otherPt));
+ const auto *other1(dynamic_cast<const DataArrayPartDefinition *>(otherPt));
if(other1)
return add1(other1);
- const SlicePartDefinition *other2(dynamic_cast<const SlicePartDefinition *>(otherPt));
+ const auto *other2(dynamic_cast<const SlicePartDefinition *>(otherPt));
if(other2)
return add2(other2);
throw INTERP_KERNEL::Exception("SlicePartDefinition::operator+ : unrecognized type in input !");
return ret;
}
-void SlicePartDefinition::serialize(std::vector<mcIdType>& tinyInt, std::vector< MCAuto<DataArrayIdType> >& bigArraysI) const
+void SlicePartDefinition::serialize(std::vector<mcIdType>& tinyInt, std::vector< MCAuto<DataArrayIdType> >& /*bigArraysI*/) const
{
tinyInt.push_back(_start);
tinyInt.push_back(_stop);
mcIdType SlicePartDefinition::getEffectiveStop() const
{
- mcIdType nbElems(DataArray::GetNumberOfItemGivenBES(_start,_stop,_step,"SlicePartDefinition::getEffectiveStop"));
+ mcIdType const nbElems(DataArray::GetNumberOfItemGivenBES(_start,_stop,_step,"SlicePartDefinition::getEffectiveStop"));
return _start+nbElems*_step;
}
}
SlicePartDefinition::~SlicePartDefinition()
-{
-}
+= default;
#pragma once
+#include "MCType.hxx"
#include "MEDCoupling.hxx"
#include "MEDCouplingMemArray.hxx"
#include "MCAuto.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingTimeLabel.hxx"
+#include <vector>
+#include <string>
+#include <cstddef>
namespace MEDCoupling
{
MEDCOUPLING_EXPORT virtual PartDefinition *tryToSimplify() const = 0;
MEDCOUPLING_EXPORT virtual void serialize(std::vector<mcIdType>& tinyInt, std::vector< MCAuto<DataArrayIdType> >& bigArraysI) const = 0;
protected:
- virtual ~PartDefinition();
+ ~PartDefinition() override;
};
class SlicePartDefinition;
public:
MEDCOUPLING_EXPORT static DataArrayPartDefinition *New(DataArrayIdType *listOfIds);
MEDCOUPLING_EXPORT std::string getClassName() const override { return std::string("DataArrayPartDefinition"); }
- MEDCOUPLING_EXPORT bool isEqual(const PartDefinition *other, std::string& what) const;
- MEDCOUPLING_EXPORT DataArrayPartDefinition *deepCopy() const;
- MEDCOUPLING_EXPORT DataArrayIdType *toDAI() const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfElems() const;
- MEDCOUPLING_EXPORT PartDefinition *operator+(const PartDefinition& other) const;
- MEDCOUPLING_EXPORT std::string getRepr() const;
- MEDCOUPLING_EXPORT PartDefinition *composeWith(const PartDefinition *other) const;
- MEDCOUPLING_EXPORT void checkConsistencyLight() const;
- MEDCOUPLING_EXPORT PartDefinition *tryToSimplify() const;
- MEDCOUPLING_EXPORT void serialize(std::vector<mcIdType>& tinyInt, std::vector< MCAuto<DataArrayIdType> >& bigArraysI) const;
+ MEDCOUPLING_EXPORT bool isEqual(const PartDefinition *other, std::string& what) const override;
+ MEDCOUPLING_EXPORT DataArrayPartDefinition *deepCopy() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *toDAI() const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfElems() const override;
+ MEDCOUPLING_EXPORT PartDefinition *operator+(const PartDefinition& other) const override;
+ MEDCOUPLING_EXPORT std::string getRepr() const override;
+ MEDCOUPLING_EXPORT PartDefinition *composeWith(const PartDefinition *other) const override;
+ MEDCOUPLING_EXPORT void checkConsistencyLight() const override;
+ MEDCOUPLING_EXPORT PartDefinition *tryToSimplify() const override;
+ MEDCOUPLING_EXPORT void serialize(std::vector<mcIdType>& tinyInt, std::vector< MCAuto<DataArrayIdType> >& bigArraysI) const override;
private:
DataArrayPartDefinition(DataArrayIdType *listOfIds);
void checkInternalArrayOK() const;
static void CheckInternalArrayOK(const DataArrayIdType *listOfIds);
- MEDCOUPLING_EXPORT void updateTime() const;
- MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDCOUPLING_EXPORT void updateTime() const override;
+ MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
DataArrayPartDefinition *add1(const DataArrayPartDefinition *other) const;
DataArrayPartDefinition *add2(const SlicePartDefinition *other) const;
- virtual ~DataArrayPartDefinition();
+ ~DataArrayPartDefinition() override;
private:
MCAuto<DataArrayIdType> _arr;
};
public:
MEDCOUPLING_EXPORT static SlicePartDefinition *New(mcIdType start, mcIdType stop, mcIdType step);
MEDCOUPLING_EXPORT std::string getClassName() const override { return std::string("SlicePartDefinition"); }
- MEDCOUPLING_EXPORT bool isEqual(const PartDefinition *other, std::string& what) const;
- MEDCOUPLING_EXPORT SlicePartDefinition *deepCopy() const;
- MEDCOUPLING_EXPORT DataArrayIdType *toDAI() const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfElems() const;
- MEDCOUPLING_EXPORT PartDefinition *operator+(const PartDefinition& other) const;
- MEDCOUPLING_EXPORT std::string getRepr() const;
- MEDCOUPLING_EXPORT PartDefinition *composeWith(const PartDefinition *other) const;
- MEDCOUPLING_EXPORT void checkConsistencyLight() const;
- MEDCOUPLING_EXPORT PartDefinition *tryToSimplify() const;
- MEDCOUPLING_EXPORT void serialize(std::vector<mcIdType>& tinyInt, std::vector< MCAuto<DataArrayIdType> >& bigArraysI) const;
+ MEDCOUPLING_EXPORT bool isEqual(const PartDefinition *other, std::string& what) const override;
+ MEDCOUPLING_EXPORT SlicePartDefinition *deepCopy() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *toDAI() const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfElems() const override;
+ MEDCOUPLING_EXPORT PartDefinition *operator+(const PartDefinition& other) const override;
+ MEDCOUPLING_EXPORT std::string getRepr() const override;
+ MEDCOUPLING_EXPORT PartDefinition *composeWith(const PartDefinition *other) const override;
+ MEDCOUPLING_EXPORT void checkConsistencyLight() const override;
+ MEDCOUPLING_EXPORT PartDefinition *tryToSimplify() const override;
+ MEDCOUPLING_EXPORT void serialize(std::vector<mcIdType>& tinyInt, std::vector< MCAuto<DataArrayIdType> >& bigArraysI) const override;
//specific method
MEDCOUPLING_EXPORT mcIdType getEffectiveStop() const;
MEDCOUPLING_EXPORT void getSlice(mcIdType& start, mcIdType& stop, mcIdType& step) const;
private:
SlicePartDefinition(mcIdType start, mcIdType stop, mcIdType step);
- MEDCOUPLING_EXPORT void updateTime() const;
- MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDCOUPLING_EXPORT void updateTime() const override;
+ MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
DataArrayPartDefinition *add1(const DataArrayPartDefinition *other) const;
PartDefinition *add2(const SlicePartDefinition *other) const;
- virtual ~SlicePartDefinition();
+ ~SlicePartDefinition() override;
private:
mcIdType _start;
mcIdType _stop;
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingPointSet.hxx"
+#include "InterpKernelGeo2DPrecision.hxx"
#include "MCAuto.hxx"
+#include "MCIdType.hxx"
+#include "MCType.hxx"
#include "MEDCoupling1GTUMesh.hxx"
+#include "MEDCouplingMesh.hxx"
+#include "MEDCouplingRefCountObject.hxx"
#include "MEDCouplingUMesh.hxx"
#include "MEDCouplingMemArray.hxx"
+#include "NormalizedUnstructuredMesh.hxx"
#include "PlanarIntersector.txx"
#include "InterpKernelGeo2DQuadraticPolygon.hxx"
#include "InterpKernelGeo2DNode.hxx"
#include "DirectedBoundingBox.hxx"
#include "InterpKernelAutoPtr.hxx"
+#include <algorithm>
#include <cmath>
+#include <cstddef>
+#include <functional>
+#include <iterator>
#include <limits>
-#include <numeric>
#include <sstream>
+#include <vector>
+#include <string>
using namespace MEDCoupling;
-MEDCouplingPointSet::MEDCouplingPointSet():_coords(0)
+MEDCouplingPointSet::MEDCouplingPointSet():_coords(nullptr)
{
}
-MEDCouplingPointSet::MEDCouplingPointSet(const MEDCouplingPointSet& other, bool deepCpy):MEDCouplingMesh(other),_coords(0)
+MEDCouplingPointSet::MEDCouplingPointSet(const MEDCouplingPointSet& other, bool deepCpy):MEDCouplingMesh(other),_coords(nullptr)
{
if(other._coords)
_coords=other._coords->performCopyOrIncrRef(deepCpy);
void MEDCouplingPointSet::copyTinyStringsFrom(const MEDCouplingMesh *other)
{
MEDCouplingMesh::copyTinyStringsFrom(other);
- const MEDCouplingPointSet *otherC=dynamic_cast<const MEDCouplingPointSet *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingPointSet *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("MEDCouplingPointSet::copyTinyStringsFrom : meshes have not same type !");
if(_coords && otherC->_coords)
{
if(!other)
throw INTERP_KERNEL::Exception("MEDCouplingPointSet::isEqualIfNotWhy : null mesh instance in input !");
- const MEDCouplingPointSet *otherC=dynamic_cast<const MEDCouplingPointSet *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingPointSet *>(other);
if(!otherC)
{
reason="mesh given in input is not castable in MEDCouplingPointSet !";
*/
bool MEDCouplingPointSet::isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const
{
- const MEDCouplingPointSet *otherC=dynamic_cast<const MEDCouplingPointSet *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingPointSet *>(other);
if(!otherC)
return false;
if(!areCoordsEqualWithoutConsideringStr(*otherC,prec))
bool MEDCouplingPointSet::areCoordsEqualIfNotWhy(const MEDCouplingPointSet& other, double prec, std::string& reason) const
{
- if(_coords==0 && other._coords==0)
+ if(_coords==nullptr && other._coords==nullptr)
return true;
- if(_coords==0 || other._coords==0)
+ if(_coords==nullptr || other._coords==nullptr)
{
reason="Only one PointSet between the two this and other has coordinate defined !";
return false;
}
if(_coords==other._coords)
return true;
- bool ret=_coords->isEqualIfNotWhy(*other._coords,prec,reason);
+ bool const ret=_coords->isEqualIfNotWhy(*other._coords,prec,reason);
if(!ret)
reason.insert(0,"Coordinates DataArray do not match : ");
return ret;
*/
bool MEDCouplingPointSet::areCoordsEqualWithoutConsideringStr(const MEDCouplingPointSet& other, double prec) const
{
- if(_coords==0 && other._coords==0)
+ if(_coords==nullptr && other._coords==nullptr)
return true;
- if(_coords==0 || other._coords==0)
+ if(_coords==nullptr || other._coords==nullptr)
return false;
if(_coords==other._coords)
return true;
{
if(!_coords)
throw INTERP_KERNEL::Exception("MEDCouplingPointSet::getCoordinatesOfNode : no coordinates array set !");
- mcIdType nbNodes=getNumberOfNodes();
+ mcIdType const nbNodes=getNumberOfNodes();
if(nodeId>=0 && nodeId<nbNodes)
{
const double *cooPtr=_coords->getConstPointer();
- std::size_t spaceDim=getSpaceDimension();
+ std::size_t const spaceDim=getSpaceDimension();
coo.insert(coo.end(),cooPtr+spaceDim*nodeId,cooPtr+spaceDim*(nodeId+1));
}
else
{
DataArrayIdType *comm,*commI;
findCommonNodes(precision,limitNodeId,comm,commI);
- mcIdType oldNbOfNodes=getNumberOfNodes();
+ mcIdType const oldNbOfNodes=getNumberOfNodes();
MCAuto<DataArrayIdType> ret=buildNewNumberingFromCommonNodesFormat(comm,commI,newNbOfNodes);
areNodesMerged=(oldNbOfNodes!=newNbOfNodes);
comm->decrRef();
*/
DataArrayIdType *MEDCouplingPointSet::getNodeIdsNearPoint(const double *pos, double eps) const
{
- DataArrayIdType *c=0,*cI=0;
+ DataArrayIdType *c=nullptr,*cI=nullptr;
getNodeIdsNearPoints(pos,1,eps,c,cI);
- MCAuto<DataArrayIdType> cITmp(cI);
+ MCAuto<DataArrayIdType> const cITmp(cI);
return c;
}
{
if(!_coords)
throw INTERP_KERNEL::Exception("MEDCouplingPointSet::getNodeIdsNearPoint : no coordiantes set !");
- std::size_t spaceDim=getSpaceDimension();
+ std::size_t const spaceDim=getSpaceDimension();
MCAuto<DataArrayDouble> points=DataArrayDouble::New();
points->useArray(pos,false,DeallocType::CPP_DEALLOC,nbOfPoints,spaceDim);
_coords->computeTupleIdsNearTuples(points,eps,c,cI);
{
DataArrayDouble *newCoords=DataArrayDouble::New();
std::vector<mcIdType> div(newNbOfNodes);
- std::size_t spaceDim=getSpaceDimension();
+ std::size_t const spaceDim=getSpaceDimension();
newCoords->alloc(newNbOfNodes,spaceDim);
newCoords->copyStringInfoFrom(*_coords);
newCoords->fillWithZero();
- mcIdType oldNbOfNodes=getNumberOfNodes();
+ mcIdType const oldNbOfNodes=getNumberOfNodes();
double *ptToFill=newCoords->getPointer();
const double *oldCoordsPtr=_coords->getConstPointer();
for(mcIdType i=0;i<oldNbOfNodes;i++)
if(!_coords)
throw INTERP_KERNEL::Exception("MEDCouplingPointSet::getCaracteristicDimension : Coordinates not set !");
const double *coords=_coords->getConstPointer();
- std::size_t nbOfValues=_coords->getNbOfElems();
+ std::size_t const nbOfValues=_coords->getNbOfElems();
return std::abs(*std::max_element(coords,coords+nbOfValues,MEDCouplingCompAbs()));
}
*/
void MEDCouplingPointSet::rotate(const double *center, const double *vector, double angle)
{
- std::size_t spaceDim=getSpaceDimension();
+ std::size_t const spaceDim=getSpaceDimension();
if(spaceDim==3)
rotate3D(center,vector,angle);
else if(spaceDim==2)
if(!_coords)
throw INTERP_KERNEL::Exception("MEDCouplingPointSet::translate : no coordinates set !");
double *coords=_coords->getPointer();
- mcIdType nbNodes=getNumberOfNodes();
- std::size_t dim=getSpaceDimension();
+ mcIdType const nbNodes=getNumberOfNodes();
+ std::size_t const dim=getSpaceDimension();
for(mcIdType i=0; i<nbNodes; i++)
for(std::size_t idim=0; idim<dim;idim++)
coords[i*dim+idim]+=vector[idim];
if(!_coords)
throw INTERP_KERNEL::Exception("MEDCouplingPointSet::scale : no coordinates set !");
double *coords=_coords->getPointer();
- mcIdType nbNodes=getNumberOfNodes();
- std::size_t dim=getSpaceDimension();
+ mcIdType const nbNodes=getNumberOfNodes();
+ std::size_t const dim=getSpaceDimension();
for(mcIdType i=0;i<nbNodes;i++)
{
std::transform(coords+i*dim,coords+(i+1)*dim,point,coords+i*dim,std::minus<double>());
*/
void MEDCouplingPointSet::changeSpaceDimension(int newSpaceDim, double dftValue)
{
- if(getCoords()==0)
+ if(getCoords()==nullptr)
throw INTERP_KERNEL::Exception("changeSpaceDimension must be called on an MEDCouplingPointSet instance with coordinates set !");
if(newSpaceDim<1)
throw INTERP_KERNEL::Exception("changeSpaceDimension must be called a newSpaceDim >=1 !");
- int oldSpaceDim=getSpaceDimension();
+ int const oldSpaceDim=getSpaceDimension();
if(newSpaceDim==oldSpaceDim)
return ;
DataArrayDouble *newCoords=getCoords()->changeNbOfComponents(newSpaceDim,dftValue);
throw INTERP_KERNEL::Exception("MEDCouplingPointSet::findNodesOnPlane : NULL point pointer specified !");
if(!vec)
throw INTERP_KERNEL::Exception("MEDCouplingPointSet::findNodesOnPlane : NULL vector pointer specified !");
- mcIdType nbOfNodes=getNumberOfNodes();
+ mcIdType const nbOfNodes=getNumberOfNodes();
double a=vec[0],b=vec[1],c=vec[2],d=-pt[0]*vec[0]-pt[1]*vec[1]-pt[2]*vec[2];
- double deno=sqrt(a*a+b*b+c*c);
+ double const deno=sqrt(a*a+b*b+c*c);
if(deno<std::numeric_limits<double>::min())
throw INTERP_KERNEL::Exception("MEDCouplingPointSet::findNodesOnPlane : vector pointer specified has norm equal to 0. !");
const double *work=_coords->getConstPointer();
*/
void MEDCouplingPointSet::findNodesOnLine(const double *pt, const double *vec, double eps, std::vector<mcIdType>& nodes) const
{
- std::size_t spaceDim=getSpaceDimension();
+ std::size_t const spaceDim=getSpaceDimension();
if(spaceDim!=2 && spaceDim!=3)
throw INTERP_KERNEL::Exception("MEDCouplingPointSet::findNodesOnLine : Invalid spacedim to be applied on this ! Must be equal to 2 or 3 !");
if(!pt)
throw INTERP_KERNEL::Exception("MEDCouplingPointSet::findNodesOnLine : NULL point pointer specified !");
if(!vec)
throw INTERP_KERNEL::Exception("MEDCouplingPointSet::findNodesOnLine : NULL vector pointer specified !");
- mcIdType nbOfNodes=getNumberOfNodes();
+ mcIdType const nbOfNodes=getNumberOfNodes();
double den=0.;
for(std::size_t i=0;i<spaceDim;i++)
den+=vec[i]*vec[i];
- double deno=sqrt(den);
+ double const deno=sqrt(den);
if(deno<10.*eps)
throw INTERP_KERNEL::Exception("MEDCouplingPointSet::findNodesOnLine : Invalid given direction vector ! Norm is too small !");
INTERP_KERNEL::AutoPtr<double> vecn=new double[spaceDim];
{
for(mcIdType i=0;i<nbOfNodes;i++)
{
- double a=vecn[0]*(work[1]-pt[1])-vecn[1]*(work[0]-pt[0]);
- double b=vecn[1]*(work[2]-pt[2])-vecn[2]*(work[1]-pt[1]);
- double c=vecn[2]*(work[0]-pt[0])-vecn[0]*(work[2]-pt[2]);
+ double const a=vecn[0]*(work[1]-pt[1])-vecn[1]*(work[0]-pt[0]);
+ double const b=vecn[1]*(work[2]-pt[2])-vecn[2]*(work[1]-pt[1]);
+ double const c=vecn[2]*(work[0]-pt[0])-vecn[0]*(work[2]-pt[2]);
if(std::sqrt(a*a+b*b+c*c)<eps)
nodes.push_back(i);
work+=3;
*/
DataArrayDouble *MEDCouplingPointSet::MergeNodesArray(const MEDCouplingPointSet *m1, const MEDCouplingPointSet *m2)
{
- int spaceDim=m1->getSpaceDimension();
+ int const spaceDim=m1->getSpaceDimension();
if(spaceDim!=m2->getSpaceDimension())
throw INTERP_KERNEL::Exception("Mismatch in SpaceDim during call of MergeNodesArray !");
return DataArrayDouble::Aggregate(m1->getCoords(),m2->getCoords());
{
if(ms.empty())
throw INTERP_KERNEL::Exception("MEDCouplingPointSet::MergeNodesArray : input array must be NON EMPTY !");
- std::vector<const MEDCouplingPointSet *>::const_iterator it=ms.begin();
+ auto it=ms.begin();
std::vector<const DataArrayDouble *> coo(ms.size());
- int spaceDim=(*it)->getSpaceDimension();
+ int const spaceDim=(*it)->getSpaceDimension();
coo[0]=(*it++)->getCoords();
if(!coo[0]->isAllocated())
throw INTERP_KERNEL::Exception("MEDCouplingPointSet::MergeNodesArray : first element in coordinates is not allocated !");
void MEDCouplingPointSet::getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const
{
int it,order;
- double time=getTime(it,order);
+ double const time=getTime(it,order);
if(_coords)
{
int spaceDim=getSpaceDimension();
/*!
* Third and final step of serialization process.
*/
-void MEDCouplingPointSet::serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const
+void MEDCouplingPointSet::serialize(DataArrayIdType *& /*a1*/, DataArrayDouble *&a2) const
{
if(_coords)
{
a2->incrRef();
}
else
- a2=0;
+ a2=nullptr;
}
/*!
* Second step of serialization process.
* @param tinyInfo must be equal to the result given by getTinySerializationInformation method.
*/
-void MEDCouplingPointSet::resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const
+void MEDCouplingPointSet::resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType * /*a1*/, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const
{
if(tinyInfo[2]>=0 && tinyInfo[1]>=1)
{
* Second and final unserialization process.
* @param tinyInfo must be equal to the result given by getTinySerializationInformation method.
*/
-void MEDCouplingPointSet::unserialization(const std::vector<double>& tinyInfoD, const std::vector<mcIdType>& tinyInfo, const DataArrayIdType *a1, DataArrayDouble *a2, const std::vector<std::string>& littleStrings)
+void MEDCouplingPointSet::unserialization(const std::vector<double>& tinyInfoD, const std::vector<mcIdType>& tinyInfo, const DataArrayIdType * /*a1*/, DataArrayDouble *a2, const std::vector<std::string>& littleStrings)
{
if(tinyInfo[2]>=0 && tinyInfo[1]>=1)
{
*/
bool MEDCouplingPointSet::intersectsBoundingBox(const double* bb1, const double* bb2, int dim, double eps)
{
- double* bbtemp = new double[2*dim];
+ auto* bbtemp = new double[2*dim];
double deltamax=0.0;
for (int i=0; i< dim; i++)
{
- double delta = bb1[2*i+1]-bb1[2*i];
+ double const delta = bb1[2*i+1]-bb1[2*i];
if ( delta > deltamax )
{
deltamax = delta ;
for (int idim=0; idim < dim; idim++)
{
- bool intersects = (bbtemp[idim*2]<bb2[idim*2+1])
+ bool const intersects = (bbtemp[idim*2]<bb2[idim*2+1])
&& (bb2[idim*2]<bbtemp[idim*2+1]) ;
if (!intersects)
{
*/
bool MEDCouplingPointSet::intersectsBoundingBox(const INTERP_KERNEL::DirectedBoundingBox& bb1, const double* bb2, int dim, double eps)
{
- double* bbtemp(new double[2*dim]);
+ auto* bbtemp(new double[2*dim]);
double deltamax(0.0);
for (int i=0; i< dim; i++)
{
- double delta = bb2[2*i+1]-bb2[2*i];
+ double const delta = bb2[2*i+1]-bb2[2*i];
if ( delta > deltamax )
{
deltamax = delta ;
bbtemp[i*2+1]=bb2[i*2+1]+deltamax*eps;
}
- bool intersects(!bb1.isDisjointWith(bbtemp));
+ bool const intersects(!bb1.isDisjointWith(bbtemp));
delete [] bbtemp;
return intersects;
}
void MEDCouplingPointSet::rotate3D(const double *center, const double *vect, double angle)
{
double *coords(_coords->getPointer());
- mcIdType nbNodes(getNumberOfNodes());
+ mcIdType const nbNodes(getNumberOfNodes());
DataArrayDouble::Rotate3DAlg(center,vect,angle,nbNodes,coords,coords);
}
*
* \sa MEDCouplingUMesh::buildPartOfMySelfSlice
*/
-MEDCouplingMesh *MEDCouplingPointSet::buildPartRangeAndReduceNodes(mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds, mcIdType& beginOut, mcIdType& endOut, mcIdType& stepOut, DataArrayIdType*& arr) const
+MEDCouplingMesh *MEDCouplingPointSet::buildPartRangeAndReduceNodes(mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds, mcIdType& /*beginOut*/, mcIdType& /*endOut*/, mcIdType& /*stepOut*/, DataArrayIdType*& arr) const
{
MCAuto<MEDCouplingPointSet> ret(buildPartOfMySelfSlice(beginCellIds,endCellIds,stepCellIds,true));
arr=ret->zipCoordsTraducer();
void MEDCouplingPointSet::rotate2D(const double *center, double angle)
{
double *coords(_coords->getPointer());
- mcIdType nbNodes(getNumberOfNodes());
+ mcIdType const nbNodes(getNumberOfNodes());
DataArrayDouble::Rotate2DAlg(center,angle,nbNodes,coords,coords);
}
public:
static const int MY_SPACEDIM=3;
static const int MY_MESHDIM=2;
- typedef mcIdType MyConnType;
+ using MyConnType = mcIdType;
static const INTERP_KERNEL::NumberingPolicy My_numPol=INTERP_KERNEL::ALL_C_MODE;
};
void MEDCouplingPointSet::project2DCellOnXY(const mcIdType *startConn, const mcIdType *endConn, std::vector<double>& res) const
{
const double *coords(_coords->getConstPointer());
- std::size_t spaceDim(getSpaceDimension());
+ std::size_t const spaceDim(getSpaceDimension());
for(const mcIdType *it=startConn;it!=endConn;it++)
res.insert(res.end(),coords+spaceDim*(*it),coords+spaceDim*(*it+1));
if(spaceDim==2)
if(spaceDim==3)
{
std::vector<double> cpy(res);
- mcIdType nbNodes=ToIdType(std::distance(startConn,endConn));
+ mcIdType const nbNodes=ToIdType(std::distance(startConn,endConn));
INTERP_KERNEL::PlanarIntersector<DummyClsMCPS,mcIdType>::Projection(&res[0],&cpy[0],nbNodes,nbNodes,1.e-12,0./*max distance*/,-1./*min dot*/,0.,true);
res.resize(2*nbNodes);
for(mcIdType i=0;i<nbNodes;i++)
*/
bool MEDCouplingPointSet::isButterfly2DCell(const std::vector<double>& res, bool isQuad, double eps)
{
- INTERP_KERNEL::QuadraticPlanarPrecision prec(eps);
+ INTERP_KERNEL::QuadraticPlanarPrecision const prec(eps);
- std::size_t nbOfNodes(res.size()/2);
+ std::size_t const nbOfNodes(res.size()/2);
std::vector<INTERP_KERNEL::Node *> nodes(nbOfNodes);
for(std::size_t i=0;i<nbOfNodes;i++)
{
- INTERP_KERNEL::Node *tmp=new INTERP_KERNEL::Node(res[2*i],res[2*i+1]);
+ auto *tmp=new INTERP_KERNEL::Node(res[2*i],res[2*i+1]);
nodes[i]=tmp;
}
- INTERP_KERNEL::QuadraticPolygon *pol=0;
+ INTERP_KERNEL::QuadraticPolygon *pol=nullptr;
if(isQuad)
pol=INTERP_KERNEL::QuadraticPolygon::BuildArcCirclePolygon(nodes);
else
pol=INTERP_KERNEL::QuadraticPolygon::BuildLinearPolygon(nodes);
- bool ret(pol->isButterflyAbs());
+ bool const ret(pol->isButterflyAbs());
delete pol;
return ret;
}
std::vector<mcIdType> c1,c2;
getNodeIdsOfCell(cellId,c1);
other->getNodeIdsOfCell(cellId,c2);
- std::size_t sz(c1.size());
+ std::size_t const sz(c1.size());
if(sz!=c2.size())
return false;
for(std::size_t i=0;i<sz;i++)
throw INTERP_KERNEL::Exception("MEDCouplingPointSet::tryToShareSameCoordsPermute : No coords specified in other !");
if(!_coords)
throw INTERP_KERNEL::Exception("MEDCouplingPointSet::tryToShareSameCoordsPermute : No coords specified in this whereas there is any in other !");
- mcIdType otherNbOfNodes=other.getNumberOfNodes();
+ mcIdType const otherNbOfNodes=other.getNumberOfNodes();
MCAuto<DataArrayDouble> newCoords=MergeNodesArray(&other,this);
_coords->incrRef();
MCAuto<DataArrayDouble> oldCoords=_coords;
setCoords(oldCoords);
throw INTERP_KERNEL::Exception("MEDCouplingPointSet::tryToShareSameCoordsPermute fails : no nodes are mergeable with specified given epsilon !");
}
- mcIdType maxId=*std::max_element(da->getConstPointer(),da->getConstPointer()+otherNbOfNodes);
+ mcIdType const maxId=*std::max_element(da->getConstPointer(),da->getConstPointer()+otherNbOfNodes);
const mcIdType *pt=std::find_if(da->getConstPointer()+otherNbOfNodes,da->getConstPointer()+da->getNbOfElems(),std::bind(std::greater<mcIdType>(),std::placeholders::_1,maxId));
if(pt!=da->getConstPointer()+da->getNbOfElems())
{
*/
MEDCouplingPointSet *MEDCouplingPointSet::buildPartOfMySelfNode(const mcIdType *begin, const mcIdType *end, bool fullyIn) const
{
- DataArrayIdType *cellIdsKept=0;
+ DataArrayIdType *cellIdsKept=nullptr;
fillCellIdsToKeepFromNodeIds(begin,end,fullyIn,cellIdsKept);
- MCAuto<DataArrayIdType> cellIdsKept2(cellIdsKept);
+ MCAuto<DataArrayIdType> const cellIdsKept2(cellIdsKept);
return buildPartOfMySelf(cellIdsKept->begin(),cellIdsKept->end(),true);
}
bool MEDCouplingPointSet::areAllNodesFetched() const
{
checkFullyDefined();
- mcIdType nbNodes(getNumberOfNodes());
+ mcIdType const nbNodes(getNumberOfNodes());
std::vector<bool> fetchedNodes(nbNodes,false);
computeNodeIdsAlg(fetchedNodes);
return std::find(fetchedNodes.begin(),fetchedNodes.end(),false)==fetchedNodes.end();
{
if(!other)
throw INTERP_KERNEL::Exception("MEDCouplingPointSet::checkDeepEquivalWith : input is null !");
- const MEDCouplingPointSet *otherC=dynamic_cast<const MEDCouplingPointSet *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingPointSet *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("MEDCouplingPointSet::checkDeepEquivalWith : other is not a PointSet mesh !");
MCAuto<MEDCouplingPointSet> m=dynamic_cast<MEDCouplingPointSet *>(mergeMyselfWith(otherC));
bool areNodesMerged;
mcIdType newNbOfNodes;
- mcIdType oldNbOfNodes=getNumberOfNodes();
+ mcIdType const oldNbOfNodes=getNumberOfNodes();
MCAuto<DataArrayIdType> da=m->buildPermArrayForMergeNode(prec,oldNbOfNodes,areNodesMerged,newNbOfNodes);
//mergeNodes
if(!areNodesMerged && oldNbOfNodes != 0)
da=m->mergeNodes(prec,areNodesMerged,newNbOfNodes);
//
da=m->zipConnectivityTraducer(cellCompPol);
- mcIdType nbCells=ToIdType(getNumberOfCells());
+ mcIdType const nbCells=ToIdType(getNumberOfCells());
if (nbCells != ToIdType(other->getNumberOfCells()))
throw INTERP_KERNEL::Exception("checkDeepEquivalWith : some cells in other are not in this !");
- mcIdType dan(da->getNumberOfTuples());
+ mcIdType const dan(da->getNumberOfTuples());
if (dan)
{
MCAuto<DataArrayIdType> da1(DataArrayIdType::New()),da2(DataArrayIdType::New());
throw INTERP_KERNEL::Exception("checkDeepEquivalWith : some cells in other are not in this !");
}
MCAuto<DataArrayIdType> cellCor2=da->selectByTupleIdSafeSlice(nbCells,ToIdType(da->getNbOfElems()),1);
- nodeCor=nodeCor2->isIota(nodeCor2->getNumberOfTuples())?0:nodeCor2.retn();
- cellCor=cellCor2->isIota(cellCor2->getNumberOfTuples())?0:cellCor2.retn();
+ nodeCor=nodeCor2->isIota(nodeCor2->getNumberOfTuples())?nullptr:nodeCor2.retn();
+ cellCor=cellCor2->isIota(cellCor2->getNumberOfTuples())?nullptr:cellCor2.retn();
}
/*!
* \ref py_mcumesh_checkDeepEquivalWith "Here is a Python example".
* \endif
*/
-void MEDCouplingPointSet::checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
+void MEDCouplingPointSet::checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *other, int cellCompPol, double /*prec*/,
DataArrayIdType *&cellCor) const
{
if(!other)
throw INTERP_KERNEL::Exception("MEDCouplingPointSet::checkDeepEquivalOnSameNodesWith : input is null !");
- const MEDCouplingPointSet *otherC=dynamic_cast<const MEDCouplingPointSet *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingPointSet *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("MEDCouplingPointSet::checkDeepEquivalOnSameNodesWith : other is not a PointSet mesh !");
if(_coords!=otherC->_coords)
throw INTERP_KERNEL::Exception("checkDeepEquivalOnSameNodesWith : meshes do not share the same coordinates ! Use tryToShareSameCoordinates or call checkDeepEquivalWith !");
MCAuto<MEDCouplingPointSet> m=mergeMyselfWithOnSameCoords(otherC);
MCAuto<DataArrayIdType> da=m->zipConnectivityTraducer(cellCompPol);
- mcIdType maxId=*std::max_element(da->getConstPointer(),da->getConstPointer()+getNumberOfCells());
+ mcIdType const maxId=*std::max_element(da->getConstPointer(),da->getConstPointer()+getNumberOfCells());
const mcIdType *pt=std::find_if(da->getConstPointer()+getNumberOfCells(),da->getConstPointer()+da->getNbOfElems(),std::bind(std::greater<mcIdType>(),std::placeholders::_1,maxId));
if(pt!=da->getConstPointer()+da->getNbOfElems())
{
throw INTERP_KERNEL::Exception("checkDeepEquivalOnSameNodesWith : some cells in other are not in this !");
}
MCAuto<DataArrayIdType> cellCor2=da->selectByTupleIdSafeSlice(ToIdType(getNumberOfCells()),ToIdType(da->getNbOfElems()),1);
- cellCor=cellCor2->isIota(cellCor2->getNumberOfTuples())?0:cellCor2.retn();
+ cellCor=cellCor2->isIota(cellCor2->getNumberOfTuples())?nullptr:cellCor2.retn();
}
void MEDCouplingPointSet::checkFastEquivalWith(const MEDCouplingMesh *other, double prec) const
{
MEDCouplingMesh::checkFastEquivalWith(other,prec);
//other not null checked by the line before
- const MEDCouplingPointSet *otherC=dynamic_cast<const MEDCouplingPointSet *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingPointSet *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("MEDCouplingPointSet::checkFastEquivalWith : fails because other is not a pointset mesh !");
- mcIdType nbOfCells=ToIdType(getNumberOfCells());
+ mcIdType const nbOfCells=ToIdType(getNumberOfCells());
if(nbOfCells<1)
return ;
bool status=true;
*/
DataArrayIdType *MEDCouplingPointSet::getCellIdsLyingOnNodes(const mcIdType *begin, const mcIdType *end, bool fullyIn) const
{
- DataArrayIdType *cellIdsKept=0;
+ DataArrayIdType *cellIdsKept=nullptr;
fillCellIdsToKeepFromNodeIds(begin,end,fullyIn,cellIdsKept);
cellIdsKept->setName(getName());
return cellIdsKept;
#ifndef __PARAMEDMEM_MEDCOUPLINGPOINTSET_HXX__
#define __PARAMEDMEM_MEDCOUPLINGPOINTSET_HXX__
+#include "MCType.hxx"
#include "MEDCoupling.hxx"
#include "MEDCouplingMesh.hxx"
#include "InterpKernelHashMap.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include <cstddef>
+#include <string>
+#include <map>
#include <vector>
namespace INTERP_KERNEL
protected:
MEDCOUPLING_EXPORT MEDCouplingPointSet();
MEDCOUPLING_EXPORT MEDCouplingPointSet(const MEDCouplingPointSet& other, bool deepCpy);
- MEDCOUPLING_EXPORT ~MEDCouplingPointSet();
+ MEDCOUPLING_EXPORT ~MEDCouplingPointSet() override;
public:
- MEDCOUPLING_EXPORT void updateTime() const;
- MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfNodes() const;
- MEDCOUPLING_EXPORT int getSpaceDimension() const;
+ MEDCOUPLING_EXPORT void updateTime() const override;
+ MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfNodes() const override;
+ MEDCOUPLING_EXPORT int getSpaceDimension() const override;
MEDCOUPLING_EXPORT void setCoords(const DataArrayDouble *coords);
MEDCOUPLING_EXPORT const DataArrayDouble *getCoords() const { return _coords; }
MEDCOUPLING_EXPORT DataArrayDouble *getCoords() { return _coords; }
- MEDCOUPLING_EXPORT DataArrayDouble *getCoordinatesAndOwner() const;
- MEDCOUPLING_EXPORT const DataArrayDouble *getDirectAccessOfCoordsArrIfInStructure() const { return _coords; }
- MEDCOUPLING_EXPORT void copyTinyStringsFrom(const MEDCouplingMesh *other);
- MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const;
- MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const;
- MEDCOUPLING_EXPORT void checkFastEquivalWith(const MEDCouplingMesh *other, double prec) const;
+ MEDCOUPLING_EXPORT DataArrayDouble *getCoordinatesAndOwner() const override;
+ MEDCOUPLING_EXPORT const DataArrayDouble *getDirectAccessOfCoordsArrIfInStructure() const override { return _coords; }
+ MEDCOUPLING_EXPORT void copyTinyStringsFrom(const MEDCouplingMesh *other) override;
+ MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const override;
+ MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const override;
+ MEDCOUPLING_EXPORT void checkFastEquivalWith(const MEDCouplingMesh *other, double prec) const override;
MEDCOUPLING_EXPORT void checkDeepEquivalWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
- DataArrayIdType *&cellCor, DataArrayIdType *&nodeCor) const;
+ DataArrayIdType *&cellCor, DataArrayIdType *&nodeCor) const override;
MEDCOUPLING_EXPORT void checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
- DataArrayIdType *&cellCor) const;
+ DataArrayIdType *&cellCor) const override;
MEDCOUPLING_EXPORT bool areCoordsEqualIfNotWhy(const MEDCouplingPointSet& other, double prec, std::string& reason) const;
MEDCOUPLING_EXPORT bool areCoordsEqual(const MEDCouplingPointSet& other, double prec) const;
MEDCOUPLING_EXPORT bool areCoordsEqualWithoutConsideringStr(const MEDCouplingPointSet& other, double prec) const;
MEDCOUPLING_EXPORT virtual DataArrayIdType *mergeNodesCenter(double precision, bool& areNodesMerged, mcIdType& newNbOfNodes);
MEDCOUPLING_EXPORT virtual MEDCouplingPointSet *mergeMyselfWithOnSameCoords(const MEDCouplingPointSet *other) const = 0;
MEDCOUPLING_EXPORT virtual void computeNodeIdsAlg(std::vector<bool>& nodeIdsInUse) const = 0;
- MEDCOUPLING_EXPORT void getCoordinatesOfNode(mcIdType nodeId, std::vector<double>& coo) const;
+ MEDCOUPLING_EXPORT void getCoordinatesOfNode(mcIdType nodeId, std::vector<double>& coo) const override;
MEDCOUPLING_EXPORT DataArrayIdType *buildPermArrayForMergeNode(double precision, mcIdType limitNodeId, bool& areNodesMerged, mcIdType& newNbOfNodes) const;
MEDCOUPLING_EXPORT DataArrayIdType *getNodeIdsNearPoint(const double *pos, double eps) const;
MEDCOUPLING_EXPORT void getNodeIdsNearPoints(const double *pos, mcIdType nbOfPoints, double eps, DataArrayIdType *& c, DataArrayIdType *& cI) const;
MEDCOUPLING_EXPORT virtual void findCommonCells(int compType, mcIdType startCellId, DataArrayIdType *& commonCellsArr, DataArrayIdType *& commonCellsIArr) const = 0;
MEDCOUPLING_EXPORT DataArrayIdType *buildNewNumberingFromCommonNodesFormat(const DataArrayIdType *comm, const DataArrayIdType *commIndex,
mcIdType& newNbOfNodes) const;
- MEDCOUPLING_EXPORT void getBoundingBox(double *bbox) const;
+ MEDCOUPLING_EXPORT void getBoundingBox(double *bbox) const override;
MEDCOUPLING_EXPORT void zipCoords();
MEDCOUPLING_EXPORT double getCaracteristicDimension() const;
MEDCOUPLING_EXPORT void recenterForMaxPrecision(double eps);
- MEDCOUPLING_EXPORT void rotate(const double *center, const double *vector, double angle);
- MEDCOUPLING_EXPORT void translate(const double *vector);
- MEDCOUPLING_EXPORT void scale(const double *point, double factor);
+ MEDCOUPLING_EXPORT void rotate(const double *center, const double *vector, double angle) override;
+ MEDCOUPLING_EXPORT void translate(const double *vector) override;
+ MEDCOUPLING_EXPORT void scale(const double *point, double factor) override;
MEDCOUPLING_EXPORT void changeSpaceDimension(int newSpaceDim, double dftVal=0.);
MEDCOUPLING_EXPORT void tryToShareSameCoords(const MEDCouplingPointSet& other, double epsilon);
MEDCOUPLING_EXPORT void duplicateNodesInCoords(const mcIdType *nodeIdsToDuplicateBg, const mcIdType *nodeIdsToDuplicateEnd);
MEDCOUPLING_EXPORT static DataArrayDouble *MergeNodesArray(const std::vector<const MEDCouplingPointSet *>& ms);
MEDCOUPLING_EXPORT static MEDCouplingPointSet *BuildInstanceFromMeshType(MEDCouplingMeshType type);
MEDCOUPLING_EXPORT static DataArrayIdType *ComputeNbOfInteractionsWithSrcCells(const MEDCouplingPointSet *srcMesh, const MEDCouplingPointSet *trgMesh, double eps);
- MEDCOUPLING_EXPORT MEDCouplingMesh *buildPart(const mcIdType *start, const mcIdType *end) const;
- MEDCOUPLING_EXPORT MEDCouplingMesh *buildPartAndReduceNodes(const mcIdType *start, const mcIdType *end, DataArrayIdType*& arr) const;
- MEDCOUPLING_EXPORT MEDCouplingMesh *buildPartRange(mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds) const;
- MEDCOUPLING_EXPORT MEDCouplingMesh *buildPartRangeAndReduceNodes(mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds, mcIdType& beginOut, mcIdType& endOut, mcIdType& stepOut, DataArrayIdType*& arr) const;
- MEDCOUPLING_EXPORT DataArrayIdType *getCellIdsFullyIncludedInNodeIds(const mcIdType *partBg, const mcIdType *partEnd) const;
+ MEDCOUPLING_EXPORT MEDCouplingMesh *buildPart(const mcIdType *start, const mcIdType *end) const override;
+ MEDCOUPLING_EXPORT MEDCouplingMesh *buildPartAndReduceNodes(const mcIdType *start, const mcIdType *end, DataArrayIdType*& arr) const override;
+ MEDCOUPLING_EXPORT MEDCouplingMesh *buildPartRange(mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds) const override;
+ MEDCOUPLING_EXPORT MEDCouplingMesh *buildPartRangeAndReduceNodes(mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds, mcIdType& beginOut, mcIdType& endOut, mcIdType& stepOut, DataArrayIdType*& arr) const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *getCellIdsFullyIncludedInNodeIds(const mcIdType *partBg, const mcIdType *partEnd) const override;
MEDCOUPLING_EXPORT DataArrayIdType *getCellIdsLyingOnNodes(const mcIdType *begin, const mcIdType *end, bool fullyIn) const;
MEDCOUPLING_EXPORT virtual MEDCouplingPointSet *buildPartOfMySelf(const mcIdType *start, const mcIdType *end, bool keepCoords=true) const;
MEDCOUPLING_EXPORT virtual MEDCouplingPointSet *buildPartOfMySelfSlice(mcIdType start, mcIdType end, mcIdType step, bool keepCoords=true) const;
MEDCOUPLING_EXPORT virtual bool isEmptyMesh(const std::vector<mcIdType>& tinyInfo) const = 0;
MEDCOUPLING_EXPORT virtual void invertOrientationOfAllCells() = 0;
MEDCOUPLING_EXPORT virtual void checkFullyDefined() const = 0;
- MEDCOUPLING_EXPORT void getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const;
- MEDCOUPLING_EXPORT void resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const;
- MEDCOUPLING_EXPORT void serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const;
+ MEDCOUPLING_EXPORT void getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const override;
+ MEDCOUPLING_EXPORT void resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const override;
+ MEDCOUPLING_EXPORT void serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const override;
MEDCOUPLING_EXPORT void unserialization(const std::vector<double>& tinyInfoD, const std::vector<mcIdType>& tinyInfo, const DataArrayIdType *a1, DataArrayDouble *a2,
- const std::vector<std::string>& littleStrings);
+ const std::vector<std::string>& littleStrings) override;
MEDCOUPLING_EXPORT virtual DataArrayDouble *getBoundingBoxForBBTree(double arcDetEps=1e-12) const = 0;
MEDCOUPLING_EXPORT virtual DataArrayIdType *getCellsInBoundingBox(const double *bbox, double eps) const = 0;
MEDCOUPLING_EXPORT virtual DataArrayIdType *getCellsInBoundingBox(const INTERP_KERNEL::DirectedBoundingBox& bbox, double eps) = 0;
public:
MEDCOUPLING_EXPORT bool areCellsFrom2MeshEqual(const MEDCouplingPointSet *other, mcIdType cellId, double prec) const;
protected:
- MEDCOUPLING_EXPORT void checkConsistencyLight() const;
+ MEDCOUPLING_EXPORT void checkConsistencyLight() const override;
MEDCOUPLING_EXPORT static bool intersectsBoundingBox(const double* bb1, const double* bb2, int dim, double eps);
MEDCOUPLING_EXPORT static bool intersectsBoundingBox(const INTERP_KERNEL::DirectedBoundingBox& bb1, const double* bb2, int dim, double eps);
MEDCOUPLING_EXPORT void rotate2D(const double *center, double angle);
#include "InterpKernelException.hxx"
+#include <cstddef>
+#include <set>
+#include <ostream>
+#include <ios>
+#include <map>
#include <sstream>
#include <algorithm>
+#include <string>
+#include <vector>
using namespace MEDCoupling;
-GlobalDict *GlobalDict::UNIQUE_INSTANCE=0;
+GlobalDict *GlobalDict::UNIQUE_INSTANCE=nullptr;
const char *MEDCoupling::MEDCouplingVersionStr()
{
void MEDCoupling::MEDCouplingVersionMajMinRel(int& maj, int& minor, int& releas)
{
- int ver=MEDCOUPLING_VERSION;
+ int const ver=MEDCOUPLING_VERSION;
maj=(ver & 0xFF0000) >> 16;
minor=(ver & 0xFF00) >> 8;
releas=(ver & 0xFF);
bool MEDCoupling::MEDCouplingByteOrder()
{
unsigned int x(1);
- unsigned char *xc(reinterpret_cast<unsigned char *>(&x));
+ auto *xc(reinterpret_cast<unsigned char *>(&x));
return xc[0]==1;
}
ret = it->getHeapMemorySizeWithoutChildren(); sum+=ret;
oss << it->getClassName() << " -> " << ret << std::endl;
s1.insert(it);
- std::vector<const BigMemoryObject *> v2(it->getDirectChildren());
+ std::vector<const BigMemoryObject *> const v2(it->getDirectChildren());
for(auto it2 : v2)
if(s1.find(it2)==s1.end())
s3.push_back(it2);
std::size_t BigMemoryObject::getHeapMemorySize() const
{
- std::size_t ret(getHeapMemorySizeWithoutChildren());
+ std::size_t const ret(getHeapMemorySizeWithoutChildren());
std::vector<const BigMemoryObject *> v(getDirectChildren());
std::set<const BigMemoryObject *> s1,s2(v.begin(),v.end());
return ret+GetHeapMemoryOfSet(s1,s2);
{
ret.insert(ret.end(),s1.begin(),s1.end());
std::vector<const BigMemoryObject *> s3;
- for(std::vector<const BigMemoryObject *>::const_iterator it0=s1.begin();it0!=s1.end();it0++)
+ for(auto it0 : s1)
{
std::vector<const BigMemoryObject *> s2;
- if(*it0)
- s2=(*it0)->getDirectChildren();
- for(std::vector<const BigMemoryObject *>::const_iterator it1=s2.begin();it1!=s2.end();it1++)
+ if(it0)
+ s2=it0->getDirectChildren();
+ for(auto it1 : s2)
{
- if(*it1)
- if(std::find(ret.begin(),ret.end(),*it1)==ret.end())
- s3.push_back(*it1);
+ if(it1)
+ if(std::find(ret.begin(),ret.end(),it1)==ret.end())
+ s3.push_back(it1);
}
}
s1=s3;
{
std::size_t ret(0);
std::set<const BigMemoryObject *> s1,s2;
- for(std::vector<const BigMemoryObject *>::const_iterator it0=objs.begin();it0!=objs.end();it0++)
+ for(auto obj : objs)
{
- if(*it0)
- if(s1.find(*it0)==s1.end())
+ if(obj)
+ if(s1.find(obj)==s1.end())
{
- std::vector<const BigMemoryObject *> vTmp((*it0)->getDirectChildren());
+ std::vector<const BigMemoryObject *> vTmp(obj->getDirectChildren());
s2.insert(vTmp.begin(),vTmp.end());
- ret+=(*it0)->getHeapMemorySizeWithoutChildren();
- s1.insert(*it0);
+ ret+=obj->getHeapMemorySizeWithoutChildren();
+ s1.insert(obj);
}
}
return ret+GetHeapMemoryOfSet(s1,s2);
while(!s2.empty())
{
std::set<const BigMemoryObject *> s3;
- for(std::set<const BigMemoryObject *>::const_iterator it=s2.begin();it!=s2.end();it++)
+ for(auto it : s2)
{
- if(s1.find(*it)==s1.end())
+ if(s1.find(it)==s1.end())
{
- ret+=(*it)->getHeapMemorySizeWithoutChildren();
- s1.insert(*it);
- std::vector<const BigMemoryObject *> v2((*it)->getDirectChildren());
- for(std::vector<const BigMemoryObject *>::const_iterator it2=v2.begin();it2!=v2.end();it2++)
- if(s1.find(*it2)==s1.end())
- s3.insert(*it2);
+ ret+=it->getHeapMemorySizeWithoutChildren();
+ s1.insert(it);
+ std::vector<const BigMemoryObject *> const v2(it->getDirectChildren());
+ for(auto it2 : v2)
+ if(s1.find(it2)==s1.end())
+ s3.insert(it2);
}
}
s2=s3;
std::ostringstream oss2; oss2 << std::fixed << ((double)remain)/1024.;
std::string s(oss2.str());
s=s.substr(1,4);
- std::size_t pos(s.find_last_not_of('0'));
+ std::size_t const pos(s.find_last_not_of('0'));
if(pos==4)
oss << s;
else
std::vector<const BigMemoryObject *> BigMemoryObject::getDirectChildren() const
{
std::vector<const BigMemoryObject *> ret;
- std::vector<const BigMemoryObject *> retWithNull(getDirectChildrenWithNull());
- for(std::vector<const BigMemoryObject *>::const_iterator it=retWithNull.begin();it!=retWithNull.end();it++)
- if(*it)
- ret.push_back(*it);
+ std::vector<const BigMemoryObject *> const retWithNull(getDirectChildrenWithNull());
+ for(auto it : retWithNull)
+ if(it)
+ ret.push_back(it);
return ret;
}
BigMemoryObject::~BigMemoryObject()
-{
-}
+= default;
//=
{
}
-RefCountObjectOnly::RefCountObjectOnly(const RefCountObjectOnly& other):_cnt(1)
+RefCountObjectOnly::RefCountObjectOnly(const RefCountObjectOnly& /*other*/):_cnt(1)
{
}
bool RefCountObjectOnly::decrRef() const
{
- bool ret=((--_cnt)==0);
+ bool const ret=((--_cnt)==0);
if(ret)
delete this;
return ret;
}
RefCountObjectOnly::~RefCountObjectOnly()
-{
-}
+= default;
/*!
* Do nothing here ! It is not a bug ( I hope :) ) because all subclasses that
* copies using operator= should not copy the ref counter of \a other !
*/
-RefCountObjectOnly& RefCountObjectOnly::operator=(const RefCountObjectOnly& other)
+RefCountObjectOnly& RefCountObjectOnly::operator=(const RefCountObjectOnly& /*other*/)
{
return *this;
}
//=
RefCountObject::RefCountObject()
-{
-}
+= default;
RefCountObject::RefCountObject(const RefCountObject& other):RefCountObjectOnly(other)
{
}
RefCountObject::~RefCountObject()
-{
-}
+= default;
//=
bool GlobalDict::hasKey(const std::string& key) const
{
- std::map<std::string, std::string>::const_iterator it(_my_map.find(key));
+ auto const it(_my_map.find(key));
return it!=_my_map.end();
}
std::string GlobalDict::value(const std::string& key) const
{
- std::map<std::string, std::string>::const_iterator it(_my_map.find(key));
+ auto const it(_my_map.find(key));
if(it==_my_map.end())
{
std::ostringstream oss;
std::vector<std::string> GlobalDict::keys() const
{
std::vector<std::string> ret;
- for(std::map<std::string, std::string>::const_iterator it=_my_map.begin();it!=_my_map.end();it++)
- ret.push_back((*it).first);
+ for(const auto & it : _my_map)
+ ret.push_back(it.first);
return ret;
}
void GlobalDict::erase(const std::string& key)
{
- std::map<std::string, std::string>::iterator it(_my_map.find(key));
+ auto const it(_my_map.find(key));
if(it==_my_map.end())
{
std::ostringstream oss;
void GlobalDict::setKeyValue(const std::string& key, const std::string& val)
{
- std::map<std::string, std::string>::const_iterator it(_my_map.find(key));
+ std::map<std::string, std::string>::const_iterator const it(_my_map.find(key));
if(it!=_my_map.end())
{
std::ostringstream oss;
std::string GlobalDict::printSelf() const
{
std::ostringstream oss;
- for(std::map<std::string, std::string>::const_iterator it=_my_map.begin();it!=_my_map.end();it++)
+ for(const auto & it : _my_map)
{
- oss << "(" << (*it).first << "," << (*it).second << ")" << std::endl;
+ oss << "(" << it.first << "," << it.second << ")" << std::endl;
}
return oss.str();
}
protected:
RefCountObject();
RefCountObject(const RefCountObject& other);
- virtual ~RefCountObject();
+ ~RefCountObject() override;
};
class MEDCOUPLING_EXPORT GlobalDict
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingRemapper.hxx"
+#include "Interpolation.txx"
+#include "MCAuto.hxx"
+#include "InterpolationOptions.hxx"
+#include "MCType.hxx"
+#include "Interpolation1D.hxx"
+#include "Interpolation2D.hxx"
+#include "Interpolation3D.hxx"
+#include "Interpolation3D1D.hxx"
+#include "Interpolation1D0D.hxx"
+#include "Interpolation2D1D.hxx"
+#include "Interpolation2D3D.hxx"
+#include "InterpolationCU.hxx"
+#include "InterpolationCC.hxx"
+#include "InterpKernelException.hxx"
+#include "MEDCouplingGaussLocalization.hxx"
+#include "MCIdType.hxx"
#include "MEDCouplingMemArray.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "MEDCouplingFieldTemplate.hxx"
#include "MEDCouplingFieldDiscretization.hxx"
#include "MEDCouplingMappedExtrudedMesh.hxx"
#include "MEDCouplingCMesh.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
#include "MEDCouplingNormalizedUnstructuredMesh.txx"
+#include "MEDCouplingNormalizedCartesianMesh.hxx"
#include "MEDCouplingNormalizedCartesianMesh.txx"
#include "MEDCouplingFieldDiscretizationOnNodesFE.hxx"
+#include "MEDCouplingUMesh.hxx"
-#include "Interpolation1D.txx"
#include "Interpolation2DCurve.hxx"
-#include "Interpolation2D.txx"
#include "Interpolation3D.txx"
#include "Interpolation3DSurf.hxx"
#include "Interpolation2D1D.txx"
#include "Interpolation1D0D.txx"
#include "InterpolationCU.txx"
#include "InterpolationCC.txx"
+#include <string>
+#include <sstream>
+#include <limits>
+#include <cstddef>
+#include "MEDCouplingPointSet.hxx"
+#include <functional>
+#include <iostream>
+#include <numeric>
using namespace MEDCoupling;
-MEDCouplingRemapper::MEDCouplingRemapper():_src_ft(0),_target_ft(0),_interp_matrix_pol(IK_ONLY_PREFERED),_nature_of_deno(NoNature),_time_deno_update(0)
+MEDCouplingRemapper::MEDCouplingRemapper():_src_ft(nullptr),_target_ft(nullptr),_interp_matrix_pol(IK_ONLY_PREFERED),_nature_of_deno(NoNature),_time_deno_update(0)
{
}
int MEDCouplingRemapper::prepareInterpKernelOnly()
{
- int meshInterpType=((int)_src_ft->getMesh()->getType()*16)+(int)_target_ft->getMesh()->getType();
+ int const meshInterpType=((int)_src_ft->getMesh()->getType()*16)+(int)_target_ft->getMesh()->getType();
// *** Remember:
// typedef enum
// {
int MEDCouplingRemapper::prepareInterpKernelOnlyUU()
{
- const MEDCouplingPointSet *src_mesh=static_cast<const MEDCouplingPointSet *>(_src_ft->getMesh());
- const MEDCouplingPointSet *target_mesh=static_cast<const MEDCouplingPointSet *>(_target_ft->getMesh());
+ const auto *src_mesh=static_cast<const MEDCouplingPointSet *>(_src_ft->getMesh());
+ const auto *target_mesh=static_cast<const MEDCouplingPointSet *>(_target_ft->getMesh());
std::string srcMeth,trgMeth;
std::string method(checkAndGiveInterpolationMethodStr(srcMeth,trgMeth));
const int srcMeshDim=src_mesh->getMeshDimension();
nbCols=interpolation.interpolateMeshes(target_mesh_wrapper,source_mesh_wrapper,matrixTmp,revMethod);
ReverseMatrix(matrixTmp,nbCols,_matrix);
nbCols=ToIdType(matrixTmp.size());
- INTERP_KERNEL::Interpolation2D1D::DuplicateFacesType duplicateFaces=interpolation.retrieveDuplicateFaces();
+ INTERP_KERNEL::Interpolation2D1D::DuplicateFacesType const duplicateFaces=interpolation.retrieveDuplicateFaces();
if(!duplicateFaces.empty())
{
std::ostringstream oss; oss << "An unexpected situation happened ! For the following 1D Cells are part of edges shared by 2D cells :\n";
MEDCouplingNormalizedUnstructuredMesh<2,2> target_mesh_wrapper(target_mesh);
INTERP_KERNEL::Interpolation2D1D interpolation(*this);
nbCols=interpolation.interpolateMeshes(source_mesh_wrapper,target_mesh_wrapper,_matrix,method);
- INTERP_KERNEL::Interpolation2D1D::DuplicateFacesType duplicateFaces=interpolation.retrieveDuplicateFaces();
+ INTERP_KERNEL::Interpolation2D1D::DuplicateFacesType const duplicateFaces=interpolation.retrieveDuplicateFaces();
if(!duplicateFaces.empty())
{
std::ostringstream oss; oss << "An unexpected situation happened ! For the following 1D Cells are part of edges shared by 2D cells :\n";
MEDCouplingNormalizedUnstructuredMesh<3,3> target_mesh_wrapper(target_mesh);
INTERP_KERNEL::Interpolation2D3D interpolation(*this);
nbCols=interpolation.interpolateMeshes(source_mesh_wrapper,target_mesh_wrapper,_matrix,method);
- INTERP_KERNEL::Interpolation2D3D::DuplicateFacesType duplicateFaces=interpolation.retrieveDuplicateFaces();
+ INTERP_KERNEL::Interpolation2D3D::DuplicateFacesType const duplicateFaces=interpolation.retrieveDuplicateFaces();
if(!duplicateFaces.empty())
{
std::ostringstream oss; oss << "An unexpected situation happened ! For the following 2D Cells are part of edges shared by 3D cells :\n";
nbCols=interpolation.interpolateMeshes(target_mesh_wrapper,source_mesh_wrapper,matrixTmp,revMethod);
ReverseMatrix(matrixTmp,nbCols,_matrix);
nbCols=ToIdType(matrixTmp.size());
- INTERP_KERNEL::Interpolation2D3D::DuplicateFacesType duplicateFaces=interpolation.retrieveDuplicateFaces();
+ INTERP_KERNEL::Interpolation2D3D::DuplicateFacesType const duplicateFaces=interpolation.retrieveDuplicateFaces();
if(!duplicateFaces.empty())
{
std::ostringstream oss; oss << "An unexpected situation happened ! For the following 2D Cells are part of edges shared by 3D cells :\n";
{
std::string srcMeth,trgMeth;
std::string methC=checkAndGiveInterpolationMethodStr(srcMeth,trgMeth);
- const MEDCouplingMappedExtrudedMesh *src_mesh=static_cast<const MEDCouplingMappedExtrudedMesh *>(_src_ft->getMesh());
- const MEDCouplingMappedExtrudedMesh *target_mesh=static_cast<const MEDCouplingMappedExtrudedMesh *>(_target_ft->getMesh());
+ const auto *src_mesh=static_cast<const MEDCouplingMappedExtrudedMesh *>(_src_ft->getMesh());
+ const auto *target_mesh=static_cast<const MEDCouplingMappedExtrudedMesh *>(_target_ft->getMesh());
if(methC!="P0P0")
throw INTERP_KERNEL::Exception("MEDCouplingRemapper::prepareInterpKernelOnlyEE : Only P0P0 method implemented for Extruded/Extruded meshes !");
MCAuto<MEDCouplingUMesh> src2D(src_mesh->getMesh2D()->clone(false)); src2D->changeSpaceDimension(2,0.);
int MEDCouplingRemapper::prepareInterpKernelOnlyUC()
{
std::string srcMeth,trgMeth;
- std::string methodCpp=checkAndGiveInterpolationMethodStr(srcMeth,trgMeth);
+ std::string const methodCpp=checkAndGiveInterpolationMethodStr(srcMeth,trgMeth);
if(methodCpp!="P0P0")
throw INTERP_KERNEL::Exception("MEDCouplingRemapper::prepareInterpKernelOnlyUC: only P0P0 interpolation supported for the moment !");
if(InterpolationOptions::getIntersectionType()!=INTERP_KERNEL::Triangulation)
throw INTERP_KERNEL::Exception("MEDCouplingRemapper::prepareInterpKernelOnlyUC: only 'Triangulation' intersection type supported!");
- const MEDCouplingUMesh *src_mesh=static_cast<const MEDCouplingUMesh *>(_src_ft->getMesh());
- const MEDCouplingCMesh *target_mesh=static_cast<const MEDCouplingCMesh *>(_target_ft->getMesh());
+ const auto *src_mesh=static_cast<const MEDCouplingUMesh *>(_src_ft->getMesh());
+ const auto *target_mesh=static_cast<const MEDCouplingCMesh *>(_target_ft->getMesh());
const int srcMeshDim=src_mesh->getMeshDimension();
const int srcSpceDim=src_mesh->getSpaceDimension();
const int trgMeshDim=target_mesh->getMeshDimension();
int MEDCouplingRemapper::prepareInterpKernelOnlyCU()
{
std::string srcMeth,trgMeth;
- std::string methodCpp=checkAndGiveInterpolationMethodStr(srcMeth,trgMeth);
+ std::string const methodCpp=checkAndGiveInterpolationMethodStr(srcMeth,trgMeth);
if(methodCpp!="P0P0")
throw INTERP_KERNEL::Exception("MEDCouplingRemapper::prepareInterpKernelOnlyCU : only P0P0 interpolation supported for the moment !");
if(InterpolationOptions::getIntersectionType()!=INTERP_KERNEL::Triangulation)
throw INTERP_KERNEL::Exception("MEDCouplingRemapper::prepareInterpKernelOnlyCU: only 'Triangulation' intersection type supported!");
- const MEDCouplingCMesh *src_mesh=static_cast<const MEDCouplingCMesh *>(_src_ft->getMesh());
- const MEDCouplingUMesh *target_mesh=static_cast<const MEDCouplingUMesh *>(_target_ft->getMesh());
+ const auto *src_mesh=static_cast<const MEDCouplingCMesh *>(_src_ft->getMesh());
+ const auto *target_mesh=static_cast<const MEDCouplingUMesh *>(_target_ft->getMesh());
const int srcMeshDim=src_mesh->getMeshDimension();
const int trgMeshDim=target_mesh->getMeshDimension();
const int trgSpceDim=target_mesh->getSpaceDimension();
int MEDCouplingRemapper::prepareInterpKernelOnlyCC()
{
std::string srcMeth,trgMeth;
- std::string methodCpp=checkAndGiveInterpolationMethodStr(srcMeth,trgMeth);
+ std::string const methodCpp=checkAndGiveInterpolationMethodStr(srcMeth,trgMeth);
if(methodCpp!="P0P0")
throw INTERP_KERNEL::Exception("MEDCouplingRemapper::prepareInterpKernelOnlyCC : only P0P0 interpolation supported for the moment !");
if(InterpolationOptions::getIntersectionType()!=INTERP_KERNEL::Triangulation)
throw INTERP_KERNEL::Exception("MEDCouplingRemapper::prepareInterpKernelOnlyCC: only 'Triangulation' intersection type supported!");
- const MEDCouplingCMesh *src_mesh=static_cast<const MEDCouplingCMesh *>(_src_ft->getMesh());
- const MEDCouplingCMesh *target_mesh=static_cast<const MEDCouplingCMesh *>(_target_ft->getMesh());
+ const auto *src_mesh=static_cast<const MEDCouplingCMesh *>(_src_ft->getMesh());
+ const auto *target_mesh=static_cast<const MEDCouplingCMesh *>(_target_ft->getMesh());
const int srcMeshDim=src_mesh->getMeshDimension();
const int trgMeshDim=target_mesh->getMeshDimension();
if(trgMeshDim!=srcMeshDim)
for(const mcIdType *trgId=ids0->begin();trgId!=ids0->end();trgId++)
{
const double *ptTrg=trgLocPtr+trgSpaceDim*(*trgId);
- mcIdType srcCellId=elts[eltsIndex[*trgId]];
+ mcIdType const srcCellId=elts[eltsIndex[*trgId]];
double dist=std::numeric_limits<double>::max();
mcIdType srcEntry=-1;
for(mcIdType srcId=srcOffsetArrPtr[srcCellId];srcId<srcOffsetArrPtr[srcCellId+1];srcId++)
}
if(ids0->getNumberOfTuples()!=trgNbOfGaussPts)
{
- MCAuto<DataArrayIdType> orphanTrgIds=nbOfSrcCellsShTrgPts->findIdsEqual(0);
+ MCAuto<DataArrayIdType> const orphanTrgIds=nbOfSrcCellsShTrgPts->findIdsEqual(0);
MCAuto<DataArrayDouble> orphanTrg=trgLoc->selectByTupleId(orphanTrgIds->begin(),orphanTrgIds->end());
MCAuto<DataArrayIdType> srcIdPerTrg=srcLoc->findClosestTupleId(orphanTrg);
const mcIdType *srcIdPerTrgPtr=srcIdPerTrg->begin();
THROW_IK_EXCEPTION("prepareNotInterpKernelOnlyFEFE : only spacedim 3 supported for target !")
if(_src_ft->getMesh()->getSpaceDimension() != 3)
THROW_IK_EXCEPTION("prepareNotInterpKernelOnlyFEFE : only spacedim 3 supported for source !")
- const MEDCouplingUMesh *srcUMesh( dynamic_cast<const MEDCouplingUMesh *>(_src_ft->getMesh()) );
- const MEDCouplingPointSet *trgMesh( dynamic_cast<const MEDCouplingPointSet *>(_target_ft->getMesh()) );
+ const auto *srcUMesh( dynamic_cast<const MEDCouplingUMesh *>(_src_ft->getMesh()) );
+ const auto *trgMesh( dynamic_cast<const MEDCouplingPointSet *>(_target_ft->getMesh()) );
if( !srcUMesh )
THROW_IK_EXCEPTION("prepareNotInterpKernelOnlyFEFE : only 3D UMesh supported as source !");
if( !trgMesh )
void MEDCouplingRemapper::releaseData(bool matrixSuppression)
{
- _src_ft=0;
- _target_ft=0;
+ _src_ft=nullptr;
+ _target_ft=nullptr;
if(matrixSuppression)
{
_matrix.clear();
void MEDCouplingRemapper::computeProduct(const double *inputPointer, int inputNbOfCompo, bool isDftVal, double dftValue, double *resPointer)
{
int idx=0;
- double *tmp=new double[inputNbOfCompo];
+ auto *tmp=new double[inputNbOfCompo];
for(std::vector<std::map<mcIdType,double> >::const_iterator iter1=_matrix.begin();iter1!=_matrix.end();iter1++,idx++)
{
if((*iter1).empty())
{
std::vector<bool> isReached(_deno_reverse_multiply.size(),false);
mcIdType idx=0;
- double *tmp=new double[inputNbOfCompo];
+ auto *tmp=new double[inputNbOfCompo];
std::fill(resPointer,resPointer+inputNbOfCompo*_deno_reverse_multiply.size(),0.);
for(std::vector<std::map<mcIdType,double> >::const_iterator iter1=_matrix.begin();iter1!=_matrix.end();iter1++,idx++)
{
void MEDCouplingRemapper::buildFinalInterpolationMatrixByConvolution(const std::vector< std::map<mcIdType,double> >& m1D,
const std::vector< std::map<mcIdType,double> >& m2D,
- const mcIdType *corrCellIdSrc, mcIdType nbOf2DCellsSrc, mcIdType nbOf1DCellsSrc,
+ const mcIdType *corrCellIdSrc, mcIdType nbOf2DCellsSrc, mcIdType /*nbOf1DCellsSrc*/,
const mcIdType *corrCellIdTrg)
{
mcIdType nbOf2DCellsTrg=ToIdType(m2D.size());
mcIdType nbOf1DCellsTrg=ToIdType(m1D.size());
- mcIdType nbOf3DCellsTrg=nbOf2DCellsTrg*nbOf1DCellsTrg;
+ mcIdType const nbOf3DCellsTrg=nbOf2DCellsTrg*nbOf1DCellsTrg;
_matrix.resize(nbOf3DCellsTrg);
mcIdType id2R=0;
for(std::vector< std::map<mcIdType,double> >::const_iterator iter2R=m2D.begin();iter2R!=m2D.end();iter2R++,id2R++)
*/
int MEDCouplingRemapper::nullifiedTinyCoeffInCrudeMatrix(double scaleFactor)
{
- double maxVal=getMaxValueInCrudeMatrix();
+ double const maxVal=getMaxValueInCrudeMatrix();
if(maxVal==0.)
return -1;
return nullifiedTinyCoeffInCrudeMatrixAbs(scaleFactor*maxVal);
#define __PARAMEDMEM_MEDCOUPLINGREMAPPER_HXX__
#include "MEDCoupling.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
#include "MEDCouplingTimeLabel.hxx"
#include "InterpolationOptions.hxx"
-#include "MEDCouplingNatureOfField.hxx"
#include "MCType.hxx"
#include "MCAuto.hxx"
-#include "InterpKernelException.hxx"
#include <map>
+#include <string>
#include <vector>
namespace MEDCoupling
{
public:
MEDCOUPLINGREMAPPER_EXPORT MEDCouplingRemapper();
- MEDCOUPLINGREMAPPER_EXPORT ~MEDCouplingRemapper();
+ MEDCOUPLINGREMAPPER_EXPORT ~MEDCouplingRemapper() override;
MEDCOUPLINGREMAPPER_EXPORT int prepare(const MEDCouplingMesh *srcMesh, const MEDCouplingMesh *targetMesh, const std::string& method);
MEDCOUPLINGREMAPPER_EXPORT int prepareEx(const MEDCouplingFieldTemplate *src, const MEDCouplingFieldTemplate *target);
MEDCOUPLINGREMAPPER_EXPORT void setCrudeMatrix(const MEDCouplingMesh *srcMesh, const MEDCouplingMesh *targetMesh, const std::string& method, const std::vector<std::map<mcIdType,double> >& m);
static int CheckInterpolationMethodManageableByNotOnlyInterpKernel(const std::string& method);
//
bool isInterpKernelOnlyOrNotOnly() const;
- void updateTime() const;
+ void updateTime() const override;
void checkPrepare() const;
void synchronizeSizeOfSideMatricesAfterMatrixComputation(mcIdType nbOfColsInMatrix);
std::string checkAndGiveInterpolationMethodStr(std::string& srcMeth, std::string& trgMeth) const;
//
#include "MEDCouplingSkyLineArray.hxx"
-
+#include "MCType.hxx"
+#include "NormalizedGeometricTypes"
+#include "MCIdType.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+
+#include <algorithm>
+#include <iterator>
+#include <cstddef>
+#include <ostream>
+#include <limits>
#include <sstream>
#include <deque>
#include <set>
+#include <vector>
using namespace MEDCoupling;
}
MEDCouplingSkyLineArray::~MEDCouplingSkyLineArray()
-{
-}
+= default;
MEDCouplingSkyLineArray* MEDCouplingSkyLineArray::New()
{
MEDCouplingSkyLineArray* MEDCouplingSkyLineArray::New( const std::vector<mcIdType>& index,
const std::vector<mcIdType>& value )
{
- MEDCouplingSkyLineArray * ret = new MEDCouplingSkyLineArray();
+ auto * ret = new MEDCouplingSkyLineArray();
ret->_index->reserve( index.size() );
ret->_index->insertAtTheEnd( index.begin(), index.end() );
ret->_values->reserve( value.size() );
MEDCouplingSkyLineArray* MEDCouplingSkyLineArray::New( DataArrayIdType* index, DataArrayIdType* value )
{
- MEDCouplingSkyLineArray* ret = new MEDCouplingSkyLineArray();
+ auto* ret = new MEDCouplingSkyLineArray();
ret->set(index, value);
return ret;
}
MEDCouplingSkyLineArray* MEDCouplingSkyLineArray::New( const MEDCouplingSkyLineArray & other )
{
- MEDCouplingSkyLineArray* ret = new MEDCouplingSkyLineArray();
+ auto* ret = new MEDCouplingSkyLineArray();
ret->_super_index = other._super_index;
ret->_index = other._index;
ret->_values = other._values;
{
using namespace std;
- MEDCouplingSkyLineArray* ret = new MEDCouplingSkyLineArray();
+ auto* ret = new MEDCouplingSkyLineArray();
const mcIdType * cP(c->begin()), * cIP(cI->begin());
mcIdType prev = -1;
throw INTERP_KERNEL::Exception("MEDCouplingSkyLineArray::BuildFromDynamicConn: misformatted connectivity (wrong nb of tuples)!");
for (mcIdType i=0; i < cI->getNbOfElems(); i++)
{
- mcIdType j = cIP[i];
+ mcIdType const j = cIP[i];
if (cIP[i] < prev)
throw INTERP_KERNEL::Exception("MEDCouplingSkyLineArray::BuildFromDynamicConn: misformatted connectivity (indices not monotonic ascending)!");
prev = cIP[i];
while (w2 != cP+end)
{
copy(w, w2, work);
- mcIdType d = ToIdType(distance(w, w2));
+ mcIdType const d = ToIdType(distance(w, w2));
cnt += d; work +=d;
idx.push_back(cnt); cnt2++;
w = w2+1; // skip the -1
cI->alloc(_super_index->getNbOfElems(),1); // same number of super packs as number of cells
mcIdType * cIVecP(cI->getPointer());
MCAuto <DataArrayIdType> dsi = _index->deltaShiftIndex();
- mcIdType sz = dsi->accumulate((std::size_t)0) + ToIdType(dsi->getNbOfElems()); // think about it: one slot for the type, -1 at the end of each face of the cell
+ mcIdType const sz = dsi->accumulate((std::size_t)0) + ToIdType(dsi->getNbOfElems()); // think about it: one slot for the type, -1 at the end of each face of the cell
c->alloc(sz, 1);
mcIdType * cVecP(c->getPointer());
for ( mcIdType i=0; i < _super_index->getNbOfElems()-1; i++)
{
cIVecP[i]= cnt;
- mcIdType endId = siP[i+1];
+ mcIdType const endId = siP[i+1];
cVecP[cnt++] = INTERP_KERNEL::NORM_POLYHED;
for (mcIdType j=siP[i]; j < endId; j++)
{
MCAuto<MEDCouplingSkyLineArray> ret(MEDCouplingSkyLineArray::New(indexCpy,valuesCpy));
if(_super_index.isNotNull())
{
- MCAuto<DataArrayIdType> superIndexCpy(this->_super_index->deepCopy());
+ MCAuto<DataArrayIdType> const superIndexCpy(this->_super_index->deepCopy());
ret->_super_index = superIndexCpy;
}
return ret.retn();
void MEDCouplingSkyLineArray::validSuperIndexAndIndex(const std::string& func, mcIdType superIndex, mcIdType index) const
{
validSuperIndex(func, superIndex);
- mcIdType idx = _super_index->begin()[superIndex] + index;
+ mcIdType const idx = _super_index->begin()[superIndex] + index;
if(idx < 0 || idx >= _index->getNbOfElems())
{
std::ostringstream oss;
*/
void MEDCouplingSkyLineArray::thresholdPerPack(mcIdType threshold, MCAuto<MEDCouplingSkyLineArray>& left, MCAuto<MEDCouplingSkyLineArray>& right) const
{
- mcIdType nbPacks(this->getNumberOf());
+ mcIdType const nbPacks(this->getNumberOf());
MCAuto<DataArrayIdType> lCount(DataArrayIdType::New()); lCount->alloc(nbPacks,1); lCount->fillWithZero();
mcIdType *lCountPtr(lCount->getPointerSilent());
const mcIdType *valuesPtr(this->_values->begin()),*indexPtr(this->_index->begin());
indexedPacks->checkAllocated();
if( indexedPacks->getNumberOfComponents() != 1 )
throw INTERP_KERNEL::Exception("MEDCouplingSkyLineArray::groupPacks : number of components must be 1 !");
- std::size_t nbTuples(indexedPacks->getNumberOfTuples());
+ std::size_t const nbTuples(indexedPacks->getNumberOfTuples());
if( nbTuples == 0 )
throw INTERP_KERNEL::Exception("MEDCouplingSkyLineArray::groupPacks : number of tuples must be > 0 !");
const DataArrayIdType *index(this->getIndexArray());
MEDCouplingSkyLineArray *MEDCouplingSkyLineArray::uniqueNotSortedByPack() const
{
- mcIdType nbPacks(this->getNumberOf());
+ mcIdType const nbPacks(this->getNumberOf());
MCAuto<DataArrayIdType> retIndex(DataArrayIdType::New()); retIndex->alloc(nbPacks+1,1);
const mcIdType *valuesPtr(this->_values->begin()),*indexPtr(this->_index->begin());
mcIdType *retIndexPtr(retIndex->getPointer()); *retIndexPtr = 0;
for(mcIdType i = 0 ; i < nbPacks ; ++i, ++retIndexPtr)
{
- std::set<mcIdType> s(valuesPtr+indexPtr[i],valuesPtr+indexPtr[i+1]);
+ std::set<mcIdType> const s(valuesPtr+indexPtr[i],valuesPtr+indexPtr[i+1]);
retIndexPtr[1] = retIndexPtr[0] + ToIdType(s.size());
}
MCAuto<DataArrayIdType> retValues(DataArrayIdType::New()); retValues->alloc(retIndex->back(),1);
mcIdType *retValuesPtr(retValues->getPointer());
for(mcIdType i = 0 ; i < nbPacks ; ++i)
{
- std::set<mcIdType> s(valuesPtr+indexPtr[i],valuesPtr+indexPtr[i+1]);
+ std::set<mcIdType> const s(valuesPtr+indexPtr[i],valuesPtr+indexPtr[i+1]);
retValuesPtr = std::copy(s.begin(),s.end(),retValuesPtr);
}
MCAuto<MEDCouplingSkyLineArray> ret(MEDCouplingSkyLineArray::New(retIndex,retValues));
{
if(sk)
{
- mcIdType curNbPacks(sk->getNumberOf());
+ mcIdType const curNbPacks(sk->getNumberOf());
if(sksEff.empty())
nbOfPacks = curNbPacks;
if(nbOfPacks != curNbPacks)
std::for_each(indicesIn.begin(),indicesIn.end(),[packId,&nbOfAggPacks](const mcIdType *elt) { nbOfAggPacks+=elt[packId+1]-elt[packId]; });
indexPtr[1] = indexPtr[0] + nbOfAggPacks;
}
- mcIdType nbOfTuplesOut(index->back());
+ mcIdType const nbOfTuplesOut(index->back());
MCAuto<DataArrayIdType> values(DataArrayIdType::New()); values->alloc(nbOfTuplesOut,1);
mcIdType *valuesPtr(values->getPointer());
// let's go to populate values array
if(absolutePackId < 0 || absolutePackId >= _index->getNbOfElems())
throw INTERP_KERNEL::Exception("MEDCouplingSkyLineArray::getPackSafe: invalid index!");
const mcIdType * iP(_index->begin()), *vP(_values->begin());
- mcIdType sz = iP[absolutePackId+1]-iP[absolutePackId];
+ mcIdType const sz = iP[absolutePackId+1]-iP[absolutePackId];
pack.resize(sz);
std::copy(vP+iP[absolutePackId], vP+iP[absolutePackId+1],pack.begin());
}
checkSuperIndex("findPackIds");
- mcIdType packSz = ToIdType(std::distance(packBg, packEnd));
+ mcIdType const packSz = ToIdType(std::distance(packBg, packEnd));
if (!packSz)
throw INTERP_KERNEL::Exception("MEDCouplingSkyLineArray::findPackIds: void pack!");
out.resize(superPackIndices.size());
mcIdType i = 0;
const mcIdType * siP(_super_index->begin()), * iP(_index->begin()), *vP(_values->begin());
- for(vector<mcIdType>::const_iterator it=superPackIndices.begin(); it!=superPackIndices.end(); ++it, i++)
+ for(auto it=superPackIndices.begin(); it!=superPackIndices.end(); ++it, i++)
{
out[i] = -1;
const mcIdType sPackIdx = *it;
_values->reAlloc(_values->getNbOfElems() - (end-start));
// _index
- mcIdType nt = _index->getNbOfElems();
+ mcIdType const nt = _index->getNbOfElems();
std::copy(iP+siP[superIdx]+idx+1, iP+nt, iP+siP[superIdx]+idx);
_index->reAlloc(nt-1); iP = _index->getPointer(); // better not forget this ...
for(mcIdType ii = siP[superIdx]+idx; ii < nt-1; ii++)
const mcIdType start(iP[idx]), end(iP[idx+1]);
// _values
- mcIdType initValSz=_values->getNbOfElems();
- mcIdType deltaSz( start-end ); // should be negative
+ mcIdType const initValSz=_values->getNbOfElems();
+ mcIdType const deltaSz( start-end ); // should be negative
mcIdType *vP(_values->getPointer());
if (deltaSz < 0)
{
else
throw INTERP_KERNEL::Exception("MEDCouplingSkyLineArray::deleteSimplePack");
// _index
- mcIdType nt=_index->getNbOfElems();
+ mcIdType const nt=_index->getNbOfElems();
std::copy(iP+idx+1, iP+nt, iP+idx);
for(mcIdType ii = idx; ii < nt-1; ii++)
iP[ii] += deltaSz;
if (idx->empty())
return;
- for (const mcIdType * id = idx->begin(); id != idx->end(); id++)
- validIndex("deleteSimplePacks", *id);
+ for (long const id : *idx)
+ validIndex("deleteSimplePacks", id);
if (idx->getNbOfElems() != ToIdType( packs.size()))
throw INTERP_KERNEL::Exception("MEDCouplingSkyLineArray::deleteSimplePacks: size of list of pack is incorrect");
std::deque< std::set<mcIdType> > valuesByIdx;
mcIdType* vP(_values->getPointer());
mcIdType* iP(_index->getPointer());
- mcIdType nt = _index->getNbOfElems();
+ mcIdType const nt = _index->getNbOfElems();
for (mcIdType ii = 0; ii < nt-1; ii++)
valuesByIdx.push_back(std::set<mcIdType>(vP+iP[ii], vP+iP[ii+1]));
// modify the deque<set<mcIdType>> according to idx and packs
mcIdType ii(0);
- for (const mcIdType *id = idx->begin(); id != idx->end(); id++)
+ for (long const id : *idx)
{
- valuesByIdx[*id] = std::set<mcIdType>(packs[ii]->begin(), packs[ii]->end());
+ valuesByIdx[id] = std::set<mcIdType>(packs[ii]->begin(), packs[ii]->end());
ii++;
}
// copy back the deque<set<mcIdType>> into _index, _values
mcIdType valSz(0);
*iP = 0;
- for (std::deque< std::set<mcIdType> >::const_iterator values=valuesByIdx.begin();values!=valuesByIdx.end();values++)
+ for (const auto & values : valuesByIdx)
{
- valSz += ToIdType((*values).size());
+ valSz += ToIdType(values.size());
*(++iP) = valSz;
}
_values->reAlloc(valSz);
void MEDCouplingSkyLineArray::deleteSimplePacks(const DataArrayIdType* idx)
{
- for (auto id = idx->begin(); id != idx->end(); id++)
- validIndex("deleteSimplePacks", *id);
+ for (long const id : *idx)
+ validIndex("deleteSimplePacks", id);
- std::set<mcIdType> packsToDelete(idx->begin(), idx->end());
+ std::set<mcIdType> const packsToDelete(idx->begin(), idx->end());
// _values
mcIdType* iP(_index->getPointer());
- mcIdType initValSz = _values->getNbOfElems();
+ mcIdType const initValSz = _values->getNbOfElems();
mcIdType *vP(_values->getPointer());
mcIdType end_prec(0),start_prec(0);
- for(std::set<mcIdType>::const_iterator ii=packsToDelete.begin();ii!=packsToDelete.end();ii++)
+ for(long const ii : packsToDelete)
{
- mcIdType start = iP[*ii];
+ mcIdType const start = iP[ii];
if (end_prec != 0)
std::copy(vP+end_prec, vP+start, vP+start_prec);
start_prec += start-end_prec;
- end_prec = iP[*ii+1];
+ end_prec = iP[ii+1];
}
if (end_prec != 0)
std::copy(vP+end_prec, vP+initValSz, vP+start_prec);
_values->reAlloc(initValSz-(end_prec-start_prec));
// _index
- mcIdType nt = _index->getNbOfElems();
+ mcIdType const nt = _index->getNbOfElems();
mcIdType offset = 0;
end_prec = 0;
start_prec = 0;
mcIdType deleted = 0;
- for(std::set<mcIdType>::const_iterator ii=packsToDelete.begin();ii!=packsToDelete.end();ii++)
+ for(long const ii : packsToDelete)
{
if (end_prec != 0)
{
- std::copy(iP+end_prec, iP+*ii, iP+start_prec);
- for (mcIdType i=start_prec; i<*ii; i++)
+ std::copy(iP+end_prec, iP+ii, iP+start_prec);
+ for (mcIdType i=start_prec; i<ii; i++)
iP[i] -= offset;
}
- offset += iP[*ii+1] - iP[*ii];
- start_prec = *ii-deleted;
- end_prec = *ii+1;
+ offset += iP[ii+1] - iP[ii];
+ start_prec = ii-deleted;
+ end_prec = ii+1;
deleted += 1;
}
if (end_prec != 0)
copy(packBg, packEnd, vP+iP[siP[superIdx+1]]);
// _index
- mcIdType nt = ToIdType(_index->getNbOfElems());
+ mcIdType const nt = ToIdType(_index->getNbOfElems());
_index->reAlloc(nt+1); iP = _index->getPointer();
copy(iP+siP[superIdx+1]+1, iP+nt, iP+siP[superIdx+1]+2);
iP[siP[superIdx+1]+1] = iP[siP[superIdx+1]] + sz;
validIndex("replaceSimplePack", idx);
mcIdType * iP(_index->getPointer());
- mcIdType newSz = ToIdType(std::distance(packBg, packEnd));
+ mcIdType const newSz = ToIdType(std::distance(packBg, packEnd));
const mcIdType start = iP[idx], end = iP[idx+1];
// _values
- mcIdType initValSz = _values->getNbOfElems();
- mcIdType deltaSz = newSz-(end-start); // can be negative
+ mcIdType const initValSz = _values->getNbOfElems();
+ mcIdType const deltaSz = newSz-(end-start); // can be negative
if (deltaSz)
{
if (deltaSz > 0)
validSuperIndexAndIndex("replacePack", superIdx, idx);
mcIdType * siP(_super_index->getPointer()), *iP(_index->getPointer());
- mcIdType newSz = ToIdType(std::distance(packBg, packEnd));
+ mcIdType const newSz = ToIdType(std::distance(packBg, packEnd));
const mcIdType start = iP[siP[superIdx]+idx], end = iP[siP[superIdx]+idx+1];
// _values
- mcIdType initValSz = _values->getNbOfElems();
- mcIdType deltaSz = newSz-(end-start); // can be negative
+ mcIdType const initValSz = _values->getNbOfElems();
+ mcIdType const deltaSz = newSz-(end-start); // can be negative
if (deltaSz)
{
if (deltaSz > 0)
#pragma once
+#include "MCType.hxx"
+#include "MCIdType.hxx"
#include "MEDCoupling.hxx"
#include "MEDCouplingMemArray.hxx"
#include "MCAuto.hxx"
-#include "NormalizedGeometricTypes"
+#include "MEDCouplingRefCountObject.hxx"
+#include <cstddef>
+#include <algorithm>
+#include <string>
+#include <iterator>
#include <vector>
#include <functional>
static std::vector< MCAuto<DataArrayIdType> > RetrieveVecOfSkyLineArrayGen(const std::vector< MCAuto<MEDCouplingSkyLineArray> >& vecSka, std::function<DataArrayIdType *(MEDCouplingSkyLineArray *)> fct)
{
- std::size_t sz(vecSka.size());
+ std::size_t const sz(vecSka.size());
std::vector< MCAuto<DataArrayIdType> > ret(sz);
- std::vector< MCAuto<DataArrayIdType> >::iterator it(ret.begin());
+ auto it(ret.begin());
std::for_each(vecSka.begin(),vecSka.end(),[&it,fct](MCAuto<MEDCouplingSkyLineArray> elt) { *it++ = MCAuto<DataArrayIdType>::TakeRef(fct(elt)); } );
return ret;
}
std::string getClassName() const override { return std::string("MEDCouplingSkyLineArray"); }
- std::size_t getHeapMemorySizeWithoutChildren() const;
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
void set( DataArrayIdType* index, DataArrayIdType* value );
void set3( DataArrayIdType* superIndex, DataArrayIdType* index, DataArrayIdType* value );
private:
MEDCouplingSkyLineArray();
- ~MEDCouplingSkyLineArray();
+ ~MEDCouplingSkyLineArray() override;
void checkSuperIndex(const std::string& func) const;
void validSuperIndex(const std::string& func, mcIdType superIndex) const;
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingStructuredMesh.hxx"
+#include "MCType.hxx"
+#include "MCIdType.hxx"
+#include "CellModel.hxx"
+#include "MCAuto.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "MEDCouplingMemArray.hxx"
#include "MEDCoupling1GTUMesh.hxx"
+#include "MEDCouplingMesh.hxx"
+#include "MEDCouplingRefCountObject.hxx"
#include "MEDCouplingUMesh.hxx"
-#include "MEDCouplingIMesh.hxx"//tony to throw when optimization will be performed in AssignPartOfFieldOfDoubleUsing
-
+#include "MEDCouplingIMesh.hxx"
+#include "NormalizedGeometricTypes"
+
+#include <algorithm>
+#include <cstddef>
+#include <iterator>
+#include <limits>
+#include <functional>
#include <numeric>
+#include <set>
+#include <string>
+#include <sstream>
+#include <vector>
+#include <utility>
using namespace MEDCoupling;
MEDCouplingStructuredMesh::MEDCouplingStructuredMesh()
-{
-}
+= default;
-MEDCouplingStructuredMesh::MEDCouplingStructuredMesh(const MEDCouplingStructuredMesh& other, bool deepCpy):MEDCouplingMesh(other)
+MEDCouplingStructuredMesh::MEDCouplingStructuredMesh(const MEDCouplingStructuredMesh& other, bool /*deepCpy*/):MEDCouplingMesh(other)
{
}
MEDCouplingStructuredMesh::~MEDCouplingStructuredMesh()
-{
-}
+= default;
std::size_t MEDCouplingStructuredMesh::getHeapMemorySizeWithoutChildren() const
{
return MEDCouplingMesh::isEqualIfNotWhy(other,prec,reason);
}
-INTERP_KERNEL::NormalizedCellType MEDCouplingStructuredMesh::getTypeOfCell(mcIdType cellId) const
+INTERP_KERNEL::NormalizedCellType MEDCouplingStructuredMesh::getTypeOfCell(mcIdType /*cellId*/) const
{
return GetGeoTypeGivenMeshDimension(getMeshDimension());
}
mcIdType MEDCouplingStructuredMesh::getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType type) const
{
- mcIdType ret(getNumberOfCells());
+ mcIdType const ret(getNumberOfCells());
if(type==getTypeOfCell(0))
return ret;
const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(getTypeOfCell(0)));
DataArrayIdType *MEDCouplingStructuredMesh::computeNbOfNodesPerCell() const
{
- std::size_t nbCells=getNumberOfCells();
+ std::size_t const nbCells=getNumberOfCells();
MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
ret->alloc(nbCells,1);
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getTypeOfCell(0));
DataArrayIdType *MEDCouplingStructuredMesh::computeNbOfFacesPerCell() const
{
- std::size_t nbCells=getNumberOfCells();
+ std::size_t const nbCells=getNumberOfCells();
MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
ret->alloc(nbCells,1);
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getTypeOfCell(0));
void MEDCouplingStructuredMesh::getNodeIdsOfCell(mcIdType cellId, std::vector<mcIdType>& conn) const
{
- int meshDim=getMeshDimension();
+ int const meshDim=getMeshDimension();
mcIdType tmpCell[3],tmpNode[3];
getSplitCellValues(tmpCell);
getSplitNodeValues(tmpNode);
int spd1(0),pos(0);
for(std::vector<mcIdType>::const_iterator it=nodeStr.begin();it!=nodeStr.end();it++,pos++)
{
- mcIdType elt(*it);
+ mcIdType const elt(*it);
if(elt<=0)
{
std::ostringstream oss; oss << "MEDCouplingStructuredMesh::getSpaceDimensionOnNodeStruct : At pos #" << pos << " value of node grid structure is " << *it << " ! must be >=1 !";
void MEDCouplingStructuredMesh::getSplitCellValues(mcIdType *res) const
{
- std::vector<mcIdType> strct(getCellGridStructure());
+ std::vector<mcIdType> const strct(getCellGridStructure());
std::vector<mcIdType> ret(MEDCouplingStructuredMesh::GetSplitVectFromStruct(strct));
std::copy(ret.begin(),ret.end(),res);
}
void MEDCouplingStructuredMesh::getSplitNodeValues(mcIdType *res) const
{
- std::vector<mcIdType> strct(getNodeGridStructure());
+ std::vector<mcIdType> const strct(getNodeGridStructure());
std::vector<mcIdType> ret(MEDCouplingStructuredMesh::GetSplitVectFromStruct(strct));
std::copy(ret.begin(),ret.end(),res);
}
*/
mcIdType MEDCouplingStructuredMesh::getNumberOfCellsOfSubLevelMesh() const
{
- std::vector<mcIdType> cgs(getCellGridStructure());
+ std::vector<mcIdType> const cgs(getCellGridStructure());
return GetNumberOfCellsOfSubLevelMesh(cgs,getMeshDimension());
}
*/
DataArrayIdType *MEDCouplingStructuredMesh::checkTypeConsistencyAndContig(const std::vector<mcIdType>& code, const std::vector<const DataArrayIdType *>& idsPerType) const
{
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
if(code.size()!=3)
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::checkTypeConsistencyAndContig : invalid input code should be exactly of size 3 !");
if(code[0]!=ToIdType(getTypeOfCell(0)))
if(code[2]==-1)
{
if(code[1]==nbOfCells)
- return 0;
+ return nullptr;
else
{
std::ostringstream oss; oss << "MEDCouplingStructuredMesh::checkTypeConsistencyAndContig : mismatch between the number of cells in this (" << nbOfCells << ") and the number of non profile (" << code[1] << ") !";
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::splitProfilePerType : input profile is NULL or not allocated !");
if(profile->getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::splitProfilePerType : input profile should have exactly one component !");
- mcIdType nbTuples(profile->getNumberOfTuples());
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbTuples(profile->getNumberOfTuples());
+ mcIdType const nbOfCells=getNumberOfCells();
code.resize(3); idsInPflPerType.resize(1);
code[0]=ToIdType(getTypeOfCell(0)); code[1]=nbOfCells;
idsInPflPerType.resize(1);
*/
MEDCoupling1SGTUMesh *MEDCouplingStructuredMesh::build1SGTSubLevelMesh() const
{
- int meshDim(getMeshDimension());
+ int const meshDim(getMeshDimension());
if(meshDim<1 || meshDim>3)
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::build1SGTSubLevelMesh : meshdim must be in [2,3] !");
MCAuto<DataArrayDouble> coords(getCoordinatesAndOwner());
MEDCouplingMesh *MEDCouplingStructuredMesh::buildPartAndReduceNodes(const mcIdType *start, const mcIdType *end, DataArrayIdType*& arr) const
{
- std::vector<mcIdType> cgs(getCellGridStructure());
+ std::vector<mcIdType> const cgs(getCellGridStructure());
std::vector< std::pair<mcIdType,mcIdType> > cellPartFormat,nodePartFormat;
if(IsPartStructured(start,end,cgs,cellPartFormat))
{
MCAuto<MEDCouplingStructuredMesh> ret(buildStructuredSubPart(cellPartFormat));
nodePartFormat=cellPartFormat;
- for(std::vector< std::pair<mcIdType,mcIdType> >::iterator it=nodePartFormat.begin();it!=nodePartFormat.end();it++)
- (*it).second++;
+ for(auto & it : nodePartFormat)
+ it.second++;
MCAuto<DataArrayIdType> tmp1(BuildExplicitIdsFrom(getNodeGridStructure(),nodePartFormat));
MCAuto<DataArrayIdType> tmp2(DataArrayIdType::New()); tmp2->alloc(getNumberOfNodes(),1);
tmp2->fillWithValue(-1);
}
}
-DataArrayIdType *MEDCouplingStructuredMesh::simplexize(int policy)
+DataArrayIdType *MEDCouplingStructuredMesh::simplexize(int /*policy*/)
{
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::simplexize : not available for Cartesian mesh !");
}
throw INTERP_KERNEL::Exception("Expected a MEDCouplingStructuredMesh with meshDim == 2 !");
MCAuto<MEDCouplingFieldDouble> ret(MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME));
MCAuto<DataArrayDouble> array(DataArrayDouble::New());
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
array->alloc(nbOfCells,3);
double *vals(array->getPointer());
for(mcIdType i=0;i<nbOfCells;i++)
void MEDCouplingStructuredMesh::getReverseNodalConnectivity(DataArrayIdType *revNodal, DataArrayIdType *revNodalIndx) const
{
- std::vector<mcIdType> ngs(getNodeGridStructure());
- int dim(getSpaceDimension());
+ std::vector<mcIdType> const ngs(getNodeGridStructure());
+ int const dim(getSpaceDimension());
switch(dim)
{
case 1:
void MEDCouplingStructuredMesh::GetReverseNodalConnectivity1(const std::vector<mcIdType>& ngs, DataArrayIdType *revNodal, DataArrayIdType *revNodalIndx)
{
- mcIdType nbNodes(ngs[0]);
+ mcIdType const nbNodes(ngs[0]);
revNodalIndx->alloc(nbNodes+1,1);
if(nbNodes==0)
{ revNodal->alloc(0,1); revNodalIndx->setIJ(0,0,0); return ; }
void MEDCouplingStructuredMesh::GetReverseNodalConnectivity2(const std::vector<mcIdType>& ngs, DataArrayIdType *revNodal, DataArrayIdType *revNodalIndx)
{
mcIdType nbNodesX(ngs[0]),nbNodesY(ngs[1]);
- mcIdType nbNodes(nbNodesX*nbNodesY);
+ mcIdType const nbNodes(nbNodesX*nbNodesY);
if(nbNodesX==0 || nbNodesY==0)
{ revNodal->alloc(0,1); revNodalIndx->setIJ(0,0,0); return ; }
if(nbNodesX==1 || nbNodesY==1)
rni[1]=rni[0]+2; rn[0]=off+nbCellsX-1; rn[1]=off2+nbCellsX-1;
rni++; rn+=2;
}
- mcIdType off3(nbCellsX*(nbCellsY-1));
+ mcIdType const off3(nbCellsX*(nbCellsY-1));
rni[1]=rni[0]+1;
rni++; *rn++=off3;
for(mcIdType i=1;i<nbNodesX-1;i++,rni++,rn+=2)
void MEDCouplingStructuredMesh::GetReverseNodalConnectivity3(const std::vector<mcIdType>& ngs, DataArrayIdType *revNodal, DataArrayIdType *revNodalIndx)
{
mcIdType nbNodesX(ngs[0]),nbNodesY(ngs[1]),nbNodesZ(ngs[2]);
- mcIdType nbNodes(nbNodesX*nbNodesY*nbNodesZ);
+ mcIdType const nbNodes(nbNodesX*nbNodesY*nbNodesZ);
if(nbNodesX==0 || nbNodesY==0 || nbNodesZ==0)
{ revNodal->alloc(0,1); revNodalIndx->setIJ(0,0,0); return ; }
if(nbNodesX==1 || nbNodesY==1 || nbNodesZ==1)
*rni=0;
for(mcIdType k=0;k<nbNodesZ;k++)
{
- bool factZ(k!=0 && k!=nbNodesZ-1);
+ bool const factZ(k!=0 && k!=nbNodesZ-1);
mcIdType offZ0((k-1)*nbCellsX*nbCellsY),offZ1(k*nbCellsX*nbCellsY);
for(mcIdType j=0;j<nbNodesY;j++)
{
- bool factYZ(factZ && (j!=0 && j!=nbNodesY-1));
+ bool const factYZ(factZ && (j!=0 && j!=nbNodesY-1));
mcIdType off00((j-1)*nbCellsX+offZ0),off01(j*nbCellsX+offZ0),off10((j-1)*nbCellsX+offZ1),off11(j*nbCellsX+offZ1);
for(mcIdType i=0;i<nbNodesX;i++,rni++)
{
- mcIdType fact(factYZ && (i!=0 && i!=nbNodesX-1));
+ mcIdType const fact(factYZ && (i!=0 && i!=nbNodesX-1));
if(fact)
{//most of points fall in this part of code
rn[0]=off00+i-1; rn[1]=off00+i; rn[2]=off01+i-1; rn[3]=off01+i;
DataArrayIdType *MEDCouplingStructuredMesh::Build1GTNodalConnectivity(const mcIdType *nodeStBg, const mcIdType *nodeStEnd)
{
mcIdType zippedNodeSt[3];
- mcIdType dim(ZipNodeStructure(nodeStBg,nodeStEnd,zippedNodeSt));
+ mcIdType const dim(ZipNodeStructure(nodeStBg,nodeStEnd,zippedNodeSt));
switch(dim)
{
case 0:
DataArrayIdType *MEDCouplingStructuredMesh::Build1GTNodalConnectivityOfSubLevelMesh(const mcIdType *nodeStBg, const mcIdType *nodeStEnd)
{
- std::size_t dim(std::distance(nodeStBg,nodeStEnd));
+ std::size_t const dim(std::distance(nodeStBg,nodeStEnd));
switch(dim)
{
case 3:
{
if(ghostLev<0)
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::ComputeCornersGhost : ghost lev must be >= 0 !");
- std::size_t dim(st.size());
+ std::size_t const dim(st.size());
MCAuto<DataArrayIdType> ret(DataArrayIdType::New());
switch(dim)
{
mcIdType *ptr(ret->getPointer());
for(mcIdType i=0;i<ghostLev;i++,ptr++)
*ptr=i;
- mcIdType offset(st[0]);
+ mcIdType const offset(st[0]);
if(offset<0)
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::ComputeCornersGhost : element in 1D structure must be >= 0 !");
for(mcIdType i=0;i<ghostLev;i++,ptr++)
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::ComputeCornersGhost : elements in 3D structure must be >= 0 !");
ret->alloc(8*ghostLev,1);
mcIdType *ptr(ret->getPointer());
- mcIdType zeOffsetZ((offsetX+2*ghostLev)*(offsetY+2*ghostLev));
+ mcIdType const zeOffsetZ((offsetX+2*ghostLev)*(offsetY+2*ghostLev));
for(mcIdType i=0;i<ghostLev;i++)
{
*ptr++=i*(2*ghostLev+offsetX+1)+i*zeOffsetZ;
{
mcIdType ret(1);
std::size_t ii(0);
- for(std::vector< std::pair<mcIdType,mcIdType> >::const_iterator it=partCompactFormat.begin();it!=partCompactFormat.end();it++,ii++)
+ for(auto it=partCompactFormat.begin();it!=partCompactFormat.end();it++,ii++)
{
mcIdType a((*it).first),b((*it).second);
if(a<0 || b<0 || b-a<0)
{
mcIdType ret(1);
bool isFetched(false);
- for(std::size_t i=0;i<st.size();i++)
+ for(long const i : st)
{
- if(st[i]<0)
+ if(i<0)
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure : presence of a negative value in structure !");
- ret*=st[i];
+ ret*=i;
isFetched=true;
}
return isFetched?ret:0;
void MEDCouplingStructuredMesh::FindTheWidestAxisOfGivenRangeInCompactFrmt(const std::vector< std::pair<mcIdType,mcIdType> >& partCompactFormat, int& axisId, mcIdType& sizeOfRange)
{
- mcIdType dim(ToIdType(partCompactFormat.size()));
+ mcIdType const dim(ToIdType(partCompactFormat.size()));
mcIdType ret(-1);
for(int i=0;i<dim;i++)
{
- mcIdType curDelta(partCompactFormat[i].second-partCompactFormat[i].first);
+ mcIdType const curDelta(partCompactFormat[i].second-partCompactFormat[i].first);
if(curDelta<0)
{
std::ostringstream oss; oss << "MEDCouplingStructuredMesh::FindTheWidestAxisOfGivenRangeInCompactFrmt : at axis #" << i << " the range is invalid (first value < second value) !";
default:
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::FindMinimalPartOf : only dimension 1, 2 and 3 are supported actually !");
}
- std::vector<mcIdType> dims(MEDCouplingStructuredMesh::GetDimensionsFromCompactFrmt(partCompactFormat));
+ std::vector<mcIdType> const dims(MEDCouplingStructuredMesh::GetDimensionsFromCompactFrmt(partCompactFormat));
mcIdType i(0);
- for(std::vector< std::pair<mcIdType,mcIdType> >::iterator it=partCompactFormat.begin();it!=partCompactFormat.end();it++,i++)
+ for(auto it=partCompactFormat.begin();it!=partCompactFormat.end();it++,i++)
{
if(st[i]<minPatchLgth)
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::FindMinimalPartOf : the input patch is tinier than the min length constraint !");
*/
std::vector< std::vector<mcIdType> > MEDCouplingStructuredMesh::ComputeSignaturePerAxisOf(const std::vector<mcIdType>& st, const std::vector<bool>& crit)
{
- std::size_t dim(st.size());
+ std::size_t const dim(st.size());
std::vector< std::vector<mcIdType> > ret(dim);
switch(dim)
{
case 1:
{
- mcIdType nx(st[0]);
+ mcIdType const nx(st[0]);
ret[0].resize(nx);
std::vector<mcIdType>& retX(ret[0]);
for(mcIdType i=0;i<nx;i++)
mcIdType cnt(0);
for(mcIdType k=0;k<nz;k++)
{
- mcIdType offz(k*nx*ny+i);
+ mcIdType const offz(k*nx*ny+i);
for(mcIdType j=0;j<ny;j++)
if(crit[offz+j*nx])
cnt++;
mcIdType cnt(0),offy(j*nx);
for(mcIdType k=0;k<nz;k++)
{
- mcIdType offz(k*nx*ny+offy);
+ mcIdType const offz(k*nx*ny+offy);
for(mcIdType i=0;i<nx;i++)
if(crit[offz+i])
cnt++;
mcIdType cnt(0),offz(k*nx*ny);
for(mcIdType j=0;j<ny;j++)
{
- mcIdType offy(offz+j*nx);
+ mcIdType const offy(offz+j*nx);
for(mcIdType i=0;i<nx;i++)
if(crit[offy+i])
cnt++;
DataArrayIdType *MEDCouplingStructuredMesh::Build1GTNodalConnectivity1D(const mcIdType *nodeStBg)
{
- mcIdType nbOfCells=*nodeStBg-1;
+ mcIdType const nbOfCells=*nodeStBg-1;
MCAuto<DataArrayIdType> conn(DataArrayIdType::New());
conn->alloc(2*nbOfCells,1);
mcIdType *cp=conn->getPointer();
for(mcIdType j=0;j<n2;j++)
for(mcIdType i=0;i<n1;i++,pos++)
{
- mcIdType tmp=(n1+1)*(n2+1);
+ mcIdType const tmp=(n1+1)*(n2+1);
cp[8*pos+0]=i+1+j*(n1+1)+k*tmp;
cp[8*pos+1]=i+j*(n1+1)+k*tmp;
cp[8*pos+2]=i+(j+1)*(n1+1)+k*tmp;
}
if(ret==0)
{
- std::size_t sz(st.size());
+ std::size_t const sz(st.size());
partCompactFormat.resize(sz);
for(std::size_t i=0;i<sz;i++)
{
}
if(ret==0)
{
- std::size_t sz(st.size());
+ std::size_t const sz(st.size());
partCompactFormat.resize(sz);
for(std::size_t i=0;i<sz;i++)
{
}
if(ret==0)
{
- std::size_t sz(st.size());
+ std::size_t const sz(st.size());
partCompactFormat.resize(sz);
for(std::size_t i=0;i<sz;i++)
{
*/
int MEDCouplingStructuredMesh::ZipNodeStructure(const mcIdType *nodeStBg, const mcIdType *nodeStEnd, mcIdType zipNodeSt[3])
{
- std::size_t spaceDim(std::distance(nodeStBg,nodeStEnd));
+ std::size_t const spaceDim(std::distance(nodeStBg,nodeStEnd));
if(spaceDim>3 || spaceDim<1)
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::ZipNodeStructure : spaceDim must in [1,2,3] !");
zipNodeSt[0]=0; zipNodeSt[1]=0; zipNodeSt[2]=0;
int zippedI(0);
for(std::size_t i=0;i<spaceDim;i++)
{
- mcIdType elt(nodeStBg[i]);
+ mcIdType const elt(nodeStBg[i]);
if(elt<1)
{
std::ostringstream oss; oss << "MEDCouplingStructuredMesh::ZipNodeStructure : the input nodal structure at pos#" << i << "(" << nodeStBg[i] << ") is invalid !";
{
std::vector<mcIdType> ngs(2);
mcIdType n0(nodeStBg[0]-1),n1(nodeStBg[1]-1); ngs[0]=n0; ngs[1]=n1;
- mcIdType off0(nodeStBg[0]);
+ mcIdType const off0(nodeStBg[0]);
MCAuto<DataArrayIdType> conn(DataArrayIdType::New());
conn->alloc(2*GetNumberOfCellsOfSubLevelMesh(ngs,2));
mcIdType *cp(conn->getPointer());
{
mcIdType tmp[3]={i,j,k};
mcIdType tmp2[3];
- mcIdType meshDim(getMeshDimension());
+ mcIdType const meshDim(getMeshDimension());
getSplitCellValues(tmp2);
std::transform(tmp,tmp+meshDim,tmp2,tmp,std::multiplies<mcIdType>());
return std::accumulate(tmp,tmp+meshDim,0);
{
mcIdType tmp[3]={i,j,k};
mcIdType tmp2[3];
- mcIdType spaceDim(getSpaceDimension());
+ mcIdType const spaceDim(getSpaceDimension());
getSplitNodeValues(tmp2);
std::transform(tmp,tmp+spaceDim,tmp2,tmp,std::multiplies<mcIdType>());
return std::accumulate(tmp,tmp+spaceDim,0);
std::size_t ii(0);
for(std::vector<mcIdType>::const_iterator it=ngs.begin();it!=ngs.end();it++,ii++)
{
- mcIdType elt(*it);
+ mcIdType const elt(*it);
if(elt<=0)
{
std::ostringstream oss; oss << "MEDCouplingStructuredMesh::getNumberOfCells : at pos #" << ii << " the number of nodes in nodeStructure is " << *it << " ! Must be > 0 !";
mcIdType MEDCouplingStructuredMesh::getNumberOfNodes() const
{
- std::vector<mcIdType> ngs(getNodeGridStructure());
+ std::vector<mcIdType> const ngs(getNodeGridStructure());
mcIdType ret(1);
- for(std::vector<mcIdType>::const_iterator it=ngs.begin();it!=ngs.end();it++)
- ret*=*it;
+ for(long const ng : ngs)
+ ret*=ng;
return ret;
}
*/
std::vector<mcIdType> MEDCouplingStructuredMesh::getLocationFromCellId(mcIdType cellId) const
{
- int meshDim(getMeshDimension());
+ int const meshDim(getMeshDimension());
std::vector<mcIdType> ret(meshDim);
std::vector<mcIdType> struc(getCellGridStructure());
- mcIdType nbCells(std::accumulate(struc.begin(),struc.end(),1,std::multiplies<mcIdType>()));
+ mcIdType const nbCells(std::accumulate(struc.begin(),struc.end(),1,std::multiplies<mcIdType>()));
if(cellId<0 || cellId>=nbCells)
{
std::ostringstream oss; oss << "MEDCouplingStructuredMesh::getLocationFromCellId : Input cell id (" << cellId << ") is invalid ! Should be in [0," << nbCells << ") !";
*/
std::vector<mcIdType> MEDCouplingStructuredMesh::getLocationFromNodeId(mcIdType nodeId) const
{
- int spaceDim(getSpaceDimension());
+ int const spaceDim(getSpaceDimension());
std::vector<mcIdType> ret(spaceDim);
std::vector<mcIdType> struc(getNodeGridStructure());
- mcIdType nbNodes(std::accumulate(struc.begin(),struc.end(),1,std::multiplies<mcIdType>()));
+ mcIdType const nbNodes(std::accumulate(struc.begin(),struc.end(),1,std::multiplies<mcIdType>()));
if(nodeId<0 || nodeId>=nbNodes)
{
std::ostringstream oss; oss << "MEDCouplingStructuredMesh::getLocationFromNodeId : Input node id (" << nodeId << ") is invalid ! Should be in [0," << nbNodes << ") !";
mcIdType work(eltId);
for(int i=meshDim-1;i>=0;i--)
{
- mcIdType pos=work/split[i];
+ mcIdType const pos=work/split[i];
work=work%split[i];
res[i]=pos;
}
std::vector<mcIdType> cgs(getCellGridStructure());
if(cgs.empty())
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::computeSquareness : empty mesh !");
- std::size_t dim(cgs.size());
+ std::size_t const dim(cgs.size());
if(dim==1)
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::computeSquareness : A segment cannot be square !");
if(dim<4)
*/
std::vector<mcIdType> MEDCouplingStructuredMesh::GetSplitVectFromStruct(const std::vector<mcIdType>& strct)
{
- std::size_t spaceDim(strct.size());
+ std::size_t const spaceDim(strct.size());
std::vector<mcIdType> res(spaceDim);
for(std::size_t l=0;l<spaceDim;l++)
{
*/
bool MEDCouplingStructuredMesh::IsPartStructured(const mcIdType *startIds, const mcIdType *stopIds, const std::vector<mcIdType>& st, std::vector< std::pair<mcIdType,mcIdType> >& partCompactFormat)
{
- int dim((int)st.size());
+ int const dim((int)st.size());
partCompactFormat.resize(dim);
if(dim<1 || dim>3)
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::isPartStructured : input structure must be of dimension in [1,2,3] !");
std::vector<mcIdType> tmp2(dim),tmp(dim),tmp3(dim),tmp4(dim); tmp2[0]=1;
for(int i=1;i<dim;i++)
tmp2[i]=tmp2[i-1]*st[i-1];
- std::size_t sz(std::distance(startIds,stopIds));
+ std::size_t const sz(std::distance(startIds,stopIds));
if(sz==0)
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::IsPartStructured : empty input !");
GetPosFromId(*startIds,dim,&tmp2[0],&tmp[0]);
{
for(mcIdType i=0;i<tmp4[2];i++)
{
- mcIdType a=tmp2[2]*(partCompactFormat[2].first+i);
+ mcIdType const a=tmp2[2]*(partCompactFormat[2].first+i);
for(mcIdType j=0;j<tmp4[1];j++)
{
- mcIdType b=tmp2[1]*(partCompactFormat[1].first+j);
+ mcIdType const b=tmp2[1]*(partCompactFormat[1].first+j);
for(mcIdType k=0;k<tmp4[0];k++,w++)
{
if(partCompactFormat[0].first+k+b+a!=*w)
{
for(mcIdType j=0;j<tmp4[1];j++)
{
- mcIdType b=tmp2[1]*(partCompactFormat[1].first+j);
+ mcIdType const b=tmp2[1]*(partCompactFormat[1].first+j);
for(mcIdType k=0;k<tmp4[0];k++,w++)
{
if(partCompactFormat[0].first+k+b!=*w)
*/
std::vector< std::pair<mcIdType,mcIdType> > MEDCouplingStructuredMesh::GetCompactFrmtFromDimensions(const std::vector<mcIdType>& dims)
{
- std::size_t sz(dims.size());
+ std::size_t const sz(dims.size());
std::vector< std::pair<mcIdType,mcIdType> > ret(sz);
for(std::size_t i=0;i<sz;i++)
{
*/
std::vector< std::pair<mcIdType,mcIdType> > MEDCouplingStructuredMesh::IntersectRanges(const std::vector< std::pair<mcIdType,mcIdType> >& r1, const std::vector< std::pair<mcIdType,mcIdType> >& r2)
{
- std::size_t sz(r1.size());
+ std::size_t const sz(r1.size());
if(sz!=r2.size())
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::IntersectRanges : the two ranges must have the same dimension !");
std::vector< std::pair<mcIdType,mcIdType> > ret(sz);
*/
bool MEDCouplingStructuredMesh::AreRangesIntersect(const std::vector< std::pair<mcIdType,mcIdType> >& r1, const std::vector< std::pair<mcIdType,mcIdType> >& r2)
{
- std::size_t sz(r1.size());
+ std::size_t const sz(r1.size());
if(sz!=r2.size())
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::AreRangesIntersect : the two ranges must have the same dimension !");
for(std::size_t i=0;i<sz;i++)
{
for(mcIdType i=0;i<dims[2];i++)
{
- mcIdType a=(partCompactFormat[2].first+i)*st[0]*st[1];
+ mcIdType const a=(partCompactFormat[2].first+i)*st[0]*st[1];
for(mcIdType j=0;j<dims[1];j++)
{
- mcIdType b=(partCompactFormat[1].first+j)*st[0];
+ mcIdType const b=(partCompactFormat[1].first+j)*st[0];
for(mcIdType k=0;k<dims[0];k++)
vectToSwitchOn[partCompactFormat[0].first+k+b+a]=true;
}
{
for(mcIdType j=0;j<dims[1];j++)
{
- mcIdType b=(partCompactFormat[1].first+j)*st[0];
+ mcIdType const b=(partCompactFormat[1].first+j)*st[0];
for(mcIdType k=0;k<dims[0];k++)
vectToSwitchOn[partCompactFormat[0].first+k+b]=true;
}
if(ToIdType(fieldOfBool.size())!=DeduceNumberOfGivenStructure(st))
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::ExtractFieldOfBoolFrom : invalid size of input field of boolean regarding the structure !");
std::vector<mcIdType> dims(GetDimensionsFromCompactFrmt(partCompactFormat));
- mcIdType nbOfTuplesOfOutField(DeduceNumberOfGivenStructure(dims));
+ mcIdType const nbOfTuplesOfOutField(DeduceNumberOfGivenStructure(dims));
fieldOut.resize(nbOfTuplesOfOutField);
mcIdType it(0);
switch(st.size())
{
for(mcIdType i=0;i<dims[2];i++)
{
- mcIdType a=(partCompactFormat[2].first+i)*st[0]*st[1];
+ mcIdType const a=(partCompactFormat[2].first+i)*st[0]*st[1];
for(mcIdType j=0;j<dims[1];j++)
{
- mcIdType b=(partCompactFormat[1].first+j)*st[0];
+ mcIdType const b=(partCompactFormat[1].first+j)*st[0];
for(mcIdType k=0;k<dims[0];k++)
fieldOut[it++]=fieldOfBool[partCompactFormat[0].first+k+b+a];
}
{
for(mcIdType j=0;j<dims[1];j++)
{
- mcIdType b=(partCompactFormat[1].first+j)*st[0];
+ mcIdType const b=(partCompactFormat[1].first+j)*st[0];
for(mcIdType k=0;k<dims[0];k++)
fieldOut[it++]=fieldOfBool[partCompactFormat[0].first+k+b];
}
if(fieldOfDbl->getNumberOfTuples()!=DeduceNumberOfGivenStructure(st))
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::ExtractFieldOfDoubleFrom : invalid size of input array of double regarding the structure !");
std::vector<mcIdType> dims(GetDimensionsFromCompactFrmt(partCompactFormat));
- mcIdType nbOfTuplesOfOutField(DeduceNumberOfGivenStructure(dims));
- std::size_t nbComp(fieldOfDbl->getNumberOfComponents());
+ mcIdType const nbOfTuplesOfOutField(DeduceNumberOfGivenStructure(dims));
+ std::size_t const nbComp(fieldOfDbl->getNumberOfComponents());
MCAuto<DataArrayDouble> ret(DataArrayDouble::New()); ret->alloc(nbOfTuplesOfOutField,nbComp);
ret->copyStringInfoFrom(*fieldOfDbl);
double *ptRet(ret->getPointer());
{
for(mcIdType i=0;i<dims[2];i++)
{
- mcIdType a=(partCompactFormat[2].first+i)*st[0]*st[1];
+ mcIdType const a=(partCompactFormat[2].first+i)*st[0]*st[1];
for(mcIdType j=0;j<dims[1];j++)
{
- mcIdType b=(partCompactFormat[1].first+j)*st[0];
+ mcIdType const b=(partCompactFormat[1].first+j)*st[0];
for(mcIdType k=0;k<dims[0];k++)
ptRet=std::copy(fieldOfDblPtr+(partCompactFormat[0].first+k+b+a)*nbComp,fieldOfDblPtr+(partCompactFormat[0].first+k+b+a+1)*nbComp,ptRet);
}
{
for(mcIdType j=0;j<dims[1];j++)
{
- mcIdType b=(partCompactFormat[1].first+j)*st[0];
+ mcIdType const b=(partCompactFormat[1].first+j)*st[0];
for(mcIdType k=0;k<dims[0];k++)
ptRet=std::copy(fieldOfDblPtr+(partCompactFormat[0].first+k+b)*nbComp,fieldOfDblPtr+(partCompactFormat[0].first+k+b+1)*nbComp,ptRet);
}
*/
void MEDCouplingStructuredMesh::AssignPartOfFieldOfDoubleUsing(const std::vector<mcIdType>& st, DataArrayDouble *fieldOfDbl, const std::vector< std::pair<mcIdType,mcIdType> >& partCompactFormat, const DataArrayDouble *other)
{//to be optimized
- std::vector<mcIdType> facts(st.size(),1);
+ std::vector<mcIdType> const facts(st.size(),1);
MEDCouplingIMesh::CondenseFineToCoarse(st,other,partCompactFormat,facts,fieldOfDbl);
}
*/
void MEDCouplingStructuredMesh::ChangeReferenceFromGlobalOfCompactFrmt(const std::vector< std::pair<mcIdType,mcIdType> >& bigInAbs, const std::vector< std::pair<mcIdType,mcIdType> >& partOfBigInAbs, std::vector< std::pair<mcIdType,mcIdType> >& partOfBigRelativeToBig, bool check)
{
- std::size_t dim(bigInAbs.size());
+ std::size_t const dim(bigInAbs.size());
if(dim!=partOfBigInAbs.size())
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::ChangeReferenceFromGlobalOfCompactFrmt : The size of parts (dimension) must be the same !");
partOfBigRelativeToBig.resize(dim);
*/
void MEDCouplingStructuredMesh::ChangeReferenceToGlobalOfCompactFrmt(const std::vector< std::pair<mcIdType,mcIdType> >& bigInAbs, const std::vector< std::pair<mcIdType,mcIdType> >& partOfBigRelativeToBig, std::vector< std::pair<mcIdType,mcIdType> >& partOfBigInAbs, bool check)
{
- std::size_t dim(bigInAbs.size());
+ std::size_t const dim(bigInAbs.size());
if(dim!=partOfBigRelativeToBig.size())
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::ChangeReferenceToGlobalOfCompactFrmt : The size of parts (dimension) must be the same !");
partOfBigInAbs.resize(dim);
*/
std::vector< std::pair<mcIdType,mcIdType> > MEDCouplingStructuredMesh::TranslateCompactFrmt(const std::vector< std::pair<mcIdType,mcIdType> >& part, const std::vector<mcIdType>& translation)
{
- std::size_t sz(part.size());
+ std::size_t const sz(part.size());
if(translation.size()!=sz)
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::TranslateCompactFrmt : the sizes are not equal !");
std::vector< std::pair<mcIdType,mcIdType> > ret(sz);
*/
std::vector<mcIdType> MEDCouplingStructuredMesh::FindTranslationFrom(const std::vector< std::pair<mcIdType,mcIdType> >& startingFrom, const std::vector< std::pair<mcIdType,mcIdType> >& goingTo)
{
- std::size_t sz(startingFrom.size());
+ std::size_t const sz(startingFrom.size());
if(goingTo.size()!=sz)
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::FindTranslationFrom : the sizes are not equal !");
std::vector< mcIdType > ret(sz);
{
for(mcIdType i=0;i<dims[2];i++)
{
- mcIdType a=(partCompactFormat[2].first+i)*st[0]*st[1];
+ mcIdType const a=(partCompactFormat[2].first+i)*st[0]*st[1];
for(mcIdType j=0;j<dims[1];j++)
{
- mcIdType b=(partCompactFormat[1].first+j)*st[0];
+ mcIdType const b=(partCompactFormat[1].first+j)*st[0];
for(mcIdType k=0;k<dims[0];k++,pt++)
*pt=partCompactFormat[0].first+k+b+a;
}
{
for(mcIdType j=0;j<dims[1];j++)
{
- mcIdType b=(partCompactFormat[1].first+j)*st[0];
+ mcIdType const b=(partCompactFormat[1].first+j)*st[0];
for(mcIdType k=0;k<dims[0];k++,pt++)
*pt=partCompactFormat[0].first+k+b;
}
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::MultiplyPartOf : invalid input range 3 !");
dims[i]=part[i].second-part[i].first;
}
- mcIdType nbOfTuplesExp(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(st));
- std::size_t nbCompo(da->getNumberOfComponents());
+ mcIdType const nbOfTuplesExp(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(st));
+ std::size_t const nbCompo(da->getNumberOfComponents());
if(da->getNumberOfTuples()!=nbOfTuplesExp)
{
std::ostringstream oss; oss << "MEDCouplingStructuredMesh::MultiplyPartOf : invalid nb of tuples ! Expected " << nbOfTuplesExp << " having " << da->getNumberOfTuples() << " !";
{
for(mcIdType i=0;i<dims[2];i++)
{
- mcIdType a=(part[2].first+i)*st[0]*st[1];
+ mcIdType const a=(part[2].first+i)*st[0]*st[1];
for(mcIdType j=0;j<dims[1];j++)
{
- mcIdType b=(part[1].first+j)*st[0];
+ mcIdType const b=(part[1].first+j)*st[0];
for(mcIdType k=0;k<dims[0];k++)
{
- mcIdType offset(part[0].first+k+b+a);
+ mcIdType const offset(part[0].first+k+b+a);
std::transform(pt+nbCompo*offset,pt+nbCompo*(offset+1),pt+nbCompo*offset,std::bind(std::multiplies<double>(),std::placeholders::_1,factor));
}
}
{
for(mcIdType j=0;j<dims[1];j++)
{
- mcIdType b=(part[1].first+j)*st[0];
+ mcIdType const b=(part[1].first+j)*st[0];
for(mcIdType k=0;k<dims[0];k++)
{
- mcIdType offset(part[0].first+k+b);
+ mcIdType const offset(part[0].first+k+b);
std::transform(pt+nbCompo*offset,pt+nbCompo*(offset+1),pt+nbCompo*offset,std::bind(std::multiplies<double>(),std::placeholders::_1,factor));
}
}
{
for(mcIdType k=0;k<dims[0];k++)
{
- mcIdType offset(part[0].first+k);
+ mcIdType const offset(part[0].first+k);
std::transform(pt+nbCompo*offset,pt+nbCompo*(offset+1),pt+nbCompo*offset,std::bind(std::multiplies<double>(),std::placeholders::_1,factor));
}
break;
{
if(ghostSize<0)
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::PutInGhostFormat : ghost size must be >= 0 !");
- std::size_t dim(part.size());
+ std::size_t const dim(part.size());
if(st.size()!=dim)
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::PutInGhostFormat : the dimension of input vectors must be the same !");
for(std::size_t i=0;i<dim;i++)
{
if(ghostSize<0)
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::ApplyGhostOnCompactFrmt : ghost size must be >= 0 !");
- std::size_t sz(partBeforeFact.size());
+ std::size_t const sz(partBeforeFact.size());
for(std::size_t i=0;i<sz;i++)
{
partBeforeFact[i].first+=ghostSize;
#ifndef __PARAMEDMEM_MEDCOUPLINGSTRUCTUREDMESH_HXX__
#define __PARAMEDMEM_MEDCOUPLINGSTRUCTUREDMESH_HXX__
+#include "MCType.hxx"
#include "MEDCoupling.hxx"
#include "MEDCouplingMesh.hxx"
+#include "NormalizedGeometricTypes"
+#include <set>
+#include <vector>
+#include <cstddef>
+#include <string>
+#include <utility>
namespace MEDCoupling
{
class MEDCouplingStructuredMesh : public MEDCouplingMesh
{
public:
- MEDCOUPLING_EXPORT INTERP_KERNEL::NormalizedCellType getTypeOfCell(mcIdType cellId) const;
- MEDCOUPLING_EXPORT std::set<INTERP_KERNEL::NormalizedCellType> getAllGeoTypes() const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType type) const;
- MEDCOUPLING_EXPORT DataArrayIdType *giveCellsWithType(INTERP_KERNEL::NormalizedCellType type) const;
- MEDCOUPLING_EXPORT DataArrayIdType *computeNbOfNodesPerCell() const;
- MEDCOUPLING_EXPORT DataArrayIdType *computeNbOfFacesPerCell() const;
- MEDCOUPLING_EXPORT DataArrayIdType *computeEffectiveNbOfNodesPerCell() const;
+ MEDCOUPLING_EXPORT INTERP_KERNEL::NormalizedCellType getTypeOfCell(mcIdType cellId) const override;
+ MEDCOUPLING_EXPORT std::set<INTERP_KERNEL::NormalizedCellType> getAllGeoTypes() const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType type) const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *giveCellsWithType(INTERP_KERNEL::NormalizedCellType type) const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *computeNbOfNodesPerCell() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *computeNbOfFacesPerCell() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *computeEffectiveNbOfNodesPerCell() const override;
MEDCOUPLING_EXPORT std::vector<mcIdType> getLocationFromCellId(mcIdType cellId) const;
MEDCOUPLING_EXPORT std::vector<mcIdType> getLocationFromNodeId(mcIdType nodeId) const;
MEDCOUPLING_EXPORT static void GetPosFromId(mcIdType eltId, int meshDim, const mcIdType *split, mcIdType *res);
MEDCOUPLING_EXPORT static INTERP_KERNEL::NormalizedCellType GetGeoTypeGivenMeshDimension( int meshDim);
- MEDCOUPLING_EXPORT void getNodeIdsOfCell(mcIdType cellId, std::vector<mcIdType>& conn) const;
- MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDCOUPLING_EXPORT void copyTinyStringsFrom(const MEDCouplingMesh *other);
- MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const;
+ MEDCOUPLING_EXPORT void getNodeIdsOfCell(mcIdType cellId, std::vector<mcIdType>& conn) const override;
+ MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDCOUPLING_EXPORT void copyTinyStringsFrom(const MEDCouplingMesh *other) override;
+ MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const override;
//tools
- MEDCOUPLING_EXPORT std::vector<mcIdType> getDistributionOfTypes() const;
- MEDCOUPLING_EXPORT DataArrayIdType *checkTypeConsistencyAndContig(const std::vector<mcIdType>& code, const std::vector<const DataArrayIdType *>& idsPerType) const;
- MEDCOUPLING_EXPORT void splitProfilePerType(const DataArrayIdType *profile, std::vector<mcIdType>& code, std::vector<DataArrayIdType *>& idsInPflPerType, std::vector<DataArrayIdType *>& idsPerType, bool smartPflKiller=true) const;
+ MEDCOUPLING_EXPORT std::vector<mcIdType> getDistributionOfTypes() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *checkTypeConsistencyAndContig(const std::vector<mcIdType>& code, const std::vector<const DataArrayIdType *>& idsPerType) const override;
+ MEDCOUPLING_EXPORT void splitProfilePerType(const DataArrayIdType *profile, std::vector<mcIdType>& code, std::vector<DataArrayIdType *>& idsInPflPerType, std::vector<DataArrayIdType *>& idsPerType, bool smartPflKiller=true) const override;
MEDCOUPLING_EXPORT MEDCoupling1SGTUMesh *build1SGTUnstructured() const;
- MEDCOUPLING_EXPORT MEDCouplingUMesh *buildUnstructured() const;
- MEDCOUPLING_EXPORT MEDCouplingMesh *buildPart(const mcIdType *start, const mcIdType *end) const;
- MEDCOUPLING_EXPORT MEDCouplingMesh *buildPartAndReduceNodes(const mcIdType *start, const mcIdType *end, DataArrayIdType*& arr) const;
- MEDCOUPLING_EXPORT DataArrayIdType *simplexize(int policy);
- MEDCOUPLING_EXPORT MEDCouplingFieldDouble *buildOrthogonalField() const;
- MEDCOUPLING_EXPORT void getReverseNodalConnectivity(DataArrayIdType *revNodal, DataArrayIdType *revNodalIndx) const;
+ MEDCOUPLING_EXPORT MEDCouplingUMesh *buildUnstructured() const override;
+ MEDCOUPLING_EXPORT MEDCouplingMesh *buildPart(const mcIdType *start, const mcIdType *end) const override;
+ MEDCOUPLING_EXPORT MEDCouplingMesh *buildPartAndReduceNodes(const mcIdType *start, const mcIdType *end, DataArrayIdType*& arr) const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *simplexize(int policy) override;
+ MEDCOUPLING_EXPORT MEDCouplingFieldDouble *buildOrthogonalField() const override;
+ MEDCOUPLING_EXPORT void getReverseNodalConnectivity(DataArrayIdType *revNodal, DataArrayIdType *revNodalIndx) const override;
//some useful methods
MEDCOUPLING_EXPORT MEDCoupling1SGTUMesh *build1SGTSubLevelMesh() const;
MEDCOUPLING_EXPORT mcIdType getCellIdFromPos(mcIdType i, mcIdType j, mcIdType k) const;
MEDCOUPLING_EXPORT mcIdType getNodeIdFromPos(mcIdType i, mcIdType j, mcIdType k) const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfCells() const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfNodes() const;
- MEDCOUPLING_EXPORT int getMeshDimension() const;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfCells() const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfNodes() const override;
+ MEDCOUPLING_EXPORT int getMeshDimension() const override;
MEDCOUPLING_EXPORT mcIdType getNumberOfCellsOfSubLevelMesh() const;
MEDCOUPLING_EXPORT int getSpaceDimensionOnNodeStruct() const;
MEDCOUPLING_EXPORT virtual void getNodeGridStructure(mcIdType *res) const = 0;
protected:
MEDCOUPLING_EXPORT MEDCouplingStructuredMesh();
MEDCOUPLING_EXPORT MEDCouplingStructuredMesh(const MEDCouplingStructuredMesh& other, bool deepCpy);
- MEDCOUPLING_EXPORT ~MEDCouplingStructuredMesh();
+ MEDCOUPLING_EXPORT ~MEDCouplingStructuredMesh() override;
};
}
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingTimeDiscretization.txx"
+
#include "MCAuto.hxx"
+#include "MCIdType.hxx"
+#include "MCType.hxx"
#include "MEDCouplingMemArray.hxx"
#include "MEDCouplingMesh.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingTimeLabel.hxx"
-#include <iterator>
+#include <cmath>
+#include <cstddef>
#include <algorithm>
#include <functional>
+#include <string>
+#include <sstream>
+#include <vector>
using namespace MEDCoupling;
{
if(std::fabs(_time_tolerance-other->_time_tolerance)>1.e-16)
return false;
- if(_array==0 && other->_array==0)
+ if(_array==nullptr && other->_array==nullptr)
return true;
- if(_array==0 || other->_array==0)
+ if(_array==nullptr || other->_array==nullptr)
return false;
if(_array->getNumberOfTuples()!=other->_array->getNumberOfTuples())
return false;
MCAuto<DataArrayDouble> arr;
if(arrSrc)
arr=arrSrc->performCopyOrIncrRef(deepCopy);
- ret->setArray(arr,0);
+ ret->setArray(arr,nullptr);
return ret;
}
bool MEDCouplingTimeDiscretization::isBefore(const MEDCouplingTimeDiscretization *other) const
{
int iteration,order;
- double time1=getEndTime(iteration,order)-_time_tolerance;
- double time2=other->getStartTime(iteration,order)+other->getTimeTolerance();
+ double const time1=getEndTime(iteration,order)-_time_tolerance;
+ double const time2=other->getStartTime(iteration,order)+other->getTimeTolerance();
return time1<=time2;
}
bool MEDCouplingTimeDiscretization::isStrictlyBefore(const MEDCouplingTimeDiscretization *other) const
{
int iteration,order;
- double time1=getEndTime(iteration,order)+_time_tolerance;
- double time2=other->getStartTime(iteration,order)-other->getTimeTolerance();
+ double const time1=getEndTime(iteration,order)+_time_tolerance;
+ double const time2=other->getStartTime(iteration,order)-other->getTimeTolerance();
return time1<time2;
}
std::vector<DataArrayDouble *> arrays3(arrays.size());
for(std::size_t j=0;j<arrays.size();j++)
arrays3[j]=arrays2[j];
- ret->setArrays(arrays3,0);
+ ret->setArrays(arrays3,nullptr);
return ret;
}
std::vector<DataArrayDouble *> arrays3(arrays.size());
for(std::size_t j=0;j<arrays.size();j++)
arrays3[j]=arrays2[j];
- ret->setArrays(arrays3,0);
+ ret->setArrays(arrays3,nullptr);
return ret;
}
arrays3[j]=arrays2[j];
MEDCouplingTimeDiscretization *ret(MEDCouplingTimeDiscretization::New(getEnum()));
ret->setTimeUnit(getTimeUnit());
- ret->setArrays(arrays3,0);
+ ret->setArrays(arrays3,nullptr);
return ret;
}
arrays3[j]=arrays2[j];
MEDCouplingTimeDiscretization *ret(MEDCouplingTimeDiscretization::New(getEnum()));
ret->setTimeUnit(getTimeUnit());
- ret->setArrays(arrays3,0);
+ ret->setArrays(arrays3,nullptr);
return ret;
}
arrays3[j]=arrays2[j];
MEDCouplingTimeDiscretization *ret(MEDCouplingTimeDiscretization::New(getEnum()));
ret->setTimeUnit(getTimeUnit());
- ret->setArrays(arrays3,0);
+ ret->setArrays(arrays3,nullptr);
return ret;
}
arrays3[j]=arrays2[j];
MEDCouplingTimeDiscretization *ret(MEDCouplingTimeDiscretization::New(getEnum()));
ret->setTimeUnit(getTimeUnit());
- ret->setArrays(arrays3,0);
+ ret->setArrays(arrays3,nullptr);
return ret;
}
arrays3[j]=arrays2[j];
MEDCouplingTimeDiscretization *ret(MEDCouplingTimeDiscretization::New(getEnum()));
ret->setTimeUnit(getTimeUnit());
- ret->setArrays(arrays3,0);
+ ret->setArrays(arrays3,nullptr);
return ret;
}
arrays3[j]=arrays2[j];
MEDCouplingTimeDiscretization *ret(MEDCouplingTimeDiscretization::New(getEnum()));
ret->setTimeUnit(getTimeUnit());
- ret->setArrays(arrays3,0);
+ ret->setArrays(arrays3,nullptr);
return ret;
}
arrays3[j]=arrays2[j];
MEDCouplingTimeDiscretization *ret(MEDCouplingTimeDiscretization::New(getEnum()));
ret->setTimeUnit(getTimeUnit());
- ret->setArrays(arrays3,0);
+ ret->setArrays(arrays3,nullptr);
return ret;
}
arrays3[j]=arrays2[j];
MEDCouplingTimeDiscretization *ret(MEDCouplingTimeDiscretization::New(getEnum()));
ret->setTimeUnit(getTimeUnit());
- ret->setArrays(arrays3,0);
+ ret->setArrays(arrays3,nullptr);
return ret;
}
arrays3[j]=arrays2[j];
MEDCouplingTimeDiscretization *ret(MEDCouplingTimeDiscretization::New(getEnum()));
ret->setTimeUnit(getTimeUnit());
- ret->setArrays(arrays3,0);
+ ret->setArrays(arrays3,nullptr);
return ret;
}
arrays3[j]=arrays2[j];
MEDCouplingTimeDiscretization *ret(MEDCouplingTimeDiscretization::New(getEnum()));
ret->setTimeUnit(getTimeUnit());
- ret->setArrays(arrays3,0);
+ ret->setArrays(arrays3,nullptr);
return ret;
}
throw INTERP_KERNEL::Exception("TimeDiscretization::setSelectedComponents : number of arrays mismatch !");
for(std::size_t i=0;i<arrays1.size();i++)
{
- if(arrays1[i]!=0 && arrays2[i]!=0)
+ if(arrays1[i]!=nullptr && arrays2[i]!=nullptr)
arrays1[i]->setSelectedComponents(arrays2[i],compoIds);
- else if(arrays1[i]!=0 || arrays2[i]!=0)
+ else if(arrays1[i]!=nullptr || arrays2[i]!=nullptr)
throw INTERP_KERNEL::Exception("TimeDiscretization::setSelectedComponents : some time array in correspondence are not defined symmetrically !");
}
}
std::vector<DataArrayDouble *> arrays3(arrays.size());
for(std::size_t j=0;j<arrays.size();j++)
arrays3[j]=arrays2[j];
- setArrays(arrays3,0);
+ setArrays(arrays3,nullptr);
}
void MEDCouplingTimeDiscretization::sortPerTuple(bool asc)
{
std::vector<DataArrayDouble *> arrays;
getArrays(arrays);
- for(std::size_t j=0;j<arrays.size();j++)
+ for(auto & array : arrays)
{
- if(arrays[j])
- arrays[j]->sortPerTuple(asc);
+ if(array)
+ array->sortPerTuple(asc);
}
}
std::vector<DataArrayDouble *> arrays3(arrays.size());
for(std::size_t j=0;j<arrays.size();j++)
arrays3[j]=arrays2[j];
- setArrays(arrays3,0);
+ setArrays(arrays3,nullptr);
}
void MEDCouplingTimeDiscretization::setOrCreateUniformValueOnAllComponents(mcIdType nbOfTuple, double value)
std::vector<DataArrayDouble *> arrays3(arrays.size());
for(std::size_t j=0;j<arrays.size();j++)
arrays3[j]=arrays2[j];
- setArrays(arrays3,0);
+ setArrays(arrays3,nullptr);
}
}
{
std::vector<DataArrayDouble *> arrays;
getArrays(arrays);
- for(std::size_t j=0;j<arrays.size();j++)
+ for(auto & array : arrays)
{
- if(arrays[j])
- arrays[j]->applyLin(a,b,compoId);
+ if(array)
+ array->applyLin(a,b,compoId);
}
}
{
std::vector<DataArrayDouble *> arrays;
getArrays(arrays);
- for(std::size_t j=0;j<arrays.size();j++)
+ for(auto & array : arrays)
{
- if(arrays[j])
- arrays[j]->applyLin(a,b);
+ if(array)
+ array->applyLin(a,b);
}
}
std::vector<DataArrayDouble *> arrays3(arrays.size());
for(std::size_t j=0;j<arrays.size();j++)
arrays3[j]=arrays2[j];
- setArrays(arrays3,0);
+ setArrays(arrays3,nullptr);
}
void MEDCouplingTimeDiscretization::applyFunc(int nbOfComp, const std::string& func)
if(arrays[j])
arrays2[j]=arrays[j]->applyFunc(nbOfComp,func);
else
- arrays2[j]=0;
+ arrays2[j]=nullptr;
}
std::vector<DataArrayDouble *> arrays3(arrays.size());
for(std::size_t j=0;j<arrays.size();j++)
arrays3[j]=arrays2[j];
- setArrays(arrays3,0);
+ setArrays(arrays3,nullptr);
}
void MEDCouplingTimeDiscretization::applyFuncCompo(int nbOfComp, const std::string& func)
std::vector<DataArrayDouble *> arrays3(arrays.size());
for(std::size_t j=0;j<arrays.size();j++)
arrays3[j]=arrays2[j];
- setArrays(arrays3,0);
+ setArrays(arrays3,nullptr);
}
void MEDCouplingTimeDiscretization::applyFuncNamedCompo(int nbOfComp, const std::vector<std::string>& varsOrder, const std::string& func)
std::vector<DataArrayDouble *> arrays3(arrays.size());
for(std::size_t j=0;j<arrays.size();j++)
arrays3[j]=arrays2[j];
- setArrays(arrays3,0);
+ setArrays(arrays3,nullptr);
}
void MEDCouplingTimeDiscretization::applyFunc(const std::string& func)
std::vector<DataArrayDouble *> arrays3(arrays.size());
for(std::size_t j=0;j<arrays.size();j++)
arrays3[j]=arrays2[j];
- setArrays(arrays3,0);
+ setArrays(arrays3,nullptr);
}
void MEDCouplingTimeDiscretization::applyFuncFast32(const std::string& func)
{
std::vector<DataArrayDouble *> arrays;
getArrays(arrays);
- for(std::size_t j=0;j<arrays.size();j++)
+ for(auto & array : arrays)
{
- if(arrays[j])
- arrays[j]->applyFuncFast32(func);
+ if(array)
+ array->applyFuncFast32(func);
}
}
{
std::vector<DataArrayDouble *> arrays;
getArrays(arrays);
- for(std::size_t j=0;j<arrays.size();j++)
+ for(auto & array : arrays)
{
- if(arrays[j])
- arrays[j]->applyFuncFast64(func);
+ if(array)
+ array->applyFuncFast64(func);
}
}
std::vector<DataArrayDouble *> arrays3(arrays.size());
for(std::size_t j=0;j<arrays.size();j++)
arrays3[j]=arrays2[j];
- setArrays(arrays3,0);
+ setArrays(arrays3,nullptr);
}
void MEDCouplingTimeDiscretization::fillFromAnalytic(const DataArrayDouble *loc, int nbOfComp, const std::string& func)
std::vector<DataArrayDouble *> arrays3(arrays.size());
for(std::size_t j=0;j<arrays.size();j++)
arrays3[j]=arrays2[j];
- setArrays(arrays3,0);
+ setArrays(arrays3,nullptr);
}
void MEDCouplingTimeDiscretization::fillFromAnalyticCompo(const DataArrayDouble *loc, int nbOfComp, const std::string& func)
std::vector<DataArrayDouble *> arrays3(arrays.size());
for(std::size_t j=0;j<arrays.size();j++)
arrays3[j]=arrays2[j];
- setArrays(arrays3,0);
+ setArrays(arrays3,nullptr);
}
void MEDCouplingTimeDiscretization::fillFromAnalyticNamedCompo(const DataArrayDouble *loc, int nbOfComp, const std::vector<std::string>& varsOrder, const std::string& func)
std::vector<DataArrayDouble *> arrays3(arrays.size());
for(std::size_t j=0;j<arrays.size();j++)
arrays3[j]=arrays2[j];
- setArrays(arrays3,0);
+ setArrays(arrays3,nullptr);
}
////////////////////////
reason="Time discretization is NULL.";
return false;
}
- const MEDCouplingTimeDiscretizationInt32 *otherC(dynamic_cast<const MEDCouplingTimeDiscretizationInt32 *>(other));
+ const auto *otherC(dynamic_cast<const MEDCouplingTimeDiscretizationInt32 *>(other));
if(!otherC)
throw INTERP_KERNEL::Exception("isEqualIfNotWhy : other is not a MEDCouplingTimeDiscretizationInt32 !");
if(!MEDCouplingTimeDiscretizationTemplate<Int32>::areStrictlyCompatible(other,reason))
{
if(prec!=0)
throw INTERP_KERNEL::Exception("MEDCouplingTimeDiscretizationInt32::isEqualWithoutConsideringStr : only precision 0 is supported !");
- const MEDCouplingTimeDiscretizationInt32 *otherC(dynamic_cast<const MEDCouplingTimeDiscretizationInt32 *>(other));
+ const auto *otherC(dynamic_cast<const MEDCouplingTimeDiscretizationInt32 *>(other));
if(!otherC)
throw INTERP_KERNEL::Exception("isEqualWithoutConsideringStr : other is not a MEDCouplingTimeDiscretizationInt !");
std::string tmp;
reason="Time discretization is NULL.";
return false;
}
- const MEDCouplingTimeDiscretizationInt64 *otherC(dynamic_cast<const MEDCouplingTimeDiscretizationInt64 *>(other));
+ const auto *otherC(dynamic_cast<const MEDCouplingTimeDiscretizationInt64 *>(other));
if(!otherC)
throw INTERP_KERNEL::Exception("isEqualIfNotWhy : other is not a MEDCouplingTimeDiscretizationInt64 !");
if(!MEDCouplingTimeDiscretizationTemplate<Int64>::areStrictlyCompatible(other,reason))
{
if(prec!=0)
throw INTERP_KERNEL::Exception("MEDCouplingTimeDiscretizationInt64::isEqualWithoutConsideringStr : only precision 0 is supported !");
- const MEDCouplingTimeDiscretizationInt64 *otherC(dynamic_cast<const MEDCouplingTimeDiscretizationInt64 *>(other));
+ const auto *otherC(dynamic_cast<const MEDCouplingTimeDiscretizationInt64 *>(other));
if(!otherC)
throw INTERP_KERNEL::Exception("isEqualWithoutConsideringStr : other is not a MEDCouplingTimeDiscretizationInt !");
std::string tmp;
reason="Time discretization is NULL.";
return false;
}
- const MEDCouplingTimeDiscretizationFloat *otherC(dynamic_cast<const MEDCouplingTimeDiscretizationFloat *>(other));
+ const auto *otherC(dynamic_cast<const MEDCouplingTimeDiscretizationFloat *>(other));
if(!otherC)
throw INTERP_KERNEL::Exception("isEqualIfNotWhy : other is not a MEDCouplingTimeDiscretizationFloat !");
if(!MEDCouplingTimeDiscretizationTemplate<float>::areStrictlyCompatible(other,reason))
{
if(prec!=0)
throw INTERP_KERNEL::Exception("MEDCouplingTimeDiscretizationFloat::isEqualWithoutConsideringStr : only precision 0 is supported !");
- const MEDCouplingTimeDiscretizationFloat *otherC(dynamic_cast<const MEDCouplingTimeDiscretizationFloat *>(other));
+ const auto *otherC(dynamic_cast<const MEDCouplingTimeDiscretizationFloat *>(other));
if(!otherC)
throw INTERP_KERNEL::Exception("isEqualWithoutConsideringStr : other is not a MEDCouplingTimeDiscretizationFloat !");
std::string tmp;
////////////////////////
MEDCouplingNoTimeLabel::MEDCouplingNoTimeLabel()
-{
-}
+= default;
MEDCouplingNoTimeLabel::MEDCouplingNoTimeLabel(const MEDCouplingTimeDiscretization& other, bool deepCopy):MEDCouplingTimeDiscretization(other,deepCopy)
{
return stream.str();
}
-void MEDCouplingNoTimeLabel::synchronizeTimeWith(const MEDCouplingMesh *mesh)
+void MEDCouplingNoTimeLabel::synchronizeTimeWith(const MEDCouplingMesh * /*mesh*/)
{
throw INTERP_KERNEL::Exception("MEDCouplingNoTimeLabel::synchronizeTimeWith : impossible to synchronize time with a MEDCouplingMesh because the time discretization is incompatible with it !");
}
{
if(!MEDCouplingTimeDiscretization::areCompatible(other))
return false;
- const MEDCouplingNoTimeLabel *otherC(dynamic_cast<const MEDCouplingNoTimeLabel *>(other));
- return otherC!=0;
+ const auto *otherC(dynamic_cast<const MEDCouplingNoTimeLabel *>(other));
+ return otherC!=nullptr;
}
bool MEDCouplingNoTimeLabel::areStrictlyCompatible(const MEDCouplingTimeDiscretizationTemplate<double> *other, std::string& reason) const
{
if(!MEDCouplingTimeDiscretization::areStrictlyCompatible(other,reason))
return false;
- const MEDCouplingNoTimeLabel *otherC(dynamic_cast<const MEDCouplingNoTimeLabel *>(other));
- bool ret=otherC!=0;
+ const auto *otherC(dynamic_cast<const MEDCouplingNoTimeLabel *>(other));
+ bool const ret=otherC!=nullptr;
if(!ret)
reason.insert(0,"time discretization of this is NO_TIME, other has a different time discretization.");
return ret;
{
if(!MEDCouplingTimeDiscretization::areStrictlyCompatibleForMul(other))
return false;
- const MEDCouplingNoTimeLabel *otherC(dynamic_cast<const MEDCouplingNoTimeLabel *>(other));
- return otherC!=0;
+ const auto *otherC(dynamic_cast<const MEDCouplingNoTimeLabel *>(other));
+ return otherC!=nullptr;
}
bool MEDCouplingNoTimeLabel::areStrictlyCompatibleForDiv(const MEDCouplingTimeDiscretizationTemplate<double> *other) const
{
if(!MEDCouplingTimeDiscretization::areStrictlyCompatibleForDiv(other))
return false;
- const MEDCouplingNoTimeLabel *otherC(dynamic_cast<const MEDCouplingNoTimeLabel *>(other));
- return otherC!=0;
+ const auto *otherC(dynamic_cast<const MEDCouplingNoTimeLabel *>(other));
+ return otherC!=nullptr;
}
bool MEDCouplingNoTimeLabel::areCompatibleForMeld(const MEDCouplingTimeDiscretization *other) const
{
if(!MEDCouplingTimeDiscretization::areCompatibleForMeld(other))
return false;
- const MEDCouplingNoTimeLabel *otherC(dynamic_cast<const MEDCouplingNoTimeLabel *>(other));
- return otherC!=0;
+ const auto *otherC(dynamic_cast<const MEDCouplingNoTimeLabel *>(other));
+ return otherC!=nullptr;
}
bool MEDCouplingNoTimeLabel::isEqualIfNotWhy(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec, std::string& reason) const
{
- const MEDCouplingNoTimeLabel *otherC(dynamic_cast<const MEDCouplingNoTimeLabel *>(other));
+ const auto *otherC(dynamic_cast<const MEDCouplingNoTimeLabel *>(other));
if(!otherC)
{
reason="This has time discretization NO_TIME, other not.";
bool MEDCouplingNoTimeLabel::isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec) const
{
- const MEDCouplingNoTimeLabel *otherC(dynamic_cast<const MEDCouplingNoTimeLabel *>(other));
+ const auto *otherC(dynamic_cast<const MEDCouplingNoTimeLabel *>(other));
if(!otherC)
return false;
return MEDCouplingTimeDiscretization::isEqualWithoutConsideringStr(other,prec);
MEDCouplingTimeDiscretization *MEDCouplingNoTimeLabel::aggregate(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingNoTimeLabel *otherC(dynamic_cast<const MEDCouplingNoTimeLabel *>(other));
+ const auto *otherC(dynamic_cast<const MEDCouplingNoTimeLabel *>(other));
if(!otherC)
throw INTERP_KERNEL::Exception("NoTimeLabel::aggregation on mismatched time discretization !");
MCAuto<DataArrayDouble> arr(DataArrayDouble::Aggregate(getArray(),other->getArray()));
- MEDCouplingNoTimeLabel *ret(new MEDCouplingNoTimeLabel);
- ret->setArray(arr,0);
+ auto *ret(new MEDCouplingNoTimeLabel);
+ ret->setArray(arr,nullptr);
return ret;
}
{
std::vector<const DataArrayDouble *> a(other.size());
int i=0;
- for(std::vector<const MEDCouplingTimeDiscretization *>::const_iterator it=other.begin();it!=other.end();it++,i++)
+ for(auto it=other.begin();it!=other.end();it++,i++)
{
- const MEDCouplingNoTimeLabel *itC=dynamic_cast<const MEDCouplingNoTimeLabel *>(*it);
+ const auto *itC=dynamic_cast<const MEDCouplingNoTimeLabel *>(*it);
if(!itC)
throw INTERP_KERNEL::Exception("NoTimeLabel::aggregate on mismatched time discretization !");
a[i]=itC->getArray();
}
MCAuto<DataArrayDouble> arr(DataArrayDouble::Aggregate(a));
- MEDCouplingNoTimeLabel *ret(new MEDCouplingNoTimeLabel);
- ret->setArray(arr,0);
+ auto *ret(new MEDCouplingNoTimeLabel);
+ ret->setArray(arr,nullptr);
return ret;
}
MEDCouplingTimeDiscretization *MEDCouplingNoTimeLabel::meld(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("NoTimeLabel::meld on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Meld(getArray(),other->getArray());
- MEDCouplingNoTimeLabel *ret=new MEDCouplingNoTimeLabel;
+ auto *ret=new MEDCouplingNoTimeLabel;
ret->setTimeTolerance(getTimeTolerance());
- ret->setArray(arr,0);
+ ret->setArray(arr,nullptr);
return ret;
}
MEDCouplingTimeDiscretization *MEDCouplingNoTimeLabel::dot(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("NoTimeLabel::dot on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Dot(getArray(),other->getArray());
- MEDCouplingNoTimeLabel *ret=new MEDCouplingNoTimeLabel;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingNoTimeLabel;
+ ret->setArray(arr,nullptr);
return ret;
}
MEDCouplingTimeDiscretization *MEDCouplingNoTimeLabel::crossProduct(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("NoTimeLabel::crossProduct on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::CrossProduct(getArray(),other->getArray());
- MEDCouplingNoTimeLabel *ret=new MEDCouplingNoTimeLabel;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingNoTimeLabel;
+ ret->setArray(arr,nullptr);
return ret;
}
MEDCouplingTimeDiscretization *MEDCouplingNoTimeLabel::max(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("NoTimeLabel::max on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Max(getArray(),other->getArray());
- MEDCouplingNoTimeLabel *ret=new MEDCouplingNoTimeLabel;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingNoTimeLabel;
+ ret->setArray(arr,nullptr);
return ret;
}
MEDCouplingTimeDiscretization *MEDCouplingNoTimeLabel::min(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("NoTimeLabel::max on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Min(getArray(),other->getArray());
- MEDCouplingNoTimeLabel *ret=new MEDCouplingNoTimeLabel;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingNoTimeLabel;
+ ret->setArray(arr,nullptr);
return ret;
}
MEDCouplingTimeDiscretization *MEDCouplingNoTimeLabel::add(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("NoTimeLabel::add on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Add(getArray(),other->getArray());
- MEDCouplingNoTimeLabel *ret=new MEDCouplingNoTimeLabel;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingNoTimeLabel;
+ ret->setArray(arr,nullptr);
return ret;
}
void MEDCouplingNoTimeLabel::addEqual(const MEDCouplingTimeDiscretization *other)
{
- const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("NoTimeLabel::addEqual on mismatched time discretization !");
if(!getArray())
MEDCouplingTimeDiscretization *MEDCouplingNoTimeLabel::substract(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("NoTimeLabel::substract on mismatched time discretization !");
if(!getArray())
throw INTERP_KERNEL::Exception("MEDCouplingNoTimeLabel::substract : Data Array is NULL !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Substract(getArray(),other->getArray());
- MEDCouplingNoTimeLabel *ret=new MEDCouplingNoTimeLabel;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingNoTimeLabel;
+ ret->setArray(arr,nullptr);
return ret;
}
void MEDCouplingNoTimeLabel::substractEqual(const MEDCouplingTimeDiscretization *other)
{
- const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("NoTimeLabel::substractEqual on mismatched time discretization !");
if(!getArray())
MEDCouplingTimeDiscretization *MEDCouplingNoTimeLabel::multiply(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("NoTimeLabel::multiply on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Multiply(getArray(),other->getArray());
- MEDCouplingNoTimeLabel *ret=new MEDCouplingNoTimeLabel;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingNoTimeLabel;
+ ret->setArray(arr,nullptr);
return ret;
}
void MEDCouplingNoTimeLabel::multiplyEqual(const MEDCouplingTimeDiscretization *other)
{
- const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("NoTimeLabel::multiplyEqual on mismatched time discretization !");
if(!getArray())
MEDCouplingTimeDiscretization *MEDCouplingNoTimeLabel::divide(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("divide on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Divide(getArray(),other->getArray());
- MEDCouplingNoTimeLabel *ret=new MEDCouplingNoTimeLabel;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingNoTimeLabel;
+ ret->setArray(arr,nullptr);
return ret;
}
void MEDCouplingNoTimeLabel::divideEqual(const MEDCouplingTimeDiscretization *other)
{
- const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("NoTimeLabel::divideEqual on mismatched time discretization !");
if(!getArray())
MEDCouplingTimeDiscretization *MEDCouplingNoTimeLabel::pow(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("pow on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Pow(getArray(),other->getArray());
- MEDCouplingNoTimeLabel *ret=new MEDCouplingNoTimeLabel;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingNoTimeLabel;
+ ret->setArray(arr,nullptr);
return ret;
}
void MEDCouplingNoTimeLabel::powEqual(const MEDCouplingTimeDiscretization *other)
{
- const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("NoTimeLabel::powEqual on mismatched time discretization !");
if(!getArray())
return new MEDCouplingNoTimeLabel(*this,deepCopy);
}
-void MEDCouplingNoTimeLabel::checkTimePresence(double time) const
+void MEDCouplingNoTimeLabel::checkTimePresence(double /*time*/) const
{
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-std::vector< const DataArrayDouble *> MEDCouplingNoTimeLabel::getArraysForTime(double time) const
+std::vector< const DataArrayDouble *> MEDCouplingNoTimeLabel::getArraysForTime(double /*time*/) const
{
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-void MEDCouplingNoTimeLabel::getValueForTime(double time, const std::vector<double>& vals, double *res) const
+void MEDCouplingNoTimeLabel::getValueForTime(double /*time*/, const std::vector<double>& /*vals*/, double * /*res*/) const
{
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-bool MEDCouplingNoTimeLabel::isBefore(const MEDCouplingTimeDiscretization *other) const
+bool MEDCouplingNoTimeLabel::isBefore(const MEDCouplingTimeDiscretization * /*other*/) const
{
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-bool MEDCouplingNoTimeLabel::isStrictlyBefore(const MEDCouplingTimeDiscretization *other) const
+bool MEDCouplingNoTimeLabel::isStrictlyBefore(const MEDCouplingTimeDiscretization * /*other*/) const
{
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-double MEDCouplingNoTimeLabel::getStartTime(int& iteration, int& order) const
+double MEDCouplingNoTimeLabel::getStartTime(int& /*iteration*/, int& /*order*/) const
{
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-double MEDCouplingNoTimeLabel::getEndTime(int& iteration, int& order) const
+double MEDCouplingNoTimeLabel::getEndTime(int& /*iteration*/, int& /*order*/) const
{
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-void MEDCouplingNoTimeLabel::setStartIteration(int it)
+void MEDCouplingNoTimeLabel::setStartIteration(int /*it*/)
{
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-void MEDCouplingNoTimeLabel::setEndIteration(int it)
+void MEDCouplingNoTimeLabel::setEndIteration(int /*it*/)
{
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-void MEDCouplingNoTimeLabel::setStartOrder(int order)
+void MEDCouplingNoTimeLabel::setStartOrder(int /*order*/)
{
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-void MEDCouplingNoTimeLabel::setEndOrder(int order)
+void MEDCouplingNoTimeLabel::setEndOrder(int /*order*/)
{
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-void MEDCouplingNoTimeLabel::setStartTimeValue(double time)
+void MEDCouplingNoTimeLabel::setStartTimeValue(double /*time*/)
{
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-void MEDCouplingNoTimeLabel::setEndTimeValue(double time)
+void MEDCouplingNoTimeLabel::setEndTimeValue(double /*time*/)
{
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-void MEDCouplingNoTimeLabel::setStartTime(double time, int iteration, int order)
+void MEDCouplingNoTimeLabel::setStartTime(double /*time*/, int /*iteration*/, int /*order*/)
{
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-void MEDCouplingNoTimeLabel::setEndTime(double time, int iteration, int order)
+void MEDCouplingNoTimeLabel::setEndTime(double /*time*/, int /*iteration*/, int /*order*/)
{
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-void MEDCouplingNoTimeLabel::getValueOnTime(mcIdType eltId, double time, double *value) const
+void MEDCouplingNoTimeLabel::getValueOnTime(mcIdType /*eltId*/, double /*time*/, double * /*value*/) const
{
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-void MEDCouplingNoTimeLabel::getValueOnDiscTime(mcIdType eltId, int iteration, int order, double *value) const
+void MEDCouplingNoTimeLabel::getValueOnDiscTime(mcIdType /*eltId*/, int /*iteration*/, int /*order*/, double * /*value*/) const
{
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
/*!
* idem finishUnserialization except that it is for multi field fetch
*/
-void MEDCouplingNoTimeLabel::finishUnserialization2(const std::vector<mcIdType>& tinyInfoI, const std::vector<double>& tinyInfoD)
+void MEDCouplingNoTimeLabel::finishUnserialization2(const std::vector<mcIdType>& /*tinyInfoI*/, const std::vector<double>& tinyInfoD)
{
_time_tolerance=tinyInfoD[0];
}
}
MEDCouplingWithTimeStep::MEDCouplingWithTimeStep()
-{
-}
+= default;
std::string MEDCouplingWithTimeStep::getStringRepr() const
{
if(!mesh)
throw INTERP_KERNEL::Exception("MEDCouplingWithTimeStep::synchronizeTimeWith : mesh instance is NULL ! Impossible to synchronize time !");
int it=-1,order=-1;
- double val=mesh->getTime(it,order);
+ double const val=mesh->getTime(it,order);
_tk.setAllInfo(val,it,order);
- std::string tUnit(mesh->getTimeUnit());
+ std::string const tUnit(mesh->getTimeUnit());
setTimeUnit(tUnit);
}
{
if(!MEDCouplingTimeDiscretization::areCompatible(other))
return false;
- const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
- return otherC!=0;
+ const auto *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
+ return otherC!=nullptr;
}
bool MEDCouplingWithTimeStep::areStrictlyCompatible(const MEDCouplingTimeDiscretizationTemplate<double> *other, std::string& reason) const
{
if(!MEDCouplingTimeDiscretization::areStrictlyCompatible(other,reason))
return false;
- const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
- bool ret=otherC!=0;
+ const auto *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
+ bool const ret=otherC!=nullptr;
if(!ret)
reason.insert(0,"time discretization of this is ONE_TIME, other has a different time discretization.");
return ret;
{
if(!MEDCouplingTimeDiscretization::areStrictlyCompatibleForMul(other))
return false;
- const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
- return otherC!=0;
+ const auto *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
+ return otherC!=nullptr;
}
bool MEDCouplingWithTimeStep::areStrictlyCompatibleForDiv(const MEDCouplingTimeDiscretizationTemplate<double> *other) const
{
if(!MEDCouplingTimeDiscretization::areStrictlyCompatibleForDiv(other))
return false;
- const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
- return otherC!=0;
+ const auto *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
+ return otherC!=nullptr;
}
bool MEDCouplingWithTimeStep::areCompatibleForMeld(const MEDCouplingTimeDiscretization *other) const
{
if(!MEDCouplingTimeDiscretization::areCompatibleForMeld(other))
return false;
- const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
- return otherC!=0;
+ const auto *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
+ return otherC!=nullptr;
}
bool MEDCouplingWithTimeStep::isEqualIfNotWhy(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec, std::string& reason) const
{
- const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
std::ostringstream oss; oss.precision(15);
if(!otherC)
{
bool MEDCouplingWithTimeStep::isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec) const
{
- const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
if(!otherC)
return false;
if(!_tk.isEqual(otherC->_tk,_time_tolerance))
void MEDCouplingWithTimeStep::copyTinyAttrFrom(const MEDCouplingTimeDiscretizationTemplate<double>& other)
{
MEDCouplingTimeDiscretization::copyTinyAttrFrom(other);
- const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(&other);
+ const auto *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(&other);
if(!otherC)
throw INTERP_KERNEL::Exception("MEDCouplingWithTimeStep::copyTinyAttrFrom : mismatch of time discretization !");
_tk.copyFrom(otherC->_tk);
MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::aggregate(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("WithTimeStep::aggregation on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Aggregate(getArray(),other->getArray());
- MEDCouplingWithTimeStep *ret=new MEDCouplingWithTimeStep;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingWithTimeStep;
+ ret->setArray(arr,nullptr);
return ret;
}
{
std::vector<const DataArrayDouble *> a(other.size());
int i=0;
- for(std::vector<const MEDCouplingTimeDiscretization *>::const_iterator it=other.begin();it!=other.end();it++,i++)
+ for(auto it=other.begin();it!=other.end();it++,i++)
{
- const MEDCouplingWithTimeStep *itC=dynamic_cast<const MEDCouplingWithTimeStep *>(*it);
+ const auto *itC=dynamic_cast<const MEDCouplingWithTimeStep *>(*it);
if(!itC)
throw INTERP_KERNEL::Exception("WithTimeStep::aggregate on mismatched time discretization !");
a[i]=itC->getArray();
}
MCAuto<DataArrayDouble> arr=DataArrayDouble::Aggregate(a);
- MEDCouplingWithTimeStep *ret=new MEDCouplingWithTimeStep;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingWithTimeStep;
+ ret->setArray(arr,nullptr);
return ret;
}
MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::meld(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("WithTimeStep::meld on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Meld(getArray(),other->getArray());
- MEDCouplingWithTimeStep *ret=new MEDCouplingWithTimeStep;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingWithTimeStep;
+ ret->setArray(arr,nullptr);
return ret;
}
MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::dot(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("WithTimeStep::dot on mismatched time discretization !");
- MEDCouplingWithTimeStep *ret=new MEDCouplingWithTimeStep;
+ auto *ret=new MEDCouplingWithTimeStep;
MCAuto<DataArrayDouble> arr=DataArrayDouble::Dot(getArray(),other->getArray());
- ret->setArray(arr,0);
+ ret->setArray(arr,nullptr);
return ret;
}
MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::crossProduct(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("WithTimeStep::crossProduct on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::CrossProduct(getArray(),other->getArray());
- MEDCouplingWithTimeStep *ret=new MEDCouplingWithTimeStep;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingWithTimeStep;
+ ret->setArray(arr,nullptr);
return ret;
}
MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::max(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("WithTimeStep::max on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Max(getArray(),other->getArray());
- MEDCouplingWithTimeStep *ret=new MEDCouplingWithTimeStep;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingWithTimeStep;
+ ret->setArray(arr,nullptr);
return ret;
}
MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::min(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("WithTimeStep::min on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Min(getArray(),other->getArray());
- MEDCouplingWithTimeStep *ret=new MEDCouplingWithTimeStep;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingWithTimeStep;
+ ret->setArray(arr,nullptr);
return ret;
}
MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::add(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("WithTimeStep::add on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Add(getArray(),other->getArray());
- MEDCouplingWithTimeStep *ret=new MEDCouplingWithTimeStep;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingWithTimeStep;
+ ret->setArray(arr,nullptr);
int tmp1,tmp2;
- double tmp3=getStartTime(tmp1,tmp2);
+ double const tmp3=getStartTime(tmp1,tmp2);
ret->setStartTime(tmp3,tmp1,tmp2);
return ret;
}
void MEDCouplingWithTimeStep::addEqual(const MEDCouplingTimeDiscretization *other)
{
- const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("WithTimeStep::addEqual on mismatched time discretization !");
if(!getArray())
MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::substract(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("WithTimeStep::substract on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Substract(getArray(),other->getArray());
- MEDCouplingWithTimeStep *ret=new MEDCouplingWithTimeStep;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingWithTimeStep;
+ ret->setArray(arr,nullptr);
int tmp1,tmp2;
- double tmp3=getStartTime(tmp1,tmp2);
+ double const tmp3=getStartTime(tmp1,tmp2);
ret->setStartTime(tmp3,tmp1,tmp2);
return ret;
}
void MEDCouplingWithTimeStep::substractEqual(const MEDCouplingTimeDiscretization *other)
{
- const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("WithTimeStep::substractEqual on mismatched time discretization !");
if(!getArray())
MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::multiply(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("WithTimeStep::multiply on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Multiply(getArray(),other->getArray());
- MEDCouplingWithTimeStep *ret=new MEDCouplingWithTimeStep;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingWithTimeStep;
+ ret->setArray(arr,nullptr);
int tmp1,tmp2;
- double tmp3=getStartTime(tmp1,tmp2);
+ double const tmp3=getStartTime(tmp1,tmp2);
ret->setStartTime(tmp3,tmp1,tmp2);
return ret;
}
void MEDCouplingWithTimeStep::multiplyEqual(const MEDCouplingTimeDiscretization *other)
{
- const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("WithTimeStep::multiplyEqual on mismatched time discretization !");
if(!getArray())
MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::divide(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("WithTimeStep::divide on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Divide(getArray(),other->getArray());
- MEDCouplingWithTimeStep *ret=new MEDCouplingWithTimeStep;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingWithTimeStep;
+ ret->setArray(arr,nullptr);
int tmp1,tmp2;
- double tmp3=getStartTime(tmp1,tmp2);
+ double const tmp3=getStartTime(tmp1,tmp2);
ret->setStartTime(tmp3,tmp1,tmp2);
return ret;
}
void MEDCouplingWithTimeStep::divideEqual(const MEDCouplingTimeDiscretization *other)
{
- const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("WithTimeStep::divideEqual on mismatched time discretization !");
if(!getArray())
MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::pow(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("WithTimeStep::pow on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Pow(getArray(),other->getArray());
- MEDCouplingWithTimeStep *ret=new MEDCouplingWithTimeStep;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingWithTimeStep;
+ ret->setArray(arr,nullptr);
int tmp1,tmp2;
- double tmp3=getStartTime(tmp1,tmp2);
+ double const tmp3=getStartTime(tmp1,tmp2);
ret->setStartTime(tmp3,tmp1,tmp2);
return ret;
}
void MEDCouplingWithTimeStep::powEqual(const MEDCouplingTimeDiscretization *other)
{
- const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("WithTimeStep::powEqual on mismatched time discretization !");
if(!getArray())
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-void MEDCouplingWithTimeStep::getValueForTime(double time, const std::vector<double>& vals, double *res) const
+void MEDCouplingWithTimeStep::getValueForTime(double /*time*/, const std::vector<double>& vals, double *res) const
{
std::copy(vals.begin(),vals.end(),res);
}
}
MEDCouplingConstOnTimeInterval::MEDCouplingConstOnTimeInterval()
-{
-}
+= default;
void MEDCouplingConstOnTimeInterval::copyTinyAttrFrom(const MEDCouplingTimeDiscretizationTemplate<double>& other)
{
MEDCouplingTimeDiscretization::copyTinyAttrFrom(other);
- const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(&other);
+ const auto *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(&other);
if(!otherC)
throw INTERP_KERNEL::Exception("MEDCouplingConstOnTimeInterval::copyTinyAttrFrom : mismatch of time discretization !");
_start.copyFrom(otherC->_start);
if(!mesh)
throw INTERP_KERNEL::Exception("MEDCouplingWithTimeStep::synchronizeTimeWith : mesh instance is NULL ! Impossible to synchronize time !");
int it=-1,order=-1;
- double val=mesh->getTime(it,order);
+ double const val=mesh->getTime(it,order);
_start.setAllInfo(val,it,order);
_end.setAllInfo(val,it,order);
- std::string tUnit(mesh->getTimeUnit());
+ std::string const tUnit(mesh->getTimeUnit());
setTimeUnit(tUnit);
}
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-void MEDCouplingConstOnTimeInterval::getValueForTime(double time, const std::vector<double>& vals, double *res) const
+void MEDCouplingConstOnTimeInterval::getValueForTime(double /*time*/, const std::vector<double>& vals, double *res) const
{
std::copy(vals.begin(),vals.end(),res);
}
{
if(!MEDCouplingTimeDiscretization::areCompatible(other))
return false;
- const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
- return otherC!=0;
+ const auto *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
+ return otherC!=nullptr;
}
bool MEDCouplingConstOnTimeInterval::areStrictlyCompatible(const MEDCouplingTimeDiscretizationTemplate<double> *other, std::string& reason) const
{
if(!MEDCouplingTimeDiscretization::areStrictlyCompatible(other,reason))
return false;
- const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
- bool ret=otherC!=0;
+ const auto *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
+ bool const ret=otherC!=nullptr;
if(!ret)
reason.insert(0,"time discretization of this is CONST_ON_TIME_INTERVAL, other has a different time discretization.");
return ret;
{
if(!MEDCouplingTimeDiscretization::areStrictlyCompatibleForMul(other))
return false;
- const MEDCouplingConstOnTimeInterval *otherC(dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other));
- return otherC!=0;
+ const auto *otherC(dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other));
+ return otherC!=nullptr;
}
bool MEDCouplingConstOnTimeInterval::areStrictlyCompatibleForDiv(const MEDCouplingTimeDiscretizationTemplate<double> *other) const
{
if(!MEDCouplingTimeDiscretization::areStrictlyCompatibleForDiv(other))
return false;
- const MEDCouplingConstOnTimeInterval *otherC(dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other));
- return otherC!=0;
+ const auto *otherC(dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other));
+ return otherC!=nullptr;
}
bool MEDCouplingConstOnTimeInterval::areCompatibleForMeld(const MEDCouplingTimeDiscretization *other) const
{
if(!MEDCouplingTimeDiscretization::areCompatibleForMeld(other))
return false;
- const MEDCouplingConstOnTimeInterval *otherC(dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other));
- return otherC!=0;
+ const auto *otherC(dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other));
+ return otherC!=nullptr;
}
bool MEDCouplingConstOnTimeInterval::isEqualIfNotWhy(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec, std::string& reason) const
{
- const MEDCouplingConstOnTimeInterval *otherC(dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other));
+ const auto *otherC(dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other));
std::ostringstream oss; oss.precision(15);
if(!otherC)
{
bool MEDCouplingConstOnTimeInterval::isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec) const
{
- const MEDCouplingConstOnTimeInterval *otherC(dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other));
+ const auto *otherC(dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other));
if(!otherC)
return false;
if(!_start.isEqual(otherC->_start,_time_tolerance))
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-void MEDCouplingConstOnTimeInterval::getValueOnDiscTime(mcIdType eltId, int iteration, int order, double *value) const
+void MEDCouplingConstOnTimeInterval::getValueOnDiscTime(mcIdType eltId, int iteration, int /*order*/, double *value) const
{
if(iteration>=_start.getIteration() && iteration<=_end.getIteration())
if(_array)
MEDCouplingTimeDiscretization *MEDCouplingConstOnTimeInterval::aggregate(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("ConstOnTimeInterval::aggregation on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Aggregate(getArray(),other->getArray());
- MEDCouplingConstOnTimeInterval *ret=new MEDCouplingConstOnTimeInterval;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingConstOnTimeInterval;
+ ret->setArray(arr,nullptr);
return ret;
}
{
std::vector<const DataArrayDouble *> a(other.size());
int i=0;
- for(std::vector<const MEDCouplingTimeDiscretization *>::const_iterator it=other.begin();it!=other.end();it++,i++)
+ for(auto it=other.begin();it!=other.end();it++,i++)
{
- const MEDCouplingConstOnTimeInterval *itC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(*it);
+ const auto *itC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(*it);
if(!itC)
throw INTERP_KERNEL::Exception("ConstOnTimeInterval::aggregate on mismatched time discretization !");
a[i]=itC->getArray();
}
MCAuto<DataArrayDouble> arr=DataArrayDouble::Aggregate(a);
- MEDCouplingConstOnTimeInterval *ret=new MEDCouplingConstOnTimeInterval;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingConstOnTimeInterval;
+ ret->setArray(arr,nullptr);
return ret;
}
MEDCouplingTimeDiscretization *MEDCouplingConstOnTimeInterval::meld(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("ConstOnTimeInterval::meld on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Meld(getArray(),other->getArray());
- MEDCouplingConstOnTimeInterval *ret=new MEDCouplingConstOnTimeInterval;
+ auto *ret=new MEDCouplingConstOnTimeInterval;
ret->setTimeTolerance(getTimeTolerance());
- ret->setArray(arr,0);
+ ret->setArray(arr,nullptr);
return ret;
}
MEDCouplingTimeDiscretization *MEDCouplingConstOnTimeInterval::dot(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("ConstOnTimeInterval::dot on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Dot(getArray(),other->getArray());
- MEDCouplingConstOnTimeInterval *ret=new MEDCouplingConstOnTimeInterval;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingConstOnTimeInterval;
+ ret->setArray(arr,nullptr);
return ret;
}
MEDCouplingTimeDiscretization *MEDCouplingConstOnTimeInterval::crossProduct(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("ConstOnTimeInterval::crossProduct on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::CrossProduct(getArray(),other->getArray());
- MEDCouplingConstOnTimeInterval *ret=new MEDCouplingConstOnTimeInterval;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingConstOnTimeInterval;
+ ret->setArray(arr,nullptr);
return ret;
}
MEDCouplingTimeDiscretization *MEDCouplingConstOnTimeInterval::max(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("ConstOnTimeInterval::max on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Max(getArray(),other->getArray());
- MEDCouplingConstOnTimeInterval *ret=new MEDCouplingConstOnTimeInterval;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingConstOnTimeInterval;
+ ret->setArray(arr,nullptr);
return ret;
}
MEDCouplingTimeDiscretization *MEDCouplingConstOnTimeInterval::min(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("ConstOnTimeInterval::min on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Min(getArray(),other->getArray());
- MEDCouplingConstOnTimeInterval *ret=new MEDCouplingConstOnTimeInterval;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingConstOnTimeInterval;
+ ret->setArray(arr,nullptr);
return ret;
}
MEDCouplingTimeDiscretization *MEDCouplingConstOnTimeInterval::add(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("ConstOnTimeInterval::add on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Add(getArray(),other->getArray());
- MEDCouplingConstOnTimeInterval *ret=new MEDCouplingConstOnTimeInterval;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingConstOnTimeInterval;
+ ret->setArray(arr,nullptr);
int tmp1,tmp2;
double tmp3=getStartTime(tmp1,tmp2);
ret->setStartTime(tmp3,tmp1,tmp2);
void MEDCouplingConstOnTimeInterval::addEqual(const MEDCouplingTimeDiscretization *other)
{
- const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("ConstOnTimeInterval::addEqual on mismatched time discretization !");
if(!getArray())
MEDCouplingTimeDiscretization *MEDCouplingConstOnTimeInterval::substract(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("ConstOnTimeInterval::substract on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Substract(getArray(),other->getArray());
- MEDCouplingConstOnTimeInterval *ret=new MEDCouplingConstOnTimeInterval;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingConstOnTimeInterval;
+ ret->setArray(arr,nullptr);
int tmp1,tmp2;
double tmp3=getStartTime(tmp1,tmp2);
ret->setStartTime(tmp3,tmp1,tmp2);
void MEDCouplingConstOnTimeInterval::substractEqual(const MEDCouplingTimeDiscretization *other)
{
- const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("ConstOnTimeInterval::substractEqual on mismatched time discretization !");
if(!getArray())
MEDCouplingTimeDiscretization *MEDCouplingConstOnTimeInterval::multiply(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("multiply on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Multiply(getArray(),other->getArray());
- MEDCouplingConstOnTimeInterval *ret=new MEDCouplingConstOnTimeInterval;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingConstOnTimeInterval;
+ ret->setArray(arr,nullptr);
int tmp1,tmp2;
double tmp3=getStartTime(tmp1,tmp2);
ret->setStartTime(tmp3,tmp1,tmp2);
void MEDCouplingConstOnTimeInterval::multiplyEqual(const MEDCouplingTimeDiscretization *other)
{
- const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("ConstOnTimeInterval::multiplyEqual on mismatched time discretization !");
if(!getArray())
MEDCouplingTimeDiscretization *MEDCouplingConstOnTimeInterval::divide(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("divide on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Divide(getArray(),other->getArray());
- MEDCouplingConstOnTimeInterval *ret=new MEDCouplingConstOnTimeInterval;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingConstOnTimeInterval;
+ ret->setArray(arr,nullptr);
int tmp1,tmp2;
double tmp3=getStartTime(tmp1,tmp2);
ret->setStartTime(tmp3,tmp1,tmp2);
void MEDCouplingConstOnTimeInterval::divideEqual(const MEDCouplingTimeDiscretization *other)
{
- const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("ConstOnTimeInterval::divideEqual on mismatched time discretization !");
if(!getArray())
MEDCouplingTimeDiscretization *MEDCouplingConstOnTimeInterval::pow(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("pow on mismatched time discretization !");
MCAuto<DataArrayDouble> arr=DataArrayDouble::Pow(getArray(),other->getArray());
- MEDCouplingConstOnTimeInterval *ret=new MEDCouplingConstOnTimeInterval;
- ret->setArray(arr,0);
+ auto *ret=new MEDCouplingConstOnTimeInterval;
+ ret->setArray(arr,nullptr);
int tmp1,tmp2;
double tmp3=getStartTime(tmp1,tmp2);
ret->setStartTime(tmp3,tmp1,tmp2);
void MEDCouplingConstOnTimeInterval::powEqual(const MEDCouplingTimeDiscretization *other)
{
- const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("ConstOnTimeInterval::powEqual on mismatched time discretization !");
if(!getArray())
if(other._end_array)
_end_array=other._end_array->performCopyOrIncrRef(deepCopy);
else
- _end_array=0;
+ _end_array=nullptr;
}
void MEDCouplingTwoTimeSteps::updateTime() const
if(!mesh)
throw INTERP_KERNEL::Exception("MEDCouplingTwoTimeSteps::synchronizeTimeWith : mesh instance is NULL ! Impossible to synchronize time !");
int it=-1,order=-1;
- double val=mesh->getTime(it,order);
+ double const val=mesh->getTime(it,order);
_start.setAllInfo(val,it,order);
_end.setAllInfo(val,it,order);
- std::string tUnit(mesh->getTimeUnit());
+ std::string const tUnit(mesh->getTimeUnit());
setTimeUnit(tUnit);
}
void MEDCouplingTwoTimeSteps::copyTinyAttrFrom(const MEDCouplingTimeDiscretizationTemplate<double>& other)
{
MEDCouplingTimeDiscretization::copyTinyAttrFrom(other);
- const MEDCouplingTwoTimeSteps *otherC=dynamic_cast<const MEDCouplingTwoTimeSteps *>(&other);
+ const auto *otherC=dynamic_cast<const MEDCouplingTwoTimeSteps *>(&other);
if(!otherC)
throw INTERP_KERNEL::Exception("MEDCouplingTwoTimeSteps::copyTinyAttrFrom : mismatch of time discretization !");
_start.copyFrom(otherC->_start);
void MEDCouplingTwoTimeSteps::copyTinyStringsFrom(const MEDCouplingTimeDiscretizationTemplate<double>& other)
{
MEDCouplingTimeDiscretization::copyTinyStringsFrom(other);
- const MEDCouplingTwoTimeSteps *otherC=dynamic_cast<const MEDCouplingTwoTimeSteps *>(&other);
+ const auto *otherC=dynamic_cast<const MEDCouplingTwoTimeSteps *>(&other);
if(!otherC)
throw INTERP_KERNEL::Exception("Trying to operate copyTinyStringsFrom on different field type (two times//one time) !");
if(_end_array && otherC->_end_array)
bool MEDCouplingTwoTimeSteps::isEqualIfNotWhy(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec, std::string& reason) const
{
- std::ostringstream oss;
- const MEDCouplingTwoTimeSteps *otherC(dynamic_cast<const MEDCouplingTwoTimeSteps *>(other));
+ std::ostringstream const oss;
+ const auto *otherC(dynamic_cast<const MEDCouplingTwoTimeSteps *>(other));
if(!otherC)
{
reason="This has time discretization LINEAR_TIME, other not.";
bool MEDCouplingTwoTimeSteps::isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec) const
{
- const MEDCouplingTwoTimeSteps *otherC(dynamic_cast<const MEDCouplingTwoTimeSteps *>(other));
+ const auto *otherC(dynamic_cast<const MEDCouplingTwoTimeSteps *>(other));
if(!otherC)
return false;
if(!_start.isEqual(otherC->_start,_time_tolerance))
return MEDCouplingTimeDiscretization::isEqualWithoutConsideringStr(other,prec);
}
-MEDCouplingTwoTimeSteps::MEDCouplingTwoTimeSteps():_end_array(0)
+MEDCouplingTwoTimeSteps::MEDCouplingTwoTimeSteps():_end_array(nullptr)
{
}
void MEDCouplingTwoTimeSteps::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
{
- std::size_t nbOfCompo=_array->getNumberOfComponents();
+ std::size_t const nbOfCompo=_array->getNumberOfComponents();
for(std::size_t i=0;i<nbOfCompo;i++)
tinyInfo.push_back(_array->getInfoOnComponent(i));
for(std::size_t i=0;i<nbOfCompo;i++)
void MEDCouplingTwoTimeSteps::resizeForUnserialization(const std::vector<mcIdType>& tinyInfoI, std::vector<DataArrayDouble *>& arrays)
{
arrays.resize(2);
- if(_array!=0)
+ if(_array!=nullptr)
_array->decrRef();
- if(_end_array!=0)
+ if(_end_array!=nullptr)
_end_array->decrRef();
- DataArrayDouble *arr=0;
+ DataArrayDouble *arr=nullptr;
if(tinyInfoI[0]!=-1 && tinyInfoI[1]!=-1)
{
arr=DataArrayDouble::New();
}
_array=arr;
arrays[0]=arr;
- arr=0;
+ arr=nullptr;
if(tinyInfoI[6]!=-1 && tinyInfoI[7]!=-1)
{
arr=DataArrayDouble::New();
static const char MSG[]="MEDCouplingTimeDiscretization::checkForUnserialization : arrays in input is expected to have size two !";
if(arrays.size()!=2)
throw INTERP_KERNEL::Exception(MSG);
- if(_array!=0)
+ if(_array!=nullptr)
_array->decrRef();
- if(_end_array!=0)
+ if(_end_array!=nullptr)
_end_array->decrRef();
- _array=0; _end_array=0;
+ _array=nullptr; _end_array=nullptr;
if(tinyInfoI[0]!=-1 && tinyInfoI[1]!=-1)
{
if(!arrays[0])
}
MEDCouplingLinearTime::MEDCouplingLinearTime()
-{
-}
+= default;
std::string MEDCouplingLinearTime::getStringRepr() const
{
{
if(!MEDCouplingTimeDiscretization::areCompatible(other))
return false;
- const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
- if(otherC==0)
+ const auto *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
+ if(otherC==nullptr)
return false;
- if(_end_array==0 && otherC->_end_array==0)
+ if(_end_array==nullptr && otherC->_end_array==nullptr)
return true;
- if(_end_array==0 || otherC->_end_array==0)
+ if(_end_array==nullptr || otherC->_end_array==nullptr)
return false;
if(_end_array->getNumberOfComponents()!=otherC->_end_array->getNumberOfComponents())
return false;
{
if(!MEDCouplingTimeDiscretization::areStrictlyCompatible(other,reason))
return false;
- const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
- bool ret=otherC!=0;
+ const auto *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
+ bool const ret=otherC!=nullptr;
if(!ret)
reason.insert(0,"time discretization of this is LINEAR_TIME, other has a different time discretization.");
return ret;
{
if(!MEDCouplingTimeDiscretization::areStrictlyCompatibleForMul(other))
return false;
- const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
- return otherC!=0;
+ const auto *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
+ return otherC!=nullptr;
}
bool MEDCouplingLinearTime::areStrictlyCompatibleForDiv(const MEDCouplingTimeDiscretizationTemplate<double> *other) const
{
if(!MEDCouplingTimeDiscretization::areStrictlyCompatibleForDiv(other))
return false;
- const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
- if(otherC==0)
+ const auto *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
+ if(otherC==nullptr)
return false;
- if(_end_array==0 && otherC->_end_array==0)
+ if(_end_array==nullptr && otherC->_end_array==nullptr)
return true;
- if(_end_array==0 || otherC->_end_array==0)
+ if(_end_array==nullptr || otherC->_end_array==nullptr)
return false;
- std::size_t nbC1=_end_array->getNumberOfComponents();
- std::size_t nbC2=otherC->_end_array->getNumberOfComponents();
+ std::size_t const nbC1=_end_array->getNumberOfComponents();
+ std::size_t const nbC2=otherC->_end_array->getNumberOfComponents();
if(nbC1!=nbC2 && nbC2!=1)
return false;
return true;
{
if(!MEDCouplingTimeDiscretization::areCompatibleForMeld(other))
return false;
- const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
- return otherC!=0;
+ const auto *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
+ return otherC!=nullptr;
}
/*!
*/
void MEDCouplingLinearTime::getValueForTime(double time, const std::vector<double>& vals, double *res) const
{
- double alpha=(_end.getTimeValue()-time)/(_end.getTimeValue()-_start.getTimeValue());
- std::size_t nbComp=vals.size()/2;
+ double const alpha=(_end.getTimeValue()-time)/(_end.getTimeValue()-_start.getTimeValue());
+ std::size_t const nbComp=vals.size()/2;
std::transform(vals.begin(),vals.begin()+nbComp,res,std::bind(std::multiplies<double>(),std::placeholders::_1,alpha));
std::vector<double> tmp(nbComp);
std::transform(vals.begin()+nbComp,vals.end(),tmp.begin(),std::bind(std::multiplies<double>(),std::placeholders::_1,1-alpha));
void MEDCouplingLinearTime::getValueOnTime(mcIdType eltId, double time, double *value) const
{
- double alpha=(_end.getTimeValue()-time)/(_end.getTimeValue()-_start.getTimeValue());
+ double const alpha=(_end.getTimeValue()-time)/(_end.getTimeValue()-_start.getTimeValue());
if(_array)
_array->getTuple(eltId,value);
else
throw INTERP_KERNEL::Exception("No start array existing.");
- std::size_t nbComp=_array->getNumberOfComponents();
+ std::size_t const nbComp=_array->getNumberOfComponents();
std::transform(value,value+nbComp,value,std::bind(std::multiplies<double>(),std::placeholders::_1,alpha));
std::vector<double> tmp(nbComp);
if(_end_array)
MEDCouplingTimeDiscretization *MEDCouplingLinearTime::aggregate(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("LinearTime::aggregation on mismatched time discretization !");
MCAuto<DataArrayDouble> arr1=DataArrayDouble::Aggregate(getArray(),other->getArray());
MCAuto<DataArrayDouble> arr2=DataArrayDouble::Aggregate(getEndArray(),other->getEndArray());
- MEDCouplingLinearTime *ret=new MEDCouplingLinearTime;
- ret->setArray(arr1,0);
- ret->setEndArray(arr2,0);
+ auto *ret=new MEDCouplingLinearTime;
+ ret->setArray(arr1,nullptr);
+ ret->setEndArray(arr2,nullptr);
return ret;
}
std::vector<const DataArrayDouble *> a(other.size());
std::vector<const DataArrayDouble *> b(other.size());
int i=0;
- for(std::vector<const MEDCouplingTimeDiscretization *>::const_iterator it=other.begin();it!=other.end();it++,i++)
+ for(auto it=other.begin();it!=other.end();it++,i++)
{
- const MEDCouplingLinearTime *itC=dynamic_cast<const MEDCouplingLinearTime *>(*it);
+ const auto *itC=dynamic_cast<const MEDCouplingLinearTime *>(*it);
if(!itC)
throw INTERP_KERNEL::Exception("MEDCouplingLinearTime::aggregate on mismatched time discretization !");
a[i]=itC->getArray();
b[i]=itC->getEndArray();
}
MCAuto<DataArrayDouble> arr(DataArrayDouble::Aggregate(a)),arr2(DataArrayDouble::Aggregate(b));
- MEDCouplingLinearTime *ret(new MEDCouplingLinearTime);
- ret->setArray(arr,0);
- ret->setEndArray(arr2,0);
+ auto *ret(new MEDCouplingLinearTime);
+ ret->setArray(arr,nullptr);
+ ret->setEndArray(arr2,nullptr);
return ret;
}
MEDCouplingTimeDiscretization *MEDCouplingLinearTime::meld(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("LinearTime::meld on mismatched time discretization !");
MCAuto<DataArrayDouble> arr1(DataArrayDouble::Meld(getArray(),other->getArray())),arr2(DataArrayDouble::Meld(getEndArray(),other->getEndArray()));
- MEDCouplingLinearTime *ret(new MEDCouplingLinearTime);
+ auto *ret(new MEDCouplingLinearTime);
ret->setTimeTolerance(getTimeTolerance());
- ret->setArray(arr1,0);
- ret->setEndArray(arr2,0);
+ ret->setArray(arr1,nullptr);
+ ret->setEndArray(arr2,nullptr);
return ret;
}
MEDCouplingTimeDiscretization *MEDCouplingLinearTime::dot(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("LinearTime::dot on mismatched time discretization !");
MCAuto<DataArrayDouble> arr1(DataArrayDouble::Dot(getArray(),other->getArray())),arr2(DataArrayDouble::Dot(getEndArray(),other->getEndArray()));
- MEDCouplingLinearTime *ret(new MEDCouplingLinearTime);
- ret->setArray(arr1,0);
- ret->setEndArray(arr2,0);
+ auto *ret(new MEDCouplingLinearTime);
+ ret->setArray(arr1,nullptr);
+ ret->setEndArray(arr2,nullptr);
return ret;
}
MEDCouplingTimeDiscretization *MEDCouplingLinearTime::crossProduct(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("LinearTime::crossProduct on mismatched time discretization !");
MCAuto<DataArrayDouble> arr1(DataArrayDouble::CrossProduct(getArray(),other->getArray())),arr2(DataArrayDouble::CrossProduct(getEndArray(),other->getEndArray()));
- MEDCouplingLinearTime *ret(new MEDCouplingLinearTime);
- ret->setArray(arr1,0);
- ret->setEndArray(arr2,0);
+ auto *ret(new MEDCouplingLinearTime);
+ ret->setArray(arr1,nullptr);
+ ret->setEndArray(arr2,nullptr);
return ret;
}
MEDCouplingTimeDiscretization *MEDCouplingLinearTime::max(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("LinearTime::max on mismatched time discretization !");
- MEDCouplingLinearTime *ret=new MEDCouplingLinearTime;
+ auto *ret=new MEDCouplingLinearTime;
MCAuto<DataArrayDouble> arr1(DataArrayDouble::Max(getArray(),other->getArray())),arr2(DataArrayDouble::Max(getEndArray(),other->getEndArray()));
- ret->setArray(arr1,0);
- ret->setEndArray(arr2,0);
+ ret->setArray(arr1,nullptr);
+ ret->setEndArray(arr2,nullptr);
return ret;
}
MEDCouplingTimeDiscretization *MEDCouplingLinearTime::min(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("LinearTime::min on mismatched time discretization !");
MCAuto<DataArrayDouble> arr1(DataArrayDouble::Min(getArray(),other->getArray())),arr2(DataArrayDouble::Min(getEndArray(),other->getEndArray()));
- MEDCouplingLinearTime *ret(new MEDCouplingLinearTime);
- ret->setArray(arr1,0);
- ret->setEndArray(arr2,0);
+ auto *ret(new MEDCouplingLinearTime);
+ ret->setArray(arr1,nullptr);
+ ret->setEndArray(arr2,nullptr);
return ret;
}
MEDCouplingTimeDiscretization *MEDCouplingLinearTime::add(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("LinearTime::add on mismatched time discretization !");
MCAuto<DataArrayDouble> arr1(DataArrayDouble::Add(getArray(),other->getArray())),arr2(DataArrayDouble::Add(getEndArray(),other->getEndArray()));
- MEDCouplingLinearTime *ret(new MEDCouplingLinearTime);
- ret->setArray(arr1,0);
- ret->setEndArray(arr2,0);
+ auto *ret(new MEDCouplingLinearTime);
+ ret->setArray(arr1,nullptr);
+ ret->setEndArray(arr2,nullptr);
return ret;
}
void MEDCouplingLinearTime::addEqual(const MEDCouplingTimeDiscretization *other)
{
- const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("LinearTime::addEqual on mismatched time discretization !");
if(!getArray())
MEDCouplingTimeDiscretization *MEDCouplingLinearTime::substract(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("LinearTime::substract on mismatched time discretization !");
MCAuto<DataArrayDouble> arr1=DataArrayDouble::Substract(getArray(),other->getArray());
MCAuto<DataArrayDouble> arr2=DataArrayDouble::Substract(getEndArray(),other->getEndArray());
- MEDCouplingLinearTime *ret=new MEDCouplingLinearTime;
- ret->setArray(arr1,0);
- ret->setEndArray(arr2,0);
+ auto *ret=new MEDCouplingLinearTime;
+ ret->setArray(arr1,nullptr);
+ ret->setEndArray(arr2,nullptr);
return ret;
}
void MEDCouplingLinearTime::substractEqual(const MEDCouplingTimeDiscretization *other)
{
- const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("LinearTime::addEqual on mismatched time discretization !");
if(!getArray())
MEDCouplingTimeDiscretization *MEDCouplingLinearTime::multiply(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("LinearTime::multiply on mismatched time discretization !");
MCAuto<DataArrayDouble> arr1=DataArrayDouble::Multiply(getArray(),other->getArray());
MCAuto<DataArrayDouble> arr2=DataArrayDouble::Multiply(getEndArray(),other->getEndArray());
- MEDCouplingLinearTime *ret=new MEDCouplingLinearTime;
- ret->setArray(arr1,0);
- ret->setEndArray(arr2,0);
+ auto *ret=new MEDCouplingLinearTime;
+ ret->setArray(arr1,nullptr);
+ ret->setEndArray(arr2,nullptr);
return ret;
}
void MEDCouplingLinearTime::multiplyEqual(const MEDCouplingTimeDiscretization *other)
{
- const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("LinearTime::addEqual on mismatched time discretization !");
if(!getArray())
MEDCouplingTimeDiscretization *MEDCouplingLinearTime::divide(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("LinearTime::divide on mismatched time discretization !");
MCAuto<DataArrayDouble> arr1=DataArrayDouble::Divide(getArray(),other->getArray());
MCAuto<DataArrayDouble> arr2=DataArrayDouble::Divide(getEndArray(),other->getEndArray());
- MEDCouplingLinearTime *ret=new MEDCouplingLinearTime;
- ret->setArray(arr1,0);
- ret->setEndArray(arr2,0);
+ auto *ret=new MEDCouplingLinearTime;
+ ret->setArray(arr1,nullptr);
+ ret->setEndArray(arr2,nullptr);
return ret;
}
void MEDCouplingLinearTime::divideEqual(const MEDCouplingTimeDiscretization *other)
{
- const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("LinearTime::addEqual on mismatched time discretization !");
if(!getArray())
MEDCouplingTimeDiscretization *MEDCouplingLinearTime::pow(const MEDCouplingTimeDiscretization *other) const
{
- const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("LinearTime::pow on mismatched time discretization !");
MCAuto<DataArrayDouble> arr1=DataArrayDouble::Pow(getArray(),other->getArray());
MCAuto<DataArrayDouble> arr2=DataArrayDouble::Pow(getEndArray(),other->getEndArray());
- MEDCouplingLinearTime *ret=new MEDCouplingLinearTime;
- ret->setArray(arr1,0);
- ret->setEndArray(arr2,0);
+ auto *ret=new MEDCouplingLinearTime;
+ ret->setArray(arr1,nullptr);
+ ret->setEndArray(arr2,nullptr);
return ret;
}
void MEDCouplingLinearTime::powEqual(const MEDCouplingTimeDiscretization *other)
{
- const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("LinearTime::addEqual on mismatched time discretization !");
if(!getArray())
#ifndef __MEDCOUPLINGTIMEDISCRETIZATION_HXX__
#define __MEDCOUPLINGTIMEDISCRETIZATION_HXX__
+#include "MCType.hxx"
#include "MEDCoupling.hxx"
#include "MEDCouplingTimeLabel.hxx"
#include "MEDCouplingRefCountObject.hxx"
-#include "InterpKernelException.hxx"
#include "MEDCouplingTraits.hxx"
+#include <string>
+#include <cstddef>
#include <vector>
namespace MEDCoupling
void copyTinyAttrFrom(const TimeHolder& other) { _time_unit=other._time_unit; }
protected:
TimeHolder() { }
- TimeHolder(const TimeHolder& other):_time_unit(other._time_unit) { }
- virtual ~TimeHolder() { }
+ TimeHolder(const TimeHolder& other) = default;
+ virtual ~TimeHolder() = default;
private:
std::string _time_unit;
};
class MEDCouplingTimeDiscretizationTemplate : public TimeLabel, public BigMemoryObject, public TimeHolder
{
public:
- MEDCOUPLING_EXPORT void updateTime() const;
+ MEDCOUPLING_EXPORT void updateTime() const override;
MEDCOUPLING_EXPORT virtual void setArray(typename Traits<T>::ArrayType *array, TimeLabel *owner);
MEDCOUPLING_EXPORT typename Traits<T>::ArrayType *getArray() { return _array; }
MEDCOUPLING_EXPORT const typename Traits<T>::ArrayType *getArray() const { return _array; }
MEDCOUPLING_EXPORT virtual void copyTinyAttrFrom(const MEDCouplingTimeDiscretizationTemplate<T>& other);
MEDCOUPLING_EXPORT virtual void copyTinyStringsFrom(const MEDCouplingTimeDiscretizationTemplate<T>& other);
MEDCOUPLING_EXPORT virtual void checkConsistencyLight() const;
- MEDCOUPLING_EXPORT virtual std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDCOUPLING_EXPORT virtual std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
//
MEDCOUPLING_EXPORT virtual bool isEqualIfNotWhy(const MEDCouplingTimeDiscretizationTemplate<T> *other, T prec, std::string& reason) const = 0;
MEDCOUPLING_EXPORT virtual bool isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretizationTemplate<T> *other, T prec) const = 0;
MEDCOUPLING_EXPORT virtual bool areCompatible(const MEDCouplingTimeDiscretizationTemplate<T> *other) const;
MEDCOUPLING_EXPORT virtual bool areStrictlyCompatibleForMul(const MEDCouplingTimeDiscretizationTemplate<T> *other) const;
MEDCOUPLING_EXPORT virtual bool areStrictlyCompatibleForDiv(const MEDCouplingTimeDiscretizationTemplate<T> *other) const;
- MEDCOUPLING_EXPORT virtual ~MEDCouplingTimeDiscretizationTemplate();
+ MEDCOUPLING_EXPORT ~MEDCouplingTimeDiscretizationTemplate() override;
MEDCOUPLING_EXPORT virtual void getTinySerializationIntInformation(std::vector<mcIdType>& tinyInfo) const;
MEDCOUPLING_EXPORT virtual void getTinySerializationDbleInformation(std::vector<double>& tinyInfo) const;
MEDCOUPLING_EXPORT virtual void getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const;
class MEDCouplingTimeKeeper
{
public:
- MEDCOUPLING_EXPORT MEDCouplingTimeKeeper():_time(0.),_iteration(-1),_order(-1) { }
+ MEDCOUPLING_EXPORT MEDCouplingTimeKeeper() = default;
MEDCOUPLING_EXPORT double getAllInfo(int& iteration, int& order) const { iteration=_iteration; order=_order; return _time; }
MEDCOUPLING_EXPORT void setAllInfo(double time, int iteration, int order) { _time=time; _iteration=iteration; _order=order; }
MEDCOUPLING_EXPORT int getIteration() const { return _iteration; }
MEDCOUPLING_EXPORT void copyFrom(const MEDCouplingTimeKeeper& other);
MEDCOUPLING_EXPORT void checkTimePresence(double time, double eps) const;
private:
- double _time;
- int _iteration;
- int _order;
+ double _time{0.};
+ int _iteration{-1};
+ int _order{-1};
};
class MEDCouplingTimeDiscretization : public MEDCouplingTimeDiscretizationTemplate<double>
public:
MEDCOUPLING_EXPORT static MEDCouplingTimeDiscretization *New(TypeOfTimeDiscretization type);
MEDCOUPLING_EXPORT virtual bool areCompatibleForMeld(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT virtual bool isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec) const;
- MEDCOUPLING_EXPORT virtual bool isEqualIfNotWhy(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec, std::string& reason) const;
+ MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec) const override;
+ MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec, std::string& reason) const override;
MEDCOUPLING_EXPORT virtual bool isEqual(const MEDCouplingTimeDiscretization *other, double prec) const;
MEDCOUPLING_EXPORT virtual MEDCouplingTimeDiscretization *buildNewTimeReprFromThis(TypeOfTimeDiscretization type, bool deepCopy) const;
MEDCOUPLING_EXPORT virtual void synchronizeTimeWith(const MEDCouplingMesh *mesh) = 0;
class MEDCouplingTimeDiscretizationSimple : public MEDCouplingTimeDiscretizationTemplate<T>
{
public:
- std::string getStringRepr() const;
- double getStartTime(int& iteration, int& order) const { return _tk.getAllInfo(iteration,order); }
- void setStartIteration(int it) { _tk.setIteration(it); }
- void setStartOrder(int order) { _tk.setOrder(order); }
- void setStartTimeValue(double time) { _tk.setTimeValue(time); }
- void setStartTime(double time, int iteration, int order) { _tk.setAllInfo(time,iteration,order); }
- double getEndTime(int& iteration, int& order) const;
- void setEndIteration(int it);
- void setEndOrder(int order);
- void setEndTimeValue(double time);
- void setEndTime(double time, int iteration, int order);
- TypeOfTimeDiscretization getEnum() const { return DISCRETIZATION; }
+ std::string getStringRepr() const override;
+ double getStartTime(int& iteration, int& order) const override { return _tk.getAllInfo(iteration,order); }
+ void setStartIteration(int it) override { _tk.setIteration(it); }
+ void setStartOrder(int order) override { _tk.setOrder(order); }
+ void setStartTimeValue(double time) override { _tk.setTimeValue(time); }
+ void setStartTime(double time, int iteration, int order) override { _tk.setAllInfo(time,iteration,order); }
+ double getEndTime(int& iteration, int& order) const override;
+ void setEndIteration(int it) override;
+ void setEndOrder(int order) override;
+ void setEndTimeValue(double time) override;
+ void setEndTime(double time, int iteration, int order) override;
+ TypeOfTimeDiscretization getEnum() const override { return DISCRETIZATION; }
protected:
MEDCouplingTimeDiscretizationSimple(const MEDCouplingTimeDiscretizationSimple<T>& other, bool deepCopy);
MEDCouplingTimeDiscretizationSimple() { }
class MEDCouplingTimeDiscretizationInt32 : public MEDCouplingTimeDiscretizationSimple<Int32>
{
public:
- MEDCouplingTimeDiscretizationInt32() { }
+ MEDCouplingTimeDiscretizationInt32() = default;
std::string getClassName() const override { return std::string("MEDCouplingTimeDiscretizationInt32"); }
MEDCouplingTimeDiscretizationInt32(const MEDCouplingTimeDiscretizationInt32& other, bool deepCopy);
static MEDCouplingTimeDiscretizationInt32 *New(TypeOfTimeDiscretization type);
- MEDCouplingTimeDiscretizationInt32 *performCopyOrIncrRef(bool deepCopy) const;
- bool isEqualIfNotWhy(const MEDCouplingTimeDiscretizationTemplate<Int32> *other, Int32 prec, std::string& reason) const;
- bool isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretizationTemplate<Int32> *other, Int32 prec) const;
+ MEDCouplingTimeDiscretizationInt32 *performCopyOrIncrRef(bool deepCopy) const override;
+ bool isEqualIfNotWhy(const MEDCouplingTimeDiscretizationTemplate<Int32> *other, Int32 prec, std::string& reason) const override;
+ bool isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretizationTemplate<Int32> *other, Int32 prec) const override;
};
class MEDCouplingTimeDiscretizationInt64 : public MEDCouplingTimeDiscretizationSimple<Int64>
{
public:
- MEDCouplingTimeDiscretizationInt64() { }
+ MEDCouplingTimeDiscretizationInt64() = default;
std::string getClassName() const override { return std::string("MEDCouplingTimeDiscretizationInt64"); }
MEDCouplingTimeDiscretizationInt64(const MEDCouplingTimeDiscretizationInt64& other, bool deepCopy);
static MEDCouplingTimeDiscretizationInt64 *New(TypeOfTimeDiscretization type);
- MEDCouplingTimeDiscretizationInt64 *performCopyOrIncrRef(bool deepCopy) const;
+ MEDCouplingTimeDiscretizationInt64 *performCopyOrIncrRef(bool deepCopy) const override;
bool isEqualIfNotWhy(const MEDCouplingTimeDiscretizationTemplate<Int64> *other, Int64 prec, std::string& reason) const override;
bool isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretizationTemplate<Int64> *other, Int64 prec) const override;
};
class MEDCouplingTimeDiscretizationFloat : public MEDCouplingTimeDiscretizationSimple<float>
{
public:
- MEDCouplingTimeDiscretizationFloat() { }
+ MEDCouplingTimeDiscretizationFloat() = default;
std::string getClassName() const override { return std::string("MEDCouplingTimeDiscretizationFloat"); }
MEDCouplingTimeDiscretizationFloat(const MEDCouplingTimeDiscretizationFloat& other, bool deepCopy);
static MEDCouplingTimeDiscretizationFloat *New(TypeOfTimeDiscretization type);
- MEDCouplingTimeDiscretizationFloat *performCopyOrIncrRef(bool deepCopy) const;
- bool isEqualIfNotWhy(const MEDCouplingTimeDiscretizationTemplate<float> *other, float prec, std::string& reason) const;
- bool isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretizationTemplate<float> *other, float prec) const;
+ MEDCouplingTimeDiscretizationFloat *performCopyOrIncrRef(bool deepCopy) const override;
+ bool isEqualIfNotWhy(const MEDCouplingTimeDiscretizationTemplate<float> *other, float prec, std::string& reason) const override;
+ bool isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretizationTemplate<float> *other, float prec) const override;
private:
static const TypeOfTimeDiscretization DISCRETIZATION=ONE_TIME;
};
public:
MEDCOUPLING_EXPORT MEDCouplingNoTimeLabel();
MEDCOUPLING_EXPORT MEDCouplingNoTimeLabel(const MEDCouplingTimeDiscretization& other, bool deepCopy);
- MEDCOUPLING_EXPORT std::string getStringRepr() const;
+ MEDCOUPLING_EXPORT std::string getStringRepr() const override;
MEDCOUPLING_EXPORT std::string getClassName() const override { return std::string("MEDCouplingNoTimeLabel"); }
- MEDCOUPLING_EXPORT TypeOfTimeDiscretization getEnum() const { return DISCRETIZATION; }
- MEDCOUPLING_EXPORT void synchronizeTimeWith(const MEDCouplingMesh *mesh);
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *aggregate(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *aggregate(const std::vector<const MEDCouplingTimeDiscretization *>& other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *meld(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *dot(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *crossProduct(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *max(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *min(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *add(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT void addEqual(const MEDCouplingTimeDiscretization *other);
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *substract(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT void substractEqual(const MEDCouplingTimeDiscretization *other);
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *multiply(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT void multiplyEqual(const MEDCouplingTimeDiscretization *other);
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *divide(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT void divideEqual(const MEDCouplingTimeDiscretization *other);
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *pow(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT void powEqual(const MEDCouplingTimeDiscretization *other);
- MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec, std::string& reason) const;
- MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec) const;
- MEDCOUPLING_EXPORT bool areCompatible(const MEDCouplingTimeDiscretizationTemplate<double> *other) const;
- MEDCOUPLING_EXPORT bool areStrictlyCompatible(const MEDCouplingTimeDiscretizationTemplate<double> *other, std::string& reason) const;
- MEDCOUPLING_EXPORT bool areStrictlyCompatibleForMul(const MEDCouplingTimeDiscretizationTemplate<double> *other) const;
- MEDCOUPLING_EXPORT bool areStrictlyCompatibleForDiv(const MEDCouplingTimeDiscretizationTemplate<double> *other) const;
- MEDCOUPLING_EXPORT bool areCompatibleForMeld(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *performCopyOrIncrRef(bool deepCopy) const;
- MEDCOUPLING_EXPORT void checkNoTimePresence() const { }
- MEDCOUPLING_EXPORT void checkTimePresence(double time) const;
- MEDCOUPLING_EXPORT std::vector< const DataArrayDouble *> getArraysForTime(double time) const;
- MEDCOUPLING_EXPORT void getValueForTime(double time, const std::vector<double>& vals, double *res) const;
- MEDCOUPLING_EXPORT bool isBefore(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT bool isStrictlyBefore(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT double getStartTime(int& iteration, int& order) const;
- MEDCOUPLING_EXPORT double getEndTime(int& iteration, int& order) const;
- MEDCOUPLING_EXPORT void setStartIteration(int it);
- MEDCOUPLING_EXPORT void setEndIteration(int it);
- MEDCOUPLING_EXPORT void setStartOrder(int order);
- MEDCOUPLING_EXPORT void setEndOrder(int order);
- MEDCOUPLING_EXPORT void setStartTimeValue(double time);
- MEDCOUPLING_EXPORT void setEndTimeValue(double time);
- MEDCOUPLING_EXPORT void setStartTime(double time, int iteration, int order);
- MEDCOUPLING_EXPORT void setEndTime(double time, int iteration, int order);
- MEDCOUPLING_EXPORT void getValueOnTime(mcIdType eltId, double time, double *value) const;
- MEDCOUPLING_EXPORT void getValueOnDiscTime(mcIdType eltId, int iteration, int order, double *value) const;
- MEDCOUPLING_EXPORT void getTinySerializationIntInformation2(std::vector<mcIdType>& tinyInfo) const;
- MEDCOUPLING_EXPORT void getTinySerializationDbleInformation2(std::vector<double>& tinyInfo) const;
- MEDCOUPLING_EXPORT void finishUnserialization2(const std::vector<mcIdType>& tinyInfoI, const std::vector<double>& tinyInfoD);
+ MEDCOUPLING_EXPORT TypeOfTimeDiscretization getEnum() const override { return DISCRETIZATION; }
+ MEDCOUPLING_EXPORT void synchronizeTimeWith(const MEDCouplingMesh *mesh) override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *aggregate(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *aggregate(const std::vector<const MEDCouplingTimeDiscretization *>& other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *meld(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *dot(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *crossProduct(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *max(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *min(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *add(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT void addEqual(const MEDCouplingTimeDiscretization *other) override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *substract(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT void substractEqual(const MEDCouplingTimeDiscretization *other) override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *multiply(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT void multiplyEqual(const MEDCouplingTimeDiscretization *other) override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *divide(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT void divideEqual(const MEDCouplingTimeDiscretization *other) override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *pow(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT void powEqual(const MEDCouplingTimeDiscretization *other) override;
+ MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec, std::string& reason) const override;
+ MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec) const override;
+ MEDCOUPLING_EXPORT bool areCompatible(const MEDCouplingTimeDiscretizationTemplate<double> *other) const override;
+ MEDCOUPLING_EXPORT bool areStrictlyCompatible(const MEDCouplingTimeDiscretizationTemplate<double> *other, std::string& reason) const override;
+ MEDCOUPLING_EXPORT bool areStrictlyCompatibleForMul(const MEDCouplingTimeDiscretizationTemplate<double> *other) const override;
+ MEDCOUPLING_EXPORT bool areStrictlyCompatibleForDiv(const MEDCouplingTimeDiscretizationTemplate<double> *other) const override;
+ MEDCOUPLING_EXPORT bool areCompatibleForMeld(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *performCopyOrIncrRef(bool deepCopy) const override;
+ MEDCOUPLING_EXPORT void checkNoTimePresence() const override { }
+ MEDCOUPLING_EXPORT void checkTimePresence(double time) const override;
+ MEDCOUPLING_EXPORT std::vector< const DataArrayDouble *> getArraysForTime(double time) const override;
+ MEDCOUPLING_EXPORT void getValueForTime(double time, const std::vector<double>& vals, double *res) const override;
+ MEDCOUPLING_EXPORT bool isBefore(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT bool isStrictlyBefore(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT double getStartTime(int& iteration, int& order) const override;
+ MEDCOUPLING_EXPORT double getEndTime(int& iteration, int& order) const override;
+ MEDCOUPLING_EXPORT void setStartIteration(int it) override;
+ MEDCOUPLING_EXPORT void setEndIteration(int it) override;
+ MEDCOUPLING_EXPORT void setStartOrder(int order) override;
+ MEDCOUPLING_EXPORT void setEndOrder(int order) override;
+ MEDCOUPLING_EXPORT void setStartTimeValue(double time) override;
+ MEDCOUPLING_EXPORT void setEndTimeValue(double time) override;
+ MEDCOUPLING_EXPORT void setStartTime(double time, int iteration, int order) override;
+ MEDCOUPLING_EXPORT void setEndTime(double time, int iteration, int order) override;
+ MEDCOUPLING_EXPORT void getValueOnTime(mcIdType eltId, double time, double *value) const override;
+ MEDCOUPLING_EXPORT void getValueOnDiscTime(mcIdType eltId, int iteration, int order, double *value) const override;
+ MEDCOUPLING_EXPORT void getTinySerializationIntInformation2(std::vector<mcIdType>& tinyInfo) const override;
+ MEDCOUPLING_EXPORT void getTinySerializationDbleInformation2(std::vector<double>& tinyInfo) const override;
+ MEDCOUPLING_EXPORT void finishUnserialization2(const std::vector<mcIdType>& tinyInfoI, const std::vector<double>& tinyInfoD) override;
public:
static const TypeOfTimeDiscretization DISCRETIZATION=NO_TIME;
MEDCOUPLING_EXPORT static const char REPR[];
public:
MEDCOUPLING_EXPORT MEDCouplingWithTimeStep();
MEDCOUPLING_EXPORT std::string getClassName() const override { return std::string("MEDCouplingWithTimeLabel"); }
- MEDCOUPLING_EXPORT std::string getStringRepr() const;
- MEDCOUPLING_EXPORT void copyTinyAttrFrom(const MEDCouplingTimeDiscretizationTemplate<double>& other);
- MEDCOUPLING_EXPORT TypeOfTimeDiscretization getEnum() const { return DISCRETIZATION; }
- MEDCOUPLING_EXPORT void synchronizeTimeWith(const MEDCouplingMesh *mesh);
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *aggregate(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *aggregate(const std::vector<const MEDCouplingTimeDiscretization *>& other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *meld(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *dot(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *crossProduct(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *max(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *min(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *add(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT void addEqual(const MEDCouplingTimeDiscretization *other);
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *substract(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT void substractEqual(const MEDCouplingTimeDiscretization *other);
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *multiply(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT void multiplyEqual(const MEDCouplingTimeDiscretization *other);
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *divide(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT void divideEqual(const MEDCouplingTimeDiscretization *other);
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *pow(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT void powEqual(const MEDCouplingTimeDiscretization *other);
- MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec, std::string& reason) const;
- MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec) const;
- MEDCOUPLING_EXPORT bool areCompatible(const MEDCouplingTimeDiscretizationTemplate<double> *other) const;
- MEDCOUPLING_EXPORT bool areStrictlyCompatible(const MEDCouplingTimeDiscretizationTemplate<double> *other, std::string& reason) const;
- MEDCOUPLING_EXPORT bool areStrictlyCompatibleForMul(const MEDCouplingTimeDiscretizationTemplate<double> *other) const;
- MEDCOUPLING_EXPORT bool areStrictlyCompatibleForDiv(const MEDCouplingTimeDiscretizationTemplate<double> *other) const;
- MEDCOUPLING_EXPORT bool areCompatibleForMeld(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT void getTinySerializationIntInformation(std::vector<mcIdType>& tinyInfo) const;
- MEDCOUPLING_EXPORT void getTinySerializationDbleInformation(std::vector<double>& tinyInfo) const;
- MEDCOUPLING_EXPORT void finishUnserialization(const std::vector<mcIdType>& tinyInfoI, const std::vector<double>& tinyInfoD, const std::vector<std::string>& tinyInfoS);
- MEDCOUPLING_EXPORT void getTinySerializationIntInformation2(std::vector<mcIdType>& tinyInfo) const;
- MEDCOUPLING_EXPORT void getTinySerializationDbleInformation2(std::vector<double>& tinyInfo) const;
- MEDCOUPLING_EXPORT void finishUnserialization2(const std::vector<mcIdType>& tinyInfoI, const std::vector<double>& tinyInfoD);
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *performCopyOrIncrRef(bool deepCopy) const;
- MEDCOUPLING_EXPORT void checkNoTimePresence() const;
- MEDCOUPLING_EXPORT void checkTimePresence(double time) const;
- MEDCOUPLING_EXPORT void setStartTime(double time, int iteration, int order) { _tk.setAllInfo(time,iteration,order); }
- MEDCOUPLING_EXPORT void setEndTime(double time, int iteration, int order) { _tk.setAllInfo(time,iteration,order); }
- MEDCOUPLING_EXPORT double getStartTime(int& iteration, int& order) const { return _tk.getAllInfo(iteration,order); }
- MEDCOUPLING_EXPORT double getEndTime(int& iteration, int& order) const { return _tk.getAllInfo(iteration,order); }
- MEDCOUPLING_EXPORT void setStartIteration(int it) { _tk.setIteration(it); }
- MEDCOUPLING_EXPORT void setEndIteration(int it) { _tk.setIteration(it); }
- MEDCOUPLING_EXPORT void setStartOrder(int order) { _tk.setOrder(order); }
- MEDCOUPLING_EXPORT void setEndOrder(int order) { _tk.setOrder(order); }
- MEDCOUPLING_EXPORT void setStartTimeValue(double time) { _tk.setTimeValue(time); }
- MEDCOUPLING_EXPORT void setEndTimeValue(double time) { _tk.setTimeValue(time); }
- MEDCOUPLING_EXPORT std::vector< const DataArrayDouble *> getArraysForTime(double time) const;
- MEDCOUPLING_EXPORT void getValueForTime(double time, const std::vector<double>& vals, double *res) const;
- MEDCOUPLING_EXPORT void getValueOnTime(mcIdType eltId, double time, double *value) const;
- MEDCOUPLING_EXPORT void getValueOnDiscTime(mcIdType eltId, int iteration, int order, double *value) const;
+ MEDCOUPLING_EXPORT std::string getStringRepr() const override;
+ MEDCOUPLING_EXPORT void copyTinyAttrFrom(const MEDCouplingTimeDiscretizationTemplate<double>& other) override;
+ MEDCOUPLING_EXPORT TypeOfTimeDiscretization getEnum() const override { return DISCRETIZATION; }
+ MEDCOUPLING_EXPORT void synchronizeTimeWith(const MEDCouplingMesh *mesh) override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *aggregate(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *aggregate(const std::vector<const MEDCouplingTimeDiscretization *>& other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *meld(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *dot(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *crossProduct(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *max(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *min(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *add(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT void addEqual(const MEDCouplingTimeDiscretization *other) override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *substract(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT void substractEqual(const MEDCouplingTimeDiscretization *other) override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *multiply(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT void multiplyEqual(const MEDCouplingTimeDiscretization *other) override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *divide(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT void divideEqual(const MEDCouplingTimeDiscretization *other) override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *pow(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT void powEqual(const MEDCouplingTimeDiscretization *other) override;
+ MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec, std::string& reason) const override;
+ MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec) const override;
+ MEDCOUPLING_EXPORT bool areCompatible(const MEDCouplingTimeDiscretizationTemplate<double> *other) const override;
+ MEDCOUPLING_EXPORT bool areStrictlyCompatible(const MEDCouplingTimeDiscretizationTemplate<double> *other, std::string& reason) const override;
+ MEDCOUPLING_EXPORT bool areStrictlyCompatibleForMul(const MEDCouplingTimeDiscretizationTemplate<double> *other) const override;
+ MEDCOUPLING_EXPORT bool areStrictlyCompatibleForDiv(const MEDCouplingTimeDiscretizationTemplate<double> *other) const override;
+ MEDCOUPLING_EXPORT bool areCompatibleForMeld(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT void getTinySerializationIntInformation(std::vector<mcIdType>& tinyInfo) const override;
+ MEDCOUPLING_EXPORT void getTinySerializationDbleInformation(std::vector<double>& tinyInfo) const override;
+ MEDCOUPLING_EXPORT void finishUnserialization(const std::vector<mcIdType>& tinyInfoI, const std::vector<double>& tinyInfoD, const std::vector<std::string>& tinyInfoS) override;
+ MEDCOUPLING_EXPORT void getTinySerializationIntInformation2(std::vector<mcIdType>& tinyInfo) const override;
+ MEDCOUPLING_EXPORT void getTinySerializationDbleInformation2(std::vector<double>& tinyInfo) const override;
+ MEDCOUPLING_EXPORT void finishUnserialization2(const std::vector<mcIdType>& tinyInfoI, const std::vector<double>& tinyInfoD) override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *performCopyOrIncrRef(bool deepCopy) const override;
+ MEDCOUPLING_EXPORT void checkNoTimePresence() const override;
+ MEDCOUPLING_EXPORT void checkTimePresence(double time) const override;
+ MEDCOUPLING_EXPORT void setStartTime(double time, int iteration, int order) override { _tk.setAllInfo(time,iteration,order); }
+ MEDCOUPLING_EXPORT void setEndTime(double time, int iteration, int order) override { _tk.setAllInfo(time,iteration,order); }
+ MEDCOUPLING_EXPORT double getStartTime(int& iteration, int& order) const override { return _tk.getAllInfo(iteration,order); }
+ MEDCOUPLING_EXPORT double getEndTime(int& iteration, int& order) const override { return _tk.getAllInfo(iteration,order); }
+ MEDCOUPLING_EXPORT void setStartIteration(int it) override { _tk.setIteration(it); }
+ MEDCOUPLING_EXPORT void setEndIteration(int it) override { _tk.setIteration(it); }
+ MEDCOUPLING_EXPORT void setStartOrder(int order) override { _tk.setOrder(order); }
+ MEDCOUPLING_EXPORT void setEndOrder(int order) override { _tk.setOrder(order); }
+ MEDCOUPLING_EXPORT void setStartTimeValue(double time) override { _tk.setTimeValue(time); }
+ MEDCOUPLING_EXPORT void setEndTimeValue(double time) override { _tk.setTimeValue(time); }
+ MEDCOUPLING_EXPORT std::vector< const DataArrayDouble *> getArraysForTime(double time) const override;
+ MEDCOUPLING_EXPORT void getValueForTime(double time, const std::vector<double>& vals, double *res) const override;
+ MEDCOUPLING_EXPORT void getValueOnTime(mcIdType eltId, double time, double *value) const override;
+ MEDCOUPLING_EXPORT void getValueOnDiscTime(mcIdType eltId, int iteration, int order, double *value) const override;
public:
static const TypeOfTimeDiscretization DISCRETIZATION=ONE_TIME;
MEDCOUPLING_EXPORT static const char REPR[];
public:
MEDCOUPLING_EXPORT MEDCouplingConstOnTimeInterval();
MEDCOUPLING_EXPORT std::string getClassName() const override { return std::string("MEDCouplingConstOnTimeInterval"); }
- MEDCOUPLING_EXPORT void copyTinyAttrFrom(const MEDCouplingTimeDiscretizationTemplate<double>& other);
- MEDCOUPLING_EXPORT void getTinySerializationIntInformation(std::vector<mcIdType>& tinyInfo) const;
- MEDCOUPLING_EXPORT void getTinySerializationDbleInformation(std::vector<double>& tinyInfo) const;
- MEDCOUPLING_EXPORT void finishUnserialization(const std::vector<mcIdType>& tinyInfoI, const std::vector<double>& tinyInfoD, const std::vector<std::string>& tinyInfoS);
- MEDCOUPLING_EXPORT void getTinySerializationIntInformation2(std::vector<mcIdType>& tinyInfo) const;
- MEDCOUPLING_EXPORT void getTinySerializationDbleInformation2(std::vector<double>& tinyInfo) const;
- MEDCOUPLING_EXPORT void finishUnserialization2(const std::vector<mcIdType>& tinyInfoI, const std::vector<double>& tinyInfoD);
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *performCopyOrIncrRef(bool deepCopy) const;
- MEDCOUPLING_EXPORT bool areCompatible(const MEDCouplingTimeDiscretizationTemplate<double> *other) const;
- MEDCOUPLING_EXPORT bool areStrictlyCompatible(const MEDCouplingTimeDiscretizationTemplate<double> *other, std::string& reason) const;
- MEDCOUPLING_EXPORT bool areStrictlyCompatibleForMul(const MEDCouplingTimeDiscretizationTemplate<double> *other) const;
- MEDCOUPLING_EXPORT bool areStrictlyCompatibleForDiv(const MEDCouplingTimeDiscretizationTemplate<double> *other) const;
- MEDCOUPLING_EXPORT bool areCompatibleForMeld(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec, std::string& reason) const;
- MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec) const;
- MEDCOUPLING_EXPORT std::vector< const DataArrayDouble *> getArraysForTime(double time) const;
- MEDCOUPLING_EXPORT void getValueForTime(double time, const std::vector<double>& vals, double *res) const;
- MEDCOUPLING_EXPORT void getValueOnTime(mcIdType eltId, double time, double *value) const;
- MEDCOUPLING_EXPORT void getValueOnDiscTime(mcIdType eltId, int iteration, int order, double *value) const;
- MEDCOUPLING_EXPORT TypeOfTimeDiscretization getEnum() const { return DISCRETIZATION; }
- MEDCOUPLING_EXPORT void synchronizeTimeWith(const MEDCouplingMesh *mesh);
- MEDCOUPLING_EXPORT std::string getStringRepr() const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *aggregate(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *aggregate(const std::vector<const MEDCouplingTimeDiscretization *>& other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *meld(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *dot(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *crossProduct(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *max(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *min(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *add(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT void addEqual(const MEDCouplingTimeDiscretization *other);
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *substract(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT void substractEqual(const MEDCouplingTimeDiscretization *other);
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *multiply(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT void multiplyEqual(const MEDCouplingTimeDiscretization *other);
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *divide(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT void divideEqual(const MEDCouplingTimeDiscretization *other);
- MEDCouplingTimeDiscretization *pow(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT void powEqual(const MEDCouplingTimeDiscretization *other);
- MEDCOUPLING_EXPORT void setStartTime(double time, int iteration, int order) { _start.setAllInfo(time,iteration,order); }
- MEDCOUPLING_EXPORT void setEndTime(double time, int iteration, int order) { _end.setAllInfo(time,iteration,order); }
- MEDCOUPLING_EXPORT double getStartTime(int& iteration, int& order) const { return _start.getAllInfo(iteration,order); }
- MEDCOUPLING_EXPORT double getEndTime(int& iteration, int& order) const { return _end.getAllInfo(iteration,order); }
- MEDCOUPLING_EXPORT void setStartIteration(int it) { _start.setIteration(it); }
- MEDCOUPLING_EXPORT void setEndIteration(int it) { _end.setIteration(it); }
- MEDCOUPLING_EXPORT void setStartOrder(int order) { _start.setOrder(order); }
- MEDCOUPLING_EXPORT void setEndOrder(int order) { _end.setOrder(order); }
- MEDCOUPLING_EXPORT void setStartTimeValue(double time) { _start.setTimeValue(time); }
- MEDCOUPLING_EXPORT void setEndTimeValue(double time) { _end.setTimeValue(time); }
- MEDCOUPLING_EXPORT void checkNoTimePresence() const;
- MEDCOUPLING_EXPORT void checkTimePresence(double time) const;
+ MEDCOUPLING_EXPORT void copyTinyAttrFrom(const MEDCouplingTimeDiscretizationTemplate<double>& other) override;
+ MEDCOUPLING_EXPORT void getTinySerializationIntInformation(std::vector<mcIdType>& tinyInfo) const override;
+ MEDCOUPLING_EXPORT void getTinySerializationDbleInformation(std::vector<double>& tinyInfo) const override;
+ MEDCOUPLING_EXPORT void finishUnserialization(const std::vector<mcIdType>& tinyInfoI, const std::vector<double>& tinyInfoD, const std::vector<std::string>& tinyInfoS) override;
+ MEDCOUPLING_EXPORT void getTinySerializationIntInformation2(std::vector<mcIdType>& tinyInfo) const override;
+ MEDCOUPLING_EXPORT void getTinySerializationDbleInformation2(std::vector<double>& tinyInfo) const override;
+ MEDCOUPLING_EXPORT void finishUnserialization2(const std::vector<mcIdType>& tinyInfoI, const std::vector<double>& tinyInfoD) override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *performCopyOrIncrRef(bool deepCopy) const override;
+ MEDCOUPLING_EXPORT bool areCompatible(const MEDCouplingTimeDiscretizationTemplate<double> *other) const override;
+ MEDCOUPLING_EXPORT bool areStrictlyCompatible(const MEDCouplingTimeDiscretizationTemplate<double> *other, std::string& reason) const override;
+ MEDCOUPLING_EXPORT bool areStrictlyCompatibleForMul(const MEDCouplingTimeDiscretizationTemplate<double> *other) const override;
+ MEDCOUPLING_EXPORT bool areStrictlyCompatibleForDiv(const MEDCouplingTimeDiscretizationTemplate<double> *other) const override;
+ MEDCOUPLING_EXPORT bool areCompatibleForMeld(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec, std::string& reason) const override;
+ MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec) const override;
+ MEDCOUPLING_EXPORT std::vector< const DataArrayDouble *> getArraysForTime(double time) const override;
+ MEDCOUPLING_EXPORT void getValueForTime(double time, const std::vector<double>& vals, double *res) const override;
+ MEDCOUPLING_EXPORT void getValueOnTime(mcIdType eltId, double time, double *value) const override;
+ MEDCOUPLING_EXPORT void getValueOnDiscTime(mcIdType eltId, int iteration, int order, double *value) const override;
+ MEDCOUPLING_EXPORT TypeOfTimeDiscretization getEnum() const override { return DISCRETIZATION; }
+ MEDCOUPLING_EXPORT void synchronizeTimeWith(const MEDCouplingMesh *mesh) override;
+ MEDCOUPLING_EXPORT std::string getStringRepr() const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *aggregate(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *aggregate(const std::vector<const MEDCouplingTimeDiscretization *>& other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *meld(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *dot(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *crossProduct(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *max(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *min(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *add(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT void addEqual(const MEDCouplingTimeDiscretization *other) override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *substract(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT void substractEqual(const MEDCouplingTimeDiscretization *other) override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *multiply(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT void multiplyEqual(const MEDCouplingTimeDiscretization *other) override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *divide(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT void divideEqual(const MEDCouplingTimeDiscretization *other) override;
+ MEDCouplingTimeDiscretization *pow(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT void powEqual(const MEDCouplingTimeDiscretization *other) override;
+ MEDCOUPLING_EXPORT void setStartTime(double time, int iteration, int order) override { _start.setAllInfo(time,iteration,order); }
+ MEDCOUPLING_EXPORT void setEndTime(double time, int iteration, int order) override { _end.setAllInfo(time,iteration,order); }
+ MEDCOUPLING_EXPORT double getStartTime(int& iteration, int& order) const override { return _start.getAllInfo(iteration,order); }
+ MEDCOUPLING_EXPORT double getEndTime(int& iteration, int& order) const override { return _end.getAllInfo(iteration,order); }
+ MEDCOUPLING_EXPORT void setStartIteration(int it) override { _start.setIteration(it); }
+ MEDCOUPLING_EXPORT void setEndIteration(int it) override { _end.setIteration(it); }
+ MEDCOUPLING_EXPORT void setStartOrder(int order) override { _start.setOrder(order); }
+ MEDCOUPLING_EXPORT void setEndOrder(int order) override { _end.setOrder(order); }
+ MEDCOUPLING_EXPORT void setStartTimeValue(double time) override { _start.setTimeValue(time); }
+ MEDCOUPLING_EXPORT void setEndTimeValue(double time) override { _end.setTimeValue(time); }
+ MEDCOUPLING_EXPORT void checkNoTimePresence() const override;
+ MEDCOUPLING_EXPORT void checkTimePresence(double time) const override;
public:
static const TypeOfTimeDiscretization DISCRETIZATION=CONST_ON_TIME_INTERVAL;
MEDCOUPLING_EXPORT static const char REPR[];
protected:
MEDCOUPLING_EXPORT MEDCouplingTwoTimeSteps(const MEDCouplingTwoTimeSteps& other, bool deepCopy);
MEDCOUPLING_EXPORT MEDCouplingTwoTimeSteps();
- MEDCOUPLING_EXPORT ~MEDCouplingTwoTimeSteps();
+ MEDCOUPLING_EXPORT ~MEDCouplingTwoTimeSteps() override;
public:
MEDCOUPLING_EXPORT std::string getClassName() const override { return std::string("MEDCouplingTwoTimeSteps"); }
- MEDCOUPLING_EXPORT void updateTime() const;
- MEDCOUPLING_EXPORT void synchronizeTimeWith(const MEDCouplingMesh *mesh);
- MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- MEDCOUPLING_EXPORT void copyTinyAttrFrom(const MEDCouplingTimeDiscretizationTemplate<double>& other);
- MEDCOUPLING_EXPORT void copyTinyStringsFrom(const MEDCouplingTimeDiscretizationTemplate<double>& other);
- MEDCOUPLING_EXPORT const DataArrayDouble *getEndArray() const;
- MEDCOUPLING_EXPORT DataArrayDouble *getEndArray();
- MEDCOUPLING_EXPORT void checkConsistencyLight() const;
- MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec, std::string& reason) const;
- MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec) const;
- MEDCOUPLING_EXPORT void checkNoTimePresence() const;
- MEDCOUPLING_EXPORT void checkTimePresence(double time) const;
- MEDCOUPLING_EXPORT void getArrays(std::vector<DataArrayDouble *>& arrays) const;
- MEDCOUPLING_EXPORT void setEndArray(DataArrayDouble *array, TimeLabel *owner);
- MEDCOUPLING_EXPORT void setStartTime(double time, int iteration, int order) { _start.setAllInfo(time,iteration,order); }
- MEDCOUPLING_EXPORT void setEndTime(double time, int iteration, int order) { _end.setAllInfo(time,iteration,order); }
- MEDCOUPLING_EXPORT double getStartTime(int& iteration, int& order) const { return _start.getAllInfo(iteration,order); }
- MEDCOUPLING_EXPORT double getEndTime(int& iteration, int& order) const { return _end.getAllInfo(iteration,order); }
- MEDCOUPLING_EXPORT void setStartIteration(int it) { _start.setIteration(it); }
- MEDCOUPLING_EXPORT void setEndIteration(int it) { _end.setIteration(it); }
- MEDCOUPLING_EXPORT void setStartOrder(int order) { _start.setOrder(order); }
- MEDCOUPLING_EXPORT void setEndOrder(int order) { _end.setOrder(order); }
- MEDCOUPLING_EXPORT void setStartTimeValue(double time) { _start.setTimeValue(time); }
- MEDCOUPLING_EXPORT void setEndTimeValue(double time) { _end.setTimeValue(time); }
- MEDCOUPLING_EXPORT void getTinySerializationIntInformation(std::vector<mcIdType>& tinyInfo) const;
- MEDCOUPLING_EXPORT void getTinySerializationDbleInformation(std::vector<double>& tinyInfo) const;
- MEDCOUPLING_EXPORT void getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const;
- MEDCOUPLING_EXPORT void resizeForUnserialization(const std::vector<mcIdType>& tinyInfoI, std::vector<DataArrayDouble *>& arrays);
- MEDCOUPLING_EXPORT void checkForUnserialization(const std::vector<mcIdType>& tinyInfoI, const std::vector<DataArrayDouble *>& arrays);
- MEDCOUPLING_EXPORT void finishUnserialization(const std::vector<mcIdType>& tinyInfoI, const std::vector<double>& tinyInfoD, const std::vector<std::string>& tinyInfoS);
- MEDCOUPLING_EXPORT void getTinySerializationIntInformation2(std::vector<mcIdType>& tinyInfo) const;
- MEDCOUPLING_EXPORT void getTinySerializationDbleInformation2(std::vector<double>& tinyInfo) const;
- MEDCOUPLING_EXPORT void finishUnserialization2(const std::vector<mcIdType>& tinyInfoI, const std::vector<double>& tinyInfoD);
- MEDCOUPLING_EXPORT std::vector< const DataArrayDouble *> getArraysForTime(double time) const;
- MEDCOUPLING_EXPORT void setArrays(const std::vector<DataArrayDouble *>& arrays, TimeLabel *owner);
+ MEDCOUPLING_EXPORT void updateTime() const override;
+ MEDCOUPLING_EXPORT void synchronizeTimeWith(const MEDCouplingMesh *mesh) override;
+ MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ MEDCOUPLING_EXPORT void copyTinyAttrFrom(const MEDCouplingTimeDiscretizationTemplate<double>& other) override;
+ MEDCOUPLING_EXPORT void copyTinyStringsFrom(const MEDCouplingTimeDiscretizationTemplate<double>& other) override;
+ MEDCOUPLING_EXPORT const DataArrayDouble *getEndArray() const override;
+ MEDCOUPLING_EXPORT DataArrayDouble *getEndArray() override;
+ MEDCOUPLING_EXPORT void checkConsistencyLight() const override;
+ MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec, std::string& reason) const override;
+ MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretizationTemplate<double> *other, double prec) const override;
+ MEDCOUPLING_EXPORT void checkNoTimePresence() const override;
+ MEDCOUPLING_EXPORT void checkTimePresence(double time) const override;
+ MEDCOUPLING_EXPORT void getArrays(std::vector<DataArrayDouble *>& arrays) const override;
+ MEDCOUPLING_EXPORT void setEndArray(DataArrayDouble *array, TimeLabel *owner) override;
+ MEDCOUPLING_EXPORT void setStartTime(double time, int iteration, int order) override { _start.setAllInfo(time,iteration,order); }
+ MEDCOUPLING_EXPORT void setEndTime(double time, int iteration, int order) override { _end.setAllInfo(time,iteration,order); }
+ MEDCOUPLING_EXPORT double getStartTime(int& iteration, int& order) const override { return _start.getAllInfo(iteration,order); }
+ MEDCOUPLING_EXPORT double getEndTime(int& iteration, int& order) const override { return _end.getAllInfo(iteration,order); }
+ MEDCOUPLING_EXPORT void setStartIteration(int it) override { _start.setIteration(it); }
+ MEDCOUPLING_EXPORT void setEndIteration(int it) override { _end.setIteration(it); }
+ MEDCOUPLING_EXPORT void setStartOrder(int order) override { _start.setOrder(order); }
+ MEDCOUPLING_EXPORT void setEndOrder(int order) override { _end.setOrder(order); }
+ MEDCOUPLING_EXPORT void setStartTimeValue(double time) override { _start.setTimeValue(time); }
+ MEDCOUPLING_EXPORT void setEndTimeValue(double time) override { _end.setTimeValue(time); }
+ MEDCOUPLING_EXPORT void getTinySerializationIntInformation(std::vector<mcIdType>& tinyInfo) const override;
+ MEDCOUPLING_EXPORT void getTinySerializationDbleInformation(std::vector<double>& tinyInfo) const override;
+ MEDCOUPLING_EXPORT void getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const override;
+ MEDCOUPLING_EXPORT void resizeForUnserialization(const std::vector<mcIdType>& tinyInfoI, std::vector<DataArrayDouble *>& arrays) override;
+ MEDCOUPLING_EXPORT void checkForUnserialization(const std::vector<mcIdType>& tinyInfoI, const std::vector<DataArrayDouble *>& arrays) override;
+ MEDCOUPLING_EXPORT void finishUnserialization(const std::vector<mcIdType>& tinyInfoI, const std::vector<double>& tinyInfoD, const std::vector<std::string>& tinyInfoS) override;
+ MEDCOUPLING_EXPORT void getTinySerializationIntInformation2(std::vector<mcIdType>& tinyInfo) const override;
+ MEDCOUPLING_EXPORT void getTinySerializationDbleInformation2(std::vector<double>& tinyInfo) const override;
+ MEDCOUPLING_EXPORT void finishUnserialization2(const std::vector<mcIdType>& tinyInfoI, const std::vector<double>& tinyInfoD) override;
+ MEDCOUPLING_EXPORT std::vector< const DataArrayDouble *> getArraysForTime(double time) const override;
+ MEDCOUPLING_EXPORT void setArrays(const std::vector<DataArrayDouble *>& arrays, TimeLabel *owner) override;
protected:
static const char EXCEPTION_MSG[];
protected:
MEDCOUPLING_EXPORT MEDCouplingLinearTime(const MEDCouplingLinearTime& other, bool deepCopy);
public:
MEDCOUPLING_EXPORT MEDCouplingLinearTime();
- MEDCOUPLING_EXPORT std::string getStringRepr() const;
- MEDCOUPLING_EXPORT TypeOfTimeDiscretization getEnum() const { return DISCRETIZATION; }
- MEDCOUPLING_EXPORT void checkConsistencyLight() const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *performCopyOrIncrRef(bool deepCopy) const;
- MEDCOUPLING_EXPORT bool areCompatible(const MEDCouplingTimeDiscretizationTemplate<double> *other) const;
- MEDCOUPLING_EXPORT bool areStrictlyCompatible(const MEDCouplingTimeDiscretizationTemplate<double> *other, std::string& reason) const;
- MEDCOUPLING_EXPORT bool areStrictlyCompatibleForMul(const MEDCouplingTimeDiscretizationTemplate<double> *other) const;
- MEDCOUPLING_EXPORT bool areStrictlyCompatibleForDiv(const MEDCouplingTimeDiscretizationTemplate<double> *other) const;
- MEDCOUPLING_EXPORT bool areCompatibleForMeld(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT void getValueForTime(double time, const std::vector<double>& vals, double *res) const;
- MEDCOUPLING_EXPORT void getValueOnTime(mcIdType eltId, double time, double *value) const;
- MEDCOUPLING_EXPORT void getValueOnDiscTime(mcIdType eltId, int iteration, int order, double *value) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *aggregate(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *aggregate(const std::vector<const MEDCouplingTimeDiscretization *>& other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *meld(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *dot(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *crossProduct(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *max(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *min(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *add(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT void addEqual(const MEDCouplingTimeDiscretization *other);
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *substract(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT void substractEqual(const MEDCouplingTimeDiscretization *other);
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *multiply(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT void multiplyEqual(const MEDCouplingTimeDiscretization *other);
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *divide(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT void divideEqual(const MEDCouplingTimeDiscretization *other);
- MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *pow(const MEDCouplingTimeDiscretization *other) const;
- MEDCOUPLING_EXPORT void powEqual(const MEDCouplingTimeDiscretization *other);
+ MEDCOUPLING_EXPORT std::string getStringRepr() const override;
+ MEDCOUPLING_EXPORT TypeOfTimeDiscretization getEnum() const override { return DISCRETIZATION; }
+ MEDCOUPLING_EXPORT void checkConsistencyLight() const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *performCopyOrIncrRef(bool deepCopy) const override;
+ MEDCOUPLING_EXPORT bool areCompatible(const MEDCouplingTimeDiscretizationTemplate<double> *other) const override;
+ MEDCOUPLING_EXPORT bool areStrictlyCompatible(const MEDCouplingTimeDiscretizationTemplate<double> *other, std::string& reason) const override;
+ MEDCOUPLING_EXPORT bool areStrictlyCompatibleForMul(const MEDCouplingTimeDiscretizationTemplate<double> *other) const override;
+ MEDCOUPLING_EXPORT bool areStrictlyCompatibleForDiv(const MEDCouplingTimeDiscretizationTemplate<double> *other) const override;
+ MEDCOUPLING_EXPORT bool areCompatibleForMeld(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT void getValueForTime(double time, const std::vector<double>& vals, double *res) const override;
+ MEDCOUPLING_EXPORT void getValueOnTime(mcIdType eltId, double time, double *value) const override;
+ MEDCOUPLING_EXPORT void getValueOnDiscTime(mcIdType eltId, int iteration, int order, double *value) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *aggregate(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *aggregate(const std::vector<const MEDCouplingTimeDiscretization *>& other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *meld(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *dot(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *crossProduct(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *max(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *min(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *add(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT void addEqual(const MEDCouplingTimeDiscretization *other) override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *substract(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT void substractEqual(const MEDCouplingTimeDiscretization *other) override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *multiply(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT void multiplyEqual(const MEDCouplingTimeDiscretization *other) override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *divide(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT void divideEqual(const MEDCouplingTimeDiscretization *other) override;
+ MEDCOUPLING_EXPORT MEDCouplingTimeDiscretization *pow(const MEDCouplingTimeDiscretization *other) const override;
+ MEDCOUPLING_EXPORT void powEqual(const MEDCouplingTimeDiscretization *other) override;
public:
static const TypeOfTimeDiscretization DISCRETIZATION=LINEAR_TIME;
MEDCOUPLING_EXPORT static const char REPR[];
#ifndef __MEDCOUPLINGTIMEDISCRETIZATION_TXX__
#define __MEDCOUPLINGTIMEDISCRETIZATION_TXX__
+#include "MEDCouplingRefCountObject.hxx"
+#include "MCType.hxx"
#include "MEDCouplingTimeDiscretization.hxx"
+#include "MEDCouplingTraits.hxx"
+#include "InterpKernelException.hxx"
#include "MEDCouplingMemArray.txx"
+#include <algorithm>
#include <cmath>
+#include <cstddef>
#include <sstream>
+#include <vector>
+#include <string>
namespace MEDCoupling
{
reason=oss.str();
return false;
}
- if(_array==0 && other->_array==0)
+ if(_array==nullptr && other->_array==nullptr)
return true;
- if(_array==0 || other->_array==0)
+ if(_array==nullptr || other->_array==nullptr)
{
reason="Field discretizations differ : Only one timediscretization between the two this and other has a DataArrayDouble for values defined";
return false;
{
if(std::fabs(_time_tolerance-other->_time_tolerance)>1.e-16)
return false;
- if(_array==0 && other->_array==0)
+ if(_array==nullptr && other->_array==nullptr)
return true;
- if(_array==0 || other->_array==0)
+ if(_array==nullptr || other->_array==nullptr)
return false;
if(_array->getNumberOfComponents()!=other->_array->getNumberOfComponents())
return false;
{
if(std::fabs(_time_tolerance-other->_time_tolerance)>1.e-16)
return false;
- if(_array==0 && other->_array==0)
+ if(_array==nullptr && other->_array==nullptr)
return true;
- if(_array==0 || other->_array==0)
+ if(_array==nullptr || other->_array==nullptr)
return false;
std::size_t nbC1(_array->getNumberOfComponents()),nbC2(other->_array->getNumberOfComponents());
- std::size_t nbMin(std::min(nbC1,nbC2));
+ std::size_t const nbMin(std::min(nbC1,nbC2));
if(nbC1!=nbC2 && nbMin!=1)
return false;
return true;
{
if(std::fabs(_time_tolerance-other->_time_tolerance)>1.e-16)
return false;
- if(_array==0 && other->_array==0)
+ if(_array==nullptr && other->_array==nullptr)
return true;
- if(_array==0 || other->_array==0)
+ if(_array==nullptr || other->_array==nullptr)
return false;
std::size_t nbC1(_array->getNumberOfComponents()),nbC2(other->_array->getNumberOfComponents());
if(nbC1!=nbC2 && nbC2!=1)
}
template<class T>
- MEDCouplingTimeDiscretizationTemplate<T>::MEDCouplingTimeDiscretizationTemplate():_time_tolerance(TIME_TOLERANCE_DFT),_array(0)
+ MEDCouplingTimeDiscretizationTemplate<T>::MEDCouplingTimeDiscretizationTemplate():_time_tolerance(TIME_TOLERANCE_DFT),_array(nullptr)
{
}
if(other._array)
_array=other._array->performCopyOrIncrRef(deepCopy);
else
- _array=0;
+ _array=nullptr;
}
template<class T>
}
template<class T>
- void MEDCouplingTimeDiscretizationTemplate<T>::setEndArray(typename Traits<T>::ArrayType *array, TimeLabel *owner)
+ void MEDCouplingTimeDiscretizationTemplate<T>::setEndArray(typename Traits<T>::ArrayType * /*array*/, TimeLabel * /*owner*/)
{
throw INTERP_KERNEL::Exception("setEndArray not available for this type of time discretization !");
}
template<class T>
void MEDCouplingTimeDiscretizationTemplate<T>::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
{
- std::size_t nbOfCompo(_array->getNumberOfComponents());
+ std::size_t const nbOfCompo(_array->getNumberOfComponents());
for(std::size_t i=0;i<nbOfCompo;i++)
tinyInfo.push_back(_array->getInfoOnComponent(i));
}
void MEDCouplingTimeDiscretizationTemplate<T>::resizeForUnserialization(const std::vector<mcIdType>& tinyInfoI, std::vector<typename Traits<T>::ArrayType *>& arrays)
{
arrays.resize(1);
- if(_array!=0)
+ if(_array!=nullptr)
_array->decrRef();
- typename Traits<T>::ArrayType *arr=0;
+ typename Traits<T>::ArrayType *arr=nullptr;
if(tinyInfoI[0]!=-1 && tinyInfoI[1]!=-1)
{
arr=Traits<T>::ArrayType::New();
static const char MSG[]="MEDCouplingTimeDiscretization::checkForUnserialization : arrays in input is expected to have size one !";
if(arrays.size()!=1)
throw INTERP_KERNEL::Exception(MSG);
- if(_array!=0)
+ if(_array!=nullptr)
_array->decrRef();
- _array=0;
+ _array=nullptr;
if(tinyInfoI[0]!=-1 && tinyInfoI[1]!=-1)
{
if(!arrays[0])
}
template<class T>
- void MEDCouplingTimeDiscretizationTemplate<T>::finishUnserialization(const std::vector<mcIdType>& tinyInfoI, const std::vector<double>& tinyInfoD, const std::vector<std::string>& tinyInfoS)
+ void MEDCouplingTimeDiscretizationTemplate<T>::finishUnserialization(const std::vector<mcIdType>& /*tinyInfoI*/, const std::vector<double>& tinyInfoD, const std::vector<std::string>& tinyInfoS)
{
_time_tolerance=tinyInfoD[0];
- std::size_t nbOfCompo=_array->getNumberOfComponents();
+ std::size_t const nbOfCompo=_array->getNumberOfComponents();
for(std::size_t i=0;i<nbOfCompo;i++)
_array->setInfoOnComponent(i,tinyInfoS[i]);
}
}
template<class T>
- double MEDCouplingTimeDiscretizationSimple<T>::getEndTime(int& iteration, int& order) const
+ double MEDCouplingTimeDiscretizationSimple<T>::getEndTime(int& /*iteration*/, int& /*order*/) const
{
throw INTERP_KERNEL::Exception("getEndTime : invalid for this type of time discr !");
}
template<class T>
- void MEDCouplingTimeDiscretizationSimple<T>::setEndIteration(int it)
+ void MEDCouplingTimeDiscretizationSimple<T>::setEndIteration(int /*it*/)
{
throw INTERP_KERNEL::Exception("setEndIteration : invalid for this type of time discr !");
}
template<class T>
- void MEDCouplingTimeDiscretizationSimple<T>::setEndOrder(int order)
+ void MEDCouplingTimeDiscretizationSimple<T>::setEndOrder(int /*order*/)
{
throw INTERP_KERNEL::Exception("setEndOrder : invalid for this type of time discr !");
}
template<class T>
- void MEDCouplingTimeDiscretizationSimple<T>::setEndTimeValue(double time)
+ void MEDCouplingTimeDiscretizationSimple<T>::setEndTimeValue(double /*time*/)
{
throw INTERP_KERNEL::Exception("setEndTimeValue : invalid for this type of time discr !");
}
template<class T>
- void MEDCouplingTimeDiscretizationSimple<T>::setEndTime(double time, int iteration, int order)
+ void MEDCouplingTimeDiscretizationSimple<T>::setEndTime(double /*time*/, int /*iteration*/, int /*order*/)
{
throw INTERP_KERNEL::Exception("setEndTime : invalid for this type of time discr !");
}
#include "InterpKernelException.hxx"
+#include <atomic>
+#include <cstddef>
#include <limits>
using namespace MEDCoupling;
}
TimeLabel::~TimeLabel()
-{
-}
+= default;
-TimeLabel& TimeLabel::operator=(const TimeLabel& other)
+TimeLabel& TimeLabel::operator=(const TimeLabel& /*other*/)
{
_time=GLOBAL_TIME++;
return *this;
// Author : Anthony Geay (EDF R&D)
#include "MEDCouplingTraits.hxx"
+#include "MCType.hxx"
using namespace MEDCoupling;
#include "MEDCoupling.hxx"
#include "MCType.hxx"
-#include <vector>
namespace MEDCoupling
{
//
// Author : Anthony Geay (EDF R&D)
-#include "MEDCouplingUMesh.txx"
+#include "InterpKernelHashMap.hxx"
+#include "MCAuto.hxx"
+#include "MCIdType.hxx"
+#include "MCType.hxx"
+#include "InterpKernelException.hxx"
+#include "InterpKernelGeo2DPrecision.hxx"
#include "MEDCouplingCMesh.hxx"
#include "MEDCoupling1GTUMesh.hxx"
#include "MEDCouplingFieldDouble.hxx"
+#include "MEDCouplingPointSet.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingMesh.hxx"
+#include "MEDCouplingMemArray.txx"
#include "MEDCouplingSkyLineArray.hxx"
#include "CellModel.hxx"
+#include "MEDCouplingUMesh.txx"
+#include "NormalizedGeometricTypes"
+#include "NormalizedUnstructuredMesh.hxx"
+#include "VolSurfFormulae.hxx"
+#include "MEDCouplingTraits.hxx"
#include "VolSurfUser.txx"
#include "InterpolationUtils.hxx"
-#include "PointLocatorAlgos.txx"
-#include "BBTree.txx"
#include "BBTreeDst.txx"
-#include "SplitterTetra.hxx"
-#include "DiameterCalculator.hxx"
+#include "SplitterTetra.txx"
#include "DirectedBoundingBox.hxx"
#include "InterpKernelMatrixTools.hxx"
#include "InterpKernelMeshQuality.hxx"
#include "InterpKernelGeo2DEdgeArcCircle.hxx"
#include "InterpKernelAutoPtr.hxx"
#include "InterpKernelGeo2DNode.hxx"
-#include "InterpKernelGeo2DEdgeLin.hxx"
#include "InterpKernelGeo2DEdgeArcCircle.hxx"
#include "InterpKernelGeo2DQuadraticPolygon.hxx"
-#include "OrientationInverter.hxx"
#include "MEDCouplingUMesh_internal.hxx"
+#include "OrientationInverter.hxx"
+#include "DiameterCalculator.hxx"
+#include <map>
+#include <list>
+#include <memory>
+#include <set>
+#include <cstdlib>
+#include <algorithm>
+#include <functional>
+#include <iterator>
+#include <cmath>
+#include <ostream>
+#include <math.h>
#include <sstream>
-#include <fstream>
#include <numeric>
-#include <memory>
#include <cstring>
#include <limits>
-#include <list>
+#include <string>
+#include <utility>
+#include <vector>
using namespace MEDCoupling;
MEDCouplingUMesh *MEDCouplingUMesh::New(const std::string& meshName, int meshDim)
{
- MEDCouplingUMesh *ret=new MEDCouplingUMesh;
+ auto *ret=new MEDCouplingUMesh;
ret->setName(meshName);
ret->setMeshDimension(meshDim);
return ret;
{
if(!other)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::shallowCopyConnectivityFrom : input pointer is null !");
- const MEDCouplingUMesh *otherC=dynamic_cast<const MEDCouplingUMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingUMesh *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::shallowCopyConnectivityFrom : input pointer is not an MEDCouplingUMesh instance !");
- MEDCouplingUMesh *otherC2=const_cast<MEDCouplingUMesh *>(otherC);//sorry :(
+ auto *otherC2=const_cast<MEDCouplingUMesh *>(otherC);//sorry :(
setConnectivity(otherC2->getNodalConnectivity(),otherC2->getNodalConnectivityIndex(),true);
}
std::size_t MEDCouplingUMesh::getHeapMemorySizeWithoutChildren() const
{
- std::size_t ret(MEDCouplingPointSet::getHeapMemorySizeWithoutChildren());
+ std::size_t const ret(MEDCouplingPointSet::getHeapMemorySizeWithoutChildren());
return ret;
}
}
}
-MEDCouplingUMesh::MEDCouplingUMesh():_mesh_dim(-2),_nodal_connec(0),_nodal_connec_index(0)
+MEDCouplingUMesh::MEDCouplingUMesh():_mesh_dim(-2),_nodal_connec(nullptr),_nodal_connec_index(nullptr)
{
}
throw INTERP_KERNEL::Exception("No mesh dimension specified !");
if(_mesh_dim!=-1)
MEDCouplingPointSet::checkConsistencyLight();
- for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator iter=_types.begin();iter!=_types.end();iter++)
+ for(auto _type : _types)
{
- if(ToIdType(INTERP_KERNEL::CellModel::GetCellModel(*iter).getDimension())!=_mesh_dim)
+ if(ToIdType(INTERP_KERNEL::CellModel::GetCellModel(_type).getDimension())!=_mesh_dim)
{
std::ostringstream message;
- message << "Mesh invalid because dimension is " << _mesh_dim << " and there is presence of cell(s) with type " << (*iter);
+ message << "Mesh invalid because dimension is " << _mesh_dim << " and there is presence of cell(s) with type " << _type;
throw INTERP_KERNEL::Exception(message.str().c_str());
}
}
* \throw If number of nodes defining an element does not correspond to the type of element.
* \throw If the nodal connectivity includes an invalid node id.
*/
-void MEDCouplingUMesh::checkConsistency(double eps) const
+void MEDCouplingUMesh::checkConsistency(double /*eps*/) const
{
checkConsistencyLight();
if(_mesh_dim==-1)
return ;
- int meshDim=getMeshDimension();
- mcIdType nbOfNodes=getNumberOfNodes();
- mcIdType nbOfCells=getNumberOfCells();
+ int const meshDim=getMeshDimension();
+ mcIdType const nbOfNodes=getNumberOfNodes();
+ mcIdType const nbOfCells=getNumberOfCells();
const mcIdType *ptr=_nodal_connec->getConstPointer();
const mcIdType *ptrI=_nodal_connec_index->getConstPointer();
for(mcIdType i=0;i<nbOfCells;i++)
oss << "MEDCouplingUMesh::checkConsistency : cell << #" << i<< " with type Type " << cm.getRepr() << " in 'this' whereas meshdim == " << meshDim << " !";
throw INTERP_KERNEL::Exception(oss.str());
}
- mcIdType nbOfNodesInCell=ptrI[i+1]-ptrI[i]-1;
+ mcIdType const nbOfNodesInCell=ptrI[i+1]-ptrI[i]-1;
if(!cm.isDynamic())
if(nbOfNodesInCell!=ToIdType(cm.getNumberOfNodes()))
{
}
for(const mcIdType *w=ptr+ptrI[i]+1;w!=ptr+ptrI[i+1];w++)
{
- mcIdType nodeId=*w;
+ mcIdType const nodeId=*w;
if(nodeId>=0)
{
if(nodeId>=nbOfNodes)
const mcIdType *ptr(_nodal_connec->begin()),*ptrI(_nodal_connec_index->begin());
for(auto icell = 0 ; icell < nbOfCells ; ++icell)
{
- std::set<mcIdType> s(ptr+ptrI[icell]+1,ptr+ptrI[icell+1]);
+ std::set<mcIdType> const s(ptr+ptrI[icell]+1,ptr+ptrI[icell+1]);
if(ToIdType(s.size())==ptrI[icell+1]-ptrI[icell]-1)
continue;
std::ostringstream oss; oss << "MEDCouplingUMesh::checkGeomConsistency : for cell #" << icell << " presence of multiple same nodeID !";
void MEDCouplingUMesh::insertNextCell(INTERP_KERNEL::NormalizedCellType type, mcIdType size, const mcIdType *nodalConnOfCell)
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
- if(_nodal_connec_index==0)
+ if(_nodal_connec_index==nullptr)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::insertNextCell : nodal connectivity not set ! invoke allocateCells before calling insertNextCell !");
if(ToIdType(cm.getDimension())==_mesh_dim)
{
oss << " ! Expecting " << cm.getNumberOfNodes() << " !";
throw INTERP_KERNEL::Exception(oss.str());
}
- mcIdType idx=_nodal_connec_index->back();
- mcIdType val=idx+size+1;
+ mcIdType const idx=_nodal_connec_index->back();
+ mcIdType const val=idx+size+1;
_nodal_connec_index->pushBackSilent(val);
_nodal_connec->writeOnPlace(idx,type,nodalConnOfCell,size);
_types.insert(type);
{
std::vector<INTERP_KERNEL::NormalizedCellType> ret;
checkConnectivityFullyDefined();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
if(nbOfCells==0)
return ret;
if(getNodalConnectivityArrayLen()<1)
if(!other)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::isEqualIfNotWhy : input other pointer is null !");
std::ostringstream oss; oss.precision(15);
- const MEDCouplingUMesh *otherC=dynamic_cast<const MEDCouplingUMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingUMesh *>(other);
if(!otherC)
{
reason="mesh given in input is not castable in MEDCouplingUMesh !";
if(_types!=otherC->_types)
{
oss << "umesh geometric type mismatch :\nThis geometric types are :";
- for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator iter=_types.begin();iter!=_types.end();iter++)
- { const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(*iter); oss << cm.getRepr() << ", "; }
+ for(auto _type : _types)
+ { const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_type); oss << cm.getRepr() << ", "; }
oss << "\nOther geometric types are :";
- for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator iter=otherC->_types.begin();iter!=otherC->_types.end();iter++)
- { const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(*iter); oss << cm.getRepr() << ", "; }
+ for(auto _type : otherC->_types)
+ { const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_type); oss << cm.getRepr() << ", "; }
reason=oss.str();
return false;
}
- if(_nodal_connec!=0 || otherC->_nodal_connec!=0)
- if(_nodal_connec==0 || otherC->_nodal_connec==0)
+ if(_nodal_connec!=nullptr || otherC->_nodal_connec!=nullptr)
+ if(_nodal_connec==nullptr || otherC->_nodal_connec==nullptr)
{
reason="Only one UMesh between the two this and other has its nodal connectivity DataArrayInt defined !";
return false;
reason.insert(0,"Nodal connectivity DataArrayInt differ : ");
return false;
}
- if(_nodal_connec_index!=0 || otherC->_nodal_connec_index!=0)
- if(_nodal_connec_index==0 || otherC->_nodal_connec_index==0)
+ if(_nodal_connec_index!=nullptr || otherC->_nodal_connec_index!=nullptr)
+ if(_nodal_connec_index==nullptr || otherC->_nodal_connec_index==nullptr)
{
reason="Only one UMesh between the two this and other has its nodal connectivity index DataArrayInt defined !";
return false;
*/
bool MEDCouplingUMesh::isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const
{
- const MEDCouplingUMesh *otherC=dynamic_cast<const MEDCouplingUMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingUMesh *>(other);
if(!otherC)
return false;
if(!MEDCouplingPointSet::isEqualWithoutConsideringStr(other,prec))
return false;
if(_types!=otherC->_types)
return false;
- if(_nodal_connec!=0 || otherC->_nodal_connec!=0)
- if(_nodal_connec==0 || otherC->_nodal_connec==0)
+ if(_nodal_connec!=nullptr || otherC->_nodal_connec!=nullptr)
+ if(_nodal_connec==nullptr || otherC->_nodal_connec==nullptr)
return false;
if(_nodal_connec!=otherC->_nodal_connec)
if(!_nodal_connec->isEqualWithoutConsideringStr(*otherC->_nodal_connec))
return false;
- if(_nodal_connec_index!=0 || otherC->_nodal_connec_index!=0)
- if(_nodal_connec_index==0 || otherC->_nodal_connec_index==0)
+ if(_nodal_connec_index!=nullptr || otherC->_nodal_connec_index!=nullptr)
+ if(_nodal_connec_index==nullptr || otherC->_nodal_connec_index==nullptr)
return false;
if(_nodal_connec_index!=otherC->_nodal_connec_index)
if(!_nodal_connec_index->isEqualWithoutConsideringStr(*otherC->_nodal_connec_index))
void MEDCouplingUMesh::checkFastEquivalWith(const MEDCouplingMesh *other, double prec) const
{
MEDCouplingPointSet::checkFastEquivalWith(other,prec);
- const MEDCouplingUMesh *otherC=dynamic_cast<const MEDCouplingUMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingUMesh *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::checkFastEquivalWith : Two meshes are not not unstructured !");
}
void MEDCouplingUMesh::getReverseNodalConnectivity(DataArrayIdType *revNodal, DataArrayIdType *revNodalIndx) const
{
checkFullyDefined();
- mcIdType nbOfNodes(getNumberOfNodes());
- mcIdType *revNodalIndxPtr=(mcIdType *)malloc((nbOfNodes+1)*sizeof(mcIdType));
+ mcIdType const nbOfNodes(getNumberOfNodes());
+ auto *revNodalIndxPtr=(mcIdType *)malloc((nbOfNodes+1)*sizeof(mcIdType));
revNodalIndx->useArray(revNodalIndxPtr,true,DeallocType::C_DEALLOC,nbOfNodes+1,1);
std::fill(revNodalIndxPtr,revNodalIndxPtr+nbOfNodes+1,0);
const mcIdType *conn(_nodal_connec->begin()),*connIndex(_nodal_connec_index->begin());
}
}
std::transform(revNodalIndxPtr+1,revNodalIndxPtr+nbOfNodes+1,revNodalIndxPtr,revNodalIndxPtr+1,std::plus<mcIdType>());
- mcIdType *revNodalPtr=(mcIdType *)malloc(nbOfEltsInRevNodal*sizeof(mcIdType));
+ auto *revNodalPtr=(mcIdType *)malloc(nbOfEltsInRevNodal*sizeof(mcIdType));
revNodal->useArray(revNodalPtr,true,DeallocType::C_DEALLOC,nbOfEltsInRevNodal,1);
std::fill(revNodalPtr,revNodalPtr+nbOfEltsInRevNodal,-1);
for(mcIdType eltId=0;eltId<nbOfCells;eltId++)
if( targetDeltaLevel == -1 )
{
desc = DataArrayIdType::New(); descIndx = DataArrayIdType::New(); revDesc = DataArrayIdType::New(); revDescIndx = DataArrayIdType::New();
- MCAuto<MEDCouplingUMesh> ret( this->buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx) );
+ MCAuto<MEDCouplingUMesh> const ret( this->buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx) );
return ret;
}
if( targetDeltaLevel == -2 && this->getMeshDimension() == 3 )
{
desc = DataArrayIdType::New(); descIndx = DataArrayIdType::New(); revDesc = DataArrayIdType::New(); revDescIndx = DataArrayIdType::New();
- MCAuto<MEDCouplingUMesh> ret( this->explode3DMeshTo1D(desc,descIndx,revDesc,revDescIndx) );
+ MCAuto<MEDCouplingUMesh> const ret( this->explode3DMeshTo1D(desc,descIndx,revDesc,revDescIndx) );
return ret;
}
if( targetDeltaLevel == -this->getMeshDimension() )
{
- MCAuto<MEDCouplingUMesh> ret = MEDCouplingUMesh::Build0DMeshFromCoords( const_cast<DataArrayDouble *>( this->getCoords() ) );
+ MCAuto<MEDCouplingUMesh> const ret = MEDCouplingUMesh::Build0DMeshFromCoords( const_cast<DataArrayDouble *>( this->getCoords() ) );
MEDCouplingUMesh::DeleteCellTypeInIndexedArray(getNodalConnectivity(),getNodalConnectivityIndex(),desc,descIndx);
revDesc = DataArrayIdType::New(); revDescIndx = DataArrayIdType::New();
this->getReverseNodalConnectivity(revDesc,revDescIndx);
MCAuto<DataArrayIdType> revDesc=DataArrayIdType::New();
MCAuto<DataArrayIdType> revDescIndx=DataArrayIdType::New();
MCAuto<MEDCouplingUMesh> meshDM1=buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
- meshDM1=0;
+ meshDM1=nullptr;
ComputeNeighborsOfCellsAdv(desc,descIndx,revDesc,revDescIndx,neighbors,neighborsIndx);
}
nodeNeigh->checkNbOfComps(1,"MEDCouplingUMesh::computeCellNeighborhoodFromNodesOne : node neigh");
nodeNeighI->checkNbOfComps(1,"MEDCouplingUMesh::computeCellNeighborhoodFromNodesOne : node neigh index");
nodeNeighI->checkNbOfTuples(1+getNumberOfNodes(),"MEDCouplingUMesh::computeCellNeighborhoodFromNodesOne : invalid length");
- mcIdType nbCells=getNumberOfCells();
+ mcIdType const nbCells=getNumberOfCells();
const mcIdType *c(_nodal_connec->begin()),*ci(_nodal_connec_index->begin()),*ne(nodeNeigh->begin()),*nei(nodeNeighI->begin());
cellNeigh=DataArrayIdType::New(); cellNeigh->alloc(0,1); cellNeighIndex=DataArrayIdType::New(); cellNeighIndex->alloc(1,1); cellNeighIndex->setIJ(0,0,0);
for(mcIdType i=0;i<nbCells;i++)
const mcIdType *revDescPtr=revDesc->begin();
const mcIdType *revDescIPtr=revDescIndx->begin();
//
- mcIdType nbCells=descIndx->getNumberOfTuples()-1;
+ mcIdType const nbCells=descIndx->getNumberOfTuples()-1;
MCAuto<DataArrayIdType> out0=DataArrayIdType::New();
MCAuto<DataArrayIdType> out1=DataArrayIdType::New(); out1->alloc(nbCells+1,1);
mcIdType *out1Ptr=out1->getPointer();
MCAuto<MEDCouplingUMesh> MEDCouplingUMesh::explodeIntoEdges(MCAuto<DataArrayIdType>& desc, MCAuto<DataArrayIdType>& descIndex, MCAuto<DataArrayIdType>& revDesc, MCAuto<DataArrayIdType>& revDescIndx) const
{
checkFullyDefined();
- int mdim(getMeshDimension());
+ int const mdim(getMeshDimension());
desc=DataArrayIdType::New(); descIndex=DataArrayIdType::New(); revDesc=DataArrayIdType::New(); revDescIndx=DataArrayIdType::New();
MCAuto<MEDCouplingUMesh> mesh1D;
switch(mdim)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::computeNeighborsOfNodes : Mesh dimension supported are [3,2,1] !");
}
}
- desc=DataArrayIdType::New(); descIndx=DataArrayIdType::New(); revDesc=0; revDescIndx=0;
+ desc=DataArrayIdType::New(); descIndx=DataArrayIdType::New(); revDesc=nullptr; revDescIndx=nullptr;
mesh1D->getReverseNodalConnectivity(desc,descIndx);
MCAuto<DataArrayIdType> ret0(DataArrayIdType::New());
ret0->alloc(desc->getNumberOfTuples(),1);
void MEDCouplingUMesh::computeEnlargedNeighborsOfNodes(MCAuto<DataArrayIdType> &neighbors, MCAuto<DataArrayIdType>& neighborsIdx) const
{
checkFullyDefined();
- mcIdType nbOfNodes(getNumberOfNodes());
+ mcIdType const nbOfNodes(getNumberOfNodes());
const mcIdType *conn(_nodal_connec->begin()),*connIndex(_nodal_connec_index->begin());
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
std::vector< std::set<mcIdType> > st0(nbOfNodes);
for(mcIdType eltId=0;eltId<nbOfCells;eltId++)
{
const mcIdType *strtNdlConnOfCurCell(conn+connIndex[eltId]+1),*endNdlConnOfCurCell(conn+connIndex[eltId+1]);
std::set<mcIdType> s(strtNdlConnOfCurCell,endNdlConnOfCurCell); s.erase(-1); //for polyhedrons
- for(std::set<mcIdType>::const_iterator iter2=s.begin();iter2!=s.end();iter2++)
+ for(auto iter2=s.begin();iter2!=s.end();iter2++)
st0[*iter2].insert(s.begin(),s.end());
}
neighborsIdx=DataArrayIdType::New(); neighborsIdx->alloc(nbOfNodes+1,1); neighborsIdx->setIJ(0,0,0);
void MEDCouplingUMesh::convertToPolyTypes(const mcIdType *cellIdsToConvertBg, const mcIdType *cellIdsToConvertEnd)
{
checkFullyDefined();
- int dim=getMeshDimension();
+ int const dim=getMeshDimension();
if(dim<2 || dim>3)
throw INTERP_KERNEL::Exception("Invalid mesh dimension : must be 2 or 3 !");
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
if(dim==2)
{
const mcIdType *connIndex=_nodal_connec_index->begin();
for(mcIdType cellId=0;cellId<nbOfCells;cellId++)
{
mcIdType pos(connIndex[cellId]),posP1(connIndex[cellId+1]);
- mcIdType lgthOld(posP1-pos-1);
+ mcIdType const lgthOld(posP1-pos-1);
if(toBeDone[cellId])
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)connOld[pos]);
- unsigned nbOfFaces(cm.getNumberOfSons2(connOld+pos+1,lgthOld));
- mcIdType *tmp(new mcIdType[nbOfFaces*lgthOld+1]);
+ unsigned const nbOfFaces(cm.getNumberOfSons2(connOld+pos+1,lgthOld));
+ auto *tmp(new mcIdType[nbOfFaces*lgthOld+1]);
mcIdType *work=tmp; *work++=INTERP_KERNEL::NORM_POLYHED;
for(unsigned j=0;j<nbOfFaces;j++)
{
INTERP_KERNEL::NormalizedCellType type;
- unsigned offset=cm.fillSonCellNodalConnectivity2(j,connOld+pos+1,lgthOld,work,type);
+ unsigned const offset=cm.fillSonCellNodalConnectivity2(j,connOld+pos+1,lgthOld,work,type);
work+=offset;
*work++=-1;
}
- std::size_t newLgth(std::distance(tmp,work)-1);//-1 for last -1
+ std::size_t const newLgth(std::distance(tmp,work)-1);//-1 for last -1
connNew->pushBackValsSilent(tmp,tmp+newLgth);
connNewI->pushBackSilent(connNewI->back()+ToIdType(newLgth));
delete [] tmp;
*/
void MEDCouplingUMesh::convertAllToPoly()
{
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
std::vector<mcIdType> cellIds(nbOfCells);
for(mcIdType i=0;i<nbOfCells;i++)
cellIds[i]=i;
checkFullyDefined();
if(getMeshDimension()!=3 || getSpaceDimension()!=3)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::convertExtrudedPolyhedra works on umeshes with meshdim equal to 3 and spaceDim equal to 3 too!");
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
MCAuto<DataArrayIdType> newCi=DataArrayIdType::New();
newCi->alloc(nbOfCells+1,1);
mcIdType *newci=newCi->getPointer();
newci[0]=0;
for(mcIdType i=0;i<nbOfCells;i++)
{
- INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)c[ci[i]];
+ auto const type=(INTERP_KERNEL::NormalizedCellType)c[ci[i]];
if(type==INTERP_KERNEL::NORM_POLYHED)
{
if(std::count(c+ci[i]+1,c+ci[i+1],-1)!=0)
std::ostringstream oss; oss << "MEDCouplingUMesh::convertExtrudedPolyhedra : cell # " << i << " is a polhedron BUT it has NOT exactly 1 face !";
throw INTERP_KERNEL::Exception(oss.str());
}
- std::size_t n2=std::distance(c+ci[i]+1,c+ci[i+1]);
+ std::size_t const n2=std::distance(c+ci[i]+1,c+ci[i+1]);
if(n2%2!=0)
{
std::ostringstream oss; oss << "MEDCouplingUMesh::convertExtrudedPolyhedra : cell # " << i << " is a polhedron with 1 face but there is a mismatch of number of nodes in face should be even !";
throw INTERP_KERNEL::Exception(oss.str());
}
- mcIdType n1=ToIdType(n2/2);
+ mcIdType const n1=ToIdType(n2/2);
newci[i+1]=7*n1+2+newci[i];//6*n1 (nodal length) + n1+2 (number of faces) - 1 (number of '-1' separator is equal to number of faces -1) + 1 (for cell type)
}
else
mcIdType *newc=newC->getPointer();
for(mcIdType i=0;i<nbOfCells;i++)
{
- INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)c[ci[i]];
+ auto const type=(INTERP_KERNEL::NormalizedCellType)c[ci[i]];
if(type==INTERP_KERNEL::NORM_POLYHED)
{
- std::size_t n1=std::distance(c+ci[i]+1,c+ci[i+1])/2;
+ std::size_t const n1=std::distance(c+ci[i]+1,c+ci[i+1])/2;
newc=std::copy(c+ci[i],c+ci[i]+n1+1,newc);
*newc++=-1;
for(std::size_t j=0;j<n1;j++)
bool MEDCouplingUMesh::unPolyze()
{
checkFullyDefined();
- int mdim=getMeshDimension();
+ int const mdim=getMeshDimension();
if(mdim<0)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::unPolyze works on umeshes with meshdim equals to 0, 1 2 or 3 !");
if(mdim<=1)
return false;
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
if(nbOfCells<1)
return false;
- mcIdType initMeshLgth=getNodalConnectivityArrayLen();
+ mcIdType const initMeshLgth=getNodalConnectivityArrayLen();
mcIdType *conn=_nodal_connec->getPointer();
mcIdType *index=_nodal_connec_index->getPointer();
mcIdType posOfCurCell=0;
for(mcIdType i=0;i<nbOfCells;i++)
{
lgthOfCurCell=index[i+1]-posOfCurCell;
- INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)conn[posOfCurCell];
+ auto const type=(INTERP_KERNEL::NormalizedCellType)conn[posOfCurCell];
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
INTERP_KERNEL::NormalizedCellType newType=INTERP_KERNEL::NORM_ERROR;
mcIdType newLgth=0;
MCAuto<DataArrayDouble> coords=getCoords()->deepCopy();
coords->recenterForMaxPrecision(eps);
//
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
const mcIdType *conn=_nodal_connec->getConstPointer();
const mcIdType *index=_nodal_connec_index->getConstPointer();
MCAuto<DataArrayIdType> connINew=DataArrayIdType::New();
checkFullyDefined();
if(getMeshDimension()!=3 || getSpaceDimension()!=3)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::colinearizeEdges() : works with meshdim=3 and spaceDim=3!");
- double seps = sqrt(1-eps);
+ double const seps = sqrt(1-eps);
// Computing connectivities and correspondances : elements -> segments -> points
DAI E_Fi(DataArrayIdType::New()), E_F(DataArrayIdType::New()), F_Ei(DataArrayIdType::New()), F_E(DataArrayIdType::New()),
F_Si(DataArrayIdType::New()), F_S(DataArrayIdType::New()), S_Fi(DataArrayIdType::New()), S_F(DataArrayIdType::New()),
std::set<mcIdType> pt_rem;
const mcIdType *m_pi = m_p->getNodalConnectivityIndex()->begin(),
*m_pc = m_p->getNodalConnectivity()->begin();
- double (*coord)[3] = (double (*)[3]) getCoords()->begin();
+ auto *coord = (double (*)[3]) getCoords()->begin();
// Find all points only connected to exaclty 2 segments - they are the candidates for elimination
// Note that in 3D this can only happen for polyhedrons (when this happens at all)
DAI dsi = P_Si->deltaShiftIndex();
for (mcIdType j = 0; j < 2; j++)
for (mcIdType k = 0; k < 2; k++)
{
- mcIdType off1 = P_Sip[i] + j; // offset to get ID of the j-th seg (around the i-th point) in the point->seg correspondance
- mcIdType pt_id = P_Sp[off1] + k; // ID of the k-th point of the j-th seg in the point->seg correspondance
- mcIdType pt_id2 = S_Pp[S_Pip[pt_id]]; // ID of the point in the point mesh
+ mcIdType const off1 = P_Sip[i] + j; // offset to get ID of the j-th seg (around the i-th point) in the point->seg correspondance
+ mcIdType const pt_id = P_Sp[off1] + k; // ID of the k-th point of the j-th seg in the point->seg correspondance
+ mcIdType const pt_id2 = S_Pp[S_Pip[pt_id]]; // ID of the point in the point mesh
p[j][k] = m_pc[m_pi[pt_id2] + 1]; // Absolute ID, as read from the connectvity (+1 to skip type: NORM_POINT1)
// Just for fun, as initially written by Antoine :-)
// p[j][k] = m_pc[m_pi[S_P->getIJ(S_Pi->getIJ(P_S->getIJ(P_Si->getIJ(i, 0) + j, 0), 0) + k, 0)] + 1];
{
checkConnectivityFullyDefined();
const mcIdType *maxEltPt(std::max_element(_nodal_connec->begin(),_nodal_connec->end()));
- mcIdType maxElt(maxEltPt==_nodal_connec->end()?0:std::abs(*maxEltPt)+1);
+ mcIdType const maxElt(maxEltPt==_nodal_connec->end()?0:std::abs(*maxEltPt)+1);
std::vector<bool> retS(maxElt,false);
computeNodeIdsAlg(retS);
return DataArrayIdType::BuildListOfSwitchedOn(retS);
struct MEDCouplingAccVisit
{
- MEDCouplingAccVisit():_new_nb_of_nodes(0) { }
+ MEDCouplingAccVisit() = default;
mcIdType operator()(mcIdType val) { if(val!=-1) return _new_nb_of_nodes++; else return -1; }
- mcIdType _new_nb_of_nodes;
+ mcIdType _new_nb_of_nodes{0};
};
/// @endcond
DataArrayIdType *MEDCouplingUMesh::getNodeIdsInUse(mcIdType& nbrOfNodesInUse) const
{
nbrOfNodesInUse=-1;
- mcIdType nbOfNodes(getNumberOfNodes());
+ mcIdType const nbOfNodes(getNumberOfNodes());
MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
ret->alloc(nbOfNodes,1);
mcIdType *traducer=ret->getPointer();
std::fill(traducer,traducer+nbOfNodes,-1);
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
const mcIdType *connIndex=_nodal_connec_index->getConstPointer();
const mcIdType *conn=_nodal_connec->getConstPointer();
for(mcIdType i=0;i<nbOfCells;i++)
DataArrayIdType *MEDCouplingUMesh::computeNbOfNodesPerCell() const
{
checkConnectivityFullyDefined();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
ret->alloc(nbOfCells,1);
mcIdType *retPtr=ret->getPointer();
DataArrayIdType *MEDCouplingUMesh::computeEffectiveNbOfNodesPerCell() const
{
checkConnectivityFullyDefined();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
ret->alloc(nbOfCells,1);
mcIdType *retPtr=ret->getPointer();
DataArrayIdType *MEDCouplingUMesh::computeNbOfFacesPerCell() const
{
checkConnectivityFullyDefined();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
ret->alloc(nbOfCells,1);
mcIdType *retPtr=ret->getPointer();
*/
int MEDCouplingUMesh::AreCellsEqualPolicy1(const mcIdType *conn, const mcIdType *connI, mcIdType cell1, mcIdType cell2)
{
- mcIdType sz=connI[cell1+1]-connI[cell1];
+ mcIdType const sz=connI[cell1+1]-connI[cell1];
if(sz==connI[cell2+1]-connI[cell2])
{
if(conn[connI[cell1]]==conn[connI[cell2]])
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)conn[connI[cell1]]);
- unsigned dim=cm.getDimension();
+ unsigned const dim=cm.getDimension();
if(dim!=3)
{
if(dim!=1)
{
- mcIdType sz1=2*(sz-1);
+ mcIdType const sz1=2*(sz-1);
INTERP_KERNEL::AutoPtr<mcIdType> tmp=new mcIdType[sz1];
mcIdType *work=std::copy(conn+connI[cell1]+1,conn+connI[cell1+1],(mcIdType *)tmp);
std::copy(conn+connI[cell1]+1,conn+connI[cell1+1],work);
{
if(conn[connI[cell1]]==conn[connI[cell2]])
{
- std::set<mcIdType> s1(conn+connI[cell1]+1,conn+connI[cell1+1]);
- std::set<mcIdType> s2(conn+connI[cell2]+1,conn+connI[cell2+1]);
+ std::set<mcIdType> const s1(conn+connI[cell1]+1,conn+connI[cell1+1]);
+ std::set<mcIdType> const s2(conn+connI[cell2]+1,conn+connI[cell2+1]);
return s1==s2?1:0;
}
}
{
if(connI[cell1+1]-connI[cell1]==connI[cell2+1]-connI[cell2])
{
- std::set<mcIdType> s1(conn+connI[cell1]+1,conn+connI[cell1+1]);
- std::set<mcIdType> s2(conn+connI[cell2]+1,conn+connI[cell2+1]);
+ std::set<mcIdType> const s1(conn+connI[cell1]+1,conn+connI[cell1+1]);
+ std::set<mcIdType> const s2(conn+connI[cell2]+1,conn+connI[cell2+1]);
return s1==s2?1:0;
}
return 0;
*/
int MEDCouplingUMesh::AreCellsEqualPolicy7(const mcIdType *conn, const mcIdType *connI, mcIdType cell1, mcIdType cell2)
{
- mcIdType sz=connI[cell1+1]-connI[cell1];
+ mcIdType const sz=connI[cell1+1]-connI[cell1];
if(sz==connI[cell2+1]-connI[cell2])
{
if(conn[connI[cell1]]==conn[connI[cell2]])
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)conn[connI[cell1]]);
- unsigned dim=cm.getDimension();
+ unsigned const dim=cm.getDimension();
if(dim!=3)
{
if(dim!=1)
{
- mcIdType sz1=2*(sz-1);
+ mcIdType const sz1=2*(sz-1);
INTERP_KERNEL::AutoPtr<mcIdType> tmp=new mcIdType[sz1];
mcIdType *work=std::copy(conn+connI[cell1]+1,conn+connI[cell1+1],(mcIdType *)tmp);
std::copy(conn+connI[cell1]+1,conn+connI[cell1+1],work);
return 1;
else
{
- std::reverse_iterator<mcIdType *> it1((mcIdType *)tmp+sz1);
- std::reverse_iterator<mcIdType *> it2((mcIdType *)tmp);
+ std::reverse_iterator<mcIdType *> const it1((mcIdType *)tmp+sz1);
+ std::reverse_iterator<mcIdType *> const it2((mcIdType *)tmp);
if(std::search(it1,it2,conn+connI[cell2]+1,conn+connI[cell2+1])!=it2)
return 2;
else
return 1;
if(!cm.isQuadratic())
{
- std::reverse_iterator<const mcIdType *> it1(conn+connI[cell1+1]);
- std::reverse_iterator<const mcIdType *> it2(conn+connI[cell1]+1);
+ std::reverse_iterator<const mcIdType *> const it1(conn+connI[cell1+1]);
+ std::reverse_iterator<const mcIdType *> const it2(conn+connI[cell1]+1);
if(std::equal(it1,it2,conn+connI[cell2]+1))
return 2;
return 0;
DataArrayIdType *& commonCellsArr, DataArrayIdType *& commonCellsIArr)
{
MCAuto<DataArrayIdType> commonCells=DataArrayIdType::New(),commonCellsI=DataArrayIdType::New(); commonCells->alloc(0,1);
- mcIdType nbOfCells=nodalI->getNumberOfTuples()-1;
+ mcIdType const nbOfCells=nodalI->getNumberOfTuples()-1;
commonCellsI->reserve(1); commonCellsI->pushBackSilent(0);
const mcIdType *revNodalPtr=revNodal->getConstPointer(),*revNodalIPtr=revNodalI->getConstPointer();
const mcIdType *connPtr=nodal->getConstPointer(),*connIPtr=nodalI->getConstPointer();
{
v=v2;
const mcIdType *locRevNodal=std::find(revNodalPtr+revNodalIPtr[*connOfNode],revNodalPtr+revNodalIPtr[*connOfNode+1],i);
- std::vector<mcIdType>::iterator it=std::set_intersection(v.begin(),v.end(),locRevNodal,revNodalPtr+revNodalIPtr[*connOfNode+1],v2.begin());
+ auto const it=std::set_intersection(v.begin(),v.end(),locRevNodal,revNodalPtr+revNodalIPtr[*connOfNode+1],v2.begin());
v2.resize(std::distance(v2.begin(),it));
}
if(v2.size()>1)
{
if(AreCellsEqualInPool(v2,compType,connPtr,connIPtr,commonCells))
{
- mcIdType pos=commonCellsI->back();
+ mcIdType const pos=commonCellsI->back();
commonCellsI->pushBackSilent(commonCells->getNumberOfTuples());
for(const mcIdType *it=commonCells->begin()+pos;it!=commonCells->end();it++)
isFetched[*it]=true;
if(*connOfNode>=0)
{
v=v2;
- std::vector<mcIdType>::iterator it=std::set_intersection(v.begin(),v.end(),revNodalPtr+revNodalIPtr[*connOfNode],revNodalPtr+revNodalIPtr[*connOfNode+1],v2.begin());
+ auto const it=std::set_intersection(v.begin(),v.end(),revNodalPtr+revNodalIPtr[*connOfNode],revNodalPtr+revNodalIPtr[*connOfNode+1],v2.begin());
v2.resize(std::distance(v2.begin(),it));
}
// v2 contains now candidates. Problem candidates are sorted using id rank.
}
if(AreCellsEqualInPool(v2,compType,connPtr,connIPtr,commonCells))
{
- mcIdType newPos(commonCells->getNumberOfTuples());
- mcIdType pos(commonCellsI->back());
+ mcIdType const newPos(commonCells->getNumberOfTuples());
+ mcIdType const pos(commonCellsI->back());
std::sort(commonCells->getPointerSilent()+pos,commonCells->getPointerSilent()+newPos);
commonCellsI->pushBackSilent(newPos);
for(const mcIdType *it=commonCells->begin()+pos;it!=commonCells->end();it++)
bool MEDCouplingUMesh::areCellsIncludedIn(const MEDCouplingUMesh *other, int compType, DataArrayIdType *& arr) const
{
MCAuto<MEDCouplingUMesh> mesh=MergeUMeshesOnSameCoords(this,other);
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
static const int possibleCompType[]={0,1,2};
if(std::find(possibleCompType,possibleCompType+sizeof(possibleCompType)/sizeof(int),compType)==possibleCompType+sizeof(possibleCompType)/sizeof(int))
{
mcIdType newNbOfCells=-1;
MCAuto<DataArrayIdType> o2n = DataArrayIdType::ConvertIndexArrayToO2N(ToIdType(mesh->getNumberOfCells()),commonCells->begin(),commonCellsI->begin(),commonCellsI->end(),newNbOfCells);
MCAuto<DataArrayIdType> p0(o2n->selectByTupleIdSafeSlice(0,nbOfCells,1));
- mcIdType maxPart(p0->getMaxValueInArray());
- bool ret(maxPart==newNbOfCells-1);
+ mcIdType const maxPart(p0->getMaxValueInArray());
+ bool const ret(maxPart==newNbOfCells-1);
MCAuto<DataArrayIdType> p1(p0->invertArrayO2N2N2O(newNbOfCells));
// fill p1 array in case of presence of cells in other not in this
mcIdType *pt(p1->getPointer());
bool MEDCouplingUMesh::areCellsIncludedInPolicy7(const MEDCouplingUMesh *other, DataArrayIdType *& arr) const
{
MCAuto<MEDCouplingUMesh> mesh=MergeUMeshesOnSameCoords(this,other);
- DataArrayIdType *commonCells=0,*commonCellsI=0;
- mcIdType thisNbCells=getNumberOfCells();
+ DataArrayIdType *commonCells=nullptr,*commonCellsI=nullptr;
+ mcIdType const thisNbCells=getNumberOfCells();
mesh->findCommonCells(7,thisNbCells,commonCells,commonCellsI);
MCAuto<DataArrayIdType> commonCellsTmp(commonCells),commonCellsITmp(commonCellsI);
const mcIdType *commonCellsPtr=commonCells->getConstPointer(),*commonCellsIPtr=commonCellsI->getConstPointer();
- mcIdType otherNbCells=other->getNumberOfCells();
+ mcIdType const otherNbCells=other->getNumberOfCells();
MCAuto<DataArrayIdType> arr2=DataArrayIdType::New();
arr2->alloc(otherNbCells,1);
arr2->fillWithZero();
mcIdType *arr2Ptr=arr2->getPointer();
- mcIdType nbOfCommon=commonCellsI->getNumberOfTuples()-1;
+ mcIdType const nbOfCommon=commonCellsI->getNumberOfTuples()-1;
for(mcIdType i=0;i<nbOfCommon;i++)
{
- mcIdType start=commonCellsPtr[commonCellsIPtr[i]];
+ mcIdType const start=commonCellsPtr[commonCellsIPtr[i]];
if(start<thisNbCells)
{
for(mcIdType j=commonCellsIPtr[i]+1;j!=commonCellsIPtr[i+1];j++)
{
- mcIdType sig=commonCellsPtr[j]>0?1:-1;
- mcIdType val=std::abs(commonCellsPtr[j])-1;
+ mcIdType const sig=commonCellsPtr[j]>0?1:-1;
+ mcIdType const val=std::abs(commonCellsPtr[j])-1;
if(val>=thisNbCells)
arr2Ptr[val-thisNbCells]=sig*(start+1);
}
{
if(!other)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::mergeMyselfWithOnSameCoords : input other is null !");
- const MEDCouplingUMesh *otherC=dynamic_cast<const MEDCouplingUMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDCouplingUMesh *>(other);
if(!otherC)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::mergeMyselfWithOnSameCoords : the input other mesh is not of type unstructured !");
std::vector<const MEDCouplingUMesh *> ms(2);
return static_cast<MEDCouplingUMesh *>(MEDCouplingPointSet::buildPartOfMySelfSlice(start,end,step,keepCoords));
else
{
- mcIdType newNbOfCells=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"MEDCouplingUMesh::buildPartOfMySelfSlice for -1 dimension mesh ");
+ mcIdType const newNbOfCells=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"MEDCouplingUMesh::buildPartOfMySelfSlice for -1 dimension mesh ");
if(newNbOfCells!=1)
throw INTERP_KERNEL::Exception("-1D mesh has only one cell !");
if(start!=0)
oss << ", whereas other mesh dimension is set equal to " << otherOnSameCoordsThanThis.getMeshDimension() << " !";
throw INTERP_KERNEL::Exception(oss.str());
}
- mcIdType nbOfCellsToModify( ToIdType((std::distance(cellIdsBg,cellIdsEnd))));
+ mcIdType const nbOfCellsToModify( ToIdType((std::distance(cellIdsBg,cellIdsEnd))));
if(nbOfCellsToModify!=otherOnSameCoordsThanThis.getNumberOfCells())
{
std::ostringstream oss; oss << "MEDCouplingUMesh::setPartOfMySelf : cells ids length (" << nbOfCellsToModify << ") do not match the number of cells of other mesh (" << otherOnSameCoordsThanThis.getNumberOfCells() << ") !";
throw INTERP_KERNEL::Exception(oss.str());
}
- mcIdType nbOfCells(getNumberOfCells());
+ mcIdType const nbOfCells(getNumberOfCells());
bool easyAssign(true);
const mcIdType *connI(_nodal_connec_index->begin());
const mcIdType *connIOther=otherOnSameCoordsThanThis._nodal_connec_index->begin();
}
else
{
- DataArrayIdType *arrOut=0,*arrIOut=0;
+ DataArrayIdType *arrOut=nullptr,*arrIOut=nullptr;
DataArrayIdType::SetPartOfIndexedArrays(cellIdsBg,cellIdsEnd,_nodal_connec,_nodal_connec_index,otherOnSameCoordsThanThis._nodal_connec,otherOnSameCoordsThanThis._nodal_connec_index,
arrOut,arrIOut);
MCAuto<DataArrayIdType> arrOutAuto(arrOut),arrIOutAuto(arrIOut);
oss << ", whereas other mesh dimension is set equal to " << otherOnSameCoordsThanThis.getMeshDimension() << " !";
throw INTERP_KERNEL::Exception(oss.str());
}
- mcIdType nbOfCellsToModify=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"MEDCouplingUMesh::setPartOfMySelfSlice : ");
+ mcIdType const nbOfCellsToModify=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"MEDCouplingUMesh::setPartOfMySelfSlice : ");
if(nbOfCellsToModify!=otherOnSameCoordsThanThis.getNumberOfCells())
{
std::ostringstream oss; oss << "MEDCouplingUMesh::setPartOfMySelfSlice : cells ids length (" << nbOfCellsToModify << ") do not match the number of cells of other mesh (" << otherOnSameCoordsThanThis.getNumberOfCells() << ") !";
throw INTERP_KERNEL::Exception(oss.str());
}
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
bool easyAssign=true;
const mcIdType *connI=_nodal_connec_index->getConstPointer();
const mcIdType *connIOther=otherOnSameCoordsThanThis._nodal_connec_index->getConstPointer();
}
else
{
- DataArrayIdType *arrOut=0,*arrIOut=0;
+ DataArrayIdType *arrOut=nullptr,*arrIOut=nullptr;
DataArrayIdType::SetPartOfIndexedArraysSlice(start,end,step,_nodal_connec,_nodal_connec_index,otherOnSameCoordsThanThis._nodal_connec,otherOnSameCoordsThanThis._nodal_connec_index,
arrOut,arrIOut);
MCAuto<DataArrayIdType> arrOutAuto(arrOut),arrIOutAuto(arrIOut);
MCAuto<DataArrayIdType> desc,descIndx,revDesc,revDescIndx;
desc=DataArrayIdType::New(); descIndx=DataArrayIdType::New(); revDesc=DataArrayIdType::New(); revDescIndx=DataArrayIdType::New();
MCAuto<MEDCouplingUMesh> subMesh=buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
- desc=0; descIndx=0; revDesc=0; revDescIndx=0;
+ desc=nullptr; descIndx=nullptr; revDesc=nullptr; revDescIndx=nullptr;
return static_cast<MEDCouplingUMesh*>(subMesh->buildPartOfMySelfNode(begin,end,fullyIn));
}
revDesc->decrRef();
desc->decrRef();
descIndx->decrRef();
- mcIdType nbOfCells=meshDM1->getNumberOfCells();
+ mcIdType const nbOfCells=meshDM1->getNumberOfCells();
const mcIdType *revDescIndxC=revDescIndx->getConstPointer();
std::vector<mcIdType> boundaryCells;
for(mcIdType i=0;i<nbOfCells;i++)
MCAuto<DataArrayIdType> desc(DataArrayIdType::New()), descIndx(DataArrayIdType::New()), revDesc(DataArrayIdType::New()), revDescIndx(DataArrayIdType::New());
//
buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx)->decrRef();
- desc=(DataArrayIdType*)0; descIndx=(DataArrayIdType*)0;
+ desc=(DataArrayIdType*)nullptr; descIndx=(DataArrayIdType*)nullptr;
//
MCAuto<DataArrayIdType> tmp=revDescIndx->deltaShiftIndex();
- MCAuto<DataArrayIdType> faceIds=tmp->findIdsEqual(1); tmp=(DataArrayIdType*)0;
+ MCAuto<DataArrayIdType> faceIds=tmp->findIdsEqual(1); tmp=(DataArrayIdType*)nullptr;
const mcIdType *revDescPtr=revDesc->getConstPointer();
const mcIdType *revDescIndxPtr=revDescIndx->getConstPointer();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
std::vector<bool> ret1(nbOfCells,false);
mcIdType sz=0;
- for(const mcIdType *pt=faceIds->begin();pt!=faceIds->end();pt++)
- if(!ret1[revDescPtr[revDescIndxPtr[*pt]]])
- { ret1[revDescPtr[revDescIndxPtr[*pt]]]=true; sz++; }
+ for(long const pt : *faceIds)
+ if(!ret1[revDescPtr[revDescIndxPtr[pt]]])
+ { ret1[revDescPtr[revDescIndxPtr[pt]]]=true; sz++; }
//
ret2->alloc(sz,1);
mcIdType *ret2Ptr=ret2->getPointer();
MCAuto<DataArrayIdType> descThisPart=DataArrayIdType::New(),descIThisPart=DataArrayIdType::New(),revDescThisPart=DataArrayIdType::New(),revDescIThisPart=DataArrayIdType::New();
MCAuto<MEDCouplingUMesh> thisPartConsti=thisPart->buildDescendingConnectivity(descThisPart,descIThisPart,revDescThisPart,revDescIThisPart);
const mcIdType *revDescThisPartPtr=revDescThisPart->getConstPointer(),*revDescIThisPartPtr=revDescIThisPart->getConstPointer();
- DataArrayIdType *idsOtherInConsti=0;
- bool b=thisPartConsti->areCellsIncludedIn(&otherDimM1OnSameCoords,2,idsOtherInConsti);
- MCAuto<DataArrayIdType> idsOtherInConstiAuto(idsOtherInConsti);
+ DataArrayIdType *idsOtherInConsti=nullptr;
+ bool const b=thisPartConsti->areCellsIncludedIn(&otherDimM1OnSameCoords,2,idsOtherInConsti);
+ MCAuto<DataArrayIdType> const idsOtherInConstiAuto(idsOtherInConsti);
if(!b)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::findCellIdsLyingOn : the given mdim-1 mesh in other is not a constituent of this !");
std::set<mcIdType> s1;
- for(const mcIdType *idOther=idsOtherInConsti->begin();idOther!=idsOtherInConsti->end();idOther++)
- s1.insert(revDescThisPartPtr+revDescIThisPartPtr[*idOther],revDescThisPartPtr+revDescIThisPartPtr[*idOther+1]);
+ for(long const idOther : *idsOtherInConsti)
+ s1.insert(revDescThisPartPtr+revDescIThisPartPtr[idOther],revDescThisPartPtr+revDescIThisPartPtr[idOther+1]);
MCAuto<DataArrayIdType> s1arr_renum1=DataArrayIdType::New(); s1arr_renum1->alloc(s1.size(),1); std::copy(s1.begin(),s1.end(),s1arr_renum1->getPointer());
s1arr_renum1->sort();
cellIdsRk0=s0arr.retn();
MCAuto<DataArrayIdType> revDescIndx=DataArrayIdType::New();
//
MCAuto<MEDCouplingUMesh> meshDM1=buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
- revDesc=0; desc=0; descIndx=0;
+ revDesc=nullptr; desc=nullptr; descIndx=nullptr;
MCAuto<DataArrayIdType> revDescIndx2=revDescIndx->deltaShiftIndex();
MCAuto<DataArrayIdType> part=revDescIndx2->findIdsEqual(1);
return static_cast<MEDCouplingUMesh *>(meshDM1->buildPartOfMySelf(part->begin(),part->end(),true));
DAInt idsTmp0 = dsi->findIdsNotInRange(-1, 3); // for 2D: if a point is connected to more than 2 segs. For 3D: if a seg is connected to more than two faces.
if(idsTmp0->getNumberOfTuples())
throw INTERP_KERNEL::Exception("MEDFileUMesh::buildInnerBoundaryAlongM1Group: group is too complex: some points (or edges) have more than two connected segments (or faces)!");
- dt0=0; dit0=0; rdt0=0; rdit0=0; idsTmp0=0;
+ dt0=nullptr; dit0=nullptr; rdt0=nullptr; rdit0=nullptr; idsTmp0=nullptr;
// Get extreme nodes from the group (they won't be duplicated except if they also lie on bound of M0 -- see below),
// ie nodes belonging to the boundary "cells" (might be points) of M1
- DAInt xtremIdsM2 = dsi->findIdsEqual(1); dsi = 0;
+ DAInt const xtremIdsM2 = dsi->findIdsEqual(1); dsi = nullptr;
MCUMesh meshM2Part = static_cast<MEDCouplingUMesh *>(meshM2->buildPartOfMySelf(xtremIdsM2->begin(), xtremIdsM2->end(),true));
DAInt xtrem = meshM2Part->computeFetchedNodeIds();
// Remove from the list points on the boundary of the M0 mesh (those need duplication!).
// Think of a partial (plane) crack in a cube: the points at the tip of the crack and not located inside the volume of the cube are not duplicated
// although they are technically on the skin of the cube.
DAInt fNodes = m0skin->computeFetchedNodeIds();
- DAInt notDup = 0;
+ DAInt notDup = nullptr;
if (getMeshDimension() == 3)
{
DAInt dnu1=DataArrayIdType::New(), dnu2=DataArrayIdType::New(), dnu3=DataArrayIdType::New(), dnu4=DataArrayIdType::New();
MCUMesh m0skinDesc = m0skin->buildDescendingConnectivity(dnu1, dnu2, dnu3, dnu4); // all segments of the skin of the 3D (M0) mesh
- dnu1=0;dnu2=0;dnu3=0;dnu4=0;
- DataArrayIdType * corresp=0;
+ dnu1=nullptr;dnu2=nullptr;dnu3=nullptr;dnu4=nullptr;
+ DataArrayIdType * corresp=nullptr;
meshM2->areCellsIncludedIn(m0skinDesc,2,corresp);
// validIds is the list of segments which are on both the skin of *this*, and in the segments of the M1 group
// In the cube example above, this is a U-shaped polyline.
// algorithm would be duplicating too much ...
// This is a costly algorithm so only go into it if a simple (non sufficient) criteria is met: a node connected to more than 3 segs in meshM2:
dnu1=DataArrayIdType::New(), dnu2=DataArrayIdType::New(), dnu3=DataArrayIdType::New(), rdit0=DataArrayIdType::New();
- MCUMesh meshM2Desc = meshM2->buildDescendingConnectivity(dnu1, dnu2, dnu3, rdit0); // a mesh made of node cells
- dnu1=0;dnu2=0;dnu3=0;
- dsi = rdit0->deltaShiftIndex(); rdit0=0;
- DAInt singPoints = dsi->findIdsNotInRange(-1,4) ; dsi=0;// points connected to (strictly) more than 3 segments
+ MCUMesh const meshM2Desc = meshM2->buildDescendingConnectivity(dnu1, dnu2, dnu3, rdit0); // a mesh made of node cells
+ dnu1=nullptr;dnu2=nullptr;dnu3=nullptr;
+ dsi = rdit0->deltaShiftIndex(); rdit0=nullptr;
+ DAInt singPoints = dsi->findIdsNotInRange(-1,4) ; dsi=nullptr;// points connected to (strictly) more than 3 segments
if (singPoints->getNumberOfTuples())
{
DAInt boundNodes = m1IntersecSkin->computeFetchedNodeIds();
// If a point on this U-shape line is connected to cells which do not share any face with M1, then it
// should not be duplicated
// 1. Extract N D cells touching U-shape line:
- DAInt cellsAroundBN = getCellIdsLyingOnNodes(boundNodes->begin(), boundNodes->end(), false); // false= take cell in, even if not all nodes are in dupl
+ DAInt const cellsAroundBN = getCellIdsLyingOnNodes(boundNodes->begin(), boundNodes->end(), false); // false= take cell in, even if not all nodes are in dupl
MCUMesh mAroundBN = static_cast<MEDCouplingUMesh *>(this->buildPartOfMySelf(cellsAroundBN->begin(), cellsAroundBN->end(), true));
DAInt descBN=DataArrayIdType::New(), descIBN=DataArrayIdType::New(), revDescBN=DataArrayIdType::New(), revDescIBN=DataArrayIdType::New();
MCUMesh mAroundBNDesc = mAroundBN->buildDescendingConnectivity(descBN,descIBN,revDescBN,revDescIBN);
{
if (v >= nCellsDesc) // Keep valid match only
continue;
- mcIdType idx0 = revDescIBNP[v];
+ mcIdType const idx0 = revDescIBNP[v];
// Keep the two cells on either side of the face v of M1:
mcIdType c1=revDescBNP[idx0], c2=revDescBNP[idx0+1];
idsTouch->pushBackSilent(c1); idsTouch->pushBackSilent(c2);
}
// 3. Build complement
- DAInt idsTouchCompl = idsTouch->buildComplement(nCells);
+ DAInt const idsTouchCompl = idsTouch->buildComplement(nCells);
MCUMesh mAroundBNStrict = static_cast<MEDCouplingUMesh *>(mAroundBN->buildPartOfMySelf(idsTouchCompl->begin(), idsTouchCompl->end(), true));
DAInt nod3 = mAroundBNStrict->computeFetchedNodeIds();
DAInt inters = boundNodes->buildIntersection(nod3);
// Compute cell IDs of the mesh with cells that touch the M1 group with a least one node:
DAInt cellsAroundGroupLarge = getCellIdsLyingOnNodes(nodeIdsToDuplicateBg, nodeIdsToDuplicateEnd, false); // false= take cell in, even if not all nodes are in dupl
MCUMesh mAroundGrpLarge=static_cast<MEDCouplingUMesh *>(buildPartOfMySelf(cellsAroundGroupLarge->begin(),cellsAroundGroupLarge->end(),true));
- mcIdType nCellsLarge=cellsAroundGroupLarge->getNumberOfTuples();
+ mcIdType const nCellsLarge=cellsAroundGroupLarge->getNumberOfTuples();
DAInt descL=DataArrayIdType::New(),descIL=DataArrayIdType::New(),revDescL=DataArrayIdType::New(),revDescIL=DataArrayIdType::New();
MCUMesh mArGrpLargeDesc=mAroundGrpLarge->buildDescendingConnectivity(descL,descIL,revDescL,revDescIL);
const mcIdType *descILP=descIL->begin(), *descLP=descL->begin();
DataArrayIdType *idsOfM1t;
mArGrpLargeDesc->areCellsIncludedIn(&otherDimM1OnSameCoords,2, idsOfM1t);
DAInt idsOfM1Large(idsOfM1t);
- mcIdType nL = mArGrpLargeDesc->getNumberOfCells();
+ mcIdType const nL = mArGrpLargeDesc->getNumberOfCells();
// Computation of the neighbor information of the mesh WITH the crack (some neighbor links are removed):
// In the neighbor information remove the connection between high dimension cells and its low level constituents which are part
// of the frontier given in parameter (i.e. the cells of low dimension from the group delimiting the crack):
DAInt descLTrunc = descL->deepCopy(), descILTrunc = descIL->deepCopy();
DataArrayIdType::RemoveIdsFromIndexedArrays(idsOfM1Large->begin(), idsOfM1Large->end(),descLTrunc,descILTrunc);
- DataArrayIdType *neight=0, *neighIt=0;
+ DataArrayIdType *neight=nullptr, *neighIt=nullptr;
MEDCouplingUMesh::ComputeNeighborsOfCellsAdv(descLTrunc,descILTrunc,revDescL,revDescIL, neight, neighIt);
DAInt neighL(neight), neighIL(neighIt);
for(const auto& v: *idsOfM1Large)
{
if (v >= nL) continue; // Keep valid match only - see doc of areCellsIncludedIn()
- mcIdType idx0 = revDescILP[v];
+ mcIdType const idx0 = revDescILP[v];
// Retrieve the two cells on either side of the face v of M1:
mcIdType c1=revDescLP[idx0], c2=revDescLP[idx0+1];
std::map<mcIdType, mcIdType> toOther = {{c1, c2}, {c2, c1}};
// If a valid value was found, use it:
mcIdType val = sv.size()==1 ? *sv.begin() : 0;
// Hopefully this does not conflict with an potential value on the other side:
- mcIdType other = toOther[c];
+ mcIdType const other = toOther[c];
if (hitCellsLargeP[other])
{
if(val && hitCellsLargeP[other] != -val)
if (cellsRet1->getNumberOfTuples() + cellsRet2->getNumberOfTuples() != cellsAroundGroupLarge->getNumberOfTuples())
{
- DAInt nonHitCells = hitCellsLarge->findIdsEqual(0); // variable kept for debug ...
+ DAInt const nonHitCells = hitCellsLarge->findIdsEqual(0); // variable kept for debug ...
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::findCellsToRenumber: Some cells not hit - Internal error should not happen");
}
cellsRet1->transformWithIndArr(cellsAroundGroupLarge->begin(),cellsAroundGroupLarge->end());
*/
void MEDCouplingUMesh::duplicateNodes(const mcIdType *nodeIdsToDuplicateBg, const mcIdType *nodeIdsToDuplicateEnd)
{
- mcIdType nbOfNodes=getNumberOfNodes();
+ mcIdType const nbOfNodes=getNumberOfNodes();
duplicateNodesInCoords(nodeIdsToDuplicateBg,nodeIdsToDuplicateEnd);
duplicateNodesInConn(nodeIdsToDuplicateBg,nodeIdsToDuplicateEnd,nbOfNodes);
}
checkConnectivityFullyDefined();
mcIdType *conn(getNodalConnectivity()->getPointer());
const mcIdType *connIndex(getNodalConnectivityIndex()->getConstPointer());
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
for(mcIdType i=0;i<nbOfCells;i++)
for(mcIdType iconn=connIndex[i]+1;iconn!=connIndex[i+1];iconn++)
{
checkConnectivityFullyDefined();
mcIdType *conn=getNodalConnectivity()->getPointer();
const mcIdType *connIndex=getNodalConnectivityIndex()->getConstPointer();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
for(mcIdType i=0;i<nbOfCells;i++)
for(mcIdType iconn=connIndex[i]+1;iconn!=connIndex[i+1];iconn++)
{
checkConnectivityFullyDefined();
mcIdType *conn=getNodalConnectivity()->getPointer();
const mcIdType *connIndex=getNodalConnectivityIndex()->getConstPointer();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
for(mcIdType i=0;i<nbOfCells;i++)
for(mcIdType iconn=connIndex[i]+1;iconn!=connIndex[i+1];iconn++)
{
m[*work]=val;
mcIdType *conn=getNodalConnectivity()->getPointer();
const mcIdType *connIndex=getNodalConnectivityIndex()->getConstPointer();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
for(mcIdType i=0;i<nbOfCells;i++)
for(mcIdType iconn=connIndex[i]+1;iconn!=connIndex[i+1];iconn++)
{
mcIdType& node=conn[iconn];
if(node>=0)//avoid polyhedron separator
{
- std::map<mcIdType,mcIdType>::iterator it=m.find(node);
+ auto const it=m.find(node);
if(it!=m.end())
node=(*it).second;
}
void MEDCouplingUMesh::renumberCells(const mcIdType *old2NewBg, bool check)
{
checkConnectivityFullyDefined();
- mcIdType nbCells=getNumberOfCells();
+ mcIdType const nbCells=getNumberOfCells();
const mcIdType *array=old2NewBg;
if(check)
array=DataArrayIdType::CheckAndPreparePermutation(old2NewBg,old2NewBg+nbCells);
newCI[0]=loc;
for(mcIdType i=0;i<nbCells;i++)
{
- mcIdType pos=n2oPtr[i];
- mcIdType nbOfElts=connI[pos+1]-connI[pos];
+ mcIdType const pos=n2oPtr[i];
+ mcIdType const nbOfElts=connI[pos+1]-connI[pos];
newC=std::copy(conn+connI[pos],conn+connI[pos+1],newC);
loc+=nbOfElts;
newCI[i+1]=loc;
elems->pushBackSilent(0);
return elems.retn();
}
- int dim=getSpaceDimension();
+ int const dim=getSpaceDimension();
INTERP_KERNEL::AutoPtr<double> elem_bb=new double[2*dim];
const mcIdType* conn = getNodalConnectivity()->getConstPointer();
const mcIdType* conn_index= getNodalConnectivityIndex()->getConstPointer();
const double* coords = getCoords()->getConstPointer();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
for ( mcIdType ielem=0; ielem<nbOfCells;ielem++ )
{
for (int i=0; i<dim; i++)
for (mcIdType inode=conn_index[ielem]+1; inode<conn_index[ielem+1]; inode++)//+1 due to offset of cell type.
{
- mcIdType node= conn[inode];
+ mcIdType const node= conn[inode];
if(node>=0)//avoid polyhedron separator
{
for (int idim=0; idim<dim; idim++)
elems->pushBackSilent(0);
return elems.retn();
}
- int dim=getSpaceDimension();
+ int const dim=getSpaceDimension();
INTERP_KERNEL::AutoPtr<double> elem_bb=new double[2*dim];
const mcIdType* conn = getNodalConnectivity()->getConstPointer();
const mcIdType* conn_index= getNodalConnectivityIndex()->getConstPointer();
const double* coords = getCoords()->getConstPointer();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
for ( mcIdType ielem=0; ielem<nbOfCells;ielem++ )
{
for (int i=0; i<dim; i++)
for (mcIdType inode=conn_index[ielem]+1; inode<conn_index[ielem+1]; inode++)//+1 due to offset of cell type.
{
- mcIdType node= conn[inode];
+ mcIdType const node= conn[inode];
if(node>=0)//avoid polyhedron separator
{
for (int idim=0; idim<dim; idim++)
MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
ret->alloc(0,1);
checkConnectivityFullyDefined();
- mcIdType nbCells=getNumberOfCells();
- int mdim=getMeshDimension();
+ mcIdType const nbCells=getNumberOfCells();
+ int const mdim=getMeshDimension();
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
if(mdim!=ToIdType(cm.getDimension()))
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::giveCellsWithType : Mismatch between mesh dimension and dimension of the cell !");
ret << "Unstructured mesh with name : \"" << getName() << "\"\n";
ret << "Description of mesh : \"" << getDescription() << "\"\n";
int tmpp1,tmpp2;
- double tt=getTime(tmpp1,tmpp2);
+ double const tt=getTime(tmpp1,tmpp2);
ret << "Time attached to the mesh [unit] : " << tt << " [" << getTimeUnit() << "]\n";
ret << "Iteration : " << tmpp1 << " Order : " << tmpp2 << "\n";
if(_mesh_dim>=-1)
{ ret << "Mesh dimension : " << _mesh_dim << "\nSpace dimension : "; }
else
{ ret << " Mesh dimension has not been set or is invalid !"; }
- if(_coords!=0)
+ if(_coords!=nullptr)
{
const int spaceDim=getSpaceDimension();
ret << spaceDim << "\nInfo attached on space dimension : ";
else
ret << msg0 << "\n";
ret << "Number of nodes : ";
- if(_coords!=0)
+ if(_coords!=nullptr)
ret << getNumberOfNodes() << "\n";
else
ret << msg0 << "\n";
ret << "Number of cells : ";
- if(_nodal_connec!=0 && _nodal_connec_index!=0)
+ if(_nodal_connec!=nullptr && _nodal_connec_index!=nullptr)
ret << getNumberOfCells() << "\n";
else
ret << "No connectivity specified !" << "\n";
ret << "Cell types present : ";
- for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator iter=_types.begin();iter!=_types.end();iter++)
+ for(auto _type : _types)
{
- const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(*iter);
+ const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_type);
ret << cm.getRepr() << " ";
}
ret << "\n";
*/
MEDCouplingUMesh *MEDCouplingUMesh::buildSetInstanceFromThis(std::size_t spaceDim) const
{
- int mdim=getMeshDimension();
+ int const mdim=getMeshDimension();
if(mdim<0)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSetInstanceFromThis : invalid mesh dimension ! Should be >= 0 !");
MCAuto<MEDCouplingUMesh> ret=MEDCouplingUMesh::New(getName(),mdim);
* If 'deeCpy' is true all arrays (coordinates and connectivities) are deeply copied.
*/
MEDCouplingUMesh::MEDCouplingUMesh(const MEDCouplingUMesh& other, bool deepCpy):MEDCouplingPointSet(other,deepCpy),_mesh_dim(other._mesh_dim),
- _nodal_connec(0),_nodal_connec_index(0),
+ _nodal_connec(nullptr),_nodal_connec_index(nullptr),
_types(other._types)
{
if(other._nodal_connec)
std::copy(conn,conn+getNodalConnectivityArrayLen(),ptA1);
}
else
- a1=0;
+ a1=nullptr;
}
/*!
{
std::string name="MeasureOfMesh_";
name+=getName();
- mcIdType nbelem=getNumberOfCells();
+ mcIdType const nbelem=getNumberOfCells();
MCAuto<MEDCouplingFieldDouble> field=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
field->setName(name);
MCAuto<DataArrayDouble> array=DataArrayDouble::New();
array->alloc(nbelem,1);
double *area_vol=array->getPointer();
- field->setArray(array) ; array=0;
+ field->setArray(array) ; array=nullptr;
field->setMesh(const_cast<MEDCouplingUMesh *>(this));
field->synchronizeTimeWithMesh();
if(getMeshDimension()!=-1)
{
mcIdType ipt;
INTERP_KERNEL::NormalizedCellType type;
- int dim_space=getSpaceDimension();
+ int const dim_space=getSpaceDimension();
const double *coords=getCoords()->getConstPointer();
const mcIdType *connec=getNodalConnectivity()->getConstPointer();
const mcIdType *connec_index=getNodalConnectivityIndex()->getConstPointer();
{
std::string name="PartMeasureOfMesh_";
name+=getName();
- std::size_t nbelem=std::distance(begin,end);
+ std::size_t const nbelem=std::distance(begin,end);
MCAuto<DataArrayDouble> array=DataArrayDouble::New();
array->setName(name);
array->alloc(nbelem,1);
{
mcIdType ipt;
INTERP_KERNEL::NormalizedCellType type;
- int dim_space=getSpaceDimension();
+ int const dim_space=getSpaceDimension();
const double *coords=getCoords()->getConstPointer();
const mcIdType *connec=getNodalConnectivity()->getConstPointer();
const mcIdType *connec_index=getNodalConnectivityIndex()->getConstPointer();
MCAuto<MEDCouplingFieldDouble> tmp=getMeasureField(isAbs);
std::string name="MeasureOnNodeOfMesh_";
name+=getName();
- mcIdType nbNodes=getNumberOfNodes();
+ mcIdType const nbNodes=getNumberOfNodes();
MCAuto<DataArrayDouble> nnpc;
{
MCAuto<DataArrayIdType> tmp2(computeNbOfNodesPerCell());
throw INTERP_KERNEL::Exception("Expected a umesh with ( meshDim == 2 spaceDim == 2 or 3 ) or ( meshDim == 1 spaceDim == 2 ) !");
MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
MCAuto<DataArrayDouble> array=DataArrayDouble::New();
- mcIdType nbOfCells=getNumberOfCells();
- int nbComp=getMeshDimension()+1;
+ mcIdType const nbOfCells=getNumberOfCells();
+ int const nbComp=getMeshDimension()+1;
array->alloc(nbOfCells,nbComp);
double *vals=array->getPointer();
const mcIdType *connI=_nodal_connec_index->getConstPointer();
const double *locPtr=loc->getConstPointer();
for(mcIdType i=0;i<nbOfCells;i++,vals+=3)
{
- mcIdType offset=connI[i];
+ mcIdType const offset=connI[i];
INTERP_KERNEL::crossprod<3>(locPtr+3*i,coords+3*conn[offset+1],coords+3*conn[offset+2],vals);
- double n=INTERP_KERNEL::norm<3>(vals);
+ double const n=INTERP_KERNEL::norm<3>(vals);
std::transform(vals,vals+3,vals,std::bind(std::multiplies<double>(),std::placeholders::_1,1./n));
}
}
double tmp[2];
for(mcIdType i=0;i<nbOfCells;i++)
{
- mcIdType offset=connI[i];
+ mcIdType const offset=connI[i];
std::transform(coords+2*conn[offset+2],coords+2*conn[offset+2]+2,coords+2*conn[offset+1],tmp,std::minus<double>());
- double n=INTERP_KERNEL::norm<2>(tmp);
+ double const n=INTERP_KERNEL::norm<2>(tmp);
std::transform(tmp,tmp+2,tmp,std::bind(std::multiplies<double>(),std::placeholders::_1,1./n));
*vals++=-tmp[1];
*vals++=tmp[0];
throw INTERP_KERNEL::Exception("Expected a umesh with ( meshDim == 2 spaceDim == 2 or 3 ) or ( meshDim == 1 spaceDim == 2 ) !");
MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
MCAuto<DataArrayDouble> array=DataArrayDouble::New();
- std::size_t nbelems=std::distance(begin,end);
- int nbComp=getMeshDimension()+1;
+ std::size_t const nbelems=std::distance(begin,end);
+ int const nbComp=getMeshDimension()+1;
array->alloc(nbelems,nbComp);
double *vals=array->getPointer();
const mcIdType *connI=_nodal_connec_index->getConstPointer();
const double *locPtr=loc->getConstPointer();
for(const mcIdType *i=begin;i!=end;i++,vals+=3,locPtr+=3)
{
- mcIdType offset=connI[*i];
+ mcIdType const offset=connI[*i];
INTERP_KERNEL::crossprod<3>(locPtr,coords+3*conn[offset+1],coords+3*conn[offset+2],vals);
- double n=INTERP_KERNEL::norm<3>(vals);
+ double const n=INTERP_KERNEL::norm<3>(vals);
std::transform(vals,vals+3,vals,std::bind(std::multiplies<double>(),std::placeholders::_1,1./n));
}
}
double tmp[2];
for(const mcIdType *i=begin;i!=end;i++)
{
- mcIdType offset=connI[*i];
+ mcIdType const offset=connI[*i];
std::transform(coords+2*conn[offset+2],coords+2*conn[offset+2]+2,coords+2*conn[offset+1],tmp,std::minus<double>());
- double n=INTERP_KERNEL::norm<2>(tmp);
+ double const n=INTERP_KERNEL::norm<2>(tmp);
std::transform(tmp,tmp+2,tmp,std::bind(std::multiplies<double>(),std::placeholders::_1,1./n));
*vals++=-tmp[1];
*vals++=tmp[0];
throw INTERP_KERNEL::Exception("Expected a umesh with only NORM_SEG2 type of elements for buildDirectionVectorField !");
MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
MCAuto<DataArrayDouble> array=DataArrayDouble::New();
- mcIdType nbOfCells=getNumberOfCells();
- int spaceDim=getSpaceDimension();
+ mcIdType const nbOfCells=getNumberOfCells();
+ int const spaceDim=getSpaceDimension();
array->alloc(nbOfCells,spaceDim);
double *pt=array->getPointer();
const double *coo=getCoords()->getConstPointer();
if(candidates->empty())
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSlice3D : No 3D cells in this intercepts the specified plane considering bounding boxes !");
std::vector<mcIdType> nodes;
- DataArrayIdType *cellIds1D=0;
+ DataArrayIdType *cellIds1D=nullptr;
MCAuto<MEDCouplingUMesh> subMesh=static_cast<MEDCouplingUMesh*>(buildPartOfMySelf(candidates->begin(),candidates->end(),false));
subMesh->findNodesOnPlane(origin,vec,eps,nodes);
MCAuto<DataArrayIdType> desc1=DataArrayIdType::New(),desc2=DataArrayIdType::New();
MCAuto<DataArrayIdType> revDesc1=DataArrayIdType::New(),revDesc2=DataArrayIdType::New();
MCAuto<DataArrayIdType> revDescIndx1=DataArrayIdType::New(),revDescIndx2=DataArrayIdType::New();
MCAuto<MEDCouplingUMesh> mDesc2=subMesh->buildDescendingConnectivity(desc2,descIndx2,revDesc2,revDescIndx2);//meshDim==2 spaceDim==3
- revDesc2=0; revDescIndx2=0;
+ revDesc2=nullptr; revDescIndx2=nullptr;
MCAuto<MEDCouplingUMesh> mDesc1=mDesc2->buildDescendingConnectivity(desc1,descIndx1,revDesc1,revDescIndx1);//meshDim==1 spaceDim==3
- revDesc1=0; revDescIndx1=0;
+ revDesc1=nullptr; revDescIndx1=nullptr;
//Marking all 1D cells that contained at least one node located on the plane
//the intersection between those cells and the plane, which consist of the nodes previously tagged, thus don't need to be computed afterwards
//(if said intersection is computed in MEDCouplingUMesh::split3DCurveWithPlane, then we might create additional nodes
//due to accuracy errors when the needed nodes already exist)
mDesc1->fillCellIdsToKeepFromNodeIds(&nodes[0],&nodes[0]+nodes.size(),false,cellIds1D);
- MCAuto<DataArrayIdType> cellIds1DTmp(cellIds1D);
+ MCAuto<DataArrayIdType> const cellIds1DTmp(cellIds1D);
//
std::vector<mcIdType> cut3DCurve(mDesc1->getNumberOfCells(),-2);
- for(const mcIdType *it=cellIds1D->begin();it!=cellIds1D->end();it++)
- cut3DCurve[*it]=-1;
+ for(long const it : *cellIds1D)
+ cut3DCurve[it]=-1;
mDesc1->split3DCurveWithPlane(origin,vec,eps,cut3DCurve);
std::vector< std::pair<mcIdType,mcIdType> > cut3DSurf(mDesc2->getNumberOfCells());
AssemblyForSplitFrom3DCurve(cut3DCurve,nodes,mDesc2->getNodalConnectivity()->getConstPointer(),mDesc2->getNodalConnectivityIndex()->getConstPointer(),
if(candidates->empty())
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSlice3DSurf : No 3D surf cells in this intercepts the specified plane considering bounding boxes !");
std::vector<mcIdType> nodes;
- DataArrayIdType *cellIds1D(0);
+ DataArrayIdType *cellIds1D(nullptr);
MCAuto<MEDCouplingUMesh> subMesh(buildPartOfMySelf(candidates->begin(),candidates->end(),false));
subMesh->findNodesOnPlane(origin,vec,eps,nodes);
MCAuto<DataArrayIdType> desc1(DataArrayIdType::New()),descIndx1(DataArrayIdType::New()),revDesc1(DataArrayIdType::New()),revDescIndx1(DataArrayIdType::New());
MCAuto<MEDCouplingUMesh> mDesc1(subMesh->buildDescendingConnectivity(desc1,descIndx1,revDesc1,revDescIndx1));//meshDim==1 spaceDim==3
mDesc1->fillCellIdsToKeepFromNodeIds(&nodes[0],&nodes[0]+nodes.size(),true,cellIds1D);
- MCAuto<DataArrayIdType> cellIds1DTmp(cellIds1D);
+ MCAuto<DataArrayIdType> const cellIds1DTmp(cellIds1D);
//
std::vector<mcIdType> cut3DCurve(mDesc1->getNumberOfCells(),-2);
- for(const mcIdType *it=cellIds1D->begin();it!=cellIds1D->end();it++)
- cut3DCurve[*it]=-1;
+ for(long const it : *cellIds1D)
+ cut3DCurve[it]=-1;
mDesc1->split3DCurveWithPlane(origin,vec,eps,cut3DCurve);
- mcIdType ncellsSub=subMesh->getNumberOfCells();
+ mcIdType const ncellsSub=subMesh->getNumberOfCells();
std::vector< std::pair<mcIdType,mcIdType> > cut3DSurf(ncellsSub);
AssemblyForSplitFrom3DCurve(cut3DCurve,nodes,subMesh->getNodalConnectivity()->getConstPointer(),subMesh->getNodalConnectivityIndex()->getConstPointer(),
mDesc1->getNodalConnectivity()->getConstPointer(),mDesc1->getNodalConnectivityIndex()->getConstPointer(),
}
else
{
- mcIdType cellId3DSurf=cut3DSurf[i].second;
- mcIdType offset=nodalI[cellId3DSurf]+1;
- mcIdType nbOfEdges=nodalI[cellId3DSurf+1]-offset;
+ mcIdType const cellId3DSurf=cut3DSurf[i].second;
+ mcIdType const offset=nodalI[cellId3DSurf]+1;
+ mcIdType const nbOfEdges=nodalI[cellId3DSurf+1]-offset;
for(mcIdType j=0;j<nbOfEdges;j++)
{
conn->pushBackSilent(ToIdType(INTERP_KERNEL::NORM_SEG2)); conn->pushBackSilent(nodal[offset+j]); conn->pushBackSilent(nodal[offset+(j+1)%nbOfEdges]);
findNodesOnPlane(origin,vec,eps,nodes);
MCAuto<DataArrayIdType> desc1(DataArrayIdType::New()),desc2(DataArrayIdType::New()),descIndx1(DataArrayIdType::New()),descIndx2(DataArrayIdType::New()),revDesc1(DataArrayIdType::New()),revDesc2(DataArrayIdType::New()),revDescIndx1(DataArrayIdType::New()),revDescIndx2(DataArrayIdType::New());
MCAuto<MEDCouplingUMesh> mDesc2(buildDescendingConnectivity(desc2,descIndx2,revDesc2,revDescIndx2));//meshDim==2 spaceDim==3
- revDesc2=0; revDescIndx2=0;
+ revDesc2=nullptr; revDescIndx2=nullptr;
MCAuto<MEDCouplingUMesh> mDesc1(mDesc2->buildDescendingConnectivity(desc1,descIndx1,revDesc1,revDescIndx1));//meshDim==1 spaceDim==3
- revDesc1=0; revDescIndx1=0;
- DataArrayIdType *cellIds1D(0);
+ revDesc1=nullptr; revDescIndx1=nullptr;
+ DataArrayIdType *cellIds1D(nullptr);
mDesc1->fillCellIdsToKeepFromNodeIds(&nodes[0],&nodes[0]+nodes.size(),true,cellIds1D);
- MCAuto<DataArrayIdType> cellIds1DTmp(cellIds1D);
+ MCAuto<DataArrayIdType> const cellIds1DTmp(cellIds1D);
std::vector<mcIdType> cut3DCurve(mDesc1->getNumberOfCells(),-2);
- for(const mcIdType *it=cellIds1D->begin();it!=cellIds1D->end();it++)
- cut3DCurve[*it]=-1;
+ for(long const it : *cellIds1D)
+ cut3DCurve[it]=-1;
bool sameNbNodes;
{
- mcIdType oldNbNodes(mDesc1->getNumberOfNodes());
+ mcIdType const oldNbNodes(mDesc1->getNumberOfNodes());
mDesc1->split3DCurveWithPlane(origin,vec,eps,cut3DCurve);
sameNbNodes=(mDesc1->getNumberOfNodes()==oldNbNodes);
}
}
std::vector<std::vector<mcIdType> > res;
buildSubCellsFromCut(cut3DSurf,desc2->begin(),descIndx2->begin(),mDesc1->getCoords()->begin(),eps,res);
- std::size_t sz(res.size());
+ std::size_t const sz(res.size());
if(ToIdType(res.size())==mDesc1->getNumberOfCells() && sameNbNodes)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::clipSingle3DCellByPlane : cell is not clipped !");
for(std::size_t i=0;i<sz;i++)
MCAuto<MEDCouplingUMesh> ret(MEDCouplingUMesh::New("",2));
ret->setCoords(mDesc1->getCoords());
ret->setConnectivity(conn,connI,true);
- mcIdType nbCellsRet(ret->getNumberOfCells());
+ mcIdType const nbCellsRet(ret->getNumberOfCells());
//
MCAuto<DataArrayDouble> vec2(DataArrayDouble::New()); vec2->alloc(1,3); std::copy(vec,vec+3,vec2->getPointer());
MCAuto<MEDCouplingFieldDouble> ortho(ret->buildOrthogonalField());
checkFullyDefined();
if(getSpaceDimension()!=3)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSlice3D works on umeshes with spaceDim equal to 3 !");
- double normm=sqrt(vec[0]*vec[0]+vec[1]*vec[1]+vec[2]*vec[2]);
+ double const normm=sqrt(vec[0]*vec[0]+vec[1]*vec[1]+vec[2]*vec[2]);
if(normm<1e-6)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getCellIdsCrossingPlane : parameter 'vec' should have a norm2 greater than 1e-6 !");
double vec2[3];
vec2[0]=vec[1]; vec2[1]=-vec[0]; vec2[2]=0.;//vec2 is the result of cross product of vec with (0,0,1)
- double angle=acos(vec[2]/normm);
+ double const angle=acos(vec[2]/normm);
MCAuto<DataArrayIdType> cellIds;
double bbox[6];
if(angle>eps)
{
MCAuto<DataArrayDouble> coo=_coords->deepCopy();
- double normm2(sqrt(vec2[0]*vec2[0]+vec2[1]*vec2[1]+vec2[2]*vec2[2]));
+ double const normm2(sqrt(vec2[0]*vec2[0]+vec2[1]*vec2[1]+vec2[2]*vec2[2]));
if(normm2/normm>1e-6)
DataArrayDouble::Rotate3DAlg(origin,vec2,angle,coo->getNumberOfTuples(),coo->getPointer(),coo->getPointer());
MCAuto<MEDCouplingUMesh> mw=clone(false);//false -> shallow copy
{
if(getMeshDimension()!=1)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::isContiguous1D : this method has a sense only for 1D mesh !");
- mcIdType nbCells=getNumberOfCells();
+ mcIdType const nbCells=getNumberOfCells();
if(nbCells<1)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::isContiguous1D : this method has a sense for non empty mesh !");
const mcIdType *connI(_nodal_connec_index->begin()),*conn(_nodal_connec->begin());
checkFullyDefined();
if(ToIdType(std::distance(ptBg,ptEnd))!=spaceDim)
{ std::ostringstream oss; oss << "MEDCouplingUMesh::distanceToPoint : input point has to have dimension equal to the space dimension of this (" << spaceDim << ") !"; throw INTERP_KERNEL::Exception(oss.str()); }
- DataArrayIdType *ret1=0;
+ DataArrayIdType *ret1=nullptr;
MCAuto<DataArrayDouble> pts=DataArrayDouble::New(); pts->useArray(ptBg,false,DeallocType::C_DEALLOC,1,spaceDim);
MCAuto<DataArrayDouble> ret0=distanceToPoints(pts,ret1);
MCAuto<DataArrayIdType> ret1Safe(ret1);
throw INTERP_KERNEL::Exception(oss.str());
}
checkFullyDefined();
- mcIdType nbCells=getNumberOfCells();
+ mcIdType const nbCells=getNumberOfCells();
if(nbCells==0)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::distanceToPoints : no cells in this !");
- mcIdType nbOfPts=pts->getNumberOfTuples();
+ mcIdType const nbOfPts=pts->getNumberOfTuples();
MCAuto<DataArrayDouble> ret0=DataArrayDouble::New(); ret0->alloc(nbOfPts,1);
MCAuto<DataArrayIdType> ret1=DataArrayIdType::New(); ret1->alloc(nbOfPts,1);
const mcIdType *nc=_nodal_connec->begin(),*ncI=_nodal_connec_index->begin(); const double *coords=_coords->begin();
{
case 3:
{
- BBTreeDst<3> myTree(bbox,0,0,nbCells);
+ BBTreeDst<3> const myTree(bbox,nullptr,0,nbCells);
for(mcIdType i=0;i<nbOfPts;i++,ret0Ptr++,ret1Ptr++,ptsPtr+=3)
{
double x=std::numeric_limits<double>::max();
}
case 2:
{
- BBTreeDst<2> myTree(bbox,0,0,nbCells);
+ BBTreeDst<2> const myTree(bbox,nullptr,0,nbCells);
for(mcIdType i=0;i<nbOfPts;i++,ret0Ptr++,ret1Ptr++,ptsPtr+=2)
{
double x=std::numeric_limits<double>::max();
const char msg[]="Butterfly detection work only for 2D cells with spaceDim==2 or 3!";
if(getMeshDimension()!=2)
throw INTERP_KERNEL::Exception(msg);
- int spaceDim=getSpaceDimension();
+ int const spaceDim=getSpaceDimension();
if(spaceDim!=2 && spaceDim!=3)
throw INTERP_KERNEL::Exception(msg);
const mcIdType *conn=_nodal_connec->getConstPointer();
const mcIdType *connI=_nodal_connec_index->getConstPointer();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
std::vector<double> cell2DinS2;
for(mcIdType i=0;i<nbOfCells;i++)
{
- mcIdType offset=connI[i];
- mcIdType nbOfNodesForCell=connI[i+1]-offset-1;
+ mcIdType const offset=connI[i];
+ mcIdType const nbOfNodesForCell=connI[i+1]-offset-1;
if(nbOfNodesForCell<=3)
continue;
- bool isQuad=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)conn[offset]).isQuadratic();
+ bool const isQuad=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)conn[offset]).isQuadratic();
project2DCellOnXY(conn+offset+1,conn+connI[i+1],cell2DinS2);
if(isButterfly2DCell(cell2DinS2,isQuad,eps))
cells.push_back(i);
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::convexEnvelop2D works only for meshDim=2 and spaceDim=2 !");
checkFullyDefined();
const double *coords=getCoords()->getConstPointer();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
MCAuto<DataArrayIdType> nodalConnecIndexOut=DataArrayIdType::New();
nodalConnecIndexOut->alloc(nbOfCells+1,1);
MCAuto<DataArrayIdType> nodalConnecOut(DataArrayIdType::New());
isChanged->alloc(0,1);
for(mcIdType i=0;i<nbOfCells;i++,workIndexOut++)
{
- mcIdType pos=nodalConnecOut->getNumberOfTuples();
+ mcIdType const pos=nodalConnecOut->getNumberOfTuples();
if(BuildConvexEnvelopOf2DCellJarvis(coords,nodalConnecIn+nodalConnecIndexIn[i],nodalConnecIn+nodalConnecIndexIn[i+1],nodalConnecOut))
isChanged->pushBackSilent(i);
types.insert((INTERP_KERNEL::NormalizedCellType)nodalConnecOut->getIJ(pos,0));
workIndexOut[1]=nodalConnecOut->getNumberOfTuples();
}
if(isChanged->empty())
- return 0;
+ return nullptr;
setConnectivity(nodalConnecOut,nodalConnecIndexOut,false);
_types=types;
return isChanged.retn();
else
throw INTERP_KERNEL::Exception("Invalid 2D mesh and 1D mesh because 2D mesh has quadratic cells and 1D is not fully quadratic !");
}
- mcIdType oldNbOfNodes(getNumberOfNodes());
+ mcIdType const oldNbOfNodes(getNumberOfNodes());
MCAuto<DataArrayDouble> newCoords;
switch(policy)
{
{
checkFullyDefined();
bool ret=true;
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
for(mcIdType i=0;i<nbOfCells && ret;i++)
{
- INTERP_KERNEL::NormalizedCellType type=getTypeOfCell(i);
+ INTERP_KERNEL::NormalizedCellType const type=getTypeOfCell(i);
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
ret=cm.isQuadratic();
}
{
checkFullyDefined();
bool ret=false;
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
for(mcIdType i=0;i<nbOfCells && !ret;i++)
{
- INTERP_KERNEL::NormalizedCellType type=getTypeOfCell(i);
+ INTERP_KERNEL::NormalizedCellType const type=getTypeOfCell(i);
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
ret=cm.isQuadratic();
}
void MEDCouplingUMesh::convertQuadraticCellsToLinear()
{
checkFullyDefined();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
mcIdType delta=0;
const mcIdType *iciptr=_nodal_connec_index->begin();
for(mcIdType i=0;i<nbOfCells;i++)
{
- INTERP_KERNEL::NormalizedCellType type=getTypeOfCell(i);
+ INTERP_KERNEL::NormalizedCellType const type=getTypeOfCell(i);
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
if(cm.isQuadratic())
{
- INTERP_KERNEL::NormalizedCellType typel=cm.getLinearType();
+ INTERP_KERNEL::NormalizedCellType const typel=cm.getLinearType();
const INTERP_KERNEL::CellModel& cml=INTERP_KERNEL::CellModel::GetCellModel(typel);
if(!cml.isDynamic())
delta+=cm.getNumberOfNodes()-cml.getNumberOfNodes();
_types.clear();
for(mcIdType i=0;i<nbOfCells;i++,ociptr++)
{
- INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)icptr[iciptr[i]];
+ auto const type=(INTERP_KERNEL::NormalizedCellType)icptr[iciptr[i]];
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
if(!cm.isQuadratic())
{
}
else
{
- INTERP_KERNEL::NormalizedCellType typel=cm.getLinearType();
+ INTERP_KERNEL::NormalizedCellType const typel=cm.getLinearType();
_types.insert(typel);
const INTERP_KERNEL::CellModel& cml=INTERP_KERNEL::CellModel::GetCellModel(typel);
mcIdType newNbOfNodes=cml.getNumberOfNodes();
*/
DataArrayIdType *MEDCouplingUMesh::convertLinearCellsToQuadratic(int conversionType)
{
- DataArrayIdType *conn=0,*connI=0;
- DataArrayDouble *coords=0;
+ DataArrayIdType *conn=nullptr,*connI=nullptr;
+ DataArrayDouble *coords=nullptr;
std::set<INTERP_KERNEL::NormalizedCellType> types;
checkFullyDefined();
MCAuto<DataArrayIdType> ret,connSafe,connISafe;
MCAuto<DataArrayDouble> coordsSafe;
- int meshDim=getMeshDimension();
+ int const meshDim=getMeshDimension();
switch(conversionType)
{
case 0:
bool MEDCouplingUMesh::areOnlySimplexCells() const
{
checkFullyDefined();
- int mdim=getMeshDimension();
+ int const mdim=getMeshDimension();
if(mdim<1 || mdim>3)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::areOnlySimplexCells : only available with meshes having a meshdim 1, 2 or 3 !");
- mcIdType nbCells=getNumberOfCells();
+ mcIdType const nbCells=getNumberOfCells();
const mcIdType *conn=_nodal_connec->begin();
const mcIdType *connI=_nodal_connec_index->begin();
for(mcIdType i=0;i<nbCells;i++)
checkFullyDefined();
if(getMeshDimension()<=1)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::convertDegeneratedCells works on umeshes with meshdim equals to 2 or 3 !");
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
if(nbOfCells<1)
return ;
- mcIdType initMeshLgth=getNodalConnectivityArrayLen();
+ mcIdType const initMeshLgth=getNodalConnectivityArrayLen();
mcIdType *conn=_nodal_connec->getPointer();
mcIdType *index=_nodal_connec_index->getPointer();
mcIdType posOfCurCell=0;
for(mcIdType i=0;i<nbOfCells;i++)
{
lgthOfCurCell=index[i+1]-posOfCurCell;
- INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)conn[posOfCurCell];
+ auto const type=(INTERP_KERNEL::NormalizedCellType)conn[posOfCurCell];
mcIdType newLgth;
- INTERP_KERNEL::NormalizedCellType newType=INTERP_KERNEL::CellSimplify::simplifyDegeneratedCell(type,conn+posOfCurCell+1,lgthOfCurCell-1,
+ INTERP_KERNEL::NormalizedCellType const newType=INTERP_KERNEL::CellSimplify::simplifyDegeneratedCell(type,conn+posOfCurCell+1,lgthOfCurCell-1,
conn+newPos+1,newLgth);
conn[newPos]=newType;
newPos+=newLgth+1;
checkFullyDefined();
if(getMeshDimension()<=1)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::convertDegeneratedCells works on umeshes with meshdim equals to 2 or 3 !");
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
MCAuto<DataArrayIdType> ret(DataArrayIdType::New()); ret->alloc(0,1);
if(nbOfCells<1)
return ret.retn();
- mcIdType initMeshLgth=getNodalConnectivityArrayLen();
+ mcIdType const initMeshLgth=getNodalConnectivityArrayLen();
mcIdType *conn=_nodal_connec->getPointer();
mcIdType *index=_nodal_connec_index->getPointer();
mcIdType posOfCurCell=0;
for(mcIdType i=0;i<nbOfCells;i++)
{
lgthOfCurCell=index[i+1]-posOfCurCell;
- INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)conn[posOfCurCell];
+ auto const type=(INTERP_KERNEL::NormalizedCellType)conn[posOfCurCell];
mcIdType newLgth;
- INTERP_KERNEL::NormalizedCellType newType=INTERP_KERNEL::CellSimplify::simplifyDegeneratedCell(type,conn+posOfCurCell+1,lgthOfCurCell-1,
+ INTERP_KERNEL::NormalizedCellType const newType=INTERP_KERNEL::CellSimplify::simplifyDegeneratedCell(type,conn+posOfCurCell+1,lgthOfCurCell-1,
conn+newPos+1,newLgth);
// Shall we delete the cell if it is completely degenerated:
- bool delCell=INTERP_KERNEL::CellSimplify::isFlatCell(conn, newPos, newLgth, newType);
+ bool const delCell=INTERP_KERNEL::CellSimplify::isFlatCell(conn, newPos, newLgth, newType);
if (delCell)
{
nbDelCells++;
{
for(std::size_t i=0;i<nbCells;i++)
{
- INTERP_KERNEL::NormalizedCellType ct((INTERP_KERNEL::NormalizedCellType)conn[conni[i]]);
+ auto const ct((INTERP_KERNEL::NormalizedCellType)conn[conni[i]]);
if(ct==INTERP_KERNEL::NORM_SEG2 || ct==INTERP_KERNEL::NORM_SEG3)
{
if(conn[conni[i]+1]!=conn[conni[i]+2])
{
if(getMeshDimension()!=2 || getSpaceDimension()!=3)
throw INTERP_KERNEL::Exception("Invalid mesh to apply are2DCellsNotCorrectlyOriented on it : must be meshDim==2 and spaceDim==3 !");
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
const mcIdType *conn=_nodal_connec->begin();
const mcIdType *connI=_nodal_connec_index->begin();
const double *coordsPtr=_coords->begin();
for(mcIdType i=0;i<nbOfCells;i++)
{
- INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)conn[connI[i]];
+ auto const type=(INTERP_KERNEL::NormalizedCellType)conn[connI[i]];
if(!polyOnly || (type==INTERP_KERNEL::NORM_POLYGON || type==INTERP_KERNEL::NORM_QPOLYG))
{
- bool isQuadratic=INTERP_KERNEL::CellModel::GetCellModel(type).isQuadratic();
+ bool const isQuadratic=INTERP_KERNEL::CellModel::GetCellModel(type).isQuadratic();
if(!IsPolygonWellOriented(isQuadratic,vec,conn+connI[i]+1,conn+connI[i+1],coordsPtr))
cells.push_back(i);
}
{
if(getMeshDimension()!=2 || getSpaceDimension()!=3)
throw INTERP_KERNEL::Exception("Invalid mesh to apply orientCorrectly2DCells on it : must be meshDim==2 and spaceDim==3 !");
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
mcIdType *conn(_nodal_connec->getPointer());
const mcIdType *connI(_nodal_connec_index->begin());
const double *coordsPtr(_coords->begin());
bool isModified(false);
for(mcIdType i=0;i<nbOfCells;i++)
{
- INTERP_KERNEL::NormalizedCellType type((INTERP_KERNEL::NormalizedCellType)conn[connI[i]]);
+ auto const type((INTERP_KERNEL::NormalizedCellType)conn[connI[i]]);
if(!polyOnly || (type==INTERP_KERNEL::NORM_POLYGON || type==INTERP_KERNEL::NORM_QPOLYG))
{
const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(type));
- bool isQuadratic(cm.isQuadratic());
+ bool const isQuadratic(cm.isQuadratic());
if(!IsPolygonWellOriented(isQuadratic,vec,conn+connI[i]+1,conn+connI[i+1],coordsPtr))
{
isModified=true;
*/
void MEDCouplingUMesh::changeOrientationOfCells()
{
- int mdim(getMeshDimension());
+ int const mdim(getMeshDimension());
if(mdim!=2 && mdim!=1)
throw INTERP_KERNEL::Exception("Invalid mesh to apply changeOrientationOfCells on it : must be meshDim==2 or meshDim==1 !");
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
mcIdType *conn(_nodal_connec->getPointer());
const mcIdType *connI(_nodal_connec_index->begin());
if(mdim==2)
{//2D
for(mcIdType i=0;i<nbOfCells;i++)
{
- INTERP_KERNEL::NormalizedCellType type((INTERP_KERNEL::NormalizedCellType)conn[connI[i]]);
+ auto const type((INTERP_KERNEL::NormalizedCellType)conn[connI[i]]);
const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(type));
cm.changeOrientationOf2D(conn+connI[i]+1,(unsigned int)(connI[i+1]-connI[i]-1));
}
{//1D
for(mcIdType i=0;i<nbOfCells;i++)
{
- INTERP_KERNEL::NormalizedCellType type((INTERP_KERNEL::NormalizedCellType)conn[connI[i]]);
+ auto const type((INTERP_KERNEL::NormalizedCellType)conn[connI[i]]);
const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(type));
cm.changeOrientationOf1D(conn+connI[i]+1,(unsigned int)(connI[i+1]-connI[i]-1));
}
{
if(getMeshDimension()!=3 || getSpaceDimension()!=3)
throw INTERP_KERNEL::Exception("Invalid mesh to apply arePolyhedronsNotCorrectlyOriented on it : must be meshDim==3 and spaceDim==3 !");
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
const mcIdType *conn=_nodal_connec->begin();
const mcIdType *connI=_nodal_connec_index->begin();
const double *coordsPtr=_coords->begin();
for(mcIdType i=0;i<nbOfCells;i++)
{
- INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)conn[connI[i]];
+ auto const type=(INTERP_KERNEL::NormalizedCellType)conn[connI[i]];
if(type==INTERP_KERNEL::NORM_POLYHED)
{
if(!IsPolyhedronWellOriented(conn+connI[i]+1,conn+connI[i+1],coordsPtr))
{
if(getMeshDimension()!=3 || getSpaceDimension()!=3)
throw INTERP_KERNEL::Exception("Invalid mesh to apply orientCorrectlyPolyhedrons on it : must be meshDim==3 and spaceDim==3 !");
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
mcIdType *conn=_nodal_connec->getPointer();
const mcIdType *connI=_nodal_connec_index->begin();
const double *coordsPtr=_coords->begin();
for(mcIdType i=0;i<nbOfCells;i++)
{
- INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)conn[connI[i]];
+ auto const type=(INTERP_KERNEL::NormalizedCellType)conn[connI[i]];
if(type==INTERP_KERNEL::NORM_POLYHED)
{
try
void MEDCouplingUMesh::invertOrientationOfAllCells()
{
checkConnectivityFullyDefined();
- std::set<INTERP_KERNEL::NormalizedCellType> gts(getAllGeoTypes());
+ std::set<INTERP_KERNEL::NormalizedCellType> const gts(getAllGeoTypes());
mcIdType *conn(_nodal_connec->getPointer());
const mcIdType *conni(_nodal_connec_index->begin());
- for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator gt=gts.begin();gt!=gts.end();gt++)
+ for(auto gt : gts)
{
- INTERP_KERNEL::AutoCppPtr<INTERP_KERNEL::OrientationInverter> oi(INTERP_KERNEL::OrientationInverter::BuildInstanceFrom(*gt));
- MCAuto<DataArrayIdType> cwt(giveCellsWithType(*gt));
- for(const mcIdType *it=cwt->begin();it!=cwt->end();it++)
- oi->operate(conn+conni[*it]+1,conn+conni[*it+1]);
+ INTERP_KERNEL::AutoCppPtr<INTERP_KERNEL::OrientationInverter> oi((INTERP_KERNEL::OrientationInverter::BuildInstanceFrom(gt)));
+ MCAuto<DataArrayIdType> cwt(giveCellsWithType(gt));
+ for(long const it : *cwt)
+ oi->operate(conn+conni[it]+1,conn+conni[it+1]);
}
updateTime();
}
const char msg[]="check3DCellsWellOriented detection works only for 3D cells !";
if(getMeshDimension()!=3)
throw INTERP_KERNEL::Exception(msg);
- int spaceDim=getSpaceDimension();
+ int const spaceDim=getSpaceDimension();
if(spaceDim!=3)
throw INTERP_KERNEL::Exception(msg);
//
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
mcIdType *conn=_nodal_connec->getPointer();
const mcIdType *connI=_nodal_connec_index->begin();
const double *coo=getCoords()->begin();
{
if(getMeshDimension()!=3 || getSpaceDimension()!=3)
throw INTERP_KERNEL::Exception("Invalid mesh to apply findAndCorrectBadOriented3DCells on it : must be meshDim==3 and spaceDim==3 !");
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
mcIdType *conn=_nodal_connec->getPointer();
const mcIdType *connI=_nodal_connec_index->begin();
const double *coordsPtr=_coords->begin();
MCAuto<DataArrayIdType> ret=DataArrayIdType::New(); ret->alloc(0,1);
for(mcIdType i=0;i<nbOfCells;i++)
{
- INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)conn[connI[i]];
+ auto const type=(INTERP_KERNEL::NormalizedCellType)conn[connI[i]];
switch(type)
{
case INTERP_KERNEL::NORM_TETRA4:
MEDCouplingFieldDouble *MEDCouplingUMesh::getEdgeRatioField() const
{
checkConsistencyLight();
- int spaceDim=getSpaceDimension();
- int meshDim=getMeshDimension();
+ int const spaceDim=getSpaceDimension();
+ int const meshDim=getMeshDimension();
if(spaceDim!=2 && spaceDim!=3)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getEdgeRatioField : SpaceDimension must be equal to 2 or 3 !");
if(meshDim!=2 && meshDim!=3)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getEdgeRatioField : MeshDimension must be equal to 2 or 3 !");
MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
ret->setMesh(this);
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
MCAuto<DataArrayDouble> arr=DataArrayDouble::New();
arr->alloc(nbOfCells,1);
double *pt=arr->getPointer();
double tmp[12];
for(mcIdType i=0;i<nbOfCells;i++,pt++)
{
- INTERP_KERNEL::NormalizedCellType t=(INTERP_KERNEL::NormalizedCellType)*conn;
+ auto const t=(INTERP_KERNEL::NormalizedCellType)*conn;
switch(t)
{
case INTERP_KERNEL::NORM_TRI3:
MEDCouplingFieldDouble *MEDCouplingUMesh::getAspectRatioField() const
{
checkConsistencyLight();
- int spaceDim=getSpaceDimension();
- int meshDim=getMeshDimension();
+ int const spaceDim=getSpaceDimension();
+ int const meshDim=getMeshDimension();
if(spaceDim!=2 && spaceDim!=3)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getAspectRatioField : SpaceDimension must be equal to 2 or 3 !");
if(meshDim!=2 && meshDim!=3)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getAspectRatioField : MeshDimension must be equal to 2 or 3 !");
MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
ret->setMesh(this);
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
MCAuto<DataArrayDouble> arr=DataArrayDouble::New();
arr->alloc(nbOfCells,1);
double *pt=arr->getPointer();
double tmp[12];
for(mcIdType i=0;i<nbOfCells;i++,pt++)
{
- INTERP_KERNEL::NormalizedCellType t=(INTERP_KERNEL::NormalizedCellType)*conn;
+ auto const t=(INTERP_KERNEL::NormalizedCellType)*conn;
switch(t)
{
case INTERP_KERNEL::NORM_TRI3:
MEDCouplingFieldDouble *MEDCouplingUMesh::getWarpField() const
{
checkConsistencyLight();
- int spaceDim=getSpaceDimension();
- int meshDim=getMeshDimension();
+ int const spaceDim=getSpaceDimension();
+ int const meshDim=getMeshDimension();
if(spaceDim!=3)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getWarpField : SpaceDimension must be equal to 3 !");
if(meshDim!=2)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getWarpField : MeshDimension must be equal to 2 !");
MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
ret->setMesh(this);
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
MCAuto<DataArrayDouble> arr=DataArrayDouble::New();
arr->alloc(nbOfCells,1);
double *pt=arr->getPointer();
double tmp[12];
for(mcIdType i=0;i<nbOfCells;i++,pt++)
{
- INTERP_KERNEL::NormalizedCellType t=(INTERP_KERNEL::NormalizedCellType)*conn;
+ auto const t=(INTERP_KERNEL::NormalizedCellType)*conn;
switch(t)
{
case INTERP_KERNEL::NORM_QUAD4:
MEDCouplingFieldDouble *MEDCouplingUMesh::getSkewField() const
{
checkConsistencyLight();
- int spaceDim=getSpaceDimension();
- int meshDim=getMeshDimension();
+ int const spaceDim=getSpaceDimension();
+ int const meshDim=getMeshDimension();
if(spaceDim!=3)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getSkewField : SpaceDimension must be equal to 3 !");
if(meshDim!=2)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getSkewField : MeshDimension must be equal to 2 !");
MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
ret->setMesh(this);
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
MCAuto<DataArrayDouble> arr=DataArrayDouble::New();
arr->alloc(nbOfCells,1);
double *pt=arr->getPointer();
double tmp[12];
for(mcIdType i=0;i<nbOfCells;i++,pt++)
{
- INTERP_KERNEL::NormalizedCellType t=(INTERP_KERNEL::NormalizedCellType)*conn;
+ auto const t=(INTERP_KERNEL::NormalizedCellType)*conn;
switch(t)
{
case INTERP_KERNEL::NORM_QUAD4:
ret->setMesh(this);
std::set<INTERP_KERNEL::NormalizedCellType> types;
ComputeAllTypesInternal(types,_nodal_connec,_nodal_connec_index);
- int spaceDim(getSpaceDimension());
- mcIdType nbCells(getNumberOfCells());
+ int const spaceDim(getSpaceDimension());
+ mcIdType const nbCells(getNumberOfCells());
MCAuto<DataArrayDouble> arr(DataArrayDouble::New());
arr->alloc(nbCells,1);
- for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=types.begin();it!=types.end();it++)
+ for(auto type : types)
{
- INTERP_KERNEL::AutoCppPtr<INTERP_KERNEL::DiameterCalculator> dc(INTERP_KERNEL::CellModel::GetCellModel(*it).buildInstanceOfDiameterCalulator(spaceDim));
- MCAuto<DataArrayIdType> cellIds(giveCellsWithType(*it));
+ INTERP_KERNEL::AutoCppPtr<INTERP_KERNEL::DiameterCalculator> dc(INTERP_KERNEL::CellModel::GetCellModel(type).buildInstanceOfDiameterCalulator(spaceDim));
+ MCAuto<DataArrayIdType> cellIds(giveCellsWithType(type));
dc->computeForListOfCellIdsUMeshFrmt(cellIds->begin(),cellIds->end(),_nodal_connec_index->begin(),_nodal_connec->begin(),getCoords()->begin(),arr->getPointer());
}
ret->setArray(arr);
if((mDim==2 && sDim==2) || (mDim==1 && sDim==2))
{
bool presenceOfQuadratic(false);
- for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=_types.begin();it!=_types.end();it++)
+ for(auto _type : _types)
{
- const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(*it));
+ const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(_type));
if(cm.isQuadratic())
presenceOfQuadratic=true;
}
DataArrayDouble *MEDCouplingUMesh::getBoundingBoxForBBTreeFast() const
{
checkFullyDefined();
- int spaceDim(getSpaceDimension());
+ int const spaceDim(getSpaceDimension());
mcIdType nbOfCells(getNumberOfCells()), nbOfNodes(getNumberOfNodes());
MCAuto<DataArrayDouble> ret(DataArrayDouble::New()); ret->alloc(nbOfCells,2*spaceDim);
double *bbox(ret->getPointer());
const mcIdType *conn(_nodal_connec->begin()),*connI(_nodal_connec_index->begin());
for(mcIdType i=0;i<nbOfCells;i++)
{
- mcIdType offset=connI[i]+1;
+ mcIdType const offset=connI[i]+1;
mcIdType nbOfNodesForCell(connI[i+1]-offset),kk(0);
for(mcIdType j=0;j<nbOfNodesForCell;j++)
{
- mcIdType nodeId=conn[offset+j];
+ mcIdType const nodeId=conn[offset+j];
if(nodeId>=0 && nodeId<nbOfNodes)
{
for(int k=0;k<spaceDim;k++)
DataArrayDouble *MEDCouplingUMesh::getBoundingBoxForBBTree2DQuadratic(double arcDetEps) const
{
checkFullyDefined();
- INTERP_KERNEL::QuadraticPlanarPrecision arcPrec(arcDetEps);
+ INTERP_KERNEL::QuadraticPlanarPrecision const arcPrec(arcDetEps);
int spaceDim(getSpaceDimension()),mDim(getMeshDimension());
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
if(spaceDim!=2 || mDim!=2)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getBoundingBoxForBBTree2DQuadratic : This method should be applied on mesh with mesh dimension equal to 2 and space dimension also equal to 2!");
MCAuto<DataArrayDouble> ret(DataArrayDouble::New()); ret->alloc(nbOfCells,2*spaceDim);
for(mcIdType i=0;i<nbOfCells;i++,bbox+=4,connI++)
{
const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)conn[*connI]));
- mcIdType sz(connI[1]-connI[0]-1);
+ mcIdType const sz(connI[1]-connI[0]-1);
std::vector<INTERP_KERNEL::Node *> nodes(sz);
- INTERP_KERNEL::QuadraticPolygon *pol(0);
+ INTERP_KERNEL::QuadraticPolygon *pol(nullptr);
for(mcIdType j=0;j<sz;j++)
{
- mcIdType nodeId(conn[*connI+1+j]);
+ mcIdType const nodeId(conn[*connI+1+j]);
nodes[j]=new INTERP_KERNEL::Node(coords[nodeId*2],coords[nodeId*2+1]);
}
if(!cm.isQuadratic())
{
checkFullyDefined();
int spaceDim(getSpaceDimension()),mDim(getMeshDimension());
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
if(spaceDim!=2 || mDim!=1)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getBoundingBoxForBBTree1DQuadratic : This method should be applied on mesh with mesh dimension equal to 1 and space dimension also equal to 2!");
- INTERP_KERNEL::QuadraticPlanarPrecision arcPrec(arcDetEps);
+ INTERP_KERNEL::QuadraticPlanarPrecision const arcPrec(arcDetEps);
MCAuto<DataArrayDouble> ret(DataArrayDouble::New()); ret->alloc(nbOfCells,2*spaceDim);
double *bbox(ret->getPointer());
const double *coords(_coords->begin());
for(mcIdType i=0;i<nbOfCells;i++,bbox+=4,connI++)
{
const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)conn[*connI]));
- mcIdType sz(connI[1]-connI[0]-1);
+ mcIdType const sz(connI[1]-connI[0]-1);
std::vector<INTERP_KERNEL::Node *> nodes(sz);
- INTERP_KERNEL::Edge *edge(0);
+ INTERP_KERNEL::Edge *edge(nullptr);
for(mcIdType j=0;j<sz;j++)
{
- mcIdType nodeId(conn[*connI+1+j]);
+ mcIdType const nodeId(conn[*connI+1+j]);
nodes[j]=new INTERP_KERNEL::Node(coords[nodeId*2],coords[nodeId*2+1]);
}
if(!cm.isQuadratic())
const mcIdType *conn=_nodal_connec->begin();
const mcIdType *connI=_nodal_connec_index->begin();
const mcIdType *work=connI;
- mcIdType nbOfCells=getNumberOfCells();
- std::size_t n=getAllGeoTypes().size();
+ mcIdType const nbOfCells=getNumberOfCells();
+ std::size_t const n=getAllGeoTypes().size();
std::vector<mcIdType> ret(3*n,-1); //ret[3*k+2]==-1 because it has no sense here
std::set<INTERP_KERNEL::NormalizedCellType> types;
for(std::size_t i=0;work!=connI+nbOfCells;i++)
{
- INTERP_KERNEL::NormalizedCellType typ=(INTERP_KERNEL::NormalizedCellType)conn[*work];
+ auto const typ=(INTERP_KERNEL::NormalizedCellType)conn[*work];
if(types.find(typ)!=types.end())
{
std::ostringstream oss; oss << "MEDCouplingUMesh::getDistributionOfTypes : Type " << INTERP_KERNEL::CellModel::GetCellModel(typ).getRepr();
{
if(code.empty())
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::checkTypeConsistencyAndContig : code is empty, should not !");
- std::size_t sz=code.size();
- std::size_t n=sz/3;
+ std::size_t const sz=code.size();
+ std::size_t const n=sz/3;
if(sz%3!=0)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::checkTypeConsistencyAndContig : code size is NOT %3 !");
std::vector<INTERP_KERNEL::NormalizedCellType> types;
if(!checkConsecutiveCellTypesAndOrder(&types[0],&types[0]+types.size()))
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::checkTypeConsistencyAndContig : non contiguous type !");
if(types.size()==_types.size())
- return 0;
+ return nullptr;
}
MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
ret->alloc(nb,1);
mcIdType *retPtr=ret->getPointer();
const mcIdType *connI=_nodal_connec_index->begin();
const mcIdType *conn=_nodal_connec->begin();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
const mcIdType *i=connI;
int kk=0;
for(std::vector<INTERP_KERNEL::NormalizedCellType>::const_iterator it=types.begin();it!=types.end();it++,kk++)
{
i=std::find_if(i,connI+nbOfCells,MEDCouplingImpl::ConnReader2(conn,ToIdType((*it))));
- mcIdType offset=ToIdType(std::distance(connI,i));
+ mcIdType const offset=ToIdType(std::distance(connI,i));
const mcIdType *j=std::find_if(i+1,connI+nbOfCells,MEDCouplingImpl::ConnReader(conn,ToIdType((*it))));
- mcIdType nbOfCellsOfCurType=ToIdType(std::distance(i,j));
+ mcIdType const nbOfCellsOfCurType=ToIdType(std::distance(i,j));
if(code[3*kk+2]==-1)
for(mcIdType k=0;k<nbOfCellsOfCurType;k++)
*retPtr++=k+offset;
else
{
- mcIdType idInIdsPerType=code[3*kk+2];
+ mcIdType const idInIdsPerType=code[3*kk+2];
if(idInIdsPerType>=0 && idInIdsPerType<ToIdType(idsPerType.size()))
{
const DataArrayIdType *zePfl=idsPerType[idInIdsPerType];
checkConnectivityFullyDefined();
const mcIdType *conn=_nodal_connec->begin();
const mcIdType *connI=_nodal_connec_index->begin();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
std::vector<INTERP_KERNEL::NormalizedCellType> types;
std::vector<mcIdType> typeRangeVals(1);
for(const mcIdType *i=connI;i!=connI+nbOfCells;)
{
- INTERP_KERNEL::NormalizedCellType curType=(INTERP_KERNEL::NormalizedCellType)conn[*i];
+ auto const curType=(INTERP_KERNEL::NormalizedCellType)conn[*i];
if(std::find(types.begin(),types.end(),curType)!=types.end())
{
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::splitProfilePerType : current mesh is not sorted by type !");
typeRangeVals.push_back(ToIdType(std::distance(connI,i)));
}
//
- DataArrayIdType *castArr=0,*rankInsideCast=0,*castsPresent=0;
+ DataArrayIdType *castArr=nullptr,*rankInsideCast=nullptr,*castsPresent=nullptr;
profile->splitByValueRange(&typeRangeVals[0],&typeRangeVals[0]+typeRangeVals.size(),castArr,rankInsideCast,castsPresent);
- MCAuto<DataArrayIdType> tmp0=castArr;
- MCAuto<DataArrayIdType> tmp1=rankInsideCast;
- MCAuto<DataArrayIdType> tmp2=castsPresent;
+ MCAuto<DataArrayIdType> const tmp0=castArr;
+ MCAuto<DataArrayIdType> const tmp1=rankInsideCast;
+ MCAuto<DataArrayIdType> const tmp2=castsPresent;
//
- mcIdType nbOfCastsFinal=castsPresent->getNumberOfTuples();
+ mcIdType const nbOfCastsFinal=castsPresent->getNumberOfTuples();
code.resize(3*nbOfCastsFinal);
std::vector< MCAuto<DataArrayIdType> > idsInPflPerType2;
std::vector< MCAuto<DataArrayIdType> > idsPerType2;
for(mcIdType i=0;i<nbOfCastsFinal;i++)
{
- mcIdType castId=castsPresent->getIJ(i,0);
+ mcIdType const castId=castsPresent->getIJ(i,0);
MCAuto<DataArrayIdType> tmp3=castArr->findIdsEqual(castId);
idsInPflPerType2.push_back(tmp3);
code[3*i]=ToIdType(types[castId]);
code[3*i+2]=-1;
}
}
- std::size_t sz2=idsInPflPerType2.size();
+ std::size_t const sz2=idsInPflPerType2.size();
idsInPflPerType.resize(sz2);
for(std::size_t i=0;i<sz2;i++)
{
locDa->incrRef();
idsInPflPerType[i]=locDa;
}
- std::size_t sz=idsPerType2.size();
+ std::size_t const sz=idsPerType2.size();
idsPerType.resize(sz);
for(std::size_t i=0;i<sz;i++)
{
tmp->renumberCells(ret0->begin(),false);
revDesc=tmp->getNodalConnectivity();
revDescIndx=tmp->getNodalConnectivityIndex();
- DataArrayIdType *ret=0;
+ DataArrayIdType *ret=nullptr;
if(!ret1->areCellsIncludedIn(nM1LevMesh,2,ret))
{
mcIdType tmp2;
checkFullyDefined();
const mcIdType *conn=_nodal_connec->begin();
const mcIdType *connI=_nodal_connec_index->begin();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
std::set<INTERP_KERNEL::NormalizedCellType> types;
for(const mcIdType *i=connI;i!=connI+nbOfCells;)
{
- INTERP_KERNEL::NormalizedCellType curType=(INTERP_KERNEL::NormalizedCellType)conn[*i];
+ auto const curType=(INTERP_KERNEL::NormalizedCellType)conn[*i];
if(types.find(curType)!=types.end())
return false;
types.insert(curType);
checkFullyDefined();
const mcIdType *conn=_nodal_connec->begin();
const mcIdType *connI=_nodal_connec_index->begin();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
if(nbOfCells==0)
return true;
mcIdType lastPos=-1;
std::set<INTERP_KERNEL::NormalizedCellType> sg;
for(const mcIdType *i=connI;i!=connI+nbOfCells;)
{
- INTERP_KERNEL::NormalizedCellType curType=(INTERP_KERNEL::NormalizedCellType)conn[*i];
+ auto const curType=(INTERP_KERNEL::NormalizedCellType)conn[*i];
const INTERP_KERNEL::NormalizedCellType *isTypeExists=std::find(orderBg,orderEnd,curType);
if(isTypeExists!=orderEnd)
{
- mcIdType pos=ToIdType(std::distance(orderBg,isTypeExists));
+ mcIdType const pos=ToIdType(std::distance(orderBg,isTypeExists));
if(pos<=lastPos)
return false;
lastPos=pos;
DataArrayIdType *MEDCouplingUMesh::getLevArrPerCellTypes(const INTERP_KERNEL::NormalizedCellType *orderBg, const INTERP_KERNEL::NormalizedCellType *orderEnd, DataArrayIdType *&nbPerType) const
{
checkConnectivityFullyDefined();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
const mcIdType *conn=_nodal_connec->begin();
const mcIdType *connI=_nodal_connec_index->begin();
MCAuto<DataArrayIdType> tmpa=DataArrayIdType::New();
const INTERP_KERNEL::NormalizedCellType *where=std::find(orderBg,orderEnd,(INTERP_KERNEL::NormalizedCellType)conn[*i]);
if(where!=orderEnd)
{
- mcIdType pos=ToIdType(std::distance(orderBg,where));
+ mcIdType const pos=ToIdType(std::distance(orderBg,where));
tmp2[pos]++;
tmp[std::distance(connI,i)]=pos;
}
*/
DataArrayIdType *MEDCouplingUMesh::getRenumArrForConsecutiveCellTypesSpec(const INTERP_KERNEL::NormalizedCellType *orderBg, const INTERP_KERNEL::NormalizedCellType *orderEnd) const
{
- DataArrayIdType *nbPerType=0;
+ DataArrayIdType *nbPerType=nullptr;
MCAuto<DataArrayIdType> tmpa=getLevArrPerCellTypes(orderBg,orderEnd,nbPerType);
nbPerType->decrRef();
return tmpa->buildPermArrPerLevel();
computeTypes();
const mcIdType *conn=_nodal_connec->begin();
const mcIdType *connI=_nodal_connec_index->begin();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
std::vector<INTERP_KERNEL::NormalizedCellType> types;
for(const mcIdType *i=connI;i!=connI+nbOfCells && (types.size()!=_types.size());)
if(std::find(types.begin(),types.end(),(INTERP_KERNEL::NormalizedCellType)conn[*i])==types.end())
{
- INTERP_KERNEL::NormalizedCellType curType=(INTERP_KERNEL::NormalizedCellType)conn[*i];
+ auto const curType=(INTERP_KERNEL::NormalizedCellType)conn[*i];
types.push_back(curType);
for(i++;i!=connI+nbOfCells && (INTERP_KERNEL::NormalizedCellType)conn[*i]==curType;i++);
}
mcIdType *retPtr=ret->getPointer();
std::fill(retPtr,retPtr+nbOfCells,-1);
mcIdType newCellId=0;
- for(std::vector<INTERP_KERNEL::NormalizedCellType>::const_iterator iter=types.begin();iter!=types.end();iter++)
+ for(auto type : types)
{
for(const mcIdType *i=connI;i!=connI+nbOfCells;i++)
- if((INTERP_KERNEL::NormalizedCellType)conn[*i]==(*iter))
+ if((INTERP_KERNEL::NormalizedCellType)conn[*i]==type)
retPtr[std::distance(connI,i)]=newCellId++;
}
renumberCells(retPtr,false);
checkConnectivityFullyDefined();
const mcIdType *conn=_nodal_connec->begin();
const mcIdType *connI=_nodal_connec_index->begin();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
std::vector<MEDCouplingUMesh *> ret;
for(const mcIdType *i=connI;i!=connI+nbOfCells;)
{
- INTERP_KERNEL::NormalizedCellType curType=(INTERP_KERNEL::NormalizedCellType)conn[*i];
- mcIdType beginCellId=ToIdType(std::distance(connI,i));
+ auto const curType=(INTERP_KERNEL::NormalizedCellType)conn[*i];
+ mcIdType const beginCellId=ToIdType(std::distance(connI,i));
i=std::find_if(i+1,connI+nbOfCells,MEDCouplingImpl::ConnReader(conn,ToIdType(curType)));
- mcIdType endCellId=ToIdType(std::distance(connI,i));
- mcIdType sz=endCellId-beginCellId;
- mcIdType *cells=new mcIdType[sz];
+ mcIdType const endCellId=ToIdType(std::distance(connI,i));
+ mcIdType const sz=endCellId-beginCellId;
+ auto *cells=new mcIdType[sz];
for(mcIdType j=0;j<sz;j++)
cells[j]=beginCellId+j;
- MEDCouplingUMesh *m=(MEDCouplingUMesh *)buildPartOfMySelf(cells,cells+sz,true);
+ auto *m=(MEDCouplingUMesh *)buildPartOfMySelf(cells,cells+sz,true);
delete [] cells;
ret.push_back(m);
}
checkConnectivityFullyDefined();
if(_types.size()!=1)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::convertIntoSingleGeoTypeMesh : current mesh does not contain exactly one geometric type !");
- INTERP_KERNEL::NormalizedCellType typ=*_types.begin();
+ INTERP_KERNEL::NormalizedCellType const typ=*_types.begin();
MCAuto<MEDCoupling1GTUMesh> ret=MEDCoupling1GTUMesh::New(getName(),typ);
ret->setCoords(getCoords());
- MEDCoupling1SGTUMesh *retC=dynamic_cast<MEDCoupling1SGTUMesh *>((MEDCoupling1GTUMesh*)ret);
+ auto *retC=dynamic_cast<MEDCoupling1SGTUMesh *>((MEDCoupling1GTUMesh*)ret);
if(retC)
{
MCAuto<DataArrayIdType> c=convertNodalConnectivityToStaticGeoTypeMesh();
}
else
{
- MEDCoupling1DGTUMesh *retD=dynamic_cast<MEDCoupling1DGTUMesh *>((MEDCoupling1GTUMesh*)ret);
+ auto *retD=dynamic_cast<MEDCoupling1DGTUMesh *>((MEDCoupling1GTUMesh*)ret);
if(!retD)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::convertIntoSingleGeoTypeMesh : Internal error !");
- DataArrayIdType *c=0,*ci=0;
+ DataArrayIdType *c=nullptr,*ci=nullptr;
convertNodalConnectivityToDynamicGeoTypeMesh(c,ci);
MCAuto<DataArrayIdType> cs(c),cis(ci);
retD->setNodalConnectivity(cs,cis);
checkConnectivityFullyDefined();
if(_types.size()!=1)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::convertNodalConnectivityToStaticGeoTypeMesh : current mesh does not contain exactly one geometric type !");
- INTERP_KERNEL::NormalizedCellType typ=*_types.begin();
+ INTERP_KERNEL::NormalizedCellType const typ=*_types.begin();
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
if(cm.isDynamic())
{
oss << "this type is dynamic ! Only static geometric type is possible for that type ! call convertNodalConnectivityToDynamicGeoTypeMesh instead !";
throw INTERP_KERNEL::Exception(oss.str());
}
- mcIdType nbCells=getNumberOfCells();
- mcIdType typi=ToIdType(typ);
+ mcIdType const nbCells=getNumberOfCells();
+ mcIdType const typi=ToIdType(typ);
mcIdType nbNodesPerCell=ToIdType(cm.getNumberOfNodes());
MCAuto<DataArrayIdType> connOut=DataArrayIdType::New(); connOut->alloc(nbCells*nbNodesPerCell,1);
mcIdType *outPtr=connOut->getPointer();
for(mcIdType i=0;i<nbCells;i++,cip++,incip++)
{
mcIdType strt(incip[0]+1),stop(incip[1]);//+1 to skip geo type
- mcIdType delta(stop-strt);
+ mcIdType const delta(stop-strt);
if(delta>=1)
{
if((strt>=0 && strt<lgth) && (stop>=0 && stop<=lgth))
DataArrayIdType *&idInMsOfCellGrpOfSameType)
{
std::vector<const MEDCouplingUMesh *> ms2;
- for(std::vector<const MEDCouplingUMesh *>::const_iterator it=ms.begin();it!=ms.end();it++)
- if(*it)
+ for(auto m : ms)
+ if(m)
{
- (*it)->checkConnectivityFullyDefined();
- ms2.push_back(*it);
+ m->checkConnectivityFullyDefined();
+ ms2.push_back(m);
}
if(ms2.empty())
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::AggregateSortedByTypeMeshesOnSameCoords : input vector is empty !");
const DataArrayDouble *refCoo=ms2[0]->getCoords();
- int meshDim=ms2[0]->getMeshDimension();
+ int const meshDim=ms2[0]->getMeshDimension();
std::vector<const MEDCouplingUMesh *> m1ssm;
std::vector< MCAuto<MEDCouplingUMesh> > m1ssmAuto;
//
std::vector<MEDCouplingUMesh *> sp=(*it)->splitByType();
std::copy(sp.begin(),sp.end(),std::back_insert_iterator< std::vector<const MEDCouplingUMesh *> >(m1ssm));
std::copy(sp.begin(),sp.end(),std::back_insert_iterator< std::vector<MCAuto<MEDCouplingUMesh> > >(m1ssmAuto));
- for(std::vector<MEDCouplingUMesh *>::const_iterator it2=sp.begin();it2!=sp.end();it2++)
+ for(auto it2 : sp)
{
- MEDCouplingUMesh *singleCell=static_cast<MEDCouplingUMesh *>((*it2)->buildPartOfMySelf(&fake,&fake+1,true));
+ auto *singleCell=static_cast<MEDCouplingUMesh *>(it2->buildPartOfMySelf(&fake,&fake+1,true));
m1ssmSingleAuto.push_back(singleCell);
m1ssmSingle.push_back(singleCell);
- ret1->pushBackSilent((*it2)->getNumberOfCells()); ret2->pushBackSilent(rk);
+ ret1->pushBackSilent(it2->getNumberOfCells()); ret2->pushBackSilent(rk);
}
}
MCAuto<MEDCouplingUMesh> m1ssmSingle2=MEDCouplingUMesh::MergeUMeshesOnSameCoords(m1ssmSingle);
checkFullyDefined();
const mcIdType *conn=_nodal_connec->begin();
const mcIdType *connI=_nodal_connec_index->begin();
- mcIdType nbOfCells=getNumberOfCells();
- std::set<INTERP_KERNEL::NormalizedCellType> types(getAllGeoTypes());
- mcIdType *tmp=new mcIdType[nbOfCells];
- for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator iter=types.begin();iter!=types.end();iter++)
+ mcIdType const nbOfCells=getNumberOfCells();
+ std::set<INTERP_KERNEL::NormalizedCellType> const types(getAllGeoTypes());
+ auto *tmp=new mcIdType[nbOfCells];
+ for(auto type : types)
{
mcIdType j=0;
for(const mcIdType *i=connI;i!=connI+nbOfCells;i++)
- if((INTERP_KERNEL::NormalizedCellType)conn[*i]==(*iter))
+ if((INTERP_KERNEL::NormalizedCellType)conn[*i]==type)
tmp[std::distance(connI,i)]=j++;
}
DataArrayIdType *ret=DataArrayIdType::New();
ret->copyStringInfoFrom(*da);
mcIdType *retPtr=ret->getPointer();
const mcIdType *daPtr=da->begin();
- mcIdType nbOfElems=da->getNbOfElems();
+ mcIdType const nbOfElems=da->getNbOfElems();
for(mcIdType k=0;k<nbOfElems;k++)
retPtr[k]=tmp[daPtr[k]];
delete [] tmp;
MEDCouplingUMesh *MEDCouplingUMesh::keepSpecifiedCells(INTERP_KERNEL::NormalizedCellType type, const mcIdType *idsPerGeoTypeBg, const mcIdType *idsPerGeoTypeEnd) const
{
std::vector<mcIdType> code=getDistributionOfTypes();
- std::size_t nOfTypesInThis=code.size()/3;
+ std::size_t const nOfTypesInThis=code.size()/3;
mcIdType sz=0,szOfType=0;
for(std::size_t i=0;i<nOfTypesInThis;i++)
{
*/
std::vector<bool> MEDCouplingUMesh::getQuadraticStatus() const
{
- mcIdType ncell=getNumberOfCells();
+ mcIdType const ncell=getNumberOfCells();
std::vector<bool> ret(ncell);
const mcIdType *cI=getNodalConnectivityIndex()->begin();
const mcIdType *c=getNodalConnectivity()->begin();
for(mcIdType i=0;i<ncell;i++)
{
- INTERP_KERNEL::NormalizedCellType typ=(INTERP_KERNEL::NormalizedCellType)c[cI[i]];
+ auto const typ=(INTERP_KERNEL::NormalizedCellType)c[cI[i]];
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
ret[i]=cm.isQuadratic();
}
{
if(other->getType()!=UNSTRUCTURED)
throw INTERP_KERNEL::Exception("Merge of umesh only available with umesh each other !");
- const MEDCouplingUMesh *otherC=static_cast<const MEDCouplingUMesh *>(other);
+ const auto *otherC=static_cast<const MEDCouplingUMesh *>(other);
return MergeUMeshes(this,otherC);
}
DataArrayDouble *MEDCouplingUMesh::computeCellCenterOfMass() const
{
MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- int spaceDim=getSpaceDimension();
- mcIdType nbOfCells=getNumberOfCells();
+ int const spaceDim=getSpaceDimension();
+ mcIdType const nbOfCells=getNumberOfCells();
ret->alloc(nbOfCells,spaceDim);
ret->copyStringInfoFrom(*getCoords());
double *ptToFill=ret->getPointer();
const double *coor=_coords->begin();
for(mcIdType i=0;i<nbOfCells;i++)
{
- INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)nodal[nodalI[i]];
+ auto const type=(INTERP_KERNEL::NormalizedCellType)nodal[nodalI[i]];
INTERP_KERNEL::computeBarycenter2<mcIdType,INTERP_KERNEL::ALL_C_MODE>(type,nodal+nodalI[i]+1,nodalI[i+1]-nodalI[i]-1,coor,spaceDim,ptToFill);
ptToFill+=spaceDim;
}
*/
DataArrayDouble *MEDCouplingUMesh::computeCellCenterOfMassWithPrecision(double eps) const
{
- INTERP_KERNEL::QuadraticPlanarPrecision prec(eps);
+ INTERP_KERNEL::QuadraticPlanarPrecision const prec(eps);
MCAuto<DataArrayDouble> ret = computeCellCenterOfMass();
return ret.retn();
}
{
checkFullyDefined();
MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- int spaceDim=getSpaceDimension();
- mcIdType nbOfCells=getNumberOfCells();
- mcIdType nbOfNodes=getNumberOfNodes();
+ int const spaceDim=getSpaceDimension();
+ mcIdType const nbOfCells=getNumberOfCells();
+ mcIdType const nbOfNodes=getNumberOfNodes();
ret->alloc(nbOfCells,spaceDim);
double *ptToFill=ret->getPointer();
const mcIdType *nodal=_nodal_connec->begin();
const double *coor=_coords->begin();
for(mcIdType i=0;i<nbOfCells;i++,ptToFill+=spaceDim)
{
- INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)nodal[nodalI[i]];
+ auto const type=(INTERP_KERNEL::NormalizedCellType)nodal[nodalI[i]];
std::fill(ptToFill,ptToFill+spaceDim,0.);
if(type!=INTERP_KERNEL::NORM_POLYHED)
{
throw INTERP_KERNEL::Exception(oss.str());
}
}
- mcIdType nbOfNodesInCell=nodalI[i+1]-nodalI[i]-1;
+ mcIdType const nbOfNodesInCell=nodalI[i+1]-nodalI[i]-1;
if(nbOfNodesInCell>0)
std::transform(ptToFill,ptToFill+spaceDim,ptToFill,std::bind(std::multiplies<double>(),std::placeholders::_1,1./(double)nbOfNodesInCell));
else
{
std::set<mcIdType> s(nodal+nodalI[i]+1,nodal+nodalI[i+1]);
s.erase(-1);
- for(std::set<mcIdType>::const_iterator it=s.begin();it!=s.end();it++)
+ for(long const it : s)
{
- if(*it>=0 && *it<nbOfNodes)
- std::transform(coor+spaceDim*(*it),coor+spaceDim*((*it)+1),ptToFill,ptToFill,std::plus<double>());
+ if(it>=0 && it<nbOfNodes)
+ std::transform(coor+spaceDim*it,coor+spaceDim*(it+1),ptToFill,ptToFill,std::plus<double>());
else
{
- std::ostringstream oss; oss << "MEDCouplingUMesh::computeIsoBarycenterOfNodesPerCell : on cell polyhedron cell #" << i << " presence of nodeId #" << *it << " should be in [0," << nbOfNodes << ") !";
+ std::ostringstream oss; oss << "MEDCouplingUMesh::computeIsoBarycenterOfNodesPerCell : on cell polyhedron cell #" << i << " presence of nodeId #" << it << " should be in [0," << nbOfNodes << ") !";
throw INTERP_KERNEL::Exception(oss.str());
}
}
DataArrayDouble *MEDCouplingUMesh::getPartBarycenterAndOwner(const mcIdType *begin, const mcIdType *end) const
{
DataArrayDouble *ret=DataArrayDouble::New();
- int spaceDim=getSpaceDimension();
- std::size_t nbOfTuple=std::distance(begin,end);
+ int const spaceDim=getSpaceDimension();
+ std::size_t const nbOfTuple=std::distance(begin,end);
ret->alloc(nbOfTuple,spaceDim);
double *ptToFill=ret->getPointer();
- double *tmp=new double[spaceDim];
+ auto *tmp=new double[spaceDim];
const mcIdType *nodal=_nodal_connec->begin();
const mcIdType *nodalI=_nodal_connec_index->begin();
const double *coor=_coords->begin();
for(const mcIdType *w=begin;w!=end;w++)
{
- INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)nodal[nodalI[*w]];
+ auto const type=(INTERP_KERNEL::NormalizedCellType)nodal[nodalI[*w]];
INTERP_KERNEL::computeBarycenter2<mcIdType,INTERP_KERNEL::ALL_C_MODE>(type,nodal+nodalI[*w]+1,nodalI[*w+1]-nodalI[*w]-1,coor,spaceDim,ptToFill);
ptToFill+=spaceDim;
}
DataArrayDouble *MEDCouplingUMesh::computePlaneEquationOf3DFaces() const
{
MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
- mcIdType nbOfCells=getNumberOfCells();
- mcIdType nbOfNodes(getNumberOfNodes());
+ mcIdType const nbOfCells=getNumberOfCells();
+ mcIdType const nbOfNodes(getNumberOfNodes());
if(getSpaceDimension()!=3 || getMeshDimension()!=2)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::computePlaneEquationOf3DFaces : This method must be applied on a mesh having meshDimension equal 2 and a spaceDimension equal to 3 !");
ret->alloc(nbOfCells,4);
,bb[3]={coor[nodal[nodalI[0]+1+2]*3+0]-coor[nodal[nodalI[0]+1+0]*3+0],
coor[nodal[nodalI[0]+1+2]*3+1]-coor[nodal[nodalI[0]+1+0]*3+1],
coor[nodal[nodalI[0]+1+2]*3+2]-coor[nodal[nodalI[0]+1+0]*3+2]};
- double cc[3]={aa[1]*bb[2]-aa[2]*bb[1],aa[2]*bb[0]-aa[0]*bb[2],aa[0]*bb[1]-aa[1]*bb[0]};
+ double const cc[3]={aa[1]*bb[2]-aa[2]*bb[1],aa[2]*bb[0]-aa[0]*bb[2],aa[0]*bb[1]-aa[1]*bb[0]};
double aa_norm(sqrt(aa[0]*aa[0]+aa[1]*aa[1]+aa[2]*aa[2])),bb_norm(sqrt(bb[0]*bb[0]+bb[1]*bb[1]+bb[2]*bb[2]));
for(int j=0;j<3;j++)
{
- mcIdType nodeId(nodal[nodalI[0]+1+j]);
+ mcIdType const nodeId(nodal[nodalI[0]+1+j]);
if(nodeId>=0 && nodeId<nbOfNodes)
std::copy(coor+nodeId*3,coor+(nodeId+1)*3,matrix+4*j);
else
double dd[3]={0.,0.,0.};
for(mcIdType offset=nodalI[0]+1;offset<nodalI[1];offset++)
std::transform(coor+3*nodal[offset],coor+3*(nodal[offset]+1),dd,dd,std::plus<double>());
- mcIdType nbOfNodesInCell(nodalI[1]-nodalI[0]-1);
+ mcIdType const nbOfNodesInCell(nodalI[1]-nodalI[0]-1);
std::transform(dd,dd+3,dd,std::bind(std::multiplies<double>(),std::placeholders::_1,1./(double)nbOfNodesInCell));
std::copy(dd,dd+3,matrix+4*2);
INTERP_KERNEL::inverseMatrix(matrix,4,matrix2);
if(!da)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::Build0DMeshFromCoords : instance of DataArrayDouble must be not null !");
da->checkAllocated();
- std::string name(da->getName());
+ std::string const name(da->getName());
MCAuto<MEDCouplingUMesh> ret(MEDCouplingUMesh::New(name,0));
if(name.empty())
ret->setName("Mesh");
ret->setCoords(da);
- mcIdType nbOfTuples(da->getNumberOfTuples());
+ mcIdType const nbOfTuples(da->getNumberOfTuples());
MCAuto<DataArrayIdType> c(DataArrayIdType::New()),cI(DataArrayIdType::New());
c->alloc(2*nbOfTuples,1);
cI->alloc(nbOfTuples+1,1);
if(!da)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::Build01MeshFromCoords : instance of DataArrayDouble must be not null !");
da->checkAllocated();
- std::string name(da->getName());
+ std::string const name(da->getName());
MCAuto<MEDCouplingUMesh> ret;
{
MCAuto<MEDCouplingCMesh> tmp(MEDCouplingCMesh::New());
*/
MEDCouplingUMesh *MEDCouplingUMesh::MergeUMeshes(const std::vector<const MEDCouplingUMesh *>& a)
{
- std::size_t sz=a.size();
+ std::size_t const sz=a.size();
if(sz==0)
return MergeUMeshesLL(a);
for(std::size_t ii=0;ii<sz;ii++)
throw INTERP_KERNEL::Exception(oss.str());
}
const DataArrayDouble *coords=meshes.front()->getCoords();
- int meshDim=meshes.front()->getMeshDimension();
- std::vector<const MEDCouplingUMesh *>::const_iterator iter=meshes.begin();
+ int const meshDim=meshes.front()->getMeshDimension();
+ auto iter=meshes.begin();
mcIdType meshLgth=0;
mcIdType meshIndexLgth=0;
for(;iter!=meshes.end();iter++)
{
const mcIdType *nod=(*iter)->getNodalConnectivity()->begin();
const mcIdType *index=(*iter)->getNodalConnectivityIndex()->begin();
- mcIdType nbOfCells=(*iter)->getNumberOfCells();
- mcIdType meshLgth2=(*iter)->getNodalConnectivityArrayLen();
+ mcIdType const nbOfCells=(*iter)->getNumberOfCells();
+ mcIdType const meshLgth2=(*iter)->getNodalConnectivityArrayLen();
nodalPtr=std::copy(nod,nod+meshLgth2,nodalPtr);
if(iter!=meshes.begin())
nodalIndexPtr=std::transform(index+1,index+nbOfCells+1,nodalIndexPtr,std::bind(std::plus<mcIdType>(),std::placeholders::_1,offset));
MCAuto<MEDCouplingUMesh> ret=MergeUMeshesOnSameCoords(meshes);
MCAuto<DataArrayIdType> o2n=ret->zipConnectivityTraducer(compType);
corr.resize(meshes.size());
- std::size_t nbOfMeshes=meshes.size();
+ std::size_t const nbOfMeshes=meshes.size();
mcIdType offset=0;
const mcIdType *o2nPtr=o2n->begin();
for(std::size_t i=0;i<nbOfMeshes;i++)
{
DataArrayIdType *tmp=DataArrayIdType::New();
- mcIdType curNbOfCells=meshes[i]->getNumberOfCells();
+ mcIdType const curNbOfCells=meshes[i]->getNumberOfCells();
tmp->alloc(curNbOfCells,1);
std::copy(o2nPtr+offset,o2nPtr+offset+curNbOfCells,tmp->getPointer());
offset+=curNbOfCells;
*/
void MEDCouplingUMesh::PutUMeshesOnSameAggregatedCoords(const std::vector<MEDCouplingUMesh *>& meshes)
{
- std::size_t sz=meshes.size();
+ std::size_t const sz=meshes.size();
if(sz==0 || sz==1)
return;
std::vector< const DataArrayDouble * > coords(meshes.size());
- std::vector< const DataArrayDouble * >::iterator it2=coords.begin();
- for(std::vector<MEDCouplingUMesh *>::const_iterator it=meshes.begin();it!=meshes.end();it++,it2++)
+ auto it2=coords.begin();
+ for(auto it=meshes.begin();it!=meshes.end();it++,it2++)
{
if((*it))
{
}
}
MCAuto<DataArrayDouble> res=DataArrayDouble::Aggregate(coords);
- std::vector<MEDCouplingUMesh *>::const_iterator it=meshes.begin();
+ auto it=meshes.begin();
mcIdType offset=(*it)->getNumberOfNodes();
(*it++)->setCoords(res);
for(;it!=meshes.end();it++)
{
- mcIdType oldNumberOfNodes=(*it)->getNumberOfNodes();
+ mcIdType const oldNumberOfNodes=(*it)->getNumberOfNodes();
(*it)->setCoords(res);
(*it)->shiftNodeNumbersInConn(offset);
offset+=oldNumberOfNodes;
if(meshes.empty())
return ;
std::set<const DataArrayDouble *> s;
- for(std::vector<MEDCouplingUMesh *>::const_iterator it=meshes.begin();it!=meshes.end();it++)
+ for(auto it=meshes.begin();it!=meshes.end();it++)
{
if(*it)
s.insert((*it)->getCoords());
DataArrayIdType *comm,*commI;
coo->findCommonTuples(eps,-1,comm,commI);
MCAuto<DataArrayIdType> tmp1(comm),tmp2(commI);
- mcIdType oldNbOfNodes=coo->getNumberOfTuples();
+ mcIdType const oldNbOfNodes=coo->getNumberOfTuples();
mcIdType newNbOfNodes;
MCAuto<DataArrayIdType> o2n=DataArrayIdType::ConvertIndexArrayToO2N(oldNbOfNodes,comm->begin(),commI->begin(),commI->end(),newNbOfNodes);
if(oldNbOfNodes==newNbOfNodes)
return ;
- MCAuto<DataArrayDouble> newCoords=coo->renumberAndReduce(o2n->begin(),newNbOfNodes);
- for(std::vector<MEDCouplingUMesh *>::const_iterator it=meshes.begin();it!=meshes.end();it++)
+ MCAuto<DataArrayDouble> const newCoords=coo->renumberAndReduce(o2n->begin(),newNbOfNodes);
+ for(auto meshe : meshes)
{
- (*it)->renumberNodesInConn(o2n->begin());
- (*it)->setCoords(newCoords);
+ meshe->renumberNodesInConn(o2n->begin());
+ meshe->setCoords(newCoords);
}
}
{
std::size_t i, ip1;
double v[3]={0.,0.,0.};
- std::size_t sz=std::distance(begin,end);
+ std::size_t const sz=std::distance(begin,end);
if(!isQuadratic)
for(i=0;i<sz;i++)
{
// Same algorithm as above but also using intermediate quadratic points.
// (taking only linear points might lead to issues if the linearized version of the
// polygon is not convex or self-intersecting ... see testCellOrientation4)
- std::size_t hsz = sz/2;
+ std::size_t const hsz = sz/2;
for(std::size_t j=0;j<sz;j++)
{
if (j%2) // current point i is quadratic, next point i+1 is standard
v[2]+=coords[3*begin[i]]*coords[3*begin[ip1]+1]-coords[3*begin[i]+1]*coords[3*begin[ip1]];
}
}
- double ret = vec[0]*v[0]+vec[1]*v[1]+vec[2]*v[2];
+ double const ret = vec[0]*v[0]+vec[1]*v[1]+vec[2]*v[2];
return (ret>0.);
}
bool MEDCouplingUMesh::IsPolyhedronWellOriented(const mcIdType *begin, const mcIdType *end, const double *coords)
{
std::vector<std::pair<mcIdType,mcIdType> > edges;
- std::size_t nbOfFaces=std::count(begin,end,-1)+1;
+ std::size_t const nbOfFaces=std::count(begin,end,-1)+1;
const mcIdType *bgFace=begin;
for(std::size_t i=0;i<nbOfFaces;i++)
{
const mcIdType *endFace=std::find(bgFace+1,end,-1);
- std::size_t nbOfEdgesInFace=std::distance(bgFace,endFace);
+ std::size_t const nbOfEdgesInFace=std::distance(bgFace,endFace);
for(std::size_t j=0;j<nbOfEdgesInFace;j++)
{
- std::pair<mcIdType,mcIdType> p1(bgFace[j],bgFace[(j+1)%nbOfEdgesInFace]);
+ std::pair<mcIdType,mcIdType> const p1(bgFace[j],bgFace[(j+1)%nbOfEdgesInFace]);
if(std::find(edges.begin(),edges.end(),p1)!=edges.end())
return false;
edges.push_back(p1);
bool MEDCouplingUMesh::Is3DExtrudedStaticCellWellOriented(const mcIdType *begin, const mcIdType *end, const double *coords)
{
double vec0[3],vec1[3];
- std::size_t sz=std::distance(begin,end);
+ std::size_t const sz=std::distance(begin,end);
if(sz%2!=0)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::Is3DExtrudedStaticCellWellOriented : the length of nodal connectivity of extruded cell is not even !");
- mcIdType nbOfNodes=ToIdType(sz/2);
+ mcIdType const nbOfNodes=ToIdType(sz/2);
INTERP_KERNEL::areaVectorOfPolygon<mcIdType,INTERP_KERNEL::ALL_C_MODE>(begin,nbOfNodes,coords,vec0);
const double *pt0=coords+3*begin[0];
const double *pt1=coords+3*begin[nbOfNodes];
void MEDCouplingUMesh::CorrectExtrudedStaticCell(mcIdType *begin, mcIdType *end)
{
- std::size_t sz=std::distance(begin,end);
+ std::size_t const sz=std::distance(begin,end);
INTERP_KERNEL::AutoPtr<mcIdType> tmp=new mcIdType[sz];
- std::size_t nbOfNodes(sz/2);
+ std::size_t const nbOfNodes(sz/2);
std::copy(begin,end,(mcIdType *)tmp);
for(std::size_t j=1;j<nbOfNodes;j++)
{
bool MEDCouplingUMesh::IsTetra4WellOriented(const mcIdType *begin, const mcIdType *end, const double *coords)
{
- std::size_t sz=std::distance(begin,end);
+ std::size_t const sz=std::distance(begin,end);
if(sz!=4)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::IsTetra4WellOriented : Tetra4 cell with not 4 nodes ! Call checkConsistency !");
double vec0[3],vec1[3];
bool MEDCouplingUMesh::IsPyra5WellOriented(const mcIdType *begin, const mcIdType *end, const double *coords)
{
- std::size_t sz=std::distance(begin,end);
+ std::size_t const sz=std::distance(begin,end);
if(sz!=5)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::IsPyra5WellOriented : Pyra5 cell with not 5 nodes ! Call checkConsistency !");
double vec0[3];
void MEDCouplingUMesh::SimplifyPolyhedronCell(double eps, const DataArrayDouble *coords, mcIdType index, DataArrayIdType *res, MEDCouplingUMesh *faces,
DataArrayIdType *E_Fi, DataArrayIdType *E_F, DataArrayIdType *F_Ei, DataArrayIdType *F_E)
{
- mcIdType nbFaces = E_Fi->getIJ(index + 1, 0) - E_Fi->getIJ(index, 0);
+ mcIdType const nbFaces = E_Fi->getIJ(index + 1, 0) - E_Fi->getIJ(index, 0);
MCAuto<DataArrayDouble> v=DataArrayDouble::New(); v->alloc(nbFaces,3);
double *vPtr=v->getPointer();
MCAuto<DataArrayDouble> p=DataArrayDouble::New(); p->alloc(nbFaces,2);
const mcIdType *f_idx = faces->getNodalConnectivityIndex()->getPointer(), *f_cnn = faces->getNodalConnectivity()->getPointer();
for(mcIdType i=0;i<nbFaces;i++,vPtr+=3,pPtr++)
{
- mcIdType face = e_f[e_fi[index] + i];
+ mcIdType const face = e_f[e_fi[index] + i];
ComputeVecAndPtOfFace(eps, coords->begin(), f_cnn + f_idx[face] + 1, f_cnn + f_idx[face + 1], vPtr, pPtr);
// to differentiate faces going to different cells:
pPtr++, *pPtr = 0;
*pPtr += FromIdType<double>(f_e[j]);
}
pPtr=p->getPointer(); vPtr=v->getPointer();
- DataArrayIdType *comm1=0,*commI1=0;
+ DataArrayIdType *comm1=nullptr,*commI1=nullptr;
v->findCommonTuples(eps,-1,comm1,commI1);
for (mcIdType i = 0; i < nbFaces; i++)
if (comm1->findIdFirstEqual(i) < 0)
MCAuto<DataArrayIdType> comm1Auto(comm1),commI1Auto(commI1);
const mcIdType *comm1Ptr=comm1->begin();
const mcIdType *commI1Ptr=commI1->begin();
- mcIdType nbOfGrps1=commI1Auto->getNumberOfTuples()-1;
+ mcIdType const nbOfGrps1=commI1Auto->getNumberOfTuples()-1;
res->pushBackSilent(ToIdType(INTERP_KERNEL::NORM_POLYHED));
//
for(mcIdType i=0;i<nbOfGrps1;i++)
{
- mcIdType vecId=comm1Ptr[commI1Ptr[i]];
+ mcIdType const vecId=comm1Ptr[commI1Ptr[i]];
MCAuto<DataArrayDouble> tmpgrp2=p->selectByTupleId(comm1Ptr+commI1Ptr[i],comm1Ptr+commI1Ptr[i+1]);
- DataArrayIdType *comm2=0,*commI2=0;
+ DataArrayIdType *comm2=nullptr,*commI2=nullptr;
tmpgrp2->findCommonTuples(eps,-1,comm2,commI2);
for (mcIdType j = 0; j < commI1Ptr[i+1] - commI1Ptr[i]; j++)
if (comm2->findIdFirstEqual(j) < 0)
MCAuto<DataArrayIdType> comm2Auto(comm2),commI2Auto(commI2);
const mcIdType *comm2Ptr=comm2->begin();
const mcIdType *commI2Ptr=commI2->begin();
- mcIdType nbOfGrps2=commI2Auto->getNumberOfTuples()-1;
+ mcIdType const nbOfGrps2=commI2Auto->getNumberOfTuples()-1;
for(mcIdType j=0;j<nbOfGrps2;j++)
{
if(commI2Ptr[j+1] == commI2Ptr[j] + 1)
{
- mcIdType face = e_f[e_fi[index] + comm1Ptr[commI1Ptr[i] + comm2Ptr[commI2Ptr[j]]]]; //hmmm
+ mcIdType const face = e_f[e_fi[index] + comm1Ptr[commI1Ptr[i] + comm2Ptr[commI2Ptr[j]]]]; //hmmm
res->insertAtTheEnd(f_cnn + f_idx[face] + 1, f_cnn + f_idx[face + 1]);
res->pushBackSilent(-1);
}
else
{
- mcIdType pointId=comm1Ptr[commI1Ptr[i]+comm2Ptr[commI2Ptr[j]]];
+ mcIdType const pointId=comm1Ptr[commI1Ptr[i]+comm2Ptr[commI2Ptr[j]]];
MCAuto<DataArrayIdType> ids2=comm2->selectByTupleIdSafeSlice(commI2Ptr[j],commI2Ptr[j+1],1);
ids2->transformWithIndArr(comm1Ptr+commI1Ptr[i],comm1Ptr+commI1Ptr[i+1]);
ids2->transformWithIndArr(e_f + e_fi[index], e_f + e_fi[index + 1]);
const mcIdType *idsNodePtr=idsNode->begin();
double center[3]; center[0]=pPtr[2*pointId]*vPtr[3*vecId]; center[1]=pPtr[2*pointId]*vPtr[3*vecId+1]; center[2]=pPtr[2*pointId]*vPtr[3*vecId+2];
double vec[3]; vec[0]=vPtr[3*vecId+1]; vec[1]=-vPtr[3*vecId]; vec[2]=0.;
- double norm=vec[0]*vec[0]+vec[1]*vec[1]+vec[2]*vec[2];
+ double const norm=vec[0]*vec[0]+vec[1]*vec[1]+vec[2]*vec[2];
if(std::abs(norm)>eps)
{
- double angle=INTERP_KERNEL::EdgeArcCircle::SafeAsin(norm);
+ double const angle=INTERP_KERNEL::EdgeArcCircle::SafeAsin(norm);
mm3->rotate(center,vec,angle);
}
mm3->changeSpaceDimension(2);
MCAuto<MEDCouplingUMesh> mm4=mm3->buildSpreadZonesWithPoly();
const mcIdType *conn4=mm4->getNodalConnectivity()->begin();
const mcIdType *connI4=mm4->getNodalConnectivityIndex()->begin();
- mcIdType nbOfCells=mm4->getNumberOfCells();
+ mcIdType const nbOfCells=mm4->getNumberOfCells();
for(mcIdType k=0;k<nbOfCells;k++)
{
int l=0;
*/
void MEDCouplingUMesh::ComputeVecAndPtOfFace(double eps, const double *coords, const mcIdType *begin, const mcIdType *end, double *v, double *p)
{
- std::size_t nbPoints=std::distance(begin,end);
+ std::size_t const nbPoints=std::distance(begin,end);
if(nbPoints<3)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ComputeVecAndPtOfFace : < of 3 points in face ! not able to find a plane on that face !");
double vec[3]={0.,0.,0.};
vec[0]=coords[3*begin[j+1]]-coords[3*begin[j]];
vec[1]=coords[3*begin[j+1]+1]-coords[3*begin[j]+1];
vec[2]=coords[3*begin[j+1]+2]-coords[3*begin[j]+2];
- double norm=sqrt(vec[0]*vec[0]+vec[1]*vec[1]+vec[2]*vec[2]);
+ double const norm=sqrt(vec[0]*vec[0]+vec[1]*vec[1]+vec[2]*vec[2]);
if(norm>eps)
{
refFound=true;
void MEDCouplingUMesh::TryToCorrectPolyhedronOrientation(mcIdType *begin, mcIdType *end, const double *coords)
{
std::list< std::pair<mcIdType,mcIdType> > edgesOK,edgesFinished;
- std::size_t nbOfFaces=std::count(begin,end,-1)+1;
+ std::size_t const nbOfFaces=std::count(begin,end,-1)+1;
std::vector<bool> isPerm(nbOfFaces,false);//field on faces False: I don't know, True : oriented
isPerm[0]=true;
mcIdType *bgFace=begin,*endFace=std::find(begin+1,end,-1);
std::size_t nbOfEdgesInFace=std::distance(bgFace,endFace);
- for(std::size_t l=0;l<nbOfEdgesInFace;l++) { std::pair<mcIdType,mcIdType> p1(bgFace[l],bgFace[(l+1)%nbOfEdgesInFace]); edgesOK.push_back(p1); }
+ for(std::size_t l=0;l<nbOfEdgesInFace;l++) { std::pair<mcIdType,mcIdType> const p1(bgFace[l],bgFace[(l+1)%nbOfEdgesInFace]); edgesOK.push_back(p1); }
//
while(std::find(isPerm.begin(),isPerm.end(),false)!=isPerm.end())
{
bool b=false;
for(std::size_t j=0;j<nbOfEdgesInFace;j++)
{
- std::pair<mcIdType,mcIdType> p1(bgFace[j],bgFace[(j+1)%nbOfEdgesInFace]);
- std::pair<mcIdType,mcIdType> p2(p1.second,p1.first);
- bool b1=std::find(edgesOK.begin(),edgesOK.end(),p1)!=edgesOK.end();
- bool b2=std::find(edgesOK.begin(),edgesOK.end(),p2)!=edgesOK.end();
+ std::pair<mcIdType,mcIdType> const p1(bgFace[j],bgFace[(j+1)%nbOfEdgesInFace]);
+ std::pair<mcIdType,mcIdType> const p2(p1.second,p1.first);
+ bool const b1=std::find(edgesOK.begin(),edgesOK.end(),p1)!=edgesOK.end();
+ bool const b2=std::find(edgesOK.begin(),edgesOK.end(),p2)!=edgesOK.end();
if(b1 || b2) { b=b2; isPerm[i]=true; smthChanged++; break; }
}
if(isPerm[i])
std::reverse(bgFace+1,endFace);
for(std::size_t j=0;j<nbOfEdgesInFace;j++)
{
- std::pair<mcIdType,mcIdType> p1(bgFace[j],bgFace[(j+1)%nbOfEdgesInFace]);
- std::pair<mcIdType,mcIdType> p2(p1.second,p1.first);
+ std::pair<mcIdType,mcIdType> const p1(bgFace[j],bgFace[(j+1)%nbOfEdgesInFace]);
+ std::pair<mcIdType,mcIdType> const p2(p1.second,p1.first);
if(std::find(edgesOK.begin(),edgesOK.end(),p1)!=edgesOK.end())
{ std::ostringstream oss; oss << "Face #" << j << " of polyhedron looks bad !"; throw INTERP_KERNEL::Exception(oss.str()); }
if(std::find(edgesFinished.begin(),edgesFinished.end(),p1)!=edgesFinished.end() || std::find(edgesFinished.begin(),edgesFinished.end(),p2)!=edgesFinished.end())
{ std::ostringstream oss; oss << "Face #" << j << " of polyhedron looks bad !"; throw INTERP_KERNEL::Exception(oss.str()); }
- std::list< std::pair<mcIdType,mcIdType> >::iterator it=std::find(edgesOK.begin(),edgesOK.end(),p2);
+ auto const it=std::find(edgesOK.begin(),edgesOK.end(),p2);
if(it!=edgesOK.end())
{
edgesOK.erase(it);
if(getMeshDimension()!=2 || getSpaceDimension()!=2)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildUnionOf2DMesh : meshdimension, spacedimension must be equal to 2 !");
MCAuto<MEDCouplingUMesh> skin(computeSkin());
- mcIdType oldNbOfNodes(skin->getNumberOfNodes());
+ mcIdType const oldNbOfNodes(skin->getNumberOfNodes());
MCAuto<DataArrayIdType> o2n(skin->zipCoordsTraducer());
- mcIdType nbOfNodesExpected(skin->getNumberOfNodes());
+ mcIdType const nbOfNodesExpected(skin->getNumberOfNodes());
MCAuto<DataArrayIdType> n2o(o2n->invertArrayO2N2N2O(oldNbOfNodes));
- mcIdType nbCells=skin->getNumberOfCells();
+ mcIdType const nbCells=skin->getNumberOfCells();
if(nbCells==nbOfNodesExpected)
return buildUnionOf2DMeshLinear(skin,n2o);
else if(2*nbCells==nbOfNodesExpected)
MCAuto<MEDCouplingUMesh> m=computeSkin();
const mcIdType *conn=m->getNodalConnectivity()->begin();
const mcIdType *connI=m->getNodalConnectivityIndex()->begin();
- mcIdType nbOfCells=m->getNumberOfCells();
+ mcIdType const nbOfCells=m->getNumberOfCells();
MCAuto<DataArrayIdType> ret=DataArrayIdType::New(); ret->alloc(m->getNodalConnectivity()->getNumberOfTuples(),1);
mcIdType *work=ret->getPointer(); *work++=INTERP_KERNEL::NORM_POLYHED;
if(nbOfCells<1)
{
checkConnectivityFullyDefined();
- int meshDim = this->getMeshDimension();
+ int const meshDim = this->getMeshDimension();
MEDCoupling::DataArrayIdType* indexr=MEDCoupling::DataArrayIdType::New();
MEDCoupling::DataArrayIdType* revConn=MEDCoupling::DataArrayIdType::New();
this->getReverseNodalConnectivity(revConn,indexr);
const MEDCoupling::DataArrayIdType* conn;
conn=this->getNodalConnectivity(); // it includes a type as the 1st element!!!
index=this->getNodalConnectivityIndex();
- mcIdType nbCells=this->getNumberOfCells();
+ mcIdType const nbCells=this->getNumberOfCells();
const mcIdType* index_ptr=index->begin();
const mcIdType* conn_ptr=conn->begin();
std::map<mcIdType,mcIdType > counter;
for (mcIdType iconn=index_ptr[icell]+1; iconn<index_ptr[icell+1];iconn++)
{
- mcIdType inode=conn_ptr[iconn];
+ mcIdType const inode=conn_ptr[iconn];
for (mcIdType iconnr=indexr_ptr[inode]; iconnr<indexr_ptr[inode+1];iconnr++)
{
- mcIdType icell2=revConn_ptr[iconnr];
- std::map<mcIdType,mcIdType>::iterator iter=counter.find(icell2);
+ mcIdType const icell2=revConn_ptr[iconnr];
+ auto const iter=counter.find(icell2);
if (iter!=counter.end()) (iter->second)++;
else counter.insert(std::make_pair(icell2,1));
}
void MEDCouplingUMesh::writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData, DataArrayByte *byteData) const
{
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
if(nbOfCells<=0)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::writeVTK : the unstructured mesh has no cells !");
ofs << " <" << getVTKDataSetType() << ">\n";
}
else
{
- mcIdType deltaFaceOffset=cIPtr[i+1]-cIPtr[i]+1;
+ mcIdType const deltaFaceOffset=cIPtr[i+1]-cIPtr[i]+1;
*w1=szFaceOffsets+deltaFaceOffset; szFaceOffsets+=deltaFaceOffset;
std::set<mcIdType> c(cPtr+cIPtr[i]+1,cPtr+cIPtr[i+1]); c.erase(-1);
*w3=szConn+ToIdType(c.size()); szConn+=ToIdType(c.size());
w4=std::copy(c.begin(),c.end(),w4);
}
}
- std::unique_ptr<mcIdType[]> medcoupling2vtkTypeTraducer_mcIdType(new mcIdType[MEDCOUPLING2VTKTYPETRADUCER_LGTH]);
+ std::unique_ptr<mcIdType[]> const medcoupling2vtkTypeTraducer_mcIdType(new mcIdType[MEDCOUPLING2VTKTYPETRADUCER_LGTH]);
for(auto ii = 0; ii<MEDCOUPLING2VTKTYPETRADUCER_LGTH ; ++ii)
medcoupling2vtkTypeTraducer_mcIdType[ii] = MEDCOUPLING2VTKTYPETRADUCER[ii]!=MEDCOUPLING2VTKTYPETRADUCER_NONE?MEDCOUPLING2VTKTYPETRADUCER[ii] : -1;
types->transformWithIndArr(medcoupling2vtkTypeTraducer_mcIdType.get(),medcoupling2vtkTypeTraducer_mcIdType.get()+MEDCOUPLING2VTKTYPETRADUCER_LGTH);
types->writeVTK(ofs,8,"UInt8","types",byteData);
- std::string vtkTypeName = Traits<mcIdType>::VTKReprStr;
+ std::string const vtkTypeName = Traits<mcIdType>::VTKReprStr;
offsets->writeVTK(ofs,8,vtkTypeName,"offsets",byteData);
if(szFaceOffsets!=0)
{//presence of Polyhedra
for(mcIdType i=0;i<nbOfCells;i++)
if((INTERP_KERNEL::NormalizedCellType)cPtr[cIPtr[i]]==INTERP_KERNEL::NORM_POLYHED)
{
- mcIdType nbFaces=ToIdType(std::count(cPtr+cIPtr[i]+1,cPtr+cIPtr[i+1],-1))+1;
+ mcIdType const nbFaces=ToIdType(std::count(cPtr+cIPtr[i]+1,cPtr+cIPtr[i+1],-1))+1;
*w1++=nbFaces;
- const mcIdType *w6=cPtr+cIPtr[i]+1,*w5=0;
+ const mcIdType *w6=cPtr+cIPtr[i]+1,*w5=nullptr;
for(mcIdType j=0;j<nbFaces;j++)
{
w5=std::find(w6,cPtr+cIPtr[i+1],-1);
{ stream << std::endl << "Nodal connectivity NOT set !"; return ; }
if(!_nodal_connec_index->isAllocated())
{ stream << std::endl << "Nodal connectivity set but not allocated !"; return ; }
- mcIdType lgth=_nodal_connec_index->getNumberOfTuples();
- std::size_t cpt=_nodal_connec_index->getNumberOfComponents();
+ mcIdType const lgth=_nodal_connec_index->getNumberOfTuples();
+ std::size_t const cpt=_nodal_connec_index->getNumberOfComponents();
if(cpt!=1 || lgth<1)
return ;
stream << std::endl << "Number of cells : " << lgth-1 << ".";
MCAuto<DataArrayIdType> _dsi(_rDI->deltaShiftIndex());
const mcIdType * dsi(_dsi->begin());
MCAuto<DataArrayIdType> dsii = _dsi->findIdsNotInRange(0,3);
- m_points=0;
+ m_points=nullptr;
if (dsii->getNumberOfTuples())
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::orderConsecutiveCells1D only work with a mesh being a (piecewise) connected line!");
- mcIdType nc=getNumberOfCells();
+ mcIdType const nc=getNumberOfCells();
MCAuto<DataArrayIdType> result(DataArrayIdType::New());
result->alloc(nc,1);
activeSeg = (seg1 == activeSeg) ? seg2 : seg1;
//for piecewise meshes made up of closed parts
- bool segmentAlreadyTreated = (std::find(linePiece.begin(), linePiece.end(), activeSeg) != linePiece.end());
+ bool const segmentAlreadyTreated = (std::find(linePiece.begin(), linePiece.end(), activeSeg) != linePiece.end());
if(segmentAlreadyTreated)
break;
}
desc->checkAllocated(); descI->checkAllocated(); subNodesInSeg->checkAllocated(); subNodesInSegI->checkAllocated();
if(getSpaceDimension()!=2 || getMeshDimension()!=2)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::split2DCells : This method only works for meshes with spaceDim=2 and meshDim=2 !");
- if(midOpt==0 && midOptI==0)
+ if(midOpt==nullptr && midOptI==nullptr)
{
split2DCellsLinear(desc,descI,subNodesInSeg,subNodesInSegI);
return 0;
}
- else if(midOpt!=0 && midOptI!=0)
+ else if(midOpt!=nullptr && midOptI!=nullptr)
return split2DCellsQuadratic(desc,descI,subNodesInSeg,subNodesInSegI,midOpt,midOptI);
else
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::split2DCells : middle parameters must be set to null for all or not null for all.");
*/
bool MEDCouplingUMesh::BuildConvexEnvelopOf2DCellJarvis(const double *coords, const mcIdType *nodalConnBg, const mcIdType *nodalConnEnd, DataArrayIdType *nodalConnecOut)
{
- std::size_t sz=std::distance(nodalConnBg,nodalConnEnd);
+ std::size_t const sz=std::distance(nodalConnBg,nodalConnEnd);
if(sz>=4)
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)*nodalConnBg);
if(*node!=tmpOut.back() && *node!=prevNode)
{
tmp2[0]=coords[2*(*node)]-coords[2*tmpOut.back()]; tmp2[1]=coords[2*(*node)+1]-coords[2*tmpOut.back()+1];
- double angleM=INTERP_KERNEL::EdgeArcCircle::GetAbsoluteAngle(tmp2,tmp1);
+ double const angleM=INTERP_KERNEL::EdgeArcCircle::GetAbsoluteAngle(tmp2,tmp1);
double res;
if(angleM<=angle0)
res=angle0-angleM;
}
}
std::vector<mcIdType> tmp3(2*(sz-1));
- std::vector<mcIdType>::iterator it=std::copy(nodalConnBg+1,nodalConnEnd,tmp3.begin());
+ auto const it=std::copy(nodalConnBg+1,nodalConnEnd,tmp3.begin());
std::copy(nodalConnBg+1,nodalConnEnd,it);
if(std::search(tmp3.begin(),tmp3.end(),tmpOut.begin(),tmpOut.end())!=tmp3.end())
{
nbOfDepthPeelingPerformed=0;
if(!arrIndxIn)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ComputeSpreadZoneGraduallyFromSeed : arrIndxIn input pointer is NULL !");
- mcIdType nbOfTuples=arrIndxIn->getNumberOfTuples()-1;
+ mcIdType const nbOfTuples=arrIndxIn->getNumberOfTuples()-1;
if(nbOfTuples<=0)
{
DataArrayIdType *ret=DataArrayIdType::New(); ret->alloc(0,1);
MEDCouplingUMesh *MEDCouplingUMesh::buildSpreadZonesWithPoly() const
{
checkFullyDefined();
- int mdim=getMeshDimension();
- int spaceDim=getSpaceDimension();
+ int const mdim=getMeshDimension();
+ int const spaceDim=getSpaceDimension();
if(mdim!=spaceDim)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSpreadZonesWithPoly : meshdimension and spacedimension do not match !");
std::vector<DataArrayIdType *> partition=partitionBySpreadZone();
ret->setCoords(getCoords());
ret->allocateCells(ToIdType(partition.size()));
//
- for(std::vector<DataArrayIdType *>::const_iterator it=partition.begin();it!=partition.end();it++)
+ for(auto it : partition)
{
- MCAuto<MEDCouplingUMesh> tmp=static_cast<MEDCouplingUMesh *>(buildPartOfMySelf((*it)->begin(),(*it)->end(),true));
+ MCAuto<MEDCouplingUMesh> tmp=static_cast<MEDCouplingUMesh *>(buildPartOfMySelf(it->begin(),it->end(),true));
MCAuto<DataArrayIdType> cell;
switch(mdim)
{
*/
std::vector<DataArrayIdType *> MEDCouplingUMesh::partitionBySpreadZone() const
{
- DataArrayIdType *neigh=0,*neighI=0;
+ DataArrayIdType *neigh=nullptr,*neighI=nullptr;
computeNeighborsOfCells(neigh,neighI);
MCAuto<DataArrayIdType> neighAuto(neigh),neighIAuto(neighI);
return PartitionBySpreadZone(neighAuto,neighIAuto);
if(!arrIn || !arrIndxIn)
throw INTERP_KERNEL::Exception("PartitionBySpreadZone : null input pointers !");
arrIn->checkAllocated(); arrIndxIn->checkAllocated();
- mcIdType nbOfTuples(arrIndxIn->getNumberOfTuples());
+ mcIdType const nbOfTuples(arrIndxIn->getNumberOfTuples());
if(arrIn->getNumberOfComponents()!=1 || arrIndxIn->getNumberOfComponents()!=1 || nbOfTuples<1)
throw INTERP_KERNEL::Exception("PartitionBySpreadZone : invalid arrays in input !");
- mcIdType nbOfCellsCur(nbOfTuples-1);
+ mcIdType const nbOfCellsCur(nbOfTuples-1);
std::vector<DataArrayIdType *> ret;
if(nbOfCellsCur<=0)
return ret;
ret2.push_back(ComputeSpreadZoneGraduallyFromSeedAlg(fetchedCells,&seed,&seed+1,arrIn,arrIndxIn,-1,nbOfPeelPerformed));
seed=ToIdType(std::distance(fetchedCells.begin(),std::find(fetchedCells.begin()+seed,fetchedCells.end(),false)));
}
- for(std::vector< MCAuto<DataArrayIdType> >::iterator it=ret2.begin();it!=ret2.end();it++)
- ret.push_back((*it).retn());
+ for(auto & it : ret2)
+ ret.push_back(it.retn());
return ret;
}
DataArrayIdType *MEDCouplingUMesh::ComputeRangesFromTypeDistribution(const std::vector<mcIdType>& code)
{
MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
- std::size_t nb=code.size()/3;
+ std::size_t const nb=code.size()/3;
if(code.size()%3!=0)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ComputeRangesFromTypeDistribution : invalid input code !");
ret->alloc(nb,2);
*/
MEDCoupling1SGTUMesh *MEDCouplingUMesh::tetrahedrize(int policy, DataArrayIdType *& n2oCells, mcIdType& nbOfAdditionalPoints) const
{
- INTERP_KERNEL::SplittingPolicy pol((INTERP_KERNEL::SplittingPolicy)policy);
+ auto const pol((INTERP_KERNEL::SplittingPolicy)policy);
checkConnectivityFullyDefined();
if(getMeshDimension()!=3 || getSpaceDimension()!=3)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::tetrahedrize : only available for mesh with meshdim == 3 and spacedim == 3 !");
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
mcIdType nbNodes(getNumberOfNodes());
MCAuto<MEDCoupling1SGTUMesh> ret0(MEDCoupling1SGTUMesh::New(getName(),INTERP_KERNEL::NORM_TETRA4));
MCAuto<DataArrayIdType> ret(DataArrayIdType::New()); ret->alloc(nbOfCells,1);
{
std::vector<mcIdType> a; std::vector<double> b;
INTERP_KERNEL::SplitIntoTetras(pol,(INTERP_KERNEL::NormalizedCellType)oldc[oldci[0]],oldc+oldci[0]+1,oldc+oldci[1],coords,a,b);
- std::size_t nbOfTet(a.size()/4); *retPt=ToIdType(nbOfTet);
+ std::size_t const nbOfTet(a.size()/4); *retPt=ToIdType(nbOfTet);
const mcIdType *aa(&a[0]);
if(!b.empty())
{
- for(std::vector<mcIdType>::iterator it=a.begin();it!=a.end();it++)
- if(*it<0)
- *it=(-(*(it))-1+nbNodes);
+ for(long & it : a)
+ if(it<0)
+ it=(-it-1+nbNodes);
addPts->insertAtTheEnd(b.begin(),b.end());
nbNodes+=ToIdType(b.size()/3);
}
return _cell;
}
else
- return 0;
+ return nullptr;
}
MEDCouplingUMeshCellByTypeEntry::MEDCouplingUMeshCellByTypeEntry(MEDCouplingUMesh *mesh):_mesh(mesh)
const mcIdType *ci=_mesh->getNodalConnectivityIndex()->begin();
if(_cell_id<_nb_cell)
{
- INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)c[ci[_cell_id]];
- mcIdType nbOfElems=ToIdType(std::distance(ci+_cell_id,std::find_if(ci+_cell_id,ci+_nb_cell,MEDCouplingImpl::ConnReader(c,type))));
- mcIdType startId=_cell_id;
+ auto const type=(INTERP_KERNEL::NormalizedCellType)c[ci[_cell_id]];
+ mcIdType const nbOfElems=ToIdType(std::distance(ci+_cell_id,std::find_if(ci+_cell_id,ci+_nb_cell,MEDCouplingImpl::ConnReader(c,type))));
+ mcIdType const startId=_cell_id;
_cell_id+=nbOfElems;
return new MEDCouplingUMeshCellEntry(_mesh,type,_cell,startId,_cell_id);
}
else
- return 0;
+ return nullptr;
}
-MEDCouplingUMeshCell::MEDCouplingUMeshCell(MEDCouplingUMesh *mesh):_conn(0),_conn_indx(0),_conn_lgth(NOTICABLE_FIRST_VAL)
+MEDCouplingUMeshCell::MEDCouplingUMeshCell(MEDCouplingUMesh *mesh):_conn(nullptr),_conn_indx(nullptr),_conn_lgth(NOTICABLE_FIRST_VAL)
{
if(mesh)
{
if(_conn_lgth!=NOTICABLE_FIRST_VAL)
return _conn;
else
- return 0;
+ return nullptr;
}
/// @cond INTERNAL
const mcIdType * revInd = revNodalIndx[ iM ]->begin();
const mcIdType * rev = revNodal [ iM ]->begin();
- mcIdType nbRevFaces0 = revInd[ n0 + 1 ] - revInd[ n0 ];
- mcIdType nbRevFaces1 = revInd[ n1 + 1 ] - revInd[ n1 ];
+ mcIdType const nbRevFaces0 = revInd[ n0 + 1 ] - revInd[ n0 ];
+ mcIdType const nbRevFaces1 = revInd[ n1 + 1 ] - revInd[ n1 ];
prevNbF = facesByEdge.size();
facesByEdge.resize( prevNbF + std::max( nbRevFaces0, nbRevFaces1 ));
{
if ( facesByEdge[ i0 ] == theUndefID )
continue;
- mcIdType objFaceID = MEDCouplingImpl::encodeID( facesByEdge[ i0 ], 0 );
+ mcIdType const objFaceID = MEDCouplingImpl::encodeID( facesByEdge[ i0 ], 0 );
bool isInputFace = ( objFaceID == inputFaceID );
for ( size_t i1 = prevNbF; i1 < facesByEdge.size(); ++i1 )
if ( facesByEdge[ i1 ] == theUndefID )
continue;
- mcIdType f0 = facesByEdge[ i0 ];
- mcIdType f1 = facesByEdge[ i1 ];
- size_t nbNodes0 = connI[0][ f0 + 1 ] - connI[0][ f0 ] - 1;
- size_t nbNodes1 = connI[1][ f1 + 1 ] - connI[1][ f1 ] - 1;
+ mcIdType const f0 = facesByEdge[ i0 ];
+ mcIdType const f1 = facesByEdge[ i1 ];
+ size_t const nbNodes0 = connI[0][ f0 + 1 ] - connI[0][ f0 ] - 1;
+ size_t const nbNodes1 = connI[1][ f1 + 1 ] - connI[1][ f1 ] - 1;
if ( nbNodes0 != nbNodes1 )
continue;
if ( std::equal( fConn0, fConn0 + nbNodes0, fConn1 ))
{
// equal faces; remove an object one
- mcIdType refFaceID = MEDCouplingImpl::encodeID( facesByEdge[ i1 ], 1 );
+ mcIdType const refFaceID = MEDCouplingImpl::encodeID( facesByEdge[ i1 ], 1 );
if ( refFaceID == inputFaceID )
isInputFace = true;
MEDCouplingUMesh* mesh[] )
{
int iMesh;
- mcIdType iF = decodeID( iFEnc, iMesh );
+ mcIdType const iF = decodeID( iFEnc, iMesh );
const mcIdType *conn = mesh[ iMesh ]->getNodalConnectivity()->getConstPointer();
const mcIdType *connI = mesh[ iMesh ]->getNodalConnectivityIndex()->getConstPointer();
auto it1 = std::find( conn + connI[ iF ] + 1,
conn + connI[ iF + 1 ],
n1 );
- long i0 = it0 - conn;
- long i1 = it1 - conn;
+ long const i0 = it0 - conn;
+ long const i1 = it1 - conn;
- bool isRev = ( std::abs( i1 - i0 ) == 1 ) ? i1 < i0 : i0 < i1;
+ bool const isRev = ( std::abs( i1 - i0 ) == 1 ) ? i1 < i0 : i0 < i1;
return isRev;
}
void reverseFace( mcIdType iFEnc, MEDCouplingUMesh* mesh[] )
{
int iMesh;
- mcIdType face = decodeID( iFEnc, iMesh );
+ mcIdType const face = decodeID( iFEnc, iMesh );
mcIdType *conn = mesh[ iMesh ]->getNodalConnectivity()->getPointer();
mcIdType *connI = mesh[ iMesh ]->getNodalConnectivityIndex()->getPointer();
break;
}
- mcIdType fID = faceQueue.back();
+ mcIdType const fID = faceQueue.back();
faceQueue.pop_back();
int iMesh, iMesh2;
- mcIdType refFace = MEDCouplingImpl::decodeID( fID, iMesh );
+ mcIdType const refFace = MEDCouplingImpl::decodeID( fID, iMesh );
nbFacesToCheck[iMesh]--;
mcIdType n0 = faceNodes[ nbEdges - 1 ]; // 1st node of edge
for ( int edge = 0; edge < nbEdges; ++edge )
{
- mcIdType n1 = faceNodes[ edge ]; // 2nd node of edge
+ mcIdType const n1 = faceNodes[ edge ]; // 2nd node of edge
// get faces sharing the edge
MEDCouplingImpl::getFacesOfEdge( n0, n1, fID, mesh, revNodal, revNodalIndx,
MEDCouplingImpl::reverseFace( facesByEdge[0], mesh );
}
- mcIdType face2 = MEDCouplingImpl::decodeID( facesByEdge[0], iMesh2 );
+ mcIdType const face2 = MEDCouplingImpl::decodeID( facesByEdge[0], iMesh2 );
if ( !isFaceQueued[iMesh2][face2] )
{
isFaceQueued[iMesh2][face2] = true;
// remove face and equalFaces from revNodal in order not to treat them again
equalFaces.push_back( fID );
- for ( mcIdType face : equalFaces )
+ for ( mcIdType const face : equalFaces )
{
- mcIdType f = MEDCouplingImpl::decodeID( face, iMesh2 );
+ mcIdType const f = MEDCouplingImpl::decodeID( face, iMesh2 );
const mcIdType *conn = mesh[iMesh2]->getNodalConnectivity()->getConstPointer();
const mcIdType *connI = mesh[iMesh2]->getNodalConnectivityIndex()->getConstPointer();
- mcIdType nbNodes = connI[ f + 1 ] - connI[ f ] - 1;
+ mcIdType const nbNodes = connI[ f + 1 ] - connI[ f ] - 1;
for ( const mcIdType* n = conn + connI[ f ] + 1, *nEnd = n + nbNodes; n < nEnd; ++n )
MEDCouplingImpl::removeFromRevNodal( *n, f, // not to treat f again
#pragma once
+#include "MCType.hxx"
+#include "MCAuto.hxx"
+#include "InterpKernelHashMap.hxx"
#include "MEDCoupling.hxx"
+#include "MEDCouplingMesh.hxx"
#include "MEDCouplingPointSet.hxx"
#include "MEDCouplingMemArray.hxx"
#include "CellModel.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "NormalizedGeometricTypes"
+#include <cstddef>
+#include <ostream>
+#include <map>
+#include <functional>
+#include <iterator>
#include <set>
+#include <string>
+#include <vector>
+#include <sstream>
+#include <utility>
namespace MEDCoupling
{
MEDCOUPLING_EXPORT static MEDCouplingUMesh *New(const std::string& meshName, int meshDim);
MEDCOUPLING_EXPORT std::string getClassName() const override { return std::string("MEDCouplingUMesh"); }
// Copy methods
- MEDCOUPLING_EXPORT MEDCouplingUMesh *deepCopy() const;
- MEDCOUPLING_EXPORT MEDCouplingUMesh *clone(bool recDeepCpy) const;
- MEDCOUPLING_EXPORT MEDCouplingUMesh *deepCopyConnectivityOnly() const;
+ MEDCOUPLING_EXPORT MEDCouplingUMesh *deepCopy() const override;
+ MEDCOUPLING_EXPORT MEDCouplingUMesh *clone(bool recDeepCpy) const override;
+ MEDCOUPLING_EXPORT MEDCouplingUMesh *deepCopyConnectivityOnly() const override;
- MEDCOUPLING_EXPORT void shallowCopyConnectivityFrom(const MEDCouplingPointSet *other);
- MEDCOUPLING_EXPORT void updateTime() const;
- MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- MEDCOUPLING_EXPORT MEDCouplingMeshType getType() const { return UNSTRUCTURED; }
- MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const;
- MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const;
- MEDCOUPLING_EXPORT void checkFastEquivalWith(const MEDCouplingMesh *other, double prec) const;
- MEDCOUPLING_EXPORT void checkConsistencyLight() const;
- MEDCOUPLING_EXPORT void checkConsistency(double eps=1e-12) const;
+ MEDCOUPLING_EXPORT void shallowCopyConnectivityFrom(const MEDCouplingPointSet *other) override;
+ MEDCOUPLING_EXPORT void updateTime() const override;
+ MEDCOUPLING_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDCOUPLING_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ MEDCOUPLING_EXPORT MEDCouplingMeshType getType() const override { return UNSTRUCTURED; }
+ MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const override;
+ MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const override;
+ MEDCOUPLING_EXPORT void checkFastEquivalWith(const MEDCouplingMesh *other, double prec) const override;
+ MEDCOUPLING_EXPORT void checkConsistencyLight() const override;
+ MEDCOUPLING_EXPORT void checkConsistency(double eps=1e-12) const override;
MEDCOUPLING_EXPORT void checkGeomConsistency(double eps=1e-12) const;
MEDCOUPLING_EXPORT void setMeshDimension(int meshDim);
MEDCOUPLING_EXPORT void allocateCells(mcIdType nbOfCells=0);
MEDCOUPLING_EXPORT void finishInsertingCells();
MEDCOUPLING_EXPORT MEDCouplingUMeshCellIterator *cellIterator();
MEDCOUPLING_EXPORT MEDCouplingUMeshCellByTypeEntry *cellsByType();
- MEDCOUPLING_EXPORT std::set<INTERP_KERNEL::NormalizedCellType> getAllGeoTypes() const;
+ MEDCOUPLING_EXPORT std::set<INTERP_KERNEL::NormalizedCellType> getAllGeoTypes() const override;
MEDCOUPLING_EXPORT std::vector<INTERP_KERNEL::NormalizedCellType> getAllGeoTypesSorted() const;
MEDCOUPLING_EXPORT std::set<INTERP_KERNEL::NormalizedCellType> getTypesOfPart(const mcIdType *begin, const mcIdType *end) const;
MEDCOUPLING_EXPORT void setConnectivity(DataArrayIdType *conn, DataArrayIdType *connIndex, bool isComputingTypes=true);
MEDCOUPLING_EXPORT const DataArrayIdType *getNodalConnectivityIndex() const { return _nodal_connec_index; }
MEDCOUPLING_EXPORT DataArrayIdType *getNodalConnectivity() { return _nodal_connec; }
MEDCOUPLING_EXPORT DataArrayIdType *getNodalConnectivityIndex() { return _nodal_connec_index; }
- MEDCOUPLING_EXPORT INTERP_KERNEL::NormalizedCellType getTypeOfCell(mcIdType cellId) const;
- MEDCOUPLING_EXPORT DataArrayIdType *giveCellsWithType(INTERP_KERNEL::NormalizedCellType type) const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType type) const;
- MEDCOUPLING_EXPORT void getNodeIdsOfCell(mcIdType cellId, std::vector<mcIdType>& conn) const;
- MEDCOUPLING_EXPORT std::string simpleRepr() const;
- MEDCOUPLING_EXPORT std::string advancedRepr() const;
+ MEDCOUPLING_EXPORT INTERP_KERNEL::NormalizedCellType getTypeOfCell(mcIdType cellId) const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *giveCellsWithType(INTERP_KERNEL::NormalizedCellType type) const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType type) const override;
+ MEDCOUPLING_EXPORT void getNodeIdsOfCell(mcIdType cellId, std::vector<mcIdType>& conn) const override;
+ MEDCOUPLING_EXPORT std::string simpleRepr() const override;
+ MEDCOUPLING_EXPORT std::string advancedRepr() const override;
MEDCOUPLING_EXPORT std::string cppRepr() const;
MEDCOUPLING_EXPORT std::string reprConnectivityOfThis() const;
MEDCOUPLING_EXPORT MEDCouplingUMesh *buildSetInstanceFromThis(std::size_t spaceDim) const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfNodesInCell(mcIdType cellId) const;
- MEDCOUPLING_EXPORT mcIdType getNumberOfCells() const;
- MEDCOUPLING_EXPORT int getMeshDimension() const;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfNodesInCell(mcIdType cellId) const override;
+ MEDCOUPLING_EXPORT mcIdType getNumberOfCells() const override;
+ MEDCOUPLING_EXPORT int getMeshDimension() const override;
MEDCOUPLING_EXPORT mcIdType getNodalConnectivityArrayLen() const;
MEDCOUPLING_EXPORT void computeTypes();
//! size of returned tinyInfo must be always the same.
- MEDCOUPLING_EXPORT void getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const;
- MEDCOUPLING_EXPORT bool isEmptyMesh(const std::vector<mcIdType>& tinyInfo) const;
- MEDCOUPLING_EXPORT void resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const;
- MEDCOUPLING_EXPORT void serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const;
- MEDCOUPLING_EXPORT void unserialization(const std::vector<double>& tinyInfoD, const std::vector<mcIdType>& tinyInfo, const DataArrayIdType *a1, DataArrayDouble *a2, const std::vector<std::string>& littleStrings);
- MEDCOUPLING_EXPORT std::string getVTKDataSetType() const;
- MEDCOUPLING_EXPORT std::string getVTKFileExtension() const;
- MEDCOUPLING_EXPORT void writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData, DataArrayByte *byteData) const;
- MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const;
+ MEDCOUPLING_EXPORT void getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const override;
+ MEDCOUPLING_EXPORT bool isEmptyMesh(const std::vector<mcIdType>& tinyInfo) const override;
+ MEDCOUPLING_EXPORT void resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const override;
+ MEDCOUPLING_EXPORT void serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const override;
+ MEDCOUPLING_EXPORT void unserialization(const std::vector<double>& tinyInfoD, const std::vector<mcIdType>& tinyInfo, const DataArrayIdType *a1, DataArrayDouble *a2, const std::vector<std::string>& littleStrings) override;
+ MEDCOUPLING_EXPORT std::string getVTKDataSetType() const override;
+ MEDCOUPLING_EXPORT std::string getVTKFileExtension() const override;
+ MEDCOUPLING_EXPORT void writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData, DataArrayByte *byteData) const override;
+ MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const override;
//tools
MEDCOUPLING_EXPORT static int AreCellsEqual(const mcIdType *conn, const mcIdType *connI, mcIdType cell1, mcIdType cell2, int compType);
MEDCOUPLING_EXPORT static int AreCellsEqualPolicy0(const mcIdType *conn, const mcIdType *connI, mcIdType cell1, mcIdType cell2);
MEDCOUPLING_EXPORT void colinearizeEdges(double eps);
MEDCOUPLING_EXPORT MEDCouplingUMesh *buildSpreadZonesWithPoly() const;
MEDCOUPLING_EXPORT std::vector<DataArrayIdType *> partitionBySpreadZone() const;
- MEDCOUPLING_EXPORT DataArrayIdType *computeFetchedNodeIds() const;
- MEDCOUPLING_EXPORT DataArrayIdType *getNodeIdsInUse(mcIdType& nbrOfNodesInUse) const;
- MEDCOUPLING_EXPORT void computeNodeIdsAlg(std::vector<bool>& nodeIdsInUse) const;
- MEDCOUPLING_EXPORT DataArrayIdType *computeNbOfNodesPerCell() const;
- MEDCOUPLING_EXPORT DataArrayIdType *computeNbOfFacesPerCell() const;
- MEDCOUPLING_EXPORT DataArrayIdType *computeEffectiveNbOfNodesPerCell() const;
- MEDCOUPLING_EXPORT DataArrayIdType *zipCoordsTraducer();
- MEDCOUPLING_EXPORT void findCommonCells(int compType, mcIdType startCellId, DataArrayIdType *& commonCellsArr, DataArrayIdType *& commonCellsIArr) const;
+ MEDCOUPLING_EXPORT DataArrayIdType *computeFetchedNodeIds() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *getNodeIdsInUse(mcIdType& nbrOfNodesInUse) const override;
+ MEDCOUPLING_EXPORT void computeNodeIdsAlg(std::vector<bool>& nodeIdsInUse) const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *computeNbOfNodesPerCell() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *computeNbOfFacesPerCell() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *computeEffectiveNbOfNodesPerCell() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *zipCoordsTraducer() override;
+ MEDCOUPLING_EXPORT void findCommonCells(int compType, mcIdType startCellId, DataArrayIdType *& commonCellsArr, DataArrayIdType *& commonCellsIArr) const override;
MEDCOUPLING_EXPORT bool areCellsIncludedIn(const MEDCouplingUMesh *other, int compType, DataArrayIdType *& arr) const;
MEDCOUPLING_EXPORT bool areCellsIncludedInPolicy7(const MEDCouplingUMesh *other, DataArrayIdType *& arr) const;
- MEDCOUPLING_EXPORT void getReverseNodalConnectivity(DataArrayIdType *revNodal, DataArrayIdType *revNodalIndx) const;
+ MEDCOUPLING_EXPORT void getReverseNodalConnectivity(DataArrayIdType *revNodal, DataArrayIdType *revNodalIndx) const override;
MEDCOUPLING_EXPORT MCAuto<MEDCouplingUMesh> explodeIntoEdges(MCAuto<DataArrayIdType>& desc, MCAuto<DataArrayIdType>& descIndex, MCAuto<DataArrayIdType>& revDesc, MCAuto<DataArrayIdType>& revDescIndx) const;
MEDCOUPLING_EXPORT MCAuto<MEDCouplingUMesh> explodeMeshTo(int targetDeltaLevel, MCAuto<DataArrayIdType>& desc, MCAuto<DataArrayIdType>& descIndx, MCAuto<DataArrayIdType>& revDesc, MCAuto<DataArrayIdType>& revDescIndx) const;
MEDCOUPLING_EXPORT MEDCouplingUMesh *explode3DMeshTo1D(DataArrayIdType *desc, DataArrayIdType *descIndx, DataArrayIdType *revDesc, DataArrayIdType *revDescIndx) const;
DataArrayIdType *&neighbors, DataArrayIdType *&neighborsIdx);
MEDCOUPLING_EXPORT void computeNeighborsOfNodes(DataArrayIdType *&neighbors, DataArrayIdType *&neighborsIdx) const;
MEDCOUPLING_EXPORT void computeEnlargedNeighborsOfNodes(MCAuto<DataArrayIdType> &neighbors, MCAuto<DataArrayIdType>& neighborsIdx) const;
- MEDCOUPLING_EXPORT MEDCouplingUMesh *mergeMyselfWithOnSameCoords(const MEDCouplingPointSet *other) const;
- MEDCOUPLING_EXPORT MEDCouplingUMesh *buildPartOfMySelf(const mcIdType *begin, const mcIdType *end, bool keepCoords=true) const;
- MEDCOUPLING_EXPORT MEDCouplingUMesh *buildPartOfMySelfSlice(mcIdType start, mcIdType end, mcIdType step, bool keepCoords=true) const;
+ MEDCOUPLING_EXPORT MEDCouplingUMesh *mergeMyselfWithOnSameCoords(const MEDCouplingPointSet *other) const override;
+ MEDCOUPLING_EXPORT MEDCouplingUMesh *buildPartOfMySelf(const mcIdType *begin, const mcIdType *end, bool keepCoords=true) const override;
+ MEDCOUPLING_EXPORT MEDCouplingUMesh *buildPartOfMySelfSlice(mcIdType start, mcIdType end, mcIdType step, bool keepCoords=true) const override;
MEDCOUPLING_EXPORT void setPartOfMySelf(const mcIdType *cellIdsBg, const mcIdType *cellIdsEnd, const MEDCouplingUMesh& otherOnSameCoordsThanThis);
MEDCOUPLING_EXPORT void setPartOfMySelfSlice(mcIdType start, mcIdType end, mcIdType step, const MEDCouplingUMesh& otherOnSameCoordsThanThis);
- MEDCOUPLING_EXPORT MEDCouplingUMesh *buildFacePartOfMySelfNode(const mcIdType *begin, const mcIdType *end, bool fullyIn) const;
- MEDCOUPLING_EXPORT MEDCouplingUMesh *buildUnstructured() const;
- MEDCOUPLING_EXPORT DataArrayIdType *findBoundaryNodes() const;
- MEDCOUPLING_EXPORT MEDCouplingUMesh *buildBoundaryMesh(bool keepCoords) const;
+ MEDCOUPLING_EXPORT MEDCouplingUMesh *buildFacePartOfMySelfNode(const mcIdType *begin, const mcIdType *end, bool fullyIn) const override;
+ MEDCOUPLING_EXPORT MEDCouplingUMesh *buildUnstructured() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *findBoundaryNodes() const override;
+ MEDCOUPLING_EXPORT MEDCouplingUMesh *buildBoundaryMesh(bool keepCoords) const override;
MEDCOUPLING_EXPORT DataArrayIdType *findCellIdsOnBoundary() const;
MEDCOUPLING_EXPORT void findCellIdsLyingOn(const MEDCouplingUMesh& otherDimM1OnSameCoords, DataArrayIdType *&cellIdsRk0, DataArrayIdType *&cellIdsRk1) const;
MEDCOUPLING_EXPORT MEDCouplingUMesh *computeSkin() const;
MEDCOUPLING_EXPORT void findCellsToRenumber(const MEDCouplingUMesh& otherDimM1OnSameCoords, const mcIdType *nodeIdsToDuplicateBg, const mcIdType *nodeIdsToDuplicateEnd,
DataArrayIdType *& cellIdsNeededToBeRenum, DataArrayIdType *& cellIdsNotModified) const;
MEDCOUPLING_EXPORT void duplicateNodes(const mcIdType *nodeIdsToDuplicateBg, const mcIdType *nodeIdsToDuplicateEnd);
- MEDCOUPLING_EXPORT void renumberNodesWithOffsetInConn(mcIdType offset);
- MEDCOUPLING_EXPORT void renumberNodesInConn(const INTERP_KERNEL::HashMap<mcIdType,mcIdType>& newNodeNumbersO2N);
- MEDCOUPLING_EXPORT void renumberNodesInConn(const mcIdType *newNodeNumbersO2N);
+ MEDCOUPLING_EXPORT void renumberNodesWithOffsetInConn(mcIdType offset) override;
+ MEDCOUPLING_EXPORT void renumberNodesInConn(const INTERP_KERNEL::HashMap<mcIdType,mcIdType>& newNodeNumbersO2N) override;
+ MEDCOUPLING_EXPORT void renumberNodesInConn(const mcIdType *newNodeNumbersO2N) override;
MEDCOUPLING_EXPORT void renumberNodesInConn(const std::map<mcIdType,mcIdType>& newNodeNumbersO2N) override;
MEDCOUPLING_EXPORT void shiftNodeNumbersInConn(mcIdType delta);
MEDCOUPLING_EXPORT void duplicateNodesInConn(const mcIdType *nodeIdsToDuplicateBg, const mcIdType *nodeIdsToDuplicateEnd, mcIdType offset);
- MEDCOUPLING_EXPORT void renumberCells(const mcIdType *old2NewBg, bool check=true);
- MEDCOUPLING_EXPORT DataArrayIdType *getCellsInBoundingBox(const double *bbox, double eps) const;
- MEDCOUPLING_EXPORT DataArrayIdType *getCellsInBoundingBox(const INTERP_KERNEL::DirectedBoundingBox& bbox, double eps);
- MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureField(bool isAbs) const;
+ MEDCOUPLING_EXPORT void renumberCells(const mcIdType *old2NewBg, bool check=true) override;
+ MEDCOUPLING_EXPORT DataArrayIdType *getCellsInBoundingBox(const double *bbox, double eps) const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *getCellsInBoundingBox(const INTERP_KERNEL::DirectedBoundingBox& bbox, double eps) override;
+ MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureField(bool isAbs) const override;
MEDCOUPLING_EXPORT DataArrayDouble *getPartMeasureField(bool isAbs, const mcIdType *begin, const mcIdType *end) const;
- MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureFieldOnNode(bool isAbs) const;
- MEDCOUPLING_EXPORT MEDCouplingFieldDouble *buildOrthogonalField() const;
+ MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getMeasureFieldOnNode(bool isAbs) const override;
+ MEDCOUPLING_EXPORT MEDCouplingFieldDouble *buildOrthogonalField() const override;
MEDCOUPLING_EXPORT MEDCouplingFieldDouble *buildPartOrthogonalField(const mcIdType *begin, const mcIdType *end) const;
MEDCOUPLING_EXPORT MEDCouplingFieldDouble *buildDirectionVectorField() const;
MEDCOUPLING_EXPORT MEDCouplingUMesh *buildSlice3D(const double *origin, const double *vec, double eps, DataArrayIdType *&cellIds) const;
MEDCOUPLING_EXPORT void project1D(const double *pt, const double *v, double eps, double *res) const;
MEDCOUPLING_EXPORT double distanceToPoint(const double *ptBg, const double *ptEnd, mcIdType& cellId) const;
MEDCOUPLING_EXPORT DataArrayDouble *distanceToPoints(const DataArrayDouble *pts, DataArrayIdType *& cellIds) const;
- MEDCOUPLING_EXPORT mcIdType getCellContainingPoint(const double *pos, double eps) const;
- MEDCOUPLING_EXPORT void getCellsContainingPoint(const double *pos, double eps, std::vector<mcIdType>& elts) const;
+ MEDCOUPLING_EXPORT mcIdType getCellContainingPoint(const double *pos, double eps) const override;
+ MEDCOUPLING_EXPORT void getCellsContainingPoint(const double *pos, double eps, std::vector<mcIdType>& elts) const override;
MEDCOUPLING_EXPORT void getCellsContainingPoints(const double *pos, mcIdType nbOfPoints, double eps, MCAuto<DataArrayIdType>& elts, MCAuto<DataArrayIdType>& eltsIndex) const override;
MEDCOUPLING_EXPORT void getCellsContainingPointsLinearPartOnlyOnNonDynType(const double *pos, mcIdType nbOfPoints, double eps, MCAuto<DataArrayIdType>& elts, MCAuto<DataArrayIdType>& eltsIndex) const override;
MEDCOUPLING_EXPORT void checkButterflyCells(std::vector<mcIdType>& cells, double eps=1e-12) const;
MEDCOUPLING_EXPORT DataArrayIdType *convexEnvelop2D();
MEDCOUPLING_EXPORT DataArrayIdType *findAndCorrectBadOriented3DExtrudedCells();
MEDCOUPLING_EXPORT DataArrayIdType *findAndCorrectBadOriented3DCells();
- MEDCOUPLING_EXPORT DataArrayDouble *getBoundingBoxForBBTree(double arcDetEps=1e-12) const;
+ MEDCOUPLING_EXPORT DataArrayDouble *getBoundingBoxForBBTree(double arcDetEps=1e-12) const override;
MEDCOUPLING_EXPORT DataArrayDouble *getBoundingBoxForBBTreeFast() const;
MEDCOUPLING_EXPORT DataArrayDouble *getBoundingBoxForBBTree2DQuadratic(double arcDetEps=1e-12) const;
MEDCOUPLING_EXPORT DataArrayDouble *getBoundingBoxForBBTree1DQuadratic(double arcDetEps=1e-12) const;
MEDCOUPLING_EXPORT DataArrayIdType *convertLinearCellsToQuadratic(int conversionType=0);
MEDCOUPLING_EXPORT void tessellate2D(double eps);
MEDCOUPLING_EXPORT MEDCoupling1SGTUMesh *tetrahedrize(int policy, DataArrayIdType *& n2oCells, mcIdType& nbOfAdditionalPoints) const;
- MEDCOUPLING_EXPORT DataArrayIdType *simplexize(int policy);
+ MEDCOUPLING_EXPORT DataArrayIdType *simplexize(int policy) override;
MEDCOUPLING_EXPORT bool areOnlySimplexCells() const;
MEDCOUPLING_EXPORT void convertDegeneratedCells();
MEDCOUPLING_EXPORT DataArrayIdType *convertDegeneratedCellsAndRemoveFlatOnes();
MEDCOUPLING_EXPORT void changeOrientationOfCells();
MEDCOUPLING_EXPORT void arePolyhedronsNotCorrectlyOriented(std::vector<mcIdType>& cells) const;
MEDCOUPLING_EXPORT void orientCorrectlyPolyhedrons();
- MEDCOUPLING_EXPORT void invertOrientationOfAllCells();
+ MEDCOUPLING_EXPORT void invertOrientationOfAllCells() override;
MEDCOUPLING_EXPORT void getFastAveragePlaneOfThis(double *vec, double *pos) const;
MEDCOUPLING_EXPORT void attractSeg3MidPtsAroundNodes(double ratio, const mcIdType *nodeIdsBg, const mcIdType *nodeIdsEnd);
//Mesh quality
MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getAspectRatioField() const;
MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getWarpField() const;
MEDCOUPLING_EXPORT MEDCouplingFieldDouble *getSkewField() const;
- MEDCOUPLING_EXPORT MEDCouplingFieldDouble *computeDiameterField() const;
+ MEDCOUPLING_EXPORT MEDCouplingFieldDouble *computeDiameterField() const override;
//utilities for MED File RW
- MEDCOUPLING_EXPORT std::vector<mcIdType> getDistributionOfTypes() const;
- MEDCOUPLING_EXPORT DataArrayIdType *checkTypeConsistencyAndContig(const std::vector<mcIdType>& code, const std::vector<const DataArrayIdType *>& idsPerType) const;
- MEDCOUPLING_EXPORT void splitProfilePerType(const DataArrayIdType *profile, std::vector<mcIdType>& code, std::vector<DataArrayIdType *>& idsInPflPerType, std::vector<DataArrayIdType *>& idsPerType, bool smartPflKiller=true) const;
+ MEDCOUPLING_EXPORT std::vector<mcIdType> getDistributionOfTypes() const override;
+ MEDCOUPLING_EXPORT DataArrayIdType *checkTypeConsistencyAndContig(const std::vector<mcIdType>& code, const std::vector<const DataArrayIdType *>& idsPerType) const override;
+ MEDCOUPLING_EXPORT void splitProfilePerType(const DataArrayIdType *profile, std::vector<mcIdType>& code, std::vector<DataArrayIdType *>& idsInPflPerType, std::vector<DataArrayIdType *>& idsPerType, bool smartPflKiller=true) const override;
MEDCOUPLING_EXPORT MEDCouplingUMesh *emulateMEDMEMBDC(const MEDCouplingUMesh *nM1LevMesh, DataArrayIdType *desc, DataArrayIdType *descIndx, DataArrayIdType *&revDesc, DataArrayIdType *&revDescIndx, DataArrayIdType *& nM1LevMeshIds, DataArrayIdType *&meshnM1Old2New) const;
MEDCOUPLING_EXPORT DataArrayIdType *sortCellsInMEDFileFrmt();
MEDCOUPLING_EXPORT bool checkConsecutiveCellTypes() const;
MEDCOUPLING_EXPORT MEDCouplingUMesh *keepSpecifiedCells(INTERP_KERNEL::NormalizedCellType type, const mcIdType *idsPerGeoTypeBg, const mcIdType *idsPerGeoTypeEnd) const;
MEDCOUPLING_EXPORT std::vector<bool> getQuadraticStatus() const;
//
- MEDCOUPLING_EXPORT MEDCouplingMesh *mergeMyselfWith(const MEDCouplingMesh *other) const;
- MEDCOUPLING_EXPORT DataArrayDouble *computeCellCenterOfMass() const;
+ MEDCOUPLING_EXPORT MEDCouplingMesh *mergeMyselfWith(const MEDCouplingMesh *other) const override;
+ MEDCOUPLING_EXPORT DataArrayDouble *computeCellCenterOfMass() const override;
MEDCOUPLING_EXPORT DataArrayDouble *computeCellCenterOfMassWithPrecision(double eps) const;
- MEDCOUPLING_EXPORT DataArrayDouble *computeIsoBarycenterOfNodesPerCell() const;
+ MEDCOUPLING_EXPORT DataArrayDouble *computeIsoBarycenterOfNodesPerCell() const override;
MEDCOUPLING_EXPORT DataArrayDouble *getPartBarycenterAndOwner(const mcIdType *begin, const mcIdType *end) const;
MEDCOUPLING_EXPORT DataArrayDouble *computePlaneEquationOf3DFaces() const;
MEDCOUPLING_EXPORT DataArrayIdType *conformize2D(double eps);
MEDCOUPLING_EXPORT DataArrayIdType *colinearize2D(double eps);
MEDCOUPLING_EXPORT DataArrayIdType *colinearizeKeepingConform2D(double eps);
MEDCOUPLING_EXPORT DataArrayIdType *conformize3D(double eps);
- MEDCOUPLING_EXPORT mcIdType split2DCells(const DataArrayIdType *desc, const DataArrayIdType *descI, const DataArrayIdType *subNodesInSeg, const DataArrayIdType *subNodesInSegI, const DataArrayIdType *midOpt=0, const DataArrayIdType *midOptI=0);
+ MEDCOUPLING_EXPORT mcIdType split2DCells(const DataArrayIdType *desc, const DataArrayIdType *descI, const DataArrayIdType *subNodesInSeg, const DataArrayIdType *subNodesInSegI, const DataArrayIdType *midOpt=nullptr, const DataArrayIdType *midOptI=nullptr);
MEDCOUPLING_EXPORT static MEDCouplingUMesh *Build0DMeshFromCoords(DataArrayDouble *da);
MEDCOUPLING_EXPORT static MCAuto<MEDCouplingUMesh> Build1DMeshFromCoords(DataArrayDouble *da);
MEDCOUPLING_EXPORT static MEDCouplingUMesh *MergeUMeshes(const MEDCouplingUMesh *mesh1, const MEDCouplingUMesh *mesh2);
MEDCouplingUMesh();
MEDCouplingUMesh(const MEDCouplingUMesh& other, bool deepCpy);
- ~MEDCouplingUMesh();
- void checkFullyDefined() const;
+ ~MEDCouplingUMesh() override;
+ void checkFullyDefined() const override;
void checkConnectivityFullyDefined() const;
void reprConnectivityOfThisLL(std::ostringstream& stream) const;
//tools
void tessellate2DInternal(double eps);
void tessellate2DCurveInternal(double eps);
void subDivide2DMesh(const mcIdType *nodeSubdived, const mcIdType *nodeIndxSubdived, const mcIdType *desc, const mcIdType *descIndex);
- void fillCellIdsToKeepFromNodeIds(const mcIdType *begin, const mcIdType *end, bool fullyIn, DataArrayIdType *&cellIdsKeptArr) const;
+ void fillCellIdsToKeepFromNodeIds(const mcIdType *begin, const mcIdType *end, bool fullyIn, DataArrayIdType *&cellIdsKeptArr) const override;
void split3DCurveWithPlane(const double *origin, const double *vec, double eps, std::vector<mcIdType>& cut3DCurve);
MEDCouplingUMesh *buildExtrudedMeshFromThisLowLev(mcIdType nbOfNodesOf1Lev, bool isQuad) const;
DataArrayDouble *fillExtCoordsUsingTranslation(const MEDCouplingUMesh *mesh1D, bool isQuad) const;
DataArrayDouble *fillExtCoordsUsingTranslAndAutoRotation2D(const MEDCouplingUMesh *mesh1D, bool isQuad) const;
DataArrayDouble *fillExtCoordsUsingTranslAndAutoRotation3D(const MEDCouplingUMesh *mesh1D, bool isQuad) const;
static bool AreCellsEqualInPool(const std::vector<mcIdType>& candidates, int compType, const mcIdType *conn, const mcIdType *connI, DataArrayIdType *result) ;
- MEDCouplingUMesh *buildPartOfMySelfKeepCoords(const mcIdType *begin, const mcIdType *end) const;
- MEDCouplingUMesh *buildPartOfMySelfKeepCoordsSlice(mcIdType start, mcIdType end, mcIdType step) const;
+ MEDCouplingUMesh *buildPartOfMySelfKeepCoords(const mcIdType *begin, const mcIdType *end) const override;
+ MEDCouplingUMesh *buildPartOfMySelfKeepCoordsSlice(mcIdType start, mcIdType end, mcIdType step) const override;
DataArrayIdType *convertLinearCellsToQuadratic1D0(DataArrayIdType *&conn, DataArrayIdType *&connI, DataArrayDouble *& coords, std::set<INTERP_KERNEL::NormalizedCellType>& types) const;
DataArrayIdType *convertLinearCellsToQuadratic2DAnd3D0(const MEDCouplingUMesh *m1D, const DataArrayIdType *desc, const DataArrayIdType *descI, DataArrayIdType *&conn, DataArrayIdType *&connI, DataArrayDouble *& coords, std::set<INTERP_KERNEL::NormalizedCellType>& types) const;
DataArrayIdType *convertLinearCellsToQuadratic2D0(DataArrayIdType *&conn, DataArrayIdType *&connI, DataArrayDouble *& coords, std::set<INTERP_KERNEL::NormalizedCellType>& types) const;
/// @cond INTERNAL
static void DeleteCellTypeInIndexedArray(const DataArrayIdType *arrIn, const DataArrayIdType *arrIndxIn, MCAuto<DataArrayIdType>& arrOut, MCAuto<DataArrayIdType>& arrIndxOut);
static MEDCouplingUMesh *MergeUMeshesLL(const std::vector<const MEDCouplingUMesh *>& a);
- typedef mcIdType (*DimM1DescNbrer)(mcIdType id, mcIdType nb, const INTERP_KERNEL::CellModel& cm, bool compute, const mcIdType *conn1, const mcIdType *conn2);
+ using DimM1DescNbrer = mcIdType (*)(mcIdType, mcIdType, const INTERP_KERNEL::CellModel &, bool, const mcIdType *, const mcIdType *);
template<class SonsGenerator>
MEDCouplingUMesh *buildDescendingConnectivityGen(DataArrayIdType *desc, DataArrayIdType *descIndx, DataArrayIdType *revDesc, DataArrayIdType *revDescIndx, DimM1DescNbrer nbrer) const;
static void DistanceToPoint3DSurfAlg(const double *pt, const mcIdType *cellIdsBg, const mcIdType *cellIdsEnd, const double *coords, const mcIdType *nc, const mcIdType *ncI, double& ret0, mcIdType& cellId);
// Author : Anthony Geay (EDF R&D)
#pragma once
+#include "MCType.hxx"
+#include "MCIdType.hxx"
#include "MEDCouplingUMesh.hxx"
#include <sstream>
checkConnectivityFullyDefined();
mcIdType *conn(getNodalConnectivity()->getPointer());
const mcIdType *connIndex(getNodalConnectivityIndex()->getConstPointer());
- mcIdType nbOfCells=ToIdType(getNumberOfCells());
+ mcIdType const nbOfCells=ToIdType(getNumberOfCells());
for(mcIdType i=0;i<nbOfCells;i++)
for(mcIdType iconn=connIndex[i]+1;iconn!=connIndex[i+1];iconn++)
{
//
// Author : Anthony Geay (CEA/DEN)
+#include "MCType.hxx"
+#include "MCAuto.hxx"
+#include "MCIdType.hxx"
+#include "InterpKernelGeo2DPrecision.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "InterpKernelException.hxx"
+#include "MEDCouplingPointSet.hxx"
#include "MEDCouplingUMesh.hxx"
-#include "MEDCouplingCMesh.hxx"
-#include "MEDCoupling1GTUMesh.hxx"
-#include "MEDCouplingFieldDouble.hxx"
-#include "MEDCouplingSkyLineArray.hxx"
#include "CellModel.hxx"
-#include "VolSurfUser.txx"
-#include "InterpolationUtils.hxx"
-#include "PointLocatorAlgos.txx"
-#include "BBTree.txx"
-#include "BBTreeDst.txx"
-#include "SplitterTetra.hxx"
-#include "DiameterCalculator.hxx"
-#include "DirectedBoundingBox.hxx"
-#include "InterpKernelMatrixTools.hxx"
-#include "InterpKernelMeshQuality.hxx"
-#include "InterpKernelCellSimplify.hxx"
+#include "NormalizedGeometricTypes"
+#include "VolSurfUser.hxx"
+#include "SplitterTetra.txx"
#include "InterpKernelGeo2DEdgeArcCircle.hxx"
#include "InterpKernelAutoPtr.hxx"
#include "InterpKernelGeo2DNode.hxx"
-#include "InterpKernelGeo2DEdgeLin.hxx"
#include "InterpKernelGeo2DEdgeArcCircle.hxx"
-#include "InterpKernelGeo2DQuadraticPolygon.hxx"
#include "MEDCouplingUMesh_internal.hxx"
+#include <algorithm>
+#include <iterator>
+#include <cmath>
+#include <map>
+#include <set>
+#include <cstdlib>
+#include <functional>
#include <sstream>
-#include <fstream>
-#include <numeric>
#include <cstring>
#include <limits>
-#include <list>
+#include <utility>
+#include <vector>
using namespace MEDCoupling;
void MEDCouplingUMesh::reprConnectivityOfThisLL(std::ostringstream& stream) const
{
- if(_nodal_connec!=0 && _nodal_connec_index!=0)
+ if(_nodal_connec!=nullptr && _nodal_connec_index!=nullptr)
{
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
const mcIdType *c=_nodal_connec->getConstPointer();
const mcIdType *ci=_nodal_connec_index->getConstPointer();
for(mcIdType i=0;i<nbOfCells;i++)
checkConnectivityFullyDefined();
if(getMeshDimension()!=2)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::simplexizePol0 : this policy is only available for mesh with meshdim == 2 !");
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
- mcIdType nbOfCutCells=getNumberOfCellsWithType(INTERP_KERNEL::NORM_QUAD4);
+ mcIdType const nbOfCutCells=getNumberOfCellsWithType(INTERP_KERNEL::NORM_QUAD4);
ret->alloc(nbOfCells+nbOfCutCells,1);
if(nbOfCutCells==0) { ret->iota(0); return ret.retn(); }
mcIdType *retPt=ret->getPointer();
checkConnectivityFullyDefined();
if(getMeshDimension()!=2)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::simplexizePol0 : this policy is only available for mesh with meshdim == 2 !");
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
- mcIdType nbOfCutCells=getNumberOfCellsWithType(INTERP_KERNEL::NORM_QUAD4);
+ mcIdType const nbOfCutCells=getNumberOfCellsWithType(INTERP_KERNEL::NORM_QUAD4);
ret->alloc(nbOfCells+nbOfCutCells,1);
if(nbOfCutCells==0) { ret->iota(0); return ret.retn(); }
mcIdType *retPt=ret->getPointer();
checkConnectivityFullyDefined();
if(getMeshDimension()!=3)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::simplexizePlanarFace5 : this policy is only available for mesh with meshdim == 3 !");
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
- mcIdType nbOfCutCells=getNumberOfCellsWithType(INTERP_KERNEL::NORM_HEXA8);
+ mcIdType const nbOfCutCells=getNumberOfCellsWithType(INTERP_KERNEL::NORM_HEXA8);
ret->alloc(nbOfCells+4*nbOfCutCells,1);
if(nbOfCutCells==0) { ret->iota(0); return ret.retn(); }
mcIdType *retPt=ret->getPointer();
checkConnectivityFullyDefined();
if(getMeshDimension()!=3)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::simplexizePlanarFace6 : this policy is only available for mesh with meshdim == 3 !");
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
- mcIdType nbOfCutCells=getNumberOfCellsWithType(INTERP_KERNEL::NORM_HEXA8);
+ mcIdType const nbOfCutCells=getNumberOfCellsWithType(INTERP_KERNEL::NORM_HEXA8);
ret->alloc(nbOfCells+5*nbOfCutCells,1);
if(nbOfCutCells==0) { ret->iota(0); return ret.retn(); }
mcIdType *retPt=ret->getPointer();
checkFullyDefined();
if(getMeshDimension()!=2 || getSpaceDimension()!=2)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::tessellate2DInternal works on umeshes with meshdim equal to 2 and spaceDim equal to 2 too!");
- double epsa=fabs(eps);
+ double const epsa=fabs(eps);
if(epsa<std::numeric_limits<double>::min())
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::tessellate2DInternal : epsilon is null ! Please specify a higher epsilon. If too tiny it can lead to a huge amount of nodes and memory !");
MCAuto<DataArrayIdType> desc1(DataArrayIdType::New()),descIndx1(DataArrayIdType::New()),revDesc1(DataArrayIdType::New()),revDescIndx1(DataArrayIdType::New());
MCAuto<MEDCouplingUMesh> mDesc(buildDescendingConnectivity2(desc1,descIndx1,revDesc1,revDescIndx1));
- revDesc1=0; revDescIndx1=0;
+ revDesc1=nullptr; revDescIndx1=nullptr;
mDesc->tessellate2D(eps);
subDivide2DMesh(mDesc->_nodal_connec->begin(),mDesc->_nodal_connec_index->begin(),desc1->begin(),descIndx1->begin());
setCoords(mDesc->getCoords());
checkFullyDefined();
if(getMeshDimension()!=1 || getSpaceDimension()!=2)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::tessellate2DCurveInternal works on umeshes with meshdim equal to 1 and spaceDim equal to 2 too!");
- double epsa=fabs(eps);
+ double const epsa=fabs(eps);
if(epsa<std::numeric_limits<double>::min())
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::tessellate2DCurveInternal : epsilon is null ! Please specify a higher epsilon. If too tiny it can lead to a huge amount of nodes and memory !");
- INTERP_KERNEL::QuadraticPlanarPrecision arcPrec(1.e-10); // RAII
- mcIdType nbCells=getNumberOfCells();
- mcIdType nbNodes=getNumberOfNodes();
+ INTERP_KERNEL::QuadraticPlanarPrecision const arcPrec(1.e-10); // RAII
+ mcIdType const nbCells=getNumberOfCells();
+ mcIdType const nbNodes=getNumberOfNodes();
const mcIdType *conn=_nodal_connec->begin();
const mcIdType *connI=_nodal_connec_index->begin();
const double *coords=_coords->begin();
checkFullyDefined();
if(getMeshDimension()!=2)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::subDivide2DMesh : works only on umesh with meshdim==2 !");
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
mcIdType *connI=_nodal_connec_index->getPointer();
mcIdType newConnLgth=0;
for(mcIdType i=0;i<nbOfCells;i++,connI++)
{
- mcIdType offset=descIndex[i];
- mcIdType nbOfEdges=descIndex[i+1]-offset;
+ mcIdType const offset=descIndex[i];
+ mcIdType const nbOfEdges=descIndex[i+1]-offset;
//
- bool ddirect=desc[offset+nbOfEdges-1]>0;
- mcIdType eedgeId=std::abs(desc[offset+nbOfEdges-1])-1;
+ bool const ddirect=desc[offset+nbOfEdges-1]>0;
+ mcIdType const eedgeId=std::abs(desc[offset+nbOfEdges-1])-1;
mcIdType ref=ddirect?nodeSubdived[nodeIndxSubdived[eedgeId+1]-1]:nodeSubdived[nodeIndxSubdived[eedgeId]+1];
for(mcIdType j=0;j<nbOfEdges;j++)
{
- bool direct=desc[offset+j]>0;
- mcIdType edgeId=std::abs(desc[offset+j])-1;
+ bool const direct=desc[offset+j]>0;
+ mcIdType const edgeId=std::abs(desc[offset+j])-1;
if(!INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)nodeSubdived[nodeIndxSubdived[edgeId]]).isQuadratic())
{
- mcIdType id1=nodeSubdived[nodeIndxSubdived[edgeId]+1];
- mcIdType id2=nodeSubdived[nodeIndxSubdived[edgeId+1]-1];
- mcIdType ref2=direct?id1:id2;
+ mcIdType const id1=nodeSubdived[nodeIndxSubdived[edgeId]+1];
+ mcIdType const id2=nodeSubdived[nodeIndxSubdived[edgeId+1]-1];
+ mcIdType const ref2=direct?id1:id2;
if(ref==ref2)
{
- mcIdType nbOfSubNodes=nodeIndxSubdived[edgeId+1]-nodeIndxSubdived[edgeId]-1;
+ mcIdType const nbOfSubNodes=nodeIndxSubdived[edgeId+1]-nodeIndxSubdived[edgeId]-1;
newConnLgth+=nbOfSubNodes-1;
ref=direct?id2:id1;
}
for(mcIdType i=0;i<nbOfCells;i++)
{
*work++=INTERP_KERNEL::NORM_POLYGON;
- mcIdType offset=descIndex[i];
- mcIdType nbOfEdges=descIndex[i+1]-offset;
+ mcIdType const offset=descIndex[i];
+ mcIdType const nbOfEdges=descIndex[i+1]-offset;
for(mcIdType j=0;j<nbOfEdges;j++)
{
- bool direct=desc[offset+j]>0;
- mcIdType edgeId=std::abs(desc[offset+j])-1;
+ bool const direct=desc[offset+j]>0;
+ mcIdType const edgeId=std::abs(desc[offset+j])-1;
if(direct)
work=std::copy(nodeSubdived+nodeIndxSubdived[edgeId]+1,nodeSubdived+nodeIndxSubdived[edgeId+1]-1,work);
else
{
- mcIdType nbOfSubNodes=nodeIndxSubdived[edgeId+1]-nodeIndxSubdived[edgeId]-1;
- std::reverse_iterator<const mcIdType *> it(nodeSubdived+nodeIndxSubdived[edgeId+1]);
+ mcIdType const nbOfSubNodes=nodeIndxSubdived[edgeId+1]-nodeIndxSubdived[edgeId]-1;
+ std::reverse_iterator<const mcIdType *> const it(nodeSubdived+nodeIndxSubdived[edgeId+1]);
work=std::copy(it,it+nbOfSubNodes-1,work);
}
}
for(const mcIdType *work=begin;work!=end;work++)
if(*work>=0 && *work<sz)
fastFinder[*work]=true;
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
const mcIdType *conn=getNodalConnectivity()->getConstPointer();
const mcIdType *connIndex=getNodalConnectivityIndex()->getConstPointer();
for(mcIdType i=0;i<nbOfCells;i++)
checkFullyDefined();
if(getMeshDimension()!=1 || getSpaceDimension()!=3)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::split3DCurveWithPlane works on umeshes with meshdim equal to 1 and spaceDim equal to 3 !");
- mcIdType ncells=getNumberOfCells();
- mcIdType nnodes=getNumberOfNodes();
+ mcIdType const ncells=getNumberOfCells();
+ mcIdType const nnodes=getNumberOfNodes();
double vec2[3],vec3[3],vec4[3];
- double normm=sqrt(vec[0]*vec[0]+vec[1]*vec[1]+vec[2]*vec[2]);
+ double const normm=sqrt(vec[0]*vec[0]+vec[1]*vec[1]+vec[2]*vec[2]);
if(normm<1e-6)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::split3DCurveWithPlane : parameter 'vec' should have a norm2 greater than 1e-6 !");
vec2[0]=vec[0]/normm; vec2[1]=vec[1]/normm; vec2[2]=vec[2]/normm;
{
mcIdType st=conn[connI[i]+1],endd=conn[connI[i]+2];
vec3[0]=coo[3*endd]-coo[3*st]; vec3[1]=coo[3*endd+1]-coo[3*st+1]; vec3[2]=coo[3*endd+2]-coo[3*st+2];
- double normm2=sqrt(vec3[0]*vec3[0]+vec3[1]*vec3[1]+vec3[2]*vec3[2]);
- double colin=std::abs((vec3[0]*vec2[0]+vec3[1]*vec2[1]+vec3[2]*vec2[2])/normm2);
+ double const normm2=sqrt(vec3[0]*vec3[0]+vec3[1]*vec3[1]+vec3[2]*vec3[2]);
+ double const colin=std::abs((vec3[0]*vec2[0]+vec3[1]*vec2[1]+vec3[2]*vec2[2])/normm2);
if(colin>eps)//if colin<=eps -> current SEG2 is colinear to the input plane
{
const double *st2=coo+3*st;
vec4[0]=st2[0]-origin[0]; vec4[1]=st2[1]-origin[1]; vec4[2]=st2[2]-origin[2];
- double pos=-(vec4[0]*vec2[0]+vec4[1]*vec2[1]+vec4[2]*vec2[2])/((vec3[0]*vec2[0]+vec3[1]*vec2[1]+vec3[2]*vec2[2]));
+ double const pos=-(vec4[0]*vec2[0]+vec4[1]*vec2[1]+vec4[2]*vec2[2])/((vec3[0]*vec2[0]+vec3[1]*vec2[1]+vec3[2]*vec2[2]));
if(pos>eps && pos<1-eps)
{
- mcIdType nNode=ToIdType(addCoo.size())/3;
+ mcIdType const nNode=ToIdType(addCoo.size())/3;
vec4[0]=st2[0]+pos*vec3[0]; vec4[1]=st2[1]+pos*vec3[1]; vec4[2]=st2[2]+pos*vec3[2];
addCoo.insert(addCoo.end(),vec4,vec4+3);
cut3DCurve[i]=nnodes+nNode;
}
if(!addCoo.empty())
{
- mcIdType newNbOfNodes=nnodes+ToIdType(addCoo.size())/3;
+ mcIdType const newNbOfNodes=nnodes+ToIdType(addCoo.size())/3;
MCAuto<DataArrayDouble> coo2=DataArrayDouble::New();
coo2->alloc(newNbOfNodes,3);
double *tmp=coo2->getPointer();
*/
DataArrayDouble *MEDCouplingUMesh::fillExtCoordsUsingTranslation(const MEDCouplingUMesh *mesh1D, bool isQuad) const
{
- mcIdType oldNbOfNodes=getNumberOfNodes();
- mcIdType nbOf1DCells=ToIdType(mesh1D->getNumberOfCells());
- std::size_t spaceDim=getSpaceDimension();
+ mcIdType const oldNbOfNodes=getNumberOfNodes();
+ mcIdType const nbOf1DCells=ToIdType(mesh1D->getNumberOfCells());
+ std::size_t const spaceDim=getSpaceDimension();
DataArrayDouble *ret=DataArrayDouble::New();
- std::vector<bool> isQuads;
- mcIdType nbOfLevsInVec=isQuad?2*nbOf1DCells+1:nbOf1DCells+1;
+ std::vector<bool> const isQuads;
+ mcIdType const nbOfLevsInVec=isQuad?2*nbOf1DCells+1:nbOf1DCells+1;
ret->alloc(oldNbOfNodes*nbOfLevsInVec,spaceDim);
double *retPtr=ret->getPointer();
const double *coords=getCoords()->getConstPointer();
{
if(isQuad)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::fillExtCoordsUsingTranslAndAutoRotation2D : not implemented for quadratic cells !");
- mcIdType oldNbOfNodes=getNumberOfNodes();
- mcIdType nbOf1DCells=ToIdType(mesh1D->getNumberOfCells());
+ mcIdType const oldNbOfNodes=getNumberOfNodes();
+ mcIdType const nbOf1DCells=ToIdType(mesh1D->getNumberOfCells());
if(nbOf1DCells<2)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::fillExtCoordsUsingTranslAndAutoRotation2D : impossible to detect any angle of rotation ! Change extrusion policy 1->0 !");
MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- mcIdType nbOfLevsInVec=nbOf1DCells+1;
+ mcIdType const nbOfLevsInVec=nbOf1DCells+1;
ret->alloc(oldNbOfNodes*nbOfLevsInVec,2);
double *retPtr=ret->getPointer();
retPtr=std::copy(getCoords()->getConstPointer(),getCoords()->getConstPointer()+getCoords()->getNbOfElems(),retPtr);
const double *p1=i+1<nbOfLevsInVec?end:begin;
const double *p2=i+1<nbOfLevsInVec?third:end;
INTERP_KERNEL::EdgeArcCircle::GetArcOfCirclePassingThru(p0,p1,p2,tmp3,radius,alpha,alpha0);
- double cosangle=i+1<nbOfLevsInVec?(p0[0]-tmp3[0])*(p1[0]-tmp3[0])+(p0[1]-tmp3[1])*(p1[1]-tmp3[1]):(p2[0]-tmp3[0])*(p1[0]-tmp3[0])+(p2[1]-tmp3[1])*(p1[1]-tmp3[1]);
- double angle=acos(cosangle/(radius*radius));
- tmp->rotate(end,0,angle);
+ double const cosangle=i+1<nbOfLevsInVec?(p0[0]-tmp3[0])*(p1[0]-tmp3[0])+(p0[1]-tmp3[1])*(p1[1]-tmp3[1]):(p2[0]-tmp3[0])*(p1[0]-tmp3[0])+(p2[1]-tmp3[1])*(p1[1]-tmp3[1]);
+ double const angle=acos(cosangle/(radius*radius));
+ tmp->rotate(end,nullptr,angle);
retPtr=std::copy(tmp2->getConstPointer(),tmp2->getConstPointer()+tmp2->getNbOfElems(),retPtr);
}
return ret.retn();
{
if(isQuad)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::fillExtCoordsUsingTranslAndAutoRotation3D : not implemented for quadratic cells !");
- mcIdType oldNbOfNodes=getNumberOfNodes();
- mcIdType nbOf1DCells=ToIdType(mesh1D->getNumberOfCells());
+ mcIdType const oldNbOfNodes=getNumberOfNodes();
+ mcIdType const nbOf1DCells=ToIdType(mesh1D->getNumberOfCells());
if(nbOf1DCells<2)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::fillExtCoordsUsingTranslAndAutoRotation3D : impossible to detect any angle of rotation ! Change extrusion policy 1->0 !");
MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
- mcIdType nbOfLevsInVec=nbOf1DCells+1;
+ mcIdType const nbOfLevsInVec=nbOf1DCells+1;
ret->alloc(oldNbOfNodes*nbOfLevsInVec,3);
double *retPtr=ret->getPointer();
retPtr=std::copy(getCoords()->getConstPointer(),getCoords()->getConstPointer()+getCoords()->getNbOfElems(),retPtr);
(p1[2]-p0[2])*(p2[0]-p1[0])-(p1[0]-p0[0])*(p2[2]-p1[2]),
(p1[0]-p0[0])*(p2[1]-p1[1])-(p1[1]-p0[1])*(p2[0]-p1[0]),
};
- double norm=sqrt(vecPlane[0]*vecPlane[0]+vecPlane[1]*vecPlane[1]+vecPlane[2]*vecPlane[2]);
+ double const norm=sqrt(vecPlane[0]*vecPlane[0]+vecPlane[1]*vecPlane[1]+vecPlane[2]*vecPlane[2]);
if(norm>1.e-7)
{
vecPlane[0]/=norm; vecPlane[1]/=norm; vecPlane[2]/=norm;
- double norm2=sqrt(vecPlane[0]*vecPlane[0]+vecPlane[1]*vecPlane[1]);
- double vec2[2]={vecPlane[1]/norm2,-vecPlane[0]/norm2};
- double s2=norm2;
+ double const norm2=sqrt(vecPlane[0]*vecPlane[0]+vecPlane[1]*vecPlane[1]);
+ double const vec2[2]={vecPlane[1]/norm2,-vecPlane[0]/norm2};
+ double const s2=norm2;
double c2=cos(asin(s2));
- double m[3][3]={
+ double const m[3][3]={
{vec2[0]*vec2[0]*(1-c2)+c2, vec2[0]*vec2[1]*(1-c2), vec2[1]*s2},
{vec2[0]*vec2[1]*(1-c2), vec2[1]*vec2[1]*(1-c2)+c2, -vec2[0]*s2},
{-vec2[1]*s2, vec2[0]*s2, c2}
double p1r[3]={m[0][0]*p1[0]+m[0][1]*p1[1]+m[0][2]*p1[2], m[1][0]*p1[0]+m[1][1]*p1[1]+m[1][2]*p1[2], m[2][0]*p1[0]+m[2][1]*p1[1]+m[2][2]*p1[2]};
double p2r[3]={m[0][0]*p2[0]+m[0][1]*p2[1]+m[0][2]*p2[2], m[1][0]*p2[0]+m[1][1]*p2[1]+m[1][2]*p2[2], m[2][0]*p2[0]+m[2][1]*p2[1]+m[2][2]*p2[2]};
INTERP_KERNEL::EdgeArcCircle::GetArcOfCirclePassingThru(p0r,p1r,p2r,tmp3,radius,alpha,alpha0);
- double cosangle=i+1<nbOfLevsInVec?(p0r[0]-tmp3[0])*(p1r[0]-tmp3[0])+(p0r[1]-tmp3[1])*(p1r[1]-tmp3[1]):(p2r[0]-tmp3[0])*(p1r[0]-tmp3[0])+(p2r[1]-tmp3[1])*(p1r[1]-tmp3[1]);
- double angle=acos(cosangle/(radius*radius));
+ double const cosangle=i+1<nbOfLevsInVec?(p0r[0]-tmp3[0])*(p1r[0]-tmp3[0])+(p0r[1]-tmp3[1])*(p1r[1]-tmp3[1]):(p2r[0]-tmp3[0])*(p1r[0]-tmp3[0])+(p2r[1]-tmp3[1])*(p1r[1]-tmp3[1]);
+ double const angle=acos(cosangle/(radius*radius));
tmp->rotate(end,vecPlane,angle);
}
retPtr=std::copy(tmp2->getConstPointer(),tmp2->getConstPointer()+tmp2->getNbOfElems(),retPtr);
*/
MEDCouplingUMesh *MEDCouplingUMesh::buildExtrudedMeshFromThisLowLev(mcIdType nbOfNodesOf1Lev, bool isQuad) const
{
- mcIdType nbOf1DCells(getNumberOfNodes()/nbOfNodesOf1Lev-1);
- mcIdType nbOf2DCells=getNumberOfCells();
- mcIdType nbOf3DCells(nbOf2DCells*nbOf1DCells);
+ mcIdType const nbOf1DCells(getNumberOfNodes()/nbOfNodesOf1Lev-1);
+ mcIdType const nbOf2DCells=getNumberOfCells();
+ mcIdType const nbOf3DCells(nbOf2DCells*nbOf1DCells);
MEDCouplingUMesh *ret(MEDCouplingUMesh::New("Extruded",getMeshDimension()+1));
const mcIdType *conn(_nodal_connec->begin()),*connI(_nodal_connec_index->begin());
MCAuto<DataArrayIdType> newConn(DataArrayIdType::New()),newConnI(DataArrayIdType::New());
}
newConn->alloc(newc.size()*nbOf1DCells,1);
mcIdType *newConnPtr(newConn->getPointer());
- mcIdType deltaPerLev(isQuad?2*nbOfNodesOf1Lev:nbOfNodesOf1Lev);
+ mcIdType const deltaPerLev(isQuad?2*nbOfNodesOf1Lev:nbOfNodesOf1Lev);
newConnIPtr=newConnI->getPointer();
for(mcIdType iz=0;iz<nbOf1DCells;iz++)
{
const mcIdType *posOfTypeOfCell(newConnIPtr);
for(std::vector<mcIdType>::const_iterator iter=newc.begin();iter!=newc.end();iter++,newConnPtr++)
{
- mcIdType icell(ToIdType(iter-newc.begin()));//std::distance unfortunately cannot been called here in C++98
+ mcIdType const icell(ToIdType(iter-newc.begin()));//std::distance unfortunately cannot been called here in C++98
if(icell!=*posOfTypeOfCell)
{
if(*iter!=-1)
if(candidates.size()<1)
return false;
bool ret=false;
- std::vector<mcIdType>::const_iterator iter=candidates.begin();
- mcIdType start=(*iter++);
+ auto iter=candidates.begin();
+ mcIdType const start=(*iter++);
for(;iter!=candidates.end();iter++)
{
- int status=AreCellsEqual(conn,connI,start,*iter,compType);
+ int const status=AreCellsEqual(conn,connI,start,*iter,compType);
if(status!=0)
{
if(!ret)
MEDCouplingUMesh *MEDCouplingUMesh::buildPartOfMySelfKeepCoords(const mcIdType *begin, const mcIdType *end) const
{
checkConnectivityFullyDefined();
- mcIdType ncell=getNumberOfCells();
+ mcIdType const ncell=getNumberOfCells();
MCAuto<MEDCouplingUMesh> ret=MEDCouplingUMesh::New();
ret->_mesh_dim=_mesh_dim;
ret->setCoords(_coords);
- std::size_t nbOfElemsRet=std::distance(begin,end);
- mcIdType *connIndexRet=(mcIdType *)malloc((nbOfElemsRet+1)*sizeof(mcIdType));
+ std::size_t const nbOfElemsRet=std::distance(begin,end);
+ auto *connIndexRet=(mcIdType *)malloc((nbOfElemsRet+1)*sizeof(mcIdType));
connIndexRet[0]=0;
const mcIdType *conn=_nodal_connec->getConstPointer();
const mcIdType *connIndex=_nodal_connec_index->getConstPointer();
throw INTERP_KERNEL::Exception(oss.str());
}
}
- mcIdType *connRet=(mcIdType *)malloc(connIndexRet[nbOfElemsRet]*sizeof(mcIdType));
+ auto *connRet=(mcIdType *)malloc(connIndexRet[nbOfElemsRet]*sizeof(mcIdType));
mcIdType *connRetWork=connRet;
std::set<INTERP_KERNEL::NormalizedCellType> types;
for(const mcIdType *work=begin;work!=end;work++)
MEDCouplingUMesh *MEDCouplingUMesh::buildPartOfMySelfKeepCoordsSlice(mcIdType start, mcIdType end, mcIdType step) const
{
checkFullyDefined();
- mcIdType ncell=getNumberOfCells();
+ mcIdType const ncell=getNumberOfCells();
MCAuto<MEDCouplingUMesh> ret=MEDCouplingUMesh::New();
ret->_mesh_dim=_mesh_dim;
ret->setCoords(_coords);
- mcIdType newNbOfCells=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"MEDCouplingUMesh::buildPartOfMySelfKeepCoordsSlice : ");
+ mcIdType const newNbOfCells=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"MEDCouplingUMesh::buildPartOfMySelfKeepCoordsSlice : ");
MCAuto<DataArrayIdType> newConnI=DataArrayIdType::New(); newConnI->alloc(newNbOfCells+1,1);
mcIdType *newConnIPtr=newConnI->getPointer(); *newConnIPtr=0;
mcIdType work=start;
}
-mcIdType MEDCouplingFastNbrer(mcIdType id, mcIdType nb, const INTERP_KERNEL::CellModel& cm, bool compute, const mcIdType *conn1, const mcIdType *conn2)
+mcIdType MEDCouplingFastNbrer(mcIdType id, mcIdType /*nb*/, const INTERP_KERNEL::CellModel& /*cm*/, bool /*compute*/, const mcIdType * /*conn1*/, const mcIdType * /*conn2*/)
{
return id;
}
MCAuto<DataArrayIdType> newConn=DataArrayIdType::New(); newConn->alloc(0,1);
MCAuto<DataArrayIdType> newConnI=DataArrayIdType::New(); newConnI->alloc(1,1); newConnI->setIJ(0,0,0);
MCAuto<DataArrayIdType> ret=DataArrayIdType::New(); ret->alloc(0,1);
- mcIdType nbOfCells=getNumberOfCells();
- mcIdType nbOfNodes=getNumberOfNodes();
+ mcIdType const nbOfCells=getNumberOfCells();
+ mcIdType const nbOfNodes=getNumberOfNodes();
const mcIdType *cPtr=_nodal_connec->begin();
const mcIdType *icPtr=_nodal_connec_index->begin();
mcIdType lastVal=0,offset=nbOfNodes;
for(mcIdType i=0;i<nbOfCells;i++,icPtr++)
{
- INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)cPtr[*icPtr];
+ auto const type=(INTERP_KERNEL::NormalizedCellType)cPtr[*icPtr];
if(type==INTERP_KERNEL::NORM_SEG2)
{
types.insert(INTERP_KERNEL::NORM_SEG3);
MCAuto<DataArrayIdType> ret=DataArrayIdType::New(); ret->alloc(0,1);
//
const mcIdType *descPtr(desc->begin()),*descIPtr(descI->begin());
- DataArrayIdType *conn1D=0,*conn1DI=0;
+ DataArrayIdType *conn1D=nullptr,*conn1DI=nullptr;
std::set<INTERP_KERNEL::NormalizedCellType> types1D;
- DataArrayDouble *coordsTmp=0;
- MCAuto<DataArrayIdType> ret1D=m1D->convertLinearCellsToQuadratic1D0(conn1D,conn1DI,coordsTmp,types1D); ret1D=0;
+ DataArrayDouble *coordsTmp=nullptr;
+ MCAuto<DataArrayIdType> ret1D=m1D->convertLinearCellsToQuadratic1D0(conn1D,conn1DI,coordsTmp,types1D); ret1D=nullptr;
MCAuto<DataArrayDouble> coordsTmpSafe(coordsTmp);
MCAuto<DataArrayIdType> conn1DSafe(conn1D),conn1DISafe(conn1DI);
const mcIdType *c1DPtr=conn1D->begin();
const mcIdType *c1DIPtr=conn1DI->begin();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
const mcIdType *cPtr=_nodal_connec->begin();
const mcIdType *icPtr=_nodal_connec_index->begin();
mcIdType lastVal=0;
for(mcIdType i=0;i<nbOfCells;i++,icPtr++,descIPtr++)
{
- INTERP_KERNEL::NormalizedCellType typ=(INTERP_KERNEL::NormalizedCellType)cPtr[*icPtr];
+ auto const typ=(INTERP_KERNEL::NormalizedCellType)cPtr[*icPtr];
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
if(!cm.isQuadratic())
{
- INTERP_KERNEL::NormalizedCellType typ2=cm.getQuadraticType();
+ INTERP_KERNEL::NormalizedCellType const typ2=cm.getQuadraticType();
types.insert(typ2); newConn->pushBackSilent(typ2);
newConn->pushBackValsSilent(cPtr+icPtr[0]+1,cPtr+icPtr[1]);
for(const mcIdType *d=descPtr+descIPtr[0];d!=descPtr+descIPtr[1];d++)
DataArrayIdType *MEDCouplingUMesh::convertLinearCellsToQuadratic2D0(DataArrayIdType *&conn, DataArrayIdType *&connI, DataArrayDouble *& coords, std::set<INTERP_KERNEL::NormalizedCellType>& types) const
{
MCAuto<DataArrayIdType> desc(DataArrayIdType::New()),descI(DataArrayIdType::New()),tmp2(DataArrayIdType::New()),tmp3(DataArrayIdType::New());
- MCAuto<MEDCouplingUMesh> m1D=buildDescendingConnectivity(desc,descI,tmp2,tmp3); tmp2=0; tmp3=0;
+ MCAuto<MEDCouplingUMesh> m1D=buildDescendingConnectivity(desc,descI,tmp2,tmp3); tmp2=nullptr; tmp3=nullptr;
return convertLinearCellsToQuadratic2DAnd3D0(m1D,desc,descI,conn,connI,coords,types);
}
DataArrayIdType *MEDCouplingUMesh::convertLinearCellsToQuadratic2D1(DataArrayIdType *&conn, DataArrayIdType *&connI, DataArrayDouble *& coords, std::set<INTERP_KERNEL::NormalizedCellType>& types) const
{
MCAuto<DataArrayIdType> desc(DataArrayIdType::New()),descI(DataArrayIdType::New()),tmp2(DataArrayIdType::New()),tmp3(DataArrayIdType::New());
- MCAuto<MEDCouplingUMesh> m1D=buildDescendingConnectivity(desc,descI,tmp2,tmp3); tmp2=0; tmp3=0;
+ MCAuto<MEDCouplingUMesh> m1D=buildDescendingConnectivity(desc,descI,tmp2,tmp3); tmp2=nullptr; tmp3=nullptr;
//
MCAuto<DataArrayIdType> newConn=DataArrayIdType::New(); newConn->alloc(0,1);
MCAuto<DataArrayIdType> newConnI=DataArrayIdType::New(); newConnI->alloc(1,1); newConnI->setIJ(0,0,0);
//
MCAuto<DataArrayDouble> bary=computeCellCenterOfMass();
const mcIdType *descPtr(desc->begin()),*descIPtr(descI->begin());
- DataArrayIdType *conn1D=0,*conn1DI=0;
+ DataArrayIdType *conn1D=nullptr,*conn1DI=nullptr;
std::set<INTERP_KERNEL::NormalizedCellType> types1D;
- DataArrayDouble *coordsTmp=0;
- MCAuto<DataArrayIdType> ret1D=m1D->convertLinearCellsToQuadratic1D0(conn1D,conn1DI,coordsTmp,types1D); ret1D=0;
+ DataArrayDouble *coordsTmp=nullptr;
+ MCAuto<DataArrayIdType> ret1D=m1D->convertLinearCellsToQuadratic1D0(conn1D,conn1DI,coordsTmp,types1D); ret1D=nullptr;
MCAuto<DataArrayDouble> coordsTmpSafe(coordsTmp);
MCAuto<DataArrayIdType> conn1DSafe(conn1D),conn1DISafe(conn1DI);
const mcIdType *c1DPtr=conn1D->begin();
const mcIdType *c1DIPtr=conn1DI->begin();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
const mcIdType *cPtr=_nodal_connec->begin();
const mcIdType *icPtr=_nodal_connec_index->begin();
mcIdType lastVal=0;
- mcIdType offset=coordsTmpSafe->getNumberOfTuples();
+ mcIdType const offset=coordsTmpSafe->getNumberOfTuples();
for(mcIdType i=0;i<nbOfCells;i++,icPtr++,descIPtr++)
{
- INTERP_KERNEL::NormalizedCellType typ=(INTERP_KERNEL::NormalizedCellType)cPtr[*icPtr];
+ auto const typ=(INTERP_KERNEL::NormalizedCellType)cPtr[*icPtr];
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
if(!cm.isQuadratic())
{
- INTERP_KERNEL::NormalizedCellType typ2=cm.getQuadraticType2();
+ INTERP_KERNEL::NormalizedCellType const typ2=cm.getQuadraticType2();
types.insert(typ2); newConn->pushBackSilent(typ2);
newConn->pushBackValsSilent(cPtr+icPtr[0]+1,cPtr+icPtr[1]);
for(const mcIdType *d=descPtr+descIPtr[0];d!=descPtr+descIPtr[1];d++)
DataArrayIdType *MEDCouplingUMesh::convertLinearCellsToQuadratic3D0(DataArrayIdType *&conn, DataArrayIdType *&connI, DataArrayDouble *& coords, std::set<INTERP_KERNEL::NormalizedCellType>& types) const
{
MCAuto<DataArrayIdType> desc(DataArrayIdType::New()),descI(DataArrayIdType::New()),tmp2(DataArrayIdType::New()),tmp3(DataArrayIdType::New());
- MCAuto<MEDCouplingUMesh> m1D=explode3DMeshTo1D(desc,descI,tmp2,tmp3); tmp2=0; tmp3=0;
+ MCAuto<MEDCouplingUMesh> m1D=explode3DMeshTo1D(desc,descI,tmp2,tmp3); tmp2=nullptr; tmp3=nullptr;
return convertLinearCellsToQuadratic2DAnd3D0(m1D,desc,descI,conn,connI,coords,types);
}
DataArrayIdType *MEDCouplingUMesh::convertLinearCellsToQuadratic3D1(DataArrayIdType *&conn, DataArrayIdType *&connI, DataArrayDouble *& coords, std::set<INTERP_KERNEL::NormalizedCellType>& types) const
{
MCAuto<DataArrayIdType> desc2(DataArrayIdType::New()),desc2I(DataArrayIdType::New()),tmp2(DataArrayIdType::New()),tmp3(DataArrayIdType::New());
- MCAuto<MEDCouplingUMesh> m2D=buildDescendingConnectivityGen<MinusOneSonsGeneratorBiQuadratic>(desc2,desc2I,tmp2,tmp3,MEDCouplingFastNbrer); tmp2=0; tmp3=0;
+ MCAuto<MEDCouplingUMesh> m2D=buildDescendingConnectivityGen<MinusOneSonsGeneratorBiQuadratic>(desc2,desc2I,tmp2,tmp3,MEDCouplingFastNbrer); tmp2=nullptr; tmp3=nullptr;
MCAuto<DataArrayIdType> desc1(DataArrayIdType::New()),desc1I(DataArrayIdType::New()),tmp4(DataArrayIdType::New()),tmp5(DataArrayIdType::New());
- MCAuto<MEDCouplingUMesh> m1D=explode3DMeshTo1D(desc1,desc1I,tmp4,tmp5); tmp4=0; tmp5=0;
+ MCAuto<MEDCouplingUMesh> m1D=explode3DMeshTo1D(desc1,desc1I,tmp4,tmp5); tmp4=nullptr; tmp5=nullptr;
//
MCAuto<DataArrayIdType> newConn=DataArrayIdType::New(); newConn->alloc(0,1);
MCAuto<DataArrayIdType> newConnI=DataArrayIdType::New(); newConnI->alloc(1,1); newConnI->setIJ(0,0,0);
//
MCAuto<DataArrayDouble> bary=computeCellCenterOfMass();
const mcIdType *descPtr(desc1->begin()),*descIPtr(desc1I->begin()),*desc2Ptr(desc2->begin()),*desc2IPtr(desc2I->begin());
- DataArrayIdType *conn1D=0,*conn1DI=0,*conn2D=0,*conn2DI=0;
+ DataArrayIdType *conn1D=nullptr,*conn1DI=nullptr,*conn2D=nullptr,*conn2DI=nullptr;
std::set<INTERP_KERNEL::NormalizedCellType> types1D,types2D;
- DataArrayDouble *coordsTmp=0,*coordsTmp2=0;
+ DataArrayDouble *coordsTmp=nullptr,*coordsTmp2=nullptr;
MCAuto<DataArrayIdType> ret1D=m1D->convertLinearCellsToQuadratic1D0(conn1D,conn1DI,coordsTmp,types1D); ret1D=DataArrayIdType::New(); ret1D->alloc(0,1);
MCAuto<DataArrayIdType> conn1DSafe(conn1D),conn1DISafe(conn1DI);
MCAuto<DataArrayDouble> coordsTmpSafe(coordsTmp);
MCAuto<DataArrayDouble> coordsTmp2Safe(coordsTmp2);
MCAuto<DataArrayIdType> conn2DSafe(conn2D),conn2DISafe(conn2DI);
const mcIdType *c1DPtr=conn1D->begin(),*c1DIPtr=conn1DI->begin(),*c2DPtr=conn2D->begin(),*c2DIPtr=conn2DI->begin();
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
const mcIdType *cPtr=_nodal_connec->begin();
const mcIdType *icPtr=_nodal_connec_index->begin();
mcIdType lastVal=0;
mcIdType offset=coordsTmpSafe->getNumberOfTuples();
for(mcIdType i=0;i<nbOfCells;i++,icPtr++,descIPtr++,desc2IPtr++)
{
- INTERP_KERNEL::NormalizedCellType typ=(INTERP_KERNEL::NormalizedCellType)cPtr[*icPtr];
+ auto const typ=(INTERP_KERNEL::NormalizedCellType)cPtr[*icPtr];
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
if(!cm.isQuadratic())
{
- INTERP_KERNEL::NormalizedCellType typ2=cm.getQuadraticType2();
+ INTERP_KERNEL::NormalizedCellType const typ2=cm.getQuadraticType2();
if(typ2==INTERP_KERNEL::NORM_ERROR)
{
std::ostringstream oss; oss << "MEDCouplingUMesh::convertLinearCellsToQuadratic3D1 : On cell #" << i << " the linear cell type does not support advanced quadratization !";
newConn->pushBackSilent(c1DPtr[c1DIPtr[*d]+3]);
for(const mcIdType *d=desc2Ptr+desc2IPtr[0];d!=desc2Ptr+desc2IPtr[1];d++)
{
- mcIdType nodeId2=c2DPtr[c2DIPtr[(*d)+1]-1];
- mcIdType tmpPos=newConn->getNumberOfTuples();
+ mcIdType const nodeId2=c2DPtr[c2DIPtr[(*d)+1]-1];
+ mcIdType const tmpPos=newConn->getNumberOfTuples();
newConn->pushBackSilent(nodeId2);
ret2D->pushBackSilent(nodeId2); ret1D->pushBackSilent(tmpPos);
}
for(const mcIdType *elt=ret1D->begin();elt!=ret1D->end();elt++)
c[*elt]=o2nRet2D->getIJ(c[*elt],0)+offset;
offset=coordsTmp2Safe->getNumberOfTuples();
- for(const mcIdType *elt=ret->begin();elt!=ret->end();elt++)
- c[cI[(*elt)+1]-1]+=offset;
+ for(long const elt : *ret)
+ c[cI[elt+1]-1]+=offset;
coords=DataArrayDouble::Aggregate(v); conn=newConn.retn(); connI=newConnI.retn();
return ret.retn();
}
DataArrayIdType *MEDCouplingUMesh::buildUnionOf2DMeshLinear(const MEDCouplingUMesh *skin, const DataArrayIdType *n2o) const
{
- mcIdType nbOfNodesExpected(skin->getNumberOfNodes());
+ mcIdType const nbOfNodesExpected(skin->getNumberOfNodes());
const mcIdType *n2oPtr(n2o->begin());
MCAuto<DataArrayIdType> revNodal(DataArrayIdType::New()),revNodalI(DataArrayIdType::New());
skin->getReverseNodalConnectivity(revNodal,revNodalI);
conn.erase(prevNode);
if(conn.size()==1)
{
- mcIdType curNode(*(conn.begin()));
+ mcIdType const curNode(*(conn.begin()));
*work++=n2oPtr[curNode];
std::set<mcIdType> shar(revNodalPtr+revNodalIPtr[curNode],revNodalPtr+revNodalIPtr[curNode+1]);
shar.erase(prevCell);
DataArrayIdType *MEDCouplingUMesh::buildUnionOf2DMeshQuadratic(const MEDCouplingUMesh *skin, const DataArrayIdType *n2o) const
{
- mcIdType nbOfNodesExpected(skin->getNumberOfNodes());
- mcIdType nbOfTurn(nbOfNodesExpected/2);
+ mcIdType const nbOfNodesExpected(skin->getNumberOfNodes());
+ mcIdType const nbOfTurn(nbOfNodesExpected/2);
const mcIdType *n2oPtr(n2o->begin());
MCAuto<DataArrayIdType> revNodal(DataArrayIdType::New()),revNodalI(DataArrayIdType::New());
skin->getReverseNodalConnectivity(revNodal,revNodalI);
conn.erase(prevNode);
if(conn.size()==1)
{
- mcIdType curNode(*(conn.begin()));
+ mcIdType const curNode(*(conn.begin()));
*work=n2oPtr[curNode];
std::set<mcIdType> shar(revNodalPtr+revNodalIPtr[curNode],revNodalPtr+revNodalIPtr[curNode+1]);
shar.erase(prevCell);
if(shar.size()==1)
{
- mcIdType curCell(*(shar.begin()));
+ mcIdType const curCell(*(shar.begin()));
work[nbOfTurn]=n2oPtr[nodalPtr[nodalIPtr[curCell]+3]];
prevCell=curCell;
prevNode=curNode;
*outArrIndxPtr++ = 0;
for( mcIdType i = 0 ; i < arrIndxNbTuples - 1 ; ++i )
{
- mcIdType startPos(*inArrIndxPtr++);
- mcIdType endPos(*inArrIndxPtr);
+ mcIdType const startPos(*inArrIndxPtr++);
+ mcIdType const endPos(*inArrIndxPtr);
if(inArrPtr[startPos] == INTERP_KERNEL::NORM_POLYHED)
{
presenceOfPolyh = true;
*outArrIndxPtr++ = 0;
for( mcIdType i = 0 ; i < arrIndxNbTuples - 1 ; ++i,++outArrIndxPtr )
{
- mcIdType startPos(*inArrIndxPtr++);
- mcIdType endPos(*inArrIndxPtr);
+ mcIdType const startPos(*inArrIndxPtr++);
+ mcIdType const endPos(*inArrIndxPtr);
if(inArrPtr[startPos] != INTERP_KERNEL::NORM_POLYHED)
{
arrOut->insertAtTheEnd(inArrPtr+startPos+1,inArrPtr+endPos);
{
if(a.empty())
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::MergeUMeshes : input array must be NON EMPTY !");
- std::vector<const MEDCouplingUMesh *>::const_iterator it=a.begin();
- int meshDim=(*it)->getMeshDimension();
+ auto it=a.begin();
+ int const meshDim=(*it)->getMeshDimension();
mcIdType nbOfCells=ToIdType((*it)->getNumberOfCells());
mcIdType meshLgth=(*it++)->getNodalConnectivityArrayLen();
for(;it!=a.end();it++)
mcIdType offset2=0;
for(it=a.begin();it!=a.end();it++)
{
- mcIdType curNbOfCell=ToIdType((*it)->getNumberOfCells());
+ mcIdType const curNbOfCell=ToIdType((*it)->getNumberOfCells());
const mcIdType *curCI=(*it)->_nodal_connec_index->begin();
const mcIdType *curC=(*it)->_nodal_connec->begin();
cIPtr=std::transform(curCI+1,curCI+curNbOfCell+1,cIPtr,std::bind(std::plus<mcIdType>(),std::placeholders::_1,offset));
{
case INTERP_KERNEL::NORM_TRI3:
{
- double tmp=INTERP_KERNEL::DistanceFromPtToTriInSpaceDim3(pt,coords+3*nc[ncI[*zeCell]+1],coords+3*nc[ncI[*zeCell]+2],coords+3*nc[ncI[*zeCell]+3]);
+ double const tmp=INTERP_KERNEL::DistanceFromPtToTriInSpaceDim3(pt,coords+3*nc[ncI[*zeCell]+1],coords+3*nc[ncI[*zeCell]+2],coords+3*nc[ncI[*zeCell]+3]);
if(tmp<ret0)
{ ret0=tmp; cellId=*zeCell; }
break;
case INTERP_KERNEL::NORM_QUAD4:
case INTERP_KERNEL::NORM_POLYGON:
{
- double tmp=INTERP_KERNEL::DistanceFromPtToPolygonInSpaceDim3(pt,nc+ncI[*zeCell]+1,nc+ncI[*zeCell+1],coords);
+ double const tmp=INTERP_KERNEL::DistanceFromPtToPolygonInSpaceDim3(pt,nc+ncI[*zeCell]+1,nc+ncI[*zeCell+1],coords);
if(tmp<ret0)
{ ret0=tmp; cellId=*zeCell; }
break;
nbOfDepthPeelingPerformed=0;
if(!seedBg || !seedEnd || !arrIn || !arrIndxIn)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ComputeSpreadZoneGraduallyFromSeedAlg : some input pointer is NULL !");
- mcIdType nbOfTuples=arrIndxIn->getNumberOfTuples()-1;
+ mcIdType const nbOfTuples=arrIndxIn->getNumberOfTuples()-1;
std::vector<bool> fetched2(nbOfTuples,false);
int i=0;
for(const mcIdType *seedElt=seedBg;seedElt!=seedEnd;seedElt++,i++)
}
const mcIdType *arrInPtr=arrIn->begin();
const mcIdType *arrIndxPtr=arrIndxIn->begin();
- mcIdType targetNbOfDepthPeeling=nbOfDepthPeeling!=-1?nbOfDepthPeeling:std::numeric_limits<mcIdType>::max();
+ mcIdType const targetNbOfDepthPeeling=nbOfDepthPeeling!=-1?nbOfDepthPeeling:std::numeric_limits<mcIdType>::max();
std::vector<mcIdType> idsToFetch1(seedBg,seedEnd);
std::vector<mcIdType> idsToFetch2;
std::vector<mcIdType> *idsToFetch=&idsToFetch1;
std::vector<mcIdType> *idsToFetchOther=&idsToFetch2;
while(!idsToFetch->empty() && nbOfDepthPeelingPerformed<targetNbOfDepthPeeling)
{
- for(std::vector<mcIdType>::const_iterator it=idsToFetch->begin();it!=idsToFetch->end();it++)
- for(const mcIdType *it2=arrInPtr+arrIndxPtr[*it];it2!=arrInPtr+arrIndxPtr[*it+1];it2++)
+ for(long const it : *idsToFetch)
+ for(const mcIdType *it2=arrInPtr+arrIndxPtr[it];it2!=arrInPtr+arrIndxPtr[it+1];it2++)
if(!fetched[*it2])
{ fetched[*it2]=true; fetched2[*it2]=true; idsToFetchOther->push_back(*it2); }
std::swap(idsToFetch,idsToFetchOther);
idsToFetchOther->clear();
nbOfDepthPeelingPerformed++;
}
- mcIdType lgth=ToIdType(std::count(fetched2.begin(),fetched2.end(),true));
+ mcIdType const lgth=ToIdType(std::count(fetched2.begin(),fetched2.end(),true));
i=0;
MCAuto<DataArrayIdType> ret=DataArrayIdType::New(); ret->alloc(lgth,1);
mcIdType *retPtr=ret->getPointer();
*/
void MEDCouplingUMesh::AppendExtrudedCell(const mcIdType *connBg, const mcIdType *connEnd, mcIdType nbOfNodesPerLev, bool isQuad, std::vector<mcIdType>& ret)
{
- INTERP_KERNEL::NormalizedCellType flatType=(INTERP_KERNEL::NormalizedCellType)connBg[0];
+ auto const flatType=(INTERP_KERNEL::NormalizedCellType)connBg[0];
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(flatType);
ret.push_back(cm.getExtrudedType());
- mcIdType deltaz=isQuad?2*nbOfNodesPerLev:nbOfNodesPerLev;
+ mcIdType const deltaz=isQuad?2*nbOfNodesPerLev:nbOfNodesPerLev;
switch(flatType)
{
case INTERP_KERNEL::NORM_POINT1:
std::back_insert_iterator< std::vector<mcIdType> > ii(ret);
std::copy(connBg+1,connEnd,ii);
*ii++=-1;
- std::reverse_iterator<const mcIdType *> rConnBg(connEnd);
- std::reverse_iterator<const mcIdType *> rConnEnd(connBg+1);
+ std::reverse_iterator<const mcIdType *> const rConnBg(connEnd);
+ std::reverse_iterator<const mcIdType *> const rConnEnd(connBg+1);
std::transform(rConnBg,rConnEnd,ii,std::bind(std::plus<mcIdType>(),std::placeholders::_1,deltaz));
- std::size_t nbOfRadFaces=std::distance(connBg+1,connEnd);
+ std::size_t const nbOfRadFaces=std::distance(connBg+1,connEnd);
for(std::size_t i=0;i<nbOfRadFaces;i++)
{
*ii++=-1;
const mcIdType *desc, const mcIdType *descIndx,
std::vector< std::pair<mcIdType,mcIdType> >& cut3DSurf)
{
- std::set<mcIdType> nodesOnP(nodesOnPlane.begin(),nodesOnPlane.end());
- mcIdType nbOf3DSurfCell=ToIdType(cut3DSurf.size());
+ std::set<mcIdType> const nodesOnP(nodesOnPlane.begin(),nodesOnPlane.end());
+ mcIdType const nbOf3DSurfCell=ToIdType(cut3DSurf.size());
for(mcIdType i=0;i<nbOf3DSurfCell;i++)
{
std::vector<mcIdType> res;
- mcIdType offset=descIndx[i];
- mcIdType nbOfSeg=descIndx[i+1]-offset;
+ mcIdType const offset=descIndx[i];
+ mcIdType const nbOfSeg=descIndx[i+1]-offset;
for(mcIdType j=0;j<nbOfSeg;j++)
{
- mcIdType edgeId=desc[offset+j];
- mcIdType status=cut3DCurve[edgeId];
+ mcIdType const edgeId=desc[offset+j];
+ mcIdType const status=cut3DCurve[edgeId];
if(status!=-2)
{
if(status>-1)
case 1:
case 0:
{
- std::set<mcIdType> s1(nodal3DSurf+nodalIndx3DSurf[i]+1,nodal3DSurf+nodalIndx3DSurf[i+1]);
+ std::set<mcIdType> const s1(nodal3DSurf+nodalIndx3DSurf[i]+1,nodal3DSurf+nodalIndx3DSurf[i+1]);
std::set_intersection(nodesOnP.begin(),nodesOnP.end(),s1.begin(),s1.end(),std::back_insert_iterator< std::vector<mcIdType> >(res));
if(res.size()==2)
{
if(getMeshDimension()!=3 || getSpaceDimension()!=3)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::assemblyForSplitFrom3DSurf works on umeshes with meshdim equal to 3 and spaceDim equal to 3 too!");
const mcIdType *nodal3D(_nodal_connec->begin()),*nodalIndx3D(_nodal_connec_index->begin());
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
for(mcIdType i=0;i<nbOfCells;i++)
{
std::map<mcIdType, std::set<mcIdType> > m;
- mcIdType offset=descIndx[i];
- mcIdType nbOfFaces=descIndx[i+1]-offset;
+ mcIdType const offset=descIndx[i];
+ mcIdType const nbOfFaces=descIndx[i+1]-offset;
mcIdType start=-1;
mcIdType end=-1;
for(int j=0;j<nbOfFaces;j++)
else
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)nodal3D[nodalIndx3D[i]]);
- mcIdType sz=nodalIndx3D[i+1]-nodalIndx3D[i]-1;
+ mcIdType const sz=nodalIndx3D[i+1]-nodalIndx3D[i]-1;
INTERP_KERNEL::AutoPtr<mcIdType> tmp=new mcIdType[sz];
INTERP_KERNEL::NormalizedCellType cmsId;
- unsigned nbOfNodesSon=cm.fillSonCellNodalConnectivity2(j,nodal3D+nodalIndx3D[i]+1,sz,tmp,cmsId);
+ unsigned const nbOfNodesSon=cm.fillSonCellNodalConnectivity2(j,nodal3D+nodalIndx3D[i]+1,sz,tmp,cmsId);
start=tmp[0]; end=tmp[nbOfNodesSon-1];
for(unsigned k=0;k<nbOfNodesSon;k++)
{
mcIdType prev=end;
while(end!=start)
{
- std::map<mcIdType, std::set<mcIdType> >::const_iterator it=m.find(start);
+ std::map<mcIdType, std::set<mcIdType> >::const_iterator const it=m.find(start);
const std::set<mcIdType>& s=(*it).second;
std::set<mcIdType> s2; s2.insert(prev);
std::set<mcIdType> s3;
std::set_difference(s.begin(),s.end(),s2.begin(),s2.end(),inserter(s3,s3.begin()));
if(s3.size()==1)
{
- mcIdType val=*s3.begin();
+ mcIdType const val=*s3.begin();
conn.push_back(start);
prev=start;
start=val;
{
types.clear();
const mcIdType *conn(nodalConnec->begin()),*connIndex(nodalConnecIndex->begin());
- mcIdType nbOfElem=ToIdType(nodalConnecIndex->getNbOfElems())-1;
+ mcIdType const nbOfElem=ToIdType(nodalConnecIndex->getNbOfElems())-1;
if(nbOfElem>0)
for(const mcIdType *pt=connIndex;pt!=connIndex+nbOfElem;pt++)
types.insert((INTERP_KERNEL::NormalizedCellType)conn[*pt]);
void MEDCouplingUMesh::attractSeg3MidPtsAroundNodes(double ratio, const mcIdType *nodeIdsBg, const mcIdType *nodeIdsEnd)
{
checkFullyDefined();
- int mdim(getMeshDimension());
+ int const mdim(getMeshDimension());
if(mdim==2 || mdim==3)
{
MCAuto<MEDCouplingUMesh> edges;
*/
void MEDCouplingUMesh::attractSeg3MidPtsAroundNodesUnderground(double ratio, const mcIdType *nodeIdsBg, const mcIdType *nodeIdsEnd)
{
- int spaceDim(getSpaceDimension());
+ int const spaceDim(getSpaceDimension());
double *coords(getCoords()->getPointer());
auto nbNodes(getNumberOfNodes());
- std::size_t nbCells(getNumberOfCells());
+ std::size_t const nbCells(getNumberOfCells());
std::vector<bool> fastFinder(nbNodes,false);
for(auto work=nodeIdsBg;work!=nodeIdsEnd;work++)
if(*work>=0 && *work<nbNodes)
fastFinder[*work]=true;
- MCAuto<DataArrayIdType> cellsIds(getCellIdsLyingOnNodes(nodeIdsBg,nodeIdsEnd,false));
+ MCAuto<DataArrayIdType> const cellsIds(getCellIdsLyingOnNodes(nodeIdsBg,nodeIdsEnd,false));
const mcIdType *nc(_nodal_connec->begin()),*nci(_nodal_connec_index->begin());
for(std::size_t cellId=0;cellId<nbCells;cellId++,nci++)
{
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// Author : Anthony Geay (EdF)
+#include "MCAuto.hxx"
+#include "MCIdType.hxx"
+#include "MCType.hxx"
+#include "InterpKernelException.hxx"
+#include "InterpKernelGeo2DPrecision.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "CellModel.hxx"
+#include "MEDCouplingUMesh.hxx"
+#include "NormalizedGeometricTypes"
+#include "NormalizedUnstructuredMesh.hxx"
+#include "BBTree.txx"
+#include "InterpKernelAutoPtr.hxx"
+#include "PointLocatorAlgos.txx"
+
using namespace MEDCoupling;
static const INTERP_KERNEL::NumberingPolicy My_numPol=INTERP_KERNEL::ALL_C_MODE;
// begin
// useless, but for windows compilation ...
- const double* getCoordinatesPtr() const { return 0; }
- const MyConnType* getConnectivityPtr() const { return 0; }
- const MyConnType* getConnectivityIndexPtr() const { return 0; }
+ const double* getCoordinatesPtr() const { return nullptr; }
+ const MyConnType* getConnectivityPtr() const { return nullptr; }
+ const MyConnType* getConnectivityIndexPtr() const { return nullptr; }
INTERP_KERNEL::NormalizedCellType getTypeOfElement(MyConnType) const { return (INTERP_KERNEL::NormalizedCellType)0; }
// end
};
//
// Author : Anthony Geay (CEA/DEN)
+#include "MCIdType.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MCAuto.hxx"
+#include "InterpKernelGeo2DComposedEdge.hxx"
+#include "InterpKernelGeo2DElementaryEdge.hxx"
+#include "InterpKernelGeo2DEdge.hxx"
+#include "MCType.hxx"
+#include "BBTreePts.txx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "InterpKernelGeo2DPrecision.hxx"
+#include "InterpKernelGeo2DAbstractEdge.hxx"
#include "MEDCouplingUMesh.hxx"
-#include "MEDCoupling1GTUMesh.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "CellModel.hxx"
-#include "VolSurfUser.txx"
-#include "InterpolationUtils.hxx"
-#include "PointLocatorAlgos.txx"
+#include "NormalizedGeometricTypes"
#include "BBTree.txx"
-#include "BBTreeDst.txx"
-#include "DirectedBoundingBox.hxx"
#include "InterpKernelGeo2DEdgeArcCircle.hxx"
#include "InterpKernelAutoPtr.hxx"
#include "InterpKernelGeo2DNode.hxx"
#include "VectorUtils.hxx"
#include "MEDCouplingSkyLineArray.hxx"
+#include <map>
+#include <algorithm>
+#include <set>
+#include <cstdlib>
+#include <iterator>
+#include <cmath>
+#include <functional>
#include <sstream>
-#include <fstream>
-#include <numeric>
#include <cstring>
#include <limits>
-#include <list>
#include <assert.h>
+#include <vector>
+#include <utility>
using namespace MEDCoupling;
return id;
else
{
- mcIdType ret(nodesCnter++);
+ mcIdType const ret(nodesCnter++);
double newPt[2];
e->getMiddleOfPoints(coo+2*startId,coo+2*endId,newPt);
addCoo.insertAtTheEnd(newPt,newPt+2);
return id;
else
{
- mcIdType ret(nodesCnter++);
+ mcIdType const ret(nodesCnter++);
double newPt[2];
e->getMiddleOfPointsOriented(coo+2*startId,coo+2*endId,newPt);
addCoo.insertAtTheEnd(newPt,newPt+2);
void EnterTheResultOf2DCellFirst(const INTERP_KERNEL::Edge *e, int start, int stp, int nbOfEdges, bool linOrArc, const double *coords, const mcIdType *connBg, mcIdType offset, DataArrayIdType *newConnOfCell, DataArrayDouble *appendedCoords, std::vector<mcIdType>& middles)
{
mcIdType tmp[3];
- int trueStart(start>=0?start:nbOfEdges+start);
+ int const trueStart(start>=0?start:nbOfEdges+start);
tmp[0]=ToIdType(linOrArc?INTERP_KERNEL::NORM_QPOLYG:INTERP_KERNEL::NORM_POLYGON); tmp[1]=connBg[trueStart]; tmp[2]=connBg[stp];
newConnOfCell->insertAtTheEnd(tmp,tmp+3);
if(linOrArc)
}
}
-void EnterTheResultOf2DCellEnd(const INTERP_KERNEL::Edge *e, int start, int stp, int nbOfEdges, bool linOrArc, const double *coords, const mcIdType *connBg, mcIdType offset, DataArrayIdType *newConnOfCell, DataArrayDouble *appendedCoords, std::vector<mcIdType>& middles)
+void EnterTheResultOf2DCellEnd(const INTERP_KERNEL::Edge *e, int start, int stp, int nbOfEdges, bool linOrArc, const double *coords, const mcIdType *connBg, mcIdType offset, DataArrayIdType * /*newConnOfCell*/, DataArrayDouble *appendedCoords, std::vector<mcIdType>& middles)
{
// only the quadratic point to deal with:
if(linOrArc)
void IKGeo2DInternalMapper2(INTERP_KERNEL::Node *n, const std::map<MCAuto<INTERP_KERNEL::Node>,mcIdType>& m, mcIdType forbVal0, mcIdType forbVal1, std::vector<mcIdType>& isect)
{
MCAuto<INTERP_KERNEL::Node> nTmp(n); nTmp->incrRef();
- std::map<MCAuto<INTERP_KERNEL::Node>,mcIdType>::const_iterator it(m.find(nTmp));
+ auto const it(m.find(nTmp));
if(it==m.end())
throw INTERP_KERNEL::Exception("Internal error in remapping !");
- mcIdType v((*it).second);
+ mcIdType const v((*it).second);
if(v==forbVal0 || v==forbVal1)
return ;
if(std::find(isect.begin(),isect.end(),v)==isect.end())
bool IKGeo2DInternalMapper(const INTERP_KERNEL::ComposedEdge& c, const std::map<MCAuto<INTERP_KERNEL::Node>,mcIdType>& m, mcIdType forbVal0, mcIdType forbVal1, std::vector<mcIdType>& isect)
{
- int sz(c.size());
+ int const sz(c.size());
if(sz<=1)
return false;
- bool presenceOfOn(false);
+ bool const presenceOfOn(false);
for(int i=0;i<sz;i++)
{
INTERP_KERNEL::ElementaryEdge *e(c[i]);
INTERP_KERNEL::Edge *MEDCouplingUMeshBuildQPFromEdge2(INTERP_KERNEL::NormalizedCellType typ, const mcIdType *bg, const double *coords2D, std::map< MCAuto<INTERP_KERNEL::Node>,mcIdType>& m)
{
- INTERP_KERNEL::Edge *ret(0);
+ INTERP_KERNEL::Edge *ret(nullptr);
MCAuto<INTERP_KERNEL::Node> n0(new INTERP_KERNEL::Node(coords2D[2*bg[0]],coords2D[2*bg[0]+1])),n1(new INTERP_KERNEL::Node(coords2D[2*bg[1]],coords2D[2*bg[1]+1]));
m[n0]=bg[0]; m[n1]=bg[1];
switch(typ)
}
case INTERP_KERNEL::NORM_SEG3:
{
- INTERP_KERNEL::Node *n2(new INTERP_KERNEL::Node(coords2D[2*bg[2]],coords2D[2*bg[2]+1])); m[n2]=bg[2];
- INTERP_KERNEL::EdgeLin *e1(new INTERP_KERNEL::EdgeLin(n0,n2)),*e2(new INTERP_KERNEL::EdgeLin(n2,n1));
- INTERP_KERNEL::SegSegIntersector inters(*e1,*e2);
+ auto *n2(new INTERP_KERNEL::Node(coords2D[2*bg[2]],coords2D[2*bg[2]+1])); m[n2]=bg[2];
+ auto *e1(new INTERP_KERNEL::EdgeLin(n0,n2)),*e2(new INTERP_KERNEL::EdgeLin(n2,n1));
+ INTERP_KERNEL::SegSegIntersector const inters(*e1,*e2);
// is the SEG3 degenerated, and thus can be reduced to a SEG2?
- bool colinearity(inters.areColinears());
+ bool const colinearity(inters.areColinears());
delete e1; delete e2;
if(colinearity)
{ ret=new INTERP_KERNEL::EdgeLin(n0,n1); }
INTERP_KERNEL::Edge *MEDCouplingUMeshBuildQPFromEdge(INTERP_KERNEL::NormalizedCellType typ, std::map<mcIdType, INTERP_KERNEL::NodeWithUsage >& mapp2, const mcIdType *bg)
{
- INTERP_KERNEL::Edge *ret=0;
+ INTERP_KERNEL::Edge *ret=nullptr;
mapp2[bg[0]].second = INTERP_KERNEL::USAGE_LINEAR;
mapp2[bg[1]].second = INTERP_KERNEL::USAGE_LINEAR;
}
case INTERP_KERNEL::NORM_SEG3:
{
- INTERP_KERNEL::EdgeLin *e1=new INTERP_KERNEL::EdgeLin(mapp2[bg[0]].first,mapp2[bg[2]].first);
- INTERP_KERNEL::EdgeLin *e2=new INTERP_KERNEL::EdgeLin(mapp2[bg[2]].first,mapp2[bg[1]].first);
- INTERP_KERNEL::SegSegIntersector inters(*e1,*e2);
+ auto *e1=new INTERP_KERNEL::EdgeLin(mapp2[bg[0]].first,mapp2[bg[2]].first);
+ auto *e2=new INTERP_KERNEL::EdgeLin(mapp2[bg[2]].first,mapp2[bg[1]].first);
+ INTERP_KERNEL::SegSegIntersector const inters(*e1,*e2);
// is the SEG3 degenerated, and thus can be reduced to a SEG2?
- bool colinearity=inters.areColinears();
+ bool const colinearity=inters.areColinears();
delete e1; delete e2;
if(colinearity)
ret=new INTERP_KERNEL::EdgeLin(mapp2[bg[0]].first,mapp2[bg[1]].first);
const mcIdType *c=mDesc->getNodalConnectivity()->getConstPointer();
const mcIdType *cI=mDesc->getNodalConnectivityIndex()->getConstPointer();
std::set<mcIdType> s;
- for(std::vector<mcIdType>::const_iterator it=candidates.begin();it!=candidates.end();it++)
- s.insert(c+cI[*it]+1,c+cI[(*it)+1]);
- for(std::set<mcIdType>::const_iterator it2=s.begin();it2!=s.end();it2++)
+ for(long const candidate : candidates)
+ s.insert(c+cI[candidate]+1,c+cI[candidate+1]);
+ for(long const it2 : s)
{
- INTERP_KERNEL::Node *n=new INTERP_KERNEL::Node(coo[2*(*it2)],coo[2*(*it2)+1]);
- mapp2[*it2]=INTERP_KERNEL::NodeWithUsage(n,INTERP_KERNEL::USAGE_UNKNOWN);
+ auto *n=new INTERP_KERNEL::Node(coo[2*it2],coo[2*it2+1]);
+ mapp2[it2]=INTERP_KERNEL::NodeWithUsage(n,INTERP_KERNEL::USAGE_UNKNOWN);
}
- INTERP_KERNEL::QuadraticPolygon *ret=new INTERP_KERNEL::QuadraticPolygon;
- for(std::vector<mcIdType>::const_iterator it=candidates.begin();it!=candidates.end();it++)
+ auto *ret=new INTERP_KERNEL::QuadraticPolygon;
+ for(long const candidate : candidates)
{
- INTERP_KERNEL::NormalizedCellType typ=(INTERP_KERNEL::NormalizedCellType)c[cI[*it]];
- ret->pushBack(MEDCouplingUMeshBuildQPFromEdge(typ,mapp2,c+cI[*it]+1));
+ auto const typ=(INTERP_KERNEL::NormalizedCellType)c[cI[candidate]];
+ ret->pushBack(MEDCouplingUMeshBuildQPFromEdge(typ,mapp2,c+cI[candidate]+1));
}
for(std::map<mcIdType, INTERP_KERNEL::NodeWithUsage >::const_iterator it2=mapp2.begin();it2!=mapp2.end();it2++)
{
const mcIdType *c=mDesc->getNodalConnectivity()->getConstPointer();
const mcIdType *cI=mDesc->getNodalConnectivityIndex()->getConstPointer();
std::set<mcIdType> s;
- for(std::vector<mcIdType>::const_iterator it=candidates.begin();it!=candidates.end();it++)
- s.insert(c+cI[*it]+1,c+cI[(*it)+1]);
- for(std::set<mcIdType>::const_iterator it2=s.begin();it2!=s.end();it2++)
+ for(long const candidate : candidates)
+ s.insert(c+cI[candidate]+1,c+cI[candidate+1]);
+ for(long const it2 : s)
{
INTERP_KERNEL::Node *n;
// Look for a potential node to merge
std::vector<mcIdType> candNode;
- nodeTree.getElementsAroundPoint(coo+2*(*it2), candNode);
+ nodeTree.getElementsAroundPoint(coo+2*it2, candNode);
if (candNode.size() > 2)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::MEDCouplingUMeshBuildQPFromMeshWithTree(): some nodes are not properly merged (within eps) in input mesh!");
bool node_created=false;
}
}
if(!node_created)
- n = new INTERP_KERNEL::Node(coo[2*(*it2)],coo[2*(*it2)+1]);
- mapp2[*it2]=INTERP_KERNEL::NodeWithUsage(n,INTERP_KERNEL::USAGE_UNKNOWN);
+ n = new INTERP_KERNEL::Node(coo[2*it2],coo[2*it2+1]);
+ mapp2[it2]=INTERP_KERNEL::NodeWithUsage(n,INTERP_KERNEL::USAGE_UNKNOWN);
}
- INTERP_KERNEL::QuadraticPolygon *ret=new INTERP_KERNEL::QuadraticPolygon;
- for(std::vector<mcIdType>::const_iterator it=candidates.begin();it!=candidates.end();it++)
+ auto *ret=new INTERP_KERNEL::QuadraticPolygon;
+ for(long const candidate : candidates)
{
- INTERP_KERNEL::NormalizedCellType typ=(INTERP_KERNEL::NormalizedCellType)c[cI[*it]];
- ret->pushBack(MEDCouplingUMeshBuildQPFromEdge(typ,mapp2,c+cI[*it]+1)); // this call will set quad points to false in the map
+ auto const typ=(INTERP_KERNEL::NormalizedCellType)c[cI[candidate]];
+ ret->pushBack(MEDCouplingUMeshBuildQPFromEdge(typ,mapp2,c+cI[candidate]+1)); // this call will set quad points to false in the map
}
for(std::map<mcIdType, INTERP_KERNEL::NodeWithUsage >::const_iterator it2=mapp2.begin();it2!=mapp2.end();it2++)
{
{
if(nodeId>=offset2)
{
- mcIdType locId=nodeId-offset2;
+ mcIdType const locId=nodeId-offset2;
return new INTERP_KERNEL::Node(addCoo[2*locId],addCoo[2*locId+1]);
}
if(nodeId>=offset1)
{
- mcIdType locId=nodeId-offset1;
+ mcIdType const locId=nodeId-offset1;
return new INTERP_KERNEL::Node(coo2[2*locId],coo2[2*locId+1]);
}
return new INTERP_KERNEL::Node(coo1[2*nodeId],coo1[2*nodeId+1]);
{
for(const mcIdType *desc1=desc1Bg;desc1!=desc1End;desc1++)
{
- mcIdType eltId1=std::abs(*desc1)-1;
- for(std::vector<mcIdType>::const_iterator it1=intesctEdges1[eltId1].begin();it1!=intesctEdges1[eltId1].end();it1++)
+ mcIdType const eltId1=std::abs(*desc1)-1;
+ for(long const it1 : intesctEdges1[eltId1])
{
- std::map<mcIdType,INTERP_KERNEL::Node *>::const_iterator it=mappRev.find(*it1);
+ std::map<mcIdType,INTERP_KERNEL::Node *>::const_iterator const it=mappRev.find(it1);
if(it==mappRev.end())
{
- INTERP_KERNEL::Node *node=MEDCouplingUMeshBuildQPNode(*it1,coo1,offset1,coo2,offset2,addCoo);
- mapp[node]=*it1;
- mappRev[*it1]=node;
+ INTERP_KERNEL::Node *node=MEDCouplingUMeshBuildQPNode(it1,coo1,offset1,coo2,offset2,addCoo);
+ mapp[node]=it1;
+ mappRev[it1]=node;
}
}
}
INTERP_KERNEL::AutoPtr<mcIdType> tmpConn(new mcIdType[sz]);
INTERP_KERNEL::AutoPtr<mcIdType> tmpConn2(new mcIdType[sz]);
const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)connBg[0]));
- unsigned nbs(cm.getNumberOfSons2(connBg+1,ToIdType(sz)));
+ unsigned const nbs(cm.getNumberOfSons2(connBg+1,ToIdType(sz)));
unsigned nbOfHit(0); // number of fusions operated
int posBaseElt(0),posEndElt(0),nbOfTurn(0);
const std::size_t maxNbOfHit = cm.isQuadratic() ? nbs-2 : nbs-3; // a quad cell is authorized to end up with only two edges, a linear one has to keep 3 at least
{
cm.fillSonCellNodalConnectivity2(nbs-i,connBg+1,ToIdType(sz),tmpConn2,typeOfSon);
// Identify common point:
- mcIdType commPoint = std::find((mcIdType *)tmpConn, tmpConn+2, tmpConn2[0]) != tmpConn+2 ? tmpConn2[0] : tmpConn2[1];
+ mcIdType const commPoint = std::find((mcIdType *)tmpConn, tmpConn+2, tmpConn2[0]) != tmpConn+2 ? tmpConn2[0] : tmpConn2[1];
auto itE(forbiddenPoints.end());
if (forbiddenPoints.find(commPoint) != itE) // is the junction point in the list of points we can not remove?
break;
INTERP_KERNEL::Edge *eCand(MEDCouplingUMeshBuildQPFromEdge2(typeOfSon,tmpConn2,coords,m));
INTERP_KERNEL::EdgeIntersector *eint(INTERP_KERNEL::Edge::BuildIntersectorWith(e,eCand));
- bool isColinear=eint->areColinears();
+ bool const isColinear=eint->areColinears();
if(isColinear)
{
nbOfHit++;
{
cm.fillSonCellNodalConnectivity2(j,connBg+1,ToIdType(sz),tmpConn2,typeOfSon); // get edge #j's connectivity
// Identify common point:
- mcIdType commPoint = std::find((mcIdType *)tmpConn, tmpConn+2, tmpConn2[0]) != tmpConn+2 ? tmpConn2[0] : tmpConn2[1];
+ mcIdType const commPoint = std::find((mcIdType *)tmpConn, tmpConn+2, tmpConn2[0]) != tmpConn+2 ? tmpConn2[0] : tmpConn2[1];
auto itE(forbiddenPoints.end());
if (forbiddenPoints.find(commPoint) != itE) // is the junction point in the list of points we can not remove?
break;
INTERP_KERNEL::Edge *eCand(MEDCouplingUMeshBuildQPFromEdge2(typeOfSon,tmpConn2,coords,m));
INTERP_KERNEL::EdgeIntersector *eint(INTERP_KERNEL::Edge::BuildIntersectorWith(e,eCand));
- bool isColinear(eint->areColinears());
+ bool const isColinear(eint->areColinears());
if(isColinear)
{
nbOfHit++;
{
if(candidates.empty())
return false;
- for(std::vector<mcIdType>::const_iterator it=candidates.begin();it!=candidates.end();it++)
+ for(long const candidate : candidates)
{
- const std::vector<mcIdType>& pool(intersectEdge1[*it]);
+ const std::vector<mcIdType>& pool(intersectEdge1[candidate]);
mcIdType tmp[2]; tmp[0]=start; tmp[1]=stop;
if(std::search(pool.begin(),pool.end(),tmp,tmp+2)!=pool.end())
{
- retVal=*it+1;
+ retVal=candidate+1;
return true;
}
tmp[0]=stop; tmp[1]=start;
if(std::search(pool.begin(),pool.end(),tmp,tmp+2)!=pool.end())
{
- retVal=-*it-1;
+ retVal=-candidate-1;
return true;
}
}
const std::vector<double>& addCoo,
const std::vector< std::vector<mcIdType> >& subDiv, std::vector< std::vector<mcIdType> >& intersectEdge)
{
- mcIdType offset1=m1->getNumberOfNodes();
- mcIdType ncell2=m2->getNumberOfCells();
+ mcIdType const offset1=m1->getNumberOfNodes();
+ mcIdType const ncell2=m2->getNumberOfCells();
const mcIdType *c=m2->getNodalConnectivity()->begin();
const mcIdType *cI=m2->getNodalConnectivityIndex()->begin();
const double *coo=m2->getCoords()->begin();
const double *cooBis=m1->getCoords()->begin();
- mcIdType offset2=offset1+m2->getNumberOfNodes();
+ mcIdType const offset2=offset1+m2->getNumberOfNodes();
intersectEdge.resize(ncell2);
for(mcIdType i=0;i<ncell2;i++,cI++)
{
const std::vector<mcIdType>& divs=subDiv[i];
- mcIdType nnode=cI[1]-cI[0]-1;
+ mcIdType const nnode=cI[1]-cI[0]-1;
std::map<mcIdType, INTERP_KERNEL::NodeWithUsage > mapp2;
std::map<INTERP_KERNEL::Node *, mcIdType> mapp22;
for(mcIdType j=0;j<nnode;j++)
{
- INTERP_KERNEL::Node *nn=new INTERP_KERNEL::Node(coo[2*c[(*cI)+j+1]],coo[2*c[(*cI)+j+1]+1]);
- mcIdType nnid=c[(*cI)+j+1];
+ auto *nn=new INTERP_KERNEL::Node(coo[2*c[(*cI)+j+1]],coo[2*c[(*cI)+j+1]+1]);
+ mcIdType const nnid=c[(*cI)+j+1];
mapp2[nnid]=INTERP_KERNEL::NodeWithUsage(nn,INTERP_KERNEL::USAGE_UNKNOWN);
mapp22[nn]=nnid+offset1;
}
std::map<INTERP_KERNEL::Node *,mcIdType> mapp3;
for(std::size_t j=0;j<divs.size();j++)
{
- mcIdType id=divs[j];
- INTERP_KERNEL::Node *tmp=0;
+ mcIdType const id=divs[j];
+ INTERP_KERNEL::Node *tmp=nullptr;
if(id<offset1)
tmp=new INTERP_KERNEL::Node(cooBis[2*id],cooBis[2*id+1]);
else if(id<offset2)
mapp3[tmp]=id;
}
e->sortIdsAbs(addNodes,mapp22,mapp3,intersectEdge[i]);
- for(std::vector<INTERP_KERNEL::Node *>::const_iterator it=addNodes.begin();it!=addNodes.end();it++)
- (*it)->decrRef();
+ for(auto addNode : addNodes)
+ addNode->decrRef();
e->decrRef();
}
}
{
idsInRetColinear=DataArrayIdType::New(); idsInRetColinear->alloc(0,1);
idsInMesh1DForIdsInRetColinear=DataArrayIdType::New(); idsInMesh1DForIdsInRetColinear->alloc(0,1);
- mcIdType nCells=mesh1D->getNumberOfCells();
+ mcIdType const nCells=mesh1D->getNumberOfCells();
if(nCells!=ToIdType(intersectEdge2.size()))
throw INTERP_KERNEL::Exception("BuildMesh1DCutFrom : internal error # 1 !");
const DataArrayDouble *coo2(mesh1D->getCoords());
const mcIdType *c(mesh1D->getNodalConnectivity()->begin()),*ci(mesh1D->getNodalConnectivityIndex()->begin());
const double *coo2Ptr(coo2->begin());
- mcIdType offset1(coords1->getNumberOfTuples());
- mcIdType offset2(offset1+coo2->getNumberOfTuples());
- mcIdType offset3(offset2+ToIdType(addCoo.size())/2);
+ mcIdType const offset1(coords1->getNumberOfTuples());
+ mcIdType const offset2(offset1+coo2->getNumberOfTuples());
+ mcIdType const offset3(offset2+ToIdType(addCoo.size())/2);
std::vector<double> addCooQuad;
MCAuto<DataArrayIdType> cOut(DataArrayIdType::New()),ciOut(DataArrayIdType::New()); cOut->alloc(0,1); ciOut->alloc(1,1); ciOut->setIJ(0,0,0);
mcIdType tmp[4],cicnt(0),kk(0);
std::map<MCAuto<INTERP_KERNEL::Node>,mcIdType> m;
INTERP_KERNEL::Edge *e(MEDCouplingUMeshBuildQPFromEdge2((INTERP_KERNEL::NormalizedCellType)c[ci[i]],c+ci[i]+1,coo2Ptr,m));
const std::vector<mcIdType>& subEdges(intersectEdge2[i]);
- mcIdType nbSubEdge=ToIdType(subEdges.size()/2);
+ mcIdType const nbSubEdge=ToIdType(subEdges.size()/2);
for(mcIdType j=0;j<nbSubEdge;j++,kk++)
{
MCAuto<INTERP_KERNEL::Node> n1(MEDCouplingUMeshBuildQPNode(subEdges[2*j],coords1->begin(),offset1,coo2Ptr,offset2,addCoo)),
else
allEdges.insert(allEdges.end(),edge1.rbegin(),edge1.rend());
}
- std::size_t nb(allEdges.size());
+ std::size_t const nb(allEdges.size());
if(nb%2!=0)
throw INTERP_KERNEL::Exception("BuildRefined2DCellLinear : internal error 1 !");
- std::size_t nbOfEdgesOf2DCellSplit(nb/2);
+ std::size_t const nbOfEdgesOf2DCellSplit(nb/2);
MCAuto<MEDCouplingUMesh> ret(MEDCouplingUMesh::New("",2));
ret->setCoords(coords);
ret->allocateCells(1);
const mcIdType *c(mesh2D->getNodalConnectivity()->begin()),*ci(mesh2D->getNodalConnectivityIndex()->begin());
const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)c[ci[cellIdInMesh2D]]));
int ii(0);
- unsigned sz(cm.getNumberOfSons2(c+ci[cellIdInMesh2D]+1,ci[cellIdInMesh2D+1]-ci[cellIdInMesh2D]-1));
+ unsigned const sz(cm.getNumberOfSons2(c+ci[cellIdInMesh2D]+1,ci[cellIdInMesh2D+1]-ci[cellIdInMesh2D]-1));
if(sz!=std::distance(descBg,descEnd))
throw INTERP_KERNEL::Exception("BuildRefined2DCellQuadratic : internal error 1 !");
INTERP_KERNEL::AutoPtr<mcIdType> tmpPtr(new mcIdType[ci[cellIdInMesh2D+1]-ci[cellIdInMesh2D]]);
std::vector<mcIdType> allEdges,centers;
const double *coordsPtr(coords->begin());
MCAuto<DataArrayDouble> addCoo(DataArrayDouble::New()); addCoo->alloc(0,1);
- mcIdType offset(coords->getNumberOfTuples());
+ mcIdType const offset(coords->getNumberOfTuples());
for(const mcIdType *it2(descBg);it2!=descEnd;it2++,ii++)
{
INTERP_KERNEL::NormalizedCellType typeOfSon;
centers.push_back(tmpPtr[2]);//special case where no subsplit of edge -> reuse the original center.
else
{//the current edge has been subsplit -> create corresponding centers.
- mcIdType nbOfCentersToAppend=ToIdType(edge1.size()/2);
+ mcIdType const nbOfCentersToAppend=ToIdType(edge1.size()/2);
std::map< MCAuto<INTERP_KERNEL::Node>,mcIdType> m;
MCAuto<INTERP_KERNEL::Edge> ee(MEDCouplingUMeshBuildQPFromEdge2(typeOfSon,tmpPtr,coordsPtr,m));
std::vector<mcIdType>::const_iterator it3(allEdges.end()-edge1.size());
}
}
}
- std::size_t nb(allEdges.size());
+ std::size_t const nb(allEdges.size());
if(nb%2!=0)
throw INTERP_KERNEL::Exception("BuildRefined2DCellQuadratic : internal error 2 !");
- std::size_t nbOfEdgesOf2DCellSplit(nb/2);
+ std::size_t const nbOfEdgesOf2DCellSplit(nb/2);
MCAuto<MEDCouplingUMesh> ret(MEDCouplingUMesh::New("",2));
if(addCoo->empty())
ret->setCoords(coords);
void AddCellInMesh2D(MEDCouplingUMesh *mesh2D, const std::vector<mcIdType>& conn, const std::vector< MCAuto<INTERP_KERNEL::Edge> >& edges)
{
bool isQuad(false);
- for(std::vector< MCAuto<INTERP_KERNEL::Edge> >::const_iterator it=edges.begin();it!=edges.end();it++)
+ for(const auto & edge : edges)
{
- const INTERP_KERNEL::Edge *ee(*it);
+ const INTERP_KERNEL::Edge *ee(edge);
if(dynamic_cast<const INTERP_KERNEL::EdgeArcCircle *>(ee))
isQuad=true;
}
else
{
const double *coo(mesh2D->getCoords()->begin());
- std::size_t sz(conn.size());
+ std::size_t const sz(conn.size());
std::vector<double> addCoo;
std::vector<mcIdType> conn2(conn);
- mcIdType offset(mesh2D->getNumberOfNodes());
+ mcIdType const offset(mesh2D->getNumberOfNodes());
for(std::size_t i=0;i<sz;i++)
{
double tmp[2];
void BuildMesh2DCutInternal2(const MEDCouplingUMesh *splitMesh1D, const std::vector<mcIdType>& edge1Bis, const std::vector< MCAuto<INTERP_KERNEL::Edge> >& edge1BisPtr,
std::vector< std::vector<mcIdType> >& out0, std::vector< std::vector< MCAuto<INTERP_KERNEL::Edge> > >& out1)
{
- std::size_t nb(edge1Bis.size()/2);
- std::size_t nbOfEdgesOf2DCellSplit(nb/2);
- mcIdType iEnd=splitMesh1D->getNumberOfCells();
+ std::size_t const nb(edge1Bis.size()/2);
+ std::size_t const nbOfEdgesOf2DCellSplit(nb/2);
+ mcIdType const iEnd=splitMesh1D->getNumberOfCells();
if(iEnd==0)
throw INTERP_KERNEL::Exception("BuildMesh2DCutInternal2 : internal error ! input 1D mesh must have at least one cell !");
std::size_t ii,jj;
for(mcIdType ik=0;ik<iEnd;ik++)
{
std::map< MCAuto<INTERP_KERNEL::Node>,mcIdType> m;
- MCAuto<INTERP_KERNEL::Edge> ee(MEDCouplingUMeshBuildQPFromEdge2((INTERP_KERNEL::NormalizedCellType)cSplitPtr[ciSplitPtr[ik]],cSplitPtr+ciSplitPtr[ik]+1,splitMesh1D->getCoords()->begin(),m));
+ MCAuto<INTERP_KERNEL::Edge> const ee(MEDCouplingUMeshBuildQPFromEdge2((INTERP_KERNEL::NormalizedCellType)cSplitPtr[ciSplitPtr[ik]],cSplitPtr+ciSplitPtr[ik]+1,splitMesh1D->getCoords()->begin(),m));
ees[ik]=ee;
}
for(mcIdType ik=iEnd-1;ik>=0;ik--)
struct CellInfo
{
public:
- CellInfo() { }
+ CellInfo() = default;
CellInfo(const std::vector<mcIdType>& edges, const std::vector< MCAuto<INTERP_KERNEL::Edge> >& edgesPtr);
public:
std::vector<mcIdType> _edges;
CellInfo::CellInfo(const std::vector<mcIdType>& edges, const std::vector< MCAuto<INTERP_KERNEL::Edge> >& edgesPtr)
{
- std::size_t nbe(edges.size());
+ std::size_t const nbe(edges.size());
std::vector<mcIdType> edges2(2*nbe); std::vector< MCAuto<INTERP_KERNEL::Edge> > edgesPtr2(2*nbe);
for(std::size_t i=0;i<nbe;i++)
{
else
{
MCAuto<DataArrayDouble> barys(mesh->computeCellCenterOfMass());
- mcIdType cellId(mesh2D->getCellContainingPoint(barys->begin(),eps));
+ mcIdType const cellId(mesh2D->getCellContainingPoint(barys->begin(),eps));
if(cellId==-1)
throw INTERP_KERNEL::Exception("EdgeInfo::feedEdgeInfoAt : internal error !");
neighbors[0]=offset+cellId; neighbors[1]=offset+cellId;
const std::vector< std::vector< MCAuto<INTERP_KERNEL::Edge> > >& edgePtrs)
{
get(pos);//to check pos
- bool isFast(pos==0 && _pool.size()==1);
- std::size_t sz(edges.size());
+ bool const isFast(pos==0 && _pool.size()==1);
+ std::size_t const sz(edges.size());
// dealing with edges
if(sz==1)
_edge_info.push_back(EdgeInfo(istart,iend,mesh1DInCase));
std::vector< MCAuto<MEDCouplingUMesh> > ms;
if(pos>0)
{
- MCAuto<MEDCouplingUMesh> elt(static_cast<MEDCouplingUMesh *>(_ze_mesh->buildPartOfMySelfSlice(0,pos,true)));
+ MCAuto<MEDCouplingUMesh> const elt(static_cast<MEDCouplingUMesh *>(_ze_mesh->buildPartOfMySelfSlice(0,pos,true)));
ms.push_back(elt);
}
ms.push_back(mesh);
if(pos<_ze_mesh->getNumberOfCells()-1)
{
- MCAuto<MEDCouplingUMesh> elt(static_cast<MEDCouplingUMesh *>(_ze_mesh->buildPartOfMySelfSlice(pos+1,_ze_mesh->getNumberOfCells(),true)));
+ MCAuto<MEDCouplingUMesh> const elt(static_cast<MEDCouplingUMesh *>(_ze_mesh->buildPartOfMySelfSlice(pos+1,_ze_mesh->getNumberOfCells(),true)));
ms.push_back(elt);
}
std::vector< const MEDCouplingUMesh *> ms2(ms.size());
if(pos<0)
throw INTERP_KERNEL::Exception("VectorOfCellInfo::getZePosOfEdgeGivenItsGlobalId : invalid id ! Must be >=0 !");
mcIdType ret(0);
- for(std::vector<EdgeInfo>::const_iterator it=_edge_info.begin();it!=_edge_info.end();it++,ret++)
+ for(auto it=_edge_info.begin();it!=_edge_info.end();it++,ret++)
{
if((*it).isInMyRange(pos))
return ret;
get(pos);//to perform the sanity check;
if(_edge_info.empty())
return ;
- std::size_t sz(_edge_info.size()-1);
+ std::size_t const sz(_edge_info.size()-1);
for(std::size_t i=0;i<sz;i++)
_edge_info[i].somethingHappendAt(pos,newLeft,newRight);
}
MEDCouplingUMesh *BuildMesh2DCutInternal(double eps, MEDCouplingUMesh *splitMesh1D, const std::vector<mcIdType>& allEdges, const std::vector< MCAuto<INTERP_KERNEL::Edge> >& allEdgesPtr, mcIdType offset,
MCAuto<DataArrayIdType>& idsLeftRight)
{
- mcIdType nbCellsInSplitMesh1D=splitMesh1D->getNumberOfCells();
+ mcIdType const nbCellsInSplitMesh1D=splitMesh1D->getNumberOfCells();
if(nbCellsInSplitMesh1D==0)
throw INTERP_KERNEL::Exception("BuildMesh2DCutInternal : internal error ! input 1D mesh must have at least one cell !");
const mcIdType *cSplitPtr(splitMesh1D->getNodalConnectivity()->begin()),*ciSplitPtr(splitMesh1D->getNodalConnectivityIndex()->begin());
iEnd++;
MCAuto<MEDCouplingUMesh> partOfSplitMesh1D(static_cast<MEDCouplingUMesh *>(splitMesh1D->buildPartOfMySelfSlice(iStart,iEnd,1,true)));
- mcIdType pos(pool.getPositionOf(eps,partOfSplitMesh1D));
+ mcIdType const pos(pool.getPositionOf(eps,partOfSplitMesh1D));
//
MCAuto<MEDCouplingUMesh>retTmp(MEDCouplingUMesh::New("",2));
retTmp->setCoords(splitMesh1D->getCoords());
/*
* splitMesh1D is an input parameter but might have its cells renumbered.
*/
-MEDCouplingUMesh *BuildMesh2DCutFrom(double eps, mcIdType cellIdInMesh2D, const MEDCouplingUMesh *mesh2DDesc, MEDCouplingUMesh *splitMesh1D,
+MEDCouplingUMesh *BuildMesh2DCutFrom(double eps, mcIdType /*cellIdInMesh2D*/, const MEDCouplingUMesh *mesh2DDesc, MEDCouplingUMesh *splitMesh1D,
const mcIdType *descBg, const mcIdType *descEnd, const std::vector< std::vector<mcIdType> >& intersectEdge1, mcIdType offset,
MCAuto<DataArrayIdType>& idsLeftRight)
{
std::vector< MCAuto<INTERP_KERNEL::Edge> > allEdgesPtr; // for each sub edge in splitMesh2D the uncut Edge object of the original mesh2D
for(const mcIdType *it(descBg);it!=descEnd;it++) // for all edges in the descending connectivity of the 2D mesh in relative Fortran mode
{
- mcIdType edgeId(std::abs(*it)-1);
+ mcIdType const edgeId(std::abs(*it)-1);
std::map< MCAuto<INTERP_KERNEL::Node>,mcIdType> m;
- MCAuto<INTERP_KERNEL::Edge> ee(MEDCouplingUMeshBuildQPFromEdge2((INTERP_KERNEL::NormalizedCellType)cdescPtr[cidescPtr[edgeId]],cdescPtr+cidescPtr[edgeId]+1,mesh2DDesc->getCoords()->begin(),m));
+ MCAuto<INTERP_KERNEL::Edge> const ee(MEDCouplingUMeshBuildQPFromEdge2((INTERP_KERNEL::NormalizedCellType)cdescPtr[cidescPtr[edgeId]],cdescPtr+cidescPtr[edgeId]+1,mesh2DDesc->getCoords()->begin(),m));
const std::vector<mcIdType>& edge1(intersectEdge1[edgeId]);
if(*it>0)
allEdges.insert(allEdges.end(),edge1.begin(),edge1.end());
else
allEdges.insert(allEdges.end(),edge1.rbegin(),edge1.rend());
- std::size_t sz(edge1.size());
+ std::size_t const sz(edge1.size());
for(std::size_t cnt=0;cnt<sz;cnt++)
allEdgesPtr.push_back(ee);
}
}
else if(typ1.isQuadratic() && typ2.isQuadratic())
{
- bool status0(conn1[0]==conn2[0] && conn1[1]==conn2[1]);
+ bool const status0(conn1[0]==conn2[0] && conn1[1]==conn2[1]);
if(!status0)
return false;
if(conn1[2]==conn2[2])
return true;
const double *a(coo2D+2*conn1[2]),*b(coo2D+2*conn2[2]);
- double dist(sqrt((a[0]-b[0])*(a[0]-b[0])+(a[1]-b[1])*(a[1]-b[1])));
+ double const dist(sqrt((a[0]-b[0])*(a[0]-b[0])+(a[1]-b[1])*(a[1]-b[1])));
return dist<eps;
}
else
{//only one is quadratic
- bool status0(conn1[0]==conn2[0] && conn1[1]==conn2[1]);
+ bool const status0(conn1[0]==conn2[0] && conn1[1]==conn2[1]);
if(!status0)
return false;
- const double *a(0),*bb(0),*be(0);
+ const double *a(nullptr),*bb(nullptr),*be(nullptr);
if(typ1.isQuadratic())
{
a=coo2D+2*conn1[2]; bb=coo2D+2*conn2[0]; be=coo2D+2*conn2[1];
a=coo2D+2*conn2[2]; bb=coo2D+2*conn1[0]; be=coo2D+2*conn1[1];
}
double b[2]; b[0]=(be[0]+bb[0])/2.; b[1]=(be[1]+bb[1])/2.;
- double dist(sqrt((a[0]-b[0])*(a[0]-b[0])+(a[1]-b[1])*(a[1]-b[1])));
+ double const dist(sqrt((a[0]-b[0])*(a[0]-b[0])+(a[1]-b[1])*(a[1]-b[1])));
return dist<eps;
}
}
MCAuto<MEDCouplingUMesh> cur2D(static_cast<MEDCouplingUMesh *>(mesh2DSplit->buildPartOfMySelf(it,it+1,true)));
const mcIdType *c(cur2D->getNodalConnectivity()->begin()),*ci(cur2D->getNodalConnectivityIndex()->begin());
const INTERP_KERNEL::CellModel &cm(INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)c[ci[0]]));
- unsigned sz(cm.getNumberOfSons2(c+ci[0]+1,ci[1]-ci[0]-1));
+ unsigned const sz(cm.getNumberOfSons2(c+ci[0]+1,ci[1]-ci[0]-1));
INTERP_KERNEL::AutoPtr<mcIdType> tmpPtr(new mcIdType[ci[1]-ci[0]]);
for(unsigned it2=0;it2<sz;it2++)
{
std::vector< std::vector<mcIdType> >& intersectEdge1, std::vector< std::vector<mcIdType> >& colinear2, std::vector< std::vector<mcIdType> >& subDiv2, std::vector<double>& addCoo, std::map<mcIdType,mcIdType>& mergedNodes)
{
static const int SPACEDIM=2;
- INTERP_KERNEL::QuadraticPlanarPrecision prec(eps);
+ INTERP_KERNEL::QuadraticPlanarPrecision const prec(eps);
const mcIdType *c1(m1Desc->getNodalConnectivity()->begin()),*ci1(m1Desc->getNodalConnectivityIndex()->begin());
// Build BB tree of all edges in the tool mesh (second mesh)
MCAuto<DataArrayDouble> bbox1Arr(m1Desc->getBoundingBoxForBBTree(eps)),bbox2Arr(m2Desc->getBoundingBoxForBBTree(eps));
intersectEdge1.resize(nDescCell1);
colinear2.resize(nDescCell2);
subDiv2.resize(nDescCell2);
- BBTree<SPACEDIM,mcIdType> myTree(bbox2,0,0,m2Desc->getNumberOfCells(),-eps);
- BBTreePts<SPACEDIM,mcIdType> treeNodes2(m2Desc->getCoords()->begin(),0,0,m2Desc->getCoords()->getNumberOfTuples(),eps);
+ BBTree<SPACEDIM,mcIdType> const myTree(bbox2,nullptr,0,m2Desc->getNumberOfCells(),-eps);
+ BBTreePts<SPACEDIM,mcIdType> const treeNodes2(m2Desc->getCoords()->begin(),nullptr,0,m2Desc->getCoords()->getNumberOfTuples(),eps);
std::vector<mcIdType> candidates1(1);
- mcIdType offset1(m1Desc->getNumberOfNodes());
- mcIdType offset2(offset1+m2Desc->getNumberOfNodes());
+ mcIdType const offset1(m1Desc->getNumberOfNodes());
+ mcIdType const offset2(offset1+m2Desc->getNumberOfNodes());
for(mcIdType i=0;i<nDescCell1;i++) // for all edges in the first mesh
{
std::vector<mcIdType> candidates2; // edges of mesh2 candidate for intersection
// This trick guarantees that Node * are discriminant (i.e. form a unique identifier)
std::set<INTERP_KERNEL::Node *> nodes;
pol1->getAllNodes(nodes); pol2->getAllNodes(nodes);
- std::size_t szz(nodes.size());
+ std::size_t const szz(nodes.size());
std::vector< MCAuto<INTERP_KERNEL::Node> > nodesSafe(szz);
- std::set<INTERP_KERNEL::Node *>::const_iterator itt(nodes.begin());
+ auto itt(nodes.begin());
for(std::size_t iii=0;iii<szz;iii++,itt++)
{ (*itt)->incrRef(); nodesSafe[iii]=*itt; }
// end of protection
static const int SPACEDIM=2;
const double *coo1(m1->getCoords()->begin());
const mcIdType *conn1(m1->getNodalConnectivity()->begin()),*connI1(m1->getNodalConnectivityIndex()->begin());
- mcIdType offset1(m1->getNumberOfNodes());
+ mcIdType const offset1(m1->getNumberOfNodes());
const double *coo2(m2->getCoords()->begin());
const mcIdType *conn2(m2->getNodalConnectivity()->begin()),*connI2(m2->getNodalConnectivityIndex()->begin());
- mcIdType offset2(offset1+m2->getNumberOfNodes());
- mcIdType offset3(offset2+ToIdType(addCoords.size())/2);
+ mcIdType const offset2(offset1+m2->getNumberOfNodes());
+ mcIdType const offset3(offset2+ToIdType(addCoords.size())/2);
MCAuto<DataArrayDouble> bbox1Arr(m1->getBoundingBoxForBBTree(eps)),bbox2Arr(m2->getBoundingBoxForBBTree(eps));
const double *bbox1(bbox1Arr->begin()),*bbox2(bbox2Arr->begin());
// Here a BBTree on 2D-cells, not on segments:
- BBTree<SPACEDIM,mcIdType> myTree(bbox2,0,0,m2->getNumberOfCells(),eps);
- mcIdType ncell1=m1->getNumberOfCells();
+ BBTree<SPACEDIM,mcIdType> const myTree(bbox2,nullptr,0,m2->getNumberOfCells(),eps);
+ mcIdType const ncell1=m1->getNumberOfCells();
crI.push_back(0);
for(mcIdType i=0;i<ncell1;i++)
{
std::map<INTERP_KERNEL::Node *,mcIdType> mapp;
std::map<mcIdType,INTERP_KERNEL::Node *> mappRev;
INTERP_KERNEL::QuadraticPolygon pol1;
- INTERP_KERNEL::NormalizedCellType typ=(INTERP_KERNEL::NormalizedCellType)conn1[connI1[i]];
+ auto const typ=(INTERP_KERNEL::NormalizedCellType)conn1[connI1[i]];
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
// Populate mapp and mappRev with nodes from the current cell (i) from mesh1 - this also builds the Node* objects:
MEDCouplingUMeshBuildQPFromMesh3(coo1,offset1,coo2,offset2,addCoords,desc1+descIndx1[i],desc1+descIndx1[i+1],intesctEdges1,/* output */mapp,mappRev);
// Again all the additional intersecting nodes are there.
for(std::vector<mcIdType>::const_iterator it2=candidates2.begin();it2!=candidates2.end();it2++,ii++)
{
- INTERP_KERNEL::NormalizedCellType typ2=(INTERP_KERNEL::NormalizedCellType)conn2[connI2[*it2]];
+ auto const typ2=(INTERP_KERNEL::NormalizedCellType)conn2[connI2[*it2]];
const INTERP_KERNEL::CellModel& cm2=INTERP_KERNEL::CellModel::GetCellModel(typ2);
// Complete mapping with elements coming from the current cell it2 in mesh2:
MEDCouplingUMeshBuildQPFromMesh3(coo1,offset1,coo2,offset2,addCoords,desc2+descIndx2[*it2],desc2+descIndx2[*it2+1],intesctEdges2,/* output */mapp,mappRev);
void InsertNodeInConnIfNecessary(mcIdType nodeIdToInsert, std::vector<mcIdType>& conn, const double *coords, double eps)
{
- std::vector<mcIdType>::iterator it(std::find(conn.begin(),conn.end(),nodeIdToInsert));
+ auto const it(std::find(conn.begin(),conn.end(),nodeIdToInsert));
if(it!=conn.end())
return ;
- std::size_t sz(conn.size());
+ std::size_t const sz(conn.size());
std::size_t found(std::numeric_limits<std::size_t>::max());
for(std::size_t i=0;i<sz;i++)
{
mcIdType pt0(conn[i]),pt1(conn[(i+1)%sz]);
double v1[3]={coords[3*pt1+0]-coords[3*pt0+0],coords[3*pt1+1]-coords[3*pt0+1],coords[3*pt1+2]-coords[3*pt0+2]},v2[3]={coords[3*nodeIdToInsert+0]-coords[3*pt0+0],coords[3*nodeIdToInsert+1]-coords[3*pt0+1],coords[3*nodeIdToInsert+2]-coords[3*pt0+2]};
- double normm(sqrt(v1[0]*v1[0]+v1[1]*v1[1]+v1[2]*v1[2]));
+ double const normm(sqrt(v1[0]*v1[0]+v1[1]*v1[1]+v1[2]*v1[2]));
std::transform(v1,v1+3,v1,std::bind(std::multiplies<double>(),std::placeholders::_1,1./normm));
std::transform(v2,v2+3,v2,std::bind(std::multiplies<double>(),std::placeholders::_1,1./normm));
double v3[3];
void SplitIntoToPart(const std::vector<mcIdType>& conn, mcIdType pt0, mcIdType pt1, std::vector<mcIdType>& part0, std::vector<mcIdType>& part1)
{
- std::size_t sz(conn.size());
+ std::size_t const sz(conn.size());
std::vector<mcIdType> *curPart(&part0);
for(std::size_t i=0;i<sz;i++)
{
- mcIdType nextt(conn[(i+1)%sz]);
+ mcIdType const nextt(conn[(i+1)%sz]);
(*curPart).push_back(nextt);
if(nextt==pt0 || nextt==pt1)
{
if(getMeshDimension()!=3 || getSpaceDimension()!=3)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSubCellsFromCut works on umeshes with meshdim equal to 3 and spaceDim equal to 3 too!");
const mcIdType *nodal3D(_nodal_connec->begin()),*nodalIndx3D(_nodal_connec_index->begin());
- mcIdType nbOfCells=getNumberOfCells();
+ mcIdType const nbOfCells=getNumberOfCells();
if(nbOfCells!=1)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSubCellsFromCut works only with single cell presently !");
for(mcIdType i=0;i<nbOfCells;i++)
{
const std::pair<mcIdType,mcIdType>& p=cut3DSurf[desc[offset+j]];
const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)nodal3D[nodalIndx3D[i]]));
- mcIdType sz=nodalIndx3D[i+1]-nodalIndx3D[i]-1;
+ mcIdType const sz=nodalIndx3D[i+1]-nodalIndx3D[i]-1;
INTERP_KERNEL::AutoPtr<mcIdType> tmp(new mcIdType[sz]);
INTERP_KERNEL::NormalizedCellType cmsId;
- unsigned nbOfNodesSon(cm.fillSonCellNodalConnectivity2(j,nodal3D+nodalIndx3D[i]+1,sz,tmp,cmsId));
+ unsigned const nbOfNodesSon(cm.fillSonCellNodalConnectivity2(j,nodal3D+nodalIndx3D[i]+1,sz,tmp,cmsId));
std::vector<mcIdType> elt((mcIdType *)tmp,(mcIdType *)tmp+nbOfNodesSon);
if(p.first!=-1 && p.second!=-1)
{
void MEDCouplingUMesh::split2DCellsLinear(const DataArrayIdType *desc, const DataArrayIdType *descI, const DataArrayIdType *subNodesInSeg, const DataArrayIdType *subNodesInSegI)
{
checkConnectivityFullyDefined();
- mcIdType ncells=getNumberOfCells();
- mcIdType lgthToReach(getNodalConnectivityArrayLen()+subNodesInSeg->getNumberOfTuples());
+ mcIdType const ncells=getNumberOfCells();
+ mcIdType const lgthToReach(getNodalConnectivityArrayLen()+subNodesInSeg->getNumberOfTuples());
MCAuto<DataArrayIdType> c(DataArrayIdType::New()); c->alloc((std::size_t)lgthToReach);
const mcIdType *subPtr(subNodesInSeg->begin()),*subIPtr(subNodesInSegI->begin()),*descPtr(desc->begin()),*descIPtr(descI->begin()),*oldConn(getNodalConnectivity()->begin());
mcIdType *cPtr(c->getPointer()),*ciPtr(getNodalConnectivityIndex()->getPointer());
mcIdType MEDCouplingUMesh::split2DCellsQuadratic(const DataArrayIdType *desc, const DataArrayIdType *descI, const DataArrayIdType *subNodesInSeg, const DataArrayIdType *subNodesInSegI, const DataArrayIdType *mid, const DataArrayIdType *midI)
{
checkConsistencyLight();
- mcIdType ncells=getNumberOfCells();
- mcIdType lgthToReach(getNodalConnectivityArrayLen()+2*subNodesInSeg->getNumberOfTuples());
+ mcIdType const ncells=getNumberOfCells();
+ mcIdType const lgthToReach(getNodalConnectivityArrayLen()+2*subNodesInSeg->getNumberOfTuples());
mcIdType nodesCnt(getNumberOfNodes());
MCAuto<DataArrayIdType> c(DataArrayIdType::New()); c->alloc((std::size_t)lgthToReach);
MCAuto<DataArrayDouble> addCoo(DataArrayDouble::New()); addCoo->alloc(0,1);
{
mcIdType offset(descIPtr[0]),sz(descIPtr[1]-descIPtr[0]),deltaSz(sz);
for(mcIdType j=0;j<sz;j++)
- { mcIdType sz2(subIPtr[descPtr[offset+j]+1]-subIPtr[descPtr[offset+j]]); deltaSz+=sz2; }
+ { mcIdType const sz2(subIPtr[descPtr[offset+j]+1]-subIPtr[descPtr[offset+j]]); deltaSz+=sz2; }
*cPtr++=ToIdType(INTERP_KERNEL::NORM_QPOLYG); cPtr[0]=oldConn[prevPosOfCi+1];
for(mcIdType j=0;j<sz;j++)//loop over subedges of oldConn
{
cPtr[1]=subPtr[offset2+k];
cPtr[deltaSz]=InternalAddPoint(e,midPtr[offset3+k],oldCoordsPtr,cPtr[0],cPtr[1],*addCoo,nodesCnt); cPtr++;
}
- mcIdType tmpEnd(oldConn[prevPosOfCi+1+(j+1)%sz]);
+ mcIdType const tmpEnd(oldConn[prevPosOfCi+1+(j+1)%sz]);
if(j!=sz-1)
{ cPtr[1]=tmpEnd; }
cPtr[deltaSz]=InternalAddPoint(e,midPtr[offset3+sz2],oldCoordsPtr,cPtr[0],tmpEnd,*addCoo,nodesCnt); cPtr++;
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::Intersect2DMeshes : input meshes must be not NULL !");
m1->checkFullyDefined();
m2->checkFullyDefined();
- INTERP_KERNEL::QuadraticPlanarPrecision prec(eps);
+ INTERP_KERNEL::QuadraticPlanarPrecision const prec(eps);
if(m1->getMeshDimension()!=2 || m1->getSpaceDimension()!=2 || m2->getMeshDimension()!=2 || m2->getSpaceDimension()!=2)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::Intersect2DMeshes works on umeshes m1 AND m2 with meshdim equal to 2 and spaceDim equal to 2 too!");
// Step 1: compute all edge intersections (new nodes)
std::vector< std::vector<mcIdType> > intersectEdge1, colinear2, subDiv2;
- MEDCouplingUMesh *m1Desc=0,*m2Desc=0; // descending connec. meshes
- DataArrayIdType *desc1=0,*descIndx1=0,*revDesc1=0,*revDescIndx1=0,*desc2=0,*descIndx2=0,*revDesc2=0,*revDescIndx2=0;
+ MEDCouplingUMesh *m1Desc=nullptr,*m2Desc=nullptr; // descending connec. meshes
+ DataArrayIdType *desc1=nullptr,*descIndx1=nullptr,*revDesc1=nullptr,*revDescIndx1=nullptr,*desc2=nullptr,*descIndx2=nullptr,*revDesc2=nullptr,*revDescIndx2=nullptr;
std::vector<double> addCoo,addCoordsQuadratic; // coordinates of newly created nodes
IntersectDescending2DMeshes(m1,m2,eps,intersectEdge1,colinear2, subDiv2,
m1Desc,desc1,descIndx1,revDesc1,revDescIndx1,
// Step 2: re-order newly created nodes according to the ordering found in m2
std::vector< std::vector<mcIdType> > intersectEdge2;
BuildIntersectEdges(m1Desc,m2Desc,addCoo,subDiv2,intersectEdge2);
- subDiv2.clear(); dd5=0; dd6=0;
+ subDiv2.clear(); dd5=nullptr; dd6=nullptr;
// Step 3:
std::vector<mcIdType> cr,crI; //no DataArrayIdType because interface with Geometric2D
// Step 1: compute all edge intersections (new nodes)
std::vector< std::vector<mcIdType> > intersectEdge1, colinear2, subDiv2;
std::vector<double> addCoo,addCoordsQuadratic; // coordinates of newly created nodes
- INTERP_KERNEL::QuadraticPlanarPrecision prec(eps);
+ INTERP_KERNEL::QuadraticPlanarPrecision const prec(eps);
//
// Build desc connectivity
DataArrayIdType *desc1(DataArrayIdType::New()),*descIndx1(DataArrayIdType::New()),*revDesc1(DataArrayIdType::New()),*revDescIndx1(DataArrayIdType::New());
std::map<mcIdType,mcIdType> mergedNodes;
Intersect1DMeshes(m1Desc,mesh1D,eps,intersectEdge1,colinear2,subDiv2,addCoo,mergedNodes);
// use mergeNodes to fix intersectEdge1
- for(std::vector< std::vector<mcIdType> >::iterator it0=intersectEdge1.begin();it0!=intersectEdge1.end();it0++)
+ for(auto & it0 : intersectEdge1)
{
- std::size_t n((*it0).size()/2);
- mcIdType eltStart((*it0)[0]),eltEnd((*it0)[2*n-1]);
+ std::size_t const n(it0.size()/2);
+ mcIdType eltStart(it0[0]),eltEnd(it0[2*n-1]);
std::map<mcIdType,mcIdType>::const_iterator it1;
it1=mergedNodes.find(eltStart);
if(it1!=mergedNodes.end())
- (*it0)[0]=(*it1).second;
+ it0[0]=(*it1).second;
it1=mergedNodes.find(eltEnd);
if(it1!=mergedNodes.end())
- (*it0)[2*n-1]=(*it1).second;
+ it0[2*n-1]=(*it1).second;
}
//
MCAuto<DataArrayDouble> addCooDa(DataArrayDouble::New());
const mcIdType* cellId1 = cells->begin() + cellsIndex->begin()[*it];
const mcIdType* cellId2 = cells->begin() + cellsIndex->begin()[*it]+1;
- std::set<mcIdType> s1(realIdsInDesc2D->begin()+dd2->begin()[*cellId1], realIdsInDesc2D->begin()+dd2->begin()[*cellId1+1]);
- std::set<mcIdType> s2(realIdsInDesc2D->begin()+dd2->begin()[*cellId2], realIdsInDesc2D->begin()+dd2->begin()[*cellId2+1]);
+ std::set<mcIdType> const s1(realIdsInDesc2D->begin()+dd2->begin()[*cellId1], realIdsInDesc2D->begin()+dd2->begin()[*cellId1+1]);
+ std::set<mcIdType> const s2(realIdsInDesc2D->begin()+dd2->begin()[*cellId2], realIdsInDesc2D->begin()+dd2->begin()[*cellId2+1]);
std::vector<mcIdType> commonEdgeId;
std::set_intersection(s1.begin(),s1.end(),s2.begin(),s2.end(), std::back_inserter(commonEdgeId));
MCAuto<DataArrayIdType> out0s;//ids in mesh2D that are impacted by the fact that some edges of \a mesh1D are part of the edges of those cells
if(!idsInDesc2DToBeRefined->empty())
{
- DataArrayIdType *out0(0),*outi0(0);
+ DataArrayIdType *out0(nullptr),*outi0(nullptr);
DataArrayIdType::ExtractFromIndexedArrays(idsInDesc2DToBeRefined->begin(),idsInDesc2DToBeRefined->end(),dd3,dd4,out0,outi0);
- MCAuto<DataArrayIdType> outi0s(outi0);
+ MCAuto<DataArrayIdType> const outi0s(outi0);
out0s=out0;
out0s=out0s->buildUnique();
out0s->sort(true);
}
//
MCAuto<MEDCouplingUMesh> ret1NonCol(static_cast<MEDCouplingUMesh *>(ret1->buildPartOfMySelf(idsInRet1NotColinear->begin(),idsInRet1NotColinear->end())));
- MCAuto<DataArrayDouble> baryRet1(centerOfMassRet1->selectByTupleId(idsInRet1NotColinear->begin(), idsInRet1NotColinear->end()));
- DataArrayIdType *out(0),*outi(0);
+ MCAuto<DataArrayDouble> const baryRet1(centerOfMassRet1->selectByTupleId(idsInRet1NotColinear->begin(), idsInRet1NotColinear->end()));
+ DataArrayIdType *out(nullptr),*outi(nullptr);
DataArrayIdType::ExtractFromIndexedArrays(idsInRet1NotColinear->begin(),idsInRet1NotColinear->end(),cells,cellsIndex,out,outi);
MCAuto<DataArrayIdType> elts(out),eltsIndex(outi);
{// here dealing with cells in out0s but not in cellsToBeModified
MCAuto<DataArrayIdType> fewModifiedCells(out0s->buildSubstraction(cellsToBeModified));
const mcIdType *rdptr(dd3->begin()),*rdiptr(dd4->begin()),*dptr(dd1->begin()),*diptr(dd2->begin());
- for(const mcIdType *it=fewModifiedCells->begin();it!=fewModifiedCells->end();it++)
+ for(long const it : *fewModifiedCells)
{
- outMesh2DSplit.push_back(BuildRefined2DCell(ret1->getCoords(),mesh2D,*it,dptr+diptr[*it],dptr+diptr[*it+1],intersectEdge1));
+ outMesh2DSplit.push_back(BuildRefined2DCell(ret1->getCoords(),mesh2D,it,dptr+diptr[it],dptr+diptr[it+1],intersectEdge1));
ret1->setCoords(outMesh2DSplit.back()->getCoords());
}
- mcIdType offset(ret2->getNumberOfTuples());
+ mcIdType const offset(ret2->getNumberOfTuples());
ret2->pushBackValsSilent(fewModifiedCells->begin(),fewModifiedCells->end());
MCAuto<DataArrayIdType> partOfRet3(DataArrayIdType::New()); partOfRet3->alloc(2*idsInRet1Colinear->getNumberOfTuples(),1);
partOfRet3->fillWithValue(std::numeric_limits<mcIdType>::max()); partOfRet3->rearrange(2);
mcIdType kk(0),*ret3ptr(partOfRet3->getPointer());
for(const mcIdType *it=idsInDescMesh2DForIdsInRetColinear->begin();it!=idsInDescMesh2DForIdsInRetColinear->end();it++,kk++)
{
- mcIdType faceId(std::abs(*it)-1);
+ mcIdType const faceId(std::abs(*it)-1);
for(const mcIdType *it2=rdptr+rdiptr[faceId];it2!=rdptr+rdiptr[faceId+1];it2++)
{
- mcIdType tmp(fewModifiedCells->findIdFirstEqual(*it2));
+ mcIdType const tmp(fewModifiedCells->findIdFirstEqual(*it2));
if(tmp!=-1)
{
if(std::find(dptr+diptr[*it2],dptr+diptr[*it2+1],-(*it))!=dptr+diptr[*it2+1])
if(!outMesh2DSplit.empty())
{
DataArrayDouble *da(outMesh2DSplit.back()->getCoords());
- for(std::vector< MCAuto<MEDCouplingUMesh> >::iterator itt=outMesh2DSplit.begin();itt!=outMesh2DSplit.end();itt++)
- (*itt)->setCoords(da);
+ for(auto & itt : outMesh2DSplit)
+ itt->setCoords(da);
}
}
cellsToBeModified=cellsToBeModified->buildUniqueNotSorted();
ret2->pushBackSilent(*it);
}
//
- std::size_t nbOfMeshes(outMesh2DSplit.size());
+ std::size_t const nbOfMeshes(outMesh2DSplit.size());
std::vector<const MEDCouplingUMesh *> tmp(nbOfMeshes);
for(std::size_t i=0;i<nbOfMeshes;i++)
tmp[i]=outMesh2DSplit[i];
MCAuto<DataArrayIdType> edgesToDealWith(ret3->findIdsStrictlyNegative());
for(const mcIdType *it=edgesToDealWith->begin();it!=edgesToDealWith->end();it++)
{
- mcIdType old2DCellId(-ret3->getIJ(*it,0)-1);
+ mcIdType const old2DCellId(-ret3->getIJ(*it,0)-1);
MCAuto<DataArrayIdType> candidates(ret2->findIdsEqual(old2DCellId));
ret3->setIJ(*it,0,FindRightCandidateAmong(ret2D,candidates->begin(),candidates->end(),ret1,*it%2==0?-((*it)/2+1):(*it)/2+1,eps));// div by 2 because 2 components natively in ret3
}
const double *bbox(bboxArr->begin()),*coords(getCoords()->begin());
mcIdType nCell=getNumberOfCells(),nDescCell=mDesc->getNumberOfCells();
std::vector< std::vector<mcIdType> > intersectEdge(nDescCell),overlapEdge(nDescCell);
- std::vector<double> addCoo;
- BBTree<SPACEDIM,mcIdType> myTree(bbox,0,0,nDescCell,-eps);
- INTERP_KERNEL::QuadraticPlanarPrecision prec(eps);
+ std::vector<double> const addCoo;
+ BBTree<SPACEDIM,mcIdType> const myTree(bbox,nullptr,0,nDescCell,-eps);
+ INTERP_KERNEL::QuadraticPlanarPrecision const prec(eps);
for(mcIdType i=0;i<nDescCell;i++)
{
std::vector<mcIdType> candidates;
myTree.getIntersectingElems(bbox+i*2*SPACEDIM,candidates);
- for(std::vector<mcIdType>::const_iterator it=candidates.begin();it!=candidates.end();it++)
- if(*it>i) // we're dealing with pair of edges, no need to treat the same pair twice
+ for(long const candidate : candidates)
+ if(candidate>i) // we're dealing with pair of edges, no need to treat the same pair twice
{
std::map<MCAuto<INTERP_KERNEL::Node>,mcIdType> m;
INTERP_KERNEL::Edge *e1(MEDCouplingUMeshBuildQPFromEdge2((INTERP_KERNEL::NormalizedCellType)c[ci[i]],c+ci[i]+1,coords,m)),
- *e2(MEDCouplingUMeshBuildQPFromEdge2((INTERP_KERNEL::NormalizedCellType)c[ci[*it]],c+ci[*it]+1,coords,m));
+ *e2(MEDCouplingUMeshBuildQPFromEdge2((INTERP_KERNEL::NormalizedCellType)c[ci[candidate]],c+ci[candidate]+1,coords,m));
INTERP_KERNEL::MergePoints merge;
INTERP_KERNEL::QuadraticPolygon c1,c2;
e1->intersectWith(e2,merge,c1,c2);
e1->decrRef(); e2->decrRef();
if(IKGeo2DInternalMapper(c1,m,c[ci[i]+1],c[ci[i]+2],intersectEdge[i]))
- overlapEdge[i].push_back(*it);
- if(IKGeo2DInternalMapper(c2,m,c[ci[*it]+1],c[ci[*it]+2],intersectEdge[*it]))
- overlapEdge[*it].push_back(i);
+ overlapEdge[i].push_back(candidate);
+ if(IKGeo2DInternalMapper(c2,m,c[ci[candidate]+1],c[ci[candidate]+2],intersectEdge[candidate]))
+ overlapEdge[candidate].push_back(i);
}
}
// splitting done. sort intersect point in intersectEdge.
for(mcIdType i=0;i<nDescCell;i++)
{
std::vector<mcIdType>& isect(intersectEdge[i]);
- std::size_t sz(isect.size());
+ std::size_t const sz(isect.size());
if(sz>1)
{
std::map<MCAuto<INTERP_KERNEL::Node>,mcIdType> m;
middleNeedsToBeUsed=true;
const std::vector<mcIdType>& candidates(overlapEdge[i]);
std::vector<mcIdType> trueCandidates;
- for(std::vector<mcIdType>::const_iterator itc=candidates.begin();itc!=candidates.end();itc++)
- if((INTERP_KERNEL::NormalizedCellType)c[ci[*itc]]==INTERP_KERNEL::NORM_SEG3)
- trueCandidates.push_back(*itc);
+ for(long const candidate : candidates)
+ if((INTERP_KERNEL::NormalizedCellType)c[ci[candidate]]==INTERP_KERNEL::NORM_SEG3)
+ trueCandidates.push_back(candidate);
mcIdType stNode(c[ci[i]+1]),endNode(isect[0]);
for(std::size_t j=0;j<sz+1;j++)
{
- for(std::vector<mcIdType>::const_iterator itc=trueCandidates.begin();itc!=trueCandidates.end();itc++)
+ for(long const trueCandidate : trueCandidates)
{
- mcIdType tmpSt(c[ci[*itc]+1]),tmpEnd(c[ci[*itc]+2]);
+ mcIdType tmpSt(c[ci[trueCandidate]+1]),tmpEnd(c[ci[trueCandidate]+2]);
if((tmpSt==stNode && tmpEnd==endNode) || (tmpSt==endNode && tmpEnd==stNode))
- { mid[j]=*itc; break; }
+ { mid[j]=trueCandidate; break; }
}
stNode=endNode;
endNode=j<sz-1?isect[j+1]:c[ci[i]+2];
*retPtr++=i;
//
MCAuto<DataArrayIdType> mSafe,nSafe,oSafe,pSafe,qSafe,rSafe;
- DataArrayIdType *m(0),*n(0),*o(0),*p(0),*q(0),*r(0);
+ DataArrayIdType *m(nullptr),*n(nullptr),*o(nullptr),*p(nullptr),*q(nullptr),*r(nullptr);
DataArrayIdType::ExtractFromIndexedArrays(ret->begin(),ret->end(),desc1,descIndx1,m,n); mSafe=m; nSafe=n;
DataArrayIdType::PutIntoToSkylineFrmt(intersectEdge,o,p); oSafe=o; pSafe=p;
if(middleNeedsToBeUsed)
{ DataArrayIdType::PutIntoToSkylineFrmt(middle,q,r); qSafe=q; rSafe=r; }
MCAuto<MEDCouplingUMesh> modif(static_cast<MEDCouplingUMesh *>(buildPartOfMySelf(ret->begin(),ret->end(),true)));
- mcIdType nbOfNodesCreated(modif->split2DCells(mSafe,nSafe,oSafe,pSafe,qSafe,rSafe));
+ mcIdType const nbOfNodesCreated(modif->split2DCells(mSafe,nSafe,oSafe,pSafe,qSafe,rSafe));
setCoords(modif->getCoords());//if nbOfNodesCreated==0 modif and this have the same coordinates pointer so this line has no effect. But for quadratic cases this line is important.
setPartOfMySelf(ret->begin(),ret->end(),*modif);
{
bool areNodesMerged; mcIdType newNbOfNodes;
if(nbOfNodesCreated!=0)
- MCAuto<DataArrayIdType> tmp(mergeNodes(eps,areNodesMerged,newNbOfNodes));
+ MCAuto<DataArrayIdType> const tmp(mergeNodes(eps,areNodesMerged,newNbOfNodes));
}
return ret.retn();
}
checkConsistencyLight();
if(getSpaceDimension()!=2 || getMeshDimension()!=2)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::colinearize2D : This method only works for meshes with spaceDim=2 and meshDim=2 !");
- INTERP_KERNEL::QuadraticPlanarPrecision prec(eps);
+ INTERP_KERNEL::QuadraticPlanarPrecision const prec(eps);
mcIdType nbOfCells(getNumberOfCells()),nbOfNodes(getNumberOfNodes());
const mcIdType *cptr(_nodal_connec->begin()),*ciptr(_nodal_connec_index->begin());
MCAuto<DataArrayIdType> newc(DataArrayIdType::New()),newci(DataArrayIdType::New()); newci->alloc(nbOfCells+1,1); newc->alloc(0,1); newci->setIJ(0,0,0);
MCAuto<DataArrayIdType> dsi(revDescI2->deltaShiftIndex());
MCAuto<DataArrayIdType> ids(dsi->findIdsGreaterThan(2));
const mcIdType * cPtr(mDesc0D->getNodalConnectivity()->begin());
- for(auto it = ids->begin(); it != ids->end(); it++)
- forbiddenPoints[cPtr[2*(*it)+1]] = true; // we know that a 0D mesh has a connectivity of the form [NORM_POINT1, i1, NORM_POINT1, i2, ...]
+ for(long const it : *ids)
+ forbiddenPoints[cPtr[2*it+1]] = true; // we know that a 0D mesh has a connectivity of the form [NORM_POINT1, i1, NORM_POINT1, i2, ...]
}
MCAuto<DataArrayDouble> appendedCoords(DataArrayDouble::New()); appendedCoords->alloc(0,1);//1 not 2 it is not a bug.
// Keep what is inside [startNode, endNode]:
mcIdType go = 0;
- for (vector<PairDI>::const_iterator it=xx.begin(); it != xx.end(); ++it)
+ for (const auto & it : xx)
{
- const mcIdType idx = (*it).second;
+ const mcIdType idx = it.second;
if (!go)
{
if (idx == startNode) go = 1;
for (const mcIdType * it = idsBg; it != endBg; ++it)
{
mcIdType start = c[cI[*it]+1], end = c[cI[*it]+2];
- vector<mcIdType>::const_iterator itStart = find(pointIds.begin(), pointIds.end(), start);
+ vector<mcIdType>::const_iterator const itStart = find(pointIds.begin(), pointIds.end(), start);
if (itStart == pointIds.end()) continue;
- vector<mcIdType>::const_iterator itEnd = find(pointIds.begin(), pointIds.end(), end);
+ vector<mcIdType>::const_iterator const itEnd = find(pointIds.begin(), pointIds.end(), end);
if (itEnd == pointIds.end()) continue;
if (abs(distance(itEnd, itStart)) != 1) continue;
hitSegs.push_back(*it); // segment is undivided.
const std::vector<mcIdType>& insidePoints, std::vector<mcIdType>& modifiedFace)
{
using namespace std;
- size_t dst = distance(sIdxConn, sIdxConnE);
+ size_t const dst = distance(sIdxConn, sIdxConnE);
modifiedFace.reserve(dst + insidePoints.size()-2);
modifiedFace.resize(dst);
copy(sIdxConn, sIdxConnE, modifiedFace.data());
- vector<mcIdType>::iterator shortEnd = modifiedFace.begin()+dst;
- vector<mcIdType>::iterator startPos = find(modifiedFace.begin(), shortEnd , startNode);
+ auto const shortEnd = modifiedFace.begin()+dst;
+ auto startPos = find(modifiedFace.begin(), shortEnd , startNode);
if (startPos == shortEnd)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ReplaceEdgeInFace: internal error, should never happen!");
- vector<mcIdType>::iterator endPos = find(modifiedFace.begin(),shortEnd, endNode);
+ auto endPos = find(modifiedFace.begin(),shortEnd, endNode);
if (endPos == shortEnd)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ReplaceEdgeInFace: internal error, should never happen!");
- size_t d = distance(startPos, endPos);
+ size_t const d = distance(startPos, endPos);
if (d == 1 || d == (1-dst)) // don't use modulo, for neg numbers, result is implementation defined ...
modifiedFace.insert(++startPos, ++insidePoints.begin(), --insidePoints.end()); // insidePoints also contains start and end node. Those don't need to be inserted.
else
// Build BBTree
MCAuto<DataArrayDouble> bboxArr(mDesc->getBoundingBoxForBBTree(eps));
const double *bbox(bboxArr->begin()); getCoords()->begin();
- mcIdType nDescCell=mDesc->getNumberOfCells();
- BBTree<SPACEDIM,mcIdType> myTree(bbox,0,0,nDescCell,-eps);
+ mcIdType const nDescCell=mDesc->getNumberOfCells();
+ BBTree<SPACEDIM,mcIdType> const myTree(bbox,nullptr,0,nDescCell,-eps);
// Surfaces - handle biggest first
MCAuto<MEDCouplingFieldDouble> surfF = mDesc->getMeasureField(true);
DataArrayDouble * surfs = surfF->getArray();
vector< pair<double,mcIdType> > S;
for(mcIdType i=0;i < surfs->getNumberOfTuples();i++)
{
- pair<double,mcIdType> p = make_pair(surfs->begin()[i], i);
+ pair<double,mcIdType> const p = make_pair(surfs->begin()[i], i);
S.push_back(p);
}
sort(S.rbegin(),S.rend()); // reverse sort
vector<bool> hit(nDescCell);
fill(hit.begin(), hit.end(), false);
- vector<mcIdType> hitPoly; // the final result: which 3D cells have been modified.
+ vector<mcIdType> const hitPoly; // the final result: which 3D cells have been modified.
- for( vector<pair<double,mcIdType> >::const_iterator it = S.begin(); it != S.end(); it++)
+ for(const auto & it : S)
{
- mcIdType faceIdx = (*it).second;
+ mcIdType const faceIdx = it.second;
if (hit[faceIdx]) continue;
vector<mcIdType> candidates, cands2;
myTree.getIntersectingElems(bbox+faceIdx*2*SPACEDIM,candidates);
// Keep only candidates whose normal matches the normal of current face
- for(vector<mcIdType>::const_iterator it2=candidates.begin();it2!=candidates.end();it2++)
+ for(long const candidate : candidates)
{
- bool col = INTERP_KERNEL::isColinear3D(normalsP + faceIdx*SPACEDIM, normalsP + *(it2)*SPACEDIM, eps/carMeshSz); // using rough relative epsilon
- if (*it2 != faceIdx && col)
- cands2.push_back(*it2);
+ bool const col = INTERP_KERNEL::isColinear3D(normalsP + faceIdx*SPACEDIM, normalsP + candidate*SPACEDIM, eps/carMeshSz); // using rough relative epsilon
+ if (candidate != faceIdx && col)
+ cands2.push_back(candidate);
}
if (!cands2.size())
continue;
double checkSurf=0.0;
const mcIdType * idsGoodPlaneP(idsGoodPlane->begin());
- for (const mcIdType * ii = ids->begin(); ii != ids->end(); ii++)
+ for (long const ii : *ids)
{
- mcIdType faceIdx2 = cands2[idsGoodPlaneP[*ii]];
+ mcIdType const faceIdx2 = cands2[idsGoodPlaneP[ii]];
hit[faceIdx2] = true;
checkSurf += surfs->begin()[faceIdx2];
}
for (const mcIdType * ii = ids->begin(); ii != ids->end(); ii++)
{
// Build pack from the face to insert:
- mcIdType faceIdx2 = cands2[idsGoodPlane->getIJ(*ii,0)];
+ mcIdType const faceIdx2 = cands2[idsGoodPlane->getIJ(*ii,0)];
mcIdType facePack2Sz;
const mcIdType * facePack2 = connSlaDesc->getSimplePackSafePtr(faceIdx2, facePack2Sz); // contains the type!
// Insert it in all hit polyhedrons:
- for (vector<mcIdType>::const_iterator it2=polyIndices.begin(); it2!=polyIndices.end(); ++it2)
- connSla->pushBackPack(*it2, facePack2+1, facePack2+facePack2Sz); // without the type
+ for (long const polyIndice : polyIndices)
+ connSla->pushBackPack(polyIndice, facePack2+1, facePack2+facePack2Sz); // without the type
}
}
} // end step1
const mcIdType *cDesc2(mDesc2->getNodalConnectivity()->begin()),*cIDesc2(mDesc2->getNodalConnectivityIndex()->begin());
MCAuto<DataArrayDouble> bboxArr(mDesc2->getBoundingBoxForBBTree(eps));
const double *bbox2(bboxArr->begin());
- mcIdType nDesc2Cell=mDesc2->getNumberOfCells();
- BBTree<SPACEDIM,mcIdType> myTree2(bbox2,0,0,nDesc2Cell,-eps);
+ mcIdType const nDesc2Cell=mDesc2->getNumberOfCells();
+ BBTree<SPACEDIM,mcIdType> const myTree2(bbox2,nullptr,0,nDesc2Cell,-eps);
// Edges - handle longest first
MCAuto<MEDCouplingFieldDouble> lenF = mDesc2->getMeasureField(true);
vector<pair<double,mcIdType> > S;
for(mcIdType i=0;i < lens->getNumberOfTuples();i++)
{
- pair<double,mcIdType> p = make_pair(lens->getIJ(i, 0), i);
+ pair<double,mcIdType> const p = make_pair(lens->getIJ(i, 0), i);
S.push_back(p);
}
sort(S.rbegin(),S.rend()); // reverse sort
vector<bool> hit(nDesc2Cell);
fill(hit.begin(), hit.end(), false);
- for( vector<pair<double,mcIdType> >::const_iterator it = S.begin(); it != S.end(); it++)
+ for(const auto & it : S)
{
- mcIdType eIdx = (*it).second;
+ mcIdType const eIdx = it.second;
if (hit[eIdx])
continue;
for (mcIdType i3=0; i3 < 3; i3++) // TODO: use fillSonCellNodalConnectivity2 or similar?
vCurr[i3] = coo[start*SPACEDIM+i3] - coo[end*SPACEDIM+i3];
double carSz = INTERP_KERNEL::caracteristicDimVector(vCurr), eps2 = eps*carSz*carSz*carSz;
- for(vector<mcIdType>::const_iterator it2=candidates.begin();it2!=candidates.end();it2++)
+ for(long const candidate : candidates)
{
double vOther[3];
- mcIdType start2 = cDesc2[cIDesc2[*it2]+1], end2 = cDesc2[cIDesc2[*it2]+2];
+ mcIdType start2 = cDesc2[cIDesc2[candidate]+1], end2 = cDesc2[cIDesc2[candidate]+2];
for (mcIdType i3=0; i3 < 3; i3++)
vOther[i3] = coo[start2*SPACEDIM+i3] - coo[end2*SPACEDIM+i3];
// isColinear() expect unit vecotr, and relative (non geometrical) precision.
// relative prec means going from eps -> eps/curSz
// normalizing vCurr and vOther means multiplying by v^4, knowing that inside isColinear3D() the square (^2) of a dot product (^2) is computed
- bool col = INTERP_KERNEL::isColinear3D(vCurr, vOther, eps2);
+ bool const col = INTERP_KERNEL::isColinear3D(vCurr, vOther, eps2);
// Warning: different from faces: we need to keep eIdx in the final list of candidates because we need
// to have its nodes inside the sub mesh mPartCand below (needed in OrderPointsAlongLine())
if (col)
- cands2.push_back(*it2);
+ cands2.push_back(candidate);
}
if (cands2.size() == 1 && cands2[0] == eIdx) // see warning above
continue;
// Now rotate edges to bring them on Ox
- mcIdType startNode = cDesc2[cIDesc2[eIdx]+1];
- mcIdType endNode = cDesc2[cIDesc2[eIdx]+2];
+ mcIdType const startNode = cDesc2[cIDesc2[eIdx]+1];
+ mcIdType const endNode = cDesc2[cIDesc2[eIdx]+2];
INTERP_KERNEL::TranslationRotationMatrix rotation;
INTERP_KERNEL::TranslationRotationMatrix::Rotate3DBipoint(coo+SPACEDIM*startNode, coo+SPACEDIM*endNode, rotation);
MCAuto<MEDCouplingUMesh> mPartRef(mDesc2->buildPartOfMySelfSlice(eIdx, eIdx+1,1,false)); // false=zipCoords is called
// Now the ordering along the Ox axis:
std::vector<mcIdType> insidePoints, hitSegs;
- bool isSplit = OrderPointsAlongLine(mPartCand->_coords->getConstPointer(), nodeMap->begin()[startNode], nodeMap->begin()[endNode],
+ bool const isSplit = OrderPointsAlongLine(mPartCand->_coords->getConstPointer(), nodeMap->begin()[startNode], nodeMap->begin()[endNode],
mPartCand->getNodalConnectivity()->begin(), mPartCand->getNodalConnectivityIndex()->begin(),
idsGoodLine->begin(), idsGoodLine->end(),
/*out*/insidePoints, hitSegs);
// Optim: smaller segments completely included in eIdx and not split won't need any further treatment:
- for (vector<mcIdType>::const_iterator its=hitSegs.begin(); its != hitSegs.end(); ++its)
- hit[cands2[*its]] = true;
+ for (long const hitSeg : hitSegs)
+ hit[cands2[hitSeg]] = true;
if (!isSplit) // current segment remains in one piece
continue;
// Get original node IDs in global coords array
- for (std::vector<mcIdType>::iterator iit = insidePoints.begin(); iit!=insidePoints.end(); ++iit)
- *iit = nodeMapInv->begin()[*iit];
+ for (long & insidePoint : insidePoints)
+ insidePoint = nodeMapInv->begin()[insidePoint];
vector<mcIdType> polyIndices, packsIds, facePack;
// For each face implying this edge
for (mcIdType ii=revDescIP2[eIdx]; ii < revDescIP2[eIdx+1]; ii++)
{
- mcIdType faceIdx = revDescP2[ii];
+ mcIdType const faceIdx = revDescP2[ii];
// each cell where this face is involved connectivity will be modified:
ret->pushBackValsSilent(revDescP + revDescIP[faceIdx], revDescP + revDescIP[faceIdx+1]);
MCAuto<DataArrayIdType> idx(DataArrayIdType::New()); idx->alloc(1); idx->fillWithValue(0);
MCAuto<DataArrayIdType> vals(DataArrayIdType::New()); vals->alloc(0);
newConn->set3(superIdx, idx, vals);
- mcIdType nbCells=getNumberOfCells();
+ mcIdType const nbCells=getNumberOfCells();
for(mcIdType ii = 0; ii < nbCells; ii++)
for (mcIdType jj=descIP[ii]; jj < descIP[ii+1]; jj++)
{
mcIdType sz, faceIdx = abs(descP[jj])-1;
- bool orient = descP[jj]>0;
+ bool const orient = descP[jj]>0;
const mcIdType * p = connSlaDesc->getSimplePackSafePtr(faceIdx, sz);
if (orient)
newConn->pushBackPack(ii, p+1, p+sz); // +1 to skip type
// Author : Anthony Geay (EDF R&D)
#include "MEDCouplingVoronoi.hxx"
+#include "MCAuto.hxx"
+#include "MCIdType.hxx"
+#include "MCType.hxx"
#include "MEDCoupling1GTUMesh.hxx"
#include "MEDCouplingCMesh.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "MCAuto.txx"
-#include "MEDCouplingNormalizedUnstructuredMesh.txx"
-#include "Interpolation2D.txx"
-#include "Interpolation3DSurf.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MEDCouplingUMesh.hxx"
+#include <algorithm>
+#include <iterator>
+#include <math.h>
+#include <cmath>
+#include "NormalizedGeometricTypes"
+#include <cstddef>
+#include <vector>
+#include <set>
using namespace MEDCoupling;
Voronizer::~Voronizer()
-{
-}
+= default;
int Voronizer1D::getDimension() const
{
static const double PT[2]={0.,0.};
m->scale(PT,FACT);
MCAuto<MEDCouplingUMesh> mu(m->buildUnstructured());
- double l(std::max(bbox[1]-bbox[0],bbox[3]-bbox[2]));
+ double const l(std::max(bbox[1]-bbox[0],bbox[3]-bbox[2]));
double middle[2]={(pt1[0]+pt2[0])/2.,(pt1[1]+pt2[1])/2.};
double v[2]={pt1[0],pt1[1]};
DataArrayDouble::Rotate2DAlg(middle,M_PI/2,1,v,v);
v[0]=middle[0]-v[0]; v[1]=middle[1]-v[1];
{
- double nor(sqrt(v[0]*v[0]+v[1]*v[1]));
+ double const nor(sqrt(v[0]*v[0]+v[1]*v[1]));
v[0]/=nor; v[1]/=nor;
}
MCAuto<MEDCouplingUMesh> line(MEDCouplingUMesh::New("line",1));
line->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,CONN);
MCAuto<MEDCouplingUMesh> sp2,sp1;
{
- DataArrayIdType *cellNb1(0),*cellNb2(0);
- MEDCouplingUMesh *sp2Pt(0),*sp1Pt(0);
+ DataArrayIdType *cellNb1(nullptr),*cellNb2(nullptr);
+ MEDCouplingUMesh *sp2Pt(nullptr),*sp1Pt(nullptr);
MEDCouplingUMesh::Intersect2DMeshWith1DLine(mu,line,eps,sp2Pt,sp1Pt,cellNb1,cellNb2);
sp1=sp1Pt; sp2=sp2Pt;
MCAuto<DataArrayIdType> cellNb10(cellNb1),cellNb20(cellNb2);
}
-MCAuto<MEDCouplingUMesh> MergeVorCells2D(MEDCouplingUMesh *p, double eps, bool isZip)
+MCAuto<MEDCouplingUMesh> MergeVorCells2D(MEDCouplingUMesh *p, double /*eps*/, bool isZip)
{
MCAuto<DataArrayIdType> edgeToKeep;
MCAuto<MEDCouplingUMesh> p0;
MCAuto<MEDCouplingUMesh> MergeVorCells(const std::vector< MCAuto<MEDCouplingUMesh> >& vcs, double eps)
{
- std::size_t sz(vcs.size());
+ std::size_t const sz(vcs.size());
if(sz<1)
throw INTERP_KERNEL::Exception("MergeVorCells : len of input vec expected to be >= 1 !");
if(sz==1)
p->zipCoords();
{
bool dummy; mcIdType dummy2;
- MCAuto<DataArrayIdType> dummy3(p->mergeNodes(eps,dummy,dummy2));
+ MCAuto<DataArrayIdType> const dummy3(p->mergeNodes(eps,dummy,dummy2));
}
return MergeVorCells2D(p,eps,true);
}
if(m->getNumberOfCells()!=1)
throw INTERP_KERNEL::Exception("SimplifyPolygon : internal error !");
const mcIdType *conn(m->getNodalConnectivity()->begin()),*conni(m->getNodalConnectivityIndex()->begin());
- mcIdType nbPtsInPolygon(conni[1]-conni[0]-1);
+ mcIdType const nbPtsInPolygon(conni[1]-conni[0]-1);
const double *coo(m->getCoords()->begin());
std::vector<mcIdType> resConn;
for(mcIdType i=0;i<nbPtsInPolygon;i++)
coo[3*current+1]-coo[3*zeNext+1],
coo[3*current+2]-coo[3*zeNext+2],
};
- double c[3]={a[1]*b[2]-a[2]*b[1], a[2]*b[0]-a[0]*b[2], a[0]*b[1]-a[1]*b[0]};
+ double const c[3]={a[1]*b[2]-a[2]*b[1], a[2]*b[0]-a[0]*b[2], a[0]*b[1]-a[1]*b[0]};
if(sqrt(c[0]*c[0]+c[1]*c[1]+c[2]*c[2])>eps)
resConn.push_back(current);
}
MCAuto<MEDCouplingUMesh> MergeVorCells3D(const std::vector< MCAuto<MEDCouplingUMesh> >& vcs, double eps)
{
- std::size_t sz(vcs.size());
+ std::size_t const sz(vcs.size());
if(sz<1)
throw INTERP_KERNEL::Exception("MergeVorCells : len of input vec expected to be >= 1 !");
if(sz==1)
p->zipCoords();
{
bool dummy; mcIdType dummy2;
- MCAuto<DataArrayIdType> dummy3(p->mergeNodes(eps,dummy,dummy2));
+ MCAuto<DataArrayIdType> const dummy3(p->mergeNodes(eps,dummy,dummy2));
}
MCAuto<DataArrayIdType> edgeToKeep;
MCAuto<MEDCouplingUMesh> p0;
MCAuto<DataArrayDouble> eqn(skinOfRes->computePlaneEquationOf3DFaces());
MCAuto<DataArrayIdType> comm,commI;
{
- DataArrayIdType *a(0),*b(0);
+ DataArrayIdType *a(nullptr),*b(nullptr);
eqn->findCommonTuples(eps,0,a,b);
comm=a; commI=b;
//comm=DataArrayIdType::New(); comm->alloc(0,1); commI=DataArrayIdType::New(); commI->alloc(1,1); commI->setIJ(0,0,0);
throw INTERP_KERNEL::Exception("Voronoize1D : spacedim must be equal to 1 and meshdim also equal to 1 !");
if(m->getNumberOfCells()!=1)
throw INTERP_KERNEL::Exception("Voronoize1D : mesh is expected to have only one cell !");
- mcIdType nbPts(points->getNumberOfTuples());
+ mcIdType const nbPts(points->getNumberOfTuples());
if(nbPts<1)
throw INTERP_KERNEL::Exception("Voronoize1D : at least one point expected !");
std::vector<double> bbox(4);
{
bool dummy;
mcIdType newNbNodes;
- MCAuto<DataArrayIdType> dummy3(vorTess->mergeNodes(eps,dummy,newNbNodes));
+ MCAuto<DataArrayIdType> const dummy3(vorTess->mergeNodes(eps,dummy,newNbNodes));
}
std::vector<mcIdType> polygsToIterOn;
const double *pt(pts+i);
if(polygsToIterOn.size()>2)
throw INTERP_KERNEL::Exception("Voronoize1D : overlap of points !");
std::vector< MCAuto<MEDCouplingUMesh> > newVorCells;
- for(std::vector<mcIdType>::const_iterator it=polygsToIterOn.begin();it!=polygsToIterOn.end();it++)
+ for(long const poly : polygsToIterOn)
{
- mcIdType poly(*it);
//
double seed(pts[poly]),zept(*pt);
- double mid((seed+zept)/2.);
+ double const mid((seed+zept)/2.);
//
MCAuto<MEDCouplingUMesh> tile(l0[poly]);
tile->zipCoords();
MCAuto<MEDCouplingUMesh> ret(MEDCouplingUMesh::MergeUMeshes(l0Bis));
{
bool dummy; mcIdType dummy2;
- MCAuto<DataArrayIdType> dummy3(ret->mergeNodes(eps,dummy,dummy2));
+ MCAuto<DataArrayIdType> const dummy3(ret->mergeNodes(eps,dummy,dummy2));
}
return ret;
}
throw INTERP_KERNEL::Exception("Voronoize2D : spacedim must be equal to 2 and meshdim also equal to 2 !");
if(m->getNumberOfCells()!=1)
throw INTERP_KERNEL::Exception("Voronoize2D : mesh is expected to have only one cell !");
- mcIdType nbPts(points->getNumberOfTuples());
+ mcIdType const nbPts(points->getNumberOfTuples());
if(nbPts<1)
throw INTERP_KERNEL::Exception("Voronoize2D : at least one point expected !");
std::vector<double> bbox(4);
{
bool dummy;
mcIdType newNbNodes;
- MCAuto<DataArrayIdType> dummy3(vorTess->mergeNodes(eps,dummy,newNbNodes));
+ MCAuto<DataArrayIdType> const dummy3(vorTess->mergeNodes(eps,dummy,newNbNodes));
}
std::vector<mcIdType> polygsToIterOn;
const double *pt(pts+i*2);
std::vector< MCAuto<MEDCouplingUMesh> > newVorCells;
while(!elemsToDo.empty())
{
- mcIdType poly(*elemsToDo.begin()); elemsToDo.erase(elemsToDo.begin()); elemsDone.insert(poly);
+ mcIdType const poly(*elemsToDo.begin()); elemsToDo.erase(elemsToDo.begin()); elemsDone.insert(poly);
const double *seed(pts+2*poly);
MCAuto<MEDCouplingUMesh> cell(ComputeBigCellFrom(pt,seed,bbox,eps));
MCAuto<MEDCouplingUMesh> tile(l0[poly]);
MCAuto<MEDCouplingUMesh> a;
MCAuto<DataArrayIdType> b,c;
{
- DataArrayIdType *bPtr(0),*cPtr(0);
+ DataArrayIdType *bPtr(nullptr),*cPtr(nullptr);
a=MEDCouplingUMesh::Intersect2DMeshes(tile,cell,eps,bPtr,cPtr);
b=bPtr; c=cPtr;
}
//
MCAuto<DataArrayIdType> ids;
{
- DataArrayIdType *tmp(0);
- bool sta(a->getCoords()->areIncludedInMe(cell->getCoords(),eps,tmp));
+ DataArrayIdType *tmp(nullptr);
+ bool const sta(a->getCoords()->areIncludedInMe(cell->getCoords(),eps,tmp));
ids=tmp;
if(!sta)
throw INTERP_KERNEL::Exception("Voronoize2D : internal error 2 !");
MCAuto<MEDCouplingUMesh> ret(MEDCouplingUMesh::MergeUMeshes(l0Bis));
{
bool dummy; mcIdType dummy2;
- MCAuto<DataArrayIdType> dummy3(ret->mergeNodes(eps,dummy,dummy2));
+ MCAuto<DataArrayIdType> const dummy3(ret->mergeNodes(eps,dummy,dummy2));
}
return ret;
}
-MCAuto<MEDCouplingUMesh> Split3DCellInParts(const MEDCouplingUMesh *m, const double pt[3], const double seed[3], double eps, mcIdType tmp[2])
+MCAuto<MEDCouplingUMesh> Split3DCellInParts(const MEDCouplingUMesh *m, const double pt[3], const double seed[3], double eps, mcIdType /*tmp*/[2])
{
if(m->getMeshDimension()!=3 || m->getSpaceDimension()!=3 || m->getNumberOfCells()!=1)
throw INTERP_KERNEL::Exception("Split3DCellInParts : expecting a 3D with exactly one cell !");
- double middle[3]={(pt[0]+seed[0])/2.,(pt[1]+seed[1])/2.,(pt[2]+seed[2])/2.};
- double vec[3]={pt[0]-seed[0],pt[1]-seed[1],pt[2]-seed[2]};
- MCAuto<MEDCouplingUMesh> res(m->clipSingle3DCellByPlane(middle,vec,eps));
+ double const middle[3]={(pt[0]+seed[0])/2.,(pt[1]+seed[1])/2.,(pt[2]+seed[2])/2.};
+ double const vec[3]={pt[0]-seed[0],pt[1]-seed[1],pt[2]-seed[2]};
+ MCAuto<MEDCouplingUMesh> const res(m->clipSingle3DCellByPlane(middle,vec,eps));
return res;
}
throw INTERP_KERNEL::Exception("Voronoize3D : spacedim must be equal to 3 and meshdim also equal to 3 !");
if(m->getNumberOfCells()!=1)
throw INTERP_KERNEL::Exception("Voronoize3D : mesh is expected to have only one cell !");
- mcIdType nbPts(points->getNumberOfTuples());
+ mcIdType const nbPts(points->getNumberOfTuples());
if(nbPts<1)
throw INTERP_KERNEL::Exception("Voronoize3D : at least one point expected !");
std::vector< MCAuto<MEDCouplingUMesh> > l0(1,MCAuto<MEDCouplingUMesh>(m->deepCopy()));
{
bool dummy;
mcIdType newNbNodes;
- MCAuto<DataArrayIdType> dummy3(vorTess->mergeNodes(eps,dummy,newNbNodes));
+ MCAuto<DataArrayIdType> const dummy3(vorTess->mergeNodes(eps,dummy,newNbNodes));
}
std::vector<mcIdType> polygsToIterOn;
const double *pt(pts+i*3);
MCAuto<MEDCouplingUMesh> ret(MEDCouplingUMesh::MergeUMeshes(l0Bis));
{
bool dummy; mcIdType dummy2;
- MCAuto<DataArrayIdType> dummy3(ret->mergeNodes(eps,dummy,dummy2));
+ MCAuto<DataArrayIdType> const dummy3(ret->mergeNodes(eps,dummy,dummy2));
}
return ret;
}
#ifndef __MEDCOUPLINGVORONOI_HXX__
#define __MEDCOUPLINGVORONOI_HXX__
-#include "MEDCoupling.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingMemArray.hxx"
#include "MEDCouplingUMesh.hxx"
namespace MEDCoupling
class Voronizer1D : public Voronizer
{
public:
- MCAuto<MEDCouplingUMesh> doIt(const MEDCouplingUMesh *m, const DataArrayDouble *points, double eps) const;
- int getDimension() const;
+ MCAuto<MEDCouplingUMesh> doIt(const MEDCouplingUMesh *m, const DataArrayDouble *points, double eps) const override;
+ int getDimension() const override;
};
class Voronizer2D : public Voronizer
{
public:
- MCAuto<MEDCouplingUMesh> doIt(const MEDCouplingUMesh *m, const DataArrayDouble *points, double eps) const;
- int getDimension() const;
+ MCAuto<MEDCouplingUMesh> doIt(const MEDCouplingUMesh *m, const DataArrayDouble *points, double eps) const override;
+ int getDimension() const override;
};
class Voronizer3D : public Voronizer
{
public:
- MCAuto<MEDCouplingUMesh> doIt(const MEDCouplingUMesh *m, const DataArrayDouble *points, double eps) const;
- int getDimension() const;
+ MCAuto<MEDCouplingUMesh> doIt(const MEDCouplingUMesh *m, const DataArrayDouble *points, double eps) const override;
+ int getDimension() const override;
};
}
#ifndef __MEDCOUPLINGBASICSTEST_HXX__
#define __MEDCOUPLINGBASICSTEST_HXX__
-#include <cppunit/extensions/HelperMacros.h>
+#include <cppunit/TestFixture.h>
#include "MCType.hxx"
#include <map>
//
// Author : Anthony Geay (CEA/DEN)
+#include "MCType.hxx"
+#include "Interpolation.txx"
+#include "Interpolation2D1D.txx"
+#include "InterpolationOptions.hxx"
+#include "Log.hxx"
+#include "Interpolation2D3D.txx"
#include "MEDCouplingBasicsTest.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingNormalizedUnstructuredMesh.txx"
#include "MEDCouplingUMesh.hxx"
#include "MEDCouplingMappedExtrudedMesh.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "MEDCouplingBasicsTestData1.hxx"
-#include "Interpolation2D.txx"
-#include "Interpolation2D3D.txx"
-#include "Interpolation2D1D.txx"
-#include "MEDCouplingNormalizedUnstructuredMesh.txx"
#include "MEDCouplingNormalizedCartesianMesh.txx"
+#include "NormalizedGeometricTypes"
+#include "VectorUtils.hxx"
+#include <algorithm>
+#include <iostream>
+#include <cppunit/TestAssert.h>
+#include <vector>
+#include <map>
using namespace MEDCoupling;
MEDCouplingUMesh *MEDCouplingBasicsTest::build3DTargetMesh_3()
{
- return 0;
+ return nullptr;
}
MEDCouplingMultiFields *MEDCouplingBasicsTest::buildMultiFields_1()
double MEDCouplingBasicsTest::sumAll(const std::vector< std::map<mcIdType,double> >& matrix)
{
double ret=0.;
- for(std::vector< std::map<mcIdType,double> >::const_iterator iter=matrix.begin();iter!=matrix.end();iter++)
- for(std::map<mcIdType,double>::const_iterator iter2=(*iter).begin();iter2!=(*iter).end();iter2++)
- ret+=(*iter2).second;
+ for(const auto & iter : matrix)
+ for(auto iter2 : iter)
+ ret+=iter2.second;
return ret;
}
int MEDCouplingBasicsTest::countNonZero(const std::vector< std::map<mcIdType,double> >& matrix)
{
int ret=0;
- for(std::vector< std::map<mcIdType,double> >::const_iterator iter=matrix.begin();iter!=matrix.end();iter++)
- for(std::map<mcIdType,double>::const_iterator iter2=(*iter).begin();iter2!=(*iter).end();iter2++)
- if (!INTERP_KERNEL::epsilonEqual((*iter2).second, 0.)) ret +=1;
+ for(const auto & iter : matrix)
+ for(auto iter2 : iter)
+ if (!INTERP_KERNEL::epsilonEqual(iter2.second, 0.)) ret +=1;
return ret;
}
const int correctDuplicateFacesNbr,
const int correctTotalIntersectFacesNbr)
{
- MEDCouplingNormalizedUnstructuredMesh<2,2> sourceWrapper(sourceMesh);
- MEDCouplingNormalizedUnstructuredMesh<2,2> targetWrapper(targetMesh);
+ MEDCouplingNormalizedUnstructuredMesh<2,2> const sourceWrapper(sourceMesh);
+ MEDCouplingNormalizedUnstructuredMesh<2,2> const targetWrapper(targetMesh);
INTERP_KERNEL::Interpolation2D1D myInterpolator;
myInterpolator.setPrecision(1e-12);
const double prec = 1.0e-5;
LOG(1, "length = " << length <<" correctLength = " << correctLength );
CPPUNIT_ASSERT_DOUBLES_EQUAL(correctLength, length, prec * std::max(correctLength, length));
- INTERP_KERNEL::Interpolation2D3D::DuplicateFacesType duplicateFaces = myInterpolator.retrieveDuplicateFaces();
- int duplicateFacesNbr = (int)duplicateFaces.size();
+ INTERP_KERNEL::Interpolation2D3D::DuplicateFacesType const duplicateFaces = myInterpolator.retrieveDuplicateFaces();
+ int const duplicateFacesNbr = (int)duplicateFaces.size();
LOG(1, "duplicateFacesNbr = " << duplicateFacesNbr <<" correctDuplicateFacesNbr = " << correctDuplicateFacesNbr);
CPPUNIT_ASSERT_EQUAL(correctDuplicateFacesNbr, duplicateFacesNbr);
const int correctDuplicateFacesNbr,
const int correctTotalIntersectFacesNbr)
{
- MEDCouplingNormalizedUnstructuredMesh<3,3> sourceWrapper(sourceMesh);
- MEDCouplingNormalizedUnstructuredMesh<3,3> targetWrapper(targetMesh);
+ MEDCouplingNormalizedUnstructuredMesh<3,3> const sourceWrapper(sourceMesh);
+ MEDCouplingNormalizedUnstructuredMesh<3,3> const targetWrapper(targetMesh);
INTERP_KERNEL::Interpolation2D3D myInterpolator;
myInterpolator.setPrecision(1e-12);
const double prec = 1.0e-5;
IntersectionMatrix matrix;
INTERP_KERNEL::SplittingPolicy sp[] = { INTERP_KERNEL::PLANAR_FACE_5, INTERP_KERNEL::PLANAR_FACE_6, INTERP_KERNEL::GENERAL_24, INTERP_KERNEL::GENERAL_48 };
- for ( size_t i = 0; i < sizeof(sp)/sizeof(sp[0]); ++i )
+ for (auto & i : sp)
{
- myInterpolator.setSplittingPolicy( sp[i] );
+ myInterpolator.setSplittingPolicy( i );
matrix.clear();
myInterpolator.interpolateMeshes(sourceWrapper,targetWrapper,matrix,"P0P0");
LOG(1, "surf = " << surf <<" correctSurf = " << correctSurf );
CPPUNIT_ASSERT_DOUBLES_EQUAL(correctSurf, surf, prec * std::max(correctSurf, surf));
- INTERP_KERNEL::Interpolation2D3D::DuplicateFacesType duplicateFaces = myInterpolator.retrieveDuplicateFaces();
- int duplicateFacesNbr = (int)duplicateFaces.size();
+ INTERP_KERNEL::Interpolation2D3D::DuplicateFacesType const duplicateFaces = myInterpolator.retrieveDuplicateFaces();
+ int const duplicateFacesNbr = (int)duplicateFaces.size();
LOG(1, "duplicateFacesNbr = " << duplicateFacesNbr <<" correctDuplicateFacesNbr = " << correctDuplicateFacesNbr);
CPPUNIT_ASSERT_EQUAL(correctDuplicateFacesNbr, duplicateFacesNbr);
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingBasicsTest1.hxx"
+#include "MEDCouplingMemArray.txx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "InterpKernelException.hxx"
+#include "MCAuto.hxx"
+#include "MCType.hxx"
+#include "MCIdType.hxx"
+#include "MEDCouplingPointSet.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
+#include "MEDCouplingMesh.hxx"
#include "MEDCouplingUMesh.hxx"
#include "MEDCouplingCMesh.hxx"
#include "MEDCouplingMappedExtrudedMesh.hxx"
#include "MEDCouplingFieldDouble.hxx"
-#include "MEDCouplingMemArray.txx"
-#include <sstream>
+#include <cppunit/TestAssert.h>
+#include "NormalizedGeometricTypes"
+#include <cstdlib>
+#include <math.h>
+#include <cstddef>
#include <cmath>
#include <algorithm>
#include <functional>
+#include <vector>
using namespace MEDCoupling;
mesh->checkConsistencyLight();
//test 1 - no copy ownership C++
myCoords=DataArrayDouble::New();
- double *tmp=new double[3*nbOfNodes];
+ auto *tmp=new double[3*nbOfNodes];
std::copy(coords,coords+3*nbOfNodes,tmp);
myCoords->useArray(tmp,true,DeallocType::CPP_DEALLOC,nbOfNodes,3);
mesh->setCoords(myCoords);
const mcIdType tab2[3]={0,2,3};
//
MEDCouplingPointSet *subMeshSimple=mesh->buildPartOfMySelf(tab1,tab1+2,true);
- MEDCouplingUMesh *subMesh=dynamic_cast<MEDCouplingUMesh *>(subMeshSimple);
+ auto *subMesh=dynamic_cast<MEDCouplingUMesh *>(subMeshSimple);
CPPUNIT_ASSERT(subMesh);
std::string name(subMesh->getName());
CPPUNIT_ASSERT_EQUAL(2,(int)mesh->getAllGeoTypes().size());
MEDCouplingUMesh *mesh=build2DTargetMesh_1();
const mcIdType tab1[4]={5,7,8,4};
MEDCouplingPointSet *subMeshSimple=mesh->buildPartOfMySelfNode(tab1,tab1+4,true);
- MEDCouplingUMesh *subMesh=dynamic_cast<MEDCouplingUMesh *>(subMeshSimple);
+ auto *subMesh=dynamic_cast<MEDCouplingUMesh *>(subMeshSimple);
CPPUNIT_ASSERT(subMesh);
CPPUNIT_ASSERT_EQUAL(1,(int)subMesh->getAllGeoTypes().size());
CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_QUAD4,*subMesh->getAllGeoTypes().begin());
//
const mcIdType tab1[2]={0,4};
MEDCouplingPointSet *subMeshPtSet=mesh->buildPartOfMySelf(tab1,tab1+2,true);
- MEDCouplingUMesh *subMesh=dynamic_cast<MEDCouplingUMesh *>(subMeshPtSet);
+ auto *subMesh=dynamic_cast<MEDCouplingUMesh *>(subMeshPtSet);
CPPUNIT_ASSERT(subMesh);
DataArrayIdType *traducer=subMesh->zipCoordsTraducer();
const mcIdType expectedTraducer[9]={0,1,-1,2,3,4,-1,5,6};
MEDCouplingUMesh *m2=build2DTargetMesh_1();
mcIdType cells1[3]={2,3,4};
MEDCouplingPointSet *m3_1=m2->buildPartOfMySelf(cells1,cells1+3,true);
- MEDCouplingUMesh *m3=dynamic_cast<MEDCouplingUMesh *>(m3_1);
+ auto *m3=dynamic_cast<MEDCouplingUMesh *>(m3_1);
CPPUNIT_ASSERT(m3);
m2->decrRef();
MEDCouplingUMesh *m4=build2DSourceMesh_1();
CPPUNIT_ASSERT(mesh1->isEqual(mesh2,1e-12));
CPPUNIT_ASSERT(mesh2->isEqual(mesh1,1e-12));
double *pt=mesh2->getCoords()->getPointer();
- double tmp=pt[1];
+ double const tmp=pt[1];
pt[1]=5.999;
CPPUNIT_ASSERT(!mesh1->isEqual(mesh2,1e-12));
CPPUNIT_ASSERT(!mesh2->isEqual(mesh1,1e-12));
CPPUNIT_ASSERT_EQUAL(1,(int)di->getNumberOfComponents());
const mcIdType *toCheck=di->getConstPointer();
CPPUNIT_ASSERT(std::equal(elts,elts+3,toCheck));
- MEDCouplingUMesh *ret1DC=dynamic_cast<MEDCouplingUMesh *>(ret1);
+ auto *ret1DC=dynamic_cast<MEDCouplingUMesh *>(ret1);
CPPUNIT_ASSERT(ret1DC);
ret1->decrRef();
di->decrRef();
MEDCouplingFieldDouble *fieldNodes=MEDCouplingFieldDouble::New(ON_NODES,NO_TIME);
fieldNodes->setMesh(targetMesh);
MEDCouplingMesh *ret2=fieldNodes->buildSubMeshData(elts,elts+3,di);
- MEDCouplingUMesh *ret2DC=dynamic_cast<MEDCouplingUMesh *>(ret2);
+ auto *ret2DC=dynamic_cast<MEDCouplingUMesh *>(ret2);
CPPUNIT_ASSERT(ret2DC);
CPPUNIT_ASSERT_EQUAL(3,(int)ret2->getNumberOfCells());
CPPUNIT_ASSERT_EQUAL(6,(int)ret2->getNumberOfNodes());
void MEDCouplingBasicsTest1::testExtrudedMesh1()
{
- MEDCouplingUMesh *mesh2D=0;
+ MEDCouplingUMesh *mesh2D=nullptr;
MEDCouplingUMesh *mesh3D=build3DExtrudedUMesh_1(mesh2D);
MEDCouplingMappedExtrudedMesh *ext=MEDCouplingMappedExtrudedMesh::New(mesh3D,mesh2D,1);
CPPUNIT_ASSERT_EQUAL(18,(int)ext->getNumberOfCells());
double v[3]={0.,0.,2.};
mTT->findNodesOnPlane(pt,v,1e-12,n);
CPPUNIT_ASSERT_EQUAL(43,(int)n.size());
- MEDCouplingUMesh *mTT3dSurf=(MEDCouplingUMesh *)mTT->buildFacePartOfMySelfNode(&n[0],&n[0]+n.size(),true);
+ auto *mTT3dSurf=(MEDCouplingUMesh *)mTT->buildFacePartOfMySelfNode(&n[0],&n[0]+n.size(),true);
MEDCouplingMappedExtrudedMesh *meTT=MEDCouplingMappedExtrudedMesh::New(mTT,mTT3dSurf,0);
CPPUNIT_ASSERT_EQUAL(200,(int)meTT->getNumberOfCells());
CPPUNIT_ASSERT_EQUAL(10,(int)meTT->getMesh2D()->getNumberOfCells());
n.clear();
mN->findNodesOnPlane(pt,v,1e-12,n);
CPPUNIT_ASSERT_EQUAL(30,(int)n.size());
- MEDCouplingUMesh *mN3dSurf=(MEDCouplingUMesh *)mN->buildFacePartOfMySelfNode(&n[0],&n[0]+n.size(),true);
+ auto *mN3dSurf=(MEDCouplingUMesh *)mN->buildFacePartOfMySelfNode(&n[0],&n[0]+n.size(),true);
MEDCouplingMappedExtrudedMesh *meN=MEDCouplingMappedExtrudedMesh::New(mN,mN3dSurf,0);
CPPUNIT_ASSERT_EQUAL(40,(int)meN->getNumberOfCells());
CPPUNIT_ASSERT_EQUAL(20,(int)meN->getMesh2D()->getNumberOfCells());
n.clear();
mTF->findNodesOnPlane(pt,v,1e-12,n);
CPPUNIT_ASSERT_EQUAL(27,(int)n.size());
- MEDCouplingUMesh *mTF3dSurf=(MEDCouplingUMesh *)mTF->buildFacePartOfMySelfNode(&n[0],&n[0]+n.size(),true);
+ auto *mTF3dSurf=(MEDCouplingUMesh *)mTF->buildFacePartOfMySelfNode(&n[0],&n[0]+n.size(),true);
MEDCouplingMappedExtrudedMesh *meTF=MEDCouplingMappedExtrudedMesh::New(mTF,mTF3dSurf,0);
CPPUNIT_ASSERT_EQUAL(340,(int)meTF->getNumberOfCells());
CPPUNIT_ASSERT_EQUAL(17,(int)meTF->getMesh2D()->getNumberOfCells());
const double vec[2]={1.,0.};
m2->translate(vec);
MEDCouplingMesh *m3=m1->mergeMyselfWith(m2);
- MEDCouplingUMesh *m3C=dynamic_cast<MEDCouplingUMesh *>(m3);
+ auto *m3C=dynamic_cast<MEDCouplingUMesh *>(m3);
CPPUNIT_ASSERT(m3C);
m3->checkConsistencyLight();
MEDCouplingUMesh *m4=build2DTargetMeshMerged_1();
MEDCouplingUMesh *m4=build2DTargetMeshMerged_1();
m4->setName(f1->getMesh()->getName());
CPPUNIT_ASSERT(f3->getMesh()->isEqual(m4,1.e-12));
- std::string name=f3->getName();
+ std::string const name=f3->getName();
CPPUNIT_ASSERT(name=="MeasureOfMesh_");
CPPUNIT_ASSERT(f3->getTypeOfField()==ON_CELLS);
CPPUNIT_ASSERT(f3->getTimeDiscretization()==ONE_TIME);
const double *tmp=f3->getArray()->getConstPointer();
std::transform(tmp,tmp+7,values,values,std::minus<double>());
std::transform(values,values+7,values,[](double c){return fabs(c);});
- double max=*std::max_element(values,values+7);
+ double const max=*std::max_element(values,values+7);
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
m4->decrRef();
f3->decrRef();
const double *tmp=f1->getArray()->getConstPointer();
std::transform(tmp,tmp+9,values1,values1,std::minus<double>());
std::transform(values1,values1+9,values1,[](double c){return fabs(c);});
- double max=*std::max_element(values1,values1+9);
+ double const max=*std::max_element(values1,values1+9);
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
f1->decrRef();
m->decrRef();
void MEDCouplingBasicsTest1::testOperationsOnFields4()
{
MEDCouplingUMesh *m=build2DTargetMesh_1();
- std::size_t nbOfCells=m->getNumberOfCells();
+ std::size_t const nbOfCells=m->getNumberOfCells();
MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,CONST_ON_TIME_INTERVAL);
f1->setMesh(m);
DataArrayDouble *array=DataArrayDouble::New();
MEDCouplingUMesh *m1=build3DSurfTargetMesh_1();
std::vector<MEDCouplingUMesh *> v=m1->splitByType();
CPPUNIT_ASSERT_EQUAL(3,(int)v.size());
- std::vector<const MEDCouplingUMesh *> v2(v.begin(),v.end());
+ std::vector<const MEDCouplingUMesh *> const v2(v.begin(),v.end());
MEDCouplingUMesh *m2=MEDCouplingUMesh::MergeUMeshesOnSameCoords(v2);
m2->setName(m1->getName().c_str());
CPPUNIT_ASSERT(m1->isEqual(m2,1.e-12));
- for(std::vector<MEDCouplingUMesh *>::const_iterator iter=v.begin();iter!=v.end();iter++)
- (*iter)->decrRef();
+ for(auto iter : v)
+ iter->decrRef();
m2->decrRef();
m1->decrRef();
}
MEDCouplingUMesh *m2=build2DTargetMesh_1();
mcIdType cells1[3]={2,3,4};
MEDCouplingPointSet *m3_1=m2->buildPartOfMySelf(cells1,cells1+3,true);
- MEDCouplingUMesh *m3=dynamic_cast<MEDCouplingUMesh *>(m3_1);
+ auto *m3=dynamic_cast<MEDCouplingUMesh *>(m3_1);
CPPUNIT_ASSERT(m3);
meshes.push_back(m3);
mcIdType cells2[3]={1,2,4};
MEDCouplingPointSet *m4_1=m2->buildPartOfMySelf(cells2,cells2+3,true);
- MEDCouplingUMesh *m4=dynamic_cast<MEDCouplingUMesh *>(m4_1);
+ auto *m4=dynamic_cast<MEDCouplingUMesh *>(m4_1);
CPPUNIT_ASSERT(m4);
meshes.push_back(m4);
mcIdType cells3[2]={1,2};
MEDCouplingPointSet *m5_1=m2->buildPartOfMySelf(cells3,cells3+2,true);
- MEDCouplingUMesh *m5=dynamic_cast<MEDCouplingUMesh *>(m5_1);
+ auto *m5=dynamic_cast<MEDCouplingUMesh *>(m5_1);
CPPUNIT_ASSERT(m5);
meshes.push_back(m5);
m2->decrRef();
{
DataArrayIdType *arr=corr[i];
CPPUNIT_ASSERT_EQUAL(1,(int)arr->getNumberOfComponents());
- mcIdType nbOfVals=expectedVals1[i];
+ mcIdType const nbOfVals=expectedVals1[i];
CPPUNIT_ASSERT_EQUAL(nbOfVals,arr->getNumberOfTuples());
const mcIdType *vals=arr->getConstPointer();
for(mcIdType j=0;j<nbOfVals;j++)
CPPUNIT_ASSERT_EQUAL(expectedVals2[i][j],vals[j]);
}
std::vector< std::vector<mcIdType> > fidsOfGroups;
- std::vector<const DataArrayIdType *> corr2(corr.begin(),corr.end());
+ std::vector<const DataArrayIdType *> const corr2(corr.begin(),corr.end());
DataArrayIdType *arr2=DataArrayIdType::MakePartition(corr2,m7->getNumberOfCells(),fidsOfGroups);
const mcIdType fidExp[4]={5,1,3,4};
const mcIdType fidsGrp[3][3]={{1,3,5},{3,4,5},{4,5,23344}};
CPPUNIT_ASSERT(std::equal(fidExp,fidExp+4,arr2->getConstPointer()));
for(int i=0;i<3;i++)
{
- mcIdType nbOfVals=expectedVals1[i];
+ mcIdType const nbOfVals=expectedVals1[i];
CPPUNIT_ASSERT_EQUAL(nbOfVals,ToIdType(fidsOfGroups[i].size()));
CPPUNIT_ASSERT(std::equal(fidsOfGroups[i].begin(),fidsOfGroups[i].end(),fidsGrp[i]));
}
- for(std::vector<DataArrayIdType *>::iterator iter=corr.begin();iter!=corr.end();iter++)
- (*iter)->decrRef();
+ for(auto & iter : corr)
+ iter->decrRef();
arr2->decrRef();
m7->decrRef();
//
MEDCouplingUMesh *m1=build3DExtrudedUMesh_1(m2);
m2->decrRef();
const mcIdType part1[5]={2,3,6,4,10};
- MEDCouplingUMesh *m3=(MEDCouplingUMesh *)m1->buildPartOfMySelf(part1,part1+5,true);
+ auto *m3=(MEDCouplingUMesh *)m1->buildPartOfMySelf(part1,part1+5,true);
const mcIdType part2[4]={5,6,4,7};
- MEDCouplingUMesh *m4=(MEDCouplingUMesh *)m1->buildPartOfMySelf(part2,part2+4,true);
+ auto *m4=(MEDCouplingUMesh *)m1->buildPartOfMySelf(part2,part2+4,true);
std::vector<const MEDCouplingUMesh *> meshes;
meshes.push_back(m1);
meshes.push_back(m3);
std::vector<DataArrayIdType *> corr;
MEDCouplingUMesh *m5=MEDCouplingUMesh::FuseUMeshesOnSameCoords(meshes,0,corr);
CPPUNIT_ASSERT_EQUAL(18,(int)m5->getNumberOfCells());
- std::vector<DataArrayIdType *>::iterator it=corr.begin();
+ auto it=corr.begin();
const mcIdType exp1[4]={18,5,5,4};
const mcIdType exp2[4][18]={
{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17},
int i=0;
for(;it!=corr.end();it++,i++)
{
- mcIdType sz=(*it)->getNumberOfTuples();
+ mcIdType const sz=(*it)->getNumberOfTuples();
CPPUNIT_ASSERT_EQUAL(exp1[i],sz);
CPPUNIT_ASSERT(std::equal(exp2[i],exp2[i]+sz,(*it)->getConstPointer()));
}
{
MEDCouplingUMesh *targetMesh=build3DSurfTargetMesh_1();
MEDCouplingFieldDouble *field=targetMesh->buildOrthogonalField();
- double expected[3]={0.70710678118654746,0.,-0.70710678118654746};
+ double const expected[3]={0.70710678118654746,0.,-0.70710678118654746};
CPPUNIT_ASSERT_EQUAL(5,(int)field->getNumberOfTuples());
CPPUNIT_ASSERT_EQUAL(3,(int)field->getNumberOfComponents());
const double *vals=field->getArray()->getConstPointer();
//2D with no help of bounding box.
double center[2]={0.2,0.2};
DataArrayDouble::Rotate2DAlg(center,0.78539816339744830962,6,pos,pos);
- targetMesh->rotate(center,0,0.78539816339744830962);
+ targetMesh->rotate(center,nullptr,0.78539816339744830962);
targetMesh->getCellsContainingPoints(pos,6,1e-12,t1,t2);
CPPUNIT_ASSERT_EQUAL(6,(int)t1->getNbOfElems());
CPPUNIT_ASSERT_EQUAL(7,(int)t2->getNbOfElems());
{
MEDCouplingUMesh *targetMesh=build2DTargetMesh_1();
MEDCouplingFieldDouble *fieldOnCells=MEDCouplingFieldDouble::New(ON_CELLS);
- std::size_t nbOfCells=targetMesh->getNumberOfCells();
+ std::size_t const nbOfCells=targetMesh->getNumberOfCells();
fieldOnCells->setMesh(targetMesh);
DataArrayDouble *array=DataArrayDouble::New();
array->alloc(nbOfCells,2);
//
targetMesh=build2DSourceMesh_1();
MEDCouplingFieldDouble *fieldOnNodes=MEDCouplingFieldDouble::New(ON_NODES);
- mcIdType nbOfNodes=targetMesh->getNumberOfNodes();
+ mcIdType const nbOfNodes=targetMesh->getNumberOfNodes();
fieldOnNodes->setMesh(targetMesh);
array=DataArrayDouble::New();
array->alloc(nbOfNodes,2);
MEDCouplingMesh* meshDeepCopy=mesh->deepCopy();
MEDCouplingCMesh* meshClone=mesh->clone(false);
- CPPUNIT_ASSERT_THROW(meshEmpty->copyTinyStringsFrom(0),INTERP_KERNEL::Exception);
+ CPPUNIT_ASSERT_THROW(meshEmpty->copyTinyStringsFrom(nullptr),INTERP_KERNEL::Exception);
meshEmpty->copyTinyStringsFrom(mesh);
//no data in meshEmpty, expected false
CPPUNIT_ASSERT(!meshEmpty->isEqual(mesh,1e-12));
ids->decrRef();
check->decrRef();
mcIdType cells1[4]={0,1,25,26};
- MEDCouplingUMesh *partMesh1=
+ auto *partMesh1=
dynamic_cast<MEDCouplingUMesh *>(mesh1->buildPart(cells1,cells1+4));
CPPUNIT_ASSERT(partMesh1);
CPPUNIT_ASSERT_EQUAL(4,(int)partMesh1->getNumberOfCellsWithType(INTERP_KERNEL::NORM_HEXA8));
mcIdType cells2[2]={25,26};
DataArrayIdType* arr1;
- MEDCouplingCMesh *partMesh2=
+ auto *partMesh2=
dynamic_cast<MEDCouplingCMesh *>(mesh1->buildPartAndReduceNodes(cells2,cells2+2,arr1));
CPPUNIT_ASSERT(partMesh2);
CPPUNIT_ASSERT_EQUAL(2,(int)partMesh2->getNumberOfCellsWithType(INTERP_KERNEL::NORM_HEXA8));
mcIdType cells3[2]={2,3};
DataArrayIdType* arr2;
- MEDCouplingUMesh *partMesh3=
+ auto *partMesh3=
dynamic_cast<MEDCouplingUMesh *>(partMesh1->buildPartAndReduceNodes(cells3,cells3+2,arr2));
CPPUNIT_ASSERT(partMesh3);
CPPUNIT_ASSERT_EQUAL(2,(int)partMesh3->getNumberOfCellsWithType(INTERP_KERNEL::NORM_HEXA8));
double v[3]={0.,0.,2.};
mesh->findNodesOnPlane(pt,v,1e-12,n);
CPPUNIT_ASSERT_EQUAL(9,(int)n.size());
- MEDCouplingUMesh *m3dSurf=(MEDCouplingUMesh *)mesh->buildFacePartOfMySelfNode(&n[0],&n[0]+n.size(),true);
+ auto *m3dSurf=(MEDCouplingUMesh *)mesh->buildFacePartOfMySelfNode(&n[0],&n[0]+n.size(),true);
MEDCouplingMappedExtrudedMesh *me=MEDCouplingMappedExtrudedMesh::New(mesh,m3dSurf,0);
const DataArrayIdType *da=me->getMesh3DIds();
CPPUNIT_ASSERT_EQUAL(8,(int)me->getNumberOfCells());
#include "MEDCouplingBasicsTest.hxx"
-#include <map>
-#include <vector>
+#include <cppunit/extensions/HelperMacros.h>
namespace MEDCoupling
{
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingBasicsTest2.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "InterpKernelException.hxx"
+#include "MCIdType.hxx"
+#include "MCType.hxx"
#include "MEDCouplingUMesh.hxx"
-#include "MEDCouplingCMesh.hxx"
#include "MEDCouplingMappedExtrudedMesh.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "MEDCouplingMemArray.hxx"
#include "MEDCouplingGaussLocalization.hxx"
+#include "NormalizedGeometricTypes"
#include <cmath>
#include <algorithm>
+#include <cppunit/TestAssert.h>
+#include <cstddef>
#include <functional>
-#include <iterator>
+#include <vector>
+#include <math.h>
+#include <set>
using namespace MEDCoupling;
const double gsCoo1[12]={ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b,
2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 };
const double wg1[6]={ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 };
- std::vector<double> _refCoo1(refCoo1,refCoo1+6);
+ std::vector<double> const _refCoo1(refCoo1,refCoo1+6);
std::vector<double> _gsCoo1(gsCoo1,gsCoo1+12);
std::vector<double> _wg1(wg1,wg1+6);
//
CPPUNIT_ASSERT_THROW(f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_QUAD4,_refCoo1,_gsCoo1,_wg1),INTERP_KERNEL::Exception);
CPPUNIT_ASSERT_EQUAL(ToIdType(1),f->getNbOfGaussLocalization());
const double refCoo2[8]={ 0.,0., 1.,0., 1.,1., 0.,1. };
- std::vector<double> _refCoo2(refCoo2,refCoo2+8);
+ std::vector<double> const _refCoo2(refCoo2,refCoo2+8);
_gsCoo1.resize(4); _wg1.resize(2);
f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
CPPUNIT_ASSERT_EQUAL(ToIdType(2),f->getNbOfGaussLocalization());
MEDCouplingFieldDouble *f2=f->clone(true);
CPPUNIT_ASSERT(f->isEqual(f2,1e-14,1e-14));
MEDCouplingGaussLocalization& gl1=f2->getGaussLocalization(0);
- double tmp=gl1.getGaussCoord(1,1);
+ double const tmp=gl1.getGaussCoord(1,1);
CPPUNIT_ASSERT_DOUBLES_EQUAL(2.07*_b-1,tmp,1e-14);
gl1.setGaussCoord(1,1,0.07);
CPPUNIT_ASSERT(!f->isEqual(f2,1e-14,1e-14));
vec[2]=-1.;
// connectivity inversion
mcIdType *conn=m->getNodalConnectivity()->getPointer();
- mcIdType tmp=conn[11];
+ mcIdType const tmp=conn[11];
conn[11]=conn[12];
conn[12]=tmp;
m->are2DCellsNotCorrectlyOriented(vec,false,res1);
void MEDCouplingBasicsTest2::testCellOrientation2()
{
- MEDCouplingUMesh *m1=0;
+ MEDCouplingUMesh *m1=nullptr;
MEDCouplingUMesh *m2=build3DExtrudedUMesh_1(m1);
m1->decrRef();
std::vector<mcIdType> res1;
DataArrayDouble *f3=m1->computeCellCenterOfMass();
CPPUNIT_ASSERT_EQUAL(4,(int)f3->getNumberOfTuples());
CPPUNIT_ASSERT_EQUAL(1,(int)f3->getNumberOfComponents());
- double expected9[4]={0.75,5.105,0.8,5.155};
+ double const expected9[4]={0.75,5.105,0.8,5.155};
ptr=f3->getConstPointer();
for(int i=0;i<4;i++)
CPPUNIT_ASSERT_DOUBLES_EQUAL(expected9[i],ptr[i],1e-12);
MEDCouplingFieldDouble *f2=m1->getMeasureField(false);
CPPUNIT_ASSERT_EQUAL(4,(int)f2->getArray()->getNumberOfTuples());
CPPUNIT_ASSERT_EQUAL(1,(int)f2->getNumberOfComponents());
- double expected1[4]={0.5,0.21,-0.6,-0.31};
+ double const expected1[4]={0.5,0.21,-0.6,-0.31};
ptr=f2->getArray()->getConstPointer();
for(int i=0;i<4;i++)
CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],ptr[i],1e-12);
f2->decrRef();
- double expected2[4]={0.5,0.21,0.6,0.31};
+ double const expected2[4]={0.5,0.21,0.6,0.31};
f2=m1->getMeasureField(true);
ptr=f2->getArray()->getConstPointer();
for(int i=0;i<4;i++)
//integral
double res[3];
f1->integral(false,res);
- double expected3[3]={0.9866,-0.3615,0.4217};
+ double const expected3[3]={0.9866,-0.3615,0.4217};
for(int i=0;i<3;i++)
CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3[i],res[i],1e-12);
CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3[0],f1->integral(0,false),1e-12);
CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3[1],f1->integral(1,false),1e-12);
CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3[2],f1->integral(2,false),1e-12);
f1->integral(true,res);
- double expected4[3]={-3.4152,8.7639,-14.6879};
+ double const expected4[3]={-3.4152,8.7639,-14.6879};
for(int i=0;i<3;i++)
CPPUNIT_ASSERT_DOUBLES_EQUAL(expected4[i],res[i],1e-12);
//normL1
f1->normL1(res);
- double expected5[3]={6.979506172839505, 16.89018518518518, 27.02969135802469};
+ double const expected5[3]={6.979506172839505, 16.89018518518518, 27.02969135802469};
for(int i=0;i<3;i++)
CPPUNIT_ASSERT_DOUBLES_EQUAL(expected5[i],res[i],1e-12);
CPPUNIT_ASSERT_DOUBLES_EQUAL(expected5[0],f1->normL1(0),1e-12);
CPPUNIT_ASSERT_DOUBLES_EQUAL(expected5[2],f1->normL1(2),1e-12);
//normL2
f1->normL2(res);
- double expected7[3]={7.090910979452395, 16.9275542960123, 27.053271464160858};
+ double const expected7[3]={7.090910979452395, 16.9275542960123, 27.053271464160858};
for(int i=0;i<3;i++)
CPPUNIT_ASSERT_DOUBLES_EQUAL(expected7[i],res[i],1e-9);
CPPUNIT_ASSERT_DOUBLES_EQUAL(expected7[0],f1->normL2(0),1e-9);
f3=m1->computeCellCenterOfMass();
CPPUNIT_ASSERT_EQUAL(4,(int)f3->getNumberOfTuples());
CPPUNIT_ASSERT_EQUAL(2,(int)f3->getNumberOfComponents());
- double expected10[8]={0.75,0.75,5.105,5.105,0.8,0.8,5.155,5.155};
+ double const expected10[8]={0.75,0.75,5.105,5.105,0.8,0.8,5.155,5.155};
ptr=f3->getConstPointer();
for(int i=0;i<8;i++)
CPPUNIT_ASSERT_DOUBLES_EQUAL(expected10[i],ptr[i],1e-12);
MEDCouplingFieldDouble *f1=m1->getMeasureField(false);
CPPUNIT_ASSERT_EQUAL(10,(int)f1->getArray()->getNumberOfTuples());
CPPUNIT_ASSERT_EQUAL(1,(int)f1->getNumberOfComponents());
- double expected1[10]={-0.5,-1,-1.5,-0.5,-1, 0.5,1,1.5,0.5,1};
+ double const expected1[10]={-0.5,-1,-1.5,-0.5,-1, 0.5,1,1.5,0.5,1};
const double *ptr=f1->getArray()->getConstPointer();
for(int i=0;i<10;i++)
CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],ptr[i],1e-12);
DataArrayDouble *f2=m1->computeCellCenterOfMass();
CPPUNIT_ASSERT_EQUAL(10,(int)f2->getNumberOfTuples());
CPPUNIT_ASSERT_EQUAL(2,(int)f2->getNumberOfComponents());
- double expected2[20]={
+ double const expected2[20]={
0.5,0.3333333333333333,0.5,0.5,0.5,0.77777777777777777,0.5,0.3333333333333333,0.5,0.5,
0.5,0.3333333333333333,0.5,0.5,0.5,0.77777777777777777,0.5,0.3333333333333333,0.5,0.5,
};
CPPUNIT_ASSERT_EQUAL(10,(int)f2->getNumberOfTuples());
CPPUNIT_ASSERT_EQUAL(3,(int)f2->getNumberOfComponents());
ptr=f2->getConstPointer();
- double expected3[30]={
+ double const expected3[30]={
0.5,0.3333333333333333,0.,0.5,0.5,0.,0.5,0.77777777777777777,0.,0.5,0.3333333333333333,0.,0.5,0.5,0.,
0.5,0.3333333333333333,0.,0.5,0.5,0.,0.5,0.77777777777777777,0.,0.5,0.3333333333333333,0.,0.5,0.5,0.
};
, 55 , 5 , 12 , 65 , -1 , 66 , 67 , 65 , 55 , 56 , 57 , -1 , 63 , 66 , 57 , 59 , 64 , -1 , 64 , 62 , 58 , 59 , -1
, 60 , 63 , 66 , 67 , 68 , 61 , -1 , 61 , 68 , 20 , 21 , -1 , 67 , 68 , 20 , 12 , 65};
- double barys[]={ -0.0165220465527 , -0.0190922868195 , 0.158882733414 ,
+ double const barys[]={ -0.0165220465527 , -0.0190922868195 , 0.158882733414 ,
0.0287618656076 , 0.135874379934 , -0.14601588119 ,
-0.147128055553 , 0.0465995097041 , -0.049391174453 ,
-0.00142506732317 , -0.0996953090351 , -0.115159183132 };
const double gsCoo1[12]={ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b,
2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 };
const double wg1[6]={ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 };
- std::vector<double> _refCoo1(refCoo1,refCoo1+6);
+ std::vector<double> const _refCoo1(refCoo1,refCoo1+6);
std::vector<double> _gsCoo1(gsCoo1,gsCoo1+12);
std::vector<double> _wg1(wg1,wg1+6);
f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
const double refCoo2[8]={ 0.,0., 1.,0., 1.,1., 0.,1. };
- std::vector<double> _refCoo2(refCoo2,refCoo2+8);
+ std::vector<double> const _refCoo2(refCoo2,refCoo2+8);
_gsCoo1.resize(4); _wg1.resize(2);
f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
arr=DataArrayDouble::New();
CPPUNIT_ASSERT(f->isEqual(fCpy,1e-12,1e-12));
f->renumberCells(renumber1,false);
CPPUNIT_ASSERT(!f->isEqual(fCpy,1e-12,1e-12));
- double expected2[36]={21.,1021.,22.,1022.,23.,1023.,24.,1024.,25.,1025.,26.,1026., 11.,1011.,12.,1012.,13.,1013.,14.,1014.,15.,1015.,16.,1016., 41.,1041.,42.,1042., 1.,1001.,2.,1002., 31.,1031.,32.,1032.};
+ double const expected2[36]={21.,1021.,22.,1022.,23.,1023.,24.,1024.,25.,1025.,26.,1026., 11.,1011.,12.,1012.,13.,1013.,14.,1014.,15.,1015.,16.,1016., 41.,1041.,42.,1042., 1.,1001.,2.,1002., 31.,1031.,32.,1032.};
ptr=f->getArray()->getConstPointer();
for(int i=0;i<36;i++)
CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],ptr[i],1e-12);
CPPUNIT_ASSERT(f->isEqual(fCpy,1e-12,1e-12));
f->renumberCells(renumber1,false);
CPPUNIT_ASSERT(!f->isEqual(fCpy,1e-12,1e-12));
- double expected3[36]={21.,1021.,22.,1022.,23.,1023.,11.,1011.,12.,1012.,13.,1013.,41.,1041.,42.,1042.,43.,1043.,44.,1044.,1.,1001.,2.,1002.,3.,1003.,4.,1004.,31.,1031.,32.,1032.,33.,1033.,34.,1034.};
+ double const expected3[36]={21.,1021.,22.,1022.,23.,1023.,11.,1011.,12.,1012.,13.,1013.,41.,1041.,42.,1042.,43.,1043.,44.,1044.,1.,1001.,2.,1002.,3.,1003.,4.,1004.,31.,1031.,32.,1032.,33.,1033.,34.,1034.};
ptr=f->getArray()->getConstPointer();
for(int i=0;i<36;i++)
CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3[i],ptr[i],1e-12);
f->setMesh(m);
CPPUNIT_ASSERT_EQUAL(ToIdType(9),f->getNumberOfMeshPlacesExpected());
DataArrayDouble *arr=DataArrayDouble::New();
- mcIdType nbOfNodes=m->getNumberOfNodes();
+ mcIdType const nbOfNodes=m->getNumberOfNodes();
arr->alloc(nbOfNodes,3);
f->setArray(arr);
arr->decrRef();
{
MEDCouplingUMesh *mesh=build2DTargetMesh_3();
mesh->checkConsistencyLight();
- std::set<INTERP_KERNEL::NormalizedCellType> types=mesh->getAllGeoTypes();
+ std::set<INTERP_KERNEL::NormalizedCellType> const types=mesh->getAllGeoTypes();
CPPUNIT_ASSERT_EQUAL(5,(int)types.size());
INTERP_KERNEL::NormalizedCellType expected1[5]={INTERP_KERNEL::NORM_POLYGON, INTERP_KERNEL::NORM_TRI3, INTERP_KERNEL::NORM_QUAD4, INTERP_KERNEL::NORM_TRI6, INTERP_KERNEL::NORM_QUAD8};
- std::set<INTERP_KERNEL::NormalizedCellType> expected1Bis(expected1,expected1+5);
+ std::set<INTERP_KERNEL::NormalizedCellType> const expected1Bis(expected1,expected1+5);
CPPUNIT_ASSERT(expected1Bis==types);
CPPUNIT_ASSERT(mesh->isPresenceOfQuadratic());
CPPUNIT_ASSERT_EQUAL(ToIdType(62),mesh->getNodalConnectivityArrayLen());
MEDCouplingFieldDouble *f2=mesh->getMeasureField(false);
CPPUNIT_ASSERT(f1->getArray()->isEqual(*f2->getArray(),1e-12));
CPPUNIT_ASSERT_EQUAL(ToIdType(48),mesh->getNodalConnectivityArrayLen());
- std::set<INTERP_KERNEL::NormalizedCellType> types2=mesh->getAllGeoTypes();
+ std::set<INTERP_KERNEL::NormalizedCellType> const types2=mesh->getAllGeoTypes();
CPPUNIT_ASSERT_EQUAL(3,(int)types2.size());
INTERP_KERNEL::NormalizedCellType expected2[3]={INTERP_KERNEL::NORM_POLYGON, INTERP_KERNEL::NORM_TRI3, INTERP_KERNEL::NORM_QUAD4};
- std::set<INTERP_KERNEL::NormalizedCellType> expected2Bis(expected2,expected2+3);
+ std::set<INTERP_KERNEL::NormalizedCellType> const expected2Bis(expected2,expected2+3);
CPPUNIT_ASSERT(expected2Bis==types2);
//
f1->decrRef();
DataArrayIdType *cellCor,*nodeCor;
//First test mesh1
mesh1->checkGeoEquivalWith(mesh1,0,1e-12,cellCor,nodeCor);//deepEqual
- CPPUNIT_ASSERT(cellCor==0);
- CPPUNIT_ASSERT(nodeCor==0);
+ CPPUNIT_ASSERT(cellCor==nullptr);
+ CPPUNIT_ASSERT(nodeCor==nullptr);
mesh1->checkGeoEquivalWith(mesh1,1,1e-12,cellCor,nodeCor);//fastEqual
- CPPUNIT_ASSERT(cellCor==0);
- CPPUNIT_ASSERT(nodeCor==0);
+ CPPUNIT_ASSERT(cellCor==nullptr);
+ CPPUNIT_ASSERT(nodeCor==nullptr);
mesh1->checkGeoEquivalWith(mesh1,10,1e-12,cellCor,nodeCor);//deepEqual with geo permutations
- CPPUNIT_ASSERT(cellCor==0);
- CPPUNIT_ASSERT(nodeCor==0);
+ CPPUNIT_ASSERT(cellCor==nullptr);
+ CPPUNIT_ASSERT(nodeCor==nullptr);
//Second test mesh1 and mesh2 are 2 different meshes instance
mesh1->checkGeoEquivalWith(mesh2,0,1e-12,cellCor,nodeCor);//deepEqual
- CPPUNIT_ASSERT(cellCor==0);
- CPPUNIT_ASSERT(nodeCor==0);
+ CPPUNIT_ASSERT(cellCor==nullptr);
+ CPPUNIT_ASSERT(nodeCor==nullptr);
mesh1->checkGeoEquivalWith(mesh2,1,1e-12,cellCor,nodeCor);//fastEqual
- CPPUNIT_ASSERT(cellCor==0);
- CPPUNIT_ASSERT(nodeCor==0);
+ CPPUNIT_ASSERT(cellCor==nullptr);
+ CPPUNIT_ASSERT(nodeCor==nullptr);
mesh1->checkGeoEquivalWith(mesh2,10,1e-12,cellCor,nodeCor);//deepEqual with geo permutations
- CPPUNIT_ASSERT(cellCor==0);
- CPPUNIT_ASSERT(nodeCor==0);
+ CPPUNIT_ASSERT(cellCor==nullptr);
+ CPPUNIT_ASSERT(nodeCor==nullptr);
//Third test : cell permutation by keeping the first the middle and the last as it is.
const mcIdType renum[]={0,2,1,3,4,5,6,8,7,9};
mesh2->renumberCells(renum,false);
CPPUNIT_ASSERT_THROW(mesh1->checkGeoEquivalWith(mesh2,0,1e-12,cellCor,nodeCor),INTERP_KERNEL::Exception);//deepEqual fails
- CPPUNIT_ASSERT(cellCor==0);
- CPPUNIT_ASSERT(nodeCor==0);
+ CPPUNIT_ASSERT(cellCor==nullptr);
+ CPPUNIT_ASSERT(nodeCor==nullptr);
mesh1->checkGeoEquivalWith(mesh2,1,1e-12,cellCor,nodeCor);//fastEqual do not see anything
- CPPUNIT_ASSERT(cellCor==0);
- CPPUNIT_ASSERT(nodeCor==0);
+ CPPUNIT_ASSERT(cellCor==nullptr);
+ CPPUNIT_ASSERT(nodeCor==nullptr);
mesh1->checkGeoEquivalWith(mesh2,10,1e-12,cellCor,nodeCor);//deepEqual with geo permutations
CPPUNIT_ASSERT(cellCor);
CPPUNIT_ASSERT_EQUAL(10,(int)cellCor->getNumberOfTuples());
CPPUNIT_ASSERT_EQUAL(1,(int)cellCor->getNumberOfComponents());
CPPUNIT_ASSERT(std::equal(renum,renum+10,cellCor->getConstPointer()));
- CPPUNIT_ASSERT(nodeCor==0);
+ CPPUNIT_ASSERT(nodeCor==nullptr);
cellCor->decrRef();
- cellCor=0;
- CPPUNIT_ASSERT(nodeCor==0);
+ cellCor=nullptr;
+ CPPUNIT_ASSERT(nodeCor==nullptr);
//4th test : cell and node permutation by keeping the first the middle and the last as it is.
mesh2->decrRef();
mesh2=build2DTargetMesh_3();
mesh2->renumberCells(renum,false);
mesh2->renumberNodes(renum2,11);
CPPUNIT_ASSERT_THROW(mesh1->checkGeoEquivalWith(mesh2,0,1e-12,cellCor,nodeCor),INTERP_KERNEL::Exception);//deepEqual fails
- CPPUNIT_ASSERT(cellCor==0);
- CPPUNIT_ASSERT(nodeCor==0);
+ CPPUNIT_ASSERT(cellCor==nullptr);
+ CPPUNIT_ASSERT(nodeCor==nullptr);
mesh1->checkGeoEquivalWith(mesh2,1,1e-12,cellCor,nodeCor);//fastEqual do not see anything
- CPPUNIT_ASSERT(cellCor==0);
- CPPUNIT_ASSERT(nodeCor==0);
+ CPPUNIT_ASSERT(cellCor==nullptr);
+ CPPUNIT_ASSERT(nodeCor==nullptr);
mesh1->checkGeoEquivalWith(mesh2,10,1e-12,cellCor,nodeCor);//deepEqual with geo permutations
CPPUNIT_ASSERT(cellCor);
CPPUNIT_ASSERT_EQUAL(10,(int)cellCor->getNumberOfTuples());
CPPUNIT_ASSERT_EQUAL(1,(int)nodeCor->getNumberOfComponents());
CPPUNIT_ASSERT(std::equal(renum2,renum2+11,nodeCor->getConstPointer()));
cellCor->decrRef();
- cellCor=0;
+ cellCor=nullptr;
nodeCor->decrRef();
- nodeCor=0;
+ nodeCor=nullptr;
//5th test : modification of the last cell to check fastCheck detection.
mesh2->decrRef();
mesh2=build2DTargetMesh_3();
}
catch(INTERP_KERNEL::Exception&) { isExcep=true; }
CPPUNIT_ASSERT(isExcep); isExcep=false;
- CPPUNIT_ASSERT(cellCor==0);
- CPPUNIT_ASSERT(nodeCor==0);
+ CPPUNIT_ASSERT(cellCor==nullptr);
+ CPPUNIT_ASSERT(nodeCor==nullptr);
try { mesh1->checkGeoEquivalWith(mesh2,1,1e-12,cellCor,nodeCor);//fastEqual has detected something
}
catch(INTERP_KERNEL::Exception&) { isExcep=true; }
CPPUNIT_ASSERT(isExcep); isExcep=false;
- CPPUNIT_ASSERT(cellCor==0);
- CPPUNIT_ASSERT(nodeCor==0);
+ CPPUNIT_ASSERT(cellCor==nullptr);
+ CPPUNIT_ASSERT(nodeCor==nullptr);
mesh2->checkGeoEquivalWith(mesh1,10,1e-12,cellCor,nodeCor);//deepEqual with geo permutations
CPPUNIT_ASSERT(cellCor);
CPPUNIT_ASSERT_EQUAL(10,(int)cellCor->getNumberOfTuples());
CPPUNIT_ASSERT_EQUAL(1,(int)nodeCor->getNumberOfComponents());
CPPUNIT_ASSERT(std::equal(renum2,renum2+11,nodeCor->getConstPointer()));
cellCor->decrRef();
- cellCor=0;
+ cellCor=nullptr;
nodeCor->decrRef();
- nodeCor=0;
+ nodeCor=nullptr;
//
mesh1->decrRef();
mesh2->decrRef();
MEDCouplingUMesh *mesh2=build2DTargetMesh_1();
DataArrayIdType *cellCor,*nodeCor;
mesh1->checkGeoEquivalWith(mesh2,10,1e-12,cellCor,nodeCor);
- CPPUNIT_ASSERT(cellCor==0);
- CPPUNIT_ASSERT(nodeCor!=0);
+ CPPUNIT_ASSERT(cellCor==nullptr);
+ CPPUNIT_ASSERT(nodeCor!=nullptr);
const mcIdType expected1[9]={0, 1, 3, 4, 5, 6, 7, 8, 9};
for(int i=0;i<9;i++)
CPPUNIT_ASSERT_EQUAL(expected1[i],nodeCor->getIJ(i,0));
void MEDCouplingBasicsTest2::testCopyTinyStringsFromOnFields()
{
MEDCouplingUMesh *m=build3DSurfTargetMesh_1();
- std::size_t nbOfCells=m->getNumberOfCells();
+ std::size_t const nbOfCells=m->getNumberOfCells();
MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_CELLS,LINEAR_TIME);
f->setMesh(m);
CPPUNIT_ASSERT_EQUAL(ToIdType(5),f->getNumberOfMeshPlacesExpected());
void MEDCouplingBasicsTest2::testGetMaxValue1()
{
MEDCouplingUMesh *m=build3DSurfTargetMesh_1();
- std::size_t nbOfCells=m->getNumberOfCells();
+ std::size_t const nbOfCells=m->getNumberOfCells();
MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_CELLS,LINEAR_TIME);
f->setMesh(m);
DataArrayDouble *a1=DataArrayDouble::New();
CPPUNIT_ASSERT_EQUAL(6,(int)f2->getMesh()->getNumberOfNodes());
CPPUNIT_ASSERT_EQUAL(2,f2->getMesh()->getSpaceDimension());
CPPUNIT_ASSERT_EQUAL(2,f2->getMesh()->getMeshDimension());
- MEDCouplingUMesh *m2C=dynamic_cast<MEDCouplingUMesh *>(const_cast<MEDCouplingMesh *>(f2->getMesh()));
+ auto *m2C=dynamic_cast<MEDCouplingUMesh *>(const_cast<MEDCouplingMesh *>(f2->getMesh()));
CPPUNIT_ASSERT_EQUAL(ToIdType(13),m2C->getNodalConnectivityArrayLen());
const double expected2[12]={0.2, -0.3, 0.7, -0.3, 0.2, 0.2, 0.7, 0.2, 0.2, 0.7, 0.7, 0.7};
for(int i=0;i<12;i++)
CPPUNIT_ASSERT_DOUBLES_EQUAL(5.6,f2->getIJ(i,0),1e-13);
f2->decrRef();
//
- DataArrayIdType *d2I=0;
+ DataArrayIdType *d2I=nullptr;
DataArrayDouble *d2=array->maxPerTupleWithCompoId(d2I);
CPPUNIT_ASSERT_EQUAL(1,(int)d2->getNumberOfComponents());
CPPUNIT_ASSERT_EQUAL(5,(int)d2->getNumberOfTuples());
mesh2->getCoords()->setInfoOnComponent(1,"");
CPPUNIT_ASSERT(mesh1->isEqual(mesh2,1e-12));
CPPUNIT_ASSERT(mesh1->isEqualWithoutConsideringStr(mesh2,1e-12));
- double tmp=mesh2->getCoords()->getIJ(0,3);
+ double const tmp=mesh2->getCoords()->getIJ(0,3);
mesh2->getCoords()->setIJ(0,3,9999.);
CPPUNIT_ASSERT(!mesh1->isEqual(mesh2,1e-12));
CPPUNIT_ASSERT(!mesh1->isEqualWithoutConsideringStr(mesh2,1e-12));
mesh2->getCoords()->setIJ(0,3,tmp);
CPPUNIT_ASSERT(mesh1->isEqual(mesh2,1e-12));
CPPUNIT_ASSERT(mesh1->isEqualWithoutConsideringStr(mesh2,1e-12));
- mcIdType tmp2=mesh2->getNodalConnectivity()->getIJ(0,4);
+ mcIdType const tmp2=mesh2->getNodalConnectivity()->getIJ(0,4);
mesh2->getNodalConnectivity()->setIJ(0,4,0);
CPPUNIT_ASSERT(!mesh1->isEqual(mesh2,1e-12));
CPPUNIT_ASSERT(!mesh1->isEqualWithoutConsideringStr(mesh2,1e-12));
#include "MEDCouplingBasicsTest.hxx"
-#include <map>
-#include <vector>
+#include <cppunit/extensions/HelperMacros.h>
namespace MEDCoupling
{
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingBasicsTest3.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingPointSet.hxx"
+#include "MCIdType.hxx"
+#include "MCAuto.hxx"
+#include "InterpKernelException.hxx"
#include "MEDCouplingUMesh.hxx"
#include "MEDCouplingCMesh.hxx"
#include "MEDCouplingMappedExtrudedMesh.hxx"
#include "MEDCouplingFieldDouble.hxx"
-#include "MEDCouplingMemArray.hxx"
#include "MEDCouplingMemArray.txx"
#include "MEDCouplingGaussLocalization.hxx"
+#include "NormalizedGeometricTypes"
+#include <algorithm>
#include <cmath>
-#include <functional>
-#include <iterator>
+#include <cppunit/TestAssert.h>
+#include <cstddef>
+#include <vector>
+#include <sstream>
+#include <math.h>
+#include <set>
using namespace MEDCoupling;
MEDCouplingUMesh *m2=build2DTargetMesh_1();
const mcIdType cells1[3]={2,3,4};
MEDCouplingPointSet *m3_1=m2->buildPartOfMySelf(cells1,cells1+3,true);
- MEDCouplingUMesh *m3=dynamic_cast<MEDCouplingUMesh *>(m3_1);
+ auto *m3=dynamic_cast<MEDCouplingUMesh *>(m3_1);
CPPUNIT_ASSERT(m3);
m2->decrRef();
MEDCouplingUMesh *m4=build2DSourceMesh_1();
void MEDCouplingBasicsTest3::testFieldDoubleGetMinMaxValues2()
{
- MEDCouplingUMesh *m1=0;
+ MEDCouplingUMesh *m1=nullptr;
MEDCouplingUMesh *m2=build3DExtrudedUMesh_1(m1);
m1->decrRef();
CPPUNIT_ASSERT_EQUAL(18,(int)m2->getNumberOfCells());
a1->setInfoOnComponent(2,"cccc");
a1->setInfoOnComponent(3,"dddd");
const mcIdType arr2[6]={1,2,1,2,0,0};
- std::vector<std::size_t> arr2V(arr2,arr2+6);
- DataArrayDouble *a2=static_cast<DataArrayDouble *>(a1->keepSelectedComponents(arr2V));
+ std::vector<std::size_t> const arr2V(arr2,arr2+6);
+ auto *a2=static_cast<DataArrayDouble *>(a1->keepSelectedComponents(arr2V));
CPPUNIT_ASSERT_EQUAL(6,(int)a2->getNumberOfComponents());
CPPUNIT_ASSERT_EQUAL(5,(int)a2->getNumberOfTuples());
CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(0))=="bbbb");
for(int i=0;i<30;i++)
CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],a2->getIJ(0,i),1e-14);
MCAuto<DataArrayInt> a3(a1->convertToIntArr());
- DataArrayInt *a4=static_cast<DataArrayInt *>(a3->keepSelectedComponents(arr2V));
+ auto *a4=static_cast<DataArrayInt *>(a3->keepSelectedComponents(arr2V));
CPPUNIT_ASSERT_EQUAL(6,(int)a4->getNumberOfComponents());
CPPUNIT_ASSERT_EQUAL(5,(int)a4->getNumberOfTuples());
CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(0))=="bbbb");
CPPUNIT_ASSERT_EQUAL((int)expected1[i],a4->getIJ(0,i));
// setSelectedComponents
const mcIdType arr3[2]={3,2};
- std::vector<std::size_t> arr3V(arr3,arr3+2);
- DataArrayDouble *a5=static_cast<DataArrayDouble *>(a1->keepSelectedComponents(arr3V));
+ std::vector<std::size_t> const arr3V(arr3,arr3+2);
+ auto *a5=static_cast<DataArrayDouble *>(a1->keepSelectedComponents(arr3V));
a5->setInfoOnComponent(0,"eeee");
a5->setInfoOnComponent(1,"ffff");
const mcIdType arr4[2]={1,2};
- std::vector<std::size_t> arr4V(arr4,arr4+2);
+ std::vector<std::size_t> const arr4V(arr4,arr4+2);
a2->setSelectedComponents(a5,arr4V);
CPPUNIT_ASSERT_EQUAL(6,(int)a2->getNumberOfComponents());
CPPUNIT_ASSERT_EQUAL(5,(int)a2->getNumberOfTuples());
const mcIdType arr5[3]={2,3,6};
const mcIdType arr6[3]={2,7,5};
const mcIdType arr7[4]={2,1,4,6};
- std::vector<std::size_t> arr5V(arr5,arr5+3);
- std::vector<std::size_t> arr6V(arr6,arr6+3);
+ std::vector<std::size_t> const arr5V(arr5,arr5+3);
+ std::vector<std::size_t> const arr6V(arr6,arr6+3);
std::vector<std::size_t> arr7V(arr7,arr7+4);
CPPUNIT_ASSERT_THROW(a2->keepSelectedComponents(arr5V),INTERP_KERNEL::Exception);
CPPUNIT_ASSERT_THROW(a2->keepSelectedComponents(arr6V),INTERP_KERNEL::Exception);
f1->checkConsistencyLight();
//
const mcIdType arr2[6]={1,2,1,2,0,0};
- std::vector<std::size_t> arr2V(arr2,arr2+6);
+ std::vector<std::size_t> const arr2V(arr2,arr2+6);
MEDCouplingFieldDouble *f2=f1->keepSelectedComponents(arr2V);
CPPUNIT_ASSERT(f2->getMesh()==f1->getMesh());
CPPUNIT_ASSERT(f2->getTimeDiscretization()==ONE_TIME);
CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f2->getIJ(0,i),1e-14);
//setSelectedComponents
const mcIdType arr3[2]={3,2};
- std::vector<std::size_t> arr3V(arr3,arr3+2);
+ std::vector<std::size_t> const arr3V(arr3,arr3+2);
MEDCouplingFieldDouble *f5=f1->keepSelectedComponents(arr3V);
f5->setTime(6.7,8,9);
f5->getArray()->setInfoOnComponent(0,"eeee");
f5->getArray()->setInfoOnComponent(1,"ffff");
f5->checkConsistencyLight();
const mcIdType arr4[2]={1,2};
- std::vector<std::size_t> arr4V(arr4,arr4+2);
+ std::vector<std::size_t> const arr4V(arr4,arr4+2);
f2->setSelectedComponents(f5,arr4V);
CPPUNIT_ASSERT_EQUAL(6,(int)f2->getNumberOfComponents());
CPPUNIT_ASSERT_EQUAL(5,(int)f2->getNumberOfTuples());
CPPUNIT_ASSERT(!((dbl->reprZip().find("Number of components : 1"))==std::string::npos));
std::ostringstream ret;
- dbl->writeVTK(ret,2,"file.tmp",0);
+ dbl->writeVTK(ret,2,"file.tmp",nullptr);
CPPUNIT_ASSERT(!((ret.str().find("<DataArray"))==std::string::npos));
CPPUNIT_ASSERT(!((ret.str().find("Float32"))==std::string::npos));
CPPUNIT_ASSERT(!((ret.str().find("16 15 14 13 12 11 10"))==std::string::npos));
CPPUNIT_ASSERT_EQUAL(ToIdType(9),c->getIJ(1,0));
CPPUNIT_ASSERT_EQUAL(ToIdType(11),c->getIJ(2,0));
c->decrRef();
- DataArrayIdType *cI=0;
+ DataArrayIdType *cI=nullptr;
mesh->getNodeIdsNearPoints(pts,3,1e-7,c,cI);
CPPUNIT_ASSERT_EQUAL(ToIdType(4),cI->getNumberOfTuples());
CPPUNIT_ASSERT_EQUAL(ToIdType(4),c->getNumberOfTuples());
f->changeSpaceDimension(2);
//
const double center[2]={0.,0.};
- f->rotate(center,0,M_PI/3);
+ f->rotate(center,nullptr,M_PI/3);
MEDCouplingUMesh *g=c->buildExtrudedMesh(f,0);
g->checkConsistencyLight();
const double expected1[]={ 0.4330127018922193, 0.4330127018922193, 0.649519052838329, 1.2990381056766578, 1.299038105676658, 1.948557158514987, 2.1650635094610955, 2.1650635094610964, 3.2475952641916446, 3.031088913245533, 3.0310889132455352, 4.546633369868303 };
for(int i=0;i<15;i++)
CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f3->getIJ(0,i),1e-12);
int dt,it;
- double time=f3->getTime(dt,it);
+ double const time=f3->getTime(dt,it);
CPPUNIT_ASSERT_DOUBLES_EQUAL(3.4,time,1e-14);
CPPUNIT_ASSERT_EQUAL(2,dt);
CPPUNIT_ASSERT_EQUAL(1,it);
{
MEDCouplingUMesh *m=build3DSurfTargetMesh_1();
const mcIdType pt[2]={1,3};
- MEDCouplingUMesh *m2=(MEDCouplingUMesh *)m->buildPartOfMySelf(pt,pt+2,true);
+ auto *m2=(MEDCouplingUMesh *)m->buildPartOfMySelf(pt,pt+2,true);
DataArrayIdType *tmp;
CPPUNIT_ASSERT(m->areCellsIncludedIn(m2,0,tmp));
CPPUNIT_ASSERT_EQUAL(2,(int)tmp->getNumberOfTuples());
{
const char myName[]="Vitoo";
MEDCouplingUMesh *m=build3DSurfTargetMesh_1();
- MEDCouplingUMesh *m2=(MEDCouplingUMesh *)m->buildPartOfMySelf(0,0,true);
+ auto *m2=(MEDCouplingUMesh *)m->buildPartOfMySelf(nullptr,nullptr,true);
CPPUNIT_ASSERT_EQUAL(0,(int)m2->getNumberOfCells());
CPPUNIT_ASSERT_EQUAL(3,m2->getSpaceDimension());
CPPUNIT_ASSERT_EQUAL(2,m2->getMeshDimension());
MEDCouplingUMesh *m3=build3DSurfTargetMesh_1();
//
const mcIdType vec1[3]={0,2,3};
- MEDCouplingUMesh *m2_2=(MEDCouplingUMesh *)m2->buildPartOfMySelf(vec1,vec1+3,false);
+ auto *m2_2=(MEDCouplingUMesh *)m2->buildPartOfMySelf(vec1,vec1+3,false);
const mcIdType vec2[2]={1,1};
- MEDCouplingUMesh *m3_2=(MEDCouplingUMesh *)m3->buildPartOfMySelf(vec2,vec2+2,false);
+ auto *m3_2=(MEDCouplingUMesh *)m3->buildPartOfMySelf(vec2,vec2+2,false);
//
std::vector<const MEDCouplingUMesh *> ms(3);
std::vector<const MEDCouplingMesh *> ms2(3);
m4bis->decrRef();
//
const mcIdType vec3[5]={0,1,2,3,4};
- MEDCouplingUMesh *m4_1=(MEDCouplingUMesh *)m4->buildPartOfMySelf(vec3,vec3+5,false);
+ auto *m4_1=(MEDCouplingUMesh *)m4->buildPartOfMySelf(vec3,vec3+5,false);
m4_1->setName(m1->getName().c_str());
CPPUNIT_ASSERT(m4_1->isEqual(m1,1e-12));
m4_1->decrRef();
//
const mcIdType vec4[3]={5,6,7};
- MEDCouplingUMesh *m4_2=(MEDCouplingUMesh *)m4->buildPartOfMySelf(vec4,vec4+3,false);
- DataArrayIdType *cellCor=0;
- DataArrayIdType *nodeCor=0;
+ auto *m4_2=(MEDCouplingUMesh *)m4->buildPartOfMySelf(vec4,vec4+3,false);
+ DataArrayIdType *cellCor=nullptr;
+ DataArrayIdType *nodeCor=nullptr;
m4_2->checkGeoEquivalWith(m2_2,10,1e-12,cellCor,nodeCor);
- CPPUNIT_ASSERT(cellCor==0);
- CPPUNIT_ASSERT(nodeCor==0);
+ CPPUNIT_ASSERT(cellCor==nullptr);
+ CPPUNIT_ASSERT(nodeCor==nullptr);
m4_2->decrRef();
//
const mcIdType vec5[2]={8,9};
- MEDCouplingUMesh *m4_3=(MEDCouplingUMesh *)m4->buildPartOfMySelf(vec5,vec5+2,false);
+ auto *m4_3=(MEDCouplingUMesh *)m4->buildPartOfMySelf(vec5,vec5+2,false);
CPPUNIT_ASSERT_EQUAL(2,(int)m4_3->getNumberOfCells());
CPPUNIT_ASSERT_EQUAL(3,(int)m4_3->getNumberOfNodes());
m3_2->zipCoords();
CPPUNIT_ASSERT_EQUAL(4,(int)m->getNumberOfCells());
CPPUNIT_ASSERT_EQUAL(3,m->getSpaceDimension());
CPPUNIT_ASSERT_EQUAL(0,m->getMeshDimension());
- std::set<INTERP_KERNEL::NormalizedCellType> types=m->getAllGeoTypes();
+ std::set<INTERP_KERNEL::NormalizedCellType> const types=m->getAllGeoTypes();
CPPUNIT_ASSERT_EQUAL(1,(int)types.size());
CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_POINT1,*types.begin());
for(int i=0;i<4;i++)
#include "MEDCouplingBasicsTest.hxx"
-#include <map>
-#include <vector>
+#include <cppunit/extensions/HelperMacros.h>
namespace MEDCoupling
{
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingBasicsTest4.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "InterpKernelException.hxx"
+#include "MEDCouplingDefinitionTime.hxx"
+#include "MCType.hxx"
+#include "MCIdType.hxx"
+#include "MCAuto.hxx"
#include "MEDCouplingUMesh.hxx"
#include "MEDCouplingCMesh.hxx"
#include "MEDCouplingMappedExtrudedMesh.hxx"
#include "MEDCouplingFieldDouble.hxx"
-#include "MEDCouplingMemArray.txx"
#include "MEDCouplingGaussLocalization.hxx"
#include "MEDCouplingMultiFields.hxx"
#include "MEDCouplingFieldOverTime.hxx"
+#include "NormalizedGeometricTypes"
+#include <algorithm>
#include <cmath>
-#include <functional>
-#include <iterator>
+#include <cppunit/TestAssert.h>
+#include <cstddef>
+#include <vector>
+#include <math.h>
using namespace MEDCoupling;
MEDCouplingUMesh *m=build2DTargetMesh_1();
m->setDescription(text1);
CPPUNIT_ASSERT(std::string(m->getDescription())==text1);
- MEDCouplingUMesh *m2=(MEDCouplingUMesh *)m->deepCopy();
+ auto *m2=(MEDCouplingUMesh *)m->deepCopy();
CPPUNIT_ASSERT(m->isEqual(m2,1e-12));
CPPUNIT_ASSERT(std::string(m2->getDescription())==text1);
m2->setDescription("ggg");
void MEDCouplingBasicsTest4::testMultiFields1()
{
MEDCouplingMultiFields *mfs=buildMultiFields_1();
- std::vector<MEDCouplingMesh *> ms=mfs->getMeshes();
+ std::vector<MEDCouplingMesh *> const ms=mfs->getMeshes();
std::vector<int> refs;
- std::vector<MEDCouplingMesh *> dms=mfs->getDifferentMeshes(refs);
- std::vector<DataArrayDouble *> das=mfs->getArrays();
+ std::vector<MEDCouplingMesh *> const dms=mfs->getDifferentMeshes(refs);
+ std::vector<DataArrayDouble *> const das=mfs->getArrays();
std::vector< std::vector<int> > refs2;
- std::vector<DataArrayDouble *> das2=mfs->getDifferentArrays(refs2);
+ std::vector<DataArrayDouble *> const das2=mfs->getDifferentArrays(refs2);
//
CPPUNIT_ASSERT_EQUAL(5,(int)ms.size());
CPPUNIT_ASSERT_EQUAL(2,(int)dms.size());
CPPUNIT_ASSERT_THROW(MEDCouplingFieldOverTime::New(fs),INTERP_KERNEL::Exception);
f4bis->setTime(2.7,20,21);
MEDCouplingFieldOverTime *fot=MEDCouplingFieldOverTime::New(fs);
- MEDCouplingDefinitionTime dt=fot->getDefinitionTimeZone();
+ MEDCouplingDefinitionTime const dt=fot->getDefinitionTimeZone();
std::vector<double> hs=dt.getHotSpotsTime();
CPPUNIT_ASSERT_EQUAL(6,(int)hs.size());
const double expected1[]={0.2,0.7,1.2,1.35,1.7,2.7};
dt3.unserialize(tmp1,tmp2);
CPPUNIT_ASSERT(dt2.isEqual(dt3));
//
- for(std::vector<MEDCouplingFieldDouble *>::iterator it=fs.begin();it!=fs.end();it++)
- (*it)->decrRef();
+ for(auto & f : fs)
+ f->decrRef();
fot->decrRef();
}
CPPUNIT_ASSERT(!m1->isEqual(m2,1e-12));
//
m1->setTime(10.34,55,12);
- MEDCouplingUMesh *m3=(MEDCouplingUMesh *)m1->deepCopy();
+ auto *m3=(MEDCouplingUMesh *)m1->deepCopy();
CPPUNIT_ASSERT(m1->isEqual(m3,1e-12));
tmp3=m3->getTime(tmp1,tmp2);
CPPUNIT_ASSERT_EQUAL(55,tmp1);
CPPUNIT_ASSERT_EQUAL(8,tmp1);
CPPUNIT_ASSERT_EQUAL(100,tmp2);
CPPUNIT_ASSERT_DOUBLES_EQUAL(5.67,tmp3,1e-12);
- MEDCouplingCMesh *c=(MEDCouplingCMesh *)b->deepCopy();
+ auto *c=(MEDCouplingCMesh *)b->deepCopy();
CPPUNIT_ASSERT(c->isEqual(b,1e-12));
tmp3=c->getTime(tmp1,tmp2);
CPPUNIT_ASSERT_EQUAL(8,tmp1);
std::vector<double> gsCoo1(1); gsCoo1[0]=0.2;
std::vector<double> refCoo1(2); refCoo1[0]=-1.0; refCoo1[1]=1.0;
f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_SEG2,refCoo1,gsCoo1,wg1);
- std::vector<double> wg2(wg1);
+ std::vector<double> const wg2(wg1);
std::vector<double> gsCoo2(1); gsCoo2[0]=0.2;
std::vector<double> refCoo2(3); refCoo2[0]=-1.0; refCoo2[1]=1.0; refCoo2[2]=0.0;
f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_SEG3,refCoo2,gsCoo2,wg2);
f->setMesh(m2);
std::vector<double> wg3(2); wg3[0]=0.3; wg3[1]=0.3;
const double tria3CooGauss[4]={ 0.1, 0.8, 0.2, 0.7 };
- std::vector<double> gsCoo3(tria3CooGauss,tria3CooGauss+4);
+ std::vector<double> const gsCoo3(tria3CooGauss,tria3CooGauss+4);
const double tria3CooRef[6]={ 0.0, 0.0, 1.0 , 0.0, 0.0, 1.0 };
- std::vector<double> refCoo3(tria3CooRef,tria3CooRef+6);
+ std::vector<double> const refCoo3(tria3CooRef,tria3CooRef+6);
f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_TRI3,refCoo3,gsCoo3,wg3);
std::vector<double> wg4(3); wg4[0]=0.3; wg4[1]=0.3; wg4[2]=0.3;
const double tria6CooGauss[6]={ 0.3, 0.2, 0.2, 0.1, 0.2, 0.4 };
- std::vector<double> gsCoo4(tria6CooGauss,tria6CooGauss+6);
+ std::vector<double> const gsCoo4(tria6CooGauss,tria6CooGauss+6);
const double tria6CooRef[12]={0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.5, 0.0, 0.5, 0.5, 0.0, 0.5};
- std::vector<double> refCoo4(tria6CooRef,tria6CooRef+12);
+ std::vector<double> const refCoo4(tria6CooRef,tria6CooRef+12);
f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_TRI6,refCoo4,gsCoo4,wg4);
std::vector<double> wg5(4); wg5[0]=0.3; wg5[1]=0.3; wg5[2]=0.3; wg5[3]=0.3;
const double quad4CooGauss[8]={ 0.3, 0.2, 0.2, 0.1, 0.2, 0.4, 0.15, 0.27 };
- std::vector<double> gsCoo5(quad4CooGauss,quad4CooGauss+8);
+ std::vector<double> const gsCoo5(quad4CooGauss,quad4CooGauss+8);
const double quad4CooRef[8]={-1.0, 1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0};
- std::vector<double> refCoo5(quad4CooRef,quad4CooRef+8);
+ std::vector<double> const refCoo5(quad4CooRef,quad4CooRef+8);
f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_QUAD4,refCoo5,gsCoo5,wg5);
std::vector<double> wg6(4); wg6[0]=0.3; wg6[1]=0.3; wg6[2]=0.3; wg6[3]=0.3;
const double quad8CooGauss[8]={ 0.34, 0.16, 0.21, 0.3, 0.23, 0.4, 0.14, 0.37 };
- std::vector<double> gsCoo6(quad8CooGauss,quad8CooGauss+8);
+ std::vector<double> const gsCoo6(quad8CooGauss,quad8CooGauss+8);
const double quad8CooRef[16]={ -1.0, -1.0, 1.0, -1.0, 1.0, 1.0, -1.0, 1.0, 0.0, -1.0, 1.0, 0.0, 0.0, 1.0, -1.0, 0.0};
- std::vector<double> refCoo6(quad8CooRef,quad8CooRef+16);
+ std::vector<double> const refCoo6(quad8CooRef,quad8CooRef+16);
f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_QUAD8,refCoo6,gsCoo6,wg6);
//
resToTest=f->getLocalizationOfDiscr();
//
std::vector<double> wg7(1); wg7[0]=0.3;
const double tetra4CooGauss[3]={0.34, 0.16, 0.21};
- std::vector<double> gsCoo7(tetra4CooGauss,tetra4CooGauss+3);
+ std::vector<double> const gsCoo7(tetra4CooGauss,tetra4CooGauss+3);
const double tetra4CooRef[12]={0.0,1.0,0.0, 0.0,0.0,1.0, 0.0,0.0,0.0, 1.0,0.0,0.0};
- std::vector<double> refCoo7(tetra4CooRef,tetra4CooRef+12);
+ std::vector<double> const refCoo7(tetra4CooRef,tetra4CooRef+12);
f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_TETRA4,refCoo7,gsCoo7,wg7);
std::vector<double> wg8(1); wg8[0]=0.3;
const double tetra10CooGauss[3]={0.2, 0.3, 0.1};
- std::vector<double> gsCoo8(tetra10CooGauss,tetra10CooGauss+3);
+ std::vector<double> const gsCoo8(tetra10CooGauss,tetra10CooGauss+3);
const double tetra10CooRef[30]={0.0,1.0,0.0, 0.0,0.0,0.0, 0.0,0.0,1.0, 1.0,0.0,0.0, 0.0,0.5,0.0, 0.0,0.0,0.5, 0.0,0.5,0.5, 0.5,0.5,0.0, 0.5,0.0,0.0, 0.5,0.0,0.5};
- std::vector<double> refCoo8(tetra10CooRef,tetra10CooRef+30);
+ std::vector<double> const refCoo8(tetra10CooRef,tetra10CooRef+30);
f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_TETRA10,refCoo8,gsCoo8,wg8);
std::vector<double> wg9(1); wg9[0]=0.3;
const double pyra5CooGauss[3]={0.2, 0.3, 0.1};
- std::vector<double> gsCoo9(pyra5CooGauss,pyra5CooGauss+3);
+ std::vector<double> const gsCoo9(pyra5CooGauss,pyra5CooGauss+3);
const double pyra5CooRef[15]={1.0,0.0,0.0, 0.0,1.0,0.0, -1.0,0.0,0.0, 0.0,-1.0,0.0, 0.0,0.0,1.0};
- std::vector<double> refCoo9(pyra5CooRef,pyra5CooRef+15);
+ std::vector<double> const refCoo9(pyra5CooRef,pyra5CooRef+15);
f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_PYRA5,refCoo9,gsCoo9,wg9);
std::vector<double> wg10(1); wg10[0]=0.3;
const double pyra13CooGauss[3]={0.1, 0.2, 0.7};
- std::vector<double> gsCoo10(pyra13CooGauss,pyra13CooGauss+3);
+ std::vector<double> const gsCoo10(pyra13CooGauss,pyra13CooGauss+3);
const double pyra13CooRef[39]={1.0,0.0,0.0, 0.0,1.0,0.0,-1.0,0.0,0.0,0.0,-1.0,0.0,0.0,0.0,1.0,0.5,0.5,0.0,-0.5,0.5,0.0,-0.5,-0.5,0.0,0.5,-0.5,0.0,0.5,0.0,0.5,0.0,0.5,0.5,-0.5,0.0,0.5,0.0,-0.5,0.5};
- std::vector<double> refCoo10(pyra13CooRef,pyra13CooRef+39);
+ std::vector<double> const refCoo10(pyra13CooRef,pyra13CooRef+39);
f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_PYRA13,refCoo10,gsCoo10,wg10);
std::vector<double> wg11(1); wg11[0]=0.3;
const double penta6CooGauss[3]={0.2, 0.3, 0.1};
- std::vector<double> gsCoo11(penta6CooGauss,penta6CooGauss+3);
+ std::vector<double> const gsCoo11(penta6CooGauss,penta6CooGauss+3);
const double penta6CooRef[18]={-1.0,1.0,0.0,-1.0,-0.0,1.0,-1.0,0.0,0.0,1.0,1.0,0.0,1.0,0.0,1.0,1.0,0.0,0.0};
- std::vector<double> refCoo11(penta6CooRef,penta6CooRef+18);
+ std::vector<double> const refCoo11(penta6CooRef,penta6CooRef+18);
f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_PENTA6,refCoo11,gsCoo11,wg11);
std::vector<double> wg12(1); wg12[0]=0.3;
const double penta15CooGauss[3]={0.2, 0.3,0.15};
- std::vector<double> gsCoo12(penta15CooGauss,penta15CooGauss+3);
+ std::vector<double> const gsCoo12(penta15CooGauss,penta15CooGauss+3);
const double penta15CooRef[45]={-1.0,1.0,0.0,-1.0,0.0,1.0,-1.0,0.0,0.0,1.0,1.0,0.0,1.0,0.0,1.0,1.0,0.0,0.0,-1.0,0.5,0.5,-1.0,0.0,0.5,-1.0,0.5,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.5,0.5,1.0,0.0, 0.5,1.0,0.5,0.0};
- std::vector<double> refCoo12(penta15CooRef,penta15CooRef+45);
+ std::vector<double> const refCoo12(penta15CooRef,penta15CooRef+45);
f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_PENTA15,refCoo12,gsCoo12,wg12);
std::vector<double> wg13(1); wg13[0]=0.3;
const double hexa8CooGauss[3]={0.2,0.3,0.15};
- std::vector<double> gsCoo13(hexa8CooGauss,hexa8CooGauss+3);
+ std::vector<double> const gsCoo13(hexa8CooGauss,hexa8CooGauss+3);
const double hexa8CooRef[24]={-1.0,-1.0,-1.0,1.0,-1.0,-1.0,1.0,1.0,-1.0,-1.0,1.0,-1.0,-1.0,-1.0,1.0,1.0,-1.0,1.0,1.0,1.0,1.0,-1.0,1.0,1.0};
- std::vector<double> refCoo13(hexa8CooRef,hexa8CooRef+24);
+ std::vector<double> const refCoo13(hexa8CooRef,hexa8CooRef+24);
f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_HEXA8,refCoo13,gsCoo13,wg13);
std::vector<double> wg14(1); wg14[0]=0.3;
const double hexa20CooGauss[3]={0.11,0.3,0.55};
- std::vector<double> gsCoo14(hexa20CooGauss,hexa20CooGauss+3);
+ std::vector<double> const gsCoo14(hexa20CooGauss,hexa20CooGauss+3);
const double hexa20CooRef[60]={-1.0,-1.0,-1.0,1.0,-1.0,-1.0,1.0,1.0,-1.0,-1.0,1.0,-1.0,-1.0,-1.0,1.0,1.0,-1.0,1.0,1.0,1.0,1.0,-1.0,1.0,1.0,0.0,-1.0,-1.0,1.0,0.0,-1.0,0.0,1.0,-1.0,-1.0,0.0,-1.0,-1.0,-1.0,0.0,1.0,-1.0,0.0,1.0,1.0,0.0,-1.0,1.0,0.0,0.0,-1.0,1.0,1.0,0.0,1.0,0.0,1.0,1.0,-1.0,0.0,1.0};
- std::vector<double> refCoo14(hexa20CooRef,hexa20CooRef+60);
+ std::vector<double> const refCoo14(hexa20CooRef,hexa20CooRef+60);
f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_HEXA20,refCoo14,gsCoo14,wg14);
//
resToTest=f->getLocalizationOfDiscr();
MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME);
f->setMesh(m);
DataArrayDouble *arr=DataArrayDouble::New();
- std::size_t nbOfCells=m->getNumberOfCells();
+ std::size_t const nbOfCells=m->getNumberOfCells();
arr->alloc(nbOfCells,3);
f->setArray(arr);
arr->decrRef();
f=MEDCouplingFieldDouble::New(ON_NODES,NO_TIME);
f->setMesh(m);
arr=DataArrayDouble::New();
- mcIdType nbOfNodes=m->getNumberOfNodes();
+ mcIdType const nbOfNodes=m->getNumberOfNodes();
arr->alloc(nbOfNodes,3);
f->setArray(arr);
arr->decrRef();
m->insertNextCell(INTERP_KERNEL::NORM_TETRA4,4,conn);
m->insertNextCell(INTERP_KERNEL::NORM_TETRA4,4,conn);
m->finishInsertingCells();
- std::vector<const MEDCouplingUMesh *> ms(4,m);
+ std::vector<const MEDCouplingUMesh *> const ms(4,m);
MEDCouplingUMesh *m2=MEDCouplingUMesh::MergeUMeshesOnSameCoords(ms);
std::vector<mcIdType> temp(1,2);
m2->convertToPolyTypes(&temp[0],&temp[0]+temp.size());
void MEDCouplingBasicsTest4::testEmulateMEDMEMBDC1()
{
- MEDCouplingUMesh *m1=0;
+ MEDCouplingUMesh *m1=nullptr;
MEDCouplingUMesh *m=buildPointe_1(m1);
DataArrayIdType *da1=DataArrayIdType::New();
DataArrayIdType *da2=DataArrayIdType::New();
- DataArrayIdType *da3=0;
- DataArrayIdType *da4=0;
- DataArrayIdType *da5=0;
- DataArrayIdType *da0=0;
+ DataArrayIdType *da3=nullptr;
+ DataArrayIdType *da4=nullptr;
+ DataArrayIdType *da5=nullptr;
+ DataArrayIdType *da0=nullptr;
MEDCouplingUMesh *m2=m->emulateMEDMEMBDC(m1,da1,da2,da3,da4,da5,da0);
const mcIdType expected0[47]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,36,37,32,33,34,35,38,39,40,41,42,43,44,45,46};
const mcIdType expected1[6]={1,32,29,23,41,36};
void MEDCouplingBasicsTest4::testGetLevArrPerCellTypes1()
{
- MEDCouplingUMesh *m1=0;
+ MEDCouplingUMesh *m1=nullptr;
MEDCouplingUMesh *m=buildPointe_1(m1);
m1->decrRef();
DataArrayIdType *d0=DataArrayIdType::New();
m1=m->buildDescendingConnectivity(d0,d1,d2,d3);
d0->decrRef(); d1->decrRef(); d2->decrRef(); d3->decrRef();
INTERP_KERNEL::NormalizedCellType order[2]={INTERP_KERNEL::NORM_TRI3,INTERP_KERNEL::NORM_QUAD4};
- DataArrayIdType *da1=0;
+ DataArrayIdType *da1=nullptr;
DataArrayIdType *da0=m1->getLevArrPerCellTypes(order,order+2,da1);
const mcIdType expected0[47]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1};
const mcIdType expected1[47]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,36,37,32,33,34,35,38,39,40,41,42,43,44,45,46};
void MEDCouplingBasicsTest4::testSortCellsInMEDFileFrmt1()
{
- MEDCouplingUMesh *m1=0;
+ MEDCouplingUMesh *m1=nullptr;
MEDCouplingUMesh *m=buildPointe_1(m1);
- MEDCouplingUMesh *m2=(MEDCouplingUMesh *)m->deepCopy();
- m->setCoords(0);
+ auto *m2=(MEDCouplingUMesh *)m->deepCopy();
+ m->setCoords(nullptr);
const mcIdType vals[16]={0,1,2,14,3,12,4,5,15,6,7,8,9,10,11,13};
DataArrayIdType *da=DataArrayIdType::New();
da->alloc(16,1);
DataArrayIdType *d=DataArrayIdType::New();
d->alloc(9,1);
std::copy(val1,val1+9,d->getPointer());
- DataArrayIdType *ee=0,*f=0,*g=0;
+ DataArrayIdType *ee=nullptr,*f=nullptr,*g=nullptr;
d->splitByValueRange(val2,val2+3,ee,f,g);
CPPUNIT_ASSERT_EQUAL(9,(int)ee->getNumberOfTuples());
CPPUNIT_ASSERT_EQUAL(1,(int)ee->getNumberOfComponents());
da->alloc(6,1);
const double array1[6]={2.3,1.2,1.3,2.3,2.301,0.8};
std::copy(array1,array1+6,da->getPointer());
- DataArrayIdType *c=0,*cI=0;
+ DataArrayIdType *c=nullptr,*cI=nullptr;
// nbOftuples=1
da->findCommonTuples(1e-2,-1,c,cI);
const mcIdType expected1[3]={0,3,4};
{
MEDCouplingUMesh *m0=build2DTargetMesh_1();
const mcIdType CellIds[2]={1,2};
- MEDCouplingUMesh *m1=static_cast<MEDCouplingUMesh *>(m0->buildPartOfMySelf(CellIds,CellIds+2,true));
+ auto *m1=static_cast<MEDCouplingUMesh *>(m0->buildPartOfMySelf(CellIds,CellIds+2,true));
mcIdType newNbOfNodes=-1;
DataArrayIdType *arr=m1->getNodeIdsInUse(newNbOfNodes);
const mcIdType expected[9]={-1,0,1,-1,2,3,-1,-1,-1};
m1c->setCoordsAt(1,coordY);
MEDCouplingUMesh *m1=m1c->buildUnstructured();
const mcIdType subPart1[3]={3,4,5};
- MEDCouplingUMesh *m1bis=static_cast<MEDCouplingUMesh *>(m1->buildPartOfMySelf(subPart1,subPart1+3,false));
- MEDCouplingUMesh *m2tmp=static_cast<MEDCouplingUMesh *>(m1->deepCopy());
+ auto *m1bis=static_cast<MEDCouplingUMesh *>(m1->buildPartOfMySelf(subPart1,subPart1+3,false));
+ auto *m2tmp=static_cast<MEDCouplingUMesh *>(m1->deepCopy());
const mcIdType subPart2[3]={0,1,2};
- MEDCouplingUMesh *m2=static_cast<MEDCouplingUMesh *>(m2tmp->buildPartOfMySelf(subPart2,subPart2+3,false));
+ auto *m2=static_cast<MEDCouplingUMesh *>(m2tmp->buildPartOfMySelf(subPart2,subPart2+3,false));
const double vec[2]={0.5,0.5};
m2->translate(vec);
// End of construction of input meshes m1bis and m2 -> start of specific part of the test
- DataArrayIdType *d1=0,*d2=0;
+ DataArrayIdType *d1=nullptr,*d2=nullptr;
MEDCouplingUMesh *m3=MEDCouplingUMesh::Intersect2DMeshes(m1bis,m2,1e-10,d1,d2);
const mcIdType expected1[8]={0,0,1,1,1,2,2,2};
const mcIdType expected2[8]={0,-1,0,1,-1,1,2,-1};
m2c->setCoordsAt(1,coordsY2);
MEDCouplingUMesh *m2=m2c->buildUnstructured();
//
- DataArrayIdType *d1=0,*d2=0;
+ DataArrayIdType *d1=nullptr,*d2=nullptr;
MEDCouplingUMesh *m3=MEDCouplingUMesh::Intersect2DMeshes(m1,m2,1e-10,d1,d2);
const mcIdType expected1[9]={0,0,1,1,2,2,3,4,5};
const mcIdType expected2[9]={0,2,1,3,1,3,2,3,3};
m2->setCoords(myCoords2);
myCoords2->decrRef();
//
- DataArrayIdType *d1=0,*d2=0;
+ DataArrayIdType *d1=nullptr,*d2=nullptr;
MEDCouplingUMesh *m3=MEDCouplingUMesh::Intersect2DMeshes(m1,m2,1e-10,d1,d2);
m3->unPolyze();
const mcIdType expected1[16]={0,1,1,1,2,3,3,3,4,5,5,5,6,7,7,7};
#include "MEDCouplingBasicsTest.hxx"
-#include <map>
-#include <vector>
+#include <cppunit/extensions/HelperMacros.h>
namespace MEDCoupling
{
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingBasicsTest5.hxx"
+#include "MCType.hxx"
+#include "MCIdType.hxx"
+#include "InterpKernelException.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingPointSet.hxx"
#include "MEDCouplingUMesh.hxx"
#include "MEDCouplingCMesh.hxx"
#include "MEDCouplingMappedExtrudedMesh.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "MEDCouplingMemArray.hxx"
-#include "MEDCouplingMemArray.txx"
#include "MEDCouplingGaussLocalization.hxx"
#include "MEDCouplingMultiFields.hxx"
-#include "MEDCouplingFieldOverTime.hxx"
+#include "NormalizedGeometricTypes"
+#include <algorithm>
#include <cmath>
-#include <functional>
-#include <iterator>
+#include <cppunit/TestAssert.h>
+#include <vector>
+#include <string>
+#include <utility>
+#include <math.h>
+#include <set>
using namespace MEDCoupling;
m1->setCoords(myCoords1);
myCoords1->decrRef();
//
- MEDCouplingUMesh *m11=static_cast<MEDCouplingUMesh *>(m1->deepCopy());
+ auto *m11=static_cast<MEDCouplingUMesh *>(m1->deepCopy());
m11->tessellate2D(1.);
CPPUNIT_ASSERT(m11->getCoords()->isEqual(*m11->getCoords(),1e-12));
const mcIdType expected1[48]={5,0,3,11,1,5,3,4,12,2,1,11,5,5,15,3,0,5,6,16,4,3,15,5,5,5,0,7,19,5,6,5,19,7,8,20,5,0,1,23,7,5,1,2,24,8,7,23};
CPPUNIT_ASSERT(std::equal(expected2,expected2+9,m11->getNodalConnectivityIndex()->getConstPointer()));
m11->decrRef();
//
- MEDCouplingUMesh *m12=static_cast<MEDCouplingUMesh *>(m1->deepCopy());
+ auto *m12=static_cast<MEDCouplingUMesh *>(m1->deepCopy());
m12->tessellate2D(0.5);
CPPUNIT_ASSERT_EQUAL(ToIdType(41),m12->getNumberOfNodes());
const mcIdType expected3[60]={5,0,3,25,26,1,5,3,4,27,28,2,1,26,25,5,5,29,30,3,0,5,6,31,32,4,3,30,29,5,5,5,0,7,33,34,5,6,5,34,33,7,8,35,36,5,0,1,37,38,7,5,1,2,39,40,8,7,38,37};
m1->setCoords(myCoords);
myCoords->decrRef();
- MEDCouplingUMesh *m2 = static_cast<MEDCouplingUMesh *>(m1->deepCopy());
+ auto *m2 = static_cast<MEDCouplingUMesh *>(m1->deepCopy());
m2->tessellate2D(0.1);
CPPUNIT_ASSERT_NO_THROW(m2->checkConsistency(0.0)); // eps param not used
m1->decrRef();
m2->setCoords(myCoords2);
myCoords2->decrRef();
//
- DataArrayIdType *d1=0,*d2=0;
+ DataArrayIdType *d1=nullptr,*d2=nullptr;
MEDCouplingUMesh *m3=MEDCouplingUMesh::Intersect2DMeshes(m2,m1,1e-10,d1,d2);
m3->unPolyze();
const mcIdType expected1[16]={0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7};
void MEDCouplingBasicsTest5::testGetCellIdsCrossingPlane1()
{
- MEDCouplingUMesh *mesh2D=0;
+ MEDCouplingUMesh *mesh2D=nullptr;
MEDCouplingUMesh *mesh3D=build3DExtrudedUMesh_1(mesh2D);
const double vec[3]={-0.07,1.,0.07};
const double origin[3]={1.524,1.4552,1.74768};
void MEDCouplingBasicsTest5::testBuildSlice3D1()
{
- MEDCouplingUMesh *mesh2D=0;
+ MEDCouplingUMesh *mesh2D=nullptr;
MEDCouplingUMesh *mesh3D=build3DExtrudedUMesh_1(mesh2D);
mesh2D->decrRef();
// First slice in the middle of 3D cells
const double vec1[3]={-0.07,1.,0.07};
const double origin1[3]={1.524,1.4552,1.74768};
- DataArrayIdType *ids=0;
+ DataArrayIdType *ids=nullptr;
MEDCouplingUMesh *slice1=mesh3D->buildSlice3D(origin1,vec1,1e-10,ids);
const mcIdType expected1[9]={1,3,4,7,9,10,13,15,16};
const mcIdType expected2[47]={5,42,41,40,43,44,5,42,46,45,41,5,44,43,40,47,48,5,49,42,44,50,5,49,51,46,42,5,50,44,48,52,5,53,49,50,54,5,53,55,51,49,5,54,50,52,56};
void MEDCouplingBasicsTest5::testBuildSlice3DSurf1()
{
- MEDCouplingUMesh *mesh2D=0;
+ MEDCouplingUMesh *mesh2D=nullptr;
MEDCouplingUMesh *mesh3D=build3DExtrudedUMesh_1(mesh2D);
mesh2D->decrRef();
DataArrayIdType *a=DataArrayIdType::New(),*b=DataArrayIdType::New(),*c=DataArrayIdType::New(),*d=DataArrayIdType::New();
//
const double vec1[3]={-0.07,1.,0.07};
const double origin1[3]={1.524,1.4552,1.74768};
- DataArrayIdType *ids=0;
+ DataArrayIdType *ids=nullptr;
MEDCouplingUMesh *slice1=mesh2D->buildSlice3DSurf(origin1,vec1,1e-10,ids);
const mcIdType expected1[25]={6,8,10,11,13,18,19,21,23,25,26,38,41,43,47,49,52,53,64,67,69,73,75,78,79};
const mcIdType expected2[75]={1,40,41,1,42,41,1,40,43,1,44,43,1,42,44,1,45,41,1,42,46,1,46,45,1,47,40,1,47,48,1,44,48,1,49,42,1,44,50,1,49,50,1,49,51,1,51,46,1,48,52,1,50,52,1,53,49,1,50,54,1,53,54,1,53,55,1,55,51,1,52,56,1,54,56};
const char *comps[2]={"comp1","comp2"};
std::vector<std::string> compsCpp(comps,comps+2);
DataArrayDouble *da=DataArrayDouble::New();
- DataArrayDouble *tmp=0;
+ DataArrayDouble *tmp=nullptr;
da->setInfoAndChangeNbOfCompo(compsCpp);
da->setName("da");
da->alloc(7,2);
const char *comps[2]={"comp1","comp2"};
std::vector<std::string> compsCpp(comps,comps+2);
DataArrayIdType *da=DataArrayIdType::New();
- DataArrayIdType *tmp=0;
+ DataArrayIdType *tmp=nullptr;
da->setInfoAndChangeNbOfCompo(compsCpp);
da->setName("da");
da->alloc(7,2);
myCoords1->decrRef();
//
double vec1[3]={0.,0.,1.};
- double *vec2=new double[2];
+ auto *vec2=new double[2];
for(int i=0;i<18;i++)
{
vec2[0]=3.*cos(M_PI/9.*i);
vec2[1]=3.*sin(M_PI/9.*i);
- MEDCouplingUMesh *m1Cpy=static_cast<MEDCouplingUMesh *>(m1->deepCopy());
+ auto *m1Cpy=static_cast<MEDCouplingUMesh *>(m1->deepCopy());
m1Cpy->translate(vec2);
std::vector<mcIdType> res;
CPPUNIT_ASSERT_THROW(m1Cpy->are2DCellsNotCorrectlyOriented(vec1,false,res),INTERP_KERNEL::Exception);
myCoords3D->decrRef();
mesh3D->checkConsistencyLight();
//
- MEDCouplingUMesh *mesh3D_2=dynamic_cast<MEDCouplingUMesh *>(mesh3D->deepCopy());
- MEDCouplingUMesh *mesh2D_2=dynamic_cast<MEDCouplingUMesh *>(mesh2D->deepCopy());
- MEDCouplingUMesh *mesh3D_4=dynamic_cast<MEDCouplingUMesh *>(mesh3D->deepCopy());
- MEDCouplingUMesh *mesh2D_4=dynamic_cast<MEDCouplingUMesh *>(mesh2D->deepCopy());
+ auto *mesh3D_2=dynamic_cast<MEDCouplingUMesh *>(mesh3D->deepCopy());
+ auto *mesh2D_2=dynamic_cast<MEDCouplingUMesh *>(mesh2D->deepCopy());
+ auto *mesh3D_4=dynamic_cast<MEDCouplingUMesh *>(mesh3D->deepCopy());
+ auto *mesh2D_4=dynamic_cast<MEDCouplingUMesh *>(mesh2D->deepCopy());
DataArrayIdType *renumNodes=DataArrayIdType::New();
- mcIdType oldNbOf3DNodes=mesh3D->getNumberOfNodes();
+ mcIdType const oldNbOf3DNodes=mesh3D->getNumberOfNodes();
renumNodes->alloc(mesh2D->getNumberOfNodes(),1);
renumNodes->iota(oldNbOf3DNodes);
DataArrayDouble *coo=DataArrayDouble::Aggregate(mesh3D->getCoords(),mesh2D->getCoords());
mesh3D->setCoords(coo);
mesh2D->setCoords(coo);
coo->decrRef();
- MEDCouplingUMesh *mesh2D_3=dynamic_cast<MEDCouplingUMesh *>(mesh2D->deepCopy());
+ auto *mesh2D_3=dynamic_cast<MEDCouplingUMesh *>(mesh2D->deepCopy());
mesh2D_3->shiftNodeNumbersInConn(oldNbOf3DNodes);
mesh2D->renumberNodesInConn(renumNodes->getConstPointer());
renumNodes->decrRef();
//
DataArrayIdType *da1,*da2;
mesh3D->checkGeoEquivalWith(mesh3D_2,10,1e-12,da1,da2);
- CPPUNIT_ASSERT(da1==0);
+ CPPUNIT_ASSERT(da1==nullptr);
CPPUNIT_ASSERT_EQUAL(8,(int)da2->getNumberOfTuples());
CPPUNIT_ASSERT_EQUAL(1,(int)da2->getNumberOfComponents());
const mcIdType expected1[8]={8,11,12,9,4,5,6,7};
da2->decrRef();
//
mesh2D->checkGeoEquivalWith(mesh2D_2,10,1e-12,da1,da2);
- CPPUNIT_ASSERT(da1==0);
+ CPPUNIT_ASSERT(da1==nullptr);
CPPUNIT_ASSERT_EQUAL(9,(int)da2->getNumberOfTuples());
CPPUNIT_ASSERT_EQUAL(1,(int)da2->getNumberOfComponents());
for(mcIdType i=0;i<9;i++)
da2->decrRef();
//
const double vect[3]={1.,0.,0.};
- MEDCouplingUMesh *mesh2D_5=dynamic_cast<MEDCouplingUMesh *>(mesh2D_4->deepCopy());
+ auto *mesh2D_5=dynamic_cast<MEDCouplingUMesh *>(mesh2D_4->deepCopy());
mesh2D_5->translate(vect);
std::vector<MEDCouplingUMesh *> meshes(3);
meshes[0]=mesh3D_4; meshes[1]=mesh2D_4; meshes[2]=mesh2D_5;
void MEDCouplingBasicsTest5::testComputeNeighborsOfCells1()
{
MEDCouplingUMesh *m=build2DTargetMesh_1();
- DataArrayIdType *d1=0,*d2=0;
+ DataArrayIdType *d1=nullptr,*d2=nullptr;
m->computeNeighborsOfCells(d1,d2);
CPPUNIT_ASSERT_EQUAL(6,(int)d2->getNumberOfTuples());
CPPUNIT_ASSERT_EQUAL(10,(int)d1->getNumberOfTuples());
{
const double values1[12]={1.,2.,3.,-0.9,2.1,3.,1.3,1.7,3.,1.,1.8,3.};
DataArrayDouble *d1=DataArrayDouble::New();
- double *res=new double[2*3];
+ auto *res=new double[2*3];
CPPUNIT_ASSERT_THROW(d1->getMinMaxPerComponent(res),INTERP_KERNEL::Exception);
d1->alloc(4,3);
std::copy(values1,values1+12,d1->getPointer());
MEDCouplingUMesh *m1=build2DTargetMesh_1();
const mcIdType cells1[3]={2,3,4};
MEDCouplingPointSet *m2_1=m1->buildPartOfMySelf(cells1,cells1+3,true);
- MEDCouplingUMesh *m2=dynamic_cast<MEDCouplingUMesh *>(m2_1);
- DataArrayIdType *arr=0;
+ auto *m2=dynamic_cast<MEDCouplingUMesh *>(m2_1);
+ DataArrayIdType *arr=nullptr;
CPPUNIT_ASSERT(m2);
// no permutation policy 0
CPPUNIT_ASSERT(m1->areCellsIncludedIn(m2,0,arr));
m2_1=m1->buildPartOfMySelf(cells2,cells2+2,true);
m2=dynamic_cast<MEDCouplingUMesh *>(m2_1);
CPPUNIT_ASSERT(m2);
- arr=0;
+ arr=nullptr;
// no permutation policy 0
CPPUNIT_ASSERT(m1->areCellsIncludedIn(m2,0,arr));
CPPUNIT_ASSERT_EQUAL(2,(int)arr->getNumberOfTuples());
MEDCouplingUMesh *m=build2DTargetMesh_1();
const mcIdType part0[3]={2,3,4};
const mcIdType part1[2]={0,1};
- MEDCouplingUMesh *m1=static_cast<MEDCouplingUMesh *>(m->buildPartOfMySelf(part0,part0+3));
- MEDCouplingUMesh *m2=static_cast<MEDCouplingUMesh *>(m->buildPartOfMySelf(part1,part1+2));
+ auto *m1=static_cast<MEDCouplingUMesh *>(m->buildPartOfMySelf(part0,part0+3));
+ auto *m2=static_cast<MEDCouplingUMesh *>(m->buildPartOfMySelf(part1,part1+2));
std::vector<const MEDCouplingUMesh *> v(3); v[0]=m; v[1]=m1; v[2]=m2;
MEDCouplingUMesh *m4=MEDCouplingUMesh::MergeUMeshes(v);
const mcIdType renum[10]={5,2,9,6,4,7,0,1,3,8};
void MEDCouplingBasicsTest5::testBuildSlice3D2()
{
- MEDCouplingUMesh *mesh2D=0;
+ MEDCouplingUMesh *mesh2D=nullptr;
MEDCouplingUMesh *mesh3D=build3DExtrudedUMesh_1(mesh2D);
mesh2D->decrRef();
// First slice in the middle of 3D cells
const double vec1[3]={-0.07,1.,0.07};
const double origin1[3]={1.524,1.4552,1.74768};
- DataArrayIdType *ids=0;
+ DataArrayIdType *ids=nullptr;
MEDCouplingUMesh *slice1=mesh3D->buildSlice3D(origin1,vec1,1e-10,ids);
//
MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
CPPUNIT_ASSERT(f2->getArray()->isEqual(*arr2,1e-12));
CPPUNIT_ASSERT(slice1->isEqual(f2->getMesh(),1e-12));
int a,b;
- double c=f2->getTime(a,b);
+ double const c=f2->getTime(a,b);
CPPUNIT_ASSERT_EQUAL(6,a);
CPPUNIT_ASSERT_EQUAL(7,b);
CPPUNIT_ASSERT_DOUBLES_EQUAL(4.5,c,1e-12);
const mcIdType expected3[18]={0,1,2,3,4,5,9,10,14,15,19,20,24,25,26,27,28,29};
CPPUNIT_ASSERT_EQUAL(ToIdType(18),ids->getNbOfElems());
CPPUNIT_ASSERT(std::equal(expected3,expected3+18,ids->getConstPointer()));
- MEDCouplingUMesh *part=dynamic_cast<MEDCouplingUMesh *>(umesh->buildFacePartOfMySelfNode(ids->begin(),ids->end(),true));
+ auto *part=dynamic_cast<MEDCouplingUMesh *>(umesh->buildFacePartOfMySelfNode(ids->begin(),ids->end(),true));
part->setName(skin->getName().c_str());
CPPUNIT_ASSERT(part->isEqual(skin,1e-12));
- MEDCouplingUMesh *part2=dynamic_cast<MEDCouplingUMesh *>(part->buildPartOfMySelfSlice(1,18,2,true));
+ auto *part2=dynamic_cast<MEDCouplingUMesh *>(part->buildPartOfMySelfSlice(1,18,2,true));
DataArrayIdType *ids2=DataArrayIdType::Range(0,18,2);
part->setPartOfMySelf(ids2->begin(),ids2->end(),*part2);
ids2->decrRef();
std::set<INTERP_KERNEL::NormalizedCellType> s; s.insert(INTERP_KERNEL::NORM_TRI3); s.insert(INTERP_KERNEL::NORM_QUAD4);
CPPUNIT_ASSERT(s==m->getAllGeoTypes());
const mcIdType ids1[3]={0,3,4};
- MEDCouplingUMesh *part=static_cast<MEDCouplingUMesh *>(m->buildPartOfMySelf(ids1,ids1+3,true));
+ auto *part=static_cast<MEDCouplingUMesh *>(m->buildPartOfMySelf(ids1,ids1+3,true));
part->simplexize(0)->decrRef();
const mcIdType ids2[3]={1,2,5};
- MEDCouplingUMesh *part2=static_cast<MEDCouplingUMesh *>(part->buildPartOfMySelf(ids2,ids2+3,true));
+ auto *part2=static_cast<MEDCouplingUMesh *>(part->buildPartOfMySelf(ids2,ids2+3,true));
m->setPartOfMySelf(ids1,ids1+3,*part2);
const mcIdType expected1[20]={3,0,4,1,3,1,4,2,3,4,5,2,3,6,7,4,3,7,5,4};
CPPUNIT_ASSERT(std::equal(expected1,expected1+20,m->getNodalConnectivity()->getConstPointer()));
const double targetPointCoordsX[40]={-0.5,-0.45,-0.4,-0.35,-0.3,-0.25,-0.2,-0.15,-0.1,-0.05,-6.93889390391e-17,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6,0.65,0.7,0.75,0.8,0.85,0.9,0.95,1.0,1.05,1.1,1.15,1.2,1.25,1.3,1.35,1.4,1.45};
const double targetFieldValsExpected[40]={2.975379475824351, 2.95613491917003, 2.936890362515361, 2.917645805861018, 2.898401249206574, 2.879156692552137, 2.859912135897732, 2.840667579243201, 2.821423022588731, 2.802178465934342, 2.78293390927989, 2.763689352625457, 2.744444795971001, 2.725209522098197, 2.709077577124666, 2.706677252549218, 2.727467797847971, 2.713338094723676, 2.671342424824244, 2.664877370146978, 2.653840141412181, 2.619607861392791, 2.569777214476479, 2.513263929794591, 2.450732752808528, 2.368313560985155, 2.250909795670307, 2.098194272085416, 1.954257891732065, 1.895040660973802, 1.865256788315972, 1.835475248687992, 1.80569370905998, 1.775912169431971, 1.746130629803976, 1.716349090175918, 1.686567550547855, 1.656786010919941, 1.627004471291988, 1.597222931663817};
//
- int nbOfInputPoints=10;
+ int const nbOfInputPoints=10;
MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_NODES_KR,ONE_TIME);
DataArrayDouble *srcArrX=DataArrayDouble::New();
srcArrX->alloc(nbOfInputPoints,1);
f->setArray(srcVals);
f->checkConsistencyLight();
//
- double *res0=new double[1];
+ auto *res0=new double[1];
f->getValueOn(targetPointCoordsX,res0);
CPPUNIT_ASSERT_DOUBLES_EQUAL(targetFieldValsExpected[0],res0[0],1e-10);
delete [] res0;
m2->setConnectivity(conn,connI,true);
coords->decrRef(); conn->decrRef(); connI->decrRef();
//
- DataArrayIdType *d1=0,*d2=0;
+ DataArrayIdType *d1=nullptr,*d2=nullptr;
MEDCouplingUMesh *m3=MEDCouplingUMesh::Intersect2DMeshes(m1,m2,1e-10,d1,d2);
CPPUNIT_ASSERT_EQUAL(105,(int)m3->getNumberOfCells());
CPPUNIT_ASSERT_EQUAL(105,(int)d1->getNumberOfTuples());
m2->setConnectivity(conn,connI,true);
coords->decrRef(); conn->decrRef(); connI->decrRef();
//
- DataArrayIdType *d1=0,*d2=0;
+ DataArrayIdType *d1=nullptr,*d2=nullptr;
MEDCouplingUMesh *m3=MEDCouplingUMesh::Intersect2DMeshes(m1,m2,1e-10,d1,d2);
CPPUNIT_ASSERT_EQUAL(4,(int)m3->getNumberOfCells());
CPPUNIT_ASSERT_EQUAL(4,(int)d1->getNumberOfTuples());
void MEDCouplingBasicsTest5::testIntersect2DMeshesTmp7()
{
- double eps = 1.0e-8;
+ double const eps = 1.0e-8;
// coordinates circle - SEE getCircle() on the Python side
DataArrayDouble *coords1=DataArrayDouble::New();
const double coordsData1[16]={0.5328427124746189, -0.08284271247461905, -0.03284271247461901, 0.4828427124746191, -0.03284271247461906, -0.082842712474619, 0.5328427124746191, 0.482842712474619};
m2->setConnectivity(conn2,connI2,true);
coords2->decrRef(); conn2->decrRef(); connI2->decrRef();
- DataArrayIdType * resToM1 = 0, * resToM2 = 0;
+ DataArrayIdType * resToM1 = nullptr, * resToM2 = nullptr;
MEDCouplingUMesh *m_intersec=MEDCouplingUMesh::Intersect2DMeshes(m2, m1, eps, resToM1, resToM2);
m_intersec->zipCoords();
DataArrayIdType *da3=DataArrayIdType::New(); da3->useArray(tab3,false,DeallocType::CPP_DEALLOC,3,1);
DataArrayIdType *da4=DataArrayIdType::New(); da4->useArray(tab1,false,DeallocType::CPP_DEALLOC,7,1);
//
- DataArrayIdType *a=0;
+ DataArrayIdType *a=nullptr;
a=da1->buildSubstractionOptimized(da2);
CPPUNIT_ASSERT_EQUAL(4,(int)a->getNumberOfTuples());
CPPUNIT_ASSERT_EQUAL(1,(int)a->getNumberOfComponents());
c->decrRef();
m->checkConsistency();
//
- MEDCouplingUMesh *m1=static_cast<MEDCouplingUMesh *>(m->deepCopy());
+ auto *m1=static_cast<MEDCouplingUMesh *>(m->deepCopy());
DataArrayIdType *d1=m1->simplexize(INTERP_KERNEL::PLANAR_FACE_5);
m1->checkConsistency();
MEDCouplingFieldDouble *f1=m1->getMeasureField(ON_CELLS);
m1->decrRef();
d1->decrRef();
//
- MEDCouplingUMesh *m2=static_cast<MEDCouplingUMesh *>(m->deepCopy());
+ auto *m2=static_cast<MEDCouplingUMesh *>(m->deepCopy());
DataArrayIdType *d2=m2->simplexize(INTERP_KERNEL::PLANAR_FACE_6);
m2->checkConsistency();
MEDCouplingFieldDouble *f2=m2->getMeasureField(ON_CELLS);
#include "MEDCouplingBasicsTest.hxx"
-#include <map>
-#include <vector>
+#include <cppunit/extensions/HelperMacros.h>
namespace MEDCoupling
{
//
// Author : Anthony Geay (CEA/DEN)
+#include "MCIdType.hxx"
+
static mcIdType connITT[201]={0, 50, 100, 150, 200, 250, 300, 350, 400, 450, 500, 550, 600, 650, 700, 750, 800, 850, 900, 950, 1000, 1029, 1058, 1087, 1116, 1145, 1174, 1203,
1232, 1261, 1290, 1319, 1348, 1377, 1406, 1435, 1464, 1493, 1522, 1551, 1580, 1609, 1638, 1667, 1696, 1725, 1754, 1783, 1812, 1841, 1870, 1899,
1928, 1957, 1986, 2015, 2044, 2073, 2102, 2131, 2160, 2189, 2218, 2247, 2276, 2305, 2334, 2363, 2392, 2421, 2450, 2479, 2508, 2537, 2566, 2595,
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingBasicsTestInterp.hxx"
+#include "MEDCouplingNormalizedUnstructuredMesh.txx"
+#include "Interpolation2D.hxx"
+#include "InterpolationOptions.hxx"
+#include "MCType.hxx"
+#include "Interpolation3D.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingNormalizedCartesianMesh.hxx"
+#include "InterpKernelException.hxx"
+#include "InterpolationCC.hxx"
+#include "InterpolationCU.hxx"
+#include "Interpolation1D.hxx"
+#include "Interpolation2D1D.hxx"
+#include "Interpolation2D3D.hxx"
#include "MEDCouplingUMesh.hxx"
#include "MEDCouplingMappedExtrudedMesh.hxx"
-#include "MEDCouplingFieldDouble.hxx"
#include "MEDCouplingMemArray.hxx"
-#include "Interpolation2D.txx"
#include "Interpolation3DSurf.hxx"
#include "Interpolation3D.txx"
#include "Interpolation2D1D.txx"
#include "InterpolationCC.txx"
#include "InterpolationCU.txx"
#include "Interpolation2DCurve.hxx"
-#include "Interpolation1D.txx"
-#include "MEDCouplingNormalizedUnstructuredMesh.txx"
#include "MEDCouplingNormalizedCartesianMesh.txx"
+#include "NormalizedGeometricTypes"
#include <cmath>
-#include <functional>
+#include <cppunit/TestAssert.h>
+#include <math.h>
+#include <vector>
+#include <map>
using namespace MEDCoupling;
-typedef std::vector<std::map<mcIdType,double> > IntersectionMatrix;
+using IntersectionMatrix = int;
void MEDCouplingBasicsTestInterp::test2DInterpP0P0_1()
{
MEDCouplingNormalizedUnstructuredMesh<2,2> targetWrapper(targetMesh);
INTERP_KERNEL::Interpolation2D myInterpolator;
std::vector<std::map<mcIdType,double> > res;
- INTERP_KERNEL::IntersectionType types[3]={INTERP_KERNEL::Triangulation, INTERP_KERNEL::Convex, INTERP_KERNEL::Geometric2D};
- for(int i=0;i<3;i++)
+ INTERP_KERNEL::IntersectionType const types[3]={INTERP_KERNEL::Triangulation, INTERP_KERNEL::Convex, INTERP_KERNEL::Geometric2D};
+ for(auto & type : types)
{
myInterpolator.setPrecision(1e-12);
- myInterpolator.setIntersectionType(types[i]);
+ myInterpolator.setIntersectionType(type);
myInterpolator.interpolateMeshes(sourceWrapper,targetWrapper,res,"P0P0");
CPPUNIT_ASSERT_EQUAL(5,(int)res.size());
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.125,res[0][0],1e-12);
MEDCouplingNormalizedUnstructuredMesh<2,2> targetWrapper(targetMesh);
INTERP_KERNEL::Interpolation2D myInterpolator;
std::vector<std::map<mcIdType,double> > res;
- INTERP_KERNEL::IntersectionType types[2]={INTERP_KERNEL::Triangulation, INTERP_KERNEL::Geometric2D};
- for(int i=0;i<2;i++)
+ INTERP_KERNEL::IntersectionType const types[2]={INTERP_KERNEL::Triangulation, INTERP_KERNEL::Geometric2D};
+ for(auto & type : types)
{
myInterpolator.setPrecision(1e-12);
- myInterpolator.setIntersectionType(types[i]);
+ myInterpolator.setIntersectionType(type);
myInterpolator.interpolateMeshes(sourceWrapper,targetWrapper,res,"P0P1");
CPPUNIT_ASSERT_EQUAL(9,(int)res.size());
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.041666666666666664,res[0][0],1e-12);
MEDCouplingNormalizedUnstructuredMesh<2,2> targetWrapper(targetMesh);
INTERP_KERNEL::Interpolation2D myInterpolator;
std::vector<std::map<mcIdType,double> > res;
- INTERP_KERNEL::IntersectionType types[2]={INTERP_KERNEL::Triangulation, INTERP_KERNEL::Geometric2D};
- for(mcIdType i=0;i<2;i++)
+ INTERP_KERNEL::IntersectionType const types[2]={INTERP_KERNEL::Triangulation, INTERP_KERNEL::Geometric2D};
+ for(auto & type : types)
{
myInterpolator.setPrecision(1e-12);
- myInterpolator.setIntersectionType(types[i]);
+ myInterpolator.setIntersectionType(type);
myInterpolator.interpolateMeshes(sourceWrapper,targetWrapper,res,"P1P0");
CPPUNIT_ASSERT_EQUAL(5,(int)res.size());
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.25,res[0][0],1e-12);
MEDCouplingNormalizedUnstructuredMesh<2,2> targetWrapper(targetMesh);
INTERP_KERNEL::Interpolation2D myInterpolator;
std::vector<std::map<mcIdType,double> > res;
- INTERP_KERNEL::IntersectionType types[2]={INTERP_KERNEL::Triangulation, INTERP_KERNEL::Geometric2D};
- for(int i=0;i<2;i++)
+ INTERP_KERNEL::IntersectionType const types[2]={INTERP_KERNEL::Triangulation, INTERP_KERNEL::Geometric2D};
+ for(auto & type : types)
{
myInterpolator.setPrecision(1e-12);
- myInterpolator.setIntersectionType(types[i]);
+ myInterpolator.setIntersectionType(type);
myInterpolator.interpolateMeshes(sourceWrapper,targetWrapper,res,"P1P1");
CPPUNIT_ASSERT_EQUAL(9,(int)res.size());
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.08333333333333334,res[0][0],1.e-12);
MEDCouplingNormalizedUnstructuredMesh<3,2> targetWrapper(targetMesh);
INTERP_KERNEL::Interpolation3DSurf myInterpolator;
std::vector<std::map<mcIdType,double> > res;
- INTERP_KERNEL::IntersectionType types[3]={INTERP_KERNEL::Triangulation, INTERP_KERNEL::Geometric2D};
+ INTERP_KERNEL::IntersectionType const types[3]={INTERP_KERNEL::Triangulation, INTERP_KERNEL::Geometric2D};
for(int i=0;i<2;i++)
{
myInterpolator.setPrecision(1e-12);
INTERP_KERNEL::Interpolation3DSurf myInterpolator;
std::vector<std::map<mcIdType,double> > res;
INTERP_KERNEL::IntersectionType types[2]={INTERP_KERNEL::Triangulation, INTERP_KERNEL::Geometric2D};
- for(int i=0;i<2;i++)
+ for(auto & type : types)
{
myInterpolator.setPrecision(1e-12);
- myInterpolator.setIntersectionType(types[i]);
+ myInterpolator.setIntersectionType(type);
myInterpolator.interpolateMeshes(sourceWrapper,targetWrapper,res,"P0P1");
CPPUNIT_ASSERT_EQUAL(9,(int)res.size());
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.041666666666666664*sqrt(2.),res[0][0],1e-12);
INTERP_KERNEL::Interpolation3DSurf myInterpolator;
std::vector<std::map<mcIdType,double> > res;
INTERP_KERNEL::IntersectionType types[2]={INTERP_KERNEL::Triangulation, INTERP_KERNEL::Geometric2D};
- for(int i=0;i<2;i++)
+ for(auto & type : types)
{
myInterpolator.setPrecision(1e-12);
- myInterpolator.setIntersectionType(types[i]);
+ myInterpolator.setIntersectionType(type);
myInterpolator.interpolateMeshes(sourceWrapper,targetWrapper,res,"P1P0");
CPPUNIT_ASSERT_EQUAL(5,(int)res.size());
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.25*sqrt(2.),res[0][0],1e-12);
INTERP_KERNEL::Interpolation3DSurf myInterpolator;
std::vector<std::map<mcIdType,double> > res;
INTERP_KERNEL::IntersectionType types[2]={INTERP_KERNEL::Triangulation, INTERP_KERNEL::Geometric2D};
- for(int i=0;i<2;i++)
+ for(auto & type : types)
{
myInterpolator.setPrecision(1e-12);
- myInterpolator.setIntersectionType(types[i]);
+ myInterpolator.setIntersectionType(type);
myInterpolator.interpolateMeshes(sourceWrapper,targetWrapper,res,"P1P1");
CPPUNIT_ASSERT_EQUAL(9,(int)res.size());
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.08333333333333334*sqrt(2.),res[0][0],1.e-12);
{
INTERP_KERNEL::Interpolation3DSurf myInterpolator;
std::vector<std::map<mcIdType,double> > res;
- double vecTrans[3]={0.,0.,1.e-10};
- double vec[3]={0.,-1.,0.};
- double pt[3]={-0.3,-0.3,5.e-11};
+ double const vecTrans[3]={0.,0.,1.e-10};
+ double const vec[3]={0.,-1.,0.};
+ double const pt[3]={-0.3,-0.3,5.e-11};
const int N=32;
const double deltaA=M_PI/N;
myInterpolator.setPrecision(1e-12);
std::vector<std::map<mcIdType,double> > res;
myInterpolator.setPrecision(1e-12);
INTERP_KERNEL::SplittingPolicy sp[] = { INTERP_KERNEL::PLANAR_FACE_5, INTERP_KERNEL::PLANAR_FACE_6, INTERP_KERNEL::GENERAL_24, INTERP_KERNEL::GENERAL_48 };
- for ( int i = 0; i < 4; ++i )
+ for (auto & i : sp)
{
- myInterpolator.setSplittingPolicy( sp[i] );
+ myInterpolator.setSplittingPolicy( i );
res.clear();
myInterpolator.interpolateMeshes(sourceWrapper,targetWrapper,res,"P0P0");
CPPUNIT_ASSERT_EQUAL(8,(int)res.size());
myInterpolator.setPrecision(1e-12);
myInterpolator.setIntersectionType(INTERP_KERNEL::PointLocator);
INTERP_KERNEL::SplittingPolicy sp[] = { INTERP_KERNEL::PLANAR_FACE_5, INTERP_KERNEL::PLANAR_FACE_6, INTERP_KERNEL::GENERAL_24, INTERP_KERNEL::GENERAL_48 };
- for ( int i = 0; i < 4; ++i )
+ for (auto & i : sp)
{
- myInterpolator.setSplittingPolicy( sp[i] );
+ myInterpolator.setSplittingPolicy( i );
res.clear();
myInterpolator.interpolateMeshes(sourceWrapper,targetWrapper,res,"P0P0");
CPPUNIT_ASSERT_EQUAL(8,(int)res.size());
myInterpolator.setPrecision(1e-12);
myInterpolator.setIntersectionType(INTERP_KERNEL::PointLocator);
INTERP_KERNEL::SplittingPolicy sp[] = { INTERP_KERNEL::PLANAR_FACE_5, INTERP_KERNEL::PLANAR_FACE_6, INTERP_KERNEL::GENERAL_24, INTERP_KERNEL::GENERAL_48 };
- for ( int i = 0; i < 4; ++i )
+ for (auto & i : sp)
{
- myInterpolator.setSplittingPolicy( sp[i] );
+ myInterpolator.setSplittingPolicy( i );
res.clear();
myInterpolator.interpolateMeshes(sourceWrapper,targetWrapper,res,"P0P0");
CPPUNIT_ASSERT_EQUAL(8,(int)res.size());
myInterpolator.setPrecision(1e-12);
myInterpolator.setIntersectionType(INTERP_KERNEL::PointLocator);
INTERP_KERNEL::SplittingPolicy sp[] = { INTERP_KERNEL::PLANAR_FACE_5, INTERP_KERNEL::PLANAR_FACE_6, INTERP_KERNEL::GENERAL_24, INTERP_KERNEL::GENERAL_48 };
- for ( int i = 0; i < 4; ++i )
+ for (auto & i : sp)
{
- myInterpolator.setSplittingPolicy( sp[i] );
+ myInterpolator.setSplittingPolicy( i );
res.clear();
myInterpolator.interpolateMeshes(sourceWrapper,targetWrapper,res,"P0P0");
CPPUNIT_ASSERT_EQUAL(8,(int)res.size());
myInterpolator.setPrecision(1e-12);
myInterpolator.setIntersectionType(INTERP_KERNEL::PointLocator);
INTERP_KERNEL::SplittingPolicy sp[] = { INTERP_KERNEL::PLANAR_FACE_5, INTERP_KERNEL::PLANAR_FACE_6, INTERP_KERNEL::GENERAL_24, INTERP_KERNEL::GENERAL_48 };
- for ( int i = 0; i < 4; ++i )
+ for (auto & i : sp)
{
- myInterpolator.setSplittingPolicy( sp[i] );
+ myInterpolator.setSplittingPolicy( i );
res.clear();
myInterpolator.interpolateMeshes(sourceWrapper,targetWrapper,res,"P0P0");
CPPUNIT_ASSERT_EQUAL(8,(int)res.size());
std::vector<std::map<mcIdType,double> > res;
myInterpolator.setPrecision(1e-12);
INTERP_KERNEL::SplittingPolicy sp[] = { INTERP_KERNEL::PLANAR_FACE_5, INTERP_KERNEL::PLANAR_FACE_6, INTERP_KERNEL::GENERAL_24, INTERP_KERNEL::GENERAL_48 };
- for ( int i = 0; i < 4; ++i )
+ for (auto & i : sp)
{
- myInterpolator.setSplittingPolicy( sp[i] );
+ myInterpolator.setSplittingPolicy( i );
res.clear();
myInterpolator.interpolateMeshes(sourceWrapper,targetWrapper,res,"P0P1");
CPPUNIT_ASSERT_EQUAL(9,(int)res.size());
myInterpolator.setPrecision(1e-12);
myInterpolator.setIntersectionType(INTERP_KERNEL::PointLocator);
INTERP_KERNEL::SplittingPolicy sp[] = { INTERP_KERNEL::PLANAR_FACE_5, INTERP_KERNEL::PLANAR_FACE_6, INTERP_KERNEL::GENERAL_24, INTERP_KERNEL::GENERAL_48 };
- for ( int i = 0; i < 4; ++i )
+ for (auto & i : sp)
{
- myInterpolator.setSplittingPolicy( sp[i] );
+ myInterpolator.setSplittingPolicy( i );
res.clear();
myInterpolator.interpolateMeshes(sourceWrapper,targetWrapper,res,"P0P1");
CPPUNIT_ASSERT_EQUAL(9,(int)res.size());
std::vector<std::map<mcIdType,double> > res;
myInterpolator.setPrecision(1e-12);
INTERP_KERNEL::SplittingPolicy sp[] = { INTERP_KERNEL::PLANAR_FACE_5, INTERP_KERNEL::PLANAR_FACE_6, INTERP_KERNEL::GENERAL_24};
- for ( int i = 0; i < 3; ++i )
+ for (auto & i : sp)
{
- myInterpolator.setSplittingPolicy( sp[i] );
+ myInterpolator.setSplittingPolicy( i );
res.clear();
myInterpolator.interpolateMeshes(sourceWrapper,targetWrapper,res,"P1P0");
CPPUNIT_ASSERT_EQUAL(8,(int)res.size());
myInterpolator.setPrecision(1e-12);
myInterpolator.setIntersectionType(INTERP_KERNEL::PointLocator);
INTERP_KERNEL::SplittingPolicy sp[] = { INTERP_KERNEL::PLANAR_FACE_5, INTERP_KERNEL::PLANAR_FACE_6, INTERP_KERNEL::GENERAL_24, INTERP_KERNEL::GENERAL_48 };
- for ( int i = 0; i < 4; ++i )
+ for (auto & i : sp)
{
- myInterpolator.setSplittingPolicy( sp[i] );
+ myInterpolator.setSplittingPolicy( i );
res.clear();
myInterpolator.interpolateMeshes(sourceWrapper,targetWrapper,res,"P1P0");
CPPUNIT_ASSERT_EQUAL(8,(int)res.size());
myInterpolator.setPrecision(1e-12);
myInterpolator.interpolateMeshes(sourceWrapper,targetWrapper,res,"P1P1");
CPPUNIT_ASSERT_EQUAL(8,(int)res.size());
- double res3D[8][28]= {{124999.999883775978, 245370.370390364464, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 203703.703634892299, 187500.000094145857, 0.0, 0.0, 4629.6296266718, 0.0, 215277.777751402784, 209722.222322299582, 0.0, 0.0, 0.0, 0.0, 104166.666590829205, 121296.296368812196, 0.0, 250000.000003472145},
+ double const res3D[8][28]= {{124999.999883775978, 245370.370390364464, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 203703.703634892299, 187500.000094145857, 0.0, 0.0, 4629.6296266718, 0.0, 215277.777751402784, 209722.222322299582, 0.0, 0.0, 0.0, 0.0, 104166.666590829205, 121296.296368812196, 0.0, 250000.000003472145},
{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 120370.370368827047, 0.0, 0.0, 38888.888897777797, 0.0, 0.0, 45370.3703701697596, 0.0, 0.0, 45370.3703701697596, 83333.3333263888926, 0.0},
{0.0, 0.0, 0.0, 97222.2222222221753, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 97222.2222222221608, 0.0, 97222.2222222222044, 41666.6666666666642, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
{0.0, 277777.777787084982, 199074.074074073927, 0.0, 0.0, 0.0, 4629.62962962962774, 0.0, 321759.259254934732, 83333.3333333333139, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4629.62962667180363, 0.0, 0.0, 251388.88888319055, 194444.444454861077, 0.0, 79629.6296194135939, 250000.000003472145, 0.0, 0.0, 0.0, 0.0},
MEDCouplingNormalizedUnstructuredMesh<2,2> targetWrapper(targetMesh);
INTERP_KERNEL::Interpolation2D myInterpolator;
std::vector<std::map<mcIdType,double> > res;
- INTERP_KERNEL::IntersectionType types[2]={INTERP_KERNEL::Barycentric,INTERP_KERNEL::BarycentricGeo2D};
- for(int i=0;i<2;i++)
+ INTERP_KERNEL::IntersectionType const types[2]={INTERP_KERNEL::Barycentric,INTERP_KERNEL::BarycentricGeo2D};
+ for(auto & type : types)
{
myInterpolator.setPrecision(1e-12);
- myInterpolator.setIntersectionType(types[i]);
+ myInterpolator.setIntersectionType(type);
myInterpolator.interpolateMeshes(sourceWrapper,targetWrapper,res,"P1P0");
CPPUNIT_ASSERT_EQUAL(5,(int)res.size());
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.16666666666666669,res[0][0],1e-12);
INTERP_KERNEL::Interpolation3DSurf myInterpolator;
std::vector<std::map<mcIdType,double> > res;
INTERP_KERNEL::IntersectionType types[2]={INTERP_KERNEL::Barycentric,INTERP_KERNEL::BarycentricGeo2D};
- for(int i=0;i<2;i++)
+ for(auto & type : types)
{
myInterpolator.setPrecision(1e-12);
- myInterpolator.setIntersectionType(types[i]);
+ myInterpolator.setIntersectionType(type);
myInterpolator.interpolateMeshes(sourceWrapper,targetWrapper,res,"P1P0");
CPPUNIT_ASSERT_EQUAL(5,(int)res.size());
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.16666666666666669*sqrt(2.),res[0][0],1e-12);
targetMesh->decrRef();
}
-#include <iomanip>
void MEDCouplingBasicsTestInterp::test3DInterpP1P0Bary_1()
{
MEDCouplingUMesh *sourceMesh=build3DSourceMesh_2();
myInterpolator.interpolateMeshes(sourceWrapper,targetWrapper,res,"P1P0");
CPPUNIT_ASSERT_EQUAL(5,(int)res.size());
- double res3D[5][28]={{104166.66658918398, 885416.666685817763, 135416.666666666541, 36458.3333333335031, 31249.9999999999018, 145833.333333333256, 41666.6666666667516, 124999.999999999971, 177083.333326388849, 0.0, 31249.9999999999636, 0.0, 41666.666620792399, 159722.22229009436, 0.0, 0.0, 41666.6666631944681, 125000, 43499.2283723790752, 164351.851924000395, 36458.3333372396883, 0.0, 0.0, 125000.000001736029, 34722.2221800900952, 13599.5370788455439, 0.0, 167438.27159690368},
+ double const res3D[5][28]={{104166.66658918398, 885416.666685817763, 135416.666666666541, 36458.3333333335031, 31249.9999999999018, 145833.333333333256, 41666.6666666667516, 124999.999999999971, 177083.333326388849, 0.0, 31249.9999999999636, 0.0, 41666.666620792399, 159722.22229009436, 0.0, 0.0, 41666.6666631944681, 125000, 43499.2283723790752, 164351.851924000395, 36458.3333372396883, 0.0, 0.0, 125000.000001736029, 34722.2221800900952, 13599.5370788455439, 0.0, 167438.27159690368},
{0.0, 41666.6664479170649, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 125000.000161457952, 0.0, 0.0, 0.0, 0.0, 111111.11112005508, 0.0, 0.0, 291666.666656249959, 41666.6666666666933, 6944.4444415638809, 270833.333520485845, 0.0, 0.0, 124999.999989583303, 41666.6665798612958, 20833.3333186342825, 145833.333354303701, 83333.3333263888198, 27777.7777501651799},
{0.0, 93750.0000000000728, 125000.000000000058, 0.0, 0.0, 72916.666666666526, 291666.666666666628, 41666.6666666667152, 197916.66666666657, 166666.666666666802, 218750.000000000116, 41666.6666666665697, 0.0, 0.0, 0.0, 0.0, 0.0, 41666.6666666666861, 0.0, 0.0, 0.0, 0.0, 0.0, 41666.6666666666642, 0.0, 0.0, 0.0, 0.0},
{72916.6666484848247, 82465.2777799315081, 0.0, 0.0, 217447.916666666686, 197916.666666666802, 0.0, 41666.6666666666715, 0.0, 0.0, 0.0, 0.0, 290364.583310396119, 125000.000018181803, 41666.6666666666351, 166666.666666666599, 0.0, 41666.6666666665551, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 27777.7777734705051, 0.0, 0.0, 27777.7778028684952},
CPPUNIT_ASSERT_DOUBLES_EQUAL(6., matrix[1][6],1e-12);
CPPUNIT_ASSERT_DOUBLES_EQUAL(3., matrix[1][7],1e-12);
- INTERP_KERNEL::Interpolation2D3D::DuplicateFacesType duplicateFaces = myInterpolator.retrieveDuplicateFaces();
+ INTERP_KERNEL::Interpolation2D3D::DuplicateFacesType const duplicateFaces = myInterpolator.retrieveDuplicateFaces();
CPPUNIT_ASSERT_EQUAL(1,(int)duplicateFaces.size());
INTERP_KERNEL::Interpolation2D3D::DuplicateFacesType correctDuplicateFaces;
myInterpolator.setPrecision(1e-12);
std::vector<std::map<int,double> > matrix;
INTERP_KERNEL::SplittingPolicy sp[] = { INTERP_KERNEL::PLANAR_FACE_5, INTERP_KERNEL::PLANAR_FACE_6, INTERP_KERNEL::GENERAL_24, INTERP_KERNEL::GENERAL_48 };
- for ( size_t i = 0; i < sizeof(sp)/sizeof(sp[0]); ++i )
+ for (auto & i : sp)
{
- myInterpolator.setSplittingPolicy( sp[i] );
+ myInterpolator.setSplittingPolicy( i );
matrix.clear();
myInterpolator.interpolateMeshes(sourceWrapper,targetWrapper,matrix,"P0P0");
CPPUNIT_ASSERT_DOUBLES_EQUAL(80. ,matrix[2][5],1e-12);
CPPUNIT_ASSERT_DOUBLES_EQUAL(112. ,matrix[2][6],1e-12);
- INTERP_KERNEL::Interpolation2D3D::DuplicateFacesType duplicateFaces = myInterpolator.retrieveDuplicateFaces();
+ INTERP_KERNEL::Interpolation2D3D::DuplicateFacesType const duplicateFaces = myInterpolator.retrieveDuplicateFaces();
CPPUNIT_ASSERT_EQUAL(3,(int)duplicateFaces.size());
INTERP_KERNEL::Interpolation2D3D::DuplicateFacesType correctDuplicateFaces;
#include "MEDCouplingBasicsTest.hxx"
-#include <map>
-#include <vector>
+#include <cppunit/extensions/HelperMacros.h>
namespace MEDCoupling
{
//
// Author : Anthony Geay (EDF R&D)
+#include "MCAuto.hxx"
+#include "MCIdType.hxx"
+#include "MCType.hxx"
+#include "InterpKernelException.hxx"
#include "MEDCouplingBasicsTest.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingPointSet.hxx"
#include "MEDCouplingUMesh.hxx"
#include "MEDCouplingCMesh.hxx"
#include "MEDCouplingMappedExtrudedMesh.hxx"
#include "MEDCouplingFieldDouble.hxx"
-#include "MEDCouplingMemArray.hxx"
#include "MEDCouplingMemArray.txx"
#include "MEDCouplingMultiFields.hxx"
+#include <vector>
+#include <stdio.h>
+#include <cppunit/TestAssert.h>
+#include <algorithm>
+#include <cmath>
+#include "NormalizedGeometricTypes"
+#include <math.h>
+#include <cstdlib>
void CppExample_MEDCouplingFieldDouble_WriteVTK()
field2->applyFunc("x + 5"); // "translate" field2
// concatenate field1 and field2
- MCAuto<MEDCouplingFieldDouble> field3 =
+ MCAuto<MEDCouplingFieldDouble> const field3 =
MEDCouplingFieldDouble::MergeFields( field1, field2 );
std::vector<const MEDCouplingFieldDouble *> fields( 2 );
fields[0] = field1;
fields[1] = field2;
- MCAuto<MEDCouplingFieldDouble> field4 =
+ MCAuto<MEDCouplingFieldDouble> const field4 =
MEDCouplingFieldDouble::MergeFields( fields );
//! [CppSnippet_MEDCouplingFieldDouble_MergeFields_1]
}
// transform the field to a 3D vector field
const char func[] = "IVec * b + JVec * a + KVec * sqrt( a*a + b*b ) + 10";
const char* varNames[2] = { "a", "b" }; // names used to refer to X and Y components
- std::vector<std::string> varNamesVec( varNames, varNames+2 );
+ std::vector<std::string> const varNamesVec( varNames, varNames+2 );
field->applyFuncNamedCompo( 3, varNamesVec, func ); // require 3 components
CPPUNIT_ASSERT( field->getNumberOfComponents() == 3 ); // 3 components as required
//! [CppSnippet_MEDCouplingFieldDouble_applyFunc3_1]
field->setMesh( mesh );
const char func[] = "IVec * b + JVec * a + KVec * sqrt( a*a + b*b ) + 10";
const char* varNames[2] = { "a", "b" }; // names used to refer to X and Y coord components
- std::vector<std::string> varNamesVec( varNames, varNames+2 );
+ std::vector<std::string> const varNamesVec( varNames, varNames+2 );
field->fillFromAnalyticNamedCompo( 3, varNamesVec, func );
//! [CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic3_2]
//! [CppSnippet_MEDCouplingFieldDouble_fillFromAnalytic3_3]
double bc1[2]; // coordinates of the second point
bc->getTuple( 1, bc1 );
//
- double dist = sqrt( bc1[0]*bc1[0] + bc1[1]*bc1[1] ); // "sqrt( a*a + b*b )"
+ double const dist = sqrt( bc1[0]*bc1[0] + bc1[1]*bc1[1] ); // "sqrt( a*a + b*b )"
CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[0], 10 + bc1[1], 13 ); // "10 + IVec * b"
CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[1], 10 + bc1[0], 13 ); // "10 + JVec * a"
CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[2], 10 + dist , 13 ); // "10 + KVec * sqrt( a*a + b*b )"
double bc1[2]; // coordinates of the second point
bc->getTuple( 1, bc1 );
//
- double dist = sqrt( bc1[0]*bc1[0] + bc1[1]*bc1[1] ); // "sqrt( a*a + b*b )"
+ double const dist = sqrt( bc1[0]*bc1[0] + bc1[1]*bc1[1] ); // "sqrt( a*a + b*b )"
CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[0], 10 + bc1[1], 13 ); // "10 + IVec * b"
CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[1], 10 + bc1[0], 13 ); // "10 + JVec * a"
CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[2], 10 + dist , 13 ); // "10 + KVec * sqrt( a*a + b*b )"
double bc1[2]; // coordinates of the second point
bc->getTuple( 1, bc1 );
//
- double dist = sqrt( bc1[0]*bc1[0] + bc1[1]*bc1[1] ); // "sqrt( a*a + b*b )"
+ double const dist = sqrt( bc1[0]*bc1[0] + bc1[1]*bc1[1] ); // "sqrt( a*a + b*b )"
CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[0], 10 + bc1[1], 13 ); // "10 + IVec * b"
CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[1], 10 + bc1[0], 13 ); // "10 + JVec * a"
CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[2], 10 + dist , 13 ); // "10 + KVec * sqrt( a*a + b*b )"
//! [CppSnippet_MEDCouplingMesh_fillFromAnalytic3_2]
const char func[] = "IVec * b + JVec * a + KVec * sqrt( a*a + b*b ) + 10";
const char* varNames[2] = { "a", "b" }; // names used to refer to X and Y coord components
- std::vector<std::string> varNamesVec( varNames, varNames+2 );
+ std::vector<std::string> const varNamesVec( varNames, varNames+2 );
MCAuto<MEDCouplingFieldDouble> field =
mesh->fillFromAnalyticNamedCompo( MEDCoupling::ON_CELLS, 3, varNamesVec, func );
//! [CppSnippet_MEDCouplingMesh_fillFromAnalytic3_2]
double bc1[2]; // coordinates of the second point
bc->getTuple( 1, bc1 );
//
- double dist = sqrt( bc1[0]*bc1[0] + bc1[1]*bc1[1] ); // "sqrt( a*a + b*b )"
+ double const dist = sqrt( bc1[0]*bc1[0] + bc1[1]*bc1[1] ); // "sqrt( a*a + b*b )"
CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[0], 10 + bc1[1], 13 ); // "10 + IVec * b"
CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[1], 10 + bc1[0], 13 ); // "10 + JVec * a"
CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[2], 10 + dist , 13 ); // "10 + KVec * sqrt( a*a + b*b )"
double bc1[2]; // coordinates of the second point
bc->getTuple( 1, bc1 );
//
- double dist = sqrt( bc1[0]*bc1[0] + bc1[1]*bc1[1] ); // "sqrt( a*a + b*b )"
+ double const dist = sqrt( bc1[0]*bc1[0] + bc1[1]*bc1[1] ); // "sqrt( a*a + b*b )"
CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[0], 10 + bc1[1], 13 ); // "10 + IVec * b"
CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[1], 10 + bc1[0], 13 ); // "10 + JVec * a"
CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[2], 10 + dist , 13 ); // "10 + KVec * sqrt( a*a + b*b )"
double bc1[2]; // coordinates of the second point
bc->getTuple( 1, bc1 );
//
- double dist = sqrt( bc1[0]*bc1[0] + bc1[1]*bc1[1] ); // "sqrt( a*a + b*b )"
+ double const dist = sqrt( bc1[0]*bc1[0] + bc1[1]*bc1[1] ); // "sqrt( a*a + b*b )"
CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[0], 10 + bc1[1], 13 ); // "10 + IVec * b"
CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[1], 10 + bc1[0], 13 ); // "10 + JVec * a"
CPPUNIT_ASSERT_DOUBLES_EQUAL( val1[2], 10 + dist , 13 ); // "10 + KVec * sqrt( a*a + b*b )"
(MEDCouplingUMesh*) mesh1->buildPartOfMySelf( cells2, cells2+3, true );
//! [CppSnippet_MEDCouplingUMesh_areCellsIncludedIn_2]
//! [CppSnippet_MEDCouplingUMesh_areCellsIncludedIn_3]
- int compType = 0; // the strongest policy
+ int const compType = 0; // the strongest policy
DataArrayIdType *corr2to1, *corr1to2;
// a larger mesh1 includes a smaller mesh2
CPPUNIT_ASSERT( mesh1->areCellsIncludedIn( mesh2, compType, corr2to1 ));
//! [CppSnippet_MEDCouplingUMesh_buildPartOfMySelf_1]
//! [CppSnippet_MEDCouplingUMesh_buildPartOfMySelf_2]
const mcIdType cellIds[2]={1,2};
- MEDCouplingUMesh* mesh2=(MEDCouplingUMesh*)mesh->buildPartOfMySelf(cellIds,cellIds+2,true);
- MEDCouplingUMesh* mesh3=(MEDCouplingUMesh*)mesh->buildPartOfMySelf(cellIds,cellIds+2,false);
+ auto* mesh2=(MEDCouplingUMesh*)mesh->buildPartOfMySelf(cellIds,cellIds+2,true);
+ auto* mesh3=(MEDCouplingUMesh*)mesh->buildPartOfMySelf(cellIds,cellIds+2,false);
CPPUNIT_ASSERT( coordsArr->isEqual( *mesh2->getCoords(), 1e-13 )); // same nodes
CPPUNIT_ASSERT( !coordsArr->isEqual( *mesh3->getCoords(), 1e-13 )); // different nodes
for ( mcIdType i = 0; i < 2; ++i )
//! [CppSnippet_MEDCouplingUMesh_zipCoordsTraducer_1]
//! [CppSnippet_MEDCouplingUMesh_zipCoordsTraducer_2]
const mcIdType cellIds[2]={1,2};
- MEDCouplingUMesh* mesh2=(MEDCouplingUMesh*)mesh->buildPartOfMySelf(cellIds,cellIds+2,true);
+ auto* mesh2=(MEDCouplingUMesh*)mesh->buildPartOfMySelf(cellIds,cellIds+2,true);
DataArrayIdType *arr=mesh2->zipCoordsTraducer();
CPPUNIT_ASSERT_EQUAL( ToIdType(4), mesh2->getNumberOfNodes() ); // nb of nodes decreased
CPPUNIT_ASSERT_EQUAL( mesh->getNumberOfNodes(), arr->getNumberOfTuples() );
//! [CppSnippet_MEDCouplingUMesh_getNodeIdsInUse_1]
//! [CppSnippet_MEDCouplingUMesh_getNodeIdsInUse_2]
const mcIdType cellIds[2]={1,2};
- MEDCouplingUMesh* mesh2=(MEDCouplingUMesh*)mesh->buildPartOfMySelf(cellIds,cellIds+2,true);
+ auto* mesh2=(MEDCouplingUMesh*)mesh->buildPartOfMySelf(cellIds,cellIds+2,true);
mcIdType newNbOfNodes = 0;
DataArrayIdType *arr=mesh2->getNodeIdsInUse( newNbOfNodes );
const mcIdType idsExpected[9] = {-1,0,1,-1,2,3,-1,-1,-1};
std::copy(array2,array2+12,da->getPointer());
//! [CppSnippet_DataArrayDouble_findCommonTuples1]
//! [CppSnippet_DataArrayDouble_findCommonTuples2]
- DataArrayIdType *c=0,*cI=0;
+ DataArrayIdType *c=nullptr,*cI=nullptr;
da->findCommonTuples(1.01e-1,-1,c,cI);
const mcIdType expected3[5]={0,3,4,1,2};
CPPUNIT_ASSERT_EQUAL(ToIdType(6),f2->getMesh()->getNumberOfNodes());
CPPUNIT_ASSERT_EQUAL(2,f2->getMesh()->getSpaceDimension());
CPPUNIT_ASSERT_EQUAL(2,f2->getMesh()->getMeshDimension());
- MEDCoupling::MEDCouplingUMesh *m2C=dynamic_cast<MEDCoupling::MEDCouplingUMesh *>(const_cast<MEDCoupling::MEDCouplingMesh *>(f2->getMesh()));
+ auto *m2C=dynamic_cast<MEDCoupling::MEDCouplingUMesh *>(const_cast<MEDCoupling::MEDCouplingMesh *>(f2->getMesh()));
CPPUNIT_ASSERT_EQUAL(ToIdType(13),m2C->getNodalConnectivityArrayLen());
const double expected2[12]={0.2, -0.3, 0.7, -0.3, 0.2, 0.2, 0.7, 0.2, 0.2, 0.7, 0.7, 0.7};
for(mcIdType i=0;i<12;i++)
const mcIdType nbOfNodes=12;
double coords[3*nbOfNodes]={2.,3.,4.,3.,4.,5.,4.,5.,6.,5.,6.,7.,6.,7.,8.,7.,8.,9.,8.,9.,10.,9.,10.,11.,10.,11.,12.,11.,12.,13.,12.,13.,14.,13.,14.,15.};
//
- MEDCoupling::DataArrayDouble *coordsArr=0;
- double *tmp=0;
+ MEDCoupling::DataArrayDouble *coordsArr=nullptr;
+ double *tmp=nullptr;
//! [CppSnippetDataArrayBuild1_0]
//
//! [CppSnippetDataArrayBuild1_1]
coordsArr->alloc(nbOfNodes,3);
tmp=coordsArr->getPointer();
std::copy(coords,coords+3*nbOfNodes,tmp);
- MEDCoupling::DataArrayDouble *coordsArrCpy=0;
+ MEDCoupling::DataArrayDouble *coordsArrCpy=nullptr;
//! [CppSnippetDataArrayBuild1_5]
coordsArrCpy=coordsArr->deepCopy();
//! [CppSnippetDataArrayBuild1_5]
//! [CppSnippetFieldDoubleBuild4_1]
}
-int main(int argc, char *argv[])
+int main(int /*argc*/, char * /*argv*/[])
{
CppExample_MEDCouplingFieldDouble_WriteVTK();
CppExample_MEDCouplingFieldDouble_MaxFields();
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingRemapperTest.hxx"
+#include "InterpolationOptions.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
+#include "MCType.hxx"
#include "MEDCouplingUMesh.hxx"
#include "MEDCouplingMappedExtrudedMesh.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "MEDCouplingRemapper.hxx"
#include "MEDCouplingBasicsTest.hxx"
+#include "NormalizedGeometricTypes"
+#include <algorithm>
#include <cmath>
+#include <cppunit/TestAssert.h>
+#include <map>
#include <numeric>
+#include <vector>
using namespace MEDCoupling;
void MEDCouplingRemapperTest::testExtruded()
{
- MEDCouplingUMesh *mesh2DS=0;
+ MEDCouplingUMesh *mesh2DS=nullptr;
MEDCouplingUMesh *mesh3DS=build3DExtrudedUMesh_1(mesh2DS);
MEDCouplingMappedExtrudedMesh *extS=MEDCouplingMappedExtrudedMesh::New(mesh3DS,mesh2DS,1);
mesh3DS->decrRef();
mesh2DS->decrRef();
- MEDCouplingUMesh *mesh2DT=0;
+ MEDCouplingUMesh *mesh2DT=nullptr;
MEDCouplingUMesh *mesh3DT=build3DExtrudedUMesh_1(mesh2DT);
MEDCouplingMappedExtrudedMesh *extT=MEDCouplingMappedExtrudedMesh::New(mesh3DT,mesh2DT,1);
//
MEDCouplingUMesh *meshN,*meshTT,*meshTF;
MEDCouplingBasicsTest::build3DExtrudedUMesh_2(meshN,meshTT,meshTF);
std::vector<mcIdType> n;
- double pt[3]={300.,300.,0.};
- double v[3]={0.,0.,2.};
+ double const pt[3]={300.,300.,0.};
+ double const v[3]={0.,0.,2.};
meshN->findNodesOnPlane(pt,v,1e-12,n);
- MEDCouplingUMesh *meshN2D=(MEDCouplingUMesh *)meshN->buildFacePartOfMySelfNode(&n[0],&n[0]+n.size(),true);
+ auto *meshN2D=(MEDCouplingUMesh *)meshN->buildFacePartOfMySelfNode(&n[0],&n[0]+n.size(),true);
n.clear();
bool b=false;
mcIdType newNbOfNodes;
CPPUNIT_ASSERT(b);
da->decrRef();
meshTT->findNodesOnPlane(pt,v,1e-12,n);
- MEDCouplingUMesh *meshTT2D=(MEDCouplingUMesh *)meshTT->buildFacePartOfMySelfNode(&n[0],&n[0]+n.size(),true);
+ auto *meshTT2D=(MEDCouplingUMesh *)meshTT->buildFacePartOfMySelfNode(&n[0],&n[0]+n.size(),true);
n.clear();
meshTF->findNodesOnPlane(pt,v,1e-12,n);
- MEDCouplingUMesh *meshTF2D=(MEDCouplingUMesh *)meshTF->buildFacePartOfMySelfNode(&n[0],&n[0]+n.size(),true);
+ auto *meshTF2D=(MEDCouplingUMesh *)meshTF->buildFacePartOfMySelfNode(&n[0],&n[0]+n.size(),true);
n.clear();
//
MEDCouplingMappedExtrudedMesh *meshNE=MEDCouplingMappedExtrudedMesh::New(meshN,meshN2D,0);
std::copy(vals2,vals2+meshTTE->getNumberOfCells(),array->getPointer());
array->decrRef();
srcField=remapper.reverseTransferField(trgField,4.220173);
- double expected3[40]={
+ double const expected3[40]={
550.,550.,551.,552.,553.,550.,550.,554.,555.,556.,550.,550.,554.,555.,556.,550.,550.,557.,558.,559.,
1550.,1550.,1551.,1552.,1553.,1550.,1550.,1554.,1555.,1556.,1550.,1550.,1554.,1555.,1556.,1550.,1550.,1557.,1558.,1559.
};
std::copy(vals3,vals3+meshTFE->getNumberOfCells(),array->getPointer());
array->decrRef();
srcField=remapper.reverseTransferField(trgField,4.220173);
- double expected4[40]={
+ double const expected4[40]={
566.,566.,552.5,553.5,554.5,566.,566.,554.5,555.5,556.5,566.,566.,558.5,559.5,560.5,566.,566.,560.5,561.5,562.5,
1566.,1566.,1552.5,1553.5,1554.5,1566.,1566.,1554.5,1555.5,1556.5,1566.,1566.,1558.5,1559.5,1560.5,1566.,1566.,1560.5,1561.5,1562.5
};
#ifndef __MEDCOUPLINGREMAPPERTEST_HXX__
#define __MEDCOUPLINGREMAPPERTEST_HXX__
+#include <cppunit/TestFixture.h>
#include <cppunit/extensions/HelperMacros.h>
-#include <map>
-#include <vector>
namespace MEDCoupling
{
#include "MEDCouplingBasicsTest4.hxx"
#include "MEDCouplingBasicsTest5.hxx"
#include "MEDCouplingBasicsTestInterp.hxx"
+#include <cppunit/extensions/HelperMacros.h>
CPPUNIT_TEST_SUITE_REGISTRATION( MEDCoupling::MEDCouplingBasicsTest1 );
CPPUNIT_TEST_SUITE_REGISTRATION( MEDCoupling::MEDCouplingBasicsTest2 );
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingRemapperTest.hxx"
+#include <cppunit/extensions/HelperMacros.h>
CPPUNIT_TEST_SUITE_REGISTRATION( MEDCoupling::MEDCouplingRemapperTest );
#include "InterpKernelAutoPtr.hxx"
#include "BoxSplittingOptions.hxx"
+#include "MEDCouplingNatureOfField.hxx"
using namespace MEDCoupling;
using namespace INTERP_KERNEL;
#ifndef __MEDCOUPLINGDATAARRAYTRAITS_HXX__
#define __MEDCOUPLINGDATAARRAYTRAITS_HXX__
-#include "MEDCouplingMemArray.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingMemArray.txx"
#include <Python.h>
MCData *_pt_mc;
};
-typedef struct PyCallBackDataArraySt<MEDCoupling::DataArrayByte> PyCallBackDataArrayChar;
-typedef struct PyCallBackDataArraySt<MEDCoupling::DataArrayInt32> PyCallBackDataArrayInt32;
-typedef struct PyCallBackDataArraySt<MEDCoupling::DataArrayInt64> PyCallBackDataArrayInt64;
-typedef struct PyCallBackDataArraySt<MEDCoupling::DataArrayFloat> PyCallBackDataArrayFloat;
-typedef struct PyCallBackDataArraySt<MEDCoupling::DataArrayDouble> PyCallBackDataArrayDouble;
+using PyCallBackDataArrayChar = struct PyCallBackDataArraySt<MEDCoupling::DataArrayByte>;
+using PyCallBackDataArrayInt32 = struct PyCallBackDataArraySt<MEDCoupling::DataArrayInt32>;
+using PyCallBackDataArrayInt64 = struct PyCallBackDataArraySt<MEDCoupling::DataArrayInt64>;
+using PyCallBackDataArrayFloat = struct PyCallBackDataArraySt<MEDCoupling::DataArrayFloat>;
+using PyCallBackDataArrayDouble = struct PyCallBackDataArraySt<MEDCoupling::DataArrayDouble>;
extern "C"
{
static PyObject *callbackmcdataarraychar___new__(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
- PyCallBackDataArrayChar *self = (PyCallBackDataArrayChar *) ( type->tp_alloc(type, 0) );
+ auto *self = (PyCallBackDataArrayChar *) ( type->tp_alloc(type, 0) );
return (PyObject *)self;
}
static PyObject *callbackmcdataarrayint32___new__(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
- PyCallBackDataArrayInt32 *self = (PyCallBackDataArrayInt32 *) ( type->tp_alloc(type, 0) );
+ auto *self = (PyCallBackDataArrayInt32 *) ( type->tp_alloc(type, 0) );
return (PyObject *)self;
}
static PyObject *callbackmcdataarrayint64___new__(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
- PyCallBackDataArrayInt64 *self = (PyCallBackDataArrayInt64 *) ( type->tp_alloc(type, 0) );
+ auto *self = (PyCallBackDataArrayInt64 *) ( type->tp_alloc(type, 0) );
return (PyObject *)self;
}
static PyObject *callbackmcdataarrayfloat___new__(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
- PyCallBackDataArrayFloat *self = (PyCallBackDataArrayFloat *) ( type->tp_alloc(type, 0) );
+ auto *self = (PyCallBackDataArrayFloat *) ( type->tp_alloc(type, 0) );
return (PyObject *)self;
}
static PyObject *callbackmcdataarraydouble___new__(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
- PyCallBackDataArrayDouble *self = (PyCallBackDataArrayDouble *) ( type->tp_alloc(type, 0) );
+ auto *self = (PyCallBackDataArrayDouble *) ( type->tp_alloc(type, 0) );
return (PyObject *)self;
}
#include "MEDFileBasis.hxx"
+#include <algorithm>
#include <cstring>
+#include <string>
using namespace MEDCoupling;
#ifndef __MEDFILEBASIS_HXX__
#define __MEDFILEBASIS_HXX__
-#include "InterpKernelException.hxx"
+#include "MCAuto.hxx"
#include "MEDCouplingMemArray.hxx"
-#include "MEDCouplingMemArray.txx"
+#include "MEDCouplingTraits.hxx"
+#include "MEDCouplingRefCountObject.hxx"
#include <string>
#include <vector>
// Author : Anthony Geay (EDF R&D)
#include "MEDFileBlowStrEltUp.hxx"
+#include "MCAuto.hxx"
+#include "MCAuto.txx"
+#include "MCType.hxx"
+#include "MEDCoupling1GTUMesh.hxx"
+#include "MCIdType.hxx"
+#include "InterpKernelAutoPtr.hxx"
#include "MEDCouplingFieldDouble.hxx"
+#include "MEDFileField.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MEDCouplingUMesh.hxx"
+#include "MEDFileFieldMultiTS.hxx"
+#include "MEDFileField1TS.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDFileFieldGlobs.hxx"
+#include "MEDFileFieldInternal.hxx"
#include "MEDFileFieldVisitor.hxx"
#include "MEDCouplingPartDefinition.hxx"
-#include "MCAuto.txx"
+#include "MEDFileMesh.hxx"
+#include "MEDFileStructureElement.hxx"
+#include <algorithm>
+#include <cstddef>
+#include "MEDFileMeshLL.hxx"
+#include "MEDFileMeshElt.hxx"
+#include "NormalizedGeometricTypes"
+#include <cmath>
+#include <iterator>
+#include <math.h>
#include <numeric>
+#include <utility>
+#include <string>
+#include <sstream>
+#include <vector>
using namespace MEDCoupling;
_ms.takeRef(ms); _ses.takeRef(ses);
std::vector< std::pair<std::string,std::string> > ps;
fsOnlyOnSE->getMeshSENames(ps);
- std::size_t sz(ps.size());
+ std::size_t const sz(ps.size());
_elts.resize(sz);
for(std::size_t i=0;i<sz;i++)
{
const std::pair<std::string,std::string>& p(ps[i]);
- MCAuto<MEDFileFields> f(fsOnlyOnSE->partOfThisLyingOnSpecifiedMeshSEName(p.first,p.second));
+ MCAuto<MEDFileFields> const f(fsOnlyOnSE->partOfThisLyingOnSpecifiedMeshSEName(p.first,p.second));
_elts[i]=f;
}
for(std::size_t i=0;i<sz;i++)
MEDFileMesh *mesh(_ms->getMeshWithName(p.first));
if(!mesh)
throw INTERP_KERNEL::Exception("MEDFileBlowStrEltUp : NULL mesh !");
- MEDFileUMesh *umesh(dynamic_cast<MEDFileUMesh *>(mesh));
+ auto *umesh(dynamic_cast<MEDFileUMesh *>(mesh));
if(!umesh)
throw INTERP_KERNEL::Exception("MEDFileBlowStrEltUp : Blow up of Stru Elt not managed yet for unstructured meshes !");
}
throw INTERP_KERNEL::Exception("MEDFileBlowStrEltUp::dealWithSEInMesh : null pointer !");
if(seName==MED_BALL_STR)
{
- MCAuto<MEDFileEltStruct4Mesh> ret(dealWithMEDBALLInMesh(mesh,mOut,fsOut));
+ MCAuto<MEDFileEltStruct4Mesh> const ret(dealWithMEDBALLInMesh(mesh,mOut,fsOut));
mesh->killStructureElements();
return ret;
}
mOut=MEDFileUMesh::New(); fsOut=MEDFileFields::New();
const std::vector< MCAuto<MEDFileEltStruct4Mesh> >& strs(mesh->getAccessOfUndergroundEltStrs());
MCAuto<MEDFileEltStruct4Mesh> zeStr;
- for(std::vector< MCAuto<MEDFileEltStruct4Mesh> >::const_iterator it=strs.begin();it!=strs.end();it++)
+ for(const auto & str : strs)
{
- if((*it)->getGeoTypeName()==MED_BALL_STR)
+ if(str->getGeoTypeName()==MED_BALL_STR)
{
- zeStr=*it;
+ zeStr=str;
break;
}
}
mOut->setRenumFieldArr(0,const_cast<DataArrayIdType *>(nf0));
mOut->copyFamGrpMapsFrom(*mesh);
const std::vector< MCAuto<DataArray> >& vars(zeStr->getVars());
- for(std::vector< MCAuto<DataArray> >::const_iterator it=vars.begin();it!=vars.end();it++)
+ for(const auto & var : vars)
{
- const DataArray *elt(*it);
+ const DataArray *elt(var);
if(!elt)
continue;
{
- const DataArrayDouble *eltC(dynamic_cast<const DataArrayDouble *>(elt));
+ const auto *eltC(dynamic_cast<const DataArrayDouble *>(elt));
if(eltC)
{
MCAuto<MEDFileFieldMultiTS> fmts(MEDFileFieldMultiTS::New());
throw INTERP_KERNEL::Exception("MEDFileBlowStrEltUp::dealWithSEInFields : only MED_BALL is managed for the moment, but if you are interested please send spec to anthony.geay@edf.fr !");
}
-void MEDFileBlowStrEltUp::dealWithMEDBALLSInFields(const MEDFileFields *fs, const MEDFileEltStruct4Mesh *zeStr, const MEDFileFields *varAtt, MEDFileFields *zeOutputs) const
+void MEDFileBlowStrEltUp::dealWithMEDBALLSInFields(const MEDFileFields *fs, const MEDFileEltStruct4Mesh * /*zeStr*/, const MEDFileFields *varAtt, MEDFileFields *zeOutputs) const
{
- int nbf(fs->getNumberOfFields());
+ int const nbf(fs->getNumberOfFields());
std::vector< MCAuto<MEDFileAnyTypeFieldMultiTS> > elts0;
std::vector< MEDFileAnyTypeFieldMultiTS * > elts1;
std::string zeMeshName;
{
MCAuto<MEDFileAnyTypeFieldMultiTS> elt(fs->getFieldAtPos(i));
MCAuto<MEDFileAnyTypeFieldMultiTS> eltOut(elt->buildNewEmpty());
- int nbTS(elt->getNumberOfTS());
+ int const nbTS(elt->getNumberOfTS());
for(int j=0;j<nbTS;j++)
{
MCAuto<MEDFileAnyTypeField1TS> eltt(elt->getTimeStepAtPos(j));
MCAuto<MEDFileAnyTypeField1TS> elttOut(eltt->deepCopy());
- std::string meshName(eltt->getMeshName());
+ std::string const meshName(eltt->getMeshName());
zeMeshName=BuildNewMeshName(meshName,MED_BALL_STR);
elttOut->setMeshName(zeMeshName);
elttOut->convertMedBallIntoClassic();
std::size_t jj(0);
for(std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> >::const_iterator it1=sp2.begin();it1!=sp2.end();it1++,jj++)
{
- for(std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
- zeOutputs->pushField(*it2);
+ for(auto it2 : *it1)
+ zeOutputs->pushField(it2);
// The most exciting part. Users that put profiles on struct elements part of fields. Reduce var att.
if((*it1).size()<1)
throw INTERP_KERNEL::Exception("MEDFileBlowStrEltUp::dealWithMEDBALLSInFields : take a deep breath !");
{
if(!(*it1)[0])
throw INTERP_KERNEL::Exception("MEDFileBlowStrEltUp::dealWithMEDBALLSInFields : take a deep breath 2 !");
- int pdm((*it1)[0]->getNumberOfTS());
+ int const pdm((*it1)[0]->getNumberOfTS());
if(pdm<1)
throw INTERP_KERNEL::Exception("MEDFileBlowStrEltUp::dealWithMEDBALLSInFields : take a deep breath 3 !");
zeGuideForPfl=(*it1)[0]->getTimeStepAtPos(0);
// Yeah we have pfls
std::vector<double> t2s;
std::vector< std::pair<int,int> > t1s((*it1)[0]->getTimeSteps(t2s));
- std::size_t nbTS3(t2s.size());
- int nbf2(varAtt->getNumberOfFields());
+ std::size_t const nbTS3(t2s.size());
+ int const nbf2(varAtt->getNumberOfFields());
for(int i=0;i<nbf2;i++)
{
MCAuto<MEDFileAnyTypeFieldMultiTS> elt(varAtt->getFieldAtPos(i));
- int nbTS2(elt->getNumberOfTS());
+ int const nbTS2(elt->getNumberOfTS());
if(nbTS2!=1)
throw INTERP_KERNEL::Exception("MEDFileBlowStrEltUp::dealWithMEDBALLSInFields : internal error ! The dealWithMEDBALLInMesh is expected to return a single TS !");
MCAuto<MEDFileAnyTypeField1TS> elt2(elt->getTimeStepAtPos(0));
void MEDFileBlowStrEltUp::generate(MEDFileMeshes *msOut, MEDFileFields *allZeOutFields)
{
- for(std::vector< MCAuto<MEDFileFields> >::iterator elt=_elts.begin();elt!=_elts.end();elt++)
+ for(auto & _elt : _elts)
{
std::vector< std::pair<std::string,std::string> > ps;
- (*elt)->getMeshSENames(ps);
+ _elt->getMeshSENames(ps);
if(ps.size()!=1)
throw INTERP_KERNEL::Exception("MEDFileBlowStrEltUp::generateMeshes : internal error !");
MEDFileMesh *mesh(_ms->getMeshWithName(ps[0].first));
if(!mesh)
throw INTERP_KERNEL::Exception("MEDFileBlowStrEltUp::generateMeshes : NULL mesh !");
- MEDFileUMesh *umesh(dynamic_cast<MEDFileUMesh *>(mesh));
+ auto *umesh(dynamic_cast<MEDFileUMesh *>(mesh));
if(!umesh)
throw INTERP_KERNEL::Exception("MEDFileBlowStrEltUp::generateMeshes : Blow up of Stru Elt not managed yet for unstructured meshes !");
//
- MCAuto<MEDFileFields> classicalSEFields(splitFieldsPerLoc(*elt,umesh,msOut,allZeOutFields));
+ MCAuto<MEDFileFields> classicalSEFields(splitFieldsPerLoc(_elt,umesh,msOut,allZeOutFields));
if(classicalSEFields.isNotNull())
{
MCAuto<MEDFileUMesh> mOut;
class LocInfo
{
public:
- LocInfo() { }
+ LocInfo() = default;
LocInfo(const std::vector<FieldWalker2>& fw);
bool operator==(const LocInfo& other) const { return _locs==other._locs && _pfl==other._pfl; }
void push(const std::string& loc, const std::string& pfl) { checkUniqueLoc(loc); _locs.push_back(loc); _pfl.push_back(pfl); }
LocInfo::LocInfo(const std::vector<FieldWalker2>& fw)
{
- std::size_t sz(fw.size());
+ std::size_t const sz(fw.size());
_locs.resize(sz); _pfl.resize(sz); _cts.resize(sz);
if(sz>0)
_pd=fw[0].getPartDef()->deepCopy();
}
}
-MCAuto<MEDCouplingUMesh> LocInfo::BuildMeshCommon(INTERP_KERNEL::NormalizedCellType gt, const std::string& pfl, const MEDFileFieldLoc& loc, const MEDFileEltStruct4Mesh *zeStr, const MEDFileUMesh *mesh, const MEDFileUMesh *section, const MEDFileFieldGlobsReal *globs, MCAuto<DataArrayDouble>& ptsForLoc)
+MCAuto<MEDCouplingUMesh> LocInfo::BuildMeshCommon(INTERP_KERNEL::NormalizedCellType gt, const std::string& pfl, const MEDFileFieldLoc& loc, const MEDFileEltStruct4Mesh *zeStr, const MEDFileUMesh *mesh, const MEDFileUMesh * /*section*/, const MEDFileFieldGlobsReal *globs, MCAuto<DataArrayDouble>& ptsForLoc)
{
MCAuto<DataArrayIdType> conn(zeStr->getConn());
conn=conn->deepCopy(); conn->rearrange(1);
//
MCAuto<MEDCouplingFieldDouble> dir(geoMesh->buildDirectionVectorField());
MCAuto<DataArrayDouble> rot(dir->getArray()->fromCartToSpher());
- std::size_t nbCompo(ptsForLoc->getNumberOfComponents());
+ std::size_t const nbCompo(ptsForLoc->getNumberOfComponents());
MCAuto<DataArrayDouble> secPts(section->getCoords()->changeNbOfComponents(nbCompo,0.));
mcIdType nbSecPts(secPts->getNumberOfTuples()),nbCells(geoMesh->getNumberOfCells()),nbg(ToIdType(loc.getGaussWeights().size()));
{
const int TAB[3]={2,0,1};
- std::vector<std::size_t> v(TAB,TAB+3);
+ std::vector<std::size_t> const v(TAB,TAB+3);
secPts=secPts->keepSelectedComponents(v);
}
const double CENTER[3]={0.,0.,0.},AX0[3]={0.,0.,1.};
for(int j=0;j<nbCells;j++)
{
MCAuto<DataArrayDouble> p(secPts->deepCopy());
- double ang0(rot->getIJ(j,2));
+ double const ang0(rot->getIJ(j,2));
DataArrayDouble::Rotate3DAlg(CENTER,AX0,ang0,nbSecPts,p->begin(),p->getPointer());
AX1[0]=-sin(ang0); AX1[1]=cos(ang0);// rot Oy around OZ
- double ang1(M_PI/2.-rot->getIJ(j,1));
+ double const ang1(M_PI/2.-rot->getIJ(j,1));
DataArrayDouble::Rotate3DAlg(CENTER,AX1,-ang1,nbSecPts,p->begin(),p->getPointer());
DataArrayDouble::Rotate3DAlg(CENTER,dir->getArray()->begin()+j*3,angleVrille->getIJ(j,0),nbSecPts,p->begin(),p->getPointer());
for(int l=0;l<nbg;l++)
}
}
std::vector<const DataArrayDouble *> arrs2(VecAutoToVecOfCstPt(arrs));
- MCAuto<DataArrayDouble> resu(DataArrayDouble::Aggregate(arrs2));
+ MCAuto<DataArrayDouble> const resu(DataArrayDouble::Aggregate(arrs2));
return resu;
}
MCAuto<MEDCouplingFieldDouble> ortho(geoMesh->buildOrthogonalField());
orthoArr.takeRef(ortho->getArray());
}
- mcIdType nbCompo(ToIdType(orthoArr->getNumberOfComponents()));
+ mcIdType const nbCompo(ToIdType(orthoArr->getNumberOfComponents()));
MCAuto<DataArrayDouble> secPts(section->getCoords()->duplicateEachTupleNTimes(nbCompo));
secPts->rearrange(nbCompo);
std::vector< MCAuto<DataArrayDouble> > arrs(nbCells*nbg);
}
}
std::vector<const DataArrayDouble *> arrs2(VecAutoToVecOfCstPt(arrs));
- MCAuto<DataArrayDouble> resu(DataArrayDouble::Aggregate(arrs2));
+ MCAuto<DataArrayDouble> const resu(DataArrayDouble::Aggregate(arrs2));
return resu;
}
dir=geoMesh2->buildDirectionVectorField();
}
MCAuto<DataArrayDouble> rot(dir->getArray()->fromCartToSpher());
- std::size_t nbCompo(ptsForLoc->getNumberOfComponents());
+ std::size_t const nbCompo(ptsForLoc->getNumberOfComponents());
MCAuto<DataArrayDouble> secPts(section->getCoords()->changeNbOfComponents(nbCompo,0.));
{
const int TAB[3]={2,0,1};
- std::vector<std::size_t> v(TAB,TAB+3);
+ std::vector<std::size_t> const v(TAB,TAB+3);
secPts=secPts->keepSelectedComponents(v);
}
const double CENTER[3]={0.,0.,0.},AX0[3]={0.,0.,1.};
{
constexpr int DIM=3;
MCAuto<DataArrayDouble> p(secPts->deepCopy());
- double ang0(rot->getIJ(j,2));
+ double const ang0(rot->getIJ(j,2));
double rmin(zeScale->getIJ(j,0)),rmax(zeScale->getIJ(j,1));
{
auto pt(p->rwBegin());
}
DataArrayDouble::Rotate3DAlg(CENTER,AX0,ang0,nbSecPts,p->begin(),p->getPointer());
AX1[0]=-sin(ang0); AX1[1]=cos(ang0);// rot Oy around OZ
- double ang1(M_PI/2.-rot->getIJ(j,1));
+ double const ang1(M_PI/2.-rot->getIJ(j,1));
DataArrayDouble::Rotate3DAlg(CENTER,AX1,-ang1,nbSecPts,p->begin(),p->getPointer());
for(int l=0;l<3;l++)
{
}
}
std::vector<const DataArrayDouble *> arrs2(VecAutoToVecOfCstPt(arrs));
- MCAuto<DataArrayDouble> resu(DataArrayDouble::Aggregate(arrs2));
+ MCAuto<DataArrayDouble> const resu(DataArrayDouble::Aggregate(arrs2));
return resu;
}
dir=geoMesh2->buildDirectionVectorField();
}
MCAuto<DataArrayDouble> rot(dir->getArray()->fromCartToSpher());
- std::size_t nbCompo(ptsForLoc->getNumberOfComponents());
+ std::size_t const nbCompo(ptsForLoc->getNumberOfComponents());
MCAuto<DataArrayDouble> secPts(section->getCoords()->changeNbOfComponents(nbCompo,0.));
{
const int TAB[3]={2,0,1};
- std::vector<std::size_t> v(TAB,TAB+3);
+ std::vector<std::size_t> const v(TAB,TAB+3);
secPts=secPts->keepSelectedComponents(v);
}
const double CENTER[3]={0.,0.,0.},AX0[3]={0.,0.,1.};
{
constexpr int DIM=3;
MCAuto<DataArrayDouble> p(secPts->deepCopy());
- double ang0(rot->getIJ(j,2));
+ double const ang0(rot->getIJ(j,2));
double rmin(zeScale->getIJ(j,0)),rmax(zeScale->getIJ(j,1));
{
auto pt(p->rwBegin());
}
DataArrayDouble::Rotate3DAlg(CENTER,AX0,ang0,nbSecPts,p->begin(),p->getPointer());
AX1[0]=-sin(ang0); AX1[1]=cos(ang0);// rot Oy around OZ
- double ang1(M_PI/2.-rot->getIJ(j,1));
+ double const ang1(M_PI/2.-rot->getIJ(j,1));
DataArrayDouble::Rotate3DAlg(CENTER,AX1,-ang1,nbSecPts,p->begin(),p->getPointer());
for(int l=0;l<3;l++)
{
}
}
std::vector<const DataArrayDouble *> arrs2(VecAutoToVecOfCstPt(arrs));
- MCAuto<DataArrayDouble> resu(DataArrayDouble::Aggregate(arrs2));
+ MCAuto<DataArrayDouble> const resu(DataArrayDouble::Aggregate(arrs2));
return resu;
}
{
const MEDFileFieldLoc& loc(globs->getLocalization(_locs[i]));
const MEDFileGTKeeper *gtk(loc.getUndergroundGTKeeper());
- const MEDFileGTKeeperDyn *gtk2(dynamic_cast<const MEDFileGTKeeperDyn *>(gtk));
+ const auto *gtk2(dynamic_cast<const MEDFileGTKeeperDyn *>(gtk));
if(!gtk2)
throw INTERP_KERNEL::Exception("LocInfo::generateNonClassicalData : internal error !");
const MEDFileUMesh *meshLoc(gtk2->getMesh()),*section(gtk2->getSection());
const MEDFileStructureElement *se(gtk2->getSE());
MCAuto<MEDCouplingUMesh> um(meshLoc->getMeshAtLevel(0));
- INTERP_KERNEL::NormalizedCellType gt(_cts[i]);
+ INTERP_KERNEL::NormalizedCellType const gt(_cts[i]);
{
std::vector<int> nel(meshLoc->getNonEmptyLevels());
if(nel.size()!=1)
throw INTERP_KERNEL::Exception(MSG1);
std::vector<mcIdType> v;
um->getNodeIdsOfCell(zePos,v);
- std::size_t sz2(v.size());
+ std::size_t const sz2(v.size());
for(std::size_t j=0;j<sz2;j++)
if(v[j]!=ToIdType(j))
throw INTERP_KERNEL::Exception(MSG1);
}
const std::vector< MCAuto<MEDFileEltStruct4Mesh> >& strs(mesh->getAccessOfUndergroundEltStrs());
MCAuto<MEDFileEltStruct4Mesh> zeStr;
- for(std::vector< MCAuto<MEDFileEltStruct4Mesh> >::const_iterator it=strs.begin();it!=strs.end();it++)
+ for(const auto & str : strs)
{
- if((*it)->getGeoTypeName()==se->getName())
+ if(str->getGeoTypeName()==se->getName())
{
- zeStr=*it;
+ zeStr=str;
break;
}
}
std::string tmp;
ret2=_pd->isEqual(other._pd,tmp);
}
- bool ret(_loc==other._loc && _pfl==other._pfl && _is_classic==other._is_classic && ret2);
+ bool const ret(_loc==other._loc && _pfl==other._pfl && _is_classic==other._is_classic && ret2);
return ret;
}
class FieldWalker1
{
public:
- FieldWalker1(const MEDFileAnyTypeField1TSWithoutSDA *ts):_ts(ts),_pm_pt(0),_nb_mesh(0) { }
+ FieldWalker1(const MEDFileAnyTypeField1TSWithoutSDA *ts):_ts(ts) { }
void newMeshEntry(const MEDFileFieldPerMesh *fpm);
void endMeshEntry(const MEDFileFieldPerMesh *fpm) { }
void newPerMeshPerTypeEntry(const MEDFileFieldPerMeshPerTypeCommon *pmpt);
std::vector<FieldWalker2> getNonClassicalData() const { return _fw; }
private:
const MEDFileAnyTypeField1TSWithoutSDA *_ts;
- const MEDFileFieldPerMeshPerTypeDyn *_pm_pt;
+ const MEDFileFieldPerMeshPerTypeDyn *_pm_pt{nullptr};
std::vector<FieldWalker2> _fw;
- int _nb_mesh;
+ int _nb_mesh{0};
};
-void FieldWalker1::newMeshEntry(const MEDFileFieldPerMesh *fpm)
+void FieldWalker1::newMeshEntry(const MEDFileFieldPerMesh * /*fpm*/)
{
if(_nb_mesh++==1)
throw INTERP_KERNEL::Exception("FieldWalker1::newMeshEntry : multi mesh not supported !");
{
if(_pm_pt)
throw INTERP_KERNEL::Exception("FieldWalker1::newPerMeshPerTypeEntry : multi SE loc not managed yet !");
- const MEDFileFieldPerMeshPerTypeDyn *pmpt2(dynamic_cast<const MEDFileFieldPerMeshPerTypeDyn *>(pmpt));
+ const auto *pmpt2(dynamic_cast<const MEDFileFieldPerMeshPerTypeDyn *>(pmpt));
if(!pmpt2)
throw INTERP_KERNEL::Exception("newPerMeshPerTypeEntry : internal error !");
_pm_pt=pmpt2;
void FieldWalker1::checkOK(const FieldWalker1& other) const
{
- std::size_t sz(_fw.size());
+ std::size_t const sz(_fw.size());
if(other._fw.size()!=sz)
throw INTERP_KERNEL::Exception("checkOK : not OK because size are not the same !");
for(std::size_t i=0;i<sz;i++)
if(_fw.empty())
throw INTERP_KERNEL::Exception("FieldWalker1::endPerMeshPerTypeEntry : internal error !");
std::size_t ic(0),inc(0);
- for(std::vector<FieldWalker2>::const_iterator it=_fw.begin();it!=_fw.end();it++)
+ for(const auto & it : _fw)
{
- if((*it).isClassic())
+ if(it.isClassic())
ic++;
else
inc++;
_fw=new FieldWalker1(ts);
}
-void FieldWalker::endTimeStepEntry(const MEDFileAnyTypeField1TSWithoutSDA *ts)
+void FieldWalker::endTimeStepEntry(const MEDFileAnyTypeField1TSWithoutSDA * /*ts*/)
{
if(_fw_prev.isNull())
_fw_prev=new FieldWalker1(*_fw);
else
_fw_prev->checkOK(*_fw);
- _fw=0;
+ _fw=nullptr;
}
void FieldWalker::newMeshEntry(const MEDFileFieldPerMesh *fpm)
class LocSpliter : public MEDFileFieldVisitor
{
public:
- LocSpliter(const MEDFileFieldGlobsReal *globs):_globs(globs),_fw(0) { }
+ LocSpliter(const MEDFileFieldGlobsReal *globs):_globs(globs),_fw(nullptr) { }
MCAuto<MEDFileFields> getClassical() const { return _classical; }
void generateNonClassicalData(const MEDFileUMesh *mesh, std::vector< MCAuto<MEDFileFields> >& outFields, std::vector< MCAuto<MEDFileUMesh> >& outMeshes) const;
private:
- void newFieldEntry(const MEDFileAnyTypeFieldMultiTSWithoutSDA *field);
- void endFieldEntry(const MEDFileAnyTypeFieldMultiTSWithoutSDA *field);
+ void newFieldEntry(const MEDFileAnyTypeFieldMultiTSWithoutSDA *field) override;
+ void endFieldEntry(const MEDFileAnyTypeFieldMultiTSWithoutSDA *field) override;
//
- void newTimeStepEntry(const MEDFileAnyTypeField1TSWithoutSDA *ts);
- void endTimeStepEntry(const MEDFileAnyTypeField1TSWithoutSDA *ts);
+ void newTimeStepEntry(const MEDFileAnyTypeField1TSWithoutSDA *ts) override;
+ void endTimeStepEntry(const MEDFileAnyTypeField1TSWithoutSDA *ts) override;
//
- void newMeshEntry(const MEDFileFieldPerMesh *fpm);
- void endMeshEntry(const MEDFileFieldPerMesh *fpm);
+ void newMeshEntry(const MEDFileFieldPerMesh *fpm) override;
+ void endMeshEntry(const MEDFileFieldPerMesh *fpm) override;
//
- void newPerMeshPerTypeEntry(const MEDFileFieldPerMeshPerTypeCommon *pmpt);
- void endPerMeshPerTypeEntry(const MEDFileFieldPerMeshPerTypeCommon *pmpt);
+ void newPerMeshPerTypeEntry(const MEDFileFieldPerMeshPerTypeCommon *pmpt) override;
+ void endPerMeshPerTypeEntry(const MEDFileFieldPerMeshPerTypeCommon *pmpt) override;
//
- void newPerMeshPerTypePerDisc(const MEDFileFieldPerMeshPerTypePerDisc *pmptpd);
+ void newPerMeshPerTypePerDisc(const MEDFileFieldPerMeshPerTypePerDisc *pmptpd) override;
private:
const MEDFileFieldGlobsReal *_globs;
std::vector< LocInfo > _locs;
}
else
{
- std::vector<FieldWalker2> fw2(_fw->getNonClassicalData());
- LocInfo elt(fw2);
- std::vector< LocInfo >::iterator it(std::find(_locs.begin(),_locs.end(),elt));
+ std::vector<FieldWalker2> const fw2(_fw->getNonClassicalData());
+ LocInfo const elt(fw2);
+ auto const it(std::find(_locs.begin(),_locs.end(),elt));
if(it==_locs.end())
{
_locs.push_back(elt);
void LocSpliter::generateNonClassicalData(const MEDFileUMesh *mesh, std::vector< MCAuto<MEDFileFields> >& outFields, std::vector< MCAuto<MEDFileUMesh> >& outMeshes) const
{
int i(0);
- for(std::vector<LocInfo>::const_iterator it=_locs.begin();it!=_locs.end();it++,i++)
+ for(auto it=_locs.begin();it!=_locs.end();it++,i++)
{
MCAuto<MEDFileUMesh> m((*it).generateNonClassicalData(i,mesh,_globs));
outMeshes.push_back(m);
MCAuto<MEDFileField1TS> outF1t(MEDFileField1TS::New());
MCAuto<MEDFileField1TS> f1ts(fmts->getTimeStepAtPos(k));
int t2,t3;
- double t1(f1ts->getTime(t2,t3));
+ double const t1(f1ts->getTime(t2,t3));
MCAuto<MEDCouplingFieldDouble> mcf(MEDCouplingFieldDouble::New(ON_NODES));
MCAuto<DataArrayDouble> arr,arr2;
arr.takeRef(f1ts->getUndergroundDataArray());
std::vector< MCAuto<MEDFileFields> > outFields;
std::vector< MCAuto<MEDFileUMesh> > outMeshes;
ls.generateNonClassicalData(mesh,outFields,outMeshes);
- for(std::vector< MCAuto<MEDFileFields> >::iterator it=outFields.begin();it!=outFields.end();it++)
+ for(auto & outField : outFields)
{
- for(int j=0;j<(*it)->getNumberOfFields();j++)
+ for(int j=0;j<outField->getNumberOfFields();j++)
{
- MCAuto<MEDFileAnyTypeFieldMultiTS> fmts((*it)->getFieldAtPos(j));
+ MCAuto<MEDFileAnyTypeFieldMultiTS> fmts(outField->getFieldAtPos(j));
//DealWithConflictNames(fmts,allZeOutFields);// uncomment to have a writable data structure
allZeOutFields->pushField(fmts);
}
}
- for(std::vector< MCAuto<MEDFileUMesh> >::iterator it=outMeshes.begin();it!=outMeshes.end();it++)
- msOut->pushMesh(*it);
+ for(auto & outMeshe : outMeshes)
+ msOut->pushMesh(outMeshe);
return ls.getClassical();
}
#ifndef __MEDFILEBLOWSTRELTUP_HXX__
#define __MEDFILEBLOWSTRELTUP_HXX__
-#include "MEDLoaderDefines.hxx"
-#include "MEDFileUtilities.txx"
+#include "MCAuto.hxx"
+#include "MEDFileMeshLL.hxx"
+#include "MEDFileFieldMultiTS.hxx"
#include "MEDFileMesh.hxx"
#include "MEDFileField.hxx"
#include "MEDFileStructureElement.hxx"
-#include "MEDCouplingRefCountObject.hxx"
+#include <string>
+#include <cstddef>
+#include <vector>
namespace MEDCoupling
{
// Author : Anthony Geay (CEA/DEN)
#include "MEDFileData.hxx"
+#include "MEDFileUtilities.hxx"
+#include "MCAuto.hxx"
+#include "MEDFileField.hxx"
+#include "MEDFileMesh.hxx"
+#include "MEDFileParameter.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDFileMeshSupport.hxx"
+#include "MEDFileStructureElement.hxx"
+#include "MCType.hxx"
+#include "MEDFileFieldMultiTS.hxx"
#include "MEDLoaderBase.hxx"
#include "MEDFileSafeCaller.txx"
#include "MEDFileBlowStrEltUp.hxx"
#include "InterpKernelAutoPtr.hxx"
+#include <string>
+#include "med.h"
+#include <cstddef>
+#include <vector>
+#include <sstream>
+#include <ostream>
+#include <utility>
+#include <set>
+#include "medfile.h"
using namespace MEDCoupling;
MEDFileData *MEDFileData::New(const std::string& fileName)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return New(fid);
}
bool MEDFileData::changeMeshName(const std::string& oldMeshName, const std::string& newMeshName)
{
- std::string oldName(oldMeshName);
+ std::string const oldName(oldMeshName);
std::vector< std::pair<std::string,std::string> > v(1);
v[0].first=oldName; v[0].second=newMeshName;
return changeMeshNames(v);
if(m)
{
std::vector<mcIdType> oldCode,newCode;
- DataArrayIdType *o2nRenumCell=0;
- bool modif=m->unPolyze(oldCode,newCode,o2nRenumCell);
+ DataArrayIdType *o2nRenumCell=nullptr;
+ bool const modif=m->unPolyze(oldCode,newCode,o2nRenumCell);
if(!modif)
continue;
renumParamsOfMeshImpacted.push_back(o2nRenumCell); memSaverIfThrow.push_back(o2nRenumCell);
MCAuto<MEDFileData> ret(MEDFileData::New());
std::vector<const MEDFileUMesh *> ms(sz);
std::vector< std::vector< std::pair<int,mcIdType> > > dts(sz);
- for(std::vector<const MEDFileData *>::const_iterator it=mfds.begin();it!=mfds.end();it++,i++)
+ for(auto it=mfds.begin();it!=mfds.end();it++,i++)
{
const MEDFileData *elt(*it);
if(!elt)
const MEDFileMesh *mesh(meshes->getMeshAtPos(0));
if(!mesh)
throw INTERP_KERNEL::Exception("MEDFileData::Aggregate : presence of null mesh in a MEDFileData instance among input vector !");
- const MEDFileUMesh *umesh(dynamic_cast<const MEDFileUMesh *>(mesh));
+ const auto *umesh(dynamic_cast<const MEDFileUMesh *>(mesh));
if(!umesh)
throw INTERP_KERNEL::Exception("MEDFileData::Aggregate : works only for unstructured meshes !");
ms[i]=umesh;
ret->setMeshes(mss);
// fields
std::vector<std::string> fieldNames(mfds[0]->getFields()->getFieldsNames());
- std::set<std::string> fieldNamess(fieldNames.begin(),fieldNames.end());
+ std::set<std::string> const fieldNamess(fieldNames.begin(),fieldNames.end());
if(fieldNames.size()!=fieldNamess.size())
throw INTERP_KERNEL::Exception("MEDFileData::Aggregate : field names must be different each other !");
std::vector< std::vector<const MEDFileAnyTypeFieldMultiTS *> > vectOfFields(fieldNames.size());
std::vector< std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > > > vectOfFields2(fieldNames.size());
MCAuto<MEDFileFields> fss(MEDFileFields::New());
- for(std::vector<const MEDFileData *>::const_iterator it=mfds.begin();it!=mfds.end();it++)
+ for(auto mfd : mfds)
{
- std::vector<std::string> fieldNames0((*it)->getFields()->getFieldsNames());
- std::set<std::string> fieldNamess0(fieldNames0.begin(),fieldNames0.end());
+ std::vector<std::string> fieldNames0(mfd->getFields()->getFieldsNames());
+ std::set<std::string> const fieldNamess0(fieldNames0.begin(),fieldNames0.end());
if(fieldNamess!=fieldNamess0)
throw INTERP_KERNEL::Exception("MEDFileData::Aggregate : field names must be the same for all input instances !");
i=0;
for(std::vector<std::string>::const_iterator it1=fieldNames.begin();it1!=fieldNames.end();it1++,i++)
{
- MCAuto<MEDFileAnyTypeFieldMultiTS> fmts((*it)->getFields()->getFieldWithName(*it1));
+ MCAuto<MEDFileAnyTypeFieldMultiTS> fmts(mfd->getFields()->getFieldWithName(*it1));
if(fmts.isNull())
throw INTERP_KERNEL::Exception("MEDFileData::Aggregate : internal error 1 !");
vectOfFields2[i].push_back(fmts); vectOfFields[i].push_back(fmts);
}
MEDFileData::MEDFileData()
-{
-}
+= default;
MEDFileData::MEDFileData(med_idt fid)
try
void MEDFileData::readHeader(med_idt fid)
{
INTERP_KERNEL::AutoPtr<char> header(MEDLoaderBase::buildEmptyString(MED_COMMENT_SIZE));
- int ret(MEDfileCommentRd(fid,header));
+ int const ret(MEDfileCommentRd(fid,header));
if(ret==0)
_header=MEDLoaderBase::buildStringFromFortran(header,MED_COMMENT_SIZE);
}
#define __MEDFILEDATA_HXX__
#include "MCAuto.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingMemArray.hxx"
#include "MEDFileParameter.hxx"
#include "MEDFileField.hxx"
#include "MEDFileMesh.hxx"
#include "MEDFileMeshSupport.hxx"
#include "MEDFileStructureElement.hxx"
+#include "MEDFileUtilities.txx"
+#include "MEDLoaderDefines.hxx"
+#include <string>
+#include "med.h"
+#include <cstddef>
+#include <vector>
+#include <utility>
namespace MEDCoupling
{
MEDLOADER_EXPORT static MEDFileData *New(DataArrayByte *db) { return BuildFromMemoryChunk<MEDFileData>(db); }
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileData"); }
MEDLOADER_EXPORT MEDFileData *deepCopy() const;
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
MEDLOADER_EXPORT MEDFileFields *getFields() const;
MEDLOADER_EXPORT MEDFileMeshes *getMeshes() const;
MEDLOADER_EXPORT MEDFileParameters *getParams() const;
MEDLOADER_EXPORT void dealWithStructureElements();
MEDLOADER_EXPORT static MCAuto<MEDFileData> Aggregate(const std::vector<const MEDFileData *>& mfds);
//
- MEDLOADER_EXPORT void writeLL(med_idt fid) const;
+ MEDLOADER_EXPORT void writeLL(med_idt fid) const override;
private:
MEDFileData();
MEDFileData(med_idt fid);
// Author : Anthony Geay (EDF R&D)
#include "MEDFileEntities.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDFileStructureElement.hxx"
+#include "MEDFileMesh.hxx"
+#include "NormalizedGeometricTypes"
+#include <string>
+#include <vector>
+#include <utility>
using namespace MEDCoupling;
}
MEDFileEntities::~MEDFileEntities()
-{
-}
+= default;
//////////////
#ifndef __MEDFILEENTITIES_HXX__
#define __MEDFILEENTITIES_HXX__
+#include "MCAuto.hxx"
+#include "MEDCouplingRefCountObject.hxx"
#include "MEDLoaderDefines.hxx"
#include "MEDFileStructureElement.hxx"
-
-#include "MEDCouplingRefCountObject.hxx"
#include "NormalizedGeometricTypes"
+#include <string>
+#include <vector>
+#include <utility>
+
namespace MEDCoupling
{
class MEDLOADER_EXPORT MEDFileEntities
public:
MEDFileStaticEntities(const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> >& entities):_entities(entities) { }
const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> >& getEntries() const { return _entities; }
- std::vector<int> getDynGTAvail() const;
- bool areAllStaticTypesPresent() const;
+ std::vector<int> getDynGTAvail() const override;
+ bool areAllStaticTypesPresent() const override;
bool areAllStaticPresentAndNoDyn() const override;
private:
std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > _entities;
class MEDLOADER_EXPORT MEDFileAllStaticEntites : public MEDFileEntities
{
public:
- MEDFileAllStaticEntites() { }
- std::vector<int> getDynGTAvail() const;
- bool areAllStaticTypesPresent() const;
+ MEDFileAllStaticEntites() = default;
+ std::vector<int> getDynGTAvail() const override;
+ bool areAllStaticTypesPresent() const override;
bool areAllStaticPresentAndNoDyn() const override;
};
{
public:
MEDFileAllStaticEntitiesPlusDyn(const MEDFileStructureElements *se);
- std::vector<int> getDynGTAvail() const;
- bool areAllStaticTypesPresent() const;
+ std::vector<int> getDynGTAvail() const override;
+ bool areAllStaticTypesPresent() const override;
bool areAllStaticPresentAndNoDyn() const override;
const MEDFileStructureElement *getWithGT(int idGT) const;
const MEDFileUMesh *getSupMeshWithName(const std::string& name) const;
// Author : Anthony Geay (EDF R&D)
#include "MEDFileEquivalence.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDFileBasis.hxx"
+#include "CellModel.hxx"
+#include "MCType.hxx"
#include "MEDFileSafeCaller.txx"
-#include "MEDCouplingMemArray.hxx"
-#include "MEDCouplingMemArray.txx"
#include "MEDLoaderBase.hxx"
#include "MEDFileMesh.hxx"
#include "InterpKernelAutoPtr.hxx"
+#include "med.h"
+#include "NormalizedGeometricTypes"
+#include <string>
+#include "medequivalence.h"
+#include <sstream>
+#include <ostream>
+#include <vector>
+#include <cstddef>
+#include <algorithm>
+#include <iterator>
// From MEDLOader.cxx TU
extern med_geometry_type typmai[MED_N_CELL_FIXED_GEO];
void MEDFileEquivalencePair::writeLL(med_idt fid) const
{
- std::string meshName(getFather()->getMeshName());
+ std::string const meshName(getFather()->getMeshName());
INTERP_KERNEL::AutoPtr<char> meshName2(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
INTERP_KERNEL::AutoPtr<char> name(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
INTERP_KERNEL::AutoPtr<char> desc(MEDLoaderBase::buildEmptyString(MED_COMMENT_SIZE));
MEDFileEquivalenceNode *node(_node);
if(!node)
{
- _node=new MEDFileEquivalenceNode(this,0);
+ _node=new MEDFileEquivalenceNode(this,nullptr);
node=_node;
}
node->setArray(da);
*/
MEDFileEquivalenceNode *MEDFileEquivalencePair::initNode()
{
- _node=new MEDFileEquivalenceNode(this,0);
+ _node=new MEDFileEquivalenceNode(this,nullptr);
return _node;
}
void MEDFileEquivalencePair::load(med_idt fid)
{
- std::string meshName(_father->getMeshName());
+ std::string const meshName(_father->getMeshName());
int dt,it;
_father->getDtIt(dt,it);
med_int ncor;
MEDFILESAFECALLERRD0(MEDequivalenceCorrespondenceRd,(fid,meshName.c_str(),_name.c_str(),dt,it,MED_NODE,MED_NONE,da->getPointer()));
da->applyLin(1,-1);
da->rearrange(2);
- MCAuto<MEDFileEquivalenceNode> node(new MEDFileEquivalenceNode(this,FromMedIntArray<int>(da)));
+ MCAuto<MEDFileEquivalenceNode> const node(new MEDFileEquivalenceNode(this,FromMedIntArray<int>(da)));
_node=node;
}
_cell=MEDFileEquivalenceCell::Load(fid,this);
std::vector<const BigMemoryObject *> MEDFileEquivalences::getDirectChildrenWithNull() const
{
- std::size_t sz(_equ.size());
+ std::size_t const sz(_equ.size());
std::vector<const BigMemoryObject *> ret(sz);
for(std::size_t i=0;i<sz;i++)
ret[i]=_equ[i];
void MEDFileEquivalences::pushEquivalence(MEDFileEquivalencePair *elt)
{
- MCAuto<MEDFileEquivalencePair> elta(elt);
+ MCAuto<MEDFileEquivalencePair> const elta(elt);
if(elt)
elt->incrRef();
_equ.push_back(elta);
MEDFileEquivalencePair *MEDFileEquivalences::getEquivalence(int i)
{
- int sz(size());
+ int const sz(size());
if(i<0 || i>=sz)
{
std::ostringstream oss; oss << "MEDFileEquivalences::getEquivalence : invalid id ! Must be in [0," << sz << ") !";
MEDFileEquivalencePair *MEDFileEquivalences::getEquivalenceWithName(const std::string& name)
{
- for(std::vector< MCAuto<MEDFileEquivalencePair> >::iterator it=_equ.begin();it!=_equ.end();it++)
+ for(auto & it : _equ)
{
- MEDFileEquivalencePair *elt(*it);
+ MEDFileEquivalencePair *elt(it);
if(elt)
{
if(elt->getName()==name)
std::vector<std::string> MEDFileEquivalences::getEquivalenceNames() const
{
std::vector<std::string> ret;
- for(std::vector< MCAuto<MEDFileEquivalencePair> >::const_iterator it=_equ.begin();it!=_equ.end();it++)
+ for(const auto & it : _equ)
{
- const MEDFileEquivalencePair *elt(*it);
+ const MEDFileEquivalencePair *elt(it);
if(elt)
{
ret.push_back(elt->getName());
bool MEDFileEquivalences::isEqual(const MEDFileEquivalences *other, std::string& what) const
{
- std::size_t sz(_equ.size());
+ std::size_t const sz(_equ.size());
if(sz!=other->_equ.size())
{
what="Equivalences differs : not same number !";
void MEDFileEquivalences::getRepr(std::ostream& oss) const
{
std::size_t ii(0);
- for(std::vector< MCAuto<MEDFileEquivalencePair> >::const_iterator it=_equ.begin();it!=_equ.end();it++,ii++)
+ for(auto it=_equ.begin();it!=_equ.end();it++,ii++)
{
const MEDFileEquivalencePair *elt(*it);
oss << "Equivalence #" << ii << " : " ;
void MEDFileEquivalences::killEquivalenceWithName(const std::string& name)
{
- std::vector< MCAuto<MEDFileEquivalencePair> >::iterator it(_equ.begin());
+ auto it(_equ.begin());
for(;it!=_equ.end();it++)
{
const MEDFileEquivalencePair *elt(*it);
void MEDFileEquivalences::killEquivalenceAt(int i)
{
- int sz(size());
+ int const sz(size());
if(i<0 || i>=sz)
{
std::ostringstream oss; oss << "MEDFileEquivalences::killEquivalenceAt : Id must be in [0," << sz << ") !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- std::vector< MCAuto<MEDFileEquivalencePair> >::iterator it(_equ.begin());
+ auto it(_equ.begin());
for(int j=0;j<i;it++,j++);
_equ.erase(it);
}
void MEDFileEquivalences::writeLL(med_idt fid) const
{
- for(std::vector< MCAuto<MEDFileEquivalencePair> >::const_iterator it=_equ.begin();it!=_equ.end();it++)
+ for(const auto & it : _equ)
{
- const MEDFileEquivalencePair *elt(*it);
+ const MEDFileEquivalencePair *elt(it);
if(elt)
elt->writeLL(fid);
}
int MEDFileEquivalences::PresenceOfEquivalences(med_idt fid, const std::string& meshName)
{
- med_int nequ(MEDnEquivalence(fid,meshName.c_str()));
+ med_int const nequ(MEDnEquivalence(fid,meshName.c_str()));
return FromMedInt<int>(nequ);
}
MCAuto<MEDFileEquivalences> ret(new MEDFileEquivalences(owner));
if(!owner)
throw INTERP_KERNEL::Exception("MEDFileEquivalences::Load : owner is NULL !");
- std::string meshName(owner->getName());
+ std::string const meshName(owner->getName());
for(int i=0;i<nbOfEq;i++)
{
INTERP_KERNEL::AutoPtr<char> equ(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
void MEDFileEquivalences::deepCpyFrom(const MEDFileEquivalences& other)
{
- for(std::vector< MCAuto<MEDFileEquivalencePair> >::const_iterator it=other._equ.begin();it!=other._equ.end();it++)
+ for(const auto & it : other._equ)
{
- const MEDFileEquivalencePair *elt(*it);
+ const MEDFileEquivalencePair *elt(it);
MCAuto<MEDFileEquivalencePair> eltCpy;
if(elt)
{
const MEDFileMesh *mesh(getFather()->getMesh());
int dt,it;
mesh->getTime(dt,it);
- std::string meshName(mesh->getName());
- std::string equName(getFather()->getName());
+ std::string const meshName(mesh->getName());
+ std::string const equName(getFather()->getName());
INTERP_KERNEL::AutoPtr<char> meshName2(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
INTERP_KERNEL::AutoPtr<char> name(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
MEDLoaderBase::safeStrCpy(meshName.c_str(),MED_NAME_SIZE,meshName2,getFather()->getMesh()->getTooLongStrPolicy());
std::vector<const BigMemoryObject *> MEDFileEquivalenceCell::getDirectChildrenWithNull() const
{
- std::size_t sz(_types.size());
+ std::size_t const sz(_types.size());
std::vector<const BigMemoryObject *> ret(sz);
for(std::size_t i=0;i<sz;i++)
ret[i]=_types[i];
if(ret->size()>0)
return ret.retn();
else
- return 0;
+ return nullptr;
}
void MEDFileEquivalenceCell::writeLL(med_idt fid) const
{
- for(std::vector< MCAuto<MEDFileEquivalenceCellType> >::const_iterator it=_types.begin();it!=_types.end();it++)
+ for(const auto & _type : _types)
{
- const MEDFileEquivalenceCellType *ct(*it);
+ const MEDFileEquivalenceCellType *ct(_type);
if(ct)
ct->writeLL(fid);
}
MEDFileEquivalenceCell *MEDFileEquivalenceCell::deepCopy(MEDFileEquivalencePair *owner) const
{
MCAuto<MEDFileEquivalenceCell> ret(new MEDFileEquivalenceCell(owner));
- for(std::vector< MCAuto<MEDFileEquivalenceCellType> >::const_iterator it=_types.begin();it!=_types.end();it++)
+ for(const auto & _type : _types)
{
- const MEDFileEquivalenceCellType *elt(*it);
+ const MEDFileEquivalenceCellType *elt(_type);
MCAuto<MEDFileEquivalenceCellType> eltCpy;
if(elt)
eltCpy=elt->deepCopy(owner);
bool MEDFileEquivalenceCell::isEqual(const MEDFileEquivalenceCell *other, std::string& what) const
{
- std::size_t sz(_types.size());
+ std::size_t const sz(_types.size());
if(sz!=other->_types.size())
{
std::ostringstream oss; oss << "Nb of geo types differs : " << sz << " != " << other->_types.size();
void MEDFileEquivalenceCell::getRepr(std::ostream& oss) const
{
- for(std::vector< MCAuto<MEDFileEquivalenceCellType> >::const_iterator it=_types.begin();it!=_types.end();it++)
+ for(const auto & _type : _types)
{
- const MEDFileEquivalenceCellType *elt(*it);
+ const MEDFileEquivalenceCellType *elt(_type);
if(elt)
elt->getRepr(oss);
}
DataArrayInt *MEDFileEquivalenceCell::getArray(INTERP_KERNEL::NormalizedCellType type)
{
- for(std::vector< MCAuto<MEDFileEquivalenceCellType> >::iterator it=_types.begin();it!=_types.end();it++)
+ for(auto & _type : _types)
{
- MEDFileEquivalenceCellType *elt(*it);
+ MEDFileEquivalenceCellType *elt(_type);
if(elt && elt->getType()==type)
return elt->getArray();
}
return ;
MEDFileEquivalences::CheckDataArray(da);
MEDFileMesh *mm(getMesh());
- mcIdType totalNbOfCells(mm->getNumberOfCellsAtLevel(meshDimRelToMax));
+ mcIdType const totalNbOfCells(mm->getNumberOfCellsAtLevel(meshDimRelToMax));
//
MCAuto<DataArrayInt> tmp(da->deepCopy()); tmp->rearrange(1);
int maxv,minv;
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
//
- std::vector<INTERP_KERNEL::NormalizedCellType> gts(mm->getGeoTypesAtLevel(meshDimRelToMax));
+ std::vector<INTERP_KERNEL::NormalizedCellType> const gts(mm->getGeoTypesAtLevel(meshDimRelToMax));
int startId(0),endId;
- std::vector<std::size_t> compS(1,0);
- for(std::vector<INTERP_KERNEL::NormalizedCellType>::const_iterator it=gts.begin();it!=gts.end();it++)
+ std::vector<std::size_t> const compS(1,0);
+ for(auto gt : gts)
{
- endId=startId+(int)mm->getNumberOfCellsWithType(*it);
+ endId=startId+(int)mm->getNumberOfCellsWithType(gt);
MCAuto<DataArrayInt> da0(da->keepSelectedComponents(compS));
MCAuto<DataArrayIdType> ids(da0->findIdsInRange(startId,endId));
MCAuto<DataArrayInt> da1(da->selectByTupleIdSafe(ids->begin(),ids->end()));
da1->applyLin(1,-startId);
- setArrayForType(*it,da1);
+ setArrayForType(gt,da1);
startId=endId;
}
}
void MEDFileEquivalenceCell::setArrayForType(INTERP_KERNEL::NormalizedCellType type, DataArrayInt *da)
{
- for(std::vector< MCAuto<MEDFileEquivalenceCellType> >::iterator it=_types.begin();it!=_types.end();it++)
+ for(auto & _type : _types)
{
- MEDFileEquivalenceCellType *elt(*it);
+ MEDFileEquivalenceCellType *elt(_type);
if(elt && elt->getType()==type)
{
elt->setArray(da);
return ;
}
}
- MCAuto<MEDFileEquivalenceCellType> newElt(new MEDFileEquivalenceCellType(getFather(),type,da));
+ MCAuto<MEDFileEquivalenceCellType> const newElt(new MEDFileEquivalenceCellType(getFather(),type,da));
_types.push_back(newElt);
}
std::vector<INTERP_KERNEL::NormalizedCellType> MEDFileEquivalenceCell::getTypes() const
{
std::vector<INTERP_KERNEL::NormalizedCellType> ret;
- for(std::vector< MCAuto<MEDFileEquivalenceCellType> >::const_iterator it=_types.begin();it!=_types.end();it++)
+ for(const auto & _type : _types)
{
- const MEDFileEquivalenceCellType *elt(*it);
+ const MEDFileEquivalenceCellType *elt(_type);
if(elt)
ret.push_back(elt->getType());
}
MEDFILESAFECALLERRD0(MEDequivalenceCorrespondenceRd,(fid,meshName.c_str(),name.c_str(),dt,it,MED_CELL,typmai[i],da->getPointer()));
da->applyLin(1,-1);
da->rearrange(2);
- MCAuto<MEDFileEquivalenceCellType> ct(new MEDFileEquivalenceCellType(getFather(),typmai2[i],FromMedIntArray<int>(da)));
+ MCAuto<MEDFileEquivalenceCellType> const ct(new MEDFileEquivalenceCellType(getFather(),typmai2[i],FromMedIntArray<int>(da)));
_types.push_back(ct);
}
}
#ifndef __MEDFILEEQUIVALENCE_HXX__
#define __MEDFILEEQUIVALENCE_HXX__
+#include "MEDFileUtilities.hxx"
+#include "MCType.hxx"
#include "MEDLoaderDefines.hxx"
#include "MEDCouplingRefCountObject.hxx"
-#include "MEDCouplingMemArray.hxx"
-#include "MEDFileUtilities.txx"
#include "MCAuto.hxx"
#include "NormalizedGeometricTypes"
+#include "med.h"
+#include <string>
+#include <ostream>
+#include <cstddef>
#include <vector>
namespace MEDCoupling
public:
static MEDFileEquivalencePair *Load(MEDFileEquivalences *father, med_idt fid, const std::string& name, const std::string &desc);
std::string getClassName() const override { return std::string("MEDFileEquivalencePair"); }
- void writeLL(med_idt fid) const;
+ void writeLL(med_idt fid) const override;
const MEDFileEquivalences *getFather() const { return _father; }
MEDFileEquivalences *getFather() { return _father; }
const MEDFileMesh *getMesh() const;
bool isEqual(const MEDFileEquivalencePair *other, std::string& what) const;
void getRepr(std::ostream& oss) const;
static MEDFileEquivalencePair *New(MEDFileEquivalences *father, const std::string& name);
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
public:
MEDLOADER_EXPORT std::string getName() const { return _name; }
MEDLOADER_EXPORT void setName(const std::string& name) { _name=name; }
class MEDFileEquivalences : public RefCountObject, public MEDFileWritableStandAlone
{
public:
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
MEDLOADER_EXPORT const MEDFileMesh *getMesh() const { return _owner; }
MEDLOADER_EXPORT MEDFileMesh *getMesh() { return _owner; }
void getDtIt(int &dt, int &it) const;
MEDLOADER_EXPORT void killEquivalenceAt(int i);
MEDLOADER_EXPORT void clear();
public:
- MEDLOADER_EXPORT void writeLL(med_idt fid) const;
+ MEDLOADER_EXPORT void writeLL(med_idt fid) const override;
static int PresenceOfEquivalences(med_idt fid, const std::string& meshName);
static MEDFileEquivalences *Load(med_idt fid, int nbOfEq, MEDFileMesh *owner);
static void CheckDataArray(const DataArrayInt *data);
const MEDFileMesh *getMesh() const { return getFather()->getMesh(); }
MEDFileMesh *getMesh() { return getFather()->getMesh(); }
protected:
- ~MEDFileEquivalenceBase() { }
+ ~MEDFileEquivalenceBase() override = default;
private:
MEDFileEquivalencePair *_father;
};
MEDLOADER_EXPORT void setArray(DataArrayInt *data);
MEDLOADER_EXPORT const DataArrayInt *getArray() const { return _data; }
MEDLOADER_EXPORT DataArrayInt *getArray() { return _data; }
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
bool isEqual(const MEDFileEquivalenceData *other, std::string& what) const;
protected:
void writeAdvanced(med_idt fid, med_entity_type medtype, med_geometry_type medgt) const;
protected:
- ~MEDFileEquivalenceData() { }
+ ~MEDFileEquivalenceData() override = default;
protected:
MCAuto<DataArrayInt> _data;
};
public:
MEDFileEquivalenceCellType(MEDFileEquivalencePair *owner, INTERP_KERNEL::NormalizedCellType type, DataArrayInt *data):MEDFileEquivalenceData(owner,data),_type(type) { }
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileEquivalenceCellType"); }
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
INTERP_KERNEL::NormalizedCellType getType() const { return _type; }
MEDFileEquivalenceCellType *deepCopy(MEDFileEquivalencePair *owner) const;
bool isEqual(const MEDFileEquivalenceCellType *other, std::string& what) const;
void getRepr(std::ostream& oss) const;
public:
- void writeLL(med_idt fid) const;
+ void writeLL(med_idt fid) const override;
protected:
- ~MEDFileEquivalenceCellType() { }
+ ~MEDFileEquivalenceCellType() override = default;
private:
INTERP_KERNEL::NormalizedCellType _type;
};
class MEDFileEquivalenceCell : public MEDFileEquivalenceBase
{
public:
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileEquivalenceCell"); }
static MEDFileEquivalenceCell *Load(med_idt fid, MEDFileEquivalencePair *owner);
- void writeLL(med_idt fid) const;
+ void writeLL(med_idt fid) const override;
MEDFileEquivalenceCell *deepCopy(MEDFileEquivalencePair *owner) const;
bool isEqual(const MEDFileEquivalenceCell *other, std::string& what) const;
void getRepr(std::ostream& oss) const;
public:
MEDFileEquivalenceCell(MEDFileEquivalencePair *owner):MEDFileEquivalenceBase(owner) { }
private:
- ~MEDFileEquivalenceCell() { }
+ ~MEDFileEquivalenceCell() override = default;
private:
void load(med_idt fid);
std::string getName() const { return getFather()->getName(); }
public:
MEDFileEquivalenceNode(MEDFileEquivalencePair *owner, DataArrayInt *data):MEDFileEquivalenceData(owner,data) { }
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileEquivalenceNode"); }
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- void writeLL(med_idt fid) const;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ void writeLL(med_idt fid) const override;
MEDFileEquivalenceNode *deepCopy(MEDFileEquivalencePair *owner) const;
bool isEqual(const MEDFileEquivalenceNode *other, std::string& what) const;
void getRepr(std::ostream& oss) const;
protected:
- ~MEDFileEquivalenceNode() { }
+ ~MEDFileEquivalenceNode() override = default;
};
}
// Author : Anthony Geay (EDF R&D)
#include "MEDFileField.hxx"
+#include "MEDFileEntities.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MCAuto.hxx"
+#include "MCType.hxx"
+#include "MCIdType.hxx"
+#include "MEDCouplingUMesh.hxx"
+#include "MEDCoupling1GTUMesh.hxx"
+#include "MEDFileFieldInternal.hxx"
+#include "InterpKernelException.hxx"
#include "MEDFileMesh.hxx"
-#include "MEDLoaderBase.hxx"
+#include "MEDFileUtilities.hxx"
#include "MEDLoaderTraits.hxx"
-#include "MEDFileSafeCaller.txx"
#include "MEDFileFieldOverView.hxx"
#include "MEDFileBlowStrEltUp.hxx"
#include "MEDFileFieldVisitor.hxx"
#include "MEDCouplingFieldDiscretization.hxx"
#include "InterpKernelAutoPtr.hxx"
-#include "CellModel.hxx"
+#include "NormalizedGeometricTypes"
+#include "med.h"
+#include "medfield.h"
#include <algorithm>
+#include <cstddef>
#include <iterator>
+#include <string>
+#include <vector>
+#include <utility>
+#include <set>
+#include <sstream>
+#include <ostream>
+#include <map>
// From MEDLoader.cxx TU:
extern INTERP_KERNEL::NormalizedCellType typmai2[MED_N_CELL_FIXED_GEO];
MEDFileFields *MEDFileFields::New(const std::string& fileName, bool loadAll)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return New(fid,loadAll);
}
MEDFileFields *MEDFileFields::NewAdv(const std::string& fileName, bool loadAll, const MEDFileEntities *entities)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return NewAdv(fid,loadAll,entities);
}
MEDFileFields *MEDFileFields::NewAdv(med_idt fid, bool loadAll, const MEDFileEntities *entities)
{
- return new MEDFileFields(fid,loadAll,0,entities);
+ return new MEDFileFields(fid,loadAll,nullptr,entities);
}
MEDFileFields *MEDFileFields::NewWithDynGT(const std::string& fileName, const MEDFileStructureElements *se, bool loadAll)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return NewWithDynGT(fid,se,loadAll);
}
if(!se)
throw INTERP_KERNEL::Exception("MEDFileFields::NewWithDynGT : null struct element pointer !");
INTERP_KERNEL::AutoCppPtr<MEDFileEntities> entities(MEDFileEntities::BuildFrom(*se));
- return new MEDFileFields(fid,loadAll,0,entities);
+ return new MEDFileFields(fid,loadAll,nullptr,entities);
}
MEDFileFields *MEDFileFields::New(med_idt fid, bool loadAll)
{
- return new MEDFileFields(fid,loadAll,0,0);
+ return new MEDFileFields(fid,loadAll,nullptr,nullptr);
}
MEDFileFields *MEDFileFields::LoadPartOf(const std::string& fileName, bool loadAll, const MEDFileMeshes *ms)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
- return new MEDFileFields(fid,loadAll,ms,0);
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
+ return new MEDFileFields(fid,loadAll,ms,nullptr);
}
MEDFileFields *MEDFileFields::LoadSpecificEntities(const std::string& fileName, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> >& entities, bool loadAll)
{
MEDFileUtilities::CheckFileForRead(fileName);
INTERP_KERNEL::AutoCppPtr<MEDFileEntities> ent(new MEDFileStaticEntities(entities));
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
- return new MEDFileFields(fid,loadAll,0,ent);
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
+ return new MEDFileFields(fid,loadAll,nullptr,ent);
}
std::size_t MEDFileFields::getHeapMemorySizeWithoutChildren() const
std::vector<const BigMemoryObject *> MEDFileFields::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
- for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
- ret.push_back((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)*it);
+ for(const auto & _field : _fields)
+ ret.push_back((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)_field);
return ret;
}
{
MCAuto<MEDFileFields> ret(shallowCpy());
std::size_t i(0);
- for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
+ for(auto it=_fields.begin();it!=_fields.end();it++,i++)
{
if((const MEDFileAnyTypeFieldMultiTSWithoutSDA*)*it)
ret->_fields[i]=(*it)->deepCopy();
std::set< std::pair<int,int> > s;
bool firstShot=true;
areThereSomeForgottenTS=false;
- for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
+ for(const auto & _field : _fields)
{
- if(!(const MEDFileAnyTypeFieldMultiTSWithoutSDA*)*it)
+ if(!(const MEDFileAnyTypeFieldMultiTSWithoutSDA*)_field)
continue;
- std::vector< std::pair<int,int> > v=(*it)->getIterations();
+ std::vector< std::pair<int,int> > v=_field->getIterations();
std::set< std::pair<int,int> > s1; std::copy(v.begin(),v.end(),std::inserter(s1,s1.end()));
if(firstShot)
{ s=s1; firstShot=false; }
{
std::vector<std::string> ret(_fields.size());
int i(0);
- for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
+ for(auto it=_fields.begin();it!=_fields.end();it++,i++)
{
const MEDFileAnyTypeFieldMultiTSWithoutSDA *f=(*it);
if(f)
std::vector<std::string> MEDFileFields::getMeshesNames() const
{
std::vector<std::string> ret;
- for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
+ for(const auto & _field : _fields)
{
- const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
+ const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(_field);
if(cur)
ret.push_back(cur->getMeshName());
}
void MEDFileFields::simpleRepr(int bkOffset, std::ostream& oss) const
{
- int nbOfFields(getNumberOfFields());
- std::string startLine(bkOffset,' ');
+ int const nbOfFields(getNumberOfFields());
+ std::string const startLine(bkOffset,' ');
oss << startLine << "There are " << nbOfFields << " fields in this :" << std::endl;
int i=0;
- for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
+ for(auto it=_fields.begin();it!=_fields.end();it++,i++)
{
const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
if(cur)
}
}
i=0;
- for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
+ for(auto it=_fields.begin();it!=_fields.end();it++,i++)
{
const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
- std::string chapter(17,(char)('0'+i));
+ std::string const chapter(17,(char)('0'+i));
oss << startLine << chapter << std::endl;
if(cur)
{
}
MEDFileFields::MEDFileFields()
-{
-}
+= default;
MEDFileFields::MEDFileFields(med_idt fid, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities)
try:MEDFileFieldGlobsReal(fid)
{
int i=0;
writeGlobals(fid,*this);
- for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
+ for(auto it=_fields.begin();it!=_fields.end();it++,i++)
{
const MEDFileAnyTypeFieldMultiTSWithoutSDA *elt=*it;
if(!elt)
{
if(getFileName().empty())
throw INTERP_KERNEL::Exception("MEDFileFields::loadArrays : the structure does not come from a file !");
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(getFileName()));
- for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(getFileName()));
+ for(auto & _field : _fields)
{
- MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
+ MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(_field);
if(elt)
elt->loadBigArraysRecursively(fid,*elt);
}
{
if(!getFileName().empty())
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(getFileName()));
- for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(getFileName()));
+ for(auto & _field : _fields)
{
- MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
+ MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(_field);
if(elt)
elt->loadBigArraysRecursivelyIfNecessary(fid,*elt);
}
*/
void MEDFileFields::unloadArrays()
{
- for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
+ for(auto & _field : _fields)
{
- MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
+ MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(_field);
if(elt)
elt->unloadArrays();
}
{
std::vector<std::string> ret;
std::set<std::string> ret2;
- for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
+ for(const auto & _field : _fields)
{
- std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
- for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
- if(ret2.find(*it2)==ret2.end())
+ std::vector<std::string> const tmp=_field->getPflsReallyUsed2();
+ for(const auto & it2 : tmp)
+ if(ret2.find(it2)==ret2.end())
{
- ret.push_back(*it2);
- ret2.insert(*it2);
+ ret.push_back(it2);
+ ret2.insert(it2);
}
}
return ret;
{
std::vector<std::string> ret;
std::set<std::string> ret2;
- for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
+ for(const auto & _field : _fields)
{
- std::vector<std::string> tmp((*it)->getLocsReallyUsed2());
- for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
- if(ret2.find(*it2)==ret2.end())
+ std::vector<std::string> const tmp(_field->getLocsReallyUsed2());
+ for(const auto & it2 : tmp)
+ if(ret2.find(it2)==ret2.end())
{
- ret.push_back(*it2);
- ret2.insert(*it2);
+ ret.push_back(it2);
+ ret2.insert(it2);
}
}
return ret;
std::vector<std::string> MEDFileFields::getPflsReallyUsedMulti() const
{
std::vector<std::string> ret;
- for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
+ for(const auto & _field : _fields)
{
- std::vector<std::string> tmp((*it)->getPflsReallyUsedMulti2());
+ std::vector<std::string> tmp(_field->getPflsReallyUsedMulti2());
ret.insert(ret.end(),tmp.begin(),tmp.end());
}
return ret;
std::vector<std::string> MEDFileFields::getLocsReallyUsedMulti() const
{
std::vector<std::string> ret;
- for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
+ for(const auto & _field : _fields)
{
- std::vector<std::string> tmp((*it)->getLocsReallyUsed2());
+ std::vector<std::string> tmp(_field->getLocsReallyUsed2());
ret.insert(ret.end(),tmp.begin(),tmp.end());
}
return ret;
void MEDFileFields::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
{
- for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
- (*it)->changePflsRefsNamesGen2(mapOfModif);
+ for(auto & _field : _fields)
+ _field->changePflsRefsNamesGen2(mapOfModif);
}
void MEDFileFields::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
{
- for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
- (*it)->changeLocsRefsNamesGen2(mapOfModif);
+ for(auto & _field : _fields)
+ _field->changeLocsRefsNamesGen2(mapOfModif);
}
void MEDFileFields::resize(int newSize)
void MEDFileFields::pushFields(const std::vector<MEDFileAnyTypeFieldMultiTS *>& fields)
{
- for(std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it=fields.begin();it!=fields.end();it++)
- pushField(*it);
+ for(auto field : fields)
+ pushField(field);
}
void MEDFileFields::pushField(MEDFileAnyTypeFieldMultiTS *field)
void MEDFileFields::destroyFieldsAtPos2(int bg, int end, int step)
{
static const char msg[]="MEDFileFields::destroyFieldsAtPos2";
- mcIdType nbOfEntriesToKill(DataArrayIdType::GetNumberOfItemGivenBESRelative(bg,end,step,msg));
+ mcIdType const nbOfEntriesToKill(DataArrayIdType::GetNumberOfItemGivenBESRelative(bg,end,step,msg));
std::vector<bool> b(_fields.size(),true);
int k=bg;
for(int i=0;i<nbOfEntriesToKill;i++,k+=step)
bool MEDFileFields::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
{
bool ret(false);
- for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
+ for(auto & _field : _fields)
{
- MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
+ MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(_field);
if(cur)
ret=cur->changeMeshNames(modifTab) || ret;
}
bool MEDFileFields::renumberEntitiesLyingOnMesh(const std::string& meshName, const std::vector<mcIdType>& oldCode, const std::vector<mcIdType>& newCode, const DataArrayIdType *renumO2N)
{
bool ret(false);
- for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
+ for(auto & _field : _fields)
{
- MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts(*it);
+ MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts(_field);
if(fmts)
{
ret=fmts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,*this) || ret;
if(!mm)
throw INTERP_KERNEL::Exception("MEDFileFields::extractPart : input mesh is NULL !");
MCAuto<MEDFileFields> fsOut(MEDFileFields::New());
- int nbFields(getNumberOfFields());
+ int const nbFields(getNumberOfFields());
for(int i=0;i<nbFields;i++)
{
MCAuto<MEDFileAnyTypeFieldMultiTS> fmts(getFieldAtPos(i));
void MEDFileFields::accept(MEDFileFieldVisitor& visitor) const
{
- for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
- if((*it).isNotNull())
+ for(const auto & _field : _fields)
+ if(_field.isNotNull())
{
- visitor.newFieldEntry(*it);
- (*it)->accept(visitor);
- visitor.endFieldEntry(*it);
+ visitor.newFieldEntry(_field);
+ _field->accept(visitor);
+ visitor.endFieldEntry(_field);
}
}
class MEDFileFieldLin2QuadVisitor : public MEDFileFieldVisitor
{
public:
- MEDFileFieldLin2QuadVisitor(const MEDFileUMesh *lin, const MEDFileUMesh *quad, const MEDFileFieldGlobsReal *linGlobs, MEDFileFields* outFs):_lin(lin),_quad(quad),_lin_globs(linGlobs),_out_fs(outFs),_gt(INTERP_KERNEL::NORM_ERROR),_1ts_update_requested(false) { }
- void newFieldEntry(const MEDFileAnyTypeFieldMultiTSWithoutSDA *field) { if(field->getMeshName()!=_lin->getName()) return; _cur_fmts=MEDFileFieldMultiTS::New(); }
- void endFieldEntry(const MEDFileAnyTypeFieldMultiTSWithoutSDA *field) { if(_cur_fmts.isNotNull()) { if(_cur_fmts->getNumberOfTS()>0) _out_fs->pushField(_cur_fmts); } }
+ MEDFileFieldLin2QuadVisitor(const MEDFileUMesh *lin, const MEDFileUMesh *quad, const MEDFileFieldGlobsReal *linGlobs, MEDFileFields* outFs):_lin(lin),_quad(quad),_lin_globs(linGlobs),_out_fs(outFs) { }
+ void newFieldEntry(const MEDFileAnyTypeFieldMultiTSWithoutSDA *field) override { if(field->getMeshName()!=_lin->getName()) return; _cur_fmts=MEDFileFieldMultiTS::New(); }
+ void endFieldEntry(const MEDFileAnyTypeFieldMultiTSWithoutSDA * /*field*/) override { if(_cur_fmts.isNotNull()) { if(_cur_fmts->getNumberOfTS()>0) _out_fs->pushField(_cur_fmts); } }
//
- void newTimeStepEntry(const MEDFileAnyTypeField1TSWithoutSDA *ts);
- void endTimeStepEntry(const MEDFileAnyTypeField1TSWithoutSDA *ts);
+ void newTimeStepEntry(const MEDFileAnyTypeField1TSWithoutSDA *ts) override;
+ void endTimeStepEntry(const MEDFileAnyTypeField1TSWithoutSDA *ts) override;
//
- void newMeshEntry(const MEDFileFieldPerMesh *fpm);
- void endMeshEntry(const MEDFileFieldPerMesh *fpm) { }
+ void newMeshEntry(const MEDFileFieldPerMesh *fpm) override;
+ void endMeshEntry(const MEDFileFieldPerMesh *fpm) override { }
//
- void newPerMeshPerTypeEntry(const MEDFileFieldPerMeshPerTypeCommon *pmpt);
- void endPerMeshPerTypeEntry(const MEDFileFieldPerMeshPerTypeCommon *pmpt) { }
+ void newPerMeshPerTypeEntry(const MEDFileFieldPerMeshPerTypeCommon *pmpt) override;
+ void endPerMeshPerTypeEntry(const MEDFileFieldPerMeshPerTypeCommon *pmpt) override { }
//
- void newPerMeshPerTypePerDisc(const MEDFileFieldPerMeshPerTypePerDisc *pmptpd);
+ void newPerMeshPerTypePerDisc(const MEDFileFieldPerMeshPerTypePerDisc *pmptpd) override;
private:
void updateData(MEDFileFieldPerMeshPerTypePerDisc *pmtd, mcIdType deltaNbNodes);
private:
MEDFileFields *_out_fs;
MCAuto<MEDFileFieldMultiTS> _cur_fmts;
MCAuto<MEDFileField1TS> _cur_f1ts;
- INTERP_KERNEL::NormalizedCellType _gt;
+ INTERP_KERNEL::NormalizedCellType _gt{INTERP_KERNEL::NORM_ERROR};
// Info on 1TS modification
- bool _1ts_update_requested;
+ bool _1ts_update_requested{false};
// Cache of matrix to compute faster the values on newly created points
std::map< std::string, PFLData > _cache;
std::vector<std::string> _pfls_to_be_updated;
throw INTERP_KERNEL::Exception("Not managed yet for ON_CELLS ON_GAUSS_NE and ON_GAUSS_PT");
_1ts_update_requested=true;
MEDFileAnyTypeField1TSWithoutSDA *ct(_cur_f1ts->contentNotNullBase());
- int locId(pmptpd->getFather()->locIdOfLeaf(pmptpd));
+ int const locId(pmptpd->getFather()->locIdOfLeaf(pmptpd));
MEDFileFieldPerMeshPerTypePerDisc *pmtdToModify(ct->getLeafGivenMeshAndTypeAndLocId(_lin->getName(),_gt,locId));
- std::string pflName(pmptpd->getProfile());
+ std::string const pflName(pmptpd->getProfile());
_pfls_to_be_updated.push_back(pflName);
- std::map< std::string, PFLData >::iterator itCache(_cache.find(pflName));
+ auto const itCache(_cache.find(pflName));
if(itCache!=_cache.end())
{
updateData(pmtdToModify,(*itCache).second.getNbOfAddPtsInPfl());
DataArrayIdType *nodeConn(allSeg3->getNodalConnectivity());
nodeConn->rearrange(3);
{
- std::vector<std::size_t> v(1,2);
+ std::vector<std::size_t> const v(1,2);
midPts=nodeConn->keepSelectedComponents(v);
}
cellSeg3Ids=DataArrayIdType::FindPermutationFromFirstToSecond(midPts,newPtsIds);
pflq=DataArrayIdType::Aggregate(vs);
pflq->setName(pflName);
}
- PFLData pdata(matrix,pflq,newPtsIds->getNumberOfTuples());
+ PFLData const pdata(matrix,pflq,newPtsIds->getNumberOfTuples());
_cache[pflName]=pdata;
updateData(pmtdToModify,pdata.getNbOfAddPtsInPfl());
}
void MEDFileFieldLin2QuadVisitor::newPerMeshPerTypeEntry(const MEDFileFieldPerMeshPerTypeCommon *pmpt)
{
- const MEDFileFieldPerMeshPerType *pmpt2(dynamic_cast<const MEDFileFieldPerMeshPerType *>(pmpt));
+ const auto *pmpt2(dynamic_cast<const MEDFileFieldPerMeshPerType *>(pmpt));
if(!pmpt2)
throw INTERP_KERNEL::Exception("MEDFileFieldLin2QuadVisitor::newPerMeshPerTypeEntry : not managed for structure elements !");
if(pmpt2->getNumberOfLoc()!=1)
_1ts_update_requested=false; _pfls_to_be_updated.clear();
if(!ts)
return ;
- const MEDFileField1TSWithoutSDA *tsd(dynamic_cast<const MEDFileField1TSWithoutSDA *>(ts));
+ const auto *tsd(dynamic_cast<const MEDFileField1TSWithoutSDA *>(ts));
if(!tsd)
return ;
MCAuto<MEDFileAnyTypeField1TSWithoutSDA> contentCpy(ts->deepCopy());
_cur_f1ts->deepCpyGlobs(*_lin_globs);
}
-void MEDFileFieldLin2QuadVisitor::endTimeStepEntry(const MEDFileAnyTypeField1TSWithoutSDA *ts)
+void MEDFileFieldLin2QuadVisitor::endTimeStepEntry(const MEDFileAnyTypeField1TSWithoutSDA * /*ts*/)
{
if(_cur_f1ts.isNull())
return ;
if(_1ts_update_requested)
{
MCAuto<DataArrayIdType> matrix,oldPfl;
- for(std::vector<std::string>::const_iterator it=_pfls_to_be_updated.begin();it!=_pfls_to_be_updated.end();it++)
+ for(const auto & it : _pfls_to_be_updated)
{
- std::map< std::string, PFLData >::const_iterator it2(_cache.find(*it));
+ std::map< std::string, PFLData >::const_iterator const it2(_cache.find(it));
if(it2==_cache.end())
throw INTERP_KERNEL::Exception("MEDFileFieldLin2QuadVisitor::endTimeStepEntry : invalid situation !");
matrix=(*it2).second.getMatrix();
- if((*it).empty())
+ if(it.empty())
continue;
- int locId(_cur_f1ts->getProfileId(*it));
- oldPfl.takeRef(_cur_f1ts->getProfile(*it));
+ int const locId(_cur_f1ts->getProfileId(it));
+ oldPfl.takeRef(_cur_f1ts->getProfile(it));
{
- std::vector<int> locToKill(1,locId);
+ std::vector<int> const locToKill(1,locId);
_cur_f1ts->killProfileIds(locToKill);
}
_cur_f1ts->appendProfile((*it2).second.getProfile());
MEDFileMesh *mm(oldLin->getMeshAtPos(i));
if(!mm)
continue;
- MEDFileUMesh *mmu(dynamic_cast<MEDFileUMesh *>(mm));
+ auto *mmu(dynamic_cast<MEDFileUMesh *>(mm));
if(!mmu)
continue;
MEDFileMesh *mmq(newQuad->getMeshWithName(mmu->getName()));
- MEDFileUMesh *mmqu(dynamic_cast<MEDFileUMesh *>(mmq));
+ auto *mmqu(dynamic_cast<MEDFileUMesh *>(mmq));
if(!mmqu)
{
std::ostringstream oss; oss << "MEDFileFields::linearToQuadratic : mismatch of name between input meshes for name \"" << mmu->getName() << "\"";
}
const MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts=_fields[i];
if(!fmts)
- return 0;
+ return nullptr;
MCAuto<MEDFileAnyTypeFieldMultiTS> ret;
- const MEDFileFieldMultiTSWithoutSDA *fmtsC(dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(fmts));
- const MEDFileInt32FieldMultiTSWithoutSDA *fmtsC2(dynamic_cast<const MEDFileInt32FieldMultiTSWithoutSDA *>(fmts));
- const MEDFileInt64FieldMultiTSWithoutSDA *fmtsC4(dynamic_cast<const MEDFileInt64FieldMultiTSWithoutSDA *>(fmts));
- const MEDFileFloatFieldMultiTSWithoutSDA *fmtsC3(dynamic_cast<const MEDFileFloatFieldMultiTSWithoutSDA *>(fmts));
+ const auto *fmtsC(dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(fmts));
+ const auto *fmtsC2(dynamic_cast<const MEDFileInt32FieldMultiTSWithoutSDA *>(fmts));
+ const auto *fmtsC4(dynamic_cast<const MEDFileInt64FieldMultiTSWithoutSDA *>(fmts));
+ const auto *fmtsC3(dynamic_cast<const MEDFileFloatFieldMultiTSWithoutSDA *>(fmts));
if(fmtsC)
ret=MEDFileFieldMultiTS::New(*fmtsC,false);
else if(fmtsC2)
MEDFileFields *MEDFileFields::buildSubPart(const int *startIds, const int *endIds) const
{
MCAuto<MEDFileFields> ret=shallowCpy();
- std::size_t sz=std::distance(startIds,endIds);
+ std::size_t const sz=std::distance(startIds,endIds);
std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(sz);
int j=0;
for(const int *i=startIds;i!=endIds;i++,j++)
bool MEDFileFields::removeFieldsWithoutAnyTimeStep()
{
std::vector<MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > newFields;
- for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
+ for(const auto & _field : _fields)
{
- const MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
+ const MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(_field);
if(elt)
{
if(elt->getNumberOfTS()>0)
- newFields.push_back(*it);
+ newFields.push_back(_field);
}
}
if(_fields.size()==newFields.size())
MEDFileFields *MEDFileFields::partOfThisLyingOnSpecifiedMeshName(const std::string& meshName) const
{
MCAuto<MEDFileFields> ret(MEDFileFields::New());
- for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
+ for(const auto & _field : _fields)
{
- const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
+ const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(_field);
if(!cur)
continue;
if(cur->getMeshName()==meshName)
{
cur->incrRef();
- MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> cur2(const_cast<MEDFileAnyTypeFieldMultiTSWithoutSDA *>(cur));
+ MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> const cur2(const_cast<MEDFileAnyTypeFieldMultiTSWithoutSDA *>(cur));
ret->_fields.push_back(cur2);
}
}
MEDFileFields *MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
{
MCAuto<MEDFileFields> ret(MEDFileFields::New());
- for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
+ for(const auto & _field : _fields)
{
- const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
+ const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(_field);
if(!cur)
continue;
- MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=cur->partOfThisLyingOnSpecifiedTimeSteps(timeSteps);
+ MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> const elt=cur->partOfThisLyingOnSpecifiedTimeSteps(timeSteps);
ret->_fields.push_back(elt);
}
ret->shallowCpyOnlyUsedGlobs(*this);
MEDFileFields *MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
{
MCAuto<MEDFileFields> ret=MEDFileFields::New();
- for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
+ for(const auto & _field : _fields)
{
- const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
+ const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(_field);
if(!cur)
continue;
MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=cur->partOfThisNotLyingOnSpecifiedTimeSteps(timeSteps);
bool MEDFileFields::presenceOfStructureElements() const
{
- for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
- if((*it).isNotNull())
- if((*it)->presenceOfStructureElements())
+ for(const auto & _field : _fields)
+ if(_field.isNotNull())
+ if(_field->presenceOfStructureElements())
return true;
return false;
}
void MEDFileFields::killStructureElements()
{
std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret;
- for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
- if((*it).isNotNull())
+ for(auto & _field : _fields)
+ if(_field.isNotNull())
{
- if((*it)->presenceOfStructureElements())
+ if(_field->presenceOfStructureElements())
{
- if(!(*it)->onlyStructureElements())
+ if(!_field->onlyStructureElements())
{
- (*it)->killStructureElements();
- ret.push_back(*it);
+ _field->killStructureElements();
+ ret.push_back(_field);
}
}
else
{
- ret.push_back(*it);
+ ret.push_back(_field);
}
}
_fields=ret;
void MEDFileFields::keepOnlyStructureElements()
{
std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret;
- for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
- if((*it).isNotNull())
+ for(auto & _field : _fields)
+ if(_field.isNotNull())
{
- if((*it)->presenceOfStructureElements())
+ if(_field->presenceOfStructureElements())
{
- if(!(*it)->onlyStructureElements())
- (*it)->keepOnlyStructureElements();
- ret.push_back(*it);
+ if(!_field->onlyStructureElements())
+ _field->keepOnlyStructureElements();
+ ret.push_back(_field);
}
}
_fields=ret;
void MEDFileFields::keepOnlyOnMeshSE(const std::string& meshName, const std::string& seName)
{
std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret;
- for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
- if((*it).isNotNull())
+ for(auto & _field : _fields)
+ if(_field.isNotNull())
{
- if((*it)->getMeshName()!=meshName)
+ if(_field->getMeshName()!=meshName)
continue;
std::vector< std::pair<std::string,std::string> > ps;
- (*it)->getMeshSENames(ps);
- std::pair<std::string,std::string> p(meshName,seName);
+ _field->getMeshSENames(ps);
+ std::pair<std::string,std::string> const p(meshName,seName);
if(std::find(ps.begin(),ps.end(),p)!=ps.end())
- (*it)->keepOnlyOnSE(seName);
- ret.push_back(*it);
+ _field->keepOnlyOnSE(seName);
+ ret.push_back(_field);
}
_fields=ret;
}
void MEDFileFields::getMeshSENames(std::vector< std::pair<std::string,std::string> >& ps) const
{
- for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
- if((*it).isNotNull())
- (*it)->getMeshSENames(ps);
+ for(const auto & _field : _fields)
+ if(_field.isNotNull())
+ _field->getMeshSENames(ps);
}
void MEDFileFields::blowUpSE(MEDFileMeshes *ms, const MEDFileStructureElements *ses)
THROW_IK_EXCEPTION("MEDFileFields::aggregateFieldsOnSameMeshes : ms is nullptr !");
//
std::vector<std::string> msNames(ms->getMeshesNames());
- std::set<std::string> msNamesSet(msNames.begin(),msNames.end());
+ std::set<std::string> const msNamesSet(msNames.begin(),msNames.end());
if(msNames.size() == msNamesSet.size())
return ;
//
zeMeshNames.insert(fmtsWithSameName->getMeshName());
if(zeMeshNames.size()!=1)
THROW_IK_EXCEPTION("MEDFileFields::aggregateFieldsOnSameMeshes : Presence of multiple MultiTS instances with same name but lying on same meshName. Looks bad !");
- std::string meshNameToMerge = *zeMeshNames.begin();
+ std::string const meshNameToMerge = *zeMeshNames.begin();
if(expectedMeshNamesToMerge.find(meshNameToMerge) != expectedMeshNamesToMerge.end())
THROW_IK_EXCEPTION("MEDFileFields::aggregateFieldsOnSameMeshes : unexpected situation ! Error in implementation !");
expectedMeshNamesToMerge.insert(*zeMeshNames.begin());
for(auto entry : entries)
dtsToPush.push_back({entry.first.first,entry.second.second-entry.second.first});
dtsToAggregate.push_back(dtsToPush);
- MCAuto<MEDFileAnyTypeFieldMultiTS> eltToAggregate = MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent(fieldToBeAggregated);
+ MCAuto<MEDFileAnyTypeFieldMultiTS> const eltToAggregate = MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent(fieldToBeAggregated);
eltsToAggregate.push_back(eltToAggregate);
}
MCAuto<MEDFileAnyTypeFieldMultiTS> gg = MEDFileAnyTypeFieldMultiTS::Aggregate(FromVecAutoToVecOfConst(eltsToAggregate),dtsToAggregate);
{
if(!curMesh->getNonEmptyLevels().empty())
THROW_IK_EXCEPTION("MEDFileFields::aggregateFieldsOnSameMeshes : only meshes without cells supported.");
- MEDFileUMesh *curMeshU(dynamic_cast<MEDFileUMesh *>(curMesh));
+ auto *curMeshU(dynamic_cast<MEDFileUMesh *>(curMesh));
if(!curMeshU)
THROW_IK_EXCEPTION("MEDFileFields::aggregateFieldsOnSameMeshes : only unstructured mesh supported.");
coos.push_back(curMeshU->getCoords());
void MEDFileFields::aggregate(const MEDFileFields& other)
{
- int nbFieldsToAdd(other.getNumberOfFields());
+ int const nbFieldsToAdd(other.getNumberOfFields());
std::vector<std::string> fsn(getFieldsNames());
for(int i=0;i<nbFieldsToAdd;i++)
{
MCAuto<MEDFileAnyTypeFieldMultiTS> elt(other.getFieldAtPos(i));
- std::string name(elt->getName());
+ std::string const name(elt->getName());
if(std::find(fsn.begin(),fsn.end(),name)!=fsn.end())
{
std::ostringstream oss; oss << "MEDFileFields::aggregate : name \"" << name << "\" already appears !";
int MEDFileFields::getPosFromFieldName(const std::string& fieldName) const
{
- std::string tmp(fieldName);
+ std::string const tmp(fieldName);
std::vector<std::string> poss;
for(unsigned int i=0;i<_fields.size();i++)
{
const MEDFileAnyTypeFieldMultiTSWithoutSDA *f(_fields[i]);
if(f)
{
- std::string fname(f->getName());
+ std::string const fname(f->getName());
if(tmp==fname)
return i;
else
}
MEDFileFieldsIterator::~MEDFileFieldsIterator()
-{
-}
+= default;
MEDFileAnyTypeFieldMultiTS *MEDFileFieldsIterator::nextt()
{
if(fs)
return fs->getFieldAtPos(_iter_id++);
else
- return 0;
+ return nullptr;
}
else
- return 0;
+ return nullptr;
}
#pragma once
+#include "MEDFileUtilities.hxx"
+#include "MCType.hxx"
#include "MEDLoaderDefines.hxx"
#include "MEDFileFieldInternal.hxx"
#include "MEDFileFieldMultiTS.hxx"
#include "MEDFileFieldOverView.hxx"
-#include "MEDFileUtilities.txx"
#include "MEDFileEntities.hxx"
#include "MCAuto.hxx"
-#include "MEDLoaderTraits.hxx"
#include "MEDCouplingTraits.hxx"
#include "MEDCouplingRefCountObject.hxx"
#include "MEDCouplingMemArray.hxx"
-#include "MEDCouplingPartDefinition.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
-#include "InterpKernelException.hxx"
+#include "NormalizedGeometricTypes"
+#include <utility>
+#include <cstddef>
+#include <ostream>
+#include <map>
#include <vector>
#include <string>
-#include <list>
-#include <set>
#include "med.h"
MEDLOADER_EXPORT static MEDFileFields *NewWithDynGT(med_idt fid, const MEDFileStructureElements *se, bool loadAll=true);
MEDLOADER_EXPORT static MEDFileFields *New(DataArrayByte *db) { return BuildFromMemoryChunk<MEDFileFields>(db); }
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileFields"); }
- MEDLOADER_EXPORT static MEDFileFields *LoadPartOf(const std::string& fileName, bool loadAll=true, const MEDFileMeshes *ms=0);
+ MEDLOADER_EXPORT static MEDFileFields *LoadPartOf(const std::string& fileName, bool loadAll=true, const MEDFileMeshes *ms=nullptr);
MEDLOADER_EXPORT static MEDFileFields *LoadSpecificEntities(const std::string& fileName, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> >& entities, bool loadAll=true);
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
MEDLOADER_EXPORT MEDFileFields *deepCopy() const;
MEDLOADER_EXPORT MEDFileFields *shallowCpy() const;
- MEDLOADER_EXPORT void writeLL(med_idt fid) const;
+ MEDLOADER_EXPORT void writeLL(med_idt fid) const override;
MEDLOADER_EXPORT void loadArrays();
MEDLOADER_EXPORT void loadArraysIfNecessary();
MEDLOADER_EXPORT void unloadArrays();
public:
MEDLOADER_EXPORT MEDFileFields *extractPart(const std::map<int, MCAuto<DataArrayIdType> >& extractDef, MEDFileMesh *mm) const;
public:
- MEDLOADER_EXPORT std::vector<std::string> getPflsReallyUsed() const;
- MEDLOADER_EXPORT std::vector<std::string> getLocsReallyUsed() const;
- MEDLOADER_EXPORT std::vector<std::string> getPflsReallyUsedMulti() const;
- MEDLOADER_EXPORT std::vector<std::string> getLocsReallyUsedMulti() const;
- MEDLOADER_EXPORT void changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif);
- MEDLOADER_EXPORT void changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif);
+ MEDLOADER_EXPORT std::vector<std::string> getPflsReallyUsed() const override;
+ MEDLOADER_EXPORT std::vector<std::string> getLocsReallyUsed() const override;
+ MEDLOADER_EXPORT std::vector<std::string> getPflsReallyUsedMulti() const override;
+ MEDLOADER_EXPORT std::vector<std::string> getLocsReallyUsedMulti() const override;
+ MEDLOADER_EXPORT void changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) override;
+ MEDLOADER_EXPORT void changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) override;
private:
- ~MEDFileFields() { }
+ ~MEDFileFields() override = default;
MEDFileFields();
MEDFileFields(med_idt fid, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities);
private:
#pragma once
+#include "MEDCouplingMemArray.hxx"
+#include "MCType.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDFileEntities.hxx"
+#include "InterpKernelAutoPtr.hxx"
#include "MEDFileField.hxx"
#include "MEDCouplingTraits.hxx"
#include "MEDCouplingFieldInt32.hxx"
#include "MEDCouplingFieldFloat.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "MEDCouplingFieldTemplate.hxx"
+#include "MEDFileField1TS.hxx"
+#include <vector>
+#include <utility>
+#include "NormalizedGeometricTypes"
+#include "MEDLoaderTraits.hxx"
+#include <cstddef>
+#include "MEDFileFieldInternal.hxx"
+#include <string>
+#include "MEDFileUtilities.hxx"
+#include "med.h"
+#include <sstream>
+#include <map>
+#include "MEDFileFieldMultiTS.hxx"
namespace MEDCoupling
{
_arr=0;
return ;
}
- typename Traits<T>::ArrayType *arrC=dynamic_cast<typename Traits<T>::ArrayType *>(arr);
+ auto *arrC=dynamic_cast<typename Traits<T>::ArrayType *>(arr);
if(!arrC)
throw INTERP_KERNEL::Exception("MEDFileField1TSTemplateWithoutSDA::setArray : the input not null array is not of type DataArrayDouble !");
else
_arr=Traits<T>::ArrayType::New();
_arr->alloc(start,nbCompo); _arr->copyStringInfoFrom(*arr);
start=0;
- for(std::vector<std::pair< int, std::pair<mcIdType,mcIdType> > >::const_iterator it=extractInfo.begin();it!=extractInfo.end();it++)
+ for(const auto & it : extractInfo)
{
- const DataArray *zeArr(das[(*it).first]);
- _arr->setContigPartOfSelectedValuesSlice(start,zeArr,(*it).second.first,(*it).second.second,1);
- start+=(*it).second.second-(*it).second.first;
+ const DataArray *zeArr(das[it.first]);
+ _arr->setContigPartOfSelectedValuesSlice(start,zeArr,it.second.first,it.second.second,1);
+ start+=it.second.second-it.second.first;
}
// see definition of _nb_of_tuples_to_be_allocated. array is built from scratch and allocated.
_nb_of_tuples_to_be_allocated=-3;
const MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
if(!pt)
throw INTERP_KERNEL::Exception("MEDFileTemplateField1TS<T>::contentNotNull : the content pointer is null !");
- const typename MLFieldTraits<T>::F1TSWSDAType *ret(dynamic_cast<const typename MLFieldTraits<T>::F1TSWSDAType *>(pt));
+ const auto *ret(dynamic_cast<const typename MLFieldTraits<T>::F1TSWSDAType *>(pt));
if(!ret)
{
std::ostringstream oss; oss << "MEDFileTemplateField1TS<T>::contentNotNull : the content pointer is not null but it is not of type double ! Reason is maybe that the read field has not the type " << MLFieldTraits<T>::F1TSWSDAType::TYPE_STR;
MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
if(!pt)
throw INTERP_KERNEL::Exception("MEDFileTemplateField1TS<T>::contentNotNull : the non const content pointer is null !");
- typename MLFieldTraits<T>::F1TSWSDAType *ret(dynamic_cast<typename MLFieldTraits<T>::F1TSWSDAType *>(pt));
+ auto *ret(dynamic_cast<typename MLFieldTraits<T>::F1TSWSDAType *>(pt));
if(!ret)
{
std::ostringstream oss; oss << "MEDFileTemplateField1TS<T>::contentNotNull : the non const content pointer is not null but it is not of type double ! Reason is maybe that the read field has not the type " << MLFieldTraits<T>::F1TSWSDAType::TYPE_STR;
if(arr.isNull())
throw INTERP_KERNEL::Exception("MEDFileTemplateField1TS<T>::SetDataArrayInField : no array !");
int t1,t2;
- double t0(f->getTime(t1,t2));
- std::string tu(f->getTimeUnit());
+ double const t0(f->getTime(t1,t2));
+ std::string const tu(f->getTimeUnit());
MCAuto<typename Traits<T>::ArrayType> arr2(DynamicCastSafe<DataArray,typename Traits<T>::ArrayType>(arr));
MCAuto<MEDCouplingFieldTemplate> ft(MEDCouplingFieldTemplate::New(*f));
MCAuto<typename Traits<T>::FieldType> ret(Traits<T>::FieldType::New(*ft));
if(!mm)
throw INTERP_KERNEL::Exception("MEDFileField1TS::extractPart : input mesh is NULL !");
MCAuto<typename MLFieldTraits<T>::F1TSType> ret(MLFieldTraits<T>::F1TSType::New());
- std::vector<TypeOfField> tof(getTypesOfFieldAvailable());
- for(std::vector<TypeOfField>::const_iterator it0=tof.begin();it0!=tof.end();it0++)
+ std::vector<TypeOfField> const tof(getTypesOfFieldAvailable());
+ for(auto it0 : tof)
{
- if((*it0)!=ON_NODES)
+ if(it0!=ON_NODES)
{
std::vector<int> levs;
getNonEmptyLevels(mm->getName(),levs);
- for(std::vector<int>::const_iterator lev=levs.begin();lev!=levs.end();lev++)
+ for(int const lev : levs)
{
- std::map<int, MCAuto<DataArrayIdType> >::const_iterator it2(extractDef.find(*lev));
+ auto const it2(extractDef.find(lev));
if(it2!=extractDef.end())
{
MCAuto<DataArrayIdType> t((*it2).second);
if(t.isNull())
throw INTERP_KERNEL::Exception("MEDFileField1TS::extractPart : presence of a value with null pointer 1 !");
- MCAuto<typename Traits<T>::FieldType> f(getFieldOnMeshAtLevel(ON_CELLS,(*lev),mm));
+ MCAuto<typename Traits<T>::FieldType> f(getFieldOnMeshAtLevel(ON_CELLS,lev,mm));
MCAuto<typename Traits<T>::FieldType> fOut(f->buildSubPart(t));
ret->setFieldNoProfileSBT(fOut);
}
}
else
{
- std::map<int, MCAuto<DataArrayIdType> >::const_iterator it2(extractDef.find(1));
+ auto const it2(extractDef.find(1));
if(it2==extractDef.end())
throw INTERP_KERNEL::Exception("MEDFileField1TS::extractPart : presence of a NODE field and no extract array available for NODE !");
MCAuto<DataArrayIdType> t((*it2).second);
{
if(!f1ts)
throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
- const typename MLFieldTraits<T>::F1TSWSDAType *f1tsC(dynamic_cast<const typename MLFieldTraits<T>::F1TSWSDAType *>(f1ts));
+ const auto *f1tsC(dynamic_cast<const typename MLFieldTraits<T>::F1TSWSDAType *>(f1ts));
if(!f1tsC)
{
std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType : the input field1TS is not a " << MLFieldTraits<T>::F1TSWSDAType::TYPE_STR << " type !";
MCAuto<MEDFileFieldMultiTSWithoutSDA> ret(new MEDFileFieldMultiTSWithoutSDA);
ret->MEDFileAnyTypeFieldMultiTSWithoutSDA::operator =(*this);
int i=0;
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=this->_time_steps.begin();it!=this->_time_steps.end();it++,i++)
+ for(auto it=this->_time_steps.begin();it!=this->_time_steps.end();it++,i++)
{
const MEDFileAnyTypeField1TSWithoutSDA *eltToConv(*it);
if(eltToConv)
if(!mm)
throw INTERP_KERNEL::Exception("MEDFileTemplateFieldMultiTS<T>::extractPart : mesh is null !");
MCAuto<typename MLFieldTraits<T>::FMTSType> fmtsOut(MLFieldTraits<T>::FMTSType::New());
- int nbTS(getNumberOfTS());
+ int const nbTS(getNumberOfTS());
for(int i=0;i<nbTS;i++)
{
MCAuto<MEDFileAnyTypeField1TS> f1ts(getTimeStepAtPos(i));
const MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
if(!pt)
throw INTERP_KERNEL::Exception("MEDFileTemplateFieldMultiTS<T>::contentNotNull : the content pointer is null !");
- const typename MLFieldTraits<T>::FMTSWSDAType *ret=dynamic_cast<const typename MLFieldTraits<T>::FMTSWSDAType *>(pt);
+ const auto *ret=dynamic_cast<const typename MLFieldTraits<T>::FMTSWSDAType *>(pt);
if(!ret)
throw INTERP_KERNEL::Exception("MEDFileTemplateFieldMultiTS<T>::contentNotNull : the content pointer is not null but it is not of type double ! Reason is maybe that the read field has not the type FLOAT64 !");
return ret;
std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepAtPos : field at pos #" << pos << " is null !";
throw INTERP_KERNEL::Exception(oss.str());
}
- const typename MLFieldTraits<T>::F1TSWSDAType *itemC=dynamic_cast<const typename MLFieldTraits<T>::F1TSWSDAType *>(item);
+ const auto *itemC=dynamic_cast<const typename MLFieldTraits<T>::F1TSWSDAType *>(item);
if(itemC)
{
MCAuto<typename MLFieldTraits<T>::F1TSType> ret(MLFieldTraits<T>::F1TSType::New(*itemC,false));
{
if(!f1ts)
throw INTERP_KERNEL::Exception("MEDFileTemplateFieldMultiTS<T>::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
- const typename MLFieldTraits<T>::F1TSType *f1tsC=dynamic_cast<const typename MLFieldTraits<T>::F1TSType *>(f1ts);
+ const auto *f1tsC=dynamic_cast<const typename MLFieldTraits<T>::F1TSType *>(f1ts);
if(!f1tsC)
{
std::ostringstream oss; oss << "MEDFileTemplateFieldMultiTS<T>::checkCoherencyOfType : the input field1TS is not a " << MLFieldTraits<T>::F1TSWSDAType::TYPE_STR << " type !";
const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(this->_content);
if(content)
{
- const typename MLFieldTraits<T>::FMTSWSDAType *contc=dynamic_cast<const typename MLFieldTraits<T>::FMTSWSDAType *>(content);
+ const auto *contc=dynamic_cast<const typename MLFieldTraits<T>::FMTSWSDAType *>(content);
if(!contc)
throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::convertToInt : the content inside this is not INT32 ! This is incoherent !");
MCAuto<MEDFileFieldMultiTSWithoutSDA> newc(contc->convertToDouble());
// Author : Anthony Geay (EDF R&D)
#include "MEDFileField1TS.hxx"
+#include "MCType.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MEDFileFieldGlobs.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MCIdType.hxx"
+#include "CellModel.hxx"
+#include "MEDCouplingMesh.hxx"
+#include "MEDFileEntities.hxx"
+#include "InterpKernelAutoPtr.hxx"
+#include "MEDFileBasis.hxx"
+#include "MEDCouplingPartDefinition.hxx"
+#include "MEDCouplingFieldDiscretization.hxx"
+#include "MEDFileFieldInternal.hxx"
#include "MEDFileFieldVisitor.hxx"
+#include "MEDFileMesh.hxx"
#include "MEDFileSafeCaller.txx"
+#include "MEDFileUtilities.hxx"
#include "MEDLoaderBase.hxx"
#include "MEDFileField.txx"
#include "MEDCouplingFieldTemplate.hxx"
#include "MEDCouplingFieldDouble.hxx"
+#include "MEDCouplingFieldInt32.hxx"
+#include "MEDCouplingFieldInt64.hxx"
+#include "NormalizedGeometricTypes"
+#include <cstddef>
+#include <vector>
+#include <ostream>
+#include <string>
+#include <utility>
+#include <set>
+#include <iterator>
+#include <algorithm>
+#include <functional>
+#include <sstream>
+#include "med.h"
+#include "medfield.h"
+#include <limits>
using namespace MEDCoupling;
{
_field_per_mesh.resize(other._field_per_mesh.size());
std::size_t i=0;
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=other._field_per_mesh.begin();it!=other._field_per_mesh.end();it++,i++)
+ for(auto it=other._field_per_mesh.begin();it!=other._field_per_mesh.end();it++,i++)
{
if((const MEDFileFieldPerMesh *)*it)
_field_per_mesh[i]=(*it)->deepCopy(this);
void MEDFileAnyTypeField1TSWithoutSDA::accept(MEDFileFieldVisitor& visitor) const
{
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
- if((*it).isNotNull())
+ for(const auto & it : _field_per_mesh)
+ if(it.isNotNull())
{
- visitor.newMeshEntry(*it);
- (*it)->accept(visitor);
- visitor.endMeshEntry(*it);
+ visitor.newMeshEntry(it);
+ it->accept(visitor);
+ visitor.endMeshEntry(it);
}
}
*/
void MEDFileAnyTypeField1TSWithoutSDA::simpleRepr(int bkOffset, std::ostream& oss, int f1tsId) const
{
- std::string startOfLine(bkOffset,' ');
+ std::string const startOfLine(bkOffset,' ');
oss << startOfLine << "Field ";
if(bkOffset==0)
oss << "[Type=" << getTypeStr() << "] with name \"" << getName() << "\" ";
if(f1tsId<0)
{
oss << startOfLine << "Field has " << comps.size() << " components with the following infos :" << std::endl;
- for(std::vector<std::string>::const_iterator it=comps.begin();it!=comps.end();it++)
- oss << startOfLine << " - \"" << (*it) << "\"" << std::endl;
+ for(const auto & comp : comps)
+ oss << startOfLine << " - \"" << comp << "\"" << std::endl;
}
if(arr->isAllocated())
{
if(!_field_per_mesh.empty())
{
int i=0;
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it2=_field_per_mesh.begin();it2!=_field_per_mesh.end();it2++,i++)
+ for(auto it2=_field_per_mesh.begin();it2!=_field_per_mesh.end();it2++,i++)
{
const MEDFileFieldPerMesh *cur=(*it2);
if(cur)
const DataArray *arr(getUndergroundDataArray());
if(!arr)
throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::splitComponents : no array defined !");
- std::size_t nbOfCompo=arr->getNumberOfComponents();
+ std::size_t const nbOfCompo=arr->getNumberOfComponents();
std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > ret(nbOfCompo);
for(std::size_t i=0;i<nbOfCompo;i++)
{
ret[i]=deepCopy();
- std::vector<std::size_t> v(1,i);
+ std::vector<std::size_t> const v(1,i);
MCAuto<DataArray> arr2=arr->keepSelectedComponents(v);
ret[i]->setArray(arr2);
}
int MEDFileAnyTypeField1TSWithoutSDA::getDimension() const
{
int ret=-2;
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
- (*it)->getDimension(ret);
+ for(const auto & it : _field_per_mesh)
+ it->getDimension(ret);
return ret;
}
bool MEDFileAnyTypeField1TSWithoutSDA::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
{
bool ret=false;
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
+ for(auto & it : _field_per_mesh)
{
- MEDFileFieldPerMesh *cur(*it);
+ MEDFileFieldPerMesh *cur(it);
if(cur)
ret=cur->changeMeshNames(modifTab) || ret;
}
void MEDFileAnyTypeField1TSWithoutSDA::fillTypesOfFieldAvailable(std::vector<TypeOfField>& types) const
{
std::set<TypeOfField> types2;
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
+ for(const auto & it : _field_per_mesh)
{
- (*it)->fillTypesOfFieldAvailable(types2);
+ it->fillTypesOfFieldAvailable(types2);
}
- std::back_insert_iterator< std::vector<TypeOfField> > bi(types);
+ std::back_insert_iterator< std::vector<TypeOfField> > const bi(types);
std::copy(types2.begin(),types2.end(),bi);
}
{
std::vector<std::string> ret;
std::set<std::string> ret2;
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
+ for(const auto & it : _field_per_mesh)
{
- std::vector<std::string> tmp=(*it)->getPflsReallyUsed();
- for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
- if(ret2.find(*it2)==ret2.end())
+ std::vector<std::string> const tmp=it->getPflsReallyUsed();
+ for(const auto & it2 : tmp)
+ if(ret2.find(it2)==ret2.end())
{
- ret.push_back(*it2);
- ret2.insert(*it2);
+ ret.push_back(it2);
+ ret2.insert(it2);
}
}
return ret;
{
std::vector<std::string> ret;
std::set<std::string> ret2;
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
+ for(const auto & it : _field_per_mesh)
{
- std::vector<std::string> tmp=(*it)->getLocsReallyUsed();
- for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
- if(ret2.find(*it2)==ret2.end())
+ std::vector<std::string> const tmp=it->getLocsReallyUsed();
+ for(const auto & it2 : tmp)
+ if(ret2.find(it2)==ret2.end())
{
- ret.push_back(*it2);
- ret2.insert(*it2);
+ ret.push_back(it2);
+ ret2.insert(it2);
}
}
return ret;
std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getPflsReallyUsedMulti2() const
{
std::vector<std::string> ret;
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
+ for(const auto & it : _field_per_mesh)
{
- std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti();
+ std::vector<std::string> tmp=it->getPflsReallyUsedMulti();
ret.insert(ret.end(),tmp.begin(),tmp.end());
}
return ret;
std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getLocsReallyUsedMulti2() const
{
std::vector<std::string> ret;
- std::set<std::string> ret2;
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
+ std::set<std::string> const ret2;
+ for(const auto & it : _field_per_mesh)
{
- std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti();
+ std::vector<std::string> tmp=it->getLocsReallyUsedMulti();
ret.insert(ret.end(),tmp.begin(),tmp.end());
}
return ret;
void MEDFileAnyTypeField1TSWithoutSDA::changePflsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
{
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
- (*it)->changePflsRefsNamesGen(mapOfModif);
+ for(auto & it : _field_per_mesh)
+ it->changePflsRefsNamesGen(mapOfModif);
}
void MEDFileAnyTypeField1TSWithoutSDA::changeLocsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
{
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
- (*it)->changeLocsRefsNamesGen(mapOfModif);
+ for(auto & it : _field_per_mesh)
+ it->changeLocsRefsNamesGen(mapOfModif);
}
/*!
* Length of this and of nested sequences is the same as that of \a typesF.
* \throw If no field is lying on \a mname.
*/
-std::vector< std::vector< std::pair<mcIdType,mcIdType> > > MEDFileAnyTypeField1TSWithoutSDA::getFieldSplitedByType(const std::string& mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const
+std::vector< std::vector< std::pair<mcIdType,mcIdType> > > MEDFileAnyTypeField1TSWithoutSDA::getFieldSplitedByType(const std::string& /*mname*/, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const
{
if(_field_per_mesh.empty())
throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldSplitedByType : This is empty !");
* \return int - the maximal absolute dimension of elements \a this fields lies on.
* \throw If no field is lying on \a mname.
*/
-int MEDFileAnyTypeField1TSWithoutSDA::getNonEmptyLevels(const std::string& mname, std::vector<int>& levs) const
+int MEDFileAnyTypeField1TSWithoutSDA::getNonEmptyLevels(const std::string& /*mname*/, std::vector<int>& levs) const
{
levs.clear();
std::vector<INTERP_KERNEL::NormalizedCellType> types;
return -1;
st.erase(INTERP_KERNEL::NORM_ERROR);
std::set<int> ret1;
- for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=st.begin();it!=st.end();it++)
+ for(auto it : st)
{
- const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(*it);
+ const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(it);
ret1.insert((int)cm.getDimension());
}
- int ret=*std::max_element(ret1.begin(),ret1.end());
+ int const ret=*std::max_element(ret1.begin(),ret1.end());
std::copy(ret1.rbegin(),ret1.rend(),std::back_insert_iterator<std::vector<int> >(levs));
std::transform(levs.begin(),levs.end(),levs.begin(),std::bind(std::plus<int>(),std::placeholders::_1,-ret));
return ret;
void MEDFileAnyTypeField1TSWithoutSDA::convertMedBallIntoClassic()
{
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it<_field_per_mesh.end();it++)
+ for(auto it=_field_per_mesh.begin();it<_field_per_mesh.end();it++)
if((*it).isNotNull())
(*it)->convertMedBallIntoClassic();
}
{
if(!pfl)
throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::makeReduction : null pfl !");
- std::string name(pfl->getName());
+ std::string const name(pfl->getName());
pfl->checkAllocated();
if(pfl->getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::makeReduction : non mono compo array !");
* \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
* \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
*/
-MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId)
+MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId(const std::string& /*mName*/, INTERP_KERNEL::NormalizedCellType typ, int locId)
{
if(_field_per_mesh.empty())
throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId : This is empty !");
* \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
* \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
*/
-const MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId) const
+const MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId(const std::string& /*mName*/, INTERP_KERNEL::NormalizedCellType typ, int locId) const
{
if(_field_per_mesh.empty())
throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId : This is empty !");
throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getMeshIdFromMeshName : No field set !");
if(mName.empty())
return 0;
- std::string mName2(mName);
+ std::string const mName2(mName);
int ret=0;
std::vector<std::string> msg;
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++,ret++)
+ for(auto it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++,ret++)
if(mName2==(*it)->getMeshName())
return ret;
else
msg.push_back((*it)->getMeshName());
std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getMeshIdFromMeshName : No such mesh \"" << mName2 << "\" as underlying mesh of field \"" << getName() << "\" !\n";
oss << "Possible meshes are : ";
- for(std::vector<std::string>::const_iterator it2=msg.begin();it2!=msg.end();it2++)
- oss << "\"" << (*it2) << "\" ";
+ for(const auto & it2 : msg)
+ oss << "\"" << it2 << "\" ";
throw INTERP_KERNEL::Exception(oss.str());
}
{
if(!mesh)
throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::addNewEntryIfNecessary : input mesh is NULL !");
- std::string tmp(mesh->getName());
+ std::string const tmp(mesh->getName());
if(tmp.empty())
throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::addNewEntryIfNecessary : empty mesh name ! unsupported by MED file !");
setMeshName(tmp);
if((*it)->getMeshName()==tmp)
return i;
}
- std::size_t sz=_field_per_mesh.size();
+ std::size_t const sz=_field_per_mesh.size();
_field_per_mesh.resize(sz+1);
_field_per_mesh[sz]=MEDFileFieldPerMesh::New(this,mesh);
return (int)sz;
MEDFileFieldGlobsReal& glob)
{
bool ret=false;
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
+ for(auto & it : _field_per_mesh)
{
- MEDFileFieldPerMesh *fpm(*it);
+ MEDFileFieldPerMesh *fpm(it);
if(fpm)
ret=fpm->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,glob) || ret;
}
std::vector<INTERP_KERNEL::NormalizedCellType> types;
std::vector< std::vector<TypeOfField> > typesF;
std::vector< std::vector<std::string> > pfls,locs;
- std::vector< std::vector<std::pair<mcIdType,mcIdType> > > bgEnd(getFieldSplitedByType(getMeshName().c_str(),types,typesF,pfls,locs));
+ std::vector< std::vector<std::pair<mcIdType,mcIdType> > > const bgEnd(getFieldSplitedByType(getMeshName().c_str(),types,typesF,pfls,locs));
std::set<TypeOfField> allEnt;
- for(std::vector< std::vector<TypeOfField> >::const_iterator it1=typesF.begin();it1!=typesF.end();it1++)
- for(std::vector<TypeOfField>::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
- allEnt.insert(*it2);
+ for(const auto & it1 : typesF)
+ for(auto it2 : it1)
+ allEnt.insert(it2);
std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > ret(allEnt.size());
- std::set<TypeOfField>::const_iterator it3(allEnt.begin());
+ auto it3(allEnt.begin());
for(std::size_t i=0;i<allEnt.size();i++,it3++)
{
std::vector< std::pair<mcIdType,mcIdType> > its;
ret[i]=shallowCpy();
- mcIdType newLgth(ret[i]->keepOnlySpatialDiscretization(*it3,its));
+ mcIdType const newLgth(ret[i]->keepOnlySpatialDiscretization(*it3,its));
ret[i]->updateData(newLgth,its);
}
return ret;
std::vector<INTERP_KERNEL::NormalizedCellType> types;
std::vector< std::vector<TypeOfField> > typesF;
std::vector< std::vector<std::string> > pfls,locs;
- std::vector< std::vector<std::pair<mcIdType,mcIdType> > > bgEnd(getFieldSplitedByType(getMeshName().c_str(),types,typesF,pfls,locs));
+ std::vector< std::vector<std::pair<mcIdType,mcIdType> > > const bgEnd(getFieldSplitedByType(getMeshName().c_str(),types,typesF,pfls,locs));
std::set<TypeOfField> allEnt;
std::size_t nbOfMDPGT(0),ii(0);
for(std::vector< std::vector<TypeOfField> >::const_iterator it1=typesF.begin();it1!=typesF.end();it1++,ii++)
{
nbOfMDPGT=std::max(nbOfMDPGT,locs[ii].size());
- for(std::vector<TypeOfField>::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
- allEnt.insert(*it2);
+ for(auto it2 : *it1)
+ allEnt.insert(it2);
}
if(allEnt.size()!=1)
throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::splitMultiDiscrPerGeoTypes : this field is expected to be defined only on one spatial discretization !");
{
std::vector< std::pair<mcIdType,mcIdType> > its;
ret[i]=shallowCpy();
- mcIdType newLgth(ret[i]->keepOnlyGaussDiscretization(i,its));
+ mcIdType const newLgth(ret[i]->keepOnlyGaussDiscretization(i,its));
ret[i]->updateData(newLgth,its);
}
return ret;
mcIdType MEDFileAnyTypeField1TSWithoutSDA::keepOnlySpatialDiscretization(TypeOfField tof, std::vector< std::pair<mcIdType,mcIdType> >& its)
{
mcIdType globalCounter(0);
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
- (*it)->keepOnlySpatialDiscretization(tof,globalCounter,its);
+ for(auto & it : _field_per_mesh)
+ it->keepOnlySpatialDiscretization(tof,globalCounter,its);
return globalCounter;
}
mcIdType MEDFileAnyTypeField1TSWithoutSDA::keepOnlyGaussDiscretization(std::size_t idOfDisc, std::vector< std::pair<mcIdType,mcIdType> >& its)
{
mcIdType globalCounter(0);
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
- (*it)->keepOnlyGaussDiscretization(idOfDisc,globalCounter,its);
+ for(auto & it : _field_per_mesh)
+ it->keepOnlyGaussDiscretization(idOfDisc,globalCounter,its);
return globalCounter;
}
if(oldArr)
newArr->copyStringInfoFrom(*oldArr);
mcIdType pos=0;
- for(std::vector< std::pair<mcIdType,mcIdType> >::const_iterator it=oldStartStops.begin();it!=oldStartStops.end();it++)
+ for(const auto & oldStartStop : oldStartStops)
{
- if((*it).second<(*it).first)
+ if(oldStartStop.second<oldStartStop.first)
throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : the range in the leaves was invalid !");
- newArr->setContigPartOfSelectedValuesSlice(pos,oldArr,(*it).first,(*it).second,1);
- pos+=(*it).second-(*it).first;
+ newArr->setContigPartOfSelectedValuesSlice(pos,oldArr,oldStartStop.first,oldStartStop.second,1);
+ pos+=oldStartStop.second-oldStartStop.first;
}
setArray(newArr);
return ;
*/
std::string MEDFileAnyTypeField1TSWithoutSDA::FieldNameToMEDFileConvention(const std::string& nonCorrectFieldName)
{
- std::string::size_type pos0(nonCorrectFieldName.find_last_not_of(' '));
+ std::string::size_type const pos0(nonCorrectFieldName.find_last_not_of(' '));
if(pos0==std::string::npos)
return nonCorrectFieldName;
if(pos0+1==nonCorrectFieldName.length())
throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursively : unexpected exception internal error !");
_field_per_mesh.resize(1);
//
- MEDFileMesh *mm(0);
+ MEDFileMesh *mm(nullptr);
if(ms)
{
mm=ms->getMeshWithName(getMeshName());
void MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
{
allocIfNecessaryTheArrayToReceiveDataFromFile();
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
- (*it)->loadBigArraysRecursively(fid,nasc);
+ for(auto & it : _field_per_mesh)
+ it->loadBigArraysRecursively(fid,nasc);
}
void MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursivelyIfNecessary(med_idt fid, const MEDFileFieldNameScope& nasc)
{
if(allocIfNecessaryTheArrayToReceiveDataFromFile())
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
- (*it)->loadBigArraysRecursively(fid,nasc);
+ for(auto & it : _field_per_mesh)
+ it->loadBigArraysRecursively(fid,nasc);
}
void MEDFileAnyTypeField1TSWithoutSDA::loadStructureAndBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc, const MEDFileMeshes *ms, const MEDFileEntities *entities)
{
- MEDFileCapability cap(fid);
+ MEDFileCapability const cap(fid);
loadOnlyStructureOfDataRecursively(fid,nasc,ms,entities,&cap);
loadBigArraysRecursively(fid,nasc);
}
void MEDFileAnyTypeField1TSWithoutSDA::loadStructureAndBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc, const PartDefinition *pd, const MEDFileEntities *entities)
{
- MEDFileCapability cap(fid);
+ MEDFileCapability const cap(fid);
loadOnlyStructureOfDataRecursively(fid,nasc,pd,entities,&cap);
loadBigArraysRecursively(fid,nasc);
}
std::vector<const BigMemoryObject *> ret;
if(getUndergroundDataArray())
ret.push_back(getUndergroundDataArray());
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
- ret.push_back((const MEDFileFieldPerMesh *)*it);
+ for(const auto & it : _field_per_mesh)
+ ret.push_back((const MEDFileFieldPerMesh *)it);
return ret;
}
{
const MEDCouplingMesh *mesh(field->getMesh());
//
- TypeOfField type(field->getTypeOfField());
- std::vector<DataArrayIdType *> dummy;
+ TypeOfField const type(field->getTypeOfField());
+ std::vector<DataArrayIdType *> const dummy;
if(mesh)
setMeshName(mesh->getName());
mcIdType start(copyTinyInfoFrom(th,field,arr));
- int pos(addNewEntryIfNecessary(mesh));
+ int const pos(addNewEntryIfNecessary(mesh));
if(type!=ON_NODES)
{
- std::vector<mcIdType> code=MEDFileField1TSWithoutSDA::CheckSBTMesh(mesh);
+ std::vector<mcIdType> const code=MEDFileField1TSWithoutSDA::CheckSBTMesh(mesh);
_field_per_mesh[pos]->assignFieldNoProfileNoRenum(start,code,field,arr,glob,nasc);
}
else
throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : input field is null !");
if(!arrOfVals || !arrOfVals->isAllocated())
throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : input array is null or not allocated !");
- TypeOfField type=field->getTypeOfField();
+ TypeOfField const type=field->getTypeOfField();
std::vector<DataArrayIdType *> idsInPflPerType;
std::vector<DataArrayIdType *> idsPerType;
std::vector<mcIdType> code,code2;
std::vector<const DataArrayIdType *> idsPerType3(idsPerType.size()); std::copy(idsPerType.begin(),idsPerType.end(),idsPerType3.begin());
// start of check
MCAuto<MEDCouplingFieldTemplate> field2=field->clone(false);
- mcIdType nbOfTuplesExp=field2->getNumberOfTuplesExpectedRegardingCode(code,idsPerType3);
+ mcIdType const nbOfTuplesExp=field2->getNumberOfTuplesExpectedRegardingCode(code,idsPerType3);
if(nbOfTuplesExp!=arrOfVals->getNumberOfTuples())
{
std::ostringstream oss; oss << "MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : The array is expected to have " << nbOfTuplesExp << " tuples ! It has " << arrOfVals->getNumberOfTuples() << " !";
mcIdType start(copyTinyInfoFrom(th,field,arrOfVals));
code2=m->getDistributionOfTypes();
//
- mcIdType pos=addNewEntryIfNecessary(m);
+ mcIdType const pos=addNewEntryIfNecessary(m);
_field_per_mesh[pos]->assignFieldProfile(start,profile,code,code2,idsInPflPerType,idsPerType,field,arrOfVals,m,glob,nasc);
}
else
throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : input profile is null, not allocated or with number of components != 1 !");
std::vector<mcIdType> v(3); v[0]=-1; v[1]=profile->getNumberOfTuples(); v[2]=0;
std::vector<const DataArrayIdType *> idsPerType3(1); idsPerType3[0]=profile;
- mcIdType nbOfTuplesExp=field->getNumberOfTuplesExpectedRegardingCode(v,idsPerType3);
+ mcIdType const nbOfTuplesExp=field->getNumberOfTuplesExpectedRegardingCode(v,idsPerType3);
if(nbOfTuplesExp!=arrOfVals->getNumberOfTuples())
{
std::ostringstream oss; oss << "MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : For node field, the array is expected to have " << nbOfTuplesExp << " tuples ! It has " << arrOfVals->getNumberOfTuples() << " !";
throw INTERP_KERNEL::Exception(oss.str());
}
mcIdType start(copyTinyInfoFrom(th,field,arrOfVals));
- mcIdType pos(addNewEntryIfNecessary(m));
+ mcIdType const pos(addNewEntryIfNecessary(m));
_field_per_mesh[pos]->assignNodeFieldProfile(start,profile,field,arrOfVals,glob,nasc);
}
}
{
if(!field)
throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::copyTinyInfoFrom : input field is NULL !");
- std::string name(field->getName());
+ std::string const name(field->getName());
setName(name.c_str());
if(field->getMesh())
setMeshName(field->getMesh()->getName());
}
else
{
- mcIdType oldNbOfTuples=getOrCreateAndGetArray()->getNumberOfTuples();
- mcIdType newNbOfTuples=oldNbOfTuples+arr->getNumberOfTuples();
+ mcIdType const oldNbOfTuples=getOrCreateAndGetArray()->getNumberOfTuples();
+ mcIdType const newNbOfTuples=oldNbOfTuples+arr->getNumberOfTuples();
getOrCreateAndGetArray()->reAlloc(newNbOfTuples);
_nb_of_tuples_to_be_allocated=-3;
return oldNbOfTuples;
bool MEDFileAnyTypeField1TSWithoutSDA::presenceOfMultiDiscPerGeoType() const
{
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
+ for(const auto & it : _field_per_mesh)
{
- const MEDFileFieldPerMesh *fpm(*it);
+ const MEDFileFieldPerMesh *fpm(it);
if(!fpm)
continue;
if(fpm->presenceOfMultiDiscPerGeoType())
bool MEDFileAnyTypeField1TSWithoutSDA::presenceOfStructureElements() const
{
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
- if((*it).isNotNull())
- if((*it)->presenceOfStructureElements())
+ for(const auto & it : _field_per_mesh)
+ if(it.isNotNull())
+ if(it->presenceOfStructureElements())
return true;
return false;
}
bool MEDFileAnyTypeField1TSWithoutSDA::onlyStructureElements() const
{
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
- if((*it).isNotNull())
- if(!(*it)->onlyStructureElements())
+ for(const auto & it : _field_per_mesh)
+ if(it.isNotNull())
+ if(!it->onlyStructureElements())
return false;
return true;
}
void MEDFileAnyTypeField1TSWithoutSDA::killStructureElements()
{
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
- if((*it).isNotNull())
- (*it)->killStructureElements();
+ for(auto & it : _field_per_mesh)
+ if(it.isNotNull())
+ it->killStructureElements();
}
void MEDFileAnyTypeField1TSWithoutSDA::keepOnlyStructureElements()
{
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
- if((*it).isNotNull())
- (*it)->keepOnlyStructureElements();
+ for(auto & it : _field_per_mesh)
+ if(it.isNotNull())
+ it->keepOnlyStructureElements();
}
void MEDFileAnyTypeField1TSWithoutSDA::keepOnlyOnSE(const std::string& seName)
{
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
- if((*it).isNotNull())
- (*it)->keepOnlyOnSE(seName);
+ for(auto & it : _field_per_mesh)
+ if(it.isNotNull())
+ it->keepOnlyOnSE(seName);
}
void MEDFileAnyTypeField1TSWithoutSDA::getMeshSENames(std::vector< std::pair<std::string,std::string> >& ps) const
{
- for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
- if((*it).isNotNull())
- (*it)->getMeshSENames(ps);
+ for(const auto & it : _field_per_mesh)
+ if(it.isNotNull())
+ it->getMeshSENames(ps);
}
MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::fieldOnMesh(const MEDFileFieldGlobsReal *glob, const MEDFileMesh *mesh, MCAuto<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
pm->fillTypesOfFieldAvailable(types);
if(types.size()!=1)
throw INTERP_KERNEL::Exception(MSG0);
- TypeOfField type(*types.begin());
+ TypeOfField const type(*types.begin());
int meshDimRelToMax(0);
if(type==ON_NODES)
meshDimRelToMax=0;
else
{
int myDim(std::numeric_limits<int>::max());
- bool isUnique(pm->isUniqueLevel(myDim));
+ bool const isUnique(pm->isUniqueLevel(myDim));
if(!isUnique)
throw INTERP_KERNEL::Exception(MSG0);
meshDimRelToMax=myDim-mesh->getMeshDimension();
mm=MEDFileMesh::New(glob->getFileName(),getMeshName().c_str(),getMeshIteration(),getMeshOrder());
else
mm=MEDFileMesh::New(glob->getFileName(),mName,getMeshIteration(),getMeshOrder());
- int absDim=getDimension();
- int meshDimRelToMax=absDim-mm->getMeshDimension();
+ int const absDim=getDimension();
+ int const meshDimRelToMax=absDim-mm->getMeshDimension();
return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,glob,mm,arrOut,nasc);
}
}
MEDCouplingFieldDiscretization *disc=ret->getDiscretization();
if(!disc) throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel : internal error, no discretization on field !");
- std::vector<DataArray *> arrOut2(1,arrOut);
+ std::vector<DataArray *> const arrOut2(1,arrOut);
// 2 following lines replace ret->renumberCells(cellRenum->getConstPointer()) if not DataArrayDouble
disc->renumberArraysForCell(ret->getMesh(),arrOut2,cellRenum->getConstPointer(),true);
(const_cast<MEDCouplingMesh*>(ret->getMesh()))->renumberCells(cellRenum->getConstPointer(),true);
{
if(!mesh)
throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::CheckSBTMesh : input mesh is NULL !");
- std::set<INTERP_KERNEL::NormalizedCellType> geoTypes=mesh->getAllGeoTypes();
- std::size_t nbOfTypes=geoTypes.size();
+ std::set<INTERP_KERNEL::NormalizedCellType> const geoTypes=mesh->getAllGeoTypes();
+ std::size_t const nbOfTypes=geoTypes.size();
std::vector<mcIdType> code(3*nbOfTypes);
MCAuto<DataArrayIdType> arr1=DataArrayIdType::New();
arr1->alloc(nbOfTypes,1);
mcIdType *arrPtr=arr1->getPointer();
- std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=geoTypes.begin();
+ auto it=geoTypes.begin();
for(std::size_t i=0;i<nbOfTypes;i++,it++)
arrPtr[i]=ToIdType(std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,*it)));
MCAuto<DataArrayIdType> arr2=arr1->checkAndPreparePermutation();
int i=0;
for(it=geoTypes.begin();it!=geoTypes.end();it++,i++)
{
- mcIdType pos=arrPtr2[i];
- mcIdType nbCells=mesh->getNumberOfCellsWithType(*it);
+ mcIdType const pos=arrPtr2[i];
+ mcIdType const nbCells=mesh->getNumberOfCellsWithType(*it);
code[3*pos]=(mcIdType)(*it);
code[3*pos+1]=nbCells;
code[3*pos+2]=-1;//no profiles
}
- std::vector<const DataArrayIdType *> idsPerType;//no profiles
+ std::vector<const DataArrayIdType *> const idsPerType;//no profiles
DataArrayIdType *da=mesh->checkTypeConsistencyAndContig(code,idsPerType);
if(da)
{
if(_field_per_mesh.empty())
throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldSplitedByType : This is empty !");
std::vector< std::vector< std::pair<mcIdType,mcIdType> > > ret0=_field_per_mesh[0]->getFieldSplitedByType(types,typesF,pfls,locs);
- std::size_t nbOfRet=ret0.size();
+ std::size_t const nbOfRet=ret0.size();
std::vector< std::vector<DataArrayDouble *> > ret(nbOfRet);
for(std::size_t i=0;i<nbOfRet;i++)
{
const std::vector< std::pair<mcIdType,mcIdType> >& p=ret0[i];
- std::size_t nbOfRet1=p.size();
+ std::size_t const nbOfRet1=p.size();
ret[i].resize(nbOfRet1);
for(std::size_t j=0;j<nbOfRet1;j++)
{
}
MEDFileInt32Field1TSWithoutSDA::MEDFileInt32Field1TSWithoutSDA()
-{
-}
+= default;
MEDFileInt32Field1TSWithoutSDA::MEDFileInt32Field1TSWithoutSDA(const std::string& fieldName, const std::string& meshName, int csit, int iteration, int order,
const std::vector<std::string>& infos):MEDFileField1TSNDTemplateWithoutSDA<int>(fieldName,meshName,csit,iteration,order,infos)
{
if(_field_per_mesh.size()!=1)
throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : field lies on several meshes, this method has no sense !");
- if(_field_per_mesh[0]==0)
+ if(_field_per_mesh[0]==nullptr)
throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : no field specified !");
_field_per_mesh[0]->getUndergroundDataArrayExt(entries);
return getUndergroundDataArrayTemplate();
}
MEDFileInt64Field1TSWithoutSDA::MEDFileInt64Field1TSWithoutSDA()
-{
-}
+= default;
MEDFileInt64Field1TSWithoutSDA::MEDFileInt64Field1TSWithoutSDA(const std::string& fieldName, const std::string& meshName, int csit, int iteration, int order,
const std::vector<std::string>& infos):MEDFileField1TSNDTemplateWithoutSDA<Int64>(fieldName,meshName,csit,iteration,order,infos)
{
if(_field_per_mesh.size()!=1)
throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : field lies on several meshes, this method has no sense !");
- if(_field_per_mesh[0]==0)
+ if(_field_per_mesh[0]==nullptr)
throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : no field specified !");
_field_per_mesh[0]->getUndergroundDataArrayExt(entries);
return getUndergroundDataArrayTemplate();
}
MEDFileFloatField1TSWithoutSDA::MEDFileFloatField1TSWithoutSDA()
-{
-}
+= default;
MEDFileFloatField1TSWithoutSDA::MEDFileFloatField1TSWithoutSDA(const std::string& fieldName, const std::string& meshName, int csit, int iteration, int order,
const std::vector<std::string>& infos):MEDFileField1TSNDTemplateWithoutSDA<float>(fieldName,meshName,csit,iteration,order,infos)
{
if(_field_per_mesh.size()!=1)
throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : field lies on several meshes, this method has no sense !");
- if(_field_per_mesh[0]==0)
+ if(_field_per_mesh[0]==nullptr)
throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : no field specified !");
_field_per_mesh[0]->getUndergroundDataArrayExt(entries);
return getUndergroundDataArrayTemplate();
//= MEDFileAnyTypeField1TS
MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS()
-{
-}
+= default;
MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::AllocateContentFrom(med_idt fid, const std::string& fieldName, int iteration, int order)
{
if(!found)
{
std::ostringstream oss; oss << "No such iteration (" << iteration << "," << order << ") in existing field '" << fName << "' in file '" << FileNameFromFID(fid) << "' ! Available iterations are : ";
- for(std::vector< std::pair<int,int> >::const_iterator iter=dtits.begin();iter!=dtits.end();iter++)
- oss << "(" << (*iter).first << "," << (*iter).second << "), ";
+ for(const auto & dtit : dtits)
+ oss << "(" << dtit.first << "," << dtit.second << "), ";
throw INTERP_KERNEL::Exception(oss.str());
}
MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities)
{
- std::string useless;
+ std::string const useless;
MCAuto<MEDFileAnyTypeField1TSWithoutSDA> ret(AllocateContentFrom(fid,useless));
if(loadAll)
ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret),ms,entities);
MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const std::string& fileName, bool loadAll)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return New(fid,loadAll);
}
MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(med_idt fid, bool loadAll)
{
- MCAuto<MEDFileAnyTypeField1TSWithoutSDA> c(BuildContentFrom(fid,loadAll,0,0));
+ MCAuto<MEDFileAnyTypeField1TSWithoutSDA> c(BuildContentFrom(fid,loadAll,nullptr,nullptr));
MCAuto<MEDFileAnyTypeField1TS> ret(BuildNewInstanceFromContent(c,fid));
ret->loadGlobals(fid);
return ret.retn();
MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return New(fid,fieldName,loadAll);
}
MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(med_idt fid, const std::string& fieldName, bool loadAll)
{
- MCAuto<MEDFileAnyTypeField1TSWithoutSDA> c(BuildContentFrom(fid,fieldName,loadAll,0,0));
+ MCAuto<MEDFileAnyTypeField1TSWithoutSDA> c(BuildContentFrom(fid,fieldName,loadAll,nullptr,nullptr));
MCAuto<MEDFileAnyTypeField1TS> ret(BuildNewInstanceFromContent(c,fid));
ret->loadGlobals(fid);
return ret.retn();
MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return New(fid,fieldName,iteration,order,loadAll);
}
MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(med_idt fid, const std::string& fieldName, int iteration, int order, bool loadAll)
{
- MCAuto<MEDFileAnyTypeField1TSWithoutSDA> c(BuildContentFrom(fid,fieldName,iteration,order,loadAll,(const MEDFileMeshes *)0,0));
+ MCAuto<MEDFileAnyTypeField1TSWithoutSDA> c(BuildContentFrom(fid,fieldName,iteration,order,loadAll,(const MEDFileMeshes *)nullptr,nullptr));
MCAuto<MEDFileAnyTypeField1TS> ret(BuildNewInstanceFromContent(c,fid));
ret->loadGlobals(fid);
return ret.retn();
MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::NewAdv(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll, const MEDFileEntities *entities)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return NewAdv(fid,fieldName,iteration,order,loadAll,entities);
}
MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::NewAdv(med_idt fid, const std::string& fieldName, int iteration, int order, bool loadAll, const MEDFileEntities *entities)
{
- MCAuto<MEDFileAnyTypeField1TSWithoutSDA> c(BuildContentFrom(fid,fieldName,iteration,order,loadAll,(const MEDFileMeshes *)0,entities));
+ MCAuto<MEDFileAnyTypeField1TSWithoutSDA> c(BuildContentFrom(fid,fieldName,iteration,order,loadAll,(const MEDFileMeshes *)nullptr,entities));
MCAuto<MEDFileAnyTypeField1TS> ret(BuildNewInstanceFromContent(c,fid));
ret->loadGlobals(fid);
return ret.retn();
{
if(checkFieldId)
{
- med_int nbFields=MEDnField(fid);
+ med_int const nbFields=MEDnField(fid);
if(fieldIdCFormat>=nbFields)
{
std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::LocateField2(fileName) : in file \'" << FileNameFromFID(fid) << "\' number of fields is " << nbFields << " ! Trying to request for id " << fieldIdCFormat << " !";
throw INTERP_KERNEL::Exception(oss.str());
}
}
- med_int ncomp(MEDfieldnComponent(fid,fieldIdCFormat+1));
+ med_int const ncomp(MEDfieldnComponent(fid,fieldIdCFormat+1));
INTERP_KERNEL::AutoPtr<char> comp(MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE));
INTERP_KERNEL::AutoPtr<char> unit(MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE));
INTERP_KERNEL::AutoPtr<char> dtunit(MEDLoaderBase::buildEmptyString(MED_LNAME_SIZE));
*/
int MEDFileAnyTypeField1TS::LocateField(med_idt fid, const std::string& fieldName, int& posCFormat, med_field_type& typcha, std::vector<std::string>& infos, std::string& dtunitOut, std::string& meshName)
{
- med_int nbFields=MEDnField(fid);
+ med_int const nbFields=MEDnField(fid);
bool found=false;
std::vector<std::string> fns(nbFields);
int nbOfStep2(-1);
if(!found)
{
std::ostringstream oss; oss << "No such field '" << fieldName << "' in file '" << FileNameFromFID(fid) << "' ! Available fields are : ";
- for(std::vector<std::string>::const_iterator it=fns.begin();it!=fns.end();it++)
- oss << "\"" << *it << "\" ";
+ for(const auto & fn : fns)
+ oss << "\"" << fn << "\" ";
throw INTERP_KERNEL::Exception(oss.str());
}
return nbOfStep2;
void MEDFileAnyTypeField1TS::setProfileNameOnLeaf(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId, const std::string& newPflName, bool forceRenameOnGlob)
{
MEDFileFieldPerMeshPerTypePerDisc *disc=getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
- std::string oldPflName=disc->getProfile();
+ std::string const oldPflName=disc->getProfile();
std::vector<std::string> vv=getPflsReallyUsedMulti();
- std::size_t nbOfOcc=std::count(vv.begin(),vv.end(),oldPflName);
+ std::size_t const nbOfOcc=std::count(vv.begin(),vv.end(),oldPflName);
if(forceRenameOnGlob || (!existsPfl(newPflName) && nbOfOcc==1))
{
disc->setProfile(newPflName);
void MEDFileAnyTypeField1TS::setLocNameOnLeaf(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId, const std::string& newLocName, bool forceRenameOnGlob)
{
MEDFileFieldPerMeshPerTypePerDisc *disc=getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
- std::string oldLocName=disc->getLocalization();
+ std::string const oldLocName=disc->getLocalization();
std::vector<std::string> vv=getLocsReallyUsedMulti();
- std::size_t nbOfOcc=std::count(vv.begin(),vv.end(),oldLocName);
+ std::size_t const nbOfOcc=std::count(vv.begin(),vv.end(),oldLocName);
if(forceRenameOnGlob || (!existsLoc(newLocName) && nbOfOcc==1))
{
disc->setLocalization(newLocName);
{
if(getFileName().empty())
throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::loadArrays : the structure does not come from a file !");
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(getFileName()));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(getFileName()));
contentNotNullBase()->loadBigArraysRecursively(fid,*contentNotNullBase());
}
{
if(!getFileName().empty())
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(getFileName()));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(getFileName()));
contentNotNullBase()->loadBigArraysRecursivelyIfNecessary(fid,*contentNotNullBase());
}
}
void MEDFileAnyTypeField1TS::writeLL(med_idt fid) const
{
- std::size_t nbComp(getNumberOfComponents());
+ std::size_t const nbComp(getNumberOfComponents());
INTERP_KERNEL::AutoPtr<char> comp(MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE));
INTERP_KERNEL::AutoPtr<char> unit(MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE));
for(std::size_t i=0;i<nbComp;i++)
{
- std::string info=getInfo()[i];
+ std::string const info=getInfo()[i];
std::string c,u;
MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,_too_long_str);
if(!content)
throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitComponents : no content in this ! Unable to split components !");
std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit=content->splitComponents();
- std::size_t sz(contentsSplit.size());
+ std::size_t const sz(contentsSplit.size());
std::vector< MCAuto< MEDFileAnyTypeField1TS > > ret(sz);
for(std::size_t i=0;i<sz;i++)
{
if(!content)
throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitDiscretizations : no content in this ! Unable to split discretization !");
std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit(content->splitDiscretizations());
- std::size_t sz(contentsSplit.size());
+ std::size_t const sz(contentsSplit.size());
std::vector< MCAuto< MEDFileAnyTypeField1TS > > ret(sz);
for(std::size_t i=0;i<sz;i++)
{
if(!content)
throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitMultiDiscrPerGeoTypes : no content in this ! Unable to split discretization !");
std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit(content->splitMultiDiscrPerGeoTypes());
- std::size_t sz(contentsSplit.size());
+ std::size_t const sz(contentsSplit.size());
std::vector< MCAuto< MEDFileAnyTypeField1TS > > ret(sz);
for(std::size_t i=0;i<sz;i++)
{
const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
if(content)
{
- const MEDFileField1TSWithoutSDA *contc=dynamic_cast<const MEDFileField1TSWithoutSDA *>(content);
+ const auto *contc=dynamic_cast<const MEDFileField1TSWithoutSDA *>(content);
if(!contc)
throw INTERP_KERNEL::Exception("MEDFileField1TS::convertToInt : the content inside this is not FLOAT64 ! This is incoherent !");
MCAuto<MEDFileInt32Field1TSWithoutSDA> newc(contc->convertToInt());
const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
if(content)
{
- const MEDFileField1TSWithoutSDA *contc=dynamic_cast<const MEDFileField1TSWithoutSDA *>(content);
+ const auto *contc=dynamic_cast<const MEDFileField1TSWithoutSDA *>(content);
if(!contc)
throw INTERP_KERNEL::Exception("MEDFileField1TS::convertToInt : the content inside this is not FLOAT64 ! This is incoherent !");
MCAuto<MEDFileInt64Field1TSWithoutSDA> newc(contc->convertToInt64());
if(!f)
throw INTERP_KERNEL::Exception("MEDFileInt32Field1TS::ConvertFieldIntToFieldDouble : null input field !");
int t1,t2;
- double t0(f->getTime(t1,t2));
- std::string tu(f->getTimeUnit());
+ double const t0(f->getTime(t1,t2));
+ std::string const tu(f->getTimeUnit());
MCAuto<MEDCouplingFieldTemplate> ft(MEDCouplingFieldTemplate::New(*f));
MCAuto<MEDCouplingFieldDouble> ret(MEDCouplingFieldDouble::New(*ft));
ret->setTime(t0,t1,t2); ret->setTimeUnit(tu);
if(!f)
throw INTERP_KERNEL::Exception("MEDFileInt64Field1TS::ConvertFieldIntToFieldDouble : null input field !");
int t1,t2;
- double t0(f->getTime(t1,t2));
- std::string tu(f->getTimeUnit());
+ double const t0(f->getTime(t1,t2));
+ std::string const tu(f->getTimeUnit());
MCAuto<MEDCouplingFieldTemplate> ft(MEDCouplingFieldTemplate::New(*f));
MCAuto<MEDCouplingFieldDouble> ret(MEDCouplingFieldDouble::New(*ft));
ret->setTime(t0,t1,t2); ret->setTimeUnit(tu);
#ifndef __MEDFILEFIELD1TS_HXX__
#define __MEDFILEFIELD1TS_HXX__
+#include "MEDCouplingRefCountObject.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingTraits.hxx"
+#include "MEDFileUtilities.txx"
#include "MEDLoaderDefines.hxx"
#include "MEDFileFieldGlobs.hxx"
#include "MEDFileFieldInternal.hxx"
#include "MEDLoaderTraits.hxx"
+#include "NormalizedGeometricTypes"
#include "med.h"
+#include <string>
+#include <vector>
+#include <utility>
+#include <cstddef>
+#include <ostream>
+#include <map>
namespace MEDCoupling
{
MEDLOADER_EXPORT void keepOnlyOnSE(const std::string& seName);
MEDLOADER_EXPORT void getMeshSENames(std::vector< std::pair<std::string,std::string> >& ps) const;
MEDLOADER_EXPORT void setInfo(const std::vector<std::string>& infos);
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
MEDLOADER_EXPORT mcIdType copyTinyInfoFrom(const TimeHolder *th, const MEDCouplingFieldTemplate *field, const DataArray *arr);
MEDLOADER_EXPORT void setFieldNoProfileSBT(const TimeHolder *th, const MEDCouplingFieldTemplate *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc);
MEDLOADER_EXPORT void setFieldProfile(const TimeHolder *th, const MEDCouplingFieldTemplate *field, const DataArray *arrOfVals, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayIdType *profile, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc, bool smartPflKiller=true);
MEDFileField1TSTemplateWithoutSDA(const std::string& fieldName, const std::string& meshName, int csit, int iteration, int order):MEDFileAnyTypeField1TSWithoutSDA(fieldName,meshName,csit,iteration,order) { }
MEDFileField1TSTemplateWithoutSDA() { }
public:
- MEDLOADER_EXPORT void setArray(DataArray *arr);
- MEDLOADER_EXPORT DataArray *createNewEmptyDataArrayInstance() const;
+ MEDLOADER_EXPORT void setArray(DataArray *arr) override;
+ MEDLOADER_EXPORT DataArray *createNewEmptyDataArrayInstance() const override;
MEDLOADER_EXPORT typename Traits<T>::ArrayType *getOrCreateAndGetArrayTemplate();
MEDLOADER_EXPORT typename Traits<T>::ArrayType const *getOrCreateAndGetArrayTemplate() const;
MEDLOADER_EXPORT typename Traits<T>::ArrayType *getUndergroundDataArrayTemplate() const;
MEDLOADER_EXPORT typename Traits<T>::ArrayType *getUndergroundDataArrayTemplateExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<mcIdType,mcIdType> > >& entries) const;
- MEDLOADER_EXPORT DataArray *getOrCreateAndGetArray();
- MEDLOADER_EXPORT const DataArray *getOrCreateAndGetArray() const;
- MEDLOADER_EXPORT DataArray *getUndergroundDataArray() const;
+ MEDLOADER_EXPORT DataArray *getOrCreateAndGetArray() override;
+ MEDLOADER_EXPORT const DataArray *getOrCreateAndGetArray() const override;
+ MEDLOADER_EXPORT DataArray *getUndergroundDataArray() const override;
MEDLOADER_EXPORT void aggregate(const typename std::vector< typename MLFieldTraits<T>::F1TSWSDAType const * >& f1tss, const std::vector< std::vector< std::pair<int,mcIdType> > >& dts);
MEDLOADER_EXPORT void copyTimeInfoFrom(const typename Traits<T>::FieldType *mcf);
protected:
class MEDFileField1TSWithoutSDA : public MEDFileField1TSTemplateWithoutSDA<double>
{
public:
- MEDLOADER_EXPORT const char *getTypeStr() const;
+ MEDLOADER_EXPORT const char *getTypeStr() const override;
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileField1TSWithoutSDA"); }
- MEDLOADER_EXPORT DataArray *getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<mcIdType,mcIdType> > >& entries) const;
+ MEDLOADER_EXPORT DataArray *getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<mcIdType,mcIdType> > >& entries) const override;
MEDLOADER_EXPORT std::vector< std::vector<DataArrayDouble *> > getFieldSplitedByType2(const std::string& mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const;
MEDLOADER_EXPORT static void CheckMeshDimRel(int meshDimRelToMax);
MEDLOADER_EXPORT static std::vector<mcIdType> CheckSBTMesh(const MEDCouplingMesh *mesh);
public:
MEDLOADER_EXPORT MEDFileField1TSWithoutSDA();
MEDLOADER_EXPORT MEDFileField1TSWithoutSDA(const std::string& fieldName, const std::string& meshName, int csit, int iteration, int order, const std::vector<std::string>& infos);
- MEDLOADER_EXPORT MEDFileField1TSWithoutSDA *shallowCpy() const;
- MEDLOADER_EXPORT MEDFileField1TSWithoutSDA *deepCopy() const;
+ MEDLOADER_EXPORT MEDFileField1TSWithoutSDA *shallowCpy() const override;
+ MEDLOADER_EXPORT MEDFileField1TSWithoutSDA *deepCopy() const override;
MEDLOADER_EXPORT MEDFileInt32Field1TSWithoutSDA *convertToInt() const;
MEDLOADER_EXPORT MEDFileInt64Field1TSWithoutSDA *convertToInt64() const;
MEDLOADER_EXPORT MEDFileFloatField1TSWithoutSDA *convertToFloat() const;
MEDLOADER_EXPORT MEDFileField1TSWithoutSDA *convertToDouble() const;
protected:
MEDFileField1TSNDTemplateWithoutSDA() { }
- MEDFileField1TSNDTemplateWithoutSDA(const std::string& fieldName, const std::string& meshName, int csit, int iteration, int order, const std::vector<std::string>& infos):MEDFileField1TSTemplateWithoutSDA<T>(fieldName,meshName,csit,iteration,order) { }
+ MEDFileField1TSNDTemplateWithoutSDA(const std::string& fieldName, const std::string& meshName, int csit, int iteration, int order, const std::vector<std::string>& /*infos*/):MEDFileField1TSTemplateWithoutSDA<T>(fieldName,meshName,csit,iteration,order) { }
};
/*!
MEDLOADER_EXPORT MEDFileInt32Field1TSWithoutSDA();
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileInt32Field1TSWithoutSDA"); }
MEDLOADER_EXPORT static MEDFileInt32Field1TSWithoutSDA *New(const std::string& fieldName, const std::string& meshName, int csit, int iteration, int order, const std::vector<std::string>& infos);
- MEDLOADER_EXPORT MEDFileInt32Field1TSWithoutSDA *deepCopy() const;
- MEDLOADER_EXPORT MEDFileInt32Field1TSWithoutSDA *shallowCpy() const;
- MEDLOADER_EXPORT const char *getTypeStr() const;
- MEDLOADER_EXPORT DataArray *getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<mcIdType,mcIdType> > >& entries) const;
+ MEDLOADER_EXPORT MEDFileInt32Field1TSWithoutSDA *deepCopy() const override;
+ MEDLOADER_EXPORT MEDFileInt32Field1TSWithoutSDA *shallowCpy() const override;
+ MEDLOADER_EXPORT const char *getTypeStr() const override;
+ MEDLOADER_EXPORT DataArray *getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<mcIdType,mcIdType> > >& entries) const override;
MEDLOADER_EXPORT DataArrayInt32 *getUndergroundDataArrayIntExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<mcIdType,mcIdType> > >& entries) const;
protected:
MEDFileInt32Field1TSWithoutSDA(const std::string& fieldName, const std::string& meshName, int csit, int iteration, int order, const std::vector<std::string>& infos);
MEDLOADER_EXPORT MEDFileInt64Field1TSWithoutSDA();
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileInt64Field1TSWithoutSDA"); }
MEDLOADER_EXPORT static MEDFileInt64Field1TSWithoutSDA *New(const std::string& fieldName, const std::string& meshName, int csit, int iteration, int order, const std::vector<std::string>& infos);
- MEDLOADER_EXPORT MEDFileInt64Field1TSWithoutSDA *deepCopy() const;
- MEDLOADER_EXPORT MEDFileInt64Field1TSWithoutSDA *shallowCpy() const;
- MEDLOADER_EXPORT const char *getTypeStr() const;
- MEDLOADER_EXPORT DataArray *getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<mcIdType,mcIdType> > >& entries) const;
+ MEDLOADER_EXPORT MEDFileInt64Field1TSWithoutSDA *deepCopy() const override;
+ MEDLOADER_EXPORT MEDFileInt64Field1TSWithoutSDA *shallowCpy() const override;
+ MEDLOADER_EXPORT const char *getTypeStr() const override;
+ MEDLOADER_EXPORT DataArray *getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<mcIdType,mcIdType> > >& entries) const override;
MEDLOADER_EXPORT DataArrayInt64 *getUndergroundDataArrayIntExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<mcIdType,mcIdType> > >& entries) const;
protected:
MEDFileInt64Field1TSWithoutSDA(const std::string& fieldName, const std::string& meshName, int csit, int iteration, int order, const std::vector<std::string>& infos);
MEDLOADER_EXPORT MEDFileFloatField1TSWithoutSDA();
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileFloatField1TSWithoutSDA"); }
MEDLOADER_EXPORT static MEDFileFloatField1TSWithoutSDA *New(const std::string& fieldName, const std::string& meshName, int csit, int iteration, int order, const std::vector<std::string>& infos);
- MEDLOADER_EXPORT MEDFileFloatField1TSWithoutSDA *deepCopy() const;
- MEDLOADER_EXPORT MEDFileFloatField1TSWithoutSDA *shallowCpy() const;
- MEDLOADER_EXPORT const char *getTypeStr() const;
- MEDLOADER_EXPORT DataArray *getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<mcIdType,mcIdType> > >& entries) const;
+ MEDLOADER_EXPORT MEDFileFloatField1TSWithoutSDA *deepCopy() const override;
+ MEDLOADER_EXPORT MEDFileFloatField1TSWithoutSDA *shallowCpy() const override;
+ MEDLOADER_EXPORT const char *getTypeStr() const override;
+ MEDLOADER_EXPORT DataArray *getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<mcIdType,mcIdType> > >& entries) const override;
MEDLOADER_EXPORT DataArrayFloat *getUndergroundDataArrayFloatExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<mcIdType,mcIdType> > >& entries) const;
protected:
MEDFileFloatField1TSWithoutSDA(const std::string& fieldName, const std::string& meshName, int csit, int iteration, int order, const std::vector<std::string>& infos);
{
protected:
MEDLOADER_EXPORT MEDFileAnyTypeField1TS();
- MEDLOADER_EXPORT MEDFileAnyTypeField1TS(med_idt fid, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities=0);
- MEDLOADER_EXPORT MEDFileAnyTypeField1TS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities=0);
- MEDLOADER_EXPORT MEDFileAnyTypeField1TS(med_idt fid, const std::string& fieldName, int iteration, int order, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities=0);
+ MEDLOADER_EXPORT MEDFileAnyTypeField1TS(med_idt fid, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities=nullptr);
+ MEDLOADER_EXPORT MEDFileAnyTypeField1TS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities=nullptr);
+ MEDLOADER_EXPORT MEDFileAnyTypeField1TS(med_idt fid, const std::string& fieldName, int iteration, int order, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities=nullptr);
MEDLOADER_EXPORT MEDFileAnyTypeField1TS(const MEDFileAnyTypeField1TSWithoutSDA& other, bool shallowCopyOfContent);
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileAnyTypeField1TS"); }
MEDLOADER_EXPORT static MEDFileAnyTypeField1TS *BuildNewInstanceFromContent(MEDFileAnyTypeField1TSWithoutSDA *c);
MEDLOADER_EXPORT static MEDFileAnyTypeField1TSWithoutSDA *BuildContentFrom(med_idt fid, const std::string& fieldName, int iteration, int order, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities);
MEDLOADER_EXPORT static MEDFileAnyTypeField1TSWithoutSDA *BuildContentFrom(med_idt fid, const std::string& fieldName, int iteration, int order, const PartDefinition *pd, const MEDFileEntities *entities);
MEDLOADER_EXPORT static MEDFileAnyTypeField1TSWithoutSDA *AllocateContentFrom(med_idt fid, const std::string& fieldName, int iteration=-1, int order=-1);
- MEDLOADER_EXPORT void writeLL(med_idt fid) const;
+ MEDLOADER_EXPORT void writeLL(med_idt fid) const override;
// direct forwarding to MEDFileAnyTypeField1TSWithoutSDA instance _content
public:
MEDLOADER_EXPORT static MEDFileAnyTypeField1TS *New(const std::string& fileName, bool loadAll=true);
MEDLOADER_EXPORT void setProfileNameOnLeaf(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId, const std::string& newPflName, bool forceRenameOnGlob=false);
//! underground method see MEDFileField1TSWithoutSDA::setLocNameOnLeaf
MEDLOADER_EXPORT void setLocNameOnLeaf(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId, const std::string& newLocName, bool forceRenameOnGlob=false);
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- MEDLOADER_EXPORT std::vector<std::string> getPflsReallyUsed() const;
- MEDLOADER_EXPORT std::vector<std::string> getLocsReallyUsed() const;
- MEDLOADER_EXPORT std::vector<std::string> getPflsReallyUsedMulti() const;
- MEDLOADER_EXPORT std::vector<std::string> getLocsReallyUsedMulti() const;
- MEDLOADER_EXPORT void changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif);
- MEDLOADER_EXPORT void changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif);
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ MEDLOADER_EXPORT std::vector<std::string> getPflsReallyUsed() const override;
+ MEDLOADER_EXPORT std::vector<std::string> getLocsReallyUsed() const override;
+ MEDLOADER_EXPORT std::vector<std::string> getPflsReallyUsedMulti() const override;
+ MEDLOADER_EXPORT std::vector<std::string> getLocsReallyUsedMulti() const override;
+ MEDLOADER_EXPORT void changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) override;
+ MEDLOADER_EXPORT void changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) override;
public:
MEDLOADER_EXPORT static int LocateField2(med_idt fid, int fieldIdCFormat, bool checkFieldId, std::string& fieldName, med_field_type& typcha, std::vector<std::string>& infos, std::string& dtunitOut, std::string& meshName);
MEDLOADER_EXPORT static int LocateField(med_idt fid, const std::string& fieldName, int& posCFormat, med_field_type& typcha, std::vector<std::string>& infos, std::string& dtunitOut, std::string& meshName);
MEDLOADER_EXPORT void setFieldProfile(const typename Traits<T>::FieldType *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayIdType *profile);
MEDLOADER_EXPORT void setFieldProfileFlatly(const typename Traits<T>::FieldType *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayIdType *profile);
MEDLOADER_EXPORT typename MLFieldTraits<T>::F1TSType *extractPartImpl(const std::map<int, MCAuto<DataArrayIdType> >& extractDef, MEDFileMesh *mm) const;
- MEDLOADER_EXPORT MEDFileAnyTypeField1TS *extractPart(const std::map<int, MCAuto<DataArrayIdType> >& extractDef, MEDFileMesh *mm) const { return this->extractPartImpl(extractDef,mm); }
+ MEDLOADER_EXPORT MEDFileAnyTypeField1TS *extractPart(const std::map<int, MCAuto<DataArrayIdType> >& extractDef, MEDFileMesh *mm) const override { return this->extractPartImpl(extractDef,mm); }
protected:
- ~MEDFileTemplateField1TS() { }
+ ~MEDFileTemplateField1TS() override = default;
MEDFileTemplateField1TS();
MEDFileTemplateField1TS(med_idt fid, bool loadAll, const MEDFileMeshes *ms):MEDFileAnyTypeField1TS(fid,loadAll,ms) { }
MEDFileTemplateField1TS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms):MEDFileAnyTypeField1TS(fid,fieldName,loadAll,ms) { }
MEDLOADER_EXPORT MEDFileInt32Field1TS *convertToInt(bool isDeepCpyGlobs=true) const;
MEDLOADER_EXPORT MEDFileInt64Field1TS *convertToInt64(bool isDeepCpyGlobs=true) const;
public:
- MEDLOADER_EXPORT MCAuto<MEDFileAnyTypeField1TS> buildNewEmpty() const;
- MEDLOADER_EXPORT MEDFileField1TS *shallowCpy() const;
+ MEDLOADER_EXPORT MCAuto<MEDFileAnyTypeField1TS> buildNewEmpty() const override;
+ MEDLOADER_EXPORT MEDFileField1TS *shallowCpy() const override;
MEDLOADER_EXPORT std::vector< std::vector<DataArrayDouble *> > getFieldSplitedByType2(const std::string& mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF,
std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const;
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileField1TS"); }
public:
private:
- med_field_type getMEDFileFieldType() const { return MED_FLOAT64; }
+ med_field_type getMEDFileFieldType() const override { return MED_FLOAT64; }
private:
- ~MEDFileField1TS() { }
+ ~MEDFileField1TS() override = default;
MEDFileField1TS(med_idt fid, bool loadAll, const MEDFileMeshes *ms);
MEDFileField1TS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms);
MEDFileField1TS(med_idt fid, const std::string& fieldName, int iteration, int order, bool loadAll, const MEDFileMeshes *ms);
MEDLOADER_EXPORT MEDFileField1TS *convertToInt(bool isDeepCpyGlobs=true) const;
MEDLOADER_EXPORT MEDFileField1TS *convertToInt64(bool isDeepCpyGlobs=true) const;
protected:
- ~MEDFileNDTemplateField1TS() { }
+ ~MEDFileNDTemplateField1TS() override = default;
MEDFileNDTemplateField1TS() { }
MEDFileNDTemplateField1TS(med_idt fid, bool loadAll, const MEDFileMeshes *ms):MEDFileTemplateField1TS<T>(fid,loadAll,ms) { }
MEDFileNDTemplateField1TS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms):MEDFileTemplateField1TS<T>(fid,fieldName,loadAll,ms) { }
{
friend class MEDFileTemplateField1TS<Int32>;
public:
- MEDLOADER_EXPORT MCAuto<MEDFileAnyTypeField1TS> buildNewEmpty() const;
- MEDLOADER_EXPORT MEDFileInt32Field1TS *shallowCpy() const { return new MEDFileInt32Field1TS(*this); }
+ MEDLOADER_EXPORT MCAuto<MEDFileAnyTypeField1TS> buildNewEmpty() const override;
+ MEDLOADER_EXPORT MEDFileInt32Field1TS *shallowCpy() const override { return new MEDFileInt32Field1TS(*this); }
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileInt32Field1TS"); }
public:
MEDLOADER_EXPORT static MCAuto<MEDCouplingFieldDouble> ConvertFieldIntToFieldDouble(const MEDCouplingFieldInt32 *f);
private:
- med_field_type getMEDFileFieldType() const { return MED_INT32; }
+ med_field_type getMEDFileFieldType() const override { return MED_INT32; }
private:
- ~MEDFileInt32Field1TS() { }
+ ~MEDFileInt32Field1TS() override = default;
MEDFileInt32Field1TS() { }
MEDFileInt32Field1TS(med_idt fid, bool loadAll, const MEDFileMeshes *ms):MEDFileNDTemplateField1TS<Int32>(fid,loadAll,ms) { }
MEDFileInt32Field1TS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms):MEDFileNDTemplateField1TS<Int32>(fid,fieldName,loadAll,ms) { }
{
friend class MEDFileTemplateField1TS<Int64>;
public:
- MEDLOADER_EXPORT MCAuto<MEDFileAnyTypeField1TS> buildNewEmpty() const;
- MEDLOADER_EXPORT MEDFileInt64Field1TS *shallowCpy() const { return new MEDFileInt64Field1TS(*this); }
+ MEDLOADER_EXPORT MCAuto<MEDFileAnyTypeField1TS> buildNewEmpty() const override;
+ MEDLOADER_EXPORT MEDFileInt64Field1TS *shallowCpy() const override { return new MEDFileInt64Field1TS(*this); }
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileInt64Field1TS"); }
public:
MEDLOADER_EXPORT static MCAuto<MEDCouplingFieldDouble> ConvertFieldIntToFieldDouble(const MEDCouplingFieldInt64 *f);
private:
- med_field_type getMEDFileFieldType() const { return MED_INT64; }
+ med_field_type getMEDFileFieldType() const override { return MED_INT64; }
private:
- ~MEDFileInt64Field1TS() { }
+ ~MEDFileInt64Field1TS() override = default;
MEDFileInt64Field1TS() { }
MEDFileInt64Field1TS(med_idt fid, bool loadAll, const MEDFileMeshes *ms):MEDFileNDTemplateField1TS<Int64>(fid,loadAll,ms) { }
MEDFileInt64Field1TS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms):MEDFileNDTemplateField1TS<Int64>(fid,fieldName,loadAll,ms) { }
{
friend class MEDFileTemplateField1TS<float>;
private:
- med_field_type getMEDFileFieldType() const { return MED_FLOAT32; }
- MEDLOADER_EXPORT MEDFileFloatField1TS *shallowCpy() const { return new MEDFileFloatField1TS(*this); }
+ med_field_type getMEDFileFieldType() const override { return MED_FLOAT32; }
+ MEDLOADER_EXPORT MEDFileFloatField1TS *shallowCpy() const override { return new MEDFileFloatField1TS(*this); }
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileFloatField1TS"); }
- MEDLOADER_EXPORT MCAuto<MEDFileAnyTypeField1TS> buildNewEmpty() const;
+ MEDLOADER_EXPORT MCAuto<MEDFileAnyTypeField1TS> buildNewEmpty() const override;
private:
- ~MEDFileFloatField1TS() { }
+ ~MEDFileFloatField1TS() override = default;
MEDFileFloatField1TS() { }
MEDFileFloatField1TS(med_idt fid, bool loadAll, const MEDFileMeshes *ms):MEDFileNDTemplateField1TS<float>(fid,loadAll,ms) { }
MEDFileFloatField1TS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms):MEDFileNDTemplateField1TS<float>(fid,fieldName,loadAll,ms) { }
// Author : Anthony Geay (EDF R&D)
#include "MEDFileFieldGlobs.hxx"
-#include "MEDFileField.txx"
+#include "MCAuto.hxx"
+#include "MEDFileBasis.hxx"
+#include "MEDCouplingRefCountObject.hxx"
#include "MEDFileMesh.hxx"
#include "MEDLoaderBase.hxx"
-#include "MEDLoaderTraits.hxx"
#include "MEDFileSafeCaller.txx"
#include "MEDFileFieldOverView.hxx"
-#include "MEDFileBlowStrEltUp.hxx"
-#include "MEDFileFieldVisitor.hxx"
+#include "MEDFileFieldInternal.hxx"
-#include "MEDCouplingMemArray.txx"
#include "MEDCouplingFieldDiscretization.hxx"
#include "MCType.hxx"
#include "InterpKernelAutoPtr.hxx"
-#include "CellModel.hxx"
+#include "med.h"
+#include "medprofile.h"
+#include "medlocalization.h"
+#include "NormalizedGeometricTypes"
#include <algorithm>
+#include <cstddef>
#include <iterator>
+#include <map>
+#include <string>
+#include <vector>
+#include <sstream>
+#include <ostream>
+#include <utility>
using namespace MEDCoupling;
if(id>=(int)_pfls.size())
_pfls.resize(id+1);
MCAuto<DataArrayMedInt> miPfl=DataArrayMedInt::New();
- med_int lgth(MEDprofileSizeByName(fid,pflName.c_str()));
+ med_int const lgth(MEDprofileSizeByName(fid,pflName.c_str()));
miPfl->setName(pflName);
miPfl->alloc(lgth,1);
MEDFILESAFECALLERRD0(MEDprofileRd,(fid,pflName.c_str(),miPfl->getPointer()));
INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
med_int sz;
MEDFILESAFECALLERRD0(MEDprofileInfo,(fid,i+1,pflName,&sz));
- std::string pflCpp=MEDLoaderBase::buildStringFromFortran(pflName,MED_NAME_SIZE);
+ std::string const pflCpp=MEDLoaderBase::buildStringFromFortran(pflName,MED_NAME_SIZE);
if(i>=(int)_pfls.size())
_pfls.resize(i+1);
MCAuto<DataArrayMedInt> miPfl=DataArrayMedInt::New();
void MEDFileFieldGlobs::writeGlobals(med_idt fid, const MEDFileWritable& opt) const
{
- std::size_t nbOfPfls=_pfls.size();
+ std::size_t const nbOfPfls=_pfls.size();
for(std::size_t i=0;i<nbOfPfls;i++)
{
MCAuto<DataArrayMedInt> cpy=DataArrayMedInt_Copy((const DataArrayIdType*)_pfls[i]);
MEDFILESAFECALLERWR0(MEDprofileWr,(fid,pflName,ToMedInt(_pfls[i]->getNumberOfTuples()),cpy->getConstPointer()));
}
//
- std::size_t nbOfLocs=_locs.size();
+ std::size_t const nbOfLocs=_locs.size();
for(std::size_t i=0;i<nbOfLocs;i++)
_locs[i]->writeLL(fid);
}
void MEDFileFieldGlobs::appendGlobs(const MEDFileFieldGlobs& other, double eps)
{
std::vector<std::string> pfls=getPfls();
- for(std::vector< MCAuto<DataArrayIdType> >::const_iterator it=other._pfls.begin();it!=other._pfls.end();it++)
+ for(const auto & _pfl : other._pfls)
{
- std::vector<std::string>::iterator it2=std::find(pfls.begin(),pfls.end(),(*it)->getName());
+ auto const it2=std::find(pfls.begin(),pfls.end(),_pfl->getName());
if(it2==pfls.end())
{
- _pfls.push_back(*it);
+ _pfls.push_back(_pfl);
}
else
{
- std::size_t id=std::distance(pfls.begin(),it2);
- if(!(*it)->isEqual(*_pfls[id]))
+ std::size_t const id=std::distance(pfls.begin(),it2);
+ if(!_pfl->isEqual(*_pfls[id]))
{
- std::ostringstream oss; oss << "MEDFileFieldGlobs::appendGlobs : Profile \"" << (*it)->getName() << "\" already exists and is different from those expecting to be append !";
+ std::ostringstream oss; oss << "MEDFileFieldGlobs::appendGlobs : Profile \"" << _pfl->getName() << "\" already exists and is different from those expecting to be append !";
throw INTERP_KERNEL::Exception(oss.str());
}
}
}
std::vector<std::string> locs=getLocs();
- for(std::vector< MCAuto<MEDFileFieldLoc> >::const_iterator it=other._locs.begin();it!=other._locs.end();it++)
+ for(const auto & _loc : other._locs)
{
- std::vector<std::string>::iterator it2=std::find(locs.begin(),locs.end(),(*it)->getName());
+ auto const it2=std::find(locs.begin(),locs.end(),_loc->getName());
if(it2==locs.end())
{
- _locs.push_back(*it);
+ _locs.push_back(_loc);
}
else
{
- std::size_t id=std::distance(locs.begin(),it2);
- if(!(*it)->isEqual(*_locs[id],eps))
+ std::size_t const id=std::distance(locs.begin(),it2);
+ if(!_loc->isEqual(*_locs[id],eps))
{
- std::ostringstream oss; oss << "MEDFileFieldGlobs::appendGlobs : Localization \"" << (*it)->getName() << "\" already exists and is different from those expecting to be append !";
+ std::ostringstream oss; oss << "MEDFileFieldGlobs::appendGlobs : Localization \"" << _loc->getName() << "\" already exists and is different from those expecting to be append !";
throw INTERP_KERNEL::Exception(oss.str());
}
}
void MEDFileFieldGlobs::checkGlobsPflsPartCoherency(const std::vector<std::string>& pflsUsed) const
{
- for(std::vector<std::string>::const_iterator it=pflsUsed.begin();it!=pflsUsed.end();it++)
- getProfile((*it).c_str());
+ for(const auto & it : pflsUsed)
+ getProfile(it.c_str());
}
void MEDFileFieldGlobs::checkGlobsLocsPartCoherency(const std::vector<std::string>& locsUsed) const
{
- for(std::vector<std::string>::const_iterator it=locsUsed.begin();it!=locsUsed.end();it++)
- getLocalization((*it).c_str());
+ for(const auto & it : locsUsed)
+ getLocalization(it.c_str());
}
void MEDFileFieldGlobs::loadGlobals(med_idt fid, const MEDFileFieldGlobsReal& real)
for(unsigned int i=0;i<sz;i++)
loadProfileInFile(fid,i,profiles[i].c_str());
//
- std::vector<std::string> locs=real.getLocsReallyUsed();
+ std::vector<std::string> const locs=real.getLocsReallyUsed();
sz=locs.size();
_locs.resize(sz);
for(std::size_t i=0;i<sz;i++)
void MEDFileFieldGlobs::loadAllGlobals(med_idt fid, const MEDFileEntities *entities)
{
- med_int nProfil=MEDnProfile(fid);
+ med_int const nProfil=MEDnProfile(fid);
for(int i=0;i<nProfil;i++)
loadProfileInFile(fid,i);
- med_int sz=MEDnLocalization(fid);
+ med_int const sz=MEDnLocalization(fid);
_locs.resize(sz);
for(int i=0;i<sz;i++)
{
std::vector<const BigMemoryObject *> MEDFileFieldGlobs::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
- for(std::vector< MCAuto< DataArrayIdType > >::const_iterator it=_pfls.begin();it!=_pfls.end();it++)
- ret.push_back((const DataArrayIdType *)*it);
- for(std::vector< MCAuto<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++)
- ret.push_back((const MEDFileFieldLoc *)*it);
+ for(const auto & _pfl : _pfls)
+ ret.push_back((const DataArrayIdType *)_pfl);
+ for(const auto & _loc : _locs)
+ ret.push_back((const MEDFileFieldLoc *)_loc);
return ret;
}
{
MCAuto<MEDFileFieldGlobs> ret=new MEDFileFieldGlobs(*this);
std::size_t i=0;
- for(std::vector< MCAuto<DataArrayIdType> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
+ for(auto it=_pfls.begin();it!=_pfls.end();it++,i++)
{
if((const DataArrayIdType *)*it)
ret->_pfls[i]=(*it)->deepCopy();
}
i=0;
- for(std::vector< MCAuto<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++,i++)
+ for(auto it=_locs.begin();it!=_locs.end();it++,i++)
{
if((const MEDFileFieldLoc*)*it)
ret->_locs[i]=(*it)->deepCopy();
MEDFileFieldGlobs *MEDFileFieldGlobs::shallowCpyPart(const std::vector<std::string>& pfls, const std::vector<std::string>& locs) const
{
MCAuto<MEDFileFieldGlobs> ret=MEDFileFieldGlobs::New();
- for(std::vector<std::string>::const_iterator it1=pfls.begin();it1!=pfls.end();it1++)
+ for(const auto & it1 : pfls)
{
- DataArrayIdType *pfl=const_cast<DataArrayIdType *>(getProfile((*it1).c_str()));
+ DataArrayIdType *pfl=const_cast<DataArrayIdType *>(getProfile(it1.c_str()));
if(!pfl)
throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::shallowCpyPart : internal error ! pfl null !");
pfl->incrRef();
- MCAuto<DataArrayIdType> pfl2(pfl);
+ MCAuto<DataArrayIdType> const pfl2(pfl);
ret->_pfls.push_back(pfl2);
}
- for(std::vector<std::string>::const_iterator it2=locs.begin();it2!=locs.end();it2++)
+ for(const auto & it2 : locs)
{
- MEDFileFieldLoc *loc=const_cast<MEDFileFieldLoc *>(&getLocalization((*it2).c_str()));
+ MEDFileFieldLoc *loc=const_cast<MEDFileFieldLoc *>(&getLocalization(it2.c_str()));
if(!loc)
throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::shallowCpyPart : internal error ! loc null !");
loc->incrRef();
- MCAuto<MEDFileFieldLoc> loc2(loc);
+ MCAuto<MEDFileFieldLoc> const loc2(loc);
ret->_locs.push_back(loc2);
}
ret->setFileName(getFileName());
MEDFileFieldGlobs *MEDFileFieldGlobs::deepCpyPart(const std::vector<std::string>& pfls, const std::vector<std::string>& locs) const
{
MCAuto<MEDFileFieldGlobs> ret=MEDFileFieldGlobs::New();
- for(std::vector<std::string>::const_iterator it1=pfls.begin();it1!=pfls.end();it1++)
+ for(const auto & it1 : pfls)
{
- DataArrayIdType *pfl=const_cast<DataArrayIdType *>(getProfile((*it1).c_str()));
+ DataArrayIdType *pfl=const_cast<DataArrayIdType *>(getProfile(it1.c_str()));
if(!pfl)
throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::deepCpyPart : internal error ! pfl null !");
ret->_pfls.push_back(pfl->deepCopy());
}
- for(std::vector<std::string>::const_iterator it2=locs.begin();it2!=locs.end();it2++)
+ for(const auto & it2 : locs)
{
- MEDFileFieldLoc *loc=const_cast<MEDFileFieldLoc *>(&getLocalization((*it2).c_str()));
+ MEDFileFieldLoc *loc=const_cast<MEDFileFieldLoc *>(&getLocalization(it2.c_str()));
if(!loc)
throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::deepCpyPart : internal error ! loc null !");
ret->_locs.push_back(loc->deepCopy());
}
MEDFileFieldGlobs::MEDFileFieldGlobs()
-{
-}
+= default;
MEDFileFieldGlobs::~MEDFileFieldGlobs()
-{
-}
+= default;
void MEDFileFieldGlobs::simpleRepr(std::ostream& oss) const
{
void MEDFileFieldGlobs::changePflsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
{
- for(std::vector< MCAuto<DataArrayIdType> >::iterator it=_pfls.begin();it!=_pfls.end();it++)
+ for(auto & _pfl : _pfls)
{
- DataArrayIdType *elt(*it);
+ DataArrayIdType *elt(_pfl);
if(elt)
{
- std::string name(elt->getName());
- for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
+ std::string const name(elt->getName());
+ for(const auto & it2 : mapOfModif)
{
- if(std::find((*it2).first.begin(),(*it2).first.end(),name)!=(*it2).first.end())
+ if(std::find(it2.first.begin(),it2.first.end(),name)!=it2.first.end())
{
- elt->setName((*it2).second.c_str());
+ elt->setName(it2.second.c_str());
return;
}
}
void MEDFileFieldGlobs::changeLocsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
{
- for(std::vector< MCAuto<MEDFileFieldLoc> >::iterator it=_locs.begin();it!=_locs.end();it++)
+ for(auto & _loc : _locs)
{
- MEDFileFieldLoc *elt(*it);
+ MEDFileFieldLoc *elt(_loc);
if(elt)
{
- std::string name(elt->getName());
- for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
+ std::string const name(elt->getName());
+ for(const auto & it2 : mapOfModif)
{
- if(std::find((*it2).first.begin(),(*it2).first.end(),name)!=(*it2).first.end())
+ if(std::find(it2.first.begin(),it2.first.end(),name)!=it2.first.end())
{
- elt->setName((*it2).second.c_str());
+ elt->setName(it2.second.c_str());
return;
}
}
int MEDFileFieldGlobs::getLocalizationId(const std::string& loc) const
{
- std::vector< MCAuto<MEDFileFieldLoc> >::const_iterator it=std::find_if(_locs.begin(),_locs.end(),MEDCouplingImpl::LocFinder(loc));
+ auto it=std::find_if(_locs.begin(),_locs.end(),MEDCouplingImpl::LocFinder(loc));
if(it==_locs.end())
{
std::ostringstream oss; oss << "MEDFileFieldGlobs::getLocalisationId : no such localisation name : \"" << loc << "\" Possible localizations are : ";
int MEDFileFieldGlobs::getProfileId(const std::string& pfl) const
{
- std::vector< MCAuto<DataArrayIdType> >::const_iterator it=std::find_if(_pfls.begin(),_pfls.end(),MEDCouplingImpl::PflFinder(pfl));
+ auto it=std::find_if(_pfls.begin(),_pfls.end(),MEDCouplingImpl::PflFinder(pfl));
if(it==_pfls.end())
{
std::ostringstream oss; oss << "MEDFileFieldGlobs::getProfileId : no such profile name : \"" << pfl << "\" Possible localizations are : ";
*/
DataArrayIdType *MEDFileFieldGlobs::getProfile(const std::string& pflName)
{
- std::string pflNameCpp(pflName);
- std::vector< MCAuto<DataArrayIdType> >::iterator it=std::find_if(_pfls.begin(),_pfls.end(),MEDCouplingImpl::PflFinder(pflNameCpp));
+ std::string const pflNameCpp(pflName);
+ auto it=std::find_if(_pfls.begin(),_pfls.end(),MEDCouplingImpl::PflFinder(pflNameCpp));
if(it==_pfls.end())
{
std::ostringstream oss; oss << "MEDFileFieldGlobs::getProfile: no such profile name : \"" << pflNameCpp << "\" Possible profiles are : ";
void MEDFileFieldGlobs::killStructureElementsInGlobs()
{
std::vector< MCAuto<MEDFileFieldLoc> > newLocs;
- for(std::vector< MCAuto<MEDFileFieldLoc> >::iterator it=_locs.begin();it!=_locs.end();it++)
+ for(auto & _loc : _locs)
{
- if((*it).isNull())
+ if(_loc.isNull())
continue;
- if(!(*it)->isOnStructureElement())
- newLocs.push_back(*it);
+ if(!_loc->isOnStructureElement())
+ newLocs.push_back(_loc);
}
_locs=newLocs;
}
std::vector<std::string> MEDFileFieldGlobs::getPfls() const
{
- std::size_t sz=_pfls.size();
+ std::size_t const sz=_pfls.size();
std::vector<std::string> ret(sz);
for(std::size_t i=0;i<sz;i++)
ret[i]=_pfls[i]->getName();
std::vector<std::string> MEDFileFieldGlobs::getLocs() const
{
- std::size_t sz=_locs.size();
+ std::size_t const sz=_locs.size();
std::vector<std::string> ret(sz);
for(std::size_t i=0;i<sz;i++)
ret[i]=_locs[i]->getName();
bool MEDFileFieldGlobs::existsPfl(const std::string& pflName) const
{
std::vector<std::string> v=getPfls();
- std::string s(pflName);
+ std::string const s(pflName);
return std::find(v.begin(),v.end(),s)!=v.end();
}
bool MEDFileFieldGlobs::existsLoc(const std::string& locName) const
{
std::vector<std::string> v=getLocs();
- std::string s(locName);
+ std::string const s(locName);
return std::find(v.begin(),v.end(),s)!=v.end();
}
{
std::map<mcIdType,std::vector<int> > m;
int i=0;
- for(std::vector< MCAuto<DataArrayIdType> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
+ for(auto it=_pfls.begin();it!=_pfls.end();it++,i++)
{
const DataArrayIdType *tmp=(*it);
if(tmp)
{
std::vector<int> ret0;
bool equalityOrNot=false;
- for(std::vector<int>::const_iterator it3=(*it2).second.begin();it3!=(*it2).second.end();it3++)
+ for(auto it3=(*it2).second.begin();it3!=(*it2).second.end();it3++)
{
- std::vector<int>::const_iterator it4=it3; it4++;
+ auto it4=it3; it4++;
for(;it4!=(*it2).second.end();it4++)
{
if(_pfls[*it3]->isEqualWithoutConsideringStr(*_pfls[*it4]))
return ret;
}
-std::vector< std::vector<int> > MEDFileFieldGlobs::whichAreEqualLocs(double eps) const
+std::vector< std::vector<int> > MEDFileFieldGlobs::whichAreEqualLocs(double /*eps*/) const
{
throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::whichAreEqualLocs : no implemented yet ! Sorry !");
}
void MEDFileFieldGlobs::appendProfile(DataArrayIdType *pfl)
{
- std::string name(pfl->getName());
+ std::string const name(pfl->getName());
if(name.empty())
throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::appendProfile : unsupported profiles with no name !");
- for(std::vector< MCAuto<DataArrayIdType> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++)
- if(name==(*it)->getName())
+ for(const auto & _pfl : _pfls)
+ if(name==_pfl->getName())
{
- if(!pfl->isEqual(*(*it)))
+ if(!pfl->isEqual(*_pfl))
{
std::ostringstream oss; oss << "MEDFileFieldGlobs::appendProfile : profile \"" << name << "\" already exists and is different from existing !";
throw INTERP_KERNEL::Exception(oss.str());
void MEDFileFieldGlobs::appendLoc(const std::string& locName, INTERP_KERNEL::NormalizedCellType geoType, const std::vector<double>& refCoo, const std::vector<double>& gsCoo, const std::vector<double>& w)
{
- std::string name(locName);
+ std::string const name(locName);
if(name.empty())
throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::appendLoc : unsupported localizations with no name !");
MCAuto<MEDFileFieldLoc> obj=MEDFileFieldLoc::New(locName,geoType,refCoo,gsCoo,w);
- for(std::vector< MCAuto<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++)
- if((*it)->isName(locName))
+ for(const auto & _loc : _locs)
+ if(_loc->isName(locName))
{
- if(!(*it)->isEqual(*obj,1e-12))
+ if(!_loc->isEqual(*obj,1e-12))
{
std::ostringstream oss; oss << "MEDFileFieldGlobs::appendLoc : localization \"" << name << "\" already exists and is different from existing !";
throw INTERP_KERNEL::Exception(oss.str());
std::string MEDFileFieldGlobs::createNewNameOfPfl() const
{
- std::vector<std::string> names=getPfls();
+ std::vector<std::string> const names=getPfls();
return CreateNewNameNotIn("NewPfl_",names);
}
std::string MEDFileFieldGlobs::createNewNameOfLoc() const
{
- std::vector<std::string> names=getLocs();
+ std::vector<std::string> const names=getLocs();
return CreateNewNameNotIn("NewLoc_",names);
}
{
const MEDFileFieldGlobs *glob=_globals;
std::ostringstream oss2; oss2 << glob;
- std::string stars(oss2.str().length(),'*');
+ std::string const stars(oss2.str().length(),'*');
oss << "Globals information on fields (at " << oss2.str() << "):" << "\n************************************" << stars << "\n\n";
if(glob)
glob->simpleRepr(oss);
}
MEDFileFieldGlobsReal::~MEDFileFieldGlobsReal()
-{
-}
+= default;
/*!
* Copies references to profiles and Gauss points from another MEDFileFieldGlobsReal.
void MEDFileFieldGlobsReal::changePflName(const std::string& oldName, const std::string& newName)
{
std::vector< std::pair<std::vector<std::string>, std::string > > mapOfModif(1);
- std::pair<std::vector<std::string>, std::string > p(std::vector<std::string>(1,std::string(oldName)),std::string(newName));
+ std::pair<std::vector<std::string>, std::string > const p(std::vector<std::string>(1,std::string(oldName)),std::string(newName));
mapOfModif[0]=p;
changePflsNames(mapOfModif);
}
void MEDFileFieldGlobsReal::changeLocName(const std::string& oldName, const std::string& newName)
{
std::vector< std::pair<std::vector<std::string>, std::string > > mapOfModif(1);
- std::pair<std::vector<std::string>, std::string > p(std::vector<std::string>(1,std::string(oldName)),std::string(newName));
+ std::pair<std::vector<std::string>, std::string > const p(std::vector<std::string>(1,std::string(oldName)),std::string(newName));
mapOfModif[0]=p;
changeLocsNames(mapOfModif);
}
{
std::vector< std::string > tmp((*it).size());
int j=0;
- for(std::vector<int>::const_iterator it2=(*it).begin();it2!=(*it).end();it2++,j++)
+ for(auto it2=(*it).begin();it2!=(*it).end();it2++,j++)
tmp[j]=std::string(getProfileFromId(*it2)->getName());
- std::pair<std::vector<std::string>, std::string > p(tmp,tmp.front());
+ std::pair<std::vector<std::string>, std::string > const p(tmp,tmp.front());
ret[i]=p;
- std::vector<int> tmp2((*it).begin()+1,(*it).end());
+ std::vector<int> const tmp2((*it).begin()+1,(*it).end());
killProfileIds(tmp2);
}
changePflsRefsNamesGen(ret);
{
std::vector< std::string > tmp((*it).size());
int j=0;
- for(std::vector<int>::const_iterator it2=(*it).begin();it2!=(*it).end();it2++,j++)
+ for(auto it2=(*it).begin();it2!=(*it).end();it2++,j++)
tmp[j]=std::string(getLocalizationFromId(*it2).getName());
- std::pair<std::vector<std::string>, std::string > p(tmp,tmp.front());
+ std::pair<std::vector<std::string>, std::string > const p(tmp,tmp.front());
ret[i]=p;
- std::vector<int> tmp2((*it).begin()+1,(*it).end());
+ std::vector<int> const tmp2((*it).begin()+1,(*it).end());
killLocalizationIds(tmp2);
}
changeLocsRefsNamesGen(ret);
//= MEDFileFieldNameScope
MEDFileFieldNameScope::MEDFileFieldNameScope()
-{
-}
+= default;
MEDFileFieldNameScope::MEDFileFieldNameScope(const std::string& fieldName, const std::string& meshName):_name(fieldName),_mesh_name(meshName)
{
#ifndef __MEDFILEFIELDGLOBS_HXX__
#define __MEDFILEFIELDGLOBS_HXX__
+#include "MEDCouplingRefCountObject.hxx"
+#include "MCType.hxx"
#include "MEDLoaderDefines.hxx"
#include "NormalizedGeometricTypes"
-#include "MEDCouplingMemArray.hxx"
#include "MCAuto.hxx"
#include "med.h"
+#include <string>
+#include <cstddef>
+#include <vector>
+#include <ostream>
+#include <utility>
namespace MEDCoupling
{
static MEDFileFieldGlobs *New(med_idt fid);
static MEDFileFieldGlobs *New();
std::string getClassName() const override { return std::string("MEDFileFieldGlobs"); }
- std::size_t getHeapMemorySizeWithoutChildren() const;
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
MEDFileFieldGlobs *deepCopy() const;
MEDFileFieldGlobs *shallowCpyPart(const std::vector<std::string>& pfls, const std::vector<std::string>& locs) const;
MEDFileFieldGlobs *deepCpyPart(const std::vector<std::string>& pfls, const std::vector<std::string>& locs) const;
protected:
MEDFileFieldGlobs(med_idt fid);
MEDFileFieldGlobs();
- ~MEDFileFieldGlobs();
+ ~MEDFileFieldGlobs() override;
protected:
std::vector< MCAuto<DataArrayIdType> > _pfls;
std::vector< MCAuto<MEDFileFieldLoc> > _locs;
MEDLOADER_EXPORT void loadProfileInFile(med_idt fid, int id, const std::string& pflName);
MEDLOADER_EXPORT void loadProfileInFile(med_idt fid, int id);
MEDLOADER_EXPORT void loadGlobals(med_idt fid);
- MEDLOADER_EXPORT void loadAllGlobals(med_idt fid, const MEDFileEntities *entities=0);
+ MEDLOADER_EXPORT void loadAllGlobals(med_idt fid, const MEDFileEntities *entities=nullptr);
MEDLOADER_EXPORT void writeGlobals(med_idt fid, const MEDFileWritable& opt) const;
MEDLOADER_EXPORT std::vector<std::string> getPfls() const;
MEDLOADER_EXPORT std::vector<std::string> getLocs() const;
// Author : Anthony Geay (EDF R&D)
#include "MEDFileFieldInternal.hxx"
+#include "InterpKernelAutoPtr.hxx"
+#include "MEDFileBasis.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MCAuto.hxx"
+#include "MCIdType.hxx"
+#include "MEDCouplingFieldDiscretization.hxx"
+#include "MEDCouplingPartDefinition.hxx"
#include "MEDFileField.hxx"
#include "MEDFileFieldVisitor.hxx"
#include "MEDFileStructureElement.hxx"
#include "MEDFilterEntity.hxx"
#include "CellModel.hxx"
+#include "med.h"
+#include "NormalizedGeometricTypes"
+#include <string>
+#include <sstream>
+#include <vector>
+#include "medlocalization.h"
+#include <iterator>
+#include <algorithm>
+#include "medmesh.h"
+#include <cstddef>
+#include <ostream>
+#include <limits>
+#include "medfield.h"
+#include <set>
+#include <utility>
+#include <map>
+#include <list>
// From MEDLOader.cxx TU
extern med_geometry_type typmai[MED_N_CELL_FIXED_GEO];
using namespace MEDCoupling;
MEDFileGTKeeper::~MEDFileGTKeeper()
-{
-}
+= default;
MEDFileGTKeeper *MEDFileGTKeeperSta::deepCopy() const
{
bool MEDFileGTKeeperSta::isEqual(const MEDFileGTKeeper *other) const
{
- const MEDFileGTKeeperSta *otherC(dynamic_cast<const MEDFileGTKeeperSta *>(other));
+ const auto *otherC(dynamic_cast<const MEDFileGTKeeperSta *>(other));
if(!otherC)
return false;
return _geo_type==otherC->_geo_type;
bool MEDFileGTKeeperDyn::isEqual(const MEDFileGTKeeper *other) const
{
- const MEDFileGTKeeperDyn *otherC(dynamic_cast<const MEDFileGTKeeperDyn *>(other));
+ const auto *otherC(dynamic_cast<const MEDFileGTKeeperDyn *>(other));
if(!otherC)
return false;
return this==otherC;
_dim=FromMedInt<int>(dim);
_nb_gauss_pt=FromMedInt<int>(nb_gauss_pt);
_name=locName;
- std::string sectionName(MEDLoaderBase::buildStringFromFortran(sectionmeshname,MED_NAME_SIZE));
+ std::string const sectionName(MEDLoaderBase::buildStringFromFortran(sectionmeshname,MED_NAME_SIZE));
if(sectionName.empty())
{
_gt=new MEDFileGTKeeperSta((INTERP_KERNEL::NormalizedCellType)(std::distance(typmai3,std::find(typmai3,typmai3+INTERP_KERNEL::NORM_MAXTYPE,geotype))));
}
else
{
- const MEDFileAllStaticEntitiesPlusDyn *entities2(dynamic_cast<const MEDFileAllStaticEntitiesPlusDyn *>(entities));
+ const auto *entities2(dynamic_cast<const MEDFileAllStaticEntitiesPlusDyn *>(entities));
if(!entities2)
{
std::ostringstream oss; oss << "MEDFileFieldLoc cstr : for loc \"" << _name << "\" presence of non static type ! Expect entities !";
const MEDFileGTKeeper *gt(_gt);
if(!gt)
throw INTERP_KERNEL::Exception("MEDFileFieldLoc::isOnStructureElement : null pointer !");
- const MEDFileGTKeeperDyn *gt2(dynamic_cast<const MEDFileGTKeeperDyn *>(gt));
- return gt2!=NULL;
+ const auto *gt2(dynamic_cast<const MEDFileGTKeeperDyn *>(gt));
+ return gt2!=nullptr;
}
std::size_t MEDFileFieldLoc::getHeapMemorySizeWithoutChildren() const
std::size_t sz=_ref_coo.size();
if(sz%_dim==0)
{
- std::size_t nbOfTuples=sz/_dim;
+ std::size_t const nbOfTuples=sz/_dim;
for(std::size_t i=0;i<nbOfTuples;i++)
{
oss << "(";
sz=_gs_coo.size();
if(sz%_dim==0)
{
- std::size_t nbOfTuples=sz/_dim;
+ std::size_t const nbOfTuples=sz/_dim;
for(std::size_t i=0;i<nbOfTuples;i++)
{
oss << "(";
{
const MEDCouplingFieldDiscretization *disc(field->getDiscretization());
const MEDCouplingGaussLocalization& gsLoc(field->getGaussLocalization(FromIdType<int>(_loc_id)));
- const MEDCouplingFieldDiscretizationGauss *disc2(dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc));
+ const auto *disc2(dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc));
if(!disc2)
throw INTERP_KERNEL::Exception("assignFieldNoProfile : invalid call to this method ! Internal Error !");
const DataArrayIdType *dai(disc2->getArrayOfDiscIds());
MCAuto<DataArrayIdType> dai2(disc2->getOffsetArr(field->getMesh()));
const mcIdType *dai2Ptr(dai2->getConstPointer());
- mcIdType nbi(ToIdType(gsLoc.getWeights().size()));
+ mcIdType const nbi(ToIdType(gsLoc.getWeights().size()));
MCAuto<DataArrayIdType> da2(dai->selectByTupleIdSafeSlice(offset,offset+nbOfCells,1));
MCAuto<DataArrayIdType> da3(da2->findIdsEqual(_loc_id));
const mcIdType *da3Ptr(da3->getConstPointer());
mcIdType *da4Ptr(da4->getPointer());
for(mcIdType i=0;i<_nval;i++)
{
- mcIdType ref=dai2Ptr[offset+da3Ptr[i]];
+ mcIdType const ref=dai2Ptr[offset+da3Ptr[i]];
for(mcIdType j=0;j<nbi;j++)
*da4Ptr++=ref+j;
}
{
_profile.clear();
_type=field->getTypeOfField();
- std::string pflName(multiTypePfl->getName());
+ std::string const pflName(multiTypePfl->getName());
std::ostringstream oss; oss << pflName;
if(_type!=ON_NODES)
{
MCAuto<DataArrayIdType> arr3=arr2->selectByTupleId(multiTypePfl->begin(),multiTypePfl->end());
arr3->computeOffsetsFull();
MCAuto<DataArrayIdType> tmp=idsInPfl->buildExplicitArrByRanges(arr3);
- mcIdType trueNval=tmp->getNumberOfTuples();
+ mcIdType const trueNval=tmp->getNumberOfTuples();
_nval=idsInPfl->getNumberOfTuples();
getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,tmp);
_end=_start+trueNval;
}
case ON_GAUSS_PT:
{
- const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(field->getDiscretization());
+ const auto *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(field->getDiscretization());
if(!disc2)
throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
const DataArrayIdType *da1=disc2->getArrayOfDiscIds();
start=_end;
}
-void MEDFileFieldPerMeshPerTypePerDisc::assignNodeFieldNoProfile(mcIdType& start, const MEDCouplingFieldTemplate *field, const DataArray *arrr, MEDFileFieldGlobsReal& glob)
+void MEDFileFieldPerMeshPerTypePerDisc::assignNodeFieldNoProfile(mcIdType& start, const MEDCouplingFieldTemplate * /*field*/, const DataArray *arrr, MEDFileFieldGlobsReal& /*glob*/)
{
_start=start;
_nval=arrr->getNumberOfTuples();
throw e;
}
-MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(MEDFileFieldPerMeshPerTypeCommon *fath, TypeOfField type, mcIdType locId, const std::string& dummy):_type(type),_father(fath),_loc_id(locId)
+MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(MEDFileFieldPerMeshPerTypeCommon *fath, TypeOfField type, mcIdType locId, const std::string& /*dummy*/):_type(type),_father(fath),_loc_id(locId)
{
}
-MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(const MEDFileFieldPerMeshPerTypePerDisc& other):RefCountObject(other),_type(other._type),_father(0),_start(other._start),_end(other._end),_nval(other._nval),_profile(other._profile),_localization(other._localization),_loc_id(other._loc_id),_profile_it(other._profile_it),_pd(other._pd),_tmp_work1(other._tmp_work1)
+MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(const MEDFileFieldPerMeshPerTypePerDisc& other):RefCountObject(other),_type(other._type),_father(nullptr),_start(other._start),_end(other._end),_nval(other._nval),_profile(other._profile),_localization(other._localization),_loc_id(other._loc_id),_profile_it(other._profile_it),_pd(other._pd),_tmp_work1(other._tmp_work1)
{
}
-MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc():_type(ON_CELLS),_father(0),_start(-std::numeric_limits<mcIdType>::max()),_end(-std::numeric_limits<mcIdType>::max()),
+MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc():_type(ON_CELLS),_father(nullptr),_start(-std::numeric_limits<mcIdType>::max()),_end(-std::numeric_limits<mcIdType>::max()),
_nval(-std::numeric_limits<mcIdType>::max()),_loc_id(-std::numeric_limits<int>::max())
{
}
throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::goReadZeValuesInFile : not implemented !");
INTERP_KERNEL::AutoPtr<char> pflname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE)),locname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
med_int profilesize,nbi;
- med_int overallNval(MEDfieldnValueWithProfile(fid,fieldName.c_str(),iteration,order,menti,mgeoti,FromIdType<int>(_profile_it+1),MED_COMPACT_PFLMODE,pflname,&profilesize,locname,&nbi));
+ med_int const overallNval(MEDfieldnValueWithProfile(fid,fieldName.c_str(),iteration,order,menti,mgeoti,FromIdType<int>(_profile_it+1),MED_COMPACT_PFLMODE,pflname,&profilesize,locname,&nbi));
{//TODO : manage int32 !
pd->checkConsistencyLight();
INTERP_KERNEL::AutoPtr<char> pflname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
std::string fieldName(nasc.getName()),meshName(getMeshName());
med_int iteration(getIteration()),order(getOrder()),profilesize,nbi;
- TypeOfField type(getType());
+ TypeOfField const type(getType());
med_geometry_type mgeoti;
med_entity_type menti;
_father->entriesForMEDfile(type,mgeoti,menti);
med_int zeNVal(MEDfieldnValueWithProfile(fid,fieldName.c_str(),iteration,order,menti,mgeoti,FromIdType<int>(_profile_it+1),MED_COMPACT_PFLMODE,pflname,&profilesize,locname,&nbi));
if(zeNVal==0 && type==ON_CELLS)
{//eheh maybe there's a surprise :)
- med_int zeNVal1(MEDfieldnValueWithProfile(fid,fieldName.c_str(),iteration,order,MED_DESCENDING_FACE,mgeoti,FromIdType<int>(_profile_it+1),MED_COMPACT_PFLMODE,pflname,&profilesize,locname,&nbi));
+ med_int const zeNVal1(MEDfieldnValueWithProfile(fid,fieldName.c_str(),iteration,order,MED_DESCENDING_FACE,mgeoti,FromIdType<int>(_profile_it+1),MED_COMPACT_PFLMODE,pflname,&profilesize,locname,&nbi));
if(zeNVal1==0)
{
- med_int zeNVal2(MEDfieldnValueWithProfile(fid,fieldName.c_str(),iteration,order,MED_DESCENDING_EDGE,mgeoti,FromIdType<int>(_profile_it+1),MED_COMPACT_PFLMODE,pflname,&profilesize,locname,&nbi));
+ med_int const zeNVal2(MEDfieldnValueWithProfile(fid,fieldName.c_str(),iteration,order,MED_DESCENDING_EDGE,mgeoti,FromIdType<int>(_profile_it+1),MED_COMPACT_PFLMODE,pflname,&profilesize,locname,&nbi));
if(zeNVal2!=0)
zeNVal=zeNVal2;
}
{
std::string fieldName(nasc.getName()),meshName(getMeshName());
int iteration(getIteration()),order(getOrder());
- TypeOfField type(getType());
+ TypeOfField const type(getType());
med_geometry_type mgeoti;
med_entity_type menti;
_father->entriesForMEDfile(type,mgeoti,menti);
std::ostringstream oss; oss << "MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : Invalid start ("<< _start << ") regarding admissible range of allocated array [0," << arr->getNumberOfTuples() << "] !";
throw INTERP_KERNEL::Exception(oss.str());
}
- int nbOfCompo((int)arr->getNumberOfComponents());
- DataArrayDouble *arrD(dynamic_cast<DataArrayDouble *>(arr));
+ int const nbOfCompo((int)arr->getNumberOfComponents());
+ auto *arrD(dynamic_cast<DataArrayDouble *>(arr));
if(arrD)
{
double *startFeeding(arrD->getPointer()+_start*nbOfCompo);
goReadZeValuesInFile(fid,fieldName,nbOfCompo,iteration,order,menti,mgeoti,reinterpret_cast<unsigned char*>(startFeeding));
return ;
}
- DataArrayInt32 *arrI(dynamic_cast<DataArrayInt32 *>(arr));
+ auto *arrI(dynamic_cast<DataArrayInt32 *>(arr));
if(arrI)
{
Int32 *startFeeding(arrI->getPointer()+_start*nbOfCompo);
goReadZeValuesInFile(fid,fieldName,nbOfCompo,iteration,order,menti,mgeoti,reinterpret_cast<unsigned char*>(startFeeding));
return ;
}
- DataArrayInt64 *arrI64(dynamic_cast<DataArrayInt64 *>(arr));
+ auto *arrI64(dynamic_cast<DataArrayInt64 *>(arr));
if(arrI64)
{
Int64 *startFeeding(arrI64->getPointer()+_start*nbOfCompo);
goReadZeValuesInFile(fid,fieldName,nbOfCompo,iteration,order,menti,mgeoti,reinterpret_cast<unsigned char*>(startFeeding));
return ;
}
- DataArrayFloat *arrF(dynamic_cast<DataArrayFloat *>(arr));
+ auto *arrF(dynamic_cast<DataArrayFloat *>(arr));
if(arrF)
{
float *startFeeding(arrF->getPointer()+_start*nbOfCompo);
*/
void MEDFileFieldPerMeshPerTypePerDisc::setNewStart(mcIdType newValueOfStart)
{
- mcIdType delta=_end-_start;
+ mcIdType const delta=_end-_start;
_start=newValueOfStart;
_end=_start+delta;
}
void MEDFileFieldPerMeshPerTypePerDisc::incrementNbOfVals(mcIdType deltaNbVal)
{
- mcIdType nbi((_end-_start)/_nval);
+ mcIdType const nbi((_end-_start)/_nval);
_nval+=deltaNbVal;
_end+=nbi*deltaNbVal;
}
void MEDFileFieldPerMeshPerTypePerDisc::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
{
- for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
+ for(const auto & it2 : mapOfModif)
{
- if(std::find((*it2).first.begin(),(*it2).first.end(),_profile)!=(*it2).first.end())
+ if(std::find(it2.first.begin(),it2.first.end(),_profile)!=it2.first.end())
{
- _profile=(*it2).second;
+ _profile=it2.second;
return;
}
}
void MEDFileFieldPerMeshPerTypePerDisc::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
{
- for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
+ for(const auto & it2 : mapOfModif)
{
- if(std::find((*it2).first.begin(),(*it2).first.end(),_localization)!=(*it2).first.end())
+ if(std::find(it2.first.begin(),it2.first.end(),_localization)!=it2.first.end())
{
- _localization=(*it2).second;
+ _localization=it2.second;
return;
}
}
dads.push_back(std::pair<mcIdType,mcIdType>(_start,_end));
geoTypes.push_back(getGeoType());
if(_profile.empty())
- pfls.push_back(0);
+ pfls.push_back(nullptr);
else
{
pfls.push_back(glob->getProfile(_profile.c_str()));
throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::writeLL : no array set !");
if(!arr->isAllocated())
throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::writeLL : the array to be written is not allocated !");
- const DataArrayDouble *arrD(dynamic_cast<const DataArrayDouble *>(arr));
- const DataArrayInt32 *arrI(dynamic_cast<const DataArrayInt32 *>(arr));
- const DataArrayInt64 *arrI64(dynamic_cast<const DataArrayInt64 *>(arr));
- const DataArrayFloat *arrF(dynamic_cast<const DataArrayFloat *>(arr));
- const unsigned char *locToWrite=0;
+ const auto *arrD(dynamic_cast<const DataArrayDouble *>(arr));
+ const auto *arrI(dynamic_cast<const DataArrayInt32 *>(arr));
+ const auto *arrI64(dynamic_cast<const DataArrayInt64 *>(arr));
+ const auto *arrF(dynamic_cast<const DataArrayFloat *>(arr));
+ const unsigned char *locToWrite=nullptr;
if(arrD)
locToWrite=reinterpret_cast<const unsigned char *>(arrD->getConstPointer()+_start*arr->getNumberOfComponents());
else if(arrI)
{
_loc_id=FromIdType<int>(offset);
std::ostringstream oss;
- std::size_t nbOfType=codeOfMesh.size()/3;
+ std::size_t const nbOfType=codeOfMesh.size()/3;
int found=-1;
for(std::size_t i=0;i<nbOfType && found==-1;i++)
if(getGeoType()==(INTERP_KERNEL::NormalizedCellType)codeOfMesh[3*i])
oss << pfl->getNumberOfTuples() << " whereas the number of ids is set to " << _nval << " for this geometric type !";
throw INTERP_KERNEL::Exception(oss.str());
}
- mcIdType offset2=codeOfMesh[3*found+2];
- for(const mcIdType *pflId=pfl->begin();pflId!=pfl->end();pflId++)
+ mcIdType const offset2=codeOfMesh[3*found+2];
+ for(long const pflId : *pfl)
{
- if(*pflId<codeOfMesh[3*found+1])
- *work++=offset2+*pflId;
+ if(pflId<codeOfMesh[3*found+1])
+ *work++=offset2+pflId;
}
}
return _nval;
int id=0;
std::map<std::pair<std::string,TypeOfField>,int> m;
std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > ret;
- for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entries.begin();it!=entries.end();it++)
- if(m.find(std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType()))==m.end())
- m[std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType())]=id++;
+ for(auto entrie : entries)
+ if(m.find(std::pair<std::string,TypeOfField>(entrie->getLocalization(),entrie->getType()))==m.end())
+ m[std::pair<std::string,TypeOfField>(entrie->getLocalization(),entrie->getType())]=id++;
ret.resize(id);
- for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entries.begin();it!=entries.end();it++)
- ret[m[std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType())]].push_back(*it);
+ for(auto entrie : entries)
+ ret[m[std::pair<std::string,TypeOfField>(entrie->getLocalization(),entrie->getType())]].push_back(entrie);
return ret;
}
{
if(entriesOnSameDisc.empty())
return false;
- TypeOfField type=entriesOnSameDisc[0]->getType();
+ TypeOfField const type=entriesOnSameDisc[0]->getType();
mcIdType szEntities=0,szTuples=0;
- for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesOnSameDisc.begin();it!=entriesOnSameDisc.end();it++)
- { szEntities+=(*it)->_nval; szTuples+=(*it)->_end-(*it)->_start; }
- mcIdType nbi=szTuples/szEntities;
+ for(auto it : entriesOnSameDisc)
+ { szEntities+=it->_nval; szTuples+=it->_end-it->_start; }
+ mcIdType const nbi=szTuples/szEntities;
if(szTuples%szEntities!=0)
throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks : internal error the splitting into same dicretization failed !");
MCAuto<DataArrayIdType> renumTuples=DataArrayIdType::New(); renumTuples->alloc(szTuples,1);
std::vector< const DataArrayIdType * > newGeoTypesPerChunk3(entriesOnSameDisc.size());
MCAuto<DataArrayIdType> newGeoTypesPerChunk4=DataArrayIdType::New(); newGeoTypesPerChunk4->alloc(szEntities,nbi);
int id=0;
- for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesOnSameDisc.begin();it!=entriesOnSameDisc.end();it++,id++)
+ for(auto it=entriesOnSameDisc.begin();it!=entriesOnSameDisc.end();it++,id++)
{
- mcIdType startOfEltIdOfChunk=(*it)->_start;
+ mcIdType const startOfEltIdOfChunk=(*it)->_start;
MCAuto<DataArrayIdType> newEltIds=explicitIdsInMesh->subArray(startOfEltIdOfChunk,startOfEltIdOfChunk+(*it)->_nval);
MCAuto<DataArrayIdType> rangeIdsForChunk=newEltIds->findRangeIdForEachTuple(ranges);
MCAuto<DataArrayIdType> idsInRrangeForChunk=newEltIds->findIdInRangeForEachTuple(ranges);
MCAuto<DataArrayIdType> newGeoTypesEltIdsAllGather=DataArrayIdType::Aggregate(newGeoTypesPerChunk2); newGeoTypesPerChunk.clear(); newGeoTypesPerChunk2.clear();
MCAuto<DataArrayIdType> newGeoTypesEltIdsAllGather2=DataArrayIdType::Aggregate(newGeoTypesPerChunk3); newGeoTypesPerChunk_bis.clear(); newGeoTypesPerChunk3.clear();
MCAuto<DataArrayIdType> diffVals=newGeoTypesEltIdsAllGather->getDifferentValues();
- MCAuto<DataArrayIdType> renumEltIds=newGeoTypesEltIdsAllGather->buildPermArrPerLevel();
+ MCAuto<DataArrayIdType> const renumEltIds=newGeoTypesEltIdsAllGather->buildPermArrPerLevel();
//
MCAuto<DataArrayIdType> renumTupleIds=newGeoTypesPerChunk4->buildPermArrPerLevel();
//
{
MCAuto<DataArrayIdType> ids=newGeoTypesEltIdsAllGather->findIdsEqual(*idIt);
MCAuto<DataArrayIdType> subIds=newGeoTypesEltIdsAllGather2->selectByTupleId(ids->begin(),ids->end());
- mcIdType nbEntityElts=subIds->getNumberOfTuples();
+ mcIdType const nbEntityElts=subIds->getNumberOfTuples();
bool ret2;
- MCAuto<MEDFileFieldPerMeshPerTypePerDisc> eltToAdd=MEDFileFieldPerMeshPerTypePerDisc::
+ MCAuto<MEDFileFieldPerMeshPerTypePerDisc> const eltToAdd=MEDFileFieldPerMeshPerTypePerDisc::
NewObjectOnSameDiscThanPool(type,(INTERP_KERNEL::NormalizedCellType)newCode[3*(*idIt)],subIds,!subIds->isIota(newCode[3*(*idIt)+1]),nbi,
offset+offset2,
li,glob,ret2);
MEDFileFieldGlobsReal& glob,
bool ¬InExisting)
{
- mcIdType nbMeshEntities=idsOfMeshElt->getNumberOfTuples();
- std::list< const MEDFileFieldPerMeshPerTypePerDisc *>::iterator it=entriesOnSameDisc.begin();
+ mcIdType const nbMeshEntities=idsOfMeshElt->getNumberOfTuples();
+ auto it=entriesOnSameDisc.begin();
for(;it!=entriesOnSameDisc.end();it++)
{
if(((INTERP_KERNEL::NormalizedCellType)(*it)->_loc_id)==geoType && (*it)->_nval==nbMeshEntities)
if(it==entriesOnSameDisc.end())
{
notInExisting=true;
- MEDFileFieldPerMeshPerTypePerDisc *ret=new MEDFileFieldPerMeshPerTypePerDisc;
+ auto *ret=new MEDFileFieldPerMeshPerTypePerDisc;
ret->_type=typeF;
ret->_loc_id=(int)geoType;
ret->_nval=nbMeshEntities;
////////////////////////////////////
MEDFileFieldPerMeshPerTypeCommon::~MEDFileFieldPerMeshPerTypeCommon()
-{
-}
+= default;
void MEDFileFieldPerMeshPerTypeCommon::setFather(MEDFileFieldPerMesh *father)
{
void MEDFileFieldPerMeshPerTypeCommon::accept(MEDFileFieldVisitor& visitor) const
{
- for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
- if((*it).isNotNull())
+ for(const auto & it : _field_pm_pt_pd)
+ if(it.isNotNull())
{
- visitor.newPerMeshPerTypePerDisc(*it);
+ visitor.newPerMeshPerTypePerDisc(it);
}
}
std::vector<const BigMemoryObject *> MEDFileFieldPerMeshPerTypeCommon::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
- for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
- ret.push_back((const MEDFileFieldPerMeshPerTypePerDisc *)*it);
+ for(const auto & it : _field_pm_pt_pd)
+ ret.push_back((const MEDFileFieldPerMeshPerTypePerDisc *)it);
return ret;
}
void MEDFileFieldPerMeshPerTypeCommon::assignFieldNoProfile(mcIdType& start, mcIdType offset, mcIdType nbOfCells, const MEDCouplingFieldTemplate *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
{
- std::vector<mcIdType> pos=addNewEntryIfNecessary(field,offset,nbOfCells);
- for(std::vector<mcIdType>::const_iterator it=pos.begin();it!=pos.end();it++)
- _field_pm_pt_pd[*it]->assignFieldNoProfile(start,offset,nbOfCells,field,arr,glob,nasc);
+ std::vector<mcIdType> const pos=addNewEntryIfNecessary(field,offset,nbOfCells);
+ for(long const po : pos)
+ _field_pm_pt_pd[po]->assignFieldNoProfile(start,offset,nbOfCells,field,arr,glob,nasc);
}
/*!
*/
void MEDFileFieldPerMeshPerTypeCommon::assignFieldProfile(bool isPflAlone, mcIdType& start, const DataArrayIdType *multiTypePfl, const DataArrayIdType *idsInPfl, DataArrayIdType *locIds, mcIdType nbOfEltsInWholeMesh, const MEDCouplingFieldTemplate *field, const DataArray *arr, const MEDCouplingMesh *mesh, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
{
- std::vector<mcIdType> pos=addNewEntryIfNecessary(field,idsInPfl);
- for(std::vector<mcIdType>::const_iterator it=pos.begin();it!=pos.end();it++)
- _field_pm_pt_pd[*it]->assignFieldProfile(isPflAlone,start,multiTypePfl,idsInPfl,locIds,nbOfEltsInWholeMesh,field,arr,mesh,glob,nasc);
+ std::vector<mcIdType> const pos=addNewEntryIfNecessary(field,idsInPfl);
+ for(long const po : pos)
+ _field_pm_pt_pd[po]->assignFieldProfile(isPflAlone,start,multiTypePfl,idsInPfl,locIds,nbOfEltsInWholeMesh,field,arr,mesh,glob,nasc);
}
void MEDFileFieldPerMeshPerTypeCommon::assignNodeFieldNoProfile(mcIdType& start, const MEDCouplingFieldTemplate *field, const DataArray *arr, MEDFileFieldGlobsReal& glob)
throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypeCommon::assignNodeFieldProfile : input array is null, or not allocated !");
_field_pm_pt_pd.resize(1);
_field_pm_pt_pd[0]=MEDFileFieldPerMeshPerTypePerDisc::New(this,ON_NODES,-3);
- _field_pm_pt_pd[0]->assignFieldProfile(true,start,pfl,pfl2,pfl2,-1,field,arr,0,glob,nasc);//mesh is not requested so 0 is send.
+ _field_pm_pt_pd[0]->assignFieldProfile(true,start,pfl,pfl2,pfl2,-1,field,arr,nullptr,glob,nasc);//mesh is not requested so 0 is send.
}
std::vector<mcIdType> MEDFileFieldPerMeshPerTypeCommon::addNewEntryIfNecessary(const MEDCouplingFieldTemplate *field, mcIdType offset, mcIdType nbOfCells)
{
- TypeOfField type=field->getTypeOfField();
+ TypeOfField const type=field->getTypeOfField();
if(type!=ON_GAUSS_PT)
{
- int locIdToFind=MEDFileFieldPerMeshPerTypePerDisc::ConvertType(type,0);
- std::size_t sz=_field_pm_pt_pd.size();
+ int const locIdToFind=MEDFileFieldPerMeshPerTypePerDisc::ConvertType(type,0);
+ std::size_t const sz=_field_pm_pt_pd.size();
bool found=false;
for(std::size_t j=0;j<sz && !found;j++)
{
else
{
std::vector<mcIdType> ret2=addNewEntryIfNecessaryGauss(field,offset,nbOfCells);
- std::size_t sz2=ret2.size();
+ std::size_t const sz2=ret2.size();
std::vector<mcIdType> ret3(sz2);
mcIdType k=0;
for(std::size_t i=0;i<sz2;i++)
{
- mcIdType sz=ToIdType(_field_pm_pt_pd.size());
- mcIdType locIdToFind=ret2[i];
+ mcIdType const sz=ToIdType(_field_pm_pt_pd.size());
+ mcIdType const locIdToFind=ret2[i];
bool found=false;
for(mcIdType j=0;j<sz && !found;j++)
{
std::vector<mcIdType> MEDFileFieldPerMeshPerTypeCommon::addNewEntryIfNecessaryGauss(const MEDCouplingFieldTemplate *field, mcIdType offset, mcIdType nbOfCells)
{
const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
- const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
+ const auto *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
if(!disc2)
throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
const DataArrayIdType *da=disc2->getArrayOfDiscIds();
std::vector<mcIdType> MEDFileFieldPerMeshPerTypeCommon::addNewEntryIfNecessary(const MEDCouplingFieldTemplate *field, const DataArrayIdType *subCells)
{
- TypeOfField type=field->getTypeOfField();
+ TypeOfField const type=field->getTypeOfField();
if(type!=ON_GAUSS_PT)
{
- int locIdToFind=MEDFileFieldPerMeshPerTypePerDisc::ConvertType(type,0);
- std::size_t sz=_field_pm_pt_pd.size();
+ int const locIdToFind=MEDFileFieldPerMeshPerTypePerDisc::ConvertType(type,0);
+ std::size_t const sz=_field_pm_pt_pd.size();
bool found=false;
for(std::size_t j=0;j<sz && !found;j++)
{
else
{
std::vector<mcIdType> ret2=addNewEntryIfNecessaryGauss(field,subCells);
- std::size_t sz2=ret2.size();
+ std::size_t const sz2=ret2.size();
std::vector<mcIdType> ret3(sz2);
mcIdType k=0;
for(std::size_t i=0;i<sz2;i++)
{
- mcIdType sz=ToIdType(_field_pm_pt_pd.size());
- mcIdType locIdToFind=ret2[i];
+ mcIdType const sz=ToIdType(_field_pm_pt_pd.size());
+ mcIdType const locIdToFind=ret2[i];
bool found=false;
for(mcIdType j=0;j<sz && !found;j++)
{
std::vector<mcIdType> MEDFileFieldPerMeshPerTypeCommon::addNewEntryIfNecessaryGauss(const MEDCouplingFieldTemplate *field, const DataArrayIdType *subCells)
{
const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
- const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
+ const auto *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
if(!disc2)
throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
const DataArrayIdType *da=disc2->getArrayOfDiscIds();
bool MEDFileFieldPerMeshPerTypeCommon::isUniqueLevel(int& dim) const
{
const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(getGeoType()));
- int curDim((int)cm.getDimension());
+ int const curDim((int)cm.getDimension());
if(dim!=std::numeric_limits<int>::max())
{
if(dim!=curDim)
void MEDFileFieldPerMeshPerTypeCommon::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const
{
- for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
+ for(const auto & it : _field_pm_pt_pd)
{
- (*it)->fillTypesOfFieldAvailable(types);
+ it->fillTypesOfFieldAvailable(types);
}
}
void MEDFileFieldPerMeshPerTypeCommon::fillFieldSplitedByType(std::vector< std::pair<mcIdType,mcIdType> >& dads, std::vector<TypeOfField>& types, std::vector<std::string>& pfls, std::vector<std::string>& locs) const
{
- std::size_t sz=_field_pm_pt_pd.size();
+ std::size_t const sz=_field_pm_pt_pd.size();
dads.resize(sz); types.resize(sz); pfls.resize(sz); locs.resize(sz);
for(std::size_t i=0;i<sz;i++)
{
void MEDFileFieldPerMeshPerTypeCommon::getSizes(mcIdType& globalSz, mcIdType& nbOfEntries) const
{
- for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
+ for(const auto & it : _field_pm_pt_pd)
{
- globalSz+=(*it)->getNumberOfTuples();
+ globalSz+=it->getNumberOfTuples();
}
nbOfEntries+=(mcIdType)_field_pm_pt_pd.size();
}
bool MEDFileFieldPerMeshPerTypeCommon::presenceOfMultiDiscPerGeoType() const
{
std::size_t nb(0);
- for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
+ for(const auto & it : _field_pm_pt_pd)
{
- const MEDFileFieldPerMeshPerTypePerDisc *fmtd(*it);
+ const MEDFileFieldPerMeshPerTypePerDisc *fmtd(it);
if(fmtd)
nb++;
}
{
std::vector<std::string> ret;
std::set<std::string> ret2;
- for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
+ for(const auto & it1 : _field_pm_pt_pd)
{
- std::string tmp=(*it1)->getProfile();
+ std::string const tmp=it1->getProfile();
if(!tmp.empty())
if(ret2.find(tmp)==ret2.end())
{
{
std::vector<std::string> ret;
std::set<std::string> ret2;
- for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
+ for(const auto & it1 : _field_pm_pt_pd)
{
- std::string tmp=(*it1)->getLocalization();
+ std::string const tmp=it1->getLocalization();
if(!tmp.empty() && tmp!=MED_GAUSS_ELNO)
if(ret2.find(tmp)==ret2.end())
{
std::vector<std::string> MEDFileFieldPerMeshPerTypeCommon::getPflsReallyUsedMulti() const
{
std::vector<std::string> ret;
- std::set<std::string> ret2;
- for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
+ std::set<std::string> const ret2;
+ for(const auto & it1 : _field_pm_pt_pd)
{
- std::string tmp=(*it1)->getProfile();
+ std::string const tmp=it1->getProfile();
if(!tmp.empty())
ret.push_back(tmp);
}
std::vector<std::string> MEDFileFieldPerMeshPerTypeCommon::getLocsReallyUsedMulti() const
{
std::vector<std::string> ret;
- for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
+ for(const auto & it1 : _field_pm_pt_pd)
{
- std::string tmp=(*it1)->getLocalization();
+ std::string const tmp=it1->getLocalization();
if(!tmp.empty() && tmp!=MED_GAUSS_ELNO)
ret.push_back(tmp);
}
void MEDFileFieldPerMeshPerTypeCommon::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
{
- for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
- (*it1)->changePflsRefsNamesGen(mapOfModif);
+ for(auto & it1 : _field_pm_pt_pd)
+ it1->changePflsRefsNamesGen(mapOfModif);
}
void MEDFileFieldPerMeshPerTypeCommon::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
{
- for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
- (*it1)->changeLocsRefsNamesGen(mapOfModif);
+ for(auto & it1 : _field_pm_pt_pd)
+ it1->changeLocsRefsNamesGen(mapOfModif);
}
MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypeCommon::getLeafGivenLocId(mcIdType locId)
std::ostringstream oss2; oss2 << "MEDFileFieldPerMeshPerTypeCommon::getLeafGivenLocId : no such locId available (" << locId;
oss2 << ") for geometric type \"" << getGeoTypeRepr() << "\" It should be in [0," << _field_pm_pt_pd.size() << ") !";
throw INTERP_KERNEL::Exception(oss2.str().c_str());
- return static_cast<MEDFileFieldPerMeshPerTypePerDisc*>(0);
+ return static_cast<MEDFileFieldPerMeshPerTypePerDisc*>(nullptr);
}
const MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypeCommon::getLeafGivenLocId(mcIdType locId) const
std::ostringstream oss2; oss2 << "MEDFileFieldPerMeshPerTypeCommon::getLeafGivenLocId : no such locId available (" << locId;
oss2 << ") for geometric type \"" << getGeoTypeRepr() << "\" It should be in [0," << _field_pm_pt_pd.size() << ") !";
throw INTERP_KERNEL::Exception(oss2.str().c_str());
- return static_cast<const MEDFileFieldPerMeshPerTypePerDisc*>(0);
+ return static_cast<const MEDFileFieldPerMeshPerTypePerDisc*>(nullptr);
}
int MEDFileFieldPerMeshPerTypeCommon::locIdOfLeaf(const MEDFileFieldPerMeshPerTypePerDisc *leaf) const
{
int ret(0);
- for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,ret++)
+ for(auto it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,ret++)
{
const MEDFileFieldPerMeshPerTypePerDisc *cand(*it);
if(cand==leaf)
void MEDFileFieldPerMeshPerTypeCommon::fillValues(mcIdType& startEntryId, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<mcIdType,mcIdType> > >& entries) const
{
int i=0;
- for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
+ for(auto it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
{
(*it)->fillValues(i,startEntryId,entries);
}
void MEDFileFieldPerMeshPerTypeCommon::setLeaves(const std::vector< MCAuto< MEDFileFieldPerMeshPerTypePerDisc > >& leaves)
{
_field_pm_pt_pd=leaves;
- for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
- (*it)->setFather(this);
+ for(auto & it : _field_pm_pt_pd)
+ it->setFather(this);
}
/*!
{
bool ret(false);
std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> > newPmPtPd;
- for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
- if((*it)->getType()==tof)
+ for(auto & it : _field_pm_pt_pd)
+ if(it->getType()==tof)
{
- newPmPtPd.push_back(*it);
- std::pair<mcIdType,mcIdType> bgEnd; bgEnd.first=(*it)->getStart(); bgEnd.second=(*it)->getEnd();
- (*it)->setNewStart(globalNum);
- globalNum=(*it)->getEnd();
+ newPmPtPd.push_back(it);
+ std::pair<mcIdType,mcIdType> bgEnd; bgEnd.first=it->getStart(); bgEnd.second=it->getEnd();
+ it->setNewStart(globalNum);
+ globalNum=it->getEnd();
its.push_back(bgEnd);
ret=true;
}
if(_field_pm_pt_pd.size()<=idOfDisc)
return false;
MCAuto<MEDFileFieldPerMeshPerTypePerDisc> elt(_field_pm_pt_pd[idOfDisc]);
- std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> > newPmPtPd(1,elt);
+ std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> > const newPmPtPd(1,elt);
std::pair<mcIdType,mcIdType> bgEnd; bgEnd.first=_field_pm_pt_pd[idOfDisc]->getStart(); bgEnd.second=_field_pm_pt_pd[idOfDisc]->getEnd();
elt->setNewStart(globalNum);
globalNum=elt->getEnd();
void MEDFileFieldPerMeshPerTypeCommon::loadOnlyStructureOfDataRecursively(med_idt fid, mcIdType &start, const MEDFileFieldNameScope& nasc)
{
- for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
- (*it)->loadOnlyStructureOfDataRecursively(fid,start,nasc);
+ for(auto & it : _field_pm_pt_pd)
+ it->loadOnlyStructureOfDataRecursively(fid,start,nasc);
}
void MEDFileFieldPerMeshPerTypeCommon::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
{
- for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
- (*it)->loadBigArray(fid,nasc);
+ for(auto & it : _field_pm_pt_pd)
+ it->loadBigArray(fid,nasc);
}
void MEDFileFieldPerMeshPerTypeCommon::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const
{
- for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
+ for(const auto & it : _field_pm_pt_pd)
{
- (*it)->copyOptionsFrom(*this);
- (*it)->writeLL(fid,nasc);
+ it->copyOptionsFrom(*this);
+ it->writeLL(fid,nasc);
}
}
if(meshDim!=(int)cm.getDimension())
return ;
}
- for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
- (*it)->getFieldAtLevel(type,glob,dads,pfls,locs,geoTypes);
+ for(const auto & it : _field_pm_pt_pd)
+ it->getFieldAtLevel(type,glob,dads,pfls,locs,geoTypes);
}
INTERP_KERNEL::NormalizedCellType MEDFileFieldPerMeshPerType::getGeoType() const
void MEDFileFieldPerMeshPerType::getDimension(int& dim) const
{
const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(_geo_type));
- int curDim((int)cm.getDimension());
+ int const curDim((int)cm.getDimension());
dim=std::max(dim,curDim);
}
void MEDFileFieldPerMeshPerType::simpleRepr(int bkOffset, std::ostream& oss, int id) const
{
const char startLine[]=" ## ";
- std::string startLine2(bkOffset,' ');
+ std::string const startLine2(bkOffset,' ');
std::string startLine3(startLine2);
startLine3+=startLine;
if(_geo_type!=INTERP_KERNEL::NORM_ERROR)
oss << startLine3 << "Entry geometry type #" << id << " is lying on NODES." << std::endl;
oss << startLine3 << "Entry is defined on " << _field_pm_pt_pd.size() << " localizations." << std::endl;
int i=0;
- for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
+ for(auto it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
{
const MEDFileFieldPerMeshPerTypePerDisc *cur=(*it);
if(cur)
}
if(type==ON_CELLS)
{
- med_int nbProfiles2(MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE_ELEMENT,mgeoti,pflName,locName));
+ med_int const nbProfiles2(MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE_ELEMENT,mgeoti,pflName,locName));
for(int i=0;i<nbProfiles2;i++)
_field_pm_pt_pd.push_back(MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(this,ON_GAUSS_NE,i,pd));
}
return ;
// dark side of the force.
{
- med_int nbProfiles1(MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_DESCENDING_FACE,mgeoti,pflName,locName));
- med_int nbProfiles2(MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_DESCENDING_EDGE,mgeoti,pflName,locName));
+ med_int const nbProfiles1(MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_DESCENDING_FACE,mgeoti,pflName,locName));
+ med_int const nbProfiles2(MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_DESCENDING_EDGE,mgeoti,pflName,locName));
if(nbProfiles1==0 && nbProfiles2==0)
return ;// OK definitely nothing in field
menti=nbProfiles1>=nbProfiles2?MED_DESCENDING_FACE:MED_DESCENDING_EDGE;//not enough words to describe the beauty
{
MCAuto<MEDFileFieldPerMeshPerType> ret(MEDFileFieldPerMeshPerType::New(father,gt));
std::map<TypeOfField, std::vector< std::pair<int,const MEDFileFieldPerMeshPerTypePerDisc * > > > m;
- for(std::vector<std::pair<int,const MEDFileFieldPerMeshPerType *> >::const_iterator it=pms.begin();it!=pms.end();it++)
+ for(const auto & pm : pms)
{
- for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it2=(*it).second->_field_pm_pt_pd.begin();it2!=(*it).second->_field_pm_pt_pd.end();it2++)
- m[(*it2)->getType()].push_back(std::pair<int,const MEDFileFieldPerMeshPerTypePerDisc * >((*it).first,*it2));
+ for(auto it2=pm.second->_field_pm_pt_pd.begin();it2!=pm.second->_field_pm_pt_pd.end();it2++)
+ m[(*it2)->getType()].push_back(std::pair<int,const MEDFileFieldPerMeshPerTypePerDisc * >(pm.first,*it2));
}
for(std::map<TypeOfField, std::vector< std::pair<int,const MEDFileFieldPerMeshPerTypePerDisc * > > >::const_iterator it=m.begin();it!=m.end();it++)
{
- MCAuto<MEDFileFieldPerMeshPerTypePerDisc> agg(MEDFileFieldPerMeshPerTypePerDisc::Aggregate(start,(*it).second,dts,(*it).first,ret,extractInfo));
+ MCAuto<MEDFileFieldPerMeshPerTypePerDisc> const agg(MEDFileFieldPerMeshPerTypePerDisc::Aggregate(start,(*it).second,dts,(*it).first,ret,extractInfo));
ret->_field_pm_pt_pd.push_back(agg);
}
return ret;
{
if(!entities)
throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypeDyn::NewOnRead : null pointer !");
- const MEDFileAllStaticEntitiesPlusDyn *entities2(dynamic_cast<const MEDFileAllStaticEntitiesPlusDyn *>(entities));
+ const auto *entities2(dynamic_cast<const MEDFileAllStaticEntitiesPlusDyn *>(entities));
if(!entities2)
throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypeDyn::NewOnRead : invalid type of entities !");
const MEDFileStructureElement *se(entities2->getWithGT(idGT));
_se.takeRef(se);
INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
INTERP_KERNEL::AutoPtr<char> locName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
- med_int nbProfiles(MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_STRUCT_ELEMENT,_se->getDynGT(),pflName,locName));
+ med_int const nbProfiles(MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_STRUCT_ELEMENT,_se->getDynGT(),pflName,locName));
_field_pm_pt_pd.resize(nbProfiles);
for(int i=0;i<nbProfiles;i++)
{
- _field_pm_pt_pd[i]=MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(this,_se->getEntity(),i,NULL);
+ _field_pm_pt_pd[i]=MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(this,_se->getEntity(),i,nullptr);
}
}
return _se->getName();
}
-void MEDFileFieldPerMeshPerTypeDyn::getDimension(int& dim) const
+void MEDFileFieldPerMeshPerTypeDyn::getDimension(int& /*dim*/) const
{
throw INTERP_KERNEL::Exception("not implemented yet !");
}
-void MEDFileFieldPerMeshPerTypeDyn::entriesForMEDfile(TypeOfField mct, med_geometry_type& gt, med_entity_type& ent) const
+void MEDFileFieldPerMeshPerTypeDyn::entriesForMEDfile(TypeOfField /*mct*/, med_geometry_type& gt, med_entity_type& ent) const
{
gt=getDynGT();
ent=MED_STRUCT_ELEMENT;
void MEDFileFieldPerMeshPerTypeDyn::simpleRepr(int bkOffset, std::ostream& oss, int id) const
{
const char startLine[]=" ## ";
- std::string startLine2(bkOffset,' ');
+ std::string const startLine2(bkOffset,' ');
std::string startLine3(startLine2);
startLine3+=startLine;
oss << startLine3 << "Entry geometry type #" << id << " is lying on geometry STRUCTURE_ELEMENT type " << getDynGT() << "." << std::endl;
oss << startLine3 << "Entry is defined on " << _field_pm_pt_pd.size() << " localizations." << std::endl;
int i=0;
- for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
+ for(auto it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
{
if((*it).isNotNull())
(*it)->simpleRepr(bkOffset,oss,i);
return ret.retn();
}
-void MEDFileFieldPerMeshPerTypeDyn::getFieldAtLevel(int meshDim, TypeOfField type, const MEDFileFieldGlobsReal *glob, std::vector< std::pair<mcIdType,mcIdType> >& dads, std::vector<const DataArrayIdType *>& pfls, std::vector<int>& locs, std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes) const
+void MEDFileFieldPerMeshPerTypeDyn::getFieldAtLevel(int /*meshDim*/, TypeOfField /*type*/, const MEDFileFieldGlobsReal * /*glob*/, std::vector< std::pair<mcIdType,mcIdType> >& /*dads*/, std::vector<const DataArrayIdType *>& /*pfls*/, std::vector<int>& /*locs*/, std::vector<INTERP_KERNEL::NormalizedCellType>& /*geoTypes*/) const
{
throw INTERP_KERNEL::Exception("not implemented yet !");
}
std::vector<const BigMemoryObject *> MEDFileFieldPerMesh::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
- ret.push_back(*it);
+ for(const auto & it : _field_pm_pt)
+ ret.push_back(it);
return ret;
}
MCAuto< MEDFileFieldPerMesh > ret=new MEDFileFieldPerMesh(*this);
ret->_father=father;
std::size_t i=0;
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
+ for(auto it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
{
if((*it).isNotNull())
ret->_field_pm_pt[i]=(*it)->deepCopy((MEDFileFieldPerMesh *)(ret));
void MEDFileFieldPerMesh::simpleRepr(int bkOffset, std::ostream& oss, int id) const
{
- std::string startLine(bkOffset,' ');
+ std::string const startLine(bkOffset,' ');
oss << startLine << "## Field part (" << id << ") lying on mesh \"" << getMeshName() << "\", Mesh iteration=" << _mesh_iteration << ". Mesh order=" << _mesh_order << "." << std::endl;
oss << startLine << "## Field is defined on " << _field_pm_pt.size() << " types." << std::endl;
int i=0;
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
+ for(auto it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
{
if((*it).isNotNull())
(*it)->simpleRepr(bkOffset,oss,i);
void MEDFileFieldPerMesh::assignFieldNoProfileNoRenum(mcIdType& start, const std::vector<mcIdType>& code, const MEDCouplingFieldTemplate *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
{
- std::size_t nbOfTypes=code.size()/3;
+ std::size_t const nbOfTypes=code.size()/3;
mcIdType offset=0;
for(std::size_t i=0;i<nbOfTypes;i++)
{
- INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)code[3*i];
- mcIdType nbOfCells=code[3*i+1];
- mcIdType pos=addNewEntryIfNecessary(type);
+ auto const type=(INTERP_KERNEL::NormalizedCellType)code[3*i];
+ mcIdType const nbOfCells=code[3*i+1];
+ mcIdType const pos=addNewEntryIfNecessary(type);
_field_pm_pt[pos]->assignFieldNoProfile(start,offset,nbOfCells,field,arr,glob,nasc);
offset+=nbOfCells;
}
*/
void MEDFileFieldPerMesh::assignFieldProfile(mcIdType& start, const DataArrayIdType *multiTypePfl, const std::vector<mcIdType>& code, const std::vector<mcIdType>& code2, const std::vector<DataArrayIdType *>& idsInPflPerType, const std::vector<DataArrayIdType *>& idsPerType, const MEDCouplingFieldTemplate *field, const DataArray *arr, const MEDCouplingMesh *mesh, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
{
- std::size_t nbOfTypes(code.size()/3);
+ std::size_t const nbOfTypes(code.size()/3);
for(std::size_t i=0;i<nbOfTypes;i++)
{
- INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)code[3*i];
- mcIdType pos=addNewEntryIfNecessary(type);
- DataArrayIdType *pfl=0;
+ auto const type=(INTERP_KERNEL::NormalizedCellType)code[3*i];
+ mcIdType const pos=addNewEntryIfNecessary(type);
+ DataArrayIdType *pfl=nullptr;
if(code[3*i+2]!=-1)
pfl=idsPerType[code[3*i+2]];
- std::size_t nbOfTupes2=code2.size()/3;
+ std::size_t const nbOfTupes2=code2.size()/3;
std::size_t found=0;
for(;found<nbOfTupes2;found++)
if(code[3*i]==code2[3*found])
void MEDFileFieldPerMesh::assignNodeFieldNoProfile(mcIdType& start, const MEDCouplingFieldTemplate *field, const DataArray *arr, MEDFileFieldGlobsReal& glob)
{
- mcIdType pos=addNewEntryIfNecessary(INTERP_KERNEL::NORM_ERROR);
+ mcIdType const pos=addNewEntryIfNecessary(INTERP_KERNEL::NORM_ERROR);
_field_pm_pt[pos]->assignNodeFieldNoProfile(start,field,arr,glob);
}
void MEDFileFieldPerMesh::assignNodeFieldProfile(mcIdType& start, const DataArrayIdType *pfl, const MEDCouplingFieldTemplate *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
{
- mcIdType pos=addNewEntryIfNecessary(INTERP_KERNEL::NORM_ERROR);
+ mcIdType const pos=addNewEntryIfNecessary(INTERP_KERNEL::NORM_ERROR);
_field_pm_pt[pos]->assignNodeFieldProfile(start,pfl,field,arr,glob,nasc);
}
void MEDFileFieldPerMesh::loadOnlyStructureOfDataRecursively(med_idt fid, mcIdType& start, const MEDFileFieldNameScope& nasc)
{
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
- (*it)->loadOnlyStructureOfDataRecursively(fid,start,nasc);
+ for(auto & it : _field_pm_pt)
+ it->loadOnlyStructureOfDataRecursively(fid,start,nasc);
}
void MEDFileFieldPerMesh::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
{
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
- (*it)->loadBigArraysRecursively(fid,nasc);
+ for(auto & it : _field_pm_pt)
+ it->loadBigArraysRecursively(fid,nasc);
}
void MEDFileFieldPerMesh::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const
{
- std::size_t nbOfTypes=_field_pm_pt.size();
+ std::size_t const nbOfTypes=_field_pm_pt.size();
for(std::size_t i=0;i<nbOfTypes;i++)
{
_field_pm_pt[i]->copyOptionsFrom(*this);
void MEDFileFieldPerMesh::getDimension(int& dim) const
{
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
- (*it)->getDimension(dim);
+ for(const auto & it : _field_pm_pt)
+ it->getDimension(dim);
}
bool MEDFileFieldPerMesh::isUniqueLevel(int& dim) const
{
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
- if(!(*it)->isUniqueLevel(dim))
+ for(const auto & it : _field_pm_pt)
+ if(!it->isUniqueLevel(dim))
return false;
return true;
}
void MEDFileFieldPerMesh::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const
{
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
- (*it)->fillTypesOfFieldAvailable(types);
+ for(const auto & it : _field_pm_pt)
+ it->fillTypesOfFieldAvailable(types);
}
std::vector< std::vector< std::pair<mcIdType,mcIdType> > > MEDFileFieldPerMesh::getFieldSplitedByType(std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> > & locs) const
{
- std::size_t sz=_field_pm_pt.size();
+ std::size_t const sz=_field_pm_pt.size();
std::vector< std::vector<std::pair<mcIdType,mcIdType> > > ret(sz);
types.resize(sz); typesF.resize(sz); pfls.resize(sz); locs.resize(sz);
for(std::size_t i=0;i<sz;i++)
bool MEDFileFieldPerMesh::presenceOfMultiDiscPerGeoType() const
{
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
+ for(const auto & it : _field_pm_pt)
{
- if((*it).isNull())
+ if(it.isNull())
continue;
- if((*it)->presenceOfMultiDiscPerGeoType())
+ if(it->presenceOfMultiDiscPerGeoType())
return true;
}
return false;
bool MEDFileFieldPerMesh::presenceOfStructureElements() const
{
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
- if((*it).isNotNull())
+ for(const auto & it : _field_pm_pt)
+ if(it.isNotNull())
{
- const MEDFileFieldPerMeshPerTypeDyn *pt(dynamic_cast<const MEDFileFieldPerMeshPerTypeDyn *>((const MEDFileFieldPerMeshPerTypeCommon *)*it));
+ const auto *pt(dynamic_cast<const MEDFileFieldPerMeshPerTypeDyn *>((const MEDFileFieldPerMeshPerTypeCommon *)it));
if(pt)
return true;
}
bool MEDFileFieldPerMesh::onlyStructureElements() const
{
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
- if((*it).isNotNull())
+ for(const auto & it : _field_pm_pt)
+ if(it.isNotNull())
{
- const MEDFileFieldPerMeshPerTypeDyn *pt(dynamic_cast<const MEDFileFieldPerMeshPerTypeDyn *>((const MEDFileFieldPerMeshPerTypeCommon *)*it));
+ const auto *pt(dynamic_cast<const MEDFileFieldPerMeshPerTypeDyn *>((const MEDFileFieldPerMeshPerTypeCommon *)it));
if(!pt)
return false;
}
void MEDFileFieldPerMesh::killStructureElements()
{
std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > > res;
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
+ for(auto & it : _field_pm_pt)
{
- if((*it).isNotNull())
+ if(it.isNotNull())
{
- const MEDFileFieldPerMeshPerTypeDyn *pt(dynamic_cast<const MEDFileFieldPerMeshPerTypeDyn *>((const MEDFileFieldPerMeshPerTypeCommon *)*it));
+ const auto *pt(dynamic_cast<const MEDFileFieldPerMeshPerTypeDyn *>((const MEDFileFieldPerMeshPerTypeCommon *)it));
if(!pt)
- res.push_back(*it);
+ res.push_back(it);
}
}
_field_pm_pt=res;
void MEDFileFieldPerMesh::keepOnlyStructureElements()
{
std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > > res;
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
+ for(auto & it : _field_pm_pt)
{
- if((*it).isNotNull())
+ if(it.isNotNull())
{
- const MEDFileFieldPerMeshPerTypeDyn *pt(dynamic_cast<const MEDFileFieldPerMeshPerTypeDyn *>((const MEDFileFieldPerMeshPerTypeCommon *)*it));
+ const auto *pt(dynamic_cast<const MEDFileFieldPerMeshPerTypeDyn *>((const MEDFileFieldPerMeshPerTypeCommon *)it));
if(pt)
- res.push_back(*it);
+ res.push_back(it);
}
}
_field_pm_pt=res;
void MEDFileFieldPerMesh::keepOnlyOnSE(const std::string& seName)
{
std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > > res;
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
+ for(auto & it : _field_pm_pt)
{
- if((*it).isNotNull())
+ if(it.isNotNull())
{
- const MEDFileFieldPerMeshPerTypeDyn *pt(dynamic_cast<const MEDFileFieldPerMeshPerTypeDyn *>((const MEDFileFieldPerMeshPerTypeCommon *)*it));
+ const auto *pt(dynamic_cast<const MEDFileFieldPerMeshPerTypeDyn *>((const MEDFileFieldPerMeshPerTypeCommon *)it));
if(!pt)
throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::keepOnlyOnSE : presence of non SE !");
if(pt->getModelName()==seName)
- res.push_back(*it);
+ res.push_back(it);
}
}
_field_pm_pt=res;
void MEDFileFieldPerMesh::getMeshSENames(std::vector< std::pair<std::string,std::string> >& ps) const
{
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
+ for(const auto & it : _field_pm_pt)
{
- if((*it).isNotNull())
+ if(it.isNotNull())
{
- const MEDFileFieldPerMeshPerTypeDyn *pt(dynamic_cast<const MEDFileFieldPerMeshPerTypeDyn *>((const MEDFileFieldPerMeshPerTypeCommon *)*it));
+ const auto *pt(dynamic_cast<const MEDFileFieldPerMeshPerTypeDyn *>((const MEDFileFieldPerMeshPerTypeCommon *)it));
if(pt)
{
ps.push_back(std::pair<std::string,std::string>(getMeshName(),pt->getModelName()));
void MEDFileFieldPerMesh::SortArraysPerType(const MEDFileFieldGlobsReal *glob, TypeOfField type, const std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes, const std::vector< std::pair<mcIdType,mcIdType> >& dads, const std::vector<const DataArrayIdType *>& pfls, const std::vector<int>& locs, std::vector<mcIdType>& code, std::vector<DataArrayIdType *>& notNullPfls)
{
int notNullPflsSz=0;
- std::size_t nbOfArrs=geoTypes.size();
+ std::size_t const nbOfArrs=geoTypes.size();
for(std::size_t i=0;i<nbOfArrs;i++)
if(pfls[i])
notNullPflsSz++;
- std::set<INTERP_KERNEL::NormalizedCellType> geoTypes3(geoTypes.begin(),geoTypes.end());
- std::size_t nbOfDiffGeoTypes=geoTypes3.size();
+ std::set<INTERP_KERNEL::NormalizedCellType> const geoTypes3(geoTypes.begin(),geoTypes.end());
+ std::size_t const nbOfDiffGeoTypes=geoTypes3.size();
code.resize(3*nbOfDiffGeoTypes);
notNullPfls.resize(notNullPflsSz);
notNullPflsSz=0;
std::size_t j=0;
for(std::size_t i=0;i<nbOfDiffGeoTypes;i++)
{
- std::size_t startZone=j;
- INTERP_KERNEL::NormalizedCellType refType=geoTypes[j];
+ std::size_t const startZone=j;
+ INTERP_KERNEL::NormalizedCellType const refType=geoTypes[j];
std::vector<const DataArrayIdType *> notNullTmp;
if(pfls[j])
notNullTmp.push_back(pfls[j]);
}
else
break;
- std::vector< std::pair<mcIdType,mcIdType> > tmpDads(dads.begin()+startZone,dads.begin()+j);
- std::vector<const DataArrayIdType *> tmpPfls(pfls.begin()+startZone,pfls.begin()+j);
- std::vector<int> tmpLocs(locs.begin()+startZone,locs.begin()+j);
+ std::vector< std::pair<mcIdType,mcIdType> > const tmpDads(dads.begin()+startZone,dads.begin()+j);
+ std::vector<const DataArrayIdType *> const tmpPfls(pfls.begin()+startZone,pfls.begin()+j);
+ std::vector<int> const tmpLocs(locs.begin()+startZone,locs.begin()+j);
code[3*i]=(mcIdType)refType;
- std::vector<INTERP_KERNEL::NormalizedCellType> refType2(1,refType);
+ std::vector<INTERP_KERNEL::NormalizedCellType> const refType2(1,refType);
code[3*i+1]=ComputeNbOfElems(glob,type,refType2,tmpDads,tmpLocs);
if(notNullTmp.empty())
code[3*i+2]=-1;
*/
mcIdType MEDFileFieldPerMesh::ComputeNbOfElems(const MEDFileFieldGlobsReal *glob, TypeOfField type, const std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes, const std::vector< std::pair<mcIdType,mcIdType> >& dads, const std::vector<int>& locs)
{
- std::size_t sz=dads.size();
+ std::size_t const sz=dads.size();
mcIdType ret=0;
for(std::size_t i=0;i<sz;i++)
{
}
else
{
- int nbOfGaussPtPerCell=glob->getNbOfGaussPtPerCell(locs[i]);
+ int const nbOfGaussPtPerCell=glob->getNbOfGaussPtPerCell(locs[i]);
ret+=(dads[i].second-dads[i].first)/nbOfGaussPtPerCell;
}
}
{
std::vector<std::string> ret;
std::set<std::string> ret2;
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
+ for(const auto & it : _field_pm_pt)
{
- std::vector<std::string> tmp=(*it)->getPflsReallyUsed();
- for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
- if(ret2.find(*it2)==ret2.end())
+ std::vector<std::string> const tmp=it->getPflsReallyUsed();
+ for(const auto & it2 : tmp)
+ if(ret2.find(it2)==ret2.end())
{
- ret.push_back(*it2);
- ret2.insert(*it2);
+ ret.push_back(it2);
+ ret2.insert(it2);
}
}
return ret;
std::vector<std::string> MEDFileFieldPerMesh::getPflsReallyUsedMulti() const
{
std::vector<std::string> ret;
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
+ for(const auto & it : _field_pm_pt)
{
- std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti();
+ std::vector<std::string> tmp=it->getPflsReallyUsedMulti();
ret.insert(ret.end(),tmp.begin(),tmp.end());
}
return ret;
{
std::vector<std::string> ret;
std::set<std::string> ret2;
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
+ for(const auto & it : _field_pm_pt)
{
- std::vector<std::string> tmp=(*it)->getLocsReallyUsed();
- for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
- if(ret2.find(*it2)==ret2.end())
+ std::vector<std::string> const tmp=it->getLocsReallyUsed();
+ for(const auto & it2 : tmp)
+ if(ret2.find(it2)==ret2.end())
{
- ret.push_back(*it2);
- ret2.insert(*it2);
+ ret.push_back(it2);
+ ret2.insert(it2);
}
}
return ret;
std::vector<std::string> MEDFileFieldPerMesh::getLocsReallyUsedMulti() const
{
std::vector<std::string> ret;
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
+ for(const auto & it : _field_pm_pt)
{
- std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti();
+ std::vector<std::string> tmp=it->getLocsReallyUsedMulti();
ret.insert(ret.end(),tmp.begin(),tmp.end());
}
return ret;
bool MEDFileFieldPerMesh::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
{
- for(std::vector< std::pair<std::string,std::string> >::const_iterator it=modifTab.begin();it!=modifTab.end();it++)
+ for(const auto & it : modifTab)
{
- if((*it).first==getMeshName())
+ if(it.first==getMeshName())
{
- setMeshName((*it).second);
+ setMeshName(it.second);
return true;
}
}
throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::convertMedBallIntoClassic : Only managed for single mesh !");
if(_field_pm_pt[0].isNull())
throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::convertMedBallIntoClassic : null pointer !");
- MEDFileFieldPerMeshPerTypeDyn *pt(dynamic_cast<MEDFileFieldPerMeshPerTypeDyn *>((MEDFileFieldPerMeshPerTypeCommon *)_field_pm_pt[0]));
+ auto *pt(dynamic_cast<MEDFileFieldPerMeshPerTypeDyn *>((MEDFileFieldPerMeshPerTypeCommon *)_field_pm_pt[0]));
if(!pt)
throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::convertMedBallIntoClassic : this is expected to be marked as structure element !");
if(pt->getNumberOfLoc()!=1)
DataArray *arr0(getOrCreateAndGetArray());//tony
if(!arr0)
throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArray storing values of field is null !");
- DataArrayDouble *arr(dynamic_cast<DataArrayDouble *>(arr0));//tony
+ auto *arr(dynamic_cast<DataArrayDouble *>(arr0));//tony
if(!arr0)
throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArray storing values is double ! Not managed for the moment !");
mcIdType sz=0;
if(!arr)
throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArrayDouble storing values of field is null !");
- for(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<mcIdType,mcIdType> > >::const_iterator it=entries.begin();it!=entries.end();it++)
+ for(const auto & entrie : entries)
{
- if(typesToKeep.find((*it).first.first)!=typesToKeep.end())
+ if(typesToKeep.find(entrie.first.first)!=typesToKeep.end())
{
- entriesKept.push_back(getLeafGivenTypeAndLocId((*it).first.first,(*it).first.second));
- sz+=(*it).second.second-(*it).second.first;
+ entriesKept.push_back(getLeafGivenTypeAndLocId(entrie.first.first,entrie.first.second));
+ sz+=entrie.second.second-entrie.second.first;
}
else
- otherEntries.push_back(getLeafGivenTypeAndLocId((*it).first.first,(*it).first.second));
+ otherEntries.push_back(getLeafGivenTypeAndLocId(entrie.first.first,entrie.first.second));
}
MCAuto<DataArrayIdType> renumDefrag=DataArrayIdType::New(); renumDefrag->alloc(arr->getNumberOfTuples(),1); renumDefrag->fillWithZero();
////////////////////
// tupleIdOfStartOfNewChuncksV[sid-1]=sz2;
MCAuto<DataArrayIdType> explicitIdsOldInArr=DataArrayIdType::New(); explicitIdsOldInArr->alloc(sz,1);
mcIdType *workI=explicitIdsOldInArr->getPointer();
- for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator itL2=(*itL1).begin();itL2!=(*itL1).end();itL2++)
+ for(auto itL2 : *itL1)
{
- mcIdType delta1=(*itL2)->fillTupleIds(workI); workI+=delta1; sz1+=delta1;
- (*itL2)->setLocId(sz2);
- (*itL2)->_tmp_work1=(*itL2)->getStart();
- mcIdType delta2=(*itL2)->fillEltIdsFromCode(sz2,oldCode,glob,workI2); workI2+=delta2; sz2+=delta2;
+ mcIdType const delta1=itL2->fillTupleIds(workI); workI+=delta1; sz1+=delta1;
+ itL2->setLocId(sz2);
+ itL2->_tmp_work1=itL2->getStart();
+ mcIdType const delta2=itL2->fillEltIdsFromCode(sz2,oldCode,glob,workI2); workI2+=delta2; sz2+=delta2;
}
renumDefrag->setPartOfValuesSimple3(sid,explicitIdsOldInArr->begin(),explicitIdsOldInArr->end(),0,1,1);
}
explicitIdsOldInMesh->reAlloc(sz2);
- mcIdType tupleIdOfStartOfNewChuncks=arr->getNumberOfTuples()-sz2;
+ mcIdType const tupleIdOfStartOfNewChuncks=arr->getNumberOfTuples()-sz2;
////////////////////
- MCAuto<DataArrayIdType> permArrDefrag=renumDefrag->buildPermArrPerLevel(); renumDefrag=0;
+ MCAuto<DataArrayIdType> permArrDefrag=renumDefrag->buildPermArrPerLevel(); renumDefrag=nullptr;
// perform redispatching of non concerned MEDFileFieldPerMeshPerTypePerDisc
std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> > otherEntriesNew;
- for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=otherEntries.begin();it!=otherEntries.end();it++)
+ for(auto otherEntrie : otherEntries)
{
- otherEntriesNew.push_back(MEDFileFieldPerMeshPerTypePerDisc::New(*(*it)));
- otherEntriesNew.back()->setNewStart(permArrDefrag->getIJ((*it)->getStart(),0));
- otherEntriesNew.back()->setLocId((*it)->getGeoType());
+ otherEntriesNew.push_back(MEDFileFieldPerMeshPerTypePerDisc::New(*otherEntrie));
+ otherEntriesNew.back()->setNewStart(permArrDefrag->getIJ(otherEntrie->getStart(),0));
+ otherEntriesNew.back()->setLocId(otherEntrie->getGeoType());
}
std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> > entriesKeptNew;
std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> entriesKeptNew2;
- for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesKept.begin();it!=entriesKept.end();it++)
+ for(auto it : entriesKept)
{
- MCAuto<MEDFileFieldPerMeshPerTypePerDisc> elt=MEDFileFieldPerMeshPerTypePerDisc::New(*(*it));
- mcIdType newStart=elt->getLocId();
- elt->setLocId((*it)->getGeoType());
+ MCAuto<MEDFileFieldPerMeshPerTypePerDisc> elt=MEDFileFieldPerMeshPerTypePerDisc::New(*it);
+ mcIdType const newStart=elt->getLocId();
+ elt->setLocId(it->getGeoType());
elt->setNewStart(newStart);
elt->_tmp_work1=permArrDefrag->getIJ(elt->_tmp_work1,0);
entriesKeptNew.push_back(elt);
MCAuto<DataArrayDouble> arr2=arr->renumber(permArrDefrag->getConstPointer());
// perform redispatching of concerned MEDFileFieldPerMeshPerTypePerDisc -> values are in arr2
MCAuto<DataArrayIdType> explicitIdsNewInMesh=renumO2N->selectByTupleId(explicitIdsOldInMesh->begin(),explicitIdsOldInMesh->end());
- std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > entriesKeptPerDisc=MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(entriesKeptNew2);
+ std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > const entriesKeptPerDisc=MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(entriesKeptNew2);
bool ret=false;
- for(std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator it4=entriesKeptPerDisc.begin();it4!=entriesKeptPerDisc.end();it4++)
+ for(const auto & it4 : entriesKeptPerDisc)
{
sid=0;
/*for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator itL2=(*it4).begin();itL2!=(*it4).end();itL2++)
MEDFileFieldPerMeshPerTypePerDisc *curNC=const_cast<MEDFileFieldPerMeshPerTypePerDisc *>(*itL2);
curNC->setNewStart(permArrDefrag->getIJ((*itL2)->getStart(),0)-tupleIdOfStartOfNewChuncks+tupleIdOfStartOfNewChuncksV[sid]);
}*/
- ret=MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks(tupleIdOfStartOfNewChuncks,*it4,explicitIdsNewInMesh,newCode,
+ ret=MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks(tupleIdOfStartOfNewChuncks,it4,explicitIdsNewInMesh,newCode,
glob,arr2,otherEntriesNew) || ret;
}
if(!ret)
void MEDFileFieldPerMesh::keepOnlySpatialDiscretization(TypeOfField tof, mcIdType &globalNum, std::vector< std::pair<mcIdType,mcIdType> >& its)
{
std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > > ret;
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
+ for(auto & it : _field_pm_pt)
{
std::vector< std::pair<mcIdType,mcIdType> > its2;
- if((*it)->keepOnlySpatialDiscretization(tof,globalNum,its2))
+ if(it->keepOnlySpatialDiscretization(tof,globalNum,its2))
{
- ret.push_back(*it);
+ ret.push_back(it);
its.insert(its.end(),its2.begin(),its2.end());
}
}
void MEDFileFieldPerMesh::keepOnlyGaussDiscretization(std::size_t idOfDisc, mcIdType &globalNum, std::vector< std::pair<mcIdType,mcIdType> >& its)
{
std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > > ret;
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
+ for(auto & it : _field_pm_pt)
{
std::vector< std::pair<mcIdType,mcIdType> > its2;
- if((*it)->keepOnlyGaussDiscretization(idOfDisc,globalNum,its2))
+ if(it->keepOnlyGaussDiscretization(idOfDisc,globalNum,its2))
{
- ret.push_back(*it);
+ ret.push_back(it);
its.insert(its.end(),its2.begin(),its2.end());
}
}
void MEDFileFieldPerMesh::assignNewLeaves(const std::vector< MCAuto< MEDFileFieldPerMeshPerTypePerDisc > >& leaves)
{
std::map<INTERP_KERNEL::NormalizedCellType,std::vector< MCAuto< MEDFileFieldPerMeshPerTypePerDisc> > > types;
- for( std::vector< MCAuto< MEDFileFieldPerMeshPerTypePerDisc > >::const_iterator it=leaves.begin();it!=leaves.end();it++)
- types[(INTERP_KERNEL::NormalizedCellType)(*it)->getLocId()].push_back(*it);
+ for(const auto & leave : leaves)
+ types[(INTERP_KERNEL::NormalizedCellType)leave->getLocId()].push_back(leave);
//
std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > > fieldPmPt(types.size());
std::map<INTERP_KERNEL::NormalizedCellType,std::vector< MCAuto< MEDFileFieldPerMeshPerTypePerDisc> > >::const_iterator it1=types.begin();
- std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it2=fieldPmPt.begin();
+ auto it2=fieldPmPt.begin();
for(;it1!=types.end();it1++,it2++)
{
MCAuto<MEDFileFieldPerMeshPerType> elt=MEDFileFieldPerMeshPerType::New(this,(INTERP_KERNEL::NormalizedCellType)((*it1).second[0]->getLocId()));
elt->setLeaves((*it1).second);
- MCAuto<MEDFileFieldPerMeshPerTypeCommon> elt2(DynamicCast<MEDFileFieldPerMeshPerType,MEDFileFieldPerMeshPerTypeCommon>(elt));
+ MCAuto<MEDFileFieldPerMeshPerTypeCommon> const elt2(DynamicCast<MEDFileFieldPerMeshPerType,MEDFileFieldPerMeshPerTypeCommon>(elt));
*it2=elt2;
}
_field_pm_pt=fieldPmPt;
void MEDFileFieldPerMesh::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
{
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
- (*it)->changePflsRefsNamesGen(mapOfModif);
+ for(auto & it : _field_pm_pt)
+ it->changePflsRefsNamesGen(mapOfModif);
}
void MEDFileFieldPerMesh::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
{
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
- (*it)->changeLocsRefsNamesGen(mapOfModif);
+ for(auto & it : _field_pm_pt)
+ it->changeLocsRefsNamesGen(mapOfModif);
}
/*!
std::vector<int> locs;
std::vector<mcIdType>code;
std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes;
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
- (*it)->getFieldAtLevel(mesh->getMeshDimension(),type,glob,dads,pfls,locs,geoTypes);
+ for(const auto & it : _field_pm_pt)
+ it->getFieldAtLevel(mesh->getMeshDimension(),type,glob,dads,pfls,locs,geoTypes);
// Sort by types
SortArraysPerType(glob,type,geoTypes,dads,pfls,locs,code,notNullPflsPerGeoType);
if(code.empty())
throw INTERP_KERNEL::Exception(oss.str());
}
//
- std::vector< MCAuto<DataArrayIdType> > notNullPflsPerGeoType2(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
+ std::vector< MCAuto<DataArrayIdType> > const notNullPflsPerGeoType2(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
std::vector< const DataArrayIdType *> notNullPflsPerGeoType3(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
if(type!=ON_NODES)
{
return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
else
{
- MCAuto<DataArrayIdType> arr2(arr);
+ MCAuto<DataArrayIdType> const arr2(arr);
return finishField2(type,glob,dads,locs,geoTypes,mesh,arr,isPfl,arrOut,nasc);
}
}
{
if(code.size()!=3)
throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : internal error #1 !");
- mcIdType nb=code[1];
+ mcIdType const nb=code[1];
if(code[2]==-1)
{
if(nb!=mesh->getNumberOfNodes())
std::vector<int> locs;
std::vector<mcIdType> code;
std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes;
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
- (*it)->getFieldAtLevel(mesh->getMeshDimension(),type,glob,dads,pfls,locs,geoTypes);
+ for(const auto & it : _field_pm_pt)
+ it->getFieldAtLevel(mesh->getMeshDimension(),type,glob,dads,pfls,locs,geoTypes);
// Sort by types
SortArraysPerType(glob,type,geoTypes,dads,pfls,locs,code,notNullPflsPerGeoType);
if(code.empty())
std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevelWithPfl : " << "The field \"" << nasc.getName() << "\" exists but not with such spatial discretization or such dimension specified !";
throw INTERP_KERNEL::Exception(oss.str());
}
- std::vector< MCAuto<DataArrayIdType> > notNullPflsPerGeoType2(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
+ std::vector< MCAuto<DataArrayIdType> > const notNullPflsPerGeoType2(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
std::vector< const DataArrayIdType *> notNullPflsPerGeoType3(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
if(type!=ON_NODES)
{
{
if(code.size()!=3)
throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : internal error #1 !");
- mcIdType nb=code[1];
+ mcIdType const nb=code[1];
if(code[2]==-1)
{
if(nb!=mesh->getNumberOfNodes())
throw INTERP_KERNEL::Exception(oss.str());
}
}
- return finishField4(dads,code[2]==-1?0:notNullPflsPerGeoType3[0],mesh->getNumberOfNodes(),pfl);
+ return finishField4(dads,code[2]==-1?nullptr:notNullPflsPerGeoType3[0],mesh->getNumberOfNodes(),pfl);
}
//
- return 0;
+ return nullptr;
}
void MEDFileFieldPerMesh::accept(MEDFileFieldVisitor& visitor) const
{
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
- if((*it).isNotNull())
+ for(const auto & it : _field_pm_pt)
+ if(it.isNotNull())
{
- visitor.newPerMeshPerTypeEntry(*it);
- (*it)->accept(visitor);
- visitor.endPerMeshPerTypeEntry(*it);
+ visitor.newPerMeshPerTypeEntry(it);
+ it->accept(visitor);
+ visitor.endPerMeshPerTypeEntry(it);
}
}
{
mcIdType globalSz=0;
mcIdType nbOfEntries=0;
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
+ for(const auto & it : _field_pm_pt)
{
- (*it)->getSizes(globalSz,nbOfEntries);
+ it->getSizes(globalSz,nbOfEntries);
}
entries.resize(nbOfEntries);
nbOfEntries=0;
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
+ for(const auto & it : _field_pm_pt)
{
- (*it)->fillValues(nbOfEntries,entries);
+ it->fillValues(nbOfEntries,entries);
}
}
MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMesh::getLeafGivenTypeAndLocId(INTERP_KERNEL::NormalizedCellType typ, mcIdType locId)
{
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
+ for(auto & it : _field_pm_pt)
{
- if((*it)->getGeoType()==typ)
- return (*it)->getLeafGivenLocId(locId);
+ if(it->getGeoType()==typ)
+ return it->getLeafGivenLocId(locId);
}
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
std::ostringstream oss; oss << "MEDFileFieldPerMesh::getLeafGivenTypeAndLocId : no such geometric type \"" << cm.getRepr() << "\" in this !" << std::endl;
oss << "Possibilities are : ";
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
+ for(const auto & it : _field_pm_pt)
{
- const INTERP_KERNEL::CellModel& cm2=INTERP_KERNEL::CellModel::GetCellModel((*it)->getGeoType());
+ const INTERP_KERNEL::CellModel& cm2=INTERP_KERNEL::CellModel::GetCellModel(it->getGeoType());
oss << "\"" << cm2.getRepr() << "\", ";
}
throw INTERP_KERNEL::Exception(oss.str());
const MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMesh::getLeafGivenTypeAndLocId(INTERP_KERNEL::NormalizedCellType typ, mcIdType locId) const
{
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
+ for(const auto & it : _field_pm_pt)
{
- if((*it)->getGeoType()==typ)
- return (*it)->getLeafGivenLocId(locId);
+ if(it->getGeoType()==typ)
+ return it->getLeafGivenLocId(locId);
}
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
std::ostringstream oss; oss << "MEDFileFieldPerMesh::getLeafGivenTypeAndLocId : no such geometric type \"" << cm.getRepr() << "\" in this !" << std::endl;
oss << "Possibilities are : ";
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
+ for(const auto & it : _field_pm_pt)
{
- const INTERP_KERNEL::CellModel& cm2=INTERP_KERNEL::CellModel::GetCellModel((*it)->getGeoType());
+ const INTERP_KERNEL::CellModel& cm2=INTERP_KERNEL::CellModel::GetCellModel(it->getGeoType());
oss << "\"" << cm2.getRepr() << "\", ";
}
throw INTERP_KERNEL::Exception(oss.str());
MCAuto<MEDFileFieldPerMeshPerTypePerDisc> ret(new MEDFileFieldPerMeshPerTypePerDisc(father,tof));
if(pms.empty())
throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::Aggregate : empty input vector !");
- for(std::vector<std::pair<int,const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator it=pms.begin();it!=pms.end();it++)
+ for(const auto & pm : pms)
{
- if(!(*it).second)
+ if(!pm.second)
throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::Aggregate : presence of null pointer !");
- if(!(*it).second->getProfile().empty())
+ if(!pm.second->getProfile().empty())
throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::Aggregate : not implemented yet for profiles !");
- if(!(*it).second->getLocalization().empty())
+ if(!pm.second->getLocalization().empty())
throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::Aggregate : not implemented yet for gauss pts !");
}
- INTERP_KERNEL::NormalizedCellType gt(pms[0].second->getGeoType());
+ INTERP_KERNEL::NormalizedCellType const gt(pms[0].second->getGeoType());
std::size_t i(0);
std::vector< std::pair<int,int> > filteredDTS;
- for(std::vector< std::vector< std::pair<int,mcIdType> > >::const_iterator it=dts.begin();it!=dts.end();it++,i++)
- for(std::vector< std::pair<int,mcIdType> >::const_iterator it2=(*it).begin();it2!=(*it).end();it2++)
- if((*it2).first==gt)
- filteredDTS.push_back(std::pair<int,int>(i,(*it2).second));
+ for(auto it=dts.begin();it!=dts.end();it++,i++)
+ for(const auto & it2 : *it)
+ if(it2.first==gt)
+ filteredDTS.push_back(std::pair<int,int>(i,it2.second));
if(pms.size()!=filteredDTS.size())
throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::Aggregate : not implemented yet for generated profiles !");
- std::vector<std::pair<int,const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator it1(pms.begin());
+ auto it1(pms.begin());
std::vector< std::pair<int,int> >::const_iterator it2(filteredDTS.begin());
mcIdType zeStart(start),nval(0);
for(;it1!=pms.end();it1++,it2++)
MCAuto<MEDFileFieldPerMesh> ret(new MEDFileFieldPerMesh(father,pms[0]->getMeshName(),pms[0]->getMeshIteration(),pms[0]->getMeshOrder()));
std::map<INTERP_KERNEL::NormalizedCellType, std::vector< std::pair<int,const MEDFileFieldPerMeshPerType *> > > m;
std::size_t i(0);
- for(std::vector<const MEDFileFieldPerMesh *>::const_iterator it=pms.begin();it!=pms.end();it++,i++)
+ for(auto it=pms.begin();it!=pms.end();it++,i++)
{
const std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >& v((*it)->_field_pm_pt);
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it2=v.begin();it2!=v.end();it2++)
+ for(const auto & it2 : v)
{
- INTERP_KERNEL::NormalizedCellType gt((*it2)->getGeoType());
- const MEDFileFieldPerMeshPerType *elt(dynamic_cast<const MEDFileFieldPerMeshPerType *>((const MEDFileFieldPerMeshPerTypeCommon *)(*it2)));
+ INTERP_KERNEL::NormalizedCellType const gt(it2->getGeoType());
+ const auto *elt(dynamic_cast<const MEDFileFieldPerMeshPerType *>((const MEDFileFieldPerMeshPerTypeCommon *)it2));
if(!elt)
throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::Aggregate : not managed for structelement !");
m[gt].push_back(std::pair<int,const MEDFileFieldPerMeshPerType *>(i,elt));
for(std::map<INTERP_KERNEL::NormalizedCellType, std::vector< std::pair<int,const MEDFileFieldPerMeshPerType *> > >::const_iterator it=m.begin();it!=m.end();it++)
{
MCAuto<MEDFileFieldPerMeshPerType> agg(MEDFileFieldPerMeshPerType::Aggregate(start,(*it).second,dts,(*it).first,ret,extractInfo));
- MCAuto<MEDFileFieldPerMeshPerTypeCommon> agg2(DynamicCast<MEDFileFieldPerMeshPerType,MEDFileFieldPerMeshPerTypeCommon>(agg));
+ MCAuto<MEDFileFieldPerMeshPerTypeCommon> const agg2(DynamicCast<MEDFileFieldPerMeshPerType,MEDFileFieldPerMeshPerTypeCommon>(agg));
ret->_field_pm_pt.push_back(agg2);
}
return ret;
int MEDFileFieldPerMesh::addNewEntryIfNecessary(INTERP_KERNEL::NormalizedCellType type)
{
int i=0;
- std::size_t pos=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,type));
- std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it2=_field_pm_pt.begin();
- for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
+ std::size_t const pos=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,type));
+ auto it2=_field_pm_pt.begin();
+ for(auto it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
{
- INTERP_KERNEL::NormalizedCellType curType=(*it)->getGeoType();
+ INTERP_KERNEL::NormalizedCellType const curType=(*it)->getGeoType();
if(type==curType)
return i;
else
{
- std::size_t pos2=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,curType));
+ std::size_t const pos2=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,curType));
if(pos>pos2)
it2=it+1;
}
}
- std::size_t ret=std::distance(_field_pm_pt.begin(),it2);
+ std::size_t const ret=std::distance(_field_pm_pt.begin(),it2);
_field_pm_pt.insert(it2,MEDFileFieldPerMeshPerType::New(this,type));
return (int)ret;
}
if(type==ON_GAUSS_PT)
{
mcIdType offset=0;
- std::size_t nbOfArrs=dads.size();
+ std::size_t const nbOfArrs=dads.size();
for(std::size_t i=0;i<nbOfArrs;i++)
{
- std::vector<std::pair<mcIdType,mcIdType> > dads2(1,dads[i]); const std::vector<int> locs2(1,locs[i]);
+ std::vector<std::pair<mcIdType,mcIdType> > const dads2(1,dads[i]); const std::vector<int> locs2(1,locs[i]);
const std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes2(1,INTERP_KERNEL::NORM_ERROR);
- mcIdType nbOfElems=ComputeNbOfElems(glob,type,geoTypes2,dads2,locs2);
+ mcIdType const nbOfElems=ComputeNbOfElems(glob,type,geoTypes2,dads2,locs2);
MCAuto<DataArrayIdType> di=DataArrayIdType::New();
di->alloc(nbOfElems,1);
di->iota(offset);
*/
MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishField2(TypeOfField type, const MEDFileFieldGlobsReal *glob,
const std::vector<std::pair<mcIdType,mcIdType> >& dads, const std::vector<int>& locs,
- const std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes,
+ const std::vector<INTERP_KERNEL::NormalizedCellType>& /*geoTypes*/,
const MEDCouplingMesh *mesh, const DataArrayIdType *da, bool& isPfl, MCAuto<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
{
if(da->isIota(mesh->getNumberOfCells()))
if(da->isIota(mesh->getNumberOfNodes()))
return finishField(ON_NODES,glob,dads,locs,mesh,isPfl,arrOut,nasc);
// Treatment of particular case where nodal field on pfl is requested with a meshDimRelToMax=1.
- const MEDCouplingUMesh *meshu=dynamic_cast<const MEDCouplingUMesh *>(mesh);
+ const auto *meshu=dynamic_cast<const MEDCouplingUMesh *>(mesh);
if(meshu)
{
- if(meshu->getNodalConnectivity()==0)
+ if(meshu->getNodalConnectivity()==nullptr)
{
MCAuto<MEDCouplingFieldDouble> ret=finishField(ON_CELLS,glob,dads,locs,mesh,isPfl,arrOut,nasc);
- mcIdType nb=da->getNbOfElems();
+ mcIdType const nb=da->getNbOfElems();
const mcIdType *ptr=da->getConstPointer();
- MEDCouplingUMesh *meshuc=const_cast<MEDCouplingUMesh *>(meshu);
+ auto *meshuc=const_cast<MEDCouplingUMesh *>(meshu);
meshuc->allocateCells(nb);
for(mcIdType i=0;i<nb;i++)
meshuc->insertNextCell(INTERP_KERNEL::NORM_POINT1,1,ptr+i);
//
MCAuto<MEDCouplingFieldDouble> ret=finishField(ON_NODES,glob,dads,locs,mesh,isPfl,arrOut,nasc);
isPfl=true;
- DataArrayIdType *arr2=0;
+ DataArrayIdType *arr2=nullptr;
MCAuto<DataArrayIdType> cellIds=mesh->getCellIdsFullyIncludedInNodeIds(da->getConstPointer(),da->getConstPointer()+da->getNbOfElems());
MCAuto<MEDCouplingMesh> mesh2=mesh->buildPartAndReduceNodes(cellIds->getConstPointer(),cellIds->getConstPointer()+cellIds->getNbOfElems(),arr2);
- MCAuto<DataArrayIdType> arr3(arr2);
- mcIdType nnodes=mesh2->getNumberOfNodes();
+ MCAuto<DataArrayIdType> const arr3(arr2);
+ mcIdType const nnodes=mesh2->getNumberOfNodes();
if(nnodes==(mcIdType)da->getNbOfElems())
{
MCAuto<DataArrayIdType> da3=da->transformWithIndArrR(arr2->begin(),arr2->end());
oss << " - if definitely the node profile has no link with mesh connectivity use MEDFileField1TS::getFieldWithProfile or MEDFileFieldMultiTS::getFieldWithProfile methods instead !";
throw INTERP_KERNEL::Exception(oss.str());
}
- return 0;
+ return nullptr;
}
/*!
MCAuto<DataArrayIdType> safePfl(pflOut);
MCAuto<DataArray> da=getOrCreateAndGetArray()->selectByTupleRanges(dads);
const std::vector<std::string>& infos=getInfo();
- std::size_t nbOfComp=infos.size();
+ std::size_t const nbOfComp=infos.size();
for(std::size_t i=0;i<nbOfComp;i++)
da->setInfoOnComponent(i,infos[i].c_str());
safePfl->incrRef();
public:
static MFFPMIter *NewCell(const MEDFileEntities *entities);
static bool IsPresenceOfNode(const MEDFileEntities *entities);
- virtual ~MFFPMIter() { }
+ virtual ~MFFPMIter() = default;
virtual void begin() = 0;
virtual bool finished() const = 0;
virtual void next() = 0;
class MFFPMIterSimple : public MFFPMIter
{
public:
- MFFPMIterSimple():_pos(0) { }
- void begin() { _pos=0; }
- bool finished() const { return _pos>=MED_N_CELL_FIXED_GEO; }
- void next() { _pos++; }
- int current() const { return _pos; }
+ MFFPMIterSimple() = default;
+ void begin() override { _pos=0; }
+ bool finished() const override { return _pos>=MED_N_CELL_FIXED_GEO; }
+ void next() override { _pos++; }
+ int current() const override { return _pos; }
private:
- int _pos;
+ int _pos{0};
};
class MFFPMIter2 : public MFFPMIter
{
public:
MFFPMIter2(const std::vector<INTERP_KERNEL::NormalizedCellType>& cts);
- void begin() { _it=_ids.begin(); }
- bool finished() const { return _it==_ids.end(); }
- void next() { _it++; }
- int current() const { return *_it; }
+ void begin() override { _it=_ids.begin(); }
+ bool finished() const override { return _it==_ids.end(); }
+ void next() override { _it++; }
+ int current() const override { return *_it; }
private:
std::vector<int> _ids;
std::vector<int>::const_iterator _it;
return new MFFPMIterSimple;
else
{
- const MEDFileStaticEntities *entities2(dynamic_cast<const MEDFileStaticEntities *>(entities));
+ const auto *entities2(dynamic_cast<const MEDFileStaticEntities *>(entities));
if(entities2)
{
std::vector<INTERP_KERNEL::NormalizedCellType> tmp;
const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> >& myEnt(entities2->getEntries());
- for(std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> >::const_iterator it=myEnt.begin();it!=myEnt.end();it++)
+ for(const auto & it : myEnt)
{
- if((*it).first==ON_CELLS || (*it).first==ON_GAUSS_NE || (*it).first==ON_GAUSS_PT)
- tmp.push_back((*it).second);
+ if(it.first==ON_CELLS || it.first==ON_GAUSS_NE || it.first==ON_GAUSS_PT)
+ tmp.push_back(it.second);
}
return new MFFPMIter2(tmp);
}
return true;
else
{
- const MEDFileStaticEntities *entities2(dynamic_cast<const MEDFileStaticEntities *>(entities));
+ const auto *entities2(dynamic_cast<const MEDFileStaticEntities *>(entities));
if(entities2)
{
const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> >& myEnt(entities2->getEntries());
- for(std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> >::const_iterator it=myEnt.begin();it!=myEnt.end();it++)
- if((*it).first==ON_NODES)
+ for(const auto & it : myEnt)
+ if(it.first==ON_NODES)
return true;
return false;
}
MFFPMIter2::MFFPMIter2(const std::vector<INTERP_KERNEL::NormalizedCellType>& cts)
{
- std::size_t sz(cts.size());
+ std::size_t const sz(cts.size());
_ids.resize(sz);
for(std::size_t i=0;i<sz;i++)
{
INTERP_KERNEL::AutoPtr<char> meshName(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
INTERP_KERNEL::AutoPtr<char> pflName(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
INTERP_KERNEL::AutoPtr<char> locName(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
- const MEDFileUMesh *mmu(dynamic_cast<const MEDFileUMesh *>(mm));
+ const auto *mmu(dynamic_cast<const MEDFileUMesh *>(mm));
INTERP_KERNEL::AutoCppPtr<MFFPMIter> iter0(MFFPMIter::NewCell(entities));
// for each geometric type inside my mesh, check if there is a field profile ie if the field is defined on this type of cells (whether the discretization is on cells or on gauss_ne)
// and if this is the case, retrieve the part to be read and build a new MedFileField from it
for(iter0->begin();!iter0->finished();iter0->next())
{
- med_int nbProfile (MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_CELL ,typmai[iter0->current()],meshCsit+1,meshName,pflName,locName));
- std::string name0(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1));
- med_int nbProfile2(MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE_ELEMENT,typmai[iter0->current()],meshCsit+1,meshName,pflName,locName));
- std::string name1(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1));
+ med_int const nbProfile (MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_CELL ,typmai[iter0->current()],meshCsit+1,meshName,pflName,locName));
+ std::string const name0(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1));
+ med_int const nbProfile2(MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE_ELEMENT,typmai[iter0->current()],meshCsit+1,meshName,pflName,locName));
+ std::string const name1(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1));
if(nbProfile>0 || nbProfile2>0)
{
- const PartDefinition *pd(0);
+ const PartDefinition *pd(nullptr);
if(mmu)
pd=mmu->getPartDefAtLevel(mmu->getRelativeLevOnGeoType(typmai2[iter0->current()]),typmai2[iter0->current()]);
_field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_CELLS,typmai2[iter0->current()],nasc,pd));
if(MFFPMIter::IsPresenceOfNode(entities))
{
// if there is a profile on nodes for the current field, retrieve the part to be read and build a new MedFileField from it
- med_int nbProfile(MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE,MED_NONE,meshCsit+1,meshName,pflName,locName));
+ med_int const nbProfile(MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE,MED_NONE,meshCsit+1,meshName,pflName,locName));
if(nbProfile>0)
{
- const PartDefinition *pd(0);
+ const PartDefinition *pd(nullptr);
if(mmu)
pd=mmu->getPartDefAtLevel(1,INTERP_KERNEL::NORM_ERROR);
_field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_NODES,INTERP_KERNEL::NORM_ERROR,nasc,pd));
}
if(!entities)
return ;
- std::vector<int> dynGT(entities->getDynGTAvail());
- for(std::vector<int>::const_iterator it=dynGT.begin();it!=dynGT.end();it++)
+ std::vector<int> const dynGT(entities->getDynGTAvail());
+ for(int const it : dynGT)
{
- med_int nbPfl(MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_STRUCT_ELEMENT,*it,pflName,locName));
+ med_int const nbPfl(MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_STRUCT_ELEMENT,it,pflName,locName));
if(nbPfl>0)
{
- _field_pm_pt.push_back(MEDFileFieldPerMeshPerTypeDyn::NewOnRead(fid,this,entities,*it,nasc));
+ _field_pm_pt.push_back(MEDFileFieldPerMeshPerTypeDyn::NewOnRead(fid,this,entities,it,nasc));
setMeshName(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE));
}
}
iter0=MFFPMIter::NewCell(entities);
for(iter0->begin();!iter0->finished();iter0->next())
{
- med_int nbProfile (MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_DESCENDING_FACE,typmai[iter0->current()],meshCsit+1,meshName,pflName,locName));
- std::string name0(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1));
- med_int nbProfile2(MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_DESCENDING_EDGE,typmai[iter0->current()],meshCsit+1,meshName,pflName,locName));
- std::string name1(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1));
+ med_int const nbProfile (MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_DESCENDING_FACE,typmai[iter0->current()],meshCsit+1,meshName,pflName,locName));
+ std::string const name0(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1));
+ med_int const nbProfile2(MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_DESCENDING_EDGE,typmai[iter0->current()],meshCsit+1,meshName,pflName,locName));
+ std::string const name1(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1));
if(nbProfile>0 || nbProfile2>0)
{
- _field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_CELLS,typmai2[iter0->current()],nasc,NULL));
+ _field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_CELLS,typmai2[iter0->current()],nasc,nullptr));
if(nbProfile>0)
setMeshName(name0);
else
INTERP_KERNEL::AutoCppPtr<MFFPMIter> iter0(MFFPMIter::NewCell(entities));
for(iter0->begin();!iter0->finished();iter0->next())
{
- med_int nbProfile (MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_CELL ,typmai[iter0->current()],meshCsit+1,meshName,pflName,locName));
- std::string name0(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1));
- med_int nbProfile2(MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE_ELEMENT,typmai[iter0->current()],meshCsit+1,meshName,pflName,locName));
- std::string name1(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1));
+ med_int const nbProfile (MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_CELL ,typmai[iter0->current()],meshCsit+1,meshName,pflName,locName));
+ std::string const name0(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1));
+ med_int const nbProfile2(MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE_ELEMENT,typmai[iter0->current()],meshCsit+1,meshName,pflName,locName));
+ std::string const name1(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1));
if(nbProfile>0 || nbProfile2>0)
{
_field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_CELLS,typmai2[iter0->current()],nasc,pd));
if(MFFPMIter::IsPresenceOfNode(entities))
{
- med_int nbProfile(MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE,MED_NONE,meshCsit+1,meshName,pflName,locName));
+ med_int const nbProfile(MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE,MED_NONE,meshCsit+1,meshName,pflName,locName));
if(nbProfile>0)
{
_field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_NODES,INTERP_KERNEL::NORM_ERROR,nasc,pd));
#ifndef __MEDFILEFIELDINTERNAL_HXX__
#define __MEDFILEFIELDINTERNAL_HXX__
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingTraits.hxx"
#include "MEDLoaderDefines.hxx"
#include "MEDFileUtilities.hxx"
#include "NormalizedGeometricTypes"
#include "med.h"
+#include <ostream>
+#include <cstddef>
+#include <set>
#include <string>
#include <list>
+#include <vector>
+#include <utility>
namespace MEDCoupling
{
{
public:
MEDFileGTKeeperSta(INTERP_KERNEL::NormalizedCellType gt):_geo_type(gt) { }
- MEDFileGTKeeper *deepCopy() const;
- INTERP_KERNEL::NormalizedCellType getGeoType() const;
- std::string getRepr() const;
- bool isEqual(const MEDFileGTKeeper *other) const;
+ MEDFileGTKeeper *deepCopy() const override;
+ INTERP_KERNEL::NormalizedCellType getGeoType() const override;
+ std::string getRepr() const override;
+ bool isEqual(const MEDFileGTKeeper *other) const override;
private:
INTERP_KERNEL::NormalizedCellType _geo_type;
};
{
public:
MEDFileGTKeeperDyn(const MEDFileUMesh *mesh, const MEDFileUMesh *section, const MEDFileStructureElement *se);
- MEDFileGTKeeper *deepCopy() const;
- INTERP_KERNEL::NormalizedCellType getGeoType() const;
- std::string getRepr() const;
- bool isEqual(const MEDFileGTKeeper *other) const;
+ MEDFileGTKeeper *deepCopy() const override;
+ INTERP_KERNEL::NormalizedCellType getGeoType() const override;
+ std::string getRepr() const override;
+ bool isEqual(const MEDFileGTKeeper *other) const override;
const MEDFileUMesh *getMesh() const { return _mesh; }
const MEDFileUMesh *getSection() const { return _section; }
const MEDFileStructureElement *getSE() const { return _se; }
static MEDFileFieldLoc *New(med_idt fid, const std::string& locName);
static MEDFileFieldLoc *New(med_idt fid, int i, const MEDFileEntities *entities);
static MEDFileFieldLoc *New(const std::string& locName, INTERP_KERNEL::NormalizedCellType geoType, const std::vector<double>& refCoo, const std::vector<double>& gsCoo, const std::vector<double>& w);
- std::size_t getHeapMemorySizeWithoutChildren() const;
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
MEDFileFieldLoc *deepCopy() const;
bool isOnStructureElement() const;
const MEDFileGTKeeper *getUndergroundGTKeeper() const { return _gt; }
static MEDFileFieldPerMeshPerTypePerDisc *New(MEDFileFieldPerMeshPerTypeCommon *fath, TypeOfField type, mcIdType locId);
static MEDFileFieldPerMeshPerTypePerDisc *New(const MEDFileFieldPerMeshPerTypePerDisc& other);
std::string getClassName() const override { return std::string("MEDFileFieldPerMeshPerTypePerDisc"); }
- std::size_t getHeapMemorySizeWithoutChildren() const;
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
MEDFileFieldPerMeshPerTypePerDisc *deepCopy(MEDFileFieldPerMeshPerTypeCommon *father) const;
void assignFieldNoProfile(mcIdType& start, mcIdType offset, mcIdType nbOfCells, const MEDCouplingFieldTemplate *field, const DataArray *arrr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc);
void assignFieldProfile(bool isPflAlone, mcIdType& start, const DataArrayIdType *multiTypePfl, const DataArrayIdType *idsInPfl, DataArrayIdType *locIds, mcIdType nbOfEltsInWholeMesh, const MEDCouplingFieldTemplate *field, const DataArray *arrr, const MEDCouplingMesh *mesh, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc);
{
public:
std::string getClassName() const override { return std::string("MEDFileFieldPerMeshPerTypeCommon"); }
- std::size_t getHeapMemorySizeWithoutChildren() const;
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
void assignFieldNoProfile(mcIdType& start, mcIdType offset, mcIdType nbOfCells, const MEDCouplingFieldTemplate *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc);
void assignFieldProfile(bool isPflAlone, mcIdType& start, const DataArrayIdType *multiTypePfl, const DataArrayIdType *idsInPfl, DataArrayIdType *locIds, mcIdType nbOfEltsInWholeMesh, const MEDCouplingFieldTemplate *field, const DataArray *arr, const MEDCouplingMesh *mesh, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc);
void assignNodeFieldNoProfile(mcIdType& start, const MEDCouplingFieldTemplate *field, const DataArray *arr, MEDFileFieldGlobsReal& glob);
void setFather(MEDFileFieldPerMesh *father);
void accept(MEDFileFieldVisitor& visitor) const;
public:
- virtual ~MEDFileFieldPerMeshPerTypeCommon();
+ ~MEDFileFieldPerMeshPerTypeCommon() override;
virtual void getDimension(int& dim) const = 0;
virtual INTERP_KERNEL::NormalizedCellType getGeoType() const = 0;
virtual INTERP_KERNEL::NormalizedCellType getGeoTypeStatic() const = 0;
static MEDFileFieldPerMeshPerType *NewOnRead(med_idt fid, MEDFileFieldPerMesh *fath, TypeOfField type, INTERP_KERNEL::NormalizedCellType geoType, const MEDFileFieldNameScope& nasc, const PartDefinition *pd);
static MCAuto<MEDFileFieldPerMeshPerType> Aggregate(mcIdType &start, const std::vector< std::pair<int,const MEDFileFieldPerMeshPerType *> >& pms, const std::vector< std::vector< std::pair<int,mcIdType> > >& dts, INTERP_KERNEL::NormalizedCellType gt, MEDFileFieldPerMesh *father, std::vector<std::pair< int, std::pair<mcIdType,mcIdType> > >& extractInfo);
public:// overload of abstract methods
- void getDimension(int& dim) const;
+ void getDimension(int& dim) const override;
INTERP_KERNEL::NormalizedCellType getGeoType() const override;
INTERP_KERNEL::NormalizedCellType getGeoTypeStatic() const override;
- void entriesForMEDfile(TypeOfField mct, med_geometry_type& gt, med_entity_type& ent) const;
- void simpleRepr(int bkOffset, std::ostream& oss, int id) const;
- std::string getGeoTypeRepr() const;
- MEDFileFieldPerMeshPerType *deepCopy(MEDFileFieldPerMesh *father) const;
- void getFieldAtLevel(int meshDim, TypeOfField type, const MEDFileFieldGlobsReal *glob, std::vector< std::pair<mcIdType,mcIdType> >& dads, std::vector<const DataArrayIdType *>& pfls, std::vector<int>& locs, std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes) const;
+ void entriesForMEDfile(TypeOfField mct, med_geometry_type& gt, med_entity_type& ent) const override;
+ void simpleRepr(int bkOffset, std::ostream& oss, int id) const override;
+ std::string getGeoTypeRepr() const override;
+ MEDFileFieldPerMeshPerType *deepCopy(MEDFileFieldPerMesh *father) const override;
+ void getFieldAtLevel(int meshDim, TypeOfField type, const MEDFileFieldGlobsReal *glob, std::vector< std::pair<mcIdType,mcIdType> >& dads, std::vector<const DataArrayIdType *>& pfls, std::vector<int>& locs, std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes) const override;
private:
MEDFileFieldPerMeshPerType(med_idt fid, MEDFileFieldPerMesh *fath, TypeOfField type, INTERP_KERNEL::NormalizedCellType geoType, const MEDFileFieldNameScope& nasc, const PartDefinition *pd);
MEDFileFieldPerMeshPerType(MEDFileFieldPerMesh *father, INTERP_KERNEL::NormalizedCellType gt);
int getDynGT() const;
std::string getModelName() const;
public:
- void getDimension(int& dim) const;
+ void getDimension(int& dim) const override;
INTERP_KERNEL::NormalizedCellType getGeoType() const override;
INTERP_KERNEL::NormalizedCellType getGeoTypeStatic() const override;
- void entriesForMEDfile(TypeOfField mct, med_geometry_type& gt, med_entity_type& ent) const;
- void simpleRepr(int bkOffset, std::ostream& oss, int id) const;
- std::string getGeoTypeRepr() const;
- MEDFileFieldPerMeshPerTypeDyn *deepCopy(MEDFileFieldPerMesh *father) const;
- void getFieldAtLevel(int meshDim, TypeOfField type, const MEDFileFieldGlobsReal *glob, std::vector< std::pair<mcIdType,mcIdType> >& dads, std::vector<const DataArrayIdType *>& pfls, std::vector<int>& locs, std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes) const;
+ void entriesForMEDfile(TypeOfField mct, med_geometry_type& gt, med_entity_type& ent) const override;
+ void simpleRepr(int bkOffset, std::ostream& oss, int id) const override;
+ std::string getGeoTypeRepr() const override;
+ MEDFileFieldPerMeshPerTypeDyn *deepCopy(MEDFileFieldPerMesh *father) const override;
+ void getFieldAtLevel(int meshDim, TypeOfField type, const MEDFileFieldGlobsReal *glob, std::vector< std::pair<mcIdType,mcIdType> >& dads, std::vector<const DataArrayIdType *>& pfls, std::vector<int>& locs, std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes) const override;
private:
MEDFileFieldPerMeshPerTypeDyn(med_idt fid, MEDFileFieldPerMesh *fath, const MEDFileStructureElement *se, const MEDFileFieldNameScope& nasc);
private:
static MEDFileFieldPerMesh *NewOnRead(med_idt fid, MEDFileAnyTypeField1TSWithoutSDA *fath, int meshCsit, int meshIteration, int meshOrder, const MEDFileFieldNameScope& nasc, const MEDFileMesh *mm, const MEDFileEntities *entities);
static MEDFileFieldPerMesh *NewOnRead(med_idt fid, MEDFileAnyTypeField1TSWithoutSDA *fath, int meshCsit, int meshIteration, int meshOrder, const MEDFileFieldNameScope& nasc, const PartDefinition *pd, const MEDFileEntities *entities);
std::string getClassName() const override { return std::string("MEDFileFieldPerMesh"); }
- std::size_t getHeapMemorySizeWithoutChildren() const;
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
MEDFileFieldPerMesh *deepCopy(MEDFileAnyTypeField1TSWithoutSDA *father) const;
void simpleRepr(int bkOffset,std::ostream& oss, int id) const;
void copyTinyInfoFrom(const MEDCouplingMesh *mesh);
MEDFileFieldPerMesh(med_idt fid, MEDFileAnyTypeField1TSWithoutSDA *fath, int meshCsit, int meshIteration, int meshOrder, const MEDFileFieldNameScope& nasc, const MEDFileMesh *mm, const MEDFileEntities *entities);
MEDFileFieldPerMesh(med_idt fid, MEDFileAnyTypeField1TSWithoutSDA *fath, int meshCsit, int meshIteration, int meshOrder, const MEDFileFieldNameScope& nasc, const PartDefinition *pd, const MEDFileEntities *entities);
MEDFileFieldPerMesh(MEDFileAnyTypeField1TSWithoutSDA *fath, const MEDCouplingMesh *mesh);
- MEDFileFieldPerMesh(MEDFileAnyTypeField1TSWithoutSDA *fath, const std::string& meshName, int meshIt, int meshOrd):_mesh_iteration(meshIt),_mesh_order(meshOrd),_father(fath) { }
+ MEDFileFieldPerMesh(MEDFileAnyTypeField1TSWithoutSDA *fath, const std::string& /*meshName*/, int meshIt, int meshOrd):_mesh_iteration(meshIt),_mesh_order(meshOrd),_father(fath) { }
private:
int _mesh_iteration;
int _mesh_order;
// Author : Anthony Geay (EDF R&D)
#include "MEDFileFieldMultiTS.hxx"
+#include "MEDFileField.txx"
+#include "MCType.hxx"
+#include "MEDFileFieldGlobs.hxx"
+#include "MEDFileEntities.hxx"
+#include "InterpKernelException.hxx"
+#include "MCAuto.hxx"
+#include "MEDFileField1TS.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "InterpKernelAutoPtr.hxx"
+#include "MEDFileBasis.hxx"
+#include "MCIdType.hxx"
+#include "MEDFileFieldOverView.hxx"
#include "MEDFileFieldVisitor.hxx"
#include "MEDFileSafeCaller.txx"
+#include "MEDFileUtilities.hxx"
#include "MEDLoaderBase.hxx"
-#include "MEDFileField.txx"
#include "MEDCouplingFieldDouble.hxx"
#include "MEDCouplingFieldTemplate.hxx"
-
+#include "NormalizedGeometricTypes"
+#include "med.h"
+#include "medfield.h"
+#include "MEDLoaderTraits.hxx"
+
+#include <cstddef>
+#include <iterator>
+#include <algorithm>
+#include <ostream>
+#include <set>
+#include <cmath>
+#include <limits>
+#include <list>
#include <sstream>
+#include <string>
+#include <vector>
+#include <utility>
using namespace MEDCoupling;
//= MEDFileAnyTypeFieldMultiTSWithoutSDA
MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA()
-{
-}
+= default;
MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(const std::string& fieldName, const std::string& meshName):MEDFileFieldNameScope(fieldName,meshName)
{
{
med_field_type typcha;
std::string dtunitOut,meshName;
- int nbOfStep(MEDFileAnyTypeField1TS::LocateField2(fid,fieldId,false,_name,typcha,_infos,dtunitOut,meshName));
+ int const nbOfStep(MEDFileAnyTypeField1TS::LocateField2(fid,fieldId,false,_name,typcha,_infos,dtunitOut,meshName));
setMeshName(meshName);
setDtUnit(dtunitOut.c_str());
loadStructureOrStructureAndBigArraysRecursively(fid,nbOfStep,typcha,loadAll,ms,entities);
std::size_t MEDFileAnyTypeFieldMultiTSWithoutSDA::getHeapMemorySizeWithoutChildren() const
{
std::size_t ret(_mesh_name.capacity()+_name.capacity()+_infos.capacity()*sizeof(std::string)+_time_steps.capacity()*sizeof(MCAuto<MEDFileField1TSWithoutSDA>));
- for(std::vector<std::string>::const_iterator it=_infos.begin();it!=_infos.end();it++)
- ret+=(*it).capacity();
+ for(const auto & _info : _infos)
+ ret+=_info.capacity();
return ret;
}
std::vector<const BigMemoryObject *> MEDFileAnyTypeFieldMultiTSWithoutSDA::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
- ret.push_back((const MEDFileAnyTypeField1TSWithoutSDA *)*it);
+ for(const auto & _time_step : _time_steps)
+ ret.push_back((const MEDFileAnyTypeField1TSWithoutSDA *)_time_step);
return ret;
}
{
MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=createNew();
ret->setInfo(_infos);
- int sz=(int)_time_steps.size();
+ int const sz=(int)_time_steps.size();
for(const int *id=startIds;id!=endIds;id++)
{
if(*id>=0 && *id<sz)
MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds2(int bg, int end, int step) const
{
static const char msg[]="MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds2";
- mcIdType nbOfEntriesToKeep=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
+ mcIdType const nbOfEntriesToKeep=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=createNew();
ret->setInfo(_infos);
- std::size_t sz=_time_steps.size();
+ std::size_t const sz=_time_steps.size();
std::size_t j=bg;
for(int i=0;i<nbOfEntriesToKeep;i++,j+=step)
{
{
int id=0;
MCAuto<DataArrayInt> ids=DataArrayInt::New(); ids->alloc(0,1);
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,id++)
+ for(auto it=_time_steps.begin();it!=_time_steps.end();it++,id++)
{
const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
if(!cur)
continue;
- std::pair<int,int> p(cur->getIteration(),cur->getOrder());
+ std::pair<int,int> const p(cur->getIteration(),cur->getOrder());
if(std::find(timeSteps.begin(),timeSteps.end(),p)!=timeSteps.end())
ids->pushBackSilent(id);
}
{
int id=0;
MCAuto<DataArrayInt> ids=DataArrayInt::New(); ids->alloc(0,1);
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,id++)
+ for(auto it=_time_steps.begin();it!=_time_steps.end();it++,id++)
{
const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
if(!cur)
continue;
- std::pair<int,int> p(cur->getIteration(),cur->getOrder());
+ std::pair<int,int> const p(cur->getIteration(),cur->getOrder());
if(std::find(timeSteps.begin(),timeSteps.end(),p)==timeSteps.end())
ids->pushBackSilent(id);
}
bool MEDFileAnyTypeFieldMultiTSWithoutSDA::presenceOfStructureElements() const
{
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
- if((*it).isNotNull())
- if((*it)->presenceOfStructureElements())
+ for(const auto & _time_step : _time_steps)
+ if(_time_step.isNotNull())
+ if(_time_step->presenceOfStructureElements())
return true;
return false;
}
bool MEDFileAnyTypeFieldMultiTSWithoutSDA::onlyStructureElements() const
{
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
- if((*it).isNotNull())
- if(!(*it)->onlyStructureElements())
+ for(const auto & _time_step : _time_steps)
+ if(_time_step.isNotNull())
+ if(!_time_step->onlyStructureElements())
return false;
return true;
}
void MEDFileAnyTypeFieldMultiTSWithoutSDA::killStructureElements()
{
std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > ret;
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
- if((*it).isNotNull())
+ for(auto & _time_step : _time_steps)
+ if(_time_step.isNotNull())
{
- if((*it)->presenceOfStructureElements())
+ if(_time_step->presenceOfStructureElements())
{
- if(!(*it)->onlyStructureElements())
+ if(!_time_step->onlyStructureElements())
{
- (*it)->killStructureElements();
- ret.push_back(*it);
+ _time_step->killStructureElements();
+ ret.push_back(_time_step);
}
}
else
{
- ret.push_back(*it);
+ ret.push_back(_time_step);
}
}
_time_steps=ret;
void MEDFileAnyTypeFieldMultiTSWithoutSDA::keepOnlyStructureElements()
{
std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > ret;
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
- if((*it).isNotNull())
+ for(auto & _time_step : _time_steps)
+ if(_time_step.isNotNull())
{
- if((*it)->presenceOfStructureElements())
+ if(_time_step->presenceOfStructureElements())
{
- if(!(*it)->onlyStructureElements())
- (*it)->keepOnlyStructureElements();
- ret.push_back(*it);
+ if(!_time_step->onlyStructureElements())
+ _time_step->keepOnlyStructureElements();
+ ret.push_back(_time_step);
}
}
_time_steps=ret;
void MEDFileAnyTypeFieldMultiTSWithoutSDA::keepOnlyOnSE(const std::string& seName)
{
- std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > ret;
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
- if((*it).isNotNull())
- (*it)->keepOnlyOnSE(seName);
+ std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > const ret;
+ for(auto & _time_step : _time_steps)
+ if(_time_step.isNotNull())
+ _time_step->keepOnlyOnSE(seName);
}
void MEDFileAnyTypeFieldMultiTSWithoutSDA::getMeshSENames(std::vector< std::pair<std::string,std::string> >& ps) const
{
std::vector< std::pair<std::string,std::string> > ps2;
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
- if((*it).isNotNull())
+ for(const auto & _time_step : _time_steps)
+ if(_time_step.isNotNull())
{
- (*it)->getMeshSENames(ps2);
+ _time_step->getMeshSENames(ps2);
break;
}
if(ps2.empty())
throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::getMeshSENames : this appears to not contain SE only !");
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
- if((*it).isNotNull())
+ for(const auto & _time_step : _time_steps)
+ if(_time_step.isNotNull())
{
std::vector< std::pair<std::string,std::string> > ps3;
- (*it)->getMeshSENames(ps3);
+ _time_step->getMeshSENames(ps3);
if(ps2!=ps3)
throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::getMeshSENames : For the moment only homogeneous SE def through time managed !");
}
- for(std::vector< std::pair<std::string,std::string> >::const_iterator it=ps2.begin();it!=ps2.end();it++)
+ for(const auto & it : ps2)
{
- std::vector< std::pair<std::string,std::string> >::iterator it2(std::find(ps.begin(),ps.end(),*it));
+ auto const it2(std::find(ps.begin(),ps.end(),it));
if(it2==ps.end())
- ps.push_back(*it);
+ ps.push_back(it);
}
}
bool MEDFileAnyTypeFieldMultiTSWithoutSDA::presenceOfMultiDiscPerGeoType() const
{
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
+ for(const auto & _time_step : _time_steps)
{
- const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
+ const MEDFileAnyTypeField1TSWithoutSDA *cur(_time_step);
if(!cur)
continue;
if(cur->presenceOfMultiDiscPerGeoType())
int MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepPos(int iteration, int order) const
{
int ret=0;
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
+ for(auto it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
{
const MEDFileAnyTypeField1TSWithoutSDA *pt(*it);
if(pt->isDealingTS(iteration,order))
return ret;
}
std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepPos : Muli timestep field on time (" << iteration << "," << order << ") does not exist ! Available (iteration,order) are :\n";
- std::vector< std::pair<int,int> > vp=getIterations();
- for(std::vector< std::pair<int,int> >::const_iterator it2=vp.begin();it2!=vp.end();it2++)
- oss << "(" << (*it2).first << "," << (*it2).second << ") ";
+ std::vector< std::pair<int,int> > const vp=getIterations();
+ for(const auto & it2 : vp)
+ oss << "(" << it2.first << "," << it2.second << ") ";
throw INTERP_KERNEL::Exception(oss.str());
}
bool MEDFileAnyTypeFieldMultiTSWithoutSDA::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
{
bool ret(false);
- for(std::vector< std::pair<std::string,std::string> >::const_iterator it=modifTab.begin();it!=modifTab.end();it++)
+ for(const auto & it : modifTab)
{
- if((*it).first==getMeshName())
+ if(it.first==getMeshName())
{
- setMeshName((*it).second);
+ setMeshName(it.second);
ret=true;
}
}
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
+ for(auto & _time_step : _time_steps)
{
- MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
+ MEDFileAnyTypeField1TSWithoutSDA *cur(_time_step);
if(cur)
ret=cur->changeMeshNames(modifTab) || ret;
}
MEDFileFieldGlobsReal& glob)
{
bool ret=false;
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
+ for(auto & _time_step : _time_steps)
{
- MEDFileAnyTypeField1TSWithoutSDA *f1ts(*it);
+ MEDFileAnyTypeField1TSWithoutSDA *f1ts(_time_step);
if(f1ts)
ret=f1ts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,glob) || ret;
}
void MEDFileAnyTypeFieldMultiTSWithoutSDA::accept(MEDFileFieldVisitor& visitor) const
{
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
- if((*it).isNotNull())
+ for(const auto & _time_step : _time_steps)
+ if(_time_step.isNotNull())
{
- visitor.newTimeStepEntry(*it);
- (*it)->accept(visitor);
- visitor.endTimeStepEntry(*it);
+ visitor.newTimeStepEntry(_time_step);
+ _time_step->accept(visitor);
+ visitor.endTimeStepEntry(_time_step);
}
}
void MEDFileAnyTypeFieldMultiTSWithoutSDA::simpleRepr(int bkOffset, std::ostream& oss, int fmtsId) const
{
- std::string startLine(bkOffset,' ');
+ std::string const startLine(bkOffset,' ');
oss << startLine << "Field multi time steps [Type=" << getTypeStr() << "]";
if(fmtsId>=0)
oss << " (" << fmtsId << ")";
oss << " has the following name: \"" << _name << "\"." << std::endl;
oss << startLine << "Field multi time steps has " << _infos.size() << " components with the following infos :" << std::endl;
- for(std::vector<std::string>::const_iterator it=_infos.begin();it!=_infos.end();it++)
+ for(const auto & _info : _infos)
{
- oss << startLine << " - \"" << *it << "\"" << std::endl;
+ oss << startLine << " - \"" << _info << "\"" << std::endl;
}
int i=0;
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
+ for(auto it=_time_steps.begin();it!=_time_steps.end();it++,i++)
{
- std::string chapter(17,(char)('0'+i));
+ std::string const chapter(17,(char)('0'+i));
oss << startLine << chapter << std::endl;
const MEDFileAnyTypeField1TSWithoutSDA *cur=(*it);
if(cur)
std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeSteps(std::vector<double>& ret1) const
{
- std::size_t sz=_time_steps.size();
+ std::size_t const sz=_time_steps.size();
std::vector< std::pair<int,int> > ret(sz);
ret1.resize(sz);
for(std::size_t i=0;i<sz;i++)
void MEDFileAnyTypeFieldMultiTSWithoutSDA::synchronizeNameScope()
{
- std::size_t nbOfCompo=_infos.size();
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
+ std::size_t const nbOfCompo=_infos.size();
+ for(auto & _time_step : _time_steps)
{
- MEDFileAnyTypeField1TSWithoutSDA *cur=(*it);
+ MEDFileAnyTypeField1TSWithoutSDA *cur=_time_step;
if(cur)
{
if((cur->getInfo()).size()!=nbOfCompo)
//
INTERP_KERNEL::AutoCppPtr<MEDFileEntities> entitiesFast;
const MEDFileEntities *entitiesForSubInstances(entities);
- MEDFileCapability mfcap(fid);
+ MEDFileCapability const mfcap(fid);
if( ( !entities || entities->areAllStaticPresentAndNoDyn() ) && mfcap.isFastReader())
{// no entities
- med_int nentitype(MEDfieldnEntityType(fid,_name.c_str(),MED_ALL_DT,MED_ALL_IT));
+ med_int const nentitype(MEDfieldnEntityType(fid,_name.c_str(),MED_ALL_DT,MED_ALL_IT));
INTERP_KERNEL::AutoPtr<med_entity_type> types(new med_entity_type[nentitype]);
med_int usedbyncs;
MEDFILESAFECALLERRD0(MEDfieldEntityType,(fid,_name.c_str(),MED_ALL_DT,MED_ALL_IT,types,&usedbyncs));
std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > entitiesFastP;
for(int i=0;i<nentitype;i++)
{
- med_int ngeotype(MEDfieldnGeometryType(fid,_name.c_str(),MED_ALL_DT,MED_ALL_IT,types[i]));
+ med_int const ngeotype(MEDfieldnGeometryType(fid,_name.c_str(),MED_ALL_DT,MED_ALL_IT,types[i]));
INTERP_KERNEL::AutoPtr<med_geometry_type> geotypes(new med_geometry_type[ngeotype]);
med_int geousedbyncs;
MEDFILESAFECALLERRD0(MEDfieldGeometryType,(fid,_name.c_str(),MED_ALL_DT,MED_ALL_IT,types[i],geotypes,&geousedbyncs));
for(med_int j=0;j<ngeotype;j++)
{
- std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> p(MEDFileMesh::ConvertFromMEDFileEntity(types[i]),ConvertGeometryType(geotypes[j]));
+ std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> const p(MEDFileMesh::ConvertFromMEDFileEntity(types[i]),ConvertGeometryType(geotypes[j]));
entitiesFastP.push_back(p);
}
}
}
for(int i=0;i<nbPdt;i++)
{
- std::vector< std::pair<int,int> > ts;
+ std::vector< std::pair<int,int> > const ts;
med_int numdt=0,numo=0;
med_float dt=0.0;
MEDFILESAFECALLERRD0(MEDfieldComputingStepInfo,(fid,_name.c_str(),i+1,&numdt,&numo,&dt));
throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::writeLL : no time steps set !");
checkThatNbOfCompoOfTSMatchThis();
std::vector<std::string> infos(getInfo());
- std::size_t nbComp=infos.size();
+ std::size_t const nbComp=infos.size();
INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
for(unsigned int i=0;i<nbComp;i++)
{
- std::string info=infos[i];
+ std::string const info=infos[i];
std::string c,u;
MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,opts.getTooLongStrPolicy());
if(_name.empty())
throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::write : MED file does not accept field with empty name !");
MEDFILESAFECALLERWR0(MEDfieldCr,(fid,_name.c_str(),getMEDFileFieldType(),ToMedInt(nbComp),comp,unit,getDtUnit().c_str(),getMeshName().c_str()));
- std::size_t nbOfTS=_time_steps.size();
+ std::size_t const nbOfTS=_time_steps.size();
for(std::size_t i=0;i<nbOfTS;i++)
_time_steps[i]->writeLL(fid,opts,*this);
}
void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
{
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
+ for(auto & _time_step : _time_steps)
{
- MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
+ MEDFileAnyTypeField1TSWithoutSDA *elt(_time_step);
if(elt)
elt->loadBigArraysRecursively(fid,nasc);
}
void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadBigArraysRecursivelyIfNecessary(med_idt fid, const MEDFileFieldNameScope& nasc)
{
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
+ for(auto & _time_step : _time_steps)
{
- MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
+ MEDFileAnyTypeField1TSWithoutSDA *elt(_time_step);
if(elt)
elt->loadBigArraysRecursivelyIfNecessary(fid,nasc);
}
void MEDFileAnyTypeFieldMultiTSWithoutSDA::unloadArrays()
{
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
+ for(auto & _time_step : _time_steps)
{
- MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
+ MEDFileAnyTypeField1TSWithoutSDA *elt(_time_step);
if(elt)
elt->unloadArrays();
}
void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseEmptyTS()
{
std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > newTS;
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
+ for(const auto & _time_step : _time_steps)
{
- const MEDFileAnyTypeField1TSWithoutSDA *tmp=(*it);
+ const MEDFileAnyTypeField1TSWithoutSDA *tmp=_time_step;
if(tmp)
- newTS.push_back(*it);
+ newTS.push_back(_time_step);
}
_time_steps=newTS;
}
void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds(const int *startIds, const int *endIds)
{
std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > newTS;
- int maxId=(int)_time_steps.size();
+ int const maxId=(int)_time_steps.size();
int ii=0;
std::set<int> idsToDel;
for(const int *id=startIds;id!=endIds;id++,ii++)
void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds2(int bg, int end, int step)
{
static const char msg[]="MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds2";
- mcIdType nbOfEntriesToKill=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
+ mcIdType const nbOfEntriesToKill=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
if(nbOfEntriesToKill==0)
return ;
- std::size_t sz=_time_steps.size();
+ std::size_t const sz=_time_steps.size();
std::vector<bool> b(sz,true);
int j=bg;
for(mcIdType i=0;i<nbOfEntriesToKill;i++,j+=step)
{
int ret=0;
std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getPosOfTimeStep : No such time step (" << iteration << "," << order << ") !\nPossibilities are : ";
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
+ for(auto it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
{
const MEDFileAnyTypeField1TSWithoutSDA *tmp(*it);
if(tmp)
int ret=0;
std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getPosGivenTime : No such time step " << time << "! \nPossibilities are : ";
oss.precision(15);
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
+ for(auto it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
{
const MEDFileAnyTypeField1TSWithoutSDA *tmp(*it);
if(tmp)
{
int it2,ord;
- double ti=tmp->getTime(it2,ord);
+ double const ti=tmp->getTime(it2,ord);
if(fabs(time-ti)<eps)
return ret;
else
std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getIterations() const
{
- std::size_t lgth=_time_steps.size();
+ std::size_t const lgth=_time_steps.size();
std::vector< std::pair<int,int> > ret(lgth);
for(std::size_t i=0;i<lgth;i++)
_time_steps[i]->fillIteration(ret[i]);
throw INTERP_KERNEL::Exception(oss.str());
}
const MEDFileAnyTypeField1TSWithoutSDA *item=_time_steps[pos];
- if(item==0)
+ if(item==nullptr)
{
std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << ", this pos id exists but the underlying Field1TS is null !";
oss << "\nTry to use following method eraseEmptyTS !";
throw INTERP_KERNEL::Exception(oss.str());
}
MEDFileAnyTypeField1TSWithoutSDA *item=_time_steps[pos];
- if(item==0)
+ if(item==nullptr)
{
std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << ", this pos id exists but the underlying Field1TS is null !";
oss << "\nTry to use following method eraseEmptyTS !";
{
std::vector<std::string> ret;
std::set<std::string> ret2;
- for(std::vector< MCAuto< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
+ for(const auto & _time_step : _time_steps)
{
- std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
- for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
- if(ret2.find(*it2)==ret2.end())
+ std::vector<std::string> const tmp=_time_step->getPflsReallyUsed2();
+ for(const auto & it2 : tmp)
+ if(ret2.find(it2)==ret2.end())
{
- ret.push_back(*it2);
- ret2.insert(*it2);
+ ret.push_back(it2);
+ ret2.insert(it2);
}
}
return ret;
{
std::vector<std::string> ret;
std::set<std::string> ret2;
- for(std::vector< MCAuto< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
+ for(const auto & _time_step : _time_steps)
{
- std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
- for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
- if(ret2.find(*it2)==ret2.end())
+ std::vector<std::string> const tmp=_time_step->getLocsReallyUsed2();
+ for(const auto & it2 : tmp)
+ if(ret2.find(it2)==ret2.end())
{
- ret.push_back(*it2);
- ret2.insert(*it2);
+ ret.push_back(it2);
+ ret2.insert(it2);
}
}
return ret;
std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getPflsReallyUsedMulti2() const
{
std::vector<std::string> ret;
- for(std::vector< MCAuto< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
+ for(const auto & _time_step : _time_steps)
{
- std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti2();
+ std::vector<std::string> tmp=_time_step->getPflsReallyUsedMulti2();
ret.insert(ret.end(),tmp.begin(),tmp.end());
}
return ret;
std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getLocsReallyUsedMulti2() const
{
std::vector<std::string> ret;
- for(std::vector< MCAuto< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
+ for(const auto & _time_step : _time_steps)
{
- std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti2();
+ std::vector<std::string> tmp=_time_step->getLocsReallyUsedMulti2();
ret.insert(ret.end(),tmp.begin(),tmp.end());
}
return ret;
void MEDFileAnyTypeFieldMultiTSWithoutSDA::changePflsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
{
- for(std::vector< MCAuto< MEDFileAnyTypeField1TSWithoutSDA > >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
- (*it)->changePflsRefsNamesGen2(mapOfModif);
+ for(auto & _time_step : _time_steps)
+ _time_step->changePflsRefsNamesGen2(mapOfModif);
}
void MEDFileAnyTypeFieldMultiTSWithoutSDA::changeLocsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
{
- for(std::vector< MCAuto< MEDFileAnyTypeField1TSWithoutSDA > >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
- (*it)->changeLocsRefsNamesGen2(mapOfModif);
+ for(auto & _time_step : _time_steps)
+ _time_step->changeLocsRefsNamesGen2(mapOfModif);
}
std::vector< std::vector<TypeOfField> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getTypesOfFieldAvailable() const
{
- std::size_t lgth=_time_steps.size();
+ std::size_t const lgth=_time_steps.size();
std::vector< std::vector<TypeOfField> > ret(lgth);
for(std::size_t i=0;i<lgth;i++)
_time_steps[i]->fillTypesOfFieldAvailable(ret[i]);
{
MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=shallowCpy();
std::size_t i=0;
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
+ for(auto it=_time_steps.begin();it!=_time_steps.end();it++,i++)
{
if((const MEDFileAnyTypeField1TSWithoutSDA *)*it)
ret->_time_steps[i]=(*it)->deepCopy();
}
for(std::size_t i=0;i<sz2;i++)
{
- std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > ret1=_time_steps[i]->splitComponents();
+ std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > const ret1=_time_steps[i]->splitComponents();
if(ret1.size()!=sz)
{
std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::splitComponents : At rank #" << i << " number of components is " << ret1.size() << " whereas it should be for all time steps " << sz << " !";
*/
std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations() const
{
- std::size_t sz(_time_steps.size());
+ std::size_t const sz(_time_steps.size());
std::vector< std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > > items(sz);
for(std::size_t i=0;i<sz;i++)
{
std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret;
std::vector< std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > > ret2;
std::vector< TypeOfField > types;
- for(std::vector< std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > >::const_iterator it0=items.begin();it0!=items.end();it0++)
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
+ for(const auto & item : items)
+ for(const auto & it1 : item)
{
- std::vector<TypeOfField> ts=(*it1)->getTypesOfFieldAvailable();
+ std::vector<TypeOfField> ts=it1->getTypesOfFieldAvailable();
if(ts.size()!=1)
throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations : it appears that the splitting of MEDFileAnyTypeField1TSWithoutSDA::splitDiscretizations has returned invalid result !");
- std::vector< TypeOfField >::iterator it2=std::find(types.begin(),types.end(),ts[0]);
+ auto const it2=std::find(types.begin(),types.end(),ts[0]);
if(it2==types.end())
types.push_back(ts[0]);
}
ret.resize(types.size()); ret2.resize(types.size());
- for(std::vector< std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > >::const_iterator it0=items.begin();it0!=items.end();it0++)
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
+ for(const auto & item : items)
+ for(const auto & it1 : item)
{
- TypeOfField typ=(*it1)->getTypesOfFieldAvailable()[0];
- std::size_t pos=std::distance(types.begin(),std::find(types.begin(),types.end(),typ));
- ret2[pos].push_back(*it1);
+ TypeOfField const typ=it1->getTypesOfFieldAvailable()[0];
+ std::size_t const pos=std::distance(types.begin(),std::find(types.begin(),types.end(),typ));
+ ret2[pos].push_back(it1);
}
for(std::size_t i=0;i<types.size();i++)
{
MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt(createNew());
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it1=ret2[i].begin();it1!=ret2[i].end();it1++)
- elt->pushBackTimeStep(*it1);//also updates infos in elt
+ for(auto & it1 : ret2[i])
+ elt->pushBackTimeStep(it1);//also updates infos in elt
ret[i]=elt;
elt->MEDFileFieldNameScope::operator=(*this);
}
*/
std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > MEDFileAnyTypeFieldMultiTSWithoutSDA::splitMultiDiscrPerGeoTypes() const
{
- std::size_t sz(_time_steps.size());
+ std::size_t const sz(_time_steps.size());
std::vector< std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > > items(sz);
std::size_t szOut(std::numeric_limits<std::size_t>::max());
for(std::size_t i=0;i<sz;i++)
void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatNbOfCompoOfTSMatchThis() const
{
- std::size_t sz=_infos.size();
+ std::size_t const sz=_infos.size();
int j=0;
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,j++)
+ for(auto it=_time_steps.begin();it!=_time_steps.end();it++,j++)
{
const MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
if(elt)
void MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration(int i, MCAuto<MEDFileAnyTypeField1TSWithoutSDA> ts)
{
- int sz=(int)_time_steps.size();
+ int const sz=(int)_time_steps.size();
if(i<0 || i>=sz)
{
std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration : trying to set element at place #" << i << " should be in [0," << sz << ") !";
std::vector< std::vector<DataArrayDouble *> > MEDFileFieldMultiTSWithoutSDA::getFieldSplitedByType2(int iteration, int order, const std::string& mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const
{
const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=getTimeStepEntry(iteration,order);
- const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
+ const auto *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
if(!myF1TSC)
throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::getFieldSplitedByType2 : mismatch of type of field expecting FLOAT64 !");
return myF1TSC->getFieldSplitedByType2(mname,types,typesF,pfls,locs);
MCAuto<MEDFileInt32FieldMultiTSWithoutSDA> ret(new MEDFileInt32FieldMultiTSWithoutSDA);
ret->MEDFileAnyTypeFieldMultiTSWithoutSDA::operator =(*this);
int i=0;
- for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
+ for(auto it=_time_steps.begin();it!=_time_steps.end();it++,i++)
{
const MEDFileAnyTypeField1TSWithoutSDA *eltToConv(*it);
if(eltToConv)
{
- const MEDFileField1TSWithoutSDA *eltToConvC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(eltToConv);
+ const auto *eltToConvC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(eltToConv);
if(!eltToConvC)
throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::convertToInt : presence of an invalid 1TS type ! Should be of type FLOAT64 !");
- MCAuto<MEDFileAnyTypeField1TSWithoutSDA> elt=eltToConvC->convertToInt();
+ MCAuto<MEDFileAnyTypeField1TSWithoutSDA> const elt=eltToConvC->convertToInt();
ret->setIteration(i,elt);
}
}
//= MEDFileAnyTypeFieldMultiTS
MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS()
-{
-}
+= default;
MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(med_idt fid, bool loadAll, const MEDFileMeshes *ms)
try:MEDFileFieldGlobsReal(fid)
{
case MED_FLOAT64:
{
- ret=new MEDFileFieldMultiTSWithoutSDA(fid,0,loadAll,ms,0);
+ ret=new MEDFileFieldMultiTSWithoutSDA(fid,0,loadAll,ms,nullptr);
break;
}
case MED_INT32:
{
- ret=new MEDFileInt32FieldMultiTSWithoutSDA(fid,0,loadAll,ms,0);
+ ret=new MEDFileInt32FieldMultiTSWithoutSDA(fid,0,loadAll,ms,nullptr);
break;
}
case MED_INT64:
{
- ret=new MEDFileInt64FieldMultiTSWithoutSDA(fid,0,loadAll,ms,0);
+ ret=new MEDFileInt64FieldMultiTSWithoutSDA(fid,0,loadAll,ms,nullptr);
break;
}
case MED_FLOAT32:
{
- ret=new MEDFileFloatFieldMultiTSWithoutSDA(fid,0,loadAll,ms,0);
+ ret=new MEDFileFloatFieldMultiTSWithoutSDA(fid,0,loadAll,ms,nullptr);
break;
}
case MED_INT:
{
if(sizeof(med_int)==sizeof(int))
{
- ret=new MEDFileInt32FieldMultiTSWithoutSDA(fid,0,loadAll,ms,0);
+ ret=new MEDFileInt32FieldMultiTSWithoutSDA(fid,0,loadAll,ms,nullptr);
break;
}
}
MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent(MEDFileAnyTypeFieldMultiTSWithoutSDA *c, med_idt fid)
{
MEDFileAnyTypeFieldMultiTS *ret(BuildNewInstanceFromContent(c));
- std::string fileName(FileNameFromFID(fid));
+ std::string const fileName(FileNameFromFID(fid));
ret->setFileName(fileName);
return ret;
}
*/
MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(const std::string& fileName, bool loadAll)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return New(fid,loadAll);
}
MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(med_idt fid, bool loadAll)
{
- MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> c(BuildContentFrom(fid,loadAll,0));
+ MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> c(BuildContentFrom(fid,loadAll,nullptr));
MCAuto<MEDFileAnyTypeFieldMultiTS> ret(BuildNewInstanceFromContent(c,fid));
ret->loadGlobals(fid);
return ret.retn();
*/
MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return New(fid,fieldName,loadAll);
}
MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(med_idt fid, const std::string& fieldName, bool loadAll)
{
- MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> c(BuildContentFrom(fid,fieldName,loadAll,0,0));
+ MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> c(BuildContentFrom(fid,fieldName,loadAll,nullptr,nullptr));
MCAuto<MEDFileAnyTypeFieldMultiTS> ret(BuildNewInstanceFromContent(c,fid));
ret->loadGlobals(fid);
return ret.retn();
MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::buildSubPart(const int *startIds, const int *endIds) const
{
- MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=contentNotNullBase()->buildFromTimeStepIds(startIds,endIds);
+ MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> const c=contentNotNullBase()->buildFromTimeStepIds(startIds,endIds);
MCAuto<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
ret->_content=c;
return ret.retn();
MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::buildSubPartSlice(int bg, int end, int step) const
{
- MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=contentNotNullBase()->buildFromTimeStepIds2(bg,end,step);
+ MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> const c=contentNotNullBase()->buildFromTimeStepIds2(bg,end,step);
MCAuto<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
ret->_content=c;
return ret.retn();
void MEDFileAnyTypeFieldMultiTS::pushBackTimeSteps(const std::vector<MEDFileAnyTypeField1TS *>& f1ts)
{
- for(std::vector<MEDFileAnyTypeField1TS *>::const_iterator it=f1ts.begin();it!=f1ts.end();it++)
- pushBackTimeStep(*it);
+ for(auto f1t : f1ts)
+ pushBackTimeStep(f1t);
}
void MEDFileAnyTypeFieldMultiTS::pushBackTimeSteps(MEDFileAnyTypeFieldMultiTS *fmts)
{
if(!fmts)
throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::pushBackTimeSteps : Input fmts is NULL !");
- int nbOfTS(fmts->getNumberOfTS());
+ int const nbOfTS(fmts->getNumberOfTS());
for(int i=0;i<nbOfTS;i++)
{
MCAuto<MEDFileAnyTypeField1TS> elt(fmts->getTimeStepAtPos(i));
throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : input pointer is NULL !");
checkCoherencyOfType(f1ts);
f1ts->incrRef();
- MCAuto<MEDFileAnyTypeField1TS> f1tsSafe(f1ts);
+ MCAuto<MEDFileAnyTypeField1TS> const f1tsSafe(f1ts);
MEDFileAnyTypeField1TSWithoutSDA *c=f1ts->contentNotNullBase();
c->incrRef();
MCAuto<MEDFileAnyTypeField1TSWithoutSDA> cSafe(c);
{
if(getFileName().empty())
throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::loadArrays : the structure does not come from a file !");
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(getFileName()));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(getFileName()));
contentNotNullBase()->loadBigArraysRecursively(fid,*contentNotNullBase());
}
{
if(!getFileName().empty())
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(getFileName()));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(getFileName()));
contentNotNullBase()->loadBigArraysRecursivelyIfNecessary(fid,*contentNotNullBase());
}
}
if(!content)
throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitComponents : no content in this ! Unable to split components !");
std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit=content->splitComponents();
- std::size_t sz(contentsSplit.size());
+ std::size_t const sz(contentsSplit.size());
std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > > ret(sz);
for(std::size_t i=0;i<sz;i++)
{
if(!content)
throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitDiscretizations : no content in this ! Unable to split discretizations !");
std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit(content->splitDiscretizations());
- std::size_t sz(contentsSplit.size());
+ std::size_t const sz(contentsSplit.size());
std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > > ret(sz);
for(std::size_t i=0;i<sz;i++)
{
if(!content)
throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitMultiDiscrPerGeoTypes : no content in this ! Unable to split discretizations !");
std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit(content->splitMultiDiscrPerGeoTypes());
- std::size_t sz(contentsSplit.size());
+ std::size_t const sz(contentsSplit.size());
std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > > ret(sz);
for(std::size_t i=0;i<sz;i++)
{
*/
MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTS::getTimeStep(int iteration, int order) const
{
- int pos=getPosOfTimeStep(iteration,order);
+ int const pos=getPosOfTimeStep(iteration,order);
return getTimeStepAtPos(pos);
}
*/
MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTS::getTimeStepGivenTime(double time, double eps) const
{
- int pos=getPosGivenTime(time,eps);
+ int const pos=getPosGivenTime(time,eps);
return getTimeStepAtPos(pos);
}
std::list<MEDFileAnyTypeFieldMultiTS *> lstFMTS(vectFMTS.begin(),vectFMTS.end());
while(!lstFMTS.empty())
{
- std::list<MEDFileAnyTypeFieldMultiTS *>::iterator it(lstFMTS.begin());
+ auto it(lstFMTS.begin());
MEDFileAnyTypeFieldMultiTS *curIt(*it);
if(!curIt)
throw INTERP_KERNEL::Exception(msg);
- std::vector< std::pair<int,int> > refIts=curIt->getIterations();
+ std::vector< std::pair<int,int> > const refIts=curIt->getIterations();
std::vector<MEDFileAnyTypeFieldMultiTS *> elt;
elt.push_back(curIt); it=lstFMTS.erase(it);
while(it!=lstFMTS.end())
curIt=*it;
if(!curIt)
throw INTERP_KERNEL::Exception(msg);
- std::vector< std::pair<int,int> > curIts=curIt->getIterations();
+ std::vector< std::pair<int,int> > const curIts=curIt->getIterations();
if(refIts==curIts)
{ elt.push_back(curIt); it=lstFMTS.erase(it); }
else
std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > ret;
if(vectFMTS.empty())
return ret;
- std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it(vectFMTS.begin());
+ auto it(vectFMTS.begin());
MEDFileAnyTypeFieldMultiTS *frstElt(*it);
if(!frstElt)
throw INTERP_KERNEL::Exception(msg);
std::vector< MCAuto<MEDFileFastCellSupportComparator> > cmps;
std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > retCell=SplitPerCommonSupportNotNodesAlg(vectFMTSNotNodes,mesh,cmps);
ret=retCell;
- for(std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it2=vectFMTSNodes.begin();it2!=vectFMTSNodes.end();it2++)
+ for(auto vectFMTSNode : vectFMTSNodes)
{
i=0;
bool isFetched(false);
{
if((*it0).empty())
throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport : internal error !");
- if(cmps[i]->isCompatibleWithNodesDiscr(*it2))
- { ret[i].push_back(*it2); isFetched=true; }
+ if(cmps[i]->isCompatibleWithNodesDiscr(vectFMTSNode))
+ { ret[i].push_back(vectFMTSNode); isFetched=true; }
}
if(!isFetched)
{
- std::vector<MEDFileAnyTypeFieldMultiTS *> tmp(1,*it2);
+ std::vector<MEDFileAnyTypeFieldMultiTS *> const tmp(1,vectFMTSNode);
MCAuto<MEDFileMeshStruct> tmp2(MEDFileMeshStruct::New(mesh));
- ret.push_back(tmp); retCell.push_back(tmp); cmps.push_back(MEDFileFastCellSupportComparator::New(tmp2,*it2));
+ ret.push_back(tmp); retCell.push_back(tmp); cmps.push_back(MEDFileFastCellSupportComparator::New(tmp2,vectFMTSNode));
}
}
fsc=cmps;
std::list<MEDFileAnyTypeFieldMultiTS *> lstFMTS(vectFMTS.begin(),vectFMTS.end());
while(!lstFMTS.empty())
{
- std::list<MEDFileAnyTypeFieldMultiTS *>::iterator it(lstFMTS.begin());
+ auto it(lstFMTS.begin());
MEDFileAnyTypeFieldMultiTS *ref(*it);
std::vector<MEDFileAnyTypeFieldMultiTS *> elt;
elt.push_back(ref); it=lstFMTS.erase(it);
std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : second field points to mesh \""<< f1->getMeshName() << "\" and input mesh to compare has name \"" << mesh->getName() << "\" !";
throw INTERP_KERNEL::Exception(oss.str());
}
- int nts=f0->getNumberOfTS();
+ int const nts=f0->getNumberOfTS();
if(nts!=f1->getNumberOfTS())
throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : number of time steps are not the same !");
if(nts==0)
throw INTERP_KERNEL::Exception("AggregateHelperF1TS : empty vector !");
std::size_t sz(f1tss.size()),i(0);
std::vector< typename MLFieldTraits<T>::F1TSWSDAType const *> f1tsw(sz);
- for(typename std::vector< typename MLFieldTraits<T>::F1TSType const *>::const_iterator it=f1tss.begin();it!=f1tss.end();it++,i++)
+ for(auto it=f1tss.begin();it!=f1tss.end();it++,i++)
{
typename MLFieldTraits<T>::F1TSType const *elt(*it);
if(!elt)
throw INTERP_KERNEL::Exception("AggregateHelperF1TS : presence of a null pointer !");
f1tsw[i]=dynamic_cast<typename MLFieldTraits<T>::F1TSWSDAType const *>(elt->contentNotNullBase());
}
- typename MLFieldTraits<T>::F1TSWSDAType *retc(dynamic_cast<typename MLFieldTraits<T>::F1TSWSDAType *>(ret->contentNotNullBase()));
+ auto *retc(dynamic_cast<typename MLFieldTraits<T>::F1TSWSDAType *>(ret->contentNotNullBase()));
if(!retc)
throw INTERP_KERNEL::Exception("AggregateHelperF1TS : internal error 1 !");
retc->aggregate(f1tsw,dts);
MCAuto< typename MLFieldTraits<T>::FMTSType > ret(MLFieldTraits<T>::FMTSType::New());
if(fmtss.empty())
throw INTERP_KERNEL::Exception("AggregateHelperFMTS : empty vector !");
- std::size_t sz(fmtss.size());
- for(typename std::vector< typename MLFieldTraits<T>::FMTSType const *>::const_iterator it=fmtss.begin();it!=fmtss.end();it++)
+ std::size_t const sz(fmtss.size());
+ for(auto it=fmtss.begin();it!=fmtss.end();it++)
{
typename MLFieldTraits<T>::FMTSType const *elt(*it);
if(!elt)
throw INTERP_KERNEL::Exception("AggregateHelperFMTS : presence of null pointer !");
}
- int nbTS(fmtss[0]->getNumberOfTS());
- for(typename std::vector< typename MLFieldTraits<T>::FMTSType const *>::const_iterator it=fmtss.begin();it!=fmtss.end();it++)
+ int const nbTS(fmtss[0]->getNumberOfTS());
+ for(auto it=fmtss.begin();it!=fmtss.end();it++)
if((*it)->getNumberOfTS()!=nbTS)
throw INTERP_KERNEL::Exception("AggregateHelperFMTS : all fields must have the same number of TS !");
for(int iterTS=0;iterTS<nbTS;iterTS++)
std::size_t i(0);
std::vector< typename MLFieldTraits<T>::F1TSType const *> f1tss(sz);
std::vector< MCAuto<typename MLFieldTraits<T>::F1TSType> > f1tss2(sz);
- for(typename std::vector< typename MLFieldTraits<T>::FMTSType const *>::const_iterator it=fmtss.begin();it!=fmtss.end();it++,i++)
+ for(auto it=fmtss.begin();it!=fmtss.end();it++,i++)
{ f1tss2[i]=(*it)->getTimeStepAtPos(iterTS); f1tss[i]=f1tss2[i]; }
MCAuto<MEDFileAnyTypeField1TS> f1ts(AggregateHelperF1TS<T>(f1tss,dts));
ret->pushBackTimeStep(f1ts);
{
if(fmtss.empty())
throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::Aggregate : input vector is empty !");
- std::size_t sz(fmtss.size());
+ std::size_t const sz(fmtss.size());
std::vector<const MEDFileFieldMultiTS *> fmtss1;
std::vector<const MEDFileInt32FieldMultiTS *> fmtss2;
std::vector<const MEDFileInt64FieldMultiTS *> fmtss3;
- for(std::vector<const MEDFileAnyTypeFieldMultiTS *>::const_iterator it=fmtss.begin();it!=fmtss.end();it++)
+ for(auto fmts : fmtss)
{
- if(!(*it))
+ if(!fmts)
throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::Aggregate : presence of null instance in input vector !");
- const MEDFileFieldMultiTS *elt1(dynamic_cast<const MEDFileFieldMultiTS *>(*it));
+ const auto *elt1(dynamic_cast<const MEDFileFieldMultiTS *>(fmts));
if(elt1)
{
fmtss1.push_back(elt1);
continue;
}
- const MEDFileInt32FieldMultiTS *elt2(dynamic_cast<const MEDFileInt32FieldMultiTS *>(*it));
+ const auto *elt2(dynamic_cast<const MEDFileInt32FieldMultiTS *>(fmts));
if(elt2)
{
fmtss2.push_back(elt2);
continue;
}
- const MEDFileInt64FieldMultiTS *elt3(dynamic_cast<const MEDFileInt64FieldMultiTS *>(*it));
+ const auto *elt3(dynamic_cast<const MEDFileInt64FieldMultiTS *>(fmts));
if(elt3)
{
fmtss3.push_back(elt3);
const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
if(content)
{
- const MEDFileFieldMultiTSWithoutSDA *contc=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(content);
+ const auto *contc=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(content);
if(!contc)
throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::convertToInt : the content inside this is not FLOAT64 ! This is incoherent !");
MCAuto<MEDFileInt32FieldMultiTSWithoutSDA> newc(contc->convertToInt());
}
MEDFileAnyTypeFieldMultiTSIterator::~MEDFileAnyTypeFieldMultiTSIterator()
-{
-}
+= default;
MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTSIterator::nextt()
{
if(fmts)
return fmts->getTimeStepAtPos(_iter_id++);
else
- return 0;
+ return nullptr;
}
else
- return 0;
+ return nullptr;
}
//= MEDFileInt32FieldMultiTS
#pragma once
+#include "MEDCouplingRefCountObject.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingTraits.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MCType.hxx"
#include "MEDLoaderDefines.hxx"
#include "MEDFileField1TS.hxx"
#include "MEDFileFieldGlobs.hxx"
#include "MEDLoaderTraits.hxx"
-#include "MEDFileUtilities.hxx"
+#include "MEDFileUtilities.txx"
+#include <string>
+#include "med.h"
+#include <vector>
+#include <cstddef>
+#include <utility>
+#include <ostream>
+#include "NormalizedGeometricTypes"
+#include <map>
namespace MEDCoupling
{
MEDFileAnyTypeFieldMultiTSWithoutSDA(med_idt fid, const std::string& fieldName, const std::string& meshName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities);
public:
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileAnyTypeFieldMultiTSWithoutSDA"); }
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
MEDLOADER_EXPORT virtual MEDFileAnyTypeFieldMultiTSWithoutSDA *deepCopy() const;
MEDLOADER_EXPORT virtual std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > splitComponents() const;
MEDLOADER_EXPORT virtual std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > splitDiscretizations() const;
{
public:
MEDLOADER_EXPORT static typename MLFieldTraits<T>::FMTSWSDAType *New(med_idt fid, const std::string& fieldName, const std::string& meshName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities);
- MEDLOADER_EXPORT const char *getTypeStr() const;
- MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTSWithoutSDA *createNew() const;
- MEDLOADER_EXPORT MEDFileAnyTypeField1TSWithoutSDA *createNew1TSWithoutSDAEmptyInstance() const;
+ MEDLOADER_EXPORT const char *getTypeStr() const override;
+ MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTSWithoutSDA *createNew() const override;
+ MEDLOADER_EXPORT MEDFileAnyTypeField1TSWithoutSDA *createNew1TSWithoutSDAEmptyInstance() const override;
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileTemplateFieldMultiTSWithoutSDA"); }
protected:
MEDFileTemplateFieldMultiTSWithoutSDA() { }
/** \param [in] fieldId field id in C mode */
MEDFileTemplateFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities):MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldId,loadAll,ms,entities) { }
MEDFileTemplateFieldMultiTSWithoutSDA(med_idt fid, const std::string& fieldName, const std::string& meshName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities):MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldName,meshName,fieldTyp,infos,nbOfStep,dtunit,loadAll,ms,entities) { }
- void checkCoherencyOfType(const MEDFileAnyTypeField1TSWithoutSDA *f1ts) const;
+ void checkCoherencyOfType(const MEDFileAnyTypeField1TSWithoutSDA *f1ts) const override;
};
class MEDFileFieldMultiTSWithoutSDA : public MEDFileTemplateFieldMultiTSWithoutSDA<double>
MEDLOADER_EXPORT MEDFileFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities):MEDFileTemplateFieldMultiTSWithoutSDA<double>(fid,fieldId,loadAll,ms,entities) { }
MEDLOADER_EXPORT std::vector< std::vector<DataArrayDouble *> > getFieldSplitedByType2(int iteration, int order, const std::string& mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const;
MEDLOADER_EXPORT MEDFileInt32FieldMultiTSWithoutSDA *convertToInt() const;
- MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTSWithoutSDA *shallowCpy() const { return new MEDFileFieldMultiTSWithoutSDA(*this); }
+ MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTSWithoutSDA *shallowCpy() const override { return new MEDFileFieldMultiTSWithoutSDA(*this); }
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileFieldMultiTSWithoutSDA"); }
MEDLOADER_EXPORT MCAuto<MEDFileAnyTypeFieldMultiTS> createNewWithSDA() const override;
protected:
MEDFileFieldMultiTSWithoutSDA(const std::string& fieldName, const std::string& meshName):MEDFileTemplateFieldMultiTSWithoutSDA<double>(fieldName,meshName) { }
MEDFileFieldMultiTSWithoutSDA(med_idt fid, const std::string& fieldName, const std::string& meshName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities):MEDFileTemplateFieldMultiTSWithoutSDA<double>(fid,fieldName,meshName,fieldTyp,infos,nbOfStep,dtunit,loadAll,ms,entities) { }
- med_field_type getMEDFileFieldType() const { return MED_FLOAT64; }
+ med_field_type getMEDFileFieldType() const override { return MED_FLOAT64; }
public:
- MEDLOADER_EXPORT MEDFileFieldMultiTSWithoutSDA() { }
+ MEDLOADER_EXPORT MEDFileFieldMultiTSWithoutSDA() = default;
};
template<class T>
friend class MEDFileTemplateFieldMultiTSWithoutSDA<Int32>;
public:
MEDLOADER_EXPORT MEDFileInt32FieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities):MEDFileNDTemplateFieldMultiTSWithoutSDA<Int32>(fid,fieldId,loadAll,ms,entities) { }
- MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTSWithoutSDA *shallowCpy() const { return new MEDFileInt32FieldMultiTSWithoutSDA(*this); }
+ MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTSWithoutSDA *shallowCpy() const override { return new MEDFileInt32FieldMultiTSWithoutSDA(*this); }
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileInt32FieldMultiTSWithoutSDA"); }
MEDLOADER_EXPORT MCAuto<MEDFileAnyTypeFieldMultiTS> createNewWithSDA() const override;
protected:
MEDFileInt32FieldMultiTSWithoutSDA(const std::string& fieldName, const std::string& meshName):MEDFileNDTemplateFieldMultiTSWithoutSDA<Int32>(fieldName,meshName) { }
MEDFileInt32FieldMultiTSWithoutSDA(med_idt fid, const std::string& fieldName, const std::string& meshName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities):MEDFileNDTemplateFieldMultiTSWithoutSDA<Int32>(fid,fieldName,meshName,fieldTyp,infos,nbOfStep,dtunit,loadAll,ms,entities) { }
- med_field_type getMEDFileFieldType() const { return MED_INT32; }
+ med_field_type getMEDFileFieldType() const override { return MED_INT32; }
public:
- MEDLOADER_EXPORT MEDFileInt32FieldMultiTSWithoutSDA() { }
+ MEDLOADER_EXPORT MEDFileInt32FieldMultiTSWithoutSDA() = default;
};
class MEDFileInt64FieldMultiTSWithoutSDA : public MEDFileNDTemplateFieldMultiTSWithoutSDA<Int64>
friend class MEDFileTemplateFieldMultiTSWithoutSDA<Int64>;
public:
MEDLOADER_EXPORT MEDFileInt64FieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities):MEDFileNDTemplateFieldMultiTSWithoutSDA<Int64>(fid,fieldId,loadAll,ms,entities) { }
- MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTSWithoutSDA *shallowCpy() const { return new MEDFileInt64FieldMultiTSWithoutSDA(*this); }
+ MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTSWithoutSDA *shallowCpy() const override { return new MEDFileInt64FieldMultiTSWithoutSDA(*this); }
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileInt64FieldMultiTSWithoutSDA"); }
MEDLOADER_EXPORT MCAuto<MEDFileAnyTypeFieldMultiTS> createNewWithSDA() const override;
protected:
MEDFileInt64FieldMultiTSWithoutSDA(const std::string& fieldName, const std::string& meshName):MEDFileNDTemplateFieldMultiTSWithoutSDA<Int64>(fieldName,meshName) { }
MEDFileInt64FieldMultiTSWithoutSDA(med_idt fid, const std::string& fieldName, const std::string& meshName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities):MEDFileNDTemplateFieldMultiTSWithoutSDA<Int64>(fid,fieldName,meshName,fieldTyp,infos,nbOfStep,dtunit,loadAll,ms,entities) { }
- med_field_type getMEDFileFieldType() const { return MED_INT64; }
+ med_field_type getMEDFileFieldType() const override { return MED_INT64; }
public:
- MEDLOADER_EXPORT MEDFileInt64FieldMultiTSWithoutSDA() { }
+ MEDLOADER_EXPORT MEDFileInt64FieldMultiTSWithoutSDA() = default;
};
class MEDFileFloatFieldMultiTSWithoutSDA : public MEDFileNDTemplateFieldMultiTSWithoutSDA<float>
friend class MEDFileTemplateFieldMultiTSWithoutSDA<float>;
public:
MEDLOADER_EXPORT MEDFileFloatFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities):MEDFileNDTemplateFieldMultiTSWithoutSDA<float>(fid,fieldId,loadAll,ms,entities) { }
- MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTSWithoutSDA *shallowCpy() const { return new MEDFileFloatFieldMultiTSWithoutSDA(*this); }
+ MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTSWithoutSDA *shallowCpy() const override { return new MEDFileFloatFieldMultiTSWithoutSDA(*this); }
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileFloatFieldMultiTSWithoutSDA"); }
MEDLOADER_EXPORT MCAuto<MEDFileAnyTypeFieldMultiTS> createNewWithSDA() const override;
protected:
MEDFileFloatFieldMultiTSWithoutSDA(const std::string& fieldName, const std::string& meshName):MEDFileNDTemplateFieldMultiTSWithoutSDA<float>(fieldName,meshName) { }
MEDFileFloatFieldMultiTSWithoutSDA(med_idt fid, const std::string& fieldName, const std::string& meshName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities):MEDFileNDTemplateFieldMultiTSWithoutSDA<float>(fid,fieldName,meshName,fieldTyp,infos,nbOfStep,dtunit,loadAll,ms,entities) { }
- med_field_type getMEDFileFieldType() const { return MED_FLOAT32; }
+ med_field_type getMEDFileFieldType() const override { return MED_FLOAT32; }
public:
- MEDLOADER_EXPORT MEDFileFloatFieldMultiTSWithoutSDA() { }
+ MEDLOADER_EXPORT MEDFileFloatFieldMultiTSWithoutSDA() = default;
};
class MEDFileAnyTypeFieldMultiTSIterator;
protected:
MEDFileAnyTypeFieldMultiTS();
MEDFileAnyTypeFieldMultiTS(med_idt fid, bool loadAll, const MEDFileMeshes *ms);
- MEDFileAnyTypeFieldMultiTS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities=0);
+ MEDFileAnyTypeFieldMultiTS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities=nullptr);
MEDFileAnyTypeFieldMultiTS(const MEDFileAnyTypeFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent);
static MEDFileAnyTypeFieldMultiTS *BuildNewInstanceFromContent(MEDFileAnyTypeFieldMultiTSWithoutSDA *c, med_idt fid);
static MEDFileAnyTypeFieldMultiTSWithoutSDA *BuildContentFrom(med_idt fid, bool loadAll, const MEDFileMeshes *ms);
MEDLOADER_EXPORT void loadArraysIfNecessary();
MEDLOADER_EXPORT void unloadArrays();
MEDLOADER_EXPORT void unloadArraysWithoutDataLoss();
- MEDLOADER_EXPORT void writeLL(med_idt fid) const;
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDLOADER_EXPORT void writeLL(med_idt fid) const override;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
MEDLOADER_EXPORT virtual MEDFileAnyTypeFieldMultiTS *deepCopy() const;
MEDLOADER_EXPORT std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > > splitComponents() const;
MEDLOADER_EXPORT std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > > splitDiscretizations() const;
MEDLOADER_EXPORT virtual MEDFileAnyTypeFieldMultiTS *extractPart(const std::map<int, MCAuto<DataArrayIdType> >& extractDef, MEDFileMesh *mm) const = 0;
MEDLOADER_EXPORT static MCAuto<MEDFileAnyTypeFieldMultiTS> Aggregate(const std::vector<const MEDFileAnyTypeFieldMultiTS *>& fmtss, const std::vector< std::vector< std::pair<int,mcIdType> > >& dts);
public:
- MEDLOADER_EXPORT std::vector<std::string> getPflsReallyUsed() const;
- MEDLOADER_EXPORT std::vector<std::string> getLocsReallyUsed() const;
- MEDLOADER_EXPORT std::vector<std::string> getPflsReallyUsedMulti() const;
- MEDLOADER_EXPORT std::vector<std::string> getLocsReallyUsedMulti() const;
- MEDLOADER_EXPORT void changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif);
- MEDLOADER_EXPORT void changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif);
+ MEDLOADER_EXPORT std::vector<std::string> getPflsReallyUsed() const override;
+ MEDLOADER_EXPORT std::vector<std::string> getLocsReallyUsed() const override;
+ MEDLOADER_EXPORT std::vector<std::string> getPflsReallyUsedMulti() const override;
+ MEDLOADER_EXPORT std::vector<std::string> getLocsReallyUsedMulti() const override;
+ MEDLOADER_EXPORT void changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) override;
+ MEDLOADER_EXPORT void changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) override;
protected:
MEDFileAnyTypeFieldMultiTSWithoutSDA *contentNotNullBase();
const MEDFileAnyTypeFieldMultiTSWithoutSDA *contentNotNullBase() const;
MEDLOADER_EXPORT static typename MLFieldTraits<T>::FMTSType *New(const typename MLFieldTraits<T>::FMTSWSDAType& other, bool shallowCopyOfContent);
MEDLOADER_EXPORT static typename MLFieldTraits<T>::FMTSType *LoadSpecificEntities(const std::string& fileName, const std::string& fieldName, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> >& entities, bool loadAll=true);
MEDLOADER_EXPORT typename MLFieldTraits<T>::FMTSType *extractPartImpl(const std::map<int, MCAuto<DataArrayIdType> >& extractDef, MEDFileMesh *mm) const;
- MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTS *extractPart(const std::map<int, MCAuto<DataArrayIdType> >& extractDef, MEDFileMesh *mm) const { return this->extractPartImpl(extractDef,mm); }
+ MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTS *extractPart(const std::map<int, MCAuto<DataArrayIdType> >& extractDef, MEDFileMesh *mm) const override { return this->extractPartImpl(extractDef,mm); }
//
MEDLOADER_EXPORT typename Traits<T>::FieldType *field(int iteration, int order, const MEDFileMesh *mesh) const;
MEDLOADER_EXPORT typename Traits<T>::FieldType *getFieldAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, int renumPol=0) const;
MEDLOADER_EXPORT void appendFieldProfile(const typename Traits<T>::FieldType *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayIdType *profile);
MEDLOADER_EXPORT void appendFieldProfileFlatly(const typename Traits<T>::FieldType *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayIdType *profile);
//
- MEDLOADER_EXPORT typename MLFieldTraits<T>::F1TSType *getTimeStepAtPos(int pos) const;
+ MEDLOADER_EXPORT typename MLFieldTraits<T>::F1TSType *getTimeStepAtPos(int pos) const override;
MEDLOADER_EXPORT typename Traits<T>::ArrayType *getUndergroundDataArray(int iteration, int order) const;
MEDLOADER_EXPORT typename Traits<T>::ArrayType *getUndergroundDataArrayExt(int iteration, int order, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<mcIdType,mcIdType> > >& entries) const;
MEDLOADER_EXPORT typename MLFieldTraits<T>::FMTSType *buildNewEmptyImpl() const;
- MEDLOADER_EXPORT void checkCoherencyOfType(const MEDFileAnyTypeField1TS *f1ts) const;
+ MEDLOADER_EXPORT void checkCoherencyOfType(const MEDFileAnyTypeField1TS *f1ts) const override;
protected:
const typename MLFieldTraits<T>::FMTSWSDAType *contentNotNull() const;
typename MLFieldTraits<T>::FMTSWSDAType *contentNotNull();
void appendFieldProfileGeneral(const typename Traits<T>::FieldType *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayIdType *profile, bool smartPflKiller);
protected:
- ~MEDFileTemplateFieldMultiTS() { }
+ ~MEDFileTemplateFieldMultiTS() override = default;
MEDFileTemplateFieldMultiTS();
MEDFileTemplateFieldMultiTS(const typename MLFieldTraits<T>::FMTSWSDAType& other, bool shallowCopyOfContent);
MEDFileTemplateFieldMultiTS(med_idt fid, bool loadAll, const MEDFileMeshes *ms);
- MEDFileTemplateFieldMultiTS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities=0);
+ MEDFileTemplateFieldMultiTS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities=nullptr);
};
class MEDFileIntFieldMultiTS;
{
friend class MEDFileTemplateFieldMultiTS<double>;
public:
- MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTS *shallowCpy() const;
+ MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTS *shallowCpy() const override;
MEDLOADER_EXPORT MEDFileInt32FieldMultiTS *convertToInt(bool isDeepCpyGlobs=true) const;
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileFieldMultiTS"); }
//
MEDLOADER_EXPORT std::vector< std::vector<DataArrayDouble *> > getFieldSplitedByType2(int iteration, int order, const std::string& mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const;
- MEDLOADER_EXPORT MEDFileFieldMultiTS *buildNewEmpty() const { return buildNewEmptyImpl(); }
+ MEDLOADER_EXPORT MEDFileFieldMultiTS *buildNewEmpty() const override { return buildNewEmptyImpl(); }
public:
private:
- ~MEDFileFieldMultiTS() { }
+ ~MEDFileFieldMultiTS() override = default;
MEDFileFieldMultiTS() { }
MEDFileFieldMultiTS(const MEDFileFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent);
MEDFileFieldMultiTS(med_idt fid, bool loadAll, const MEDFileMeshes *ms);
- MEDFileFieldMultiTS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities=0);
+ MEDFileFieldMultiTS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities=nullptr);
};
template<class T>
public:
MEDLOADER_EXPORT MEDFileFieldMultiTS *convertToDouble(bool isDeepCpyGlobs=true) const;
protected:
- ~MEDFileNDTemplateFieldMultiTS() { }
+ ~MEDFileNDTemplateFieldMultiTS() override = default;
MEDFileNDTemplateFieldMultiTS() { }
MEDFileNDTemplateFieldMultiTS(const typename MLFieldTraits<T>::FMTSWSDAType& other, bool shallowCopyOfContent):MEDFileTemplateFieldMultiTS<T>(other,shallowCopyOfContent) { }
MEDFileNDTemplateFieldMultiTS(med_idt fid, bool loadAll, const MEDFileMeshes *ms):MEDFileTemplateFieldMultiTS<T>(fid,loadAll,ms) { }
{
friend class MEDFileTemplateFieldMultiTS<Int32>;
public:
- MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTS *shallowCpy() const { return new MEDFileInt32FieldMultiTS(*this); }
- MEDLOADER_EXPORT MEDFileInt32FieldMultiTS *buildNewEmpty() const { return buildNewEmptyImpl(); }
+ MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTS *shallowCpy() const override { return new MEDFileInt32FieldMultiTS(*this); }
+ MEDLOADER_EXPORT MEDFileInt32FieldMultiTS *buildNewEmpty() const override { return buildNewEmptyImpl(); }
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileInt32FieldMultiTS"); }
private:
- ~MEDFileInt32FieldMultiTS() { }
+ ~MEDFileInt32FieldMultiTS() override = default;
MEDFileInt32FieldMultiTS() { }
MEDFileInt32FieldMultiTS(const MEDFileInt32FieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileNDTemplateFieldMultiTS<Int32>(other,shallowCopyOfContent) { }
MEDFileInt32FieldMultiTS(med_idt fid, bool loadAll, const MEDFileMeshes *ms):MEDFileNDTemplateFieldMultiTS<Int32>(fid,loadAll,ms) { }
- MEDFileInt32FieldMultiTS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities=0):MEDFileNDTemplateFieldMultiTS<Int32>(fid,fieldName,loadAll,ms,entities) { }
+ MEDFileInt32FieldMultiTS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities=nullptr):MEDFileNDTemplateFieldMultiTS<Int32>(fid,fieldName,loadAll,ms,entities) { }
};
/*!
{
friend class MEDFileTemplateFieldMultiTS<Int64>;
public:
- MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTS *shallowCpy() const { return new MEDFileInt64FieldMultiTS(*this); }
- MEDLOADER_EXPORT MEDFileInt64FieldMultiTS *buildNewEmpty() const { return buildNewEmptyImpl(); }
+ MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTS *shallowCpy() const override { return new MEDFileInt64FieldMultiTS(*this); }
+ MEDLOADER_EXPORT MEDFileInt64FieldMultiTS *buildNewEmpty() const override { return buildNewEmptyImpl(); }
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileInt64FieldMultiTS"); }
private:
- ~MEDFileInt64FieldMultiTS() { }
+ ~MEDFileInt64FieldMultiTS() override = default;
MEDFileInt64FieldMultiTS() { }
MEDFileInt64FieldMultiTS(const MEDFileInt64FieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileNDTemplateFieldMultiTS<Int64>(other,shallowCopyOfContent) { }
MEDFileInt64FieldMultiTS(med_idt fid, bool loadAll, const MEDFileMeshes *ms):MEDFileNDTemplateFieldMultiTS<Int64>(fid,loadAll,ms) { }
- MEDFileInt64FieldMultiTS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities=0):MEDFileNDTemplateFieldMultiTS<Int64>(fid,fieldName,loadAll,ms,entities) { }
+ MEDFileInt64FieldMultiTS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities=nullptr):MEDFileNDTemplateFieldMultiTS<Int64>(fid,fieldName,loadAll,ms,entities) { }
};
/*!
{
friend class MEDFileTemplateFieldMultiTS<float>;
public:
- MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTS *shallowCpy() const { return new MEDFileFloatFieldMultiTS(*this); }
- MEDLOADER_EXPORT MEDFileFloatFieldMultiTS *buildNewEmpty() const { return buildNewEmptyImpl(); }
+ MEDLOADER_EXPORT MEDFileAnyTypeFieldMultiTS *shallowCpy() const override { return new MEDFileFloatFieldMultiTS(*this); }
+ MEDLOADER_EXPORT MEDFileFloatFieldMultiTS *buildNewEmpty() const override { return buildNewEmptyImpl(); }
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileFloatFieldMultiTS"); }
private:
- ~MEDFileFloatFieldMultiTS() { }
+ ~MEDFileFloatFieldMultiTS() override = default;
MEDFileFloatFieldMultiTS() { }
MEDFileFloatFieldMultiTS(const MEDFileFloatFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileNDTemplateFieldMultiTS<float>(other,shallowCopyOfContent) { }
MEDFileFloatFieldMultiTS(med_idt fid, bool loadAll, const MEDFileMeshes *ms):MEDFileNDTemplateFieldMultiTS<float>(fid,loadAll,ms) { }
- MEDFileFloatFieldMultiTS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities=0):MEDFileNDTemplateFieldMultiTS<float>(fid,fieldName,loadAll,ms,entities) { }
+ MEDFileFloatFieldMultiTS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities=nullptr):MEDFileNDTemplateFieldMultiTS<float>(fid,fieldName,loadAll,ms,entities) { }
};
class MEDFileAnyTypeFieldMultiTSIterator
// Author : Anthony Geay (CEA/DEN)
#include "MEDFileFieldOverView.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MCIdType.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingPartDefinition.hxx"
+#include "MEDCoupling1GTUMesh.hxx"
+#include "MEDCouplingPointSet.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MEDCouplingStructuredMesh.hxx"
#include "MEDFileField.hxx"
+#include "MEDFileFieldInternal.hxx"
#include "MEDFileMesh.hxx"
#include "MEDCouplingFieldDiscretization.hxx"
#include "CellModel.hxx"
+#include <cstddef>
+#include <vector>
+#include <algorithm>
+#include "NormalizedGeometricTypes"
+#include <set>
+#include <utility>
+#include <iterator>
+#include <functional>
+#include <sstream>
+#include <limits>
+#include <ostream>
using namespace MEDCoupling;
std::size_t MEDFileMeshStruct::getHeapMemorySizeWithoutChildren() const
{
std::size_t ret(0);
- for(std::vector< std::vector<mcIdType> >::const_iterator it0=_geo_types_distrib.begin();it0!=_geo_types_distrib.end();it0++)
- ret+=(*it0).capacity()*sizeof(int);
+ for(const auto & it0 : _geo_types_distrib)
+ ret+=it0.capacity()*sizeof(int);
ret+=_geo_types_distrib.capacity()*sizeof(std::vector<mcIdType>);
return ret;
}
if(!levs.empty())
{
_geo_types_distrib.resize(-(*std::min_element(levs.begin(),levs.end()))+1);
- for(std::vector<int>::const_iterator lev=levs.begin();lev!=levs.end();lev++)
- _geo_types_distrib[-(*lev)]=mesh->getDistributionOfTypes(*lev);
+ for(int const lev : levs)
+ _geo_types_distrib[-lev]=mesh->getDistributionOfTypes(lev);
}
}
int MEDFileMeshStruct::getLevelOfGeoType(INTERP_KERNEL::NormalizedCellType t) const
{
int j=0;
- for(std::vector< std::vector<mcIdType> >::const_iterator it1=_geo_types_distrib.begin();it1!=_geo_types_distrib.end();it1++,j--)
+ for(auto it1=_geo_types_distrib.begin();it1!=_geo_types_distrib.end();it1++,j--)
{
- std::size_t sz=(*it1).size();
+ std::size_t const sz=(*it1).size();
if(sz%3!=0)
throw INTERP_KERNEL::Exception("MEDFileMeshStruct::getLevelOfGeoType : internal error in code !");
- std::size_t nbGeo=sz/3;
+ std::size_t const nbGeo=sz/3;
for(std::size_t i=0;i<nbGeo;i++)
if((*it1)[3*i]==(int)t)
return j;
*/
mcIdType MEDFileMeshStruct::getNumberOfElemsOfGeoType(INTERP_KERNEL::NormalizedCellType t) const
{
- for(std::vector< std::vector<mcIdType> >::const_iterator it1=_geo_types_distrib.begin();it1!=_geo_types_distrib.end();it1++)
+ for(const auto & it1 : _geo_types_distrib)
{
- std::size_t sz=(*it1).size();
+ std::size_t const sz=it1.size();
if(sz%3!=0)
throw INTERP_KERNEL::Exception("MEDFileMeshStruct::getNumberOfElemsOfGeoType : internal error in code !");
- std::size_t nbGeo=sz/3;
+ std::size_t const nbGeo=sz/3;
for(std::size_t i=0;i<nbGeo;i++)
- if((*it1)[3*i]==(int)t)
- return (*it1)[3*i+1];
+ if(it1[3*i]==(int)t)
+ return it1[3*i+1];
}
throw INTERP_KERNEL::Exception("The specified geometric type is not present in the mesh structure !");
}
*/
bool MEDFileMeshStruct::doesManageGeoType(INTERP_KERNEL::NormalizedCellType t) const
{
- for(std::vector< std::vector<mcIdType> >::const_iterator it1=_geo_types_distrib.begin();it1!=_geo_types_distrib.end();it1++)
+ for(const auto & it1 : _geo_types_distrib)
{
- std::size_t sz=(*it1).size();
+ std::size_t const sz=it1.size();
if(sz%3!=0)
throw INTERP_KERNEL::Exception("MEDFileMeshStruct::doesManageGeoType : internal error in code !");
- std::size_t nbGeo=sz/3;
+ std::size_t const nbGeo=sz/3;
for(std::size_t i=0;i<nbGeo;i++)
- if((*it1)[3*i]==(int)t)
+ if(it1[3*i]==(int)t)
return true;
}
return false;
static const char MSG[]="MEDFileMeshStruct::appendIfImplicitType : the distribution does not looks like structured standard !";
if(_geo_types_distrib.size()!=1)
throw INTERP_KERNEL::Exception(MSG);
- std::size_t sz(_geo_types_distrib[0].size());
+ std::size_t const sz(_geo_types_distrib[0].size());
if(sz%3!=0)
throw INTERP_KERNEL::Exception("MEDFileMeshStruct::appendIfImplicitType : internal error in code !");
- std::size_t nbGeo(sz/3);
+ std::size_t const nbGeo(sz/3);
if(nbGeo!=1)
throw INTERP_KERNEL::Exception(MSG);
std::vector<mcIdType> arr(3); arr[0]=(mcIdType)t; arr[1]=_mesh->buildImplicitPartIfAny(t); arr[2]=-1;
int MEDFileMeshStruct::getNumberOfGeoTypesInLev(int relativeLev) const
{
- int pos(-relativeLev);
+ int const pos(-relativeLev);
if(pos<0 || pos>=(int)_geo_types_distrib.size())
throw INTERP_KERNEL::Exception("MEDFileMeshStruct::getNumberOfGeoTypesInLev : invalid level specified !");
- std::size_t sz=_geo_types_distrib[pos].size();
+ std::size_t const sz=_geo_types_distrib[pos].size();
if(sz%3!=0)
throw INTERP_KERNEL::Exception("MEDFileMeshStruct::getNumberOfGeoTypesInLev : internal error in code !");
return (int)(sz/3);
{
if(!m)
throw INTERP_KERNEL::Exception("MEDMeshMultiLev::New : null input pointer !");
- const MEDFileUMesh *um(dynamic_cast<const MEDFileUMesh *>(m));
+ const auto *um(dynamic_cast<const MEDFileUMesh *>(m));
if(um)
return MEDUMeshMultiLev::New(um,levs);
- const MEDFileCMesh *cm(dynamic_cast<const MEDFileCMesh *>(m));
+ const auto *cm(dynamic_cast<const MEDFileCMesh *>(m));
if(cm)
return MEDCMeshMultiLev::New(cm,levs);
- const MEDFileCurveLinearMesh *clm(dynamic_cast<const MEDFileCurveLinearMesh *>(m));
+ const auto *clm(dynamic_cast<const MEDFileCurveLinearMesh *>(m));
if(clm)
return MEDCurveLinearMeshMultiLev::New(clm,levs);
throw INTERP_KERNEL::Exception("MEDMeshMultiLev::New : unrecognized type of mesh ! Must be in [MEDFileUMesh,MEDFileCMesh,MEDFileCurveLinearMesh] !");
{
if(!m)
throw INTERP_KERNEL::Exception("MEDMeshMultiLev::New 2 : null input pointer !");
- const MEDFileUMesh *um(dynamic_cast<const MEDFileUMesh *>(m));
+ const auto *um(dynamic_cast<const MEDFileUMesh *>(m));
if(um)
return MEDUMeshMultiLev::New(um,gts,pfls,nbEntities);
- const MEDFileCMesh *cm(dynamic_cast<const MEDFileCMesh *>(m));
+ const auto *cm(dynamic_cast<const MEDFileCMesh *>(m));
if(cm)
return MEDCMeshMultiLev::New(cm,gts,pfls,nbEntities);
- const MEDFileCurveLinearMesh *clm(dynamic_cast<const MEDFileCurveLinearMesh *>(m));
+ const auto *clm(dynamic_cast<const MEDFileCurveLinearMesh *>(m));
if(clm)
return MEDCurveLinearMeshMultiLev::New(clm,gts,pfls,nbEntities);
throw INTERP_KERNEL::Exception("MEDMeshMultiLev::New 2 : unrecognized type of mesh ! Must be in [MEDFileUMesh,MEDFileCMesh,MEDFileCurveLinearMesh] !");
cr->incrRef();
}
-bool MEDMeshMultiLev::isFastlyTheSameStruct(const MEDFileField1TSStructItem& fst, const MEDFileFieldGlobsReal *globs) const
+bool MEDMeshMultiLev::isFastlyTheSameStruct(const MEDFileField1TSStructItem& fst, const MEDFileFieldGlobsReal * /*globs*/) const
{
if(fst.getType()==ON_NODES)
{
if(fst.getNumberOfItems()!=1)
throw INTERP_KERNEL::Exception("MEDMeshMultiLev::isFastlyTheSameStruct : unexpected situation for nodes !");
const MEDFileField1TSStructItem2& p(fst[0]);
- std::string pflName(p.getPflName());
+ std::string const pflName(p.getPflName());
const DataArrayIdType *nr(_node_reduction);
if(pflName.empty() && !nr)
return true;
}
else
{
- std::size_t sz(fst.getNumberOfItems());
+ std::size_t const sz(fst.getNumberOfItems());
if(sz!=_geo_types.size())
return false;
mcIdType strt(0);
{
const DataArrayIdType *fids(_cell_fam_ids);
if(!fids)
- { famIds=0; isWithoutCopy=true; return ; }
- std::size_t sz(_geo_types.size());
+ { famIds=nullptr; isWithoutCopy=true; return ; }
+ std::size_t const sz(_geo_types.size());
bool presenceOfPfls(false);
for(std::size_t i=0;i<sz && !presenceOfPfls;i++)
{
for(std::size_t i=0;i<sz;i++)
{
const DataArrayIdType *pfl(_pfls[i]);
- mcIdType lgth(_nb_entities[i]);
+ mcIdType const lgth(_nb_entities[i]);
if(pfl)
{
MCAuto<DataArrayIdType> tmp(fids->selectByTupleIdSafeSlice(start,start+lgth,1));
{
const DataArrayIdType *nids(_cell_num_ids);
if(!nids)
- { numIds=0; isWithoutCopy=true; return ; }
- std::size_t sz(_geo_types.size());
+ { numIds=nullptr; isWithoutCopy=true; return ; }
+ std::size_t const sz(_geo_types.size());
bool presenceOfPfls(false);
for(std::size_t i=0;i<sz && !presenceOfPfls;i++)
{
for(std::size_t i=0;i<sz;i++)
{
const DataArrayIdType *pfl(_pfls[i]);
- mcIdType lgth(_nb_entities[i]);
+ mcIdType const lgth(_nb_entities[i]);
if(pfl)
{
MCAuto<DataArrayIdType> tmp(nids->selectByTupleIdSafeSlice(start,start+lgth,1));
{
const DataArrayIdType *fids(_node_fam_ids);
if(!fids)
- { famIds=0; isWithoutCopy=true; return ; }
+ { famIds=nullptr; isWithoutCopy=true; return ; }
const DataArrayIdType *nr(_node_reduction);
if(nr)
{
{
const DataArrayIdType *fids(_node_num_ids);
if(!fids)
- { numIds=0; isWithoutCopy=true; return ; }
+ { numIds=nullptr; isWithoutCopy=true; return ; }
const DataArrayIdType *nr(_node_reduction);
if(nr)
{
*/
DataArrayIdType *MEDMeshMultiLev::retrieveGlobalNodeIdsIfAny() const
{
- const MEDFileUMesh *umesh(dynamic_cast<const MEDFileUMesh *>(_mesh));
+ const auto *umesh(dynamic_cast<const MEDFileUMesh *>(_mesh));
if(!umesh)
return nullptr;
const PartDefinition *pd(umesh->getPartDefAtLevel(1));
std::string MEDMeshMultiLev::getPflNameOfId(int id) const
{
- std::size_t sz(_pfls.size());
+ std::size_t const sz(_pfls.size());
if(id<0 || id>=(int)sz)
throw INTERP_KERNEL::Exception("MEDMeshMultiLev::getPflNameOfId : invalid input id !");
const DataArrayIdType *pfl(_pfls[id]);
*/
mcIdType MEDMeshMultiLev::getNumberOfCells(INTERP_KERNEL::NormalizedCellType t) const
{
- std::size_t sz(_nb_entities.size());
+ std::size_t const sz(_nb_entities.size());
for(std::size_t i=0;i<sz;i++)
if(_geo_types[i]==t)
return _nb_entities[i];
if(fst.getNumberOfItems()!=1)
throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for nodes !");
const MEDFileField1TSStructItem2& p(fst[0]);
- std::string pflName(p.getPflName());
+ std::string const pflName(p.getPflName());
const DataArrayIdType *nr(_node_reduction);
if(pflName.empty() && !nr)
return vals->deepCopy();
}
else
{
- std::size_t sz(fst.getNumberOfItems());
- std::set<INTERP_KERNEL::NormalizedCellType> s(_geo_types.begin(),_geo_types.end());
+ std::size_t const sz(fst.getNumberOfItems());
+ std::set<INTERP_KERNEL::NormalizedCellType> const s(_geo_types.begin(),_geo_types.end());
if(s.size()!=_geo_types.size())
throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for cells 2 !");
std::vector< const DataArray *> arr(s.size());
std::vector< MCAuto<DataArray> > arrSafe(s.size());
int iii(0);
- mcIdType nc(ToIdType(vals->getNumberOfComponents()));
- std::vector<std::string> compInfo(vals->getInfoOnComponents());
- for(std::vector< INTERP_KERNEL::NormalizedCellType >::const_iterator it=_geo_types.begin();it!=_geo_types.end();it++,iii++)
+ mcIdType const nc(ToIdType(vals->getNumberOfComponents()));
+ std::vector<std::string> const compInfo(vals->getInfoOnComponents());
+ for(auto it=_geo_types.begin();it!=_geo_types.end();it++,iii++)
{
const DataArrayIdType *thisP(_pfls[iii]);
std::vector<const MEDFileField1TSStructItem2 *> ps;
throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for cells 1 !");
if(ps.size()==1)
{
- int nbi(ps[0]->getNbOfIntegrationPts(globs));
+ int const nbi(ps[0]->getNbOfIntegrationPts(globs));
const DataArrayIdType *otherP(ps[0]->getPfl(globs));
const std::pair<int,int>& strtStop(ps[0]->getStartStop());
MCAuto<DataArray> ret(vals->selectByTupleIdSafeSlice(strtStop.first,strtStop.second,1));
int jj(0);
for(std::vector<const MEDFileField1TSStructItem2 *>::const_iterator it2=ps.begin();it2!=ps.end();it2++,jj++)
{
- int nbi((*it2)->getNbOfIntegrationPts(globs));
+ int const nbi((*it2)->getNbOfIntegrationPts(globs));
const DataArrayIdType *otherPfl((*it2)->getPfl(globs));
const std::pair<int,int>& strtStop((*it2)->getStartStop());
MCAuto<DataArray> ret2(vals->selectByTupleIdSafeSlice(strtStop.first,strtStop.second,1));
*/
void MEDMeshMultiLev::appendVertices(const DataArrayIdType *verticesToAdd, DataArrayIdType *nr)
{
- mcIdType nbOfVertices(verticesToAdd->getNumberOfTuples());
- std::size_t sz(_pfls.size());
+ mcIdType const nbOfVertices(verticesToAdd->getNumberOfTuples());
+ std::size_t const sz(_pfls.size());
_pfls.resize(sz+1);
_geo_types.resize(sz+1,INTERP_KERNEL::NORM_POINT1);
_nb_entities.resize(sz+1,nbOfVertices);
MEDMeshMultiLev::MEDMeshMultiLev(const MEDFileMesh *mesh, mcIdType nbNodes, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayIdType *>& pfls, const std::vector<mcIdType>& nbEntities):_mesh(mesh),_geo_types(gts),_nb_entities(nbEntities),_nb_nodes(nbNodes)
{
- std::size_t sz(_geo_types.size());
+ std::size_t const sz(_geo_types.size());
if(sz!=pfls.size() || sz!=nbEntities.size())
throw INTERP_KERNEL::Exception("MEDMeshMultiLev::MEDMeshMultiLev : input vector must have the same size !");
_pfls.resize(sz);
}
}
-MEDMeshMultiLev::MEDMeshMultiLev(const MEDMeshMultiLev& other):RefCountObject(other),_mesh(other._mesh),_pfls(other._pfls),_geo_types(other._geo_types),_nb_entities(other._nb_entities),_node_reduction(other._node_reduction),_nb_nodes(other._nb_nodes),_cell_fam_ids(other._cell_fam_ids),_cell_num_ids(other._cell_num_ids),_node_fam_ids(other._node_fam_ids),_node_num_ids(other._node_num_ids)
-{
-}
+MEDMeshMultiLev::MEDMeshMultiLev(const MEDMeshMultiLev& other)
+= default;
//=
if(!m)
throw INTERP_KERNEL::Exception("MEDUMeshMultiLev constructor : null input pointer !");
std::vector<MEDCoupling1GTUMesh *> v;
- for(std::vector<int>::const_iterator it=levs.begin();it!=levs.end();it++)
+ for(int const lev : levs)
{
- std::vector<MEDCoupling1GTUMesh *> vTmp(m->getDirectUndergroundSingleGeoTypeMeshes(*it));
+ std::vector<MEDCoupling1GTUMesh *> vTmp(m->getDirectUndergroundSingleGeoTypeMeshes(lev));
v.insert(v.end(),vTmp.begin(),vTmp.end());
}
- std::size_t sz(v.size());
+ std::size_t const sz(v.size());
if(v.empty())
{
_coords=m->getCoords(); _coords->incrRef();
_nb_entities[i]=obj->getNumberOfCells();
}
// ids fields management
- bool cellFamIdsNoCpy(levs.size()==1);
+ bool const cellFamIdsNoCpy(levs.size()==1);
if(cellFamIdsNoCpy)
{
const DataArrayIdType *tmp(m->getFamilyFieldAtLevel(levs[0]));
if(f && !tmps.empty())
_cell_fam_ids=DataArrayIdType::Aggregate(tmps);
}
- bool cellNumIdsNoCpy(levs.size()==1);
+ bool const cellNumIdsNoCpy(levs.size()==1);
if(cellNumIdsNoCpy)
{
const DataArrayIdType *tmp(m->getNumberFieldAtLevel(levs[0]));
MEDUMeshMultiLev::MEDUMeshMultiLev(const MEDFileUMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayIdType *>& pfls, const std::vector<mcIdType>& nbEntities):MEDMeshMultiLev(m,m->getNumberOfNodes(),gts,pfls,nbEntities)
{
- std::size_t sz(gts.size());
+ std::size_t const sz(gts.size());
if(sz<1)
throw INTERP_KERNEL::Exception("constructor of MEDUMeshMultiLev : number of different geo type must be >= 1 !");
- unsigned dim(INTERP_KERNEL::CellModel::GetCellModel(gts[0]).getDimension());
+ unsigned const dim(INTERP_KERNEL::CellModel::GetCellModel(gts[0]).getDimension());
_parts.resize(sz);
bool isSameDim(true),isNoPfl(true);
for(std::size_t i=0;i<sz;i++)
_parts[i]=elt;
}
// ids fields management
- int lev((int)dim-m->getMeshDimension());
+ int const lev((int)dim-m->getMeshDimension());
if(isSameDim && isNoPfl && m->getGeoTypesAtLevel(lev)==gts)//optimized part
{
const DataArrayIdType *famIds(m->getFamilyFieldAtLevel(lev));
{
if(!pflNodes || !pflNodes->isAllocated())
return ;
- std::size_t sz(_parts.size());
+ std::size_t const sz(_parts.size());
std::vector< MCAuto<DataArrayIdType> > a(sz);
std::vector< const DataArrayIdType *> aa(sz);
for(std::size_t i=0;i<sz;i++)
MCAuto<MEDCoupling1GTUMesh> m(_parts[i]);
if(pfl)
m=dynamic_cast<MEDCoupling1GTUMesh *>(_parts[i]->buildPartOfMySelfKeepCoords(pfl->begin(),pfl->end()));
- DataArrayIdType *cellIds=0;
+ DataArrayIdType *cellIds=nullptr;
m->fillCellIdsToKeepFromNodeIds(pflNodes->begin(),pflNodes->end(),true,cellIds);
- MCAuto<DataArrayIdType> cellIdsSafe(cellIds);
+ MCAuto<DataArrayIdType> const cellIdsSafe(cellIds);
MCAuto<MEDCouplingPointSet> m2(m->buildPartOfMySelfKeepCoords(cellIds->begin(),cellIds->end()));
mcIdType tmp=-1;
MCAuto<DataArrayIdType> o2n(m2->getNodeIdsInUse(tmp));
return new MEDUMeshMultiLev(*this);
}
-MEDUMeshMultiLev::MEDUMeshMultiLev(const MEDUMeshMultiLev& other):MEDMeshMultiLev(other),_parts(other._parts),_coords(other._coords)
-{
-}
+MEDUMeshMultiLev::MEDUMeshMultiLev(const MEDUMeshMultiLev& other)
+= default;
MEDUMeshMultiLev::MEDUMeshMultiLev(const MEDStructuredMeshMultiLev& other, const MCAuto<MEDCoupling1GTUMesh>& part):MEDMeshMultiLev(other)
{
_parts[0]=part;
_geo_types.resize(1); _geo_types[0]=part->getCellModelEnum();
_nb_entities.resize(1); _nb_entities[0]=part->getNumberOfCells();
- _pfls.resize(1); _pfls[0]=0;
+ _pfls.resize(1); _pfls[0]=nullptr;
}
/*!
*/
bool MEDUMeshMultiLev::buildVTUArrays(DataArrayDouble *& coords, DataArrayByte *&types, DataArrayIdType *&cellLocations, DataArrayIdType *& cells, DataArrayIdType *&faceLocations, DataArrayIdType *&faces) const
{
- const DataArrayDouble *tmp(0);
+ const DataArrayDouble *tmp(nullptr);
if(_parts.empty())
tmp=_coords;
else
mcIdType szBCE(0),szD(0),szF(0);
bool isPolyh(false);
int iii(0);
- for(std::vector< MCAuto<MEDCoupling1GTUMesh> >::const_iterator it=_parts.begin();it!=_parts.end();it++,iii++)
+ for(auto it=_parts.begin();it!=_parts.end();it++,iii++)
{
const MEDCoupling1GTUMesh *cur(*it);
if(!cur)
else
{ cur2=dynamic_cast<MEDCoupling1GTUMesh *>(cur->buildPartOfMySelfKeepCoords(pfl->begin(),pfl->end())); cur=cur2; }
//
- mcIdType curNbCells(cur->getNumberOfCells());
+ mcIdType const curNbCells(cur->getNumberOfCells());
szBCE+=curNbCells;
if((*it)->getCellModelEnum()!=INTERP_KERNEL::NORM_POLYHED)
szD+=cur->getNodalConnectivity()->getNumberOfTuples()+curNbCells;
MCAuto<DataArrayByte> b(DataArrayByte::New()); b->alloc(szBCE,1); char *bPtr(b->getPointer());
MCAuto<DataArrayIdType> c(DataArrayIdType::New()); c->alloc(szBCE,1); mcIdType *cPtr(c->getPointer());
MCAuto<DataArrayIdType> d(DataArrayIdType::New()); d->alloc(szD,1); mcIdType *dPtr(d->getPointer());
- MCAuto<DataArrayIdType> e(DataArrayIdType::New()),f(DataArrayIdType::New()); mcIdType *ePtr(0),*fPtr(0);
+ MCAuto<DataArrayIdType> e(DataArrayIdType::New()),f(DataArrayIdType::New()); mcIdType *ePtr(nullptr),*fPtr(nullptr);
if(isPolyh)
{ e->alloc(szBCE,1); ePtr=e->getPointer(); f->alloc(szF,1); fPtr=f->getPointer(); }
mcIdType k(0);
iii=0;
- for(std::vector< MCAuto<MEDCoupling1GTUMesh> >::const_iterator it=_parts.begin();it!=_parts.end();it++,iii++)
+ for(auto it=_parts.begin();it!=_parts.end();it++,iii++)
{
const MEDCoupling1GTUMesh *cur(*it);
//
else
{ cur2=dynamic_cast<MEDCoupling1GTUMesh *>(cur->buildPartOfMySelfKeepCoords(pfl->begin(),pfl->end())); cur=cur2; }
//
- mcIdType curNbCells(cur->getNumberOfCells());
- int gt((int)cur->getCellModelEnum());
+ mcIdType const curNbCells(cur->getNumberOfCells());
+ int const gt((int)cur->getCellModelEnum());
if(gt<0 || gt>=PARAMEDMEM_2_VTKTYPE_LGTH)
throw INTERP_KERNEL::Exception("MEDUMeshMultiLev::getVTUArrays : invalid geometric type !");
- unsigned char gtvtk(PARAMEDMEM_2_VTKTYPE[gt]);
+ unsigned char const gtvtk(PARAMEDMEM_2_VTKTYPE[gt]);
if(gtvtk==255)
throw INTERP_KERNEL::Exception("MEDUMeshMultiLev::getVTUArrays : no VTK type for the requested INTERP_KERNEL geometric type !");
std::fill(bPtr,bPtr+curNbCells,gtvtk); bPtr+=curNbCells;
- const MEDCoupling1SGTUMesh *scur(dynamic_cast<const MEDCoupling1SGTUMesh *>(cur));
- const MEDCoupling1DGTUMesh *dcur(dynamic_cast<const MEDCoupling1DGTUMesh *>(cur));
+ const auto *scur(dynamic_cast<const MEDCoupling1SGTUMesh *>(cur));
+ const auto *dcur(dynamic_cast<const MEDCoupling1DGTUMesh *>(cur));
const mcIdType *connPtr(cur->getNodalConnectivity()->begin());
if(!scur && !dcur)
throw INTERP_KERNEL::Exception("MEDUMeshMultiLev::getVTUArrays : internal error !");
{
if(cur->getCellModelEnum()!=INTERP_KERNEL::NORM_HEXA27)
{
- mcIdType nnpc(scur->getNumberOfNodesPerCell());
+ mcIdType const nnpc(scur->getNumberOfNodesPerCell());
for(mcIdType i=0;i<curNbCells;i++,connPtr+=nnpc)
{
*dPtr++=nnpc;
mcIdType kk(0);
for(int i=0;i<curNbCells;i++,connIPtr++)
{
- mcIdType nbFace(ToIdType(std::count(connPtr+connIPtr[0],connPtr+connIPtr[1],-1)+1));
+ mcIdType const nbFace(ToIdType(std::count(connPtr+connIPtr[0],connPtr+connIPtr[1],-1)+1));
*fPtr++=nbFace;
const mcIdType *work(connPtr+connIPtr[0]);
for(int j=0;j<nbFace;j++)
}
}
if(!isPolyh)
- reorderNodesIfNecessary(a,d,0);
+ reorderNodesIfNecessary(a,d,nullptr);
else
reorderNodesIfNecessary(a,d,f);
if(a->getNumberOfComponents()!=3)
a=a->changeNbOfComponents(3,0.);
coords=a.retn(); types=b.retn(); cellLocations=c.retn(); cells=d.retn();
if(!isPolyh)
- { faceLocations=0; faces=0; }
+ { faceLocations=nullptr; faces=nullptr; }
else
{ faceLocations=e.retn(); faces=f.retn(); }
return _mesh->isObjectInTheProgeny(coords);
coords=(coords->selectByTupleIdSafe(nr->begin(),nr->end()));
return ;
}
- mcIdType sz(coords->getNumberOfTuples());
+ mcIdType const sz(coords->getNumberOfTuples());
std::vector<bool> b(sz,false);
const mcIdType *work(nodalConnVTK->begin()),*endW(nodalConnVTK->end());
while(work!=endW)
{
- mcIdType nb(*work++);
+ mcIdType const nb(*work++);
for(mcIdType i=0;i<nb && work!=endW;i++,work++)
{
if(*work>=0 && *work<sz)
work=polyhedNodalConnVTK->begin(); endW=polyhedNodalConnVTK->end();
while(work!=endW)
{
- mcIdType nb(*work++);
+ mcIdType const nb(*work++);
for(mcIdType i=0;i<nb && work!=endW;i++)
{
- mcIdType nb2(*work++);
+ mcIdType const nb2(*work++);
for(mcIdType j=0;j<nb2 && work!=endW;j++,work++)
{
if(*work>=0 && *work<sz)
}
}
}
- std::size_t szExp(std::count(b.begin(),b.end(),true));
+ std::size_t const szExp(std::count(b.begin(),b.end(),true));
if(ToIdType(szExp)!=nr->getNumberOfTuples())
throw INTERP_KERNEL::Exception("MEDUMeshMultiLev::reorderNodesIfNecessary : internal error #3 !");
// Go renumbering !
mcIdType *work2(nodalConnVTK->getPointer()),*endW2(nodalConnVTK->getPointer()+nodalConnVTK->getNumberOfTuples());
while(work2!=endW2)
{
- mcIdType nb(*work2++);
+ mcIdType const nb(*work2++);
for(mcIdType i=0;i<nb && work2!=endW2;i++,work2++)
*work2=permPtr[o2nPtrc[*work2]];
}
work2=polyhedNodalConnVTK->getPointer(); endW2=polyhedNodalConnVTK->getPointer()+polyhedNodalConnVTK->getNumberOfTuples();
while(work2!=endW2)
{
- mcIdType nb(*work2++);
+ mcIdType const nb(*work2++);
for(mcIdType i=0;i<nb && work2!=endW2;i++)
{
- mcIdType nb2(*work2++);
+ mcIdType const nb2(*work2++);
for(mcIdType j=0;j<nb2 && work2!=endW2;j++,work2++)
*work2=permPtr[o2nPtrc[*work2]];
}
void MEDUMeshMultiLev::appendVertices(const DataArrayIdType *verticesToAdd, DataArrayIdType *nr)
{
- mcIdType nbOfCells(verticesToAdd->getNumberOfTuples());//it is not a bug cells are NORM_POINT1
+ mcIdType const nbOfCells(verticesToAdd->getNumberOfTuples());//it is not a bug cells are NORM_POINT1
MEDMeshMultiLev::appendVertices(verticesToAdd,nr);
MCAuto<MEDCoupling1SGTUMesh> elt(MEDCoupling1SGTUMesh::New("",INTERP_KERNEL::NORM_POINT1));
elt->allocateCells(nbOfCells);
//=
-MEDStructuredMeshMultiLev::MEDStructuredMeshMultiLev(const MEDFileStructuredMesh *m, const std::vector<int>& lev):MEDMeshMultiLev(m),_is_internal(true)
+MEDStructuredMeshMultiLev::MEDStructuredMeshMultiLev(const MEDFileStructuredMesh *m, const std::vector<int>& /*lev*/):MEDMeshMultiLev(m),_is_internal(true)
{
initStdFieldOfIntegers(m);
}
void MEDStructuredMeshMultiLev::initStdFieldOfIntegers(const MEDFileStructuredMesh *m)
{
// ids fields management
- const DataArrayIdType *tmp(0);
+ const DataArrayIdType *tmp(nullptr);
tmp=m->getFamilyFieldAtLevel(0);
if(tmp)
{
_cell_num_ids=const_cast<DataArrayIdType *>(tmp);
}
//
- tmp=0;
+ tmp=nullptr;
tmp=m->getFamilyFieldAtLevel(1);
if(tmp)
{
void MEDStructuredMeshMultiLev::moveFaceToCell() const
{
- const_cast<MEDStructuredMeshMultiLev *>(this)->_cell_fam_ids=_face_fam_ids; const_cast<MEDStructuredMeshMultiLev *>(this)->_face_fam_ids=0;
- const_cast<MEDStructuredMeshMultiLev *>(this)->_cell_num_ids=_face_num_ids; const_cast<MEDStructuredMeshMultiLev *>(this)->_face_num_ids=0;
+ const_cast<MEDStructuredMeshMultiLev *>(this)->_cell_fam_ids=_face_fam_ids; const_cast<MEDStructuredMeshMultiLev *>(this)->_face_fam_ids=nullptr;
+ const_cast<MEDStructuredMeshMultiLev *>(this)->_cell_num_ids=_face_num_ids; const_cast<MEDStructuredMeshMultiLev *>(this)->_face_num_ids=nullptr;
}
bool MEDStructuredMeshMultiLev::prepareForImplicitUnstructuredMeshCase(MEDMeshMultiLev *&ret) const
{
- ret=0;
+ ret=nullptr;
if(_geo_types.empty())
return false;
if(_geo_types.size()!=1)
throw INTERP_KERNEL::Exception("MEDStructuredMeshMultiLev::prepareForImplicitUnstructuredMeshCase only one geo types supported at most supported for the moment !");
- INTERP_KERNEL::NormalizedCellType gt(MEDCouplingStructuredMesh::GetGeoTypeGivenMeshDimension(_mesh->getMeshDimension()));
+ INTERP_KERNEL::NormalizedCellType const gt(MEDCouplingStructuredMesh::GetGeoTypeGivenMeshDimension(_mesh->getMeshDimension()));
if(_geo_types[0]==gt)
return false;
MEDCoupling1GTUMesh *facesIfPresent((static_cast<const MEDFileStructuredMesh *>(_mesh))->getImplicitFaceMesh());
if(!facesIfPresent)
return false;
- const DataArrayIdType *pfl(0),*nr(_node_reduction);
+ const DataArrayIdType *pfl(nullptr),*nr(_node_reduction);
if(!_pfls.empty())
pfl=_pfls[0];
- MCAuto<MEDCoupling1GTUMesh> facesIfPresent2(facesIfPresent); facesIfPresent->incrRef();
+ MCAuto<MEDCoupling1GTUMesh> const facesIfPresent2(facesIfPresent); facesIfPresent->incrRef();
moveFaceToCell();
MCAuto<MEDUMeshMultiLev> ret2(new MEDUMeshMultiLev(*this,facesIfPresent2));
if(pfl)
void MEDStructuredMeshMultiLev::dealWithImplicitUnstructuredMesh(const MEDFileMesh *m)
{
- const DataArrayIdType *tmp(0);
+ const DataArrayIdType *tmp(nullptr);
tmp=m->getFamilyFieldAtLevel(-1);
if(tmp)
{
{
m=dynamic_cast<MEDCoupling1SGTUMesh *>(m->buildPartOfMySelfKeepCoords(pfl->begin(),pfl->end()));
}
- DataArrayIdType *cellIds=0;
+ DataArrayIdType *cellIds=nullptr;
m->fillCellIdsToKeepFromNodeIds(pflNodes->begin(),pflNodes->end(),true,cellIds);
- MCAuto<DataArrayIdType> cellIdsSafe(cellIds);
+ MCAuto<DataArrayIdType> const cellIdsSafe(cellIds);
MCAuto<MEDCouplingPointSet> m2(m->buildPartOfMySelfKeepCoords(cellIds->begin(),cellIds->end()));
mcIdType tmp=-1;
_node_reduction=m2->getNodeIdsInUse(tmp);
throw INTERP_KERNEL::Exception("MEDCMeshMultiLev constructor : null input pointer !");
if(levs.size()!=1 || levs[0]!=0)
throw INTERP_KERNEL::Exception("MEDCMeshMultiLev constructor : levels supported is 0 only !");
- int sdim(m->getSpaceDimension());
+ int const sdim(m->getSpaceDimension());
_coords.resize(sdim);
for(int i=0;i<sdim;i++)
{
- DataArrayDouble *elt(const_cast<DataArrayDouble *>(m->getMesh()->getCoordsAt(i)));
+ auto *elt(const_cast<DataArrayDouble *>(m->getMesh()->getCoordsAt(i)));
if(!elt)
throw INTERP_KERNEL::Exception("MEDCMeshMultiLev constructor 2 : presence of null pointer for an vector of double along an axis !");
elt->incrRef();
throw INTERP_KERNEL::Exception("MEDCMeshMultiLev constructor 2 : null input pointer !");
if(gts.size()!=1 || pfls.size()!=1)
throw INTERP_KERNEL::Exception("MEDCMeshMultiLev constructor 2 : lengths of gts and pfls must be equal to one !");
- int mdim(m->getMeshDimension());
- INTERP_KERNEL::NormalizedCellType gt(MEDCouplingStructuredMesh::GetGeoTypeGivenMeshDimension(mdim));
+ int const mdim(m->getMeshDimension());
+ INTERP_KERNEL::NormalizedCellType const gt(MEDCouplingStructuredMesh::GetGeoTypeGivenMeshDimension(mdim));
if(gt==gts[0])
{
_coords.resize(mdim);
for(int i=0;i<mdim;i++)
{
- DataArrayDouble *elt(const_cast<DataArrayDouble *>(m->getMesh()->getCoordsAt(i)));
+ auto *elt(const_cast<DataArrayDouble *>(m->getMesh()->getCoordsAt(i)));
if(!elt)
throw INTERP_KERNEL::Exception("MEDCMeshMultiLev constructor 2 : presence of null pointer for an vector of double along an axis !");
_coords[i]=elt; _coords[i]->incrRef();
dealWithImplicitUnstructuredMesh(m);
}
-MEDCMeshMultiLev::MEDCMeshMultiLev(const MEDCMeshMultiLev& other):MEDStructuredMeshMultiLev(other),_coords(other._coords)
-{
-}
+MEDCMeshMultiLev::MEDCMeshMultiLev(const MEDCMeshMultiLev& other)
+= default;
std::vector<mcIdType> MEDCMeshMultiLev::getNodeGridStructure() const
{
MEDMeshMultiLev *MEDCMeshMultiLev::prepare() const
{
- MEDMeshMultiLev *retSpecific(0);
+ MEDMeshMultiLev *retSpecific(nullptr);
if(prepareForImplicitUnstructuredMeshCase(retSpecific))
return retSpecific;
- const DataArrayIdType *pfl(0),*nr(_node_reduction);
+ const DataArrayIdType *pfl(nullptr),*nr(_node_reduction);
if(!_pfls.empty())
pfl=_pfls[0];
MCAuto<DataArrayIdType> nnr;
if(nr)
{ nnr=nr->deepCopy(); nnr->sort(true); ret->setNodeReduction(nnr); }
ret->_nb_entities[0]=pfl->getNumberOfTuples();
- ret->_pfls[0]=0;
+ ret->_pfls[0]=nullptr;
std::vector< MCAuto<DataArrayDouble> > coords(_coords.size());
for(std::size_t i=0;i<_coords.size();i++)
coords[i]=_coords[i]->selectByTupleIdSafeSlice(cellParts[i].first,cellParts[i].second+1,1);
std::vector< DataArrayDouble * > MEDCMeshMultiLev::buildVTUArrays(bool& isInternal) const
{
isInternal=_is_internal;
- std::size_t sz(_coords.size());
+ std::size_t const sz(_coords.size());
std::vector< DataArrayDouble * > ret(sz);
for(std::size_t i=0;i<sz;i++)
{
throw INTERP_KERNEL::Exception("MEDCurveLinearMeshMultiLev constructor : null input pointer !");
if(levs.size()!=1 || levs[0]!=0)
throw INTERP_KERNEL::Exception("MEDCurveLinearMeshMultiLev constructor : levels supported is 0 only !");
- DataArrayDouble *coords(const_cast<DataArrayDouble *>(m->getMesh()->getCoords()));
+ auto *coords(const_cast<DataArrayDouble *>(m->getMesh()->getCoords()));
if(!coords)
throw INTERP_KERNEL::Exception("MEDCurveLinearMeshMultiLev constructor 2 : no coords set !");
coords->incrRef();
throw INTERP_KERNEL::Exception("MEDCurveLinearMeshMultiLev constructor 2 : null input pointer !");
if(gts.size()!=1 || pfls.size()!=1)
throw INTERP_KERNEL::Exception("MEDCurveLinearMeshMultiLev constructor 2 : lengths of gts and pfls must be equal to one !");
- INTERP_KERNEL::NormalizedCellType gt(MEDCouplingStructuredMesh::GetGeoTypeGivenMeshDimension(m->getMeshDimension()));
+ INTERP_KERNEL::NormalizedCellType const gt(MEDCouplingStructuredMesh::GetGeoTypeGivenMeshDimension(m->getMeshDimension()));
if(gt==gts[0])
{
- DataArrayDouble *coords(const_cast<DataArrayDouble *>(m->getMesh()->getCoords()));
+ auto *coords(const_cast<DataArrayDouble *>(m->getMesh()->getCoords()));
if(!coords)
throw INTERP_KERNEL::Exception("MEDCurveLinearMeshMultiLev constructor 2 : no coords set !");
coords->incrRef();
dealWithImplicitUnstructuredMesh(m);
}
-MEDCurveLinearMeshMultiLev::MEDCurveLinearMeshMultiLev(const MEDCurveLinearMeshMultiLev& other):MEDStructuredMeshMultiLev(other),_coords(other._coords),_structure(other._structure)
-{
-}
+MEDCurveLinearMeshMultiLev::MEDCurveLinearMeshMultiLev(const MEDCurveLinearMeshMultiLev& other)
+= default;
std::vector<mcIdType> MEDCurveLinearMeshMultiLev::getNodeGridStructure() const
{
MEDMeshMultiLev *MEDCurveLinearMeshMultiLev::prepare() const
{
- MEDMeshMultiLev *retSpecific(0);
+ MEDMeshMultiLev *retSpecific(nullptr);
if(prepareForImplicitUnstructuredMeshCase(retSpecific))
return retSpecific;
- const DataArrayIdType *pfl(0),*nr(_node_reduction);
+ const DataArrayIdType *pfl(nullptr),*nr(_node_reduction);
if(!_pfls.empty())
pfl=_pfls[0];
MCAuto<DataArrayIdType> nnr;
if(nr)
{ nnr=nr->deepCopy(); nnr->sort(true); ret->setNodeReduction(nnr); }
ret->_nb_entities[0]=pfl->getNumberOfTuples();
- ret->_pfls[0]=0;
+ ret->_pfls[0]=nullptr;
ret->_coords=_coords->selectByTupleIdSafe(p->begin(),p->end());
ret->_structure=st;
ret2=(MEDCurveLinearMeshMultiLev *)ret; ret2->incrRef();
//=
MEDFileField1TSStructItem2::MEDFileField1TSStructItem2()
-{
-}
+= default;
MEDFileField1TSStructItem2::MEDFileField1TSStructItem2(INTERP_KERNEL::NormalizedCellType a, const std::pair<mcIdType,mcIdType>& b, const std::string& c, const std::string& d):_geo_type(a),_start_end(b),_pfl(DataArrayIdType::New()),_loc(d),_nb_of_entity(-1)
{
{
if(!mst->doesManageGeoType(_geo_type))
{
- MEDFileMeshStruct *mstUnConstCasted(const_cast<MEDFileMeshStruct *>(mst));
+ auto *mstUnConstCasted(const_cast<MEDFileMeshStruct *>(mst));
mstUnConstCasted->appendIfImplicitType(_geo_type);
}
- mcIdType nbOfEnt=mst->getNumberOfElemsOfGeoType(_geo_type);
+ mcIdType const nbOfEnt=mst->getNumberOfElemsOfGeoType(_geo_type);
checkInRange(nbOfEnt,1,globs);
}
void MEDFileField1TSStructItem2::checkWithMeshStructForGaussNE(const MEDFileMeshStruct *mst, const MEDFileFieldGlobsReal *globs)
{
- mcIdType nbOfEnt=mst->getNumberOfElemsOfGeoType(_geo_type);
+ mcIdType const nbOfEnt=mst->getNumberOfElemsOfGeoType(_geo_type);
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
checkInRange(nbOfEnt,(int)cm.getNumberOfNodes(),globs);
}
if(_loc.empty())
throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem2::checkWithMeshStructForGaussPT : no localization specified !");
const MEDFileFieldLoc& loc=globs->getLocalization(_loc.c_str());
- mcIdType nbOfEnt=mst->getNumberOfElemsOfGeoType(_geo_type);
+ mcIdType const nbOfEnt=mst->getNumberOfElemsOfGeoType(_geo_type);
checkInRange(nbOfEnt,loc.getNumberOfGaussPoints(),globs);
}
if(!_pfl->isAllocated())
{
if(_pfl->getName().empty())
- return 0;
+ return nullptr;
else
return globs->getProfile(_pfl->getName().c_str());
}
throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem2::BuildAggregationOf : empty input !");
if(objs.size()==1)
return MEDFileField1TSStructItem2(*objs[0]);
- INTERP_KERNEL::NormalizedCellType gt(objs[0]->_geo_type);
- mcIdType nbEntityRef(objs[0]->_nb_of_entity);
- std::size_t sz(objs.size());
+ INTERP_KERNEL::NormalizedCellType const gt(objs[0]->_geo_type);
+ mcIdType const nbEntityRef(objs[0]->_nb_of_entity);
+ std::size_t const sz(objs.size());
std::vector<const DataArrayIdType *> arrs(sz);
for(std::size_t i=0;i<sz;i++)
{
}
MCAuto<DataArrayIdType> arr(DataArrayIdType::Aggregate(arrs));
arr->sort();
- mcIdType oldNbTuples(arr->getNumberOfTuples());
+ mcIdType const oldNbTuples(arr->getNumberOfTuples());
arr=arr->buildUnique();
if(oldNbTuples!=arr->getNumberOfTuples())
throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem2::BuildAggregationOf : some entities are present several times !");
if(arr->isIota(nbEntityRef))
{
- std::pair<mcIdType,mcIdType> p(0,nbEntityRef);
+ std::pair<mcIdType,mcIdType> const p(0,nbEntityRef);
std::string a,b;
MEDFileField1TSStructItem2 ret(gt,p,a,b);
ret._nb_of_entity=nbEntityRef;
else
{
arr->setName(NEWLY_CREATED_PFL_NAME);
- std::pair<mcIdType,mcIdType> p(0,oldNbTuples);
+ std::pair<mcIdType,mcIdType> const p(0,oldNbTuples);
std::string a,b;
MEDFileField1TSStructItem2 ret(gt,p,a,b);
ret._nb_of_entity=nbEntityRef;
std::size_t MEDFileField1TSStructItem2::getHeapMemorySizeWithoutChildren() const
{
- std::size_t ret(_loc.capacity());
+ std::size_t const ret(_loc.capacity());
return ret;
}
{
case ON_NODES:
{
- mcIdType nbOfEnt=mst->getNumberOfNodes();
+ mcIdType const nbOfEnt=mst->getNumberOfNodes();
if(_items.size()!=1)
throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem::checkWithMeshStruct : for nodes field only one subdivision supported !");
_items[0].checkInRange(nbOfEnt,1,globs);
}
case ON_CELLS:
{
- for(std::vector< MEDFileField1TSStructItem2 >::iterator it=_items.begin();it!=_items.end();it++)
- (*it).checkWithMeshStructForCells(mst,globs);
+ for(auto & _item : _items)
+ _item.checkWithMeshStructForCells(mst,globs);
break;
}
case ON_GAUSS_NE:
{
- for(std::vector< MEDFileField1TSStructItem2 >::iterator it=_items.begin();it!=_items.end();it++)
- (*it).checkWithMeshStructForGaussNE(mst,globs);
+ for(auto & _item : _items)
+ _item.checkWithMeshStructForGaussNE(mst,globs);
break;
}
case ON_GAUSS_PT:
{
- for(std::vector< MEDFileField1TSStructItem2 >::iterator it=_items.begin();it!=_items.end();it++)
- (*it).checkWithMeshStructForGaussPT(mst,globs);
+ for(auto & _item : _items)
+ _item.checkWithMeshStructForGaussPT(mst,globs);
break;
}
default:
throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem::simplifyMeOnCellEntity : must be on ON_CELLS, ON_GAUSS_NE or ON_GAUSS_PT !");
std::vector< std::pair< INTERP_KERNEL::NormalizedCellType, std::vector<std::size_t> > > m;
std::size_t i=0;
- for(std::vector< MEDFileField1TSStructItem2 >::const_iterator it=_items.begin();it!=_items.end();it++,i++)
+ for(auto it=_items.begin();it!=_items.end();it++,i++)
{
- std::vector< std::pair< INTERP_KERNEL::NormalizedCellType, std::vector<std::size_t> > >::iterator it0(std::find_if(m.begin(),m.end(),CmpGeo((*it).getGeo())));
+ auto const it0(std::find_if(m.begin(),m.end(),CmpGeo((*it).getGeo())));
if(it0==m.end())
m.push_back(std::pair< INTERP_KERNEL::NormalizedCellType, std::vector<std::size_t> >((*it).getGeo(),std::vector<std::size_t>(1,i)));
else
ret._type=ON_CELLS;
return ret;
}
- std::size_t sz(m.size());
+ std::size_t const sz(m.size());
std::vector< MEDFileField1TSStructItem2 > items(sz);
for(i=0;i<sz;i++)
{
if(other._items.size()!=1)
throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem::isCompatibleWithNodesDiscr : other is on nodes but number of subparts !");
int theFirstLevFull;
- bool ret0=isFullyOnOneLev(meshSt,theFirstLevFull);
+ bool const ret0=isFullyOnOneLev(meshSt,theFirstLevFull);
const MEDFileField1TSStructItem2& otherNodeIt(other._items[0]);
- mcIdType nbOfNodes(meshSt->getNumberOfNodes());
+ mcIdType const nbOfNodes(meshSt->getNumberOfNodes());
if(otherNodeIt.getPflName().empty())
{//on all nodes
if(!ret0)
throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem::isFullyOnOneLev : works only for ON_CELLS discretization !");
if(_items.empty())
throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem::isFullyOnOneLev : items vector is empty !");
- int nbOfLevs(meshSt->getNumberOfLevs());
+ int const nbOfLevs(meshSt->getNumberOfLevs());
if(nbOfLevs==0)
throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem::isFullyOnOneLev : no levels in input mesh structure !");
std::vector<int> levs(nbOfLevs);
theFirstLevFull=1;
std::set<INTERP_KERNEL::NormalizedCellType> gts;
- for(std::vector< MEDFileField1TSStructItem2 >::const_iterator it=_items.begin();it!=_items.end();it++)
+ for(const auto & _item : _items)
{
- if(!(*it).getPflName().empty())
+ if(!_item.getPflName().empty())
return false;
- INTERP_KERNEL::NormalizedCellType gt((*it).getGeo());
+ INTERP_KERNEL::NormalizedCellType const gt(_item.getGeo());
if(gts.find(gt)!=gts.end())
throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem::isFullyOnOneLev : internal error !");
gts.insert(gt);
- int pos(meshSt->getLevelOfGeoType((*it).getGeo()));
+ int const pos(meshSt->getLevelOfGeoType(_item.getGeo()));
levs[-pos]++;
}
for(int i=0;i<nbOfLevs;i++)
std::size_t MEDFileField1TSStructItem::getHeapMemorySizeWithoutChildren() const
{
- std::size_t ret(_items.size()*sizeof(MEDFileField1TSStructItem2));
+ std::size_t const ret(_items.size()*sizeof(MEDFileField1TSStructItem2));
return ret;
}
std::vector<const BigMemoryObject *> MEDFileField1TSStructItem::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
- for(std::vector< MEDFileField1TSStructItem2 >::const_iterator it=_items.begin();it!=_items.end();it++)
- ret.push_back(&(*it));
+ for(const auto & _item : _items)
+ ret.push_back(&_item);
return ret;
}
MEDMeshMultiLev *MEDFileField1TSStructItem::buildFromScratchDataSetSupportOnCells(const MEDFileMeshStruct *mst, const MEDFileFieldGlobsReal *globs) const
{
- std::size_t sz(_items.size());
+ std::size_t const sz(_items.size());
std::vector<INTERP_KERNEL::NormalizedCellType> a0(sz);
std::vector<const DataArrayIdType *> a1(sz);
std::vector<mcIdType> a2(sz);
std::size_t i(0);
- for(std::vector< MEDFileField1TSStructItem2 >::const_iterator it=_items.begin();it!=_items.end();it++,i++)
+ for(auto it=_items.begin();it!=_items.end();it++,i++)
{
a0[i]=(*it).getGeo();
a1[i]=(*it).getPfl(globs);
else
return ret;
}
- for(std::vector< MEDFileField1TSStructItem2 >::const_iterator it=_items.begin();it!=_items.end();it++)
+ for(const auto & _item : _items)
{
- INTERP_KERNEL::NormalizedCellType elt((*it).getGeo());
- std::vector<INTERP_KERNEL::NormalizedCellType>::iterator it2(std::find(ret.begin(),ret.end(),elt));
+ INTERP_KERNEL::NormalizedCellType const elt(_item.getGeo());
+ auto const it2(std::find(ret.begin(),ret.end(),elt));
if(it2==ret.end())
ret.push_back(elt);
}
std::vector< std::vector<TypeOfField> > typesF;
std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes;
std::vector< std::vector<std::pair<mcIdType,mcIdType> > > strtEnds=ref->getFieldSplitedByType(std::string(),geoTypes,typesF,pfls,locs);
- std::size_t nbOfGeoTypes(geoTypes.size());
+ std::size_t const nbOfGeoTypes(geoTypes.size());
if(nbOfGeoTypes==0)
throw INTERP_KERNEL::Exception("MEDFileField1TSStruct : not null by empty ref !");
if(typesF[0].empty())
throw INTERP_KERNEL::Exception("MEDFileField1TSStruct : internal error #1 bis !");
- TypeOfField atype(typesF[0][0]);
+ TypeOfField const atype(typesF[0][0]);
for(std::size_t i=0;i<nbOfGeoTypes;i++)
{
- std::size_t sz=typesF[i].size();
+ std::size_t const sz=typesF[i].size();
if(strtEnds[i].size()<1 || sz<1 || pfls[i].size()<1)
throw INTERP_KERNEL::Exception("MEDFileField1TSStruct : internal error #1 !");
//
bool MEDFileField1TSStruct::isEqualConsideringThePast(const MEDFileAnyTypeField1TS *other, const MEDFileMeshStruct *mst) const
{
- MEDFileField1TSStructItem b(MEDFileField1TSStructItem::BuildItemFrom(other,mst));
- for(std::vector<MEDFileField1TSStructItem>::const_iterator it=_already_checked.begin();it!=_already_checked.end();it++)
+ MEDFileField1TSStructItem const b(MEDFileField1TSStructItem::BuildItemFrom(other,mst));
+ for(const auto & it : _already_checked)
{
- if((*it)==b)
+ if(it==b)
return true;
}
return false;
{
if(_already_checked.empty())
throw INTERP_KERNEL::Exception("MEDFileField1TSStruct::isSupportSameAs : no ref !");
- MEDFileField1TSStructItem b(MEDFileField1TSStructItem::BuildItemFrom(other,meshSt));
+ MEDFileField1TSStructItem const b(MEDFileField1TSStructItem::BuildItemFrom(other,meshSt));
if(!_already_checked[0].isEntityCell() || !b.isEntityCell())
throw INTERP_KERNEL::Exception("MEDFileField1TSStruct::isSupportSameAs : only available on cell entities !");
- MEDFileField1TSStructItem other1(b.simplifyMeOnCellEntity(other));
+ MEDFileField1TSStructItem const other1(b.simplifyMeOnCellEntity(other));
int found=-1,i=0;
for(std::vector<MEDFileField1TSStructItem>::const_iterator it=_already_checked.begin();it!=_already_checked.end();it++,i++)
if((*it).isComputed())
bool ret(false);
if(found==-1)
{
- MEDFileField1TSStructItem this1(_already_checked[0].simplifyMeOnCellEntity(other));
+ MEDFileField1TSStructItem const this1(_already_checked[0].simplifyMeOnCellEntity(other));
ret=this1.isCellSupportEqual(other1,other);
if(ret)
_already_checked.push_back(this1);
{
if(_already_checked.empty())
throw INTERP_KERNEL::Exception("MEDFileField1TSStruct::isCompatibleWithNodesDiscr : no ref !");
- MEDFileField1TSStructItem other1(MEDFileField1TSStructItem::BuildItemFrom(other,meshSt));
+ MEDFileField1TSStructItem const other1(MEDFileField1TSStructItem::BuildItemFrom(other,meshSt));
if(_already_checked[0].isEntityCell())
{
int found=-1,i=0;
bool ret(false);
if(found==-1)
{
- MEDFileField1TSStructItem this1(_already_checked[0].simplifyMeOnCellEntity(other));
+ MEDFileField1TSStructItem const this1(_already_checked[0].simplifyMeOnCellEntity(other));
ret=this1.isCompatibleWithNodesDiscr(other1,meshSt,other);
if(ret)
_already_checked.push_back(this1);
std::size_t MEDFileField1TSStruct::getHeapMemorySizeWithoutChildren() const
{
- std::size_t ret(_already_checked.capacity()*sizeof(MEDFileField1TSStructItem));
+ std::size_t const ret(_already_checked.capacity()*sizeof(MEDFileField1TSStructItem));
return ret;
}
std::vector<const BigMemoryObject *> MEDFileField1TSStruct::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
- for(std::vector<MEDFileField1TSStructItem>::const_iterator it=_already_checked.begin();it!=_already_checked.end();it++)
- ret.push_back(&(*it));
+ for(const auto & it : _already_checked)
+ ret.push_back(&it);
return ret;
}
std::vector<INTERP_KERNEL::NormalizedCellType> MEDFileField1TSStruct::getGeoTypes(const MEDFileMesh *m) const
{
std::vector<INTERP_KERNEL::NormalizedCellType> ret;
- for(std::vector<MEDFileField1TSStructItem>::const_iterator it=_already_checked.begin();it!=_already_checked.end();it++)
+ for(const auto & it : _already_checked)
{
- std::vector<INTERP_KERNEL::NormalizedCellType> ret2((*it).getGeoTypes(m));
- for(std::vector<INTERP_KERNEL::NormalizedCellType>::const_iterator it2=ret2.begin();it2!=ret2.end();it2++)
+ std::vector<INTERP_KERNEL::NormalizedCellType> const ret2(it.getGeoTypes(m));
+ for(auto it2 : ret2)
{
- if(*it2==INTERP_KERNEL::NORM_ERROR)
+ if(it2==INTERP_KERNEL::NORM_ERROR)
continue;
- std::vector<INTERP_KERNEL::NormalizedCellType>::iterator it3(std::find(ret.begin(),ret.end(),*it2));
+ auto const it3(std::find(ret.begin(),ret.end(),it2));
if(it3==ret.end())
- ret.push_back(*it2);
+ ret.push_back(it2);
}
}
return ret;
std::size_t refSz(std::numeric_limits<std::size_t>::max());
bool ret(false);
int i(0);
- for(std::vector<MEDFileField1TSStructItem>::const_iterator it=_already_checked.begin();it!=_already_checked.end();it++,i++)
+ for(auto it=_already_checked.begin();it!=_already_checked.end();it++,i++)
{
if((*it).getType()!=ON_NODES)
{
ret=true;
- std::size_t sz((*it).getNumberOfItems());
+ std::size_t const sz((*it).getNumberOfItems());
if(refSz>sz)
{ pos=i; refSz=sz; }
}
bool MEDFileField1TSStruct::presenceOfPartialNodeDiscr(int& pos) const
{
int i(0);
- for(std::vector<MEDFileField1TSStructItem>::const_iterator it=_already_checked.begin();it!=_already_checked.end();it++,i++)
+ for(auto it=_already_checked.begin();it!=_already_checked.end();it++,i++)
{
if((*it).getType()==ON_NODES)
{
- std::size_t sz((*it).getNumberOfItems());
+ std::size_t const sz((*it).getNumberOfItems());
if(sz==1)
{
if(!(*it)[0].getPflName().empty())
if(!m)
throw INTERP_KERNEL::Exception("MEDFileFastCellSupportComparator constructor : null input mesh struct !");
_mesh_comp=const_cast<MEDFileMeshStruct *>(m); _mesh_comp->incrRef();
- int nbPts=ref->getNumberOfTS();
+ int const nbPts=ref->getNumberOfTS();
_f1ts_cmps.resize(nbPts);
for(int i=0;i<nbPts;i++)
{
std::size_t MEDFileFastCellSupportComparator::getHeapMemorySizeWithoutChildren() const
{
- std::size_t ret(_f1ts_cmps.capacity()*sizeof(MCAuto<MEDFileField1TSStruct>));
+ std::size_t const ret(_f1ts_cmps.capacity()*sizeof(MCAuto<MEDFileField1TSStruct>));
return ret;
}
const MEDFileMeshStruct *mst(_mesh_comp);
if(mst)
ret.push_back(mst);
- for(std::vector< MCAuto<MEDFileField1TSStruct> >::const_iterator it=_f1ts_cmps.begin();it!=_f1ts_cmps.end();it++)
- ret.push_back((const MEDFileField1TSStruct *)*it);
+ for(const auto & _f1ts_cmp : _f1ts_cmps)
+ ret.push_back((const MEDFileField1TSStruct *)_f1ts_cmp);
return ret;
}
bool MEDFileFastCellSupportComparator::isEqual(const MEDFileAnyTypeFieldMultiTS *other)
{
- int nbPts=other->getNumberOfTS();
+ int const nbPts=other->getNumberOfTS();
if(nbPts!=(int)_f1ts_cmps.size())
{
std::ostringstream oss; oss << "MEDFileFastCellSupportComparator::isEqual : unexpected nb of time steps in input ! Should be " << _f1ts_cmps.size() << " it is in reality " << nbPts << " !";
bool MEDFileFastCellSupportComparator::isCompatibleWithNodesDiscr(const MEDFileAnyTypeFieldMultiTS *other)
{
- int nbPts=other->getNumberOfTS();
+ int const nbPts=other->getNumberOfTS();
if(nbPts!=(int)_f1ts_cmps.size())
{
std::ostringstream oss; oss << "MEDFileFastCellSupportComparator::isCompatibleWithNodesDiscr : unexpected nb of time steps in input ! Should be " << _f1ts_cmps.size() << " it is in reality " << nbPts << " !";
#ifndef __MEDFILEFIELDOVERVIEW_HXX__
#define __MEDFILEFIELDOVERVIEW_HXX__
+#include "MCType.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "CellModel.hxx"
#include "MEDLoaderDefines.hxx"
#include "MCAuto.hxx"
#include "MEDCouplingRefCountObject.hxx"
#include "MEDCoupling1GTUMesh.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
-#include "InterpKernelException.hxx"
+#include "NormalizedGeometricTypes"
+#include <string>
+#include <cstddef>
+#include <utility>
#include <vector>
namespace MEDCoupling
public:
MEDLOADER_EXPORT static MEDFileMeshStruct *New(const MEDFileMesh *mesh);
std::string getClassName() const override { return std::string("MEDFileMeshStruct"); }
- std::size_t getHeapMemorySizeWithoutChildren() const;
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
const MEDFileMesh *getTheMesh() const { return _mesh; }
mcIdType getNumberOfNodes() const { return _nb_nodes; }
bool doesManageGeoType(INTERP_KERNEL::NormalizedCellType t) const;
class MEDMeshMultiLev : public RefCountObject
{
public:
- std::size_t getHeapMemorySizeWithoutChildren() const;
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
std::string getClassName() const override { return std::string("MEDMeshMultiLev"); }
public:
static MEDMeshMultiLev *New(const MEDFileMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayIdType *>& pfls, const std::vector<mcIdType>& nbEntities);
public:
static MEDUMeshMultiLev *New(const MEDFileUMesh *m, const std::vector<int>& levs);
static MEDUMeshMultiLev *New(const MEDFileUMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayIdType *>& pfls, const std::vector<mcIdType>& nbEntities);
- void selectPartOfNodes(const DataArrayIdType *pflNodes);
+ void selectPartOfNodes(const DataArrayIdType *pflNodes) override;
std::string getClassName() const override { return std::string("MEDUMeshMultiLev"); }
- MEDMeshMultiLev *prepare() const;
+ MEDMeshMultiLev *prepare() const override;
MEDUMeshMultiLev(const MEDStructuredMeshMultiLev& other, const MCAuto<MEDCoupling1GTUMesh>& part);
MEDLOADER_EXPORT bool buildVTUArrays(DataArrayDouble *& coords, DataArrayByte *&types, DataArrayIdType *&cellLocations, DataArrayIdType *& cells, DataArrayIdType *&faceLocations, DataArrayIdType *&faces) const;
protected:
- void appendVertices(const DataArrayIdType *verticesToAdd, DataArrayIdType *nr);
+ void appendVertices(const DataArrayIdType *verticesToAdd, DataArrayIdType *nr) override;
private:
void reorderNodesIfNecessary(MCAuto<DataArrayDouble>& coords, DataArrayIdType *nodalConnVTK, DataArrayIdType *polyhedNodalConnVTK) const;
private:
class MEDStructuredMeshMultiLev : public MEDMeshMultiLev
{
public:
- void selectPartOfNodes(const DataArrayIdType *pflNodes);
+ void selectPartOfNodes(const DataArrayIdType *pflNodes) override;
virtual std::vector<mcIdType> getNodeGridStructure() const = 0;
std::string getClassName() const override { return std::string("MEDStructuredMeshMultiLev"); }
protected:
public:
static MEDCMeshMultiLev *New(const MEDFileCMesh *m, const std::vector<int>& levs);
static MEDCMeshMultiLev *New(const MEDFileCMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayIdType *>& pfls, const std::vector<mcIdType>& nbEntities);
- std::vector<mcIdType> getNodeGridStructure() const;
+ std::vector<mcIdType> getNodeGridStructure() const override;
std::string getClassName() const override { return std::string("MEDCMeshMultiLev"); }
- MEDMeshMultiLev *prepare() const;
+ MEDMeshMultiLev *prepare() const override;
MEDLOADER_EXPORT std::vector< DataArrayDouble * > buildVTUArrays(bool& isInternal) const;
private:
MEDCMeshMultiLev(const MEDCMeshMultiLev& other);
static MEDCurveLinearMeshMultiLev *New(const MEDFileCurveLinearMesh *m, const std::vector<int>& levs);
static MEDCurveLinearMeshMultiLev *New(const MEDFileCurveLinearMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayIdType *>& pfls , const std::vector<mcIdType>& nbEntities);
std::string getClassName() const override { return std::string("MEDCurveLinearMeshMultiLev"); }
- std::vector<mcIdType> getNodeGridStructure() const;
- MEDMeshMultiLev *prepare() const;
+ std::vector<mcIdType> getNodeGridStructure() const override;
+ MEDMeshMultiLev *prepare() const override;
MEDLOADER_EXPORT void buildVTUArrays(DataArrayDouble *&coords, std::vector<mcIdType>& nodeStrct, bool& isInternal) const;
private:
MEDCurveLinearMeshMultiLev(const MEDCurveLinearMeshMultiLev& other);
void checkWithMeshStructForGaussNE(const MEDFileMeshStruct *mst, const MEDFileFieldGlobsReal *globs);
void checkWithMeshStructForGaussPT(const MEDFileMeshStruct *mst, const MEDFileFieldGlobsReal *globs);
//
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
//
const DataArrayIdType *getPfl(const MEDFileFieldGlobsReal *globs) const;
INTERP_KERNEL::NormalizedCellType getGeo() const { return _geo_type; }
void checkWithMeshStruct(const MEDFileMeshStruct *mst, const MEDFileFieldGlobsReal *globs);
bool operator==(const MEDFileField1TSStructItem& other) const;
std::string getClassName() const override { return std::string("MEDFileField1TSStructItem"); }
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
bool isEntityCell() const;
bool isComputed() const { return _computed; }
TypeOfField getType() const { return _type; }
public:
static MEDFileField1TSStruct *New(const MEDFileAnyTypeField1TS *ref, MEDFileMeshStruct *mst);
void checkWithMeshStruct(MEDFileMeshStruct *mst, const MEDFileFieldGlobsReal *globs);
- std::size_t getHeapMemorySizeWithoutChildren() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
std::string getClassName() const override { return std::string("MEDFileField1TSStruct"); }
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
bool isEqualConsideringThePast(const MEDFileAnyTypeField1TS *other, const MEDFileMeshStruct *mst) const;
bool isSupportSameAs(const MEDFileAnyTypeField1TS *other, const MEDFileMeshStruct *meshSt);
bool isCompatibleWithNodesDiscr(const MEDFileAnyTypeField1TS *other, const MEDFileMeshStruct *meshSt);
MEDLOADER_EXPORT std::vector<INTERP_KERNEL::NormalizedCellType> getGeoTypesAt(int timeStepId, const MEDFileMesh *m) const;
bool isEqual(const MEDFileAnyTypeFieldMultiTS *other);
bool isCompatibleWithNodesDiscr(const MEDFileAnyTypeFieldMultiTS *other);
- std::size_t getHeapMemorySizeWithoutChildren() const;
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
private:
MEDFileFastCellSupportComparator(const MEDFileMeshStruct *m, const MEDFileAnyTypeFieldMultiTS *ref);
private:
#ifndef __MEDFILEFIELDVISITOR_HXX__
#define __MEDFILEFIELDVISITOR_HXX__
-#include "MEDLoaderDefines.hxx"
#include "MEDFileField.hxx"
namespace MEDCoupling
virtual void endPerMeshPerTypeEntry(const MEDFileFieldPerMeshPerTypeCommon *pmpt) = 0;
//
virtual void newPerMeshPerTypePerDisc(const MEDFileFieldPerMeshPerTypePerDisc *pmptpd) = 0;
- virtual ~MEDFileFieldVisitor() { }
+ virtual ~MEDFileFieldVisitor() = default;
};
}
//
#include "MEDFileJoint.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MCType.hxx"
#include "MEDFileBasis.hxx"
-#include "MEDLoader.hxx"
+#include "MEDFileUtilities.hxx"
#include "MEDLoaderBase.hxx"
#include "MEDFileSafeCaller.txx"
#include "CellModel.hxx"
#include "InterpKernelAutoPtr.hxx"
+#include "med.h"
+#include "NormalizedGeometricTypes"
+#include <cstddef>
+#include <vector>
+#include <string>
+#include "medfile.h"
+#include <sstream>
+#include "medsubdomain.h"
+#include <ostream>
+#include <utility>
+#include <algorithm>
+#include <iterator>
// From MEDLOader.cxx TU
extern med_geometry_type typmai[MED_N_CELL_FIXED_GEO];
*/
void MEDFileJointCorrespondence::write(const std::string& fileName, int mode, const std::string& localMeshName, const std::string& jointName, int order, int iteration) const
{
- med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
- MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),medmod);
+ med_access_mode const medmod=MEDFileUtilities::TraduceWriteMode(mode);
+ MEDFileUtilities::AutoFid const fid=MEDfileOpen(fileName.c_str(),medmod);
std::ostringstream oss; oss << "MEDFileJointCorrespondence : error on attempt to write in file : \"" << fileName << "\"";
MEDFileUtilities::CheckMEDCode((int)fid,fid,oss.str());
const DataArrayIdType* tmp=getCorrespondence();
oss << "- Correspondence : <<";
- for(const mcIdType *it=tmp->begin();it!=tmp->end();it++)
- oss<< *it << " ";
+ for(long const it : *tmp)
+ oss<< it << " ";
}
else
{
MEDFileJointOneStep *MEDFileJointOneStep::New(int dt, int it)
{
- MEDFileJointOneStep* j = new MEDFileJointOneStep();
+ auto* j = new MEDFileJointOneStep();
j->setOrder( dt );
j->setIteration( it );
return j;
MEDFileJointOneStep *MEDFileJointOneStep::New(const std::string& fileName, const std::string& mName, const std::string& jointName, int num)
{
MEDFileUtilities::CheckFileForRead(fileName);
- MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(), MED_ACC_RDONLY);
+ MEDFileUtilities::AutoFid const fid=MEDfileOpen(fileName.c_str(), MED_ACC_RDONLY);
return new MEDFileJointOneStep(fid, mName, jointName, num);
}
*/
void MEDFileJointOneStep::write(const std::string& fileName, int mode, const std::string& localMeshName, const std::string& jointName) const
{
- med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
- MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),medmod);
+ med_access_mode const medmod=MEDFileUtilities::TraduceWriteMode(mode);
+ MEDFileUtilities::AutoFid const fid=MEDfileOpen(fileName.c_str(),medmod);
std::ostringstream oss; oss << "MEDFileJointOneStep : error on attempt to write in file : \"" << fileName << "\"";
MEDFileUtilities::CheckMEDCode((int)fid,fid,oss.str());
if ( _correspondences.empty() )
void MEDFileJointOneStep::writeLL(med_idt fid, const std::string& localMeshName, const std::string& jointName) const
{
- for(std::vector< MCAuto<MEDFileJointCorrespondence> >::const_iterator it=_correspondences.begin();it!=_correspondences.end();it++)
+ for(const auto & _correspondence : _correspondences)
{
- (*it)->writeLL(fid, localMeshName, jointName, getOrder(), getIteration());
+ _correspondence->writeLL(fid, localMeshName, jointName, getOrder(), getIteration());
}
}
{
std::vector< MCAuto<MEDFileJointCorrespondence> > correspondences(_correspondences.size());
std::size_t i=0;
- for(std::vector< MCAuto<MEDFileJointCorrespondence> >::const_iterator it=_correspondences.begin();it!=_correspondences.end();it++,i++)
+ for(auto it=_correspondences.begin();it!=_correspondences.end();it++,i++)
if((const MEDFileJointCorrespondence *)*it)
correspondences[i]=(*it)->deepCopy();
MCAuto<MEDFileJointOneStep> ret= new MEDFileJointOneStep;
std::ostringstream oss;
oss << "(*************************************)\n(* JOINT_ONE_STEP INFORMATION: *)\n(*************************************)\n";
oss << "- Number of the correspondences : <<" << _correspondences.size() << ">>\n";
- for(std::vector< MCAuto<MEDFileJointCorrespondence> >::const_iterator it=_correspondences.begin();it!=_correspondences.end();it++)
+ for(const auto & _correspondence : _correspondences)
{
- oss << (*it)->simpleRepr();
+ oss << _correspondence->simpleRepr();
}
return oss.str();
}
MEDFileJoint *MEDFileJoint::New(const std::string& fileName, const std::string& mName, int curJoint)
{
MEDFileUtilities::CheckFileForRead(fileName);
- MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(), MED_ACC_RDONLY);
+ MEDFileUtilities::AutoFid const fid=MEDfileOpen(fileName.c_str(), MED_ACC_RDONLY);
return new MEDFileJoint(fid,mName,curJoint);
}
MEDFileJoint *MEDFileJoint::New(const std::string& jointName, const std::string& locMeshName, const std::string& remoteMeshName, int remoteMeshNum)
{
- MEDFileJoint* j = new MEDFileJoint();
+ auto* j = new MEDFileJoint();
j->setJointName( jointName );
j->setLocalMeshName( locMeshName );
j->setRemoteMeshName( remoteMeshName );
}
MEDFileJoint::MEDFileJoint()
-{
-}
+= default;
/*!
* Returns a new MEDFileJoint holding the mesh data that has been read from a given MED
// if ( _loc_mesh_name.empty() )
// throw INTERP_KERNEL::Exception("MEDFileJoint::write : name of a local mesh not defined!");
MEDFILESAFECALLERWR0(MEDsubdomainJointCr,(fid,getLocalMeshName().c_str(),getJointName().c_str(),getDescription().c_str(),getDomainNumber(),getRemoteMeshName().c_str()));
- for(std::vector< MCAuto<MEDFileJointOneStep> >::const_iterator it=_joint.begin();it!=_joint.end();it++)
- (*it)->writeLL(fid, getLocalMeshName(),getJointName());
+ for(const auto & it : _joint)
+ it->writeLL(fid, getLocalMeshName(),getJointName());
}
void MEDFileJoint::pushStep(MEDFileJointOneStep* step)
return false;
if(_domain_number!=other->_domain_number)
return false;
- int nbTS(getNumberOfSteps());
+ int const nbTS(getNumberOfSteps());
if(nbTS!=other->getNumberOfSteps())
return false;
std::vector<bool> found(nbTS,false);
{
std::vector< MCAuto<MEDFileJointOneStep> > joint(_joint.size());
std::size_t i=0;
- for(std::vector< MCAuto<MEDFileJointOneStep> >::const_iterator it=_joint.begin();it!=_joint.end();it++,i++)
+ for(auto it=_joint.begin();it!=_joint.end();it++,i++)
if((const MEDFileJointOneStep *)*it)
joint[i]=(*it)->deepCopy();
MCAuto<MEDFileJoint> ret=new MEDFileJoint(*this);
bool MEDFileJoint::changeJointNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
{
- for(std::vector< std::pair<std::string,std::string> >::const_iterator it=modifTab.begin();it!=modifTab.end();it++)
+ for(const auto & it : modifTab)
{
- if((*it).first==_joint_name)
+ if(it.first==_joint_name)
{
- _joint_name=(*it).second;
+ _joint_name=it.second;
return true;
}
}
oss << "- Description : <<" << getDescription() << ">>\n";
oss << "- Joint name : <<" << getJointName() << ">>\n";
oss << "- Domain number : " << getDomainNumber() << "\n";
- for(std::vector< MCAuto<MEDFileJointOneStep> >::const_iterator it=_joint.begin();it!=_joint.end();it++)
+ for(const auto & it : _joint)
{
- oss << (*it)->simpleRepr();
+ oss << it->simpleRepr();
}
return oss.str();
}
MEDFileJoints *MEDFileJoints::New(const std::string& fileName, const std::string& meshName)
{
MEDFileUtilities::CheckFileForRead(fileName);
- MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(), MED_ACC_RDONLY);
+ MEDFileUtilities::AutoFid const fid=MEDfileOpen(fileName.c_str(), MED_ACC_RDONLY);
return new MEDFileJoints( fid, meshName );
}
void MEDFileJoints::writeLL(med_idt fid) const
{
- for(std::vector< MCAuto<MEDFileJoint> >::const_iterator it=_joints.begin();it!=_joints.end();it++)
- (*it)->writeLL(fid);
+ for(const auto & _joint : _joints)
+ _joint->writeLL(fid);
}
std::string MEDFileJoints::getMeshName() const
MEDFileJoint *MEDFileJoints::getJointWithName(const std::string& jname) const
{
std::vector<std::string> js=getJointsNames();
- std::vector<std::string>::iterator it=std::find(js.begin(),js.end(),jname);
+ auto const it=std::find(js.begin(),js.end(),jname);
if(it==js.end())
{
std::ostringstream oss; oss << "MEDFileJoints::getJointWithName : Joint \"" << jname << "\" does not exist in this ! Existing are : ";
{
std::vector<std::string> ret(_joints.size());
int i=0;
- for(std::vector< MCAuto<MEDFileJoint> >::const_iterator it=_joints.begin();it!=_joints.end();it++,i++)
+ for(auto it=_joints.begin();it!=_joints.end();it++,i++)
{
const MEDFileJoint *f=(*it);
if(f)
bool MEDFileJoints::changeJointNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
{
bool ret=false;
- for(std::vector< MCAuto<MEDFileJoint> >::iterator it=_joints.begin();it!=_joints.end();it++)
+ for(auto & _joint : _joints)
{
- MEDFileJoint *cur(*it);
+ MEDFileJoint *cur(_joint);
if(cur)
ret=cur->changeJointNames(modifTab) || ret;
}
}
MEDFileJoints::MEDFileJoints()
-{
-}
+= default;
MEDFileJoints::MEDFileJoints(med_idt fid, const std::string& meshName)
{
- med_int num_joint=MEDnSubdomainJoint(fid, meshName.c_str() );
+ med_int const num_joint=MEDnSubdomainJoint(fid, meshName.c_str() );
for(int i = 1; i <= num_joint; i++)
_joints.push_back(MEDFileJoint::New(fid,meshName,i));
}
{
std::vector< MCAuto<MEDFileJoint> > joints(_joints.size());
std::size_t i=0;
- for(std::vector< MCAuto<MEDFileJoint> >::const_iterator it=_joints.begin();it!=_joints.end();it++,i++)
+ for(auto it=_joints.begin();it!=_joints.end();it++,i++)
if((const MEDFileJoint *)*it)
joints[i]=(*it)->deepCopy();
MCAuto<MEDFileJoints> ret=MEDFileJoints::New();
std::vector<const BigMemoryObject *> MEDFileJoints::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
- for(std::vector< MCAuto<MEDFileJoint> >::const_iterator it=_joints.begin();it!=_joints.end();it++)
- ret.push_back((const MEDFileJoint *)*it);
+ for(const auto & _joint : _joints)
+ ret.push_back((const MEDFileJoint *)_joint);
return ret;
}
void MEDFileJoints::simpleReprWithoutHeader(std::ostream& oss) const
{
- int nbOfJoints=getNumberOfJoints();
+ int const nbOfJoints=getNumberOfJoints();
oss << "There are " << nbOfJoints << " joints with the following names : \n";
std::vector<std::string> jns=getJointsNames();
for(int i=0;i<nbOfJoints;i++)
oss << " - #" << i << " \"" << jns[i] << "\"\n";
- for(std::vector< MCAuto<MEDFileJoint> >::const_iterator it=_joints.begin();it!=_joints.end();it++)
+ for(const auto & _joint : _joints)
{
- oss << (*it)->simpleRepr();
+ oss << _joint->simpleRepr();
}
}
#ifndef __MEDFILEJOINT_HXX__
#define __MEDFILEJOINT_HXX__
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDFileUtilities.hxx"
+#include "MCType.hxx"
#include "MEDLoaderDefines.hxx"
-#include "MEDFileUtilities.txx"
-#include "MEDCouplingMemArray.hxx"
#include "MCAuto.hxx"
#include "NormalizedGeometricTypes"
+#include <string>
+#include <cstddef>
+#include <vector>
+#include "med.h"
+#include <utility>
+#include <ostream>
namespace MEDCoupling
{
INTERP_KERNEL::NormalizedCellType loc_geo_type,
INTERP_KERNEL::NormalizedCellType rem_geo_type);
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileJointCorrespondence"); }
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
MEDLOADER_EXPORT MEDFileJointCorrespondence *deepCopy() const;
MEDLOADER_EXPORT MEDFileJointCorrespondence *shallowCpy() const;
MEDLOADER_EXPORT bool isEqual(const MEDFileJointCorrespondence *other) const;
MEDLOADER_EXPORT static MEDFileJointOneStep *New(const std::string& fileName, const std::string& mName, const std::string& jointName, int number=1);
MEDLOADER_EXPORT static MEDFileJointOneStep *New(med_idt fid, const std::string& mName, const std::string& jointName, int number=1);
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileJointOneStep"); }
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
MEDLOADER_EXPORT MEDFileJointOneStep *deepCopy() const;
MEDLOADER_EXPORT MEDFileJointOneStep *shallowCpy() const;
MEDLOADER_EXPORT bool isEqual(const MEDFileJointOneStep *other) const;
MEDLOADER_EXPORT static MEDFileJoint *New(med_idt fid, const std::string& mName, int num);
MEDLOADER_EXPORT static MEDFileJoint *New(const std::string& jointName, const std::string& locMeshName, const std::string& remoteMeshName, int remoteMeshNum );
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileJoint"); }
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
MEDLOADER_EXPORT MEDFileJoint *deepCopy() const;
MEDLOADER_EXPORT MEDFileJoint *shallowCpy() const;
MEDLOADER_EXPORT bool isEqual(const MEDFileJoint *other) const;
MEDLOADER_EXPORT int getNumberOfSteps() const;
MEDLOADER_EXPORT MEDFileJointOneStep *getStepAtPos(int i) const;
- MEDLOADER_EXPORT void writeLL(med_idt fid) const;
+ MEDLOADER_EXPORT void writeLL(med_idt fid) const override;
MEDLOADER_EXPORT std::string simpleRepr() const;
private:
MEDLOADER_EXPORT static MEDFileJoints *New(med_idt fid, const std::string& meshName);
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileJoints"); }
MEDLOADER_EXPORT MEDFileJoints *deepCopy() const;
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
MEDLOADER_EXPORT std::string simpleRepr() const;
MEDLOADER_EXPORT void simpleReprWithoutHeader(std::ostream& oss) const;
- MEDLOADER_EXPORT void writeLL(med_idt fid) const;
+ MEDLOADER_EXPORT void writeLL(med_idt fid) const override;
MEDLOADER_EXPORT std::string getMeshName() const;
MEDLOADER_EXPORT int getNumberOfJoints() const;
MEDLOADER_EXPORT MEDFileJoint *getJointAtPos(int i) const;
MEDLOADER_EXPORT void setJointAtPos(int i, MEDFileJoint *joint);
MEDLOADER_EXPORT void destroyJointAtPos(int i);
private:
- ~MEDFileJoints() { }
+ ~MEDFileJoints() override = default;
MEDFileJoints();
MEDFileJoints(med_idt fid, const std::string& meshName);
private:
// Author : Anthony Geay (CEA/DEN)
#include "MEDFileMesh.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingMesh.hxx"
+#include "MCAuto.hxx"
+#include "MEDFileEquivalence.hxx"
+#include "MCIdType.hxx"
+#include "MEDCouplingPartDefinition.hxx"
+#include "CellModel.hxx"
+#include "MEDCouplingPointSet.hxx"
+#include "MEDCouplingStructuredMesh.hxx"
+#include "MEDFileBasis.hxx"
+#include "MEDCouplingCurveLinearMesh.hxx"
+#include "InterpKernelException.hxx"
+#include "MEDCouplingRefCountObject.hxx"
#include "MEDFileFieldOverView.hxx"
#include "MEDFileField.hxx"
+#include "MEDFileMeshReadSelector.hxx"
+#include "MEDFileUtilities.hxx"
+#include "MEDFileMeshLL.hxx"
+#include "MEDFileJoint.hxx"
#include "MEDLoader.hxx"
-#include "MEDLoaderNS.hxx"
#include "MEDFileSafeCaller.txx"
#include "MEDLoaderBase.hxx"
#include "CrackAlgo.hxx"
+#include "MEDLoaderNS.hxx"
#include "MEDCouplingUMesh.hxx"
#include "MEDCouplingMappedExtrudedMesh.hxx"
#include "MEDCouplingMemArray.txx"
+// #include "MEDFileMeshElt.hxx"
#include "InterpKernelAutoPtr.hxx"
+#include "med.h"
+#include "NormalizedGeometricTypes"
+#include "MEDLoaderTraits.hxx"
+#include "medfile.h"
+#include "medmesh.h"
+#include <algorithm>
#include <cstddef>
+#include <functional>
+#include <iterator>
#include <limits>
#include <cmath>
-#include <memory>
-#include <numeric>
+#include <map>
+#include <set>
+#include <list>
+#include <sstream>
+#include <ostream>
+#include <utility>
+#include <vector>
+#include <string>
// From MEDLOader.cxx TU
extern med_geometry_type typmai[MED_N_CELL_FIXED_GEO];
std::size_t MEDFileMesh::getHeapMemorySizeWithoutChildren() const
{
std::size_t ret(_dt_unit.capacity()+_name.capacity()+_univ_name.capacity()+_desc_name.capacity());
- for(std::map<std::string, std::vector<std::string> >::const_iterator it=_groups.begin();it!=_groups.end();it++)
+ for(const auto & _group : _groups)
{
- ret+=(*it).first.capacity()+(*it).second.capacity()*sizeof(std::string);
- for(std::vector<std::string>::const_iterator it2=(*it).second.begin();it2!=(*it).second.end();it2++)
- ret+=(*it2).capacity();
+ ret+=_group.first.capacity()+_group.second.capacity()*sizeof(std::string);
+ for(const auto & it2 : _group.second)
+ ret+=it2.capacity();
}
- for(std::map<std::string,mcIdType>::const_iterator it=_families.begin();it!=_families.end();it++)
- ret+=(*it).first.capacity()+sizeof(mcIdType);
+ for(const auto & _familie : _families)
+ ret+=_familie.first.capacity()+sizeof(mcIdType);
return ret;
}
*/
MEDFileMesh *MEDFileMesh::New(const std::string& fileName, MEDFileMeshReadSelector *mrs)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return New(fid,mrs);
}
MEDFileMesh *MEDFileMesh::New(med_idt fid, MEDFileMeshReadSelector *mrs)
{
- std::vector<std::string> ms(MEDLoaderNS::getMeshNamesFid(fid));
+ std::vector<std::string> ms((MEDLoaderNS::getMeshNamesFid(fid)));
if(ms.empty())
{
std::ostringstream oss; oss << "MEDFileMesh::New : no meshes in file \"" << FileNameFromFID(fid) << "\" !";
*/
MEDFileMesh *MEDFileMesh::New(const std::string& fileName, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs, MEDFileJoints* joints)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return New(fid,mName,dt,it,mrs,joints);
}
-MEDFileMesh *MEDFileMesh::New(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs, MEDFileJoints* joints)
+MEDFileMesh *MEDFileMesh::New(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs, MEDFileJoints* /*joints*/)
{
MEDCoupling::MEDCouplingMeshType meshType;
int dummy0,dummy1;
bool MEDFileMesh::changeNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
{
- for(std::vector< std::pair<std::string,std::string> >::const_iterator it=modifTab.begin();it!=modifTab.end();it++)
+ for(const auto & it : modifTab)
{
- if((*it).first==_name)
+ if(it.first==_name)
{
- _name=(*it).second;
+ _name=it.second;
return true;
}
}
*/
std::vector<std::string> MEDFileMesh::getFamiliesOnGroup(const std::string& name) const
{
- std::string oname(name);
- std::map<std::string, std::vector<std::string> >::const_iterator it=_groups.find(oname);
+ std::string const oname(name);
+ auto const it=_groups.find(oname);
if(it==_groups.end())
{
std::vector<std::string> grps=getGroupsNames();
std::vector<std::string> MEDFileMesh::getFamiliesOnGroups(const std::vector<std::string>& grps) const
{
std::set<std::string> fams;
- for(std::vector<std::string>::const_iterator it=grps.begin();it!=grps.end();it++)
+ for(const auto & grp : grps)
{
- std::map<std::string, std::vector<std::string> >::const_iterator it2=_groups.find(*it);
+ auto const it2=_groups.find(grp);
if(it2==_groups.end())
{
- std::ostringstream oss; oss << "No such group in mesh \"" << _name << "\" : " << *it;
+ std::ostringstream oss; oss << "No such group in mesh \"" << _name << "\" : " << grp;
std::vector<std::string> grps2=getGroupsNames(); oss << "\" !\nAvailable groups are :";
std::copy(grps2.begin(),grps2.end(),std::ostream_iterator<std::string>(oss," "));
throw INTERP_KERNEL::Exception(oss.str().c_str());
*/
std::vector<mcIdType> MEDFileMesh::getFamiliesIdsOnGroup(const std::string& name) const
{
- std::string oname(name);
- std::map<std::string, std::vector<std::string> >::const_iterator it=_groups.find(oname);
+ std::string const oname(name);
+ auto const it=_groups.find(oname);
std::vector<std::string> grps=getGroupsNames();
if(it==_groups.end())
{
*/
void MEDFileMesh::setFamiliesOnGroup(const std::string& name, const std::vector<std::string>& fams)
{
- std::string oname(name);
+ std::string const oname(name);
_groups[oname]=fams;
- for(std::vector<std::string>::const_iterator it1=fams.begin();it1!=fams.end();it1++)
+ for(const auto & fam : fams)
{
- std::map<std::string,mcIdType>::iterator it2=_families.find(*it1);
+ auto const it2=_families.find(fam);
if(it2==_families.end())
- _families[*it1]=0;
+ _families[fam]=0;
}
}
*/
void MEDFileMesh::setFamiliesIdsOnGroup(const std::string& name, const std::vector<mcIdType>& famIds)
{
- std::string oname(name);
+ std::string const oname(name);
std::vector<std::string> fams(famIds.size());
int i=0;
- for(std::vector<mcIdType>::const_iterator it1=famIds.begin();it1!=famIds.end();it1++,i++)
+ for(auto it1=famIds.begin();it1!=famIds.end();it1++,i++)
{
- std::string name2=getFamilyNameGivenId(*it1);
+ std::string const name2=getFamilyNameGivenId(*it1);
fams[i]=name2;
}
_groups[oname]=fams;
std::vector<std::string> MEDFileMesh::getGroupsOnFamily(const std::string& name) const
{
std::vector<std::string> ret;
- for(std::map<std::string, std::vector<std::string> >::const_iterator it1=_groups.begin();it1!=_groups.end();it1++)
+ for(const auto & _group : _groups)
{
- for(std::vector<std::string>::const_iterator it2=(*it1).second.begin();it2!=(*it1).second.end();it2++)
+ for(auto it2=_group.second.begin();it2!=_group.second.end();it2++)
if((*it2)==name)
{
- ret.push_back((*it1).first);
+ ret.push_back(_group.first);
break;
}
}
*/
void MEDFileMesh::setGroupsOnFamily(const std::string& famName, const std::vector<std::string>& grps)
{
- std::string fName(famName);
+ std::string const fName(famName);
const std::map<std::string,mcIdType>::const_iterator it=_families.find(fName);
if(it==_families.end())
{
std::copy(fams.begin(),fams.end(),std::ostream_iterator<std::string>(oss," "));
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- for(std::vector<std::string>::const_iterator it3=grps.begin();it3!=grps.end();it3++)
+ for(const auto & grp : grps)
{
- std::map< std::string, std::vector<std::string> >::iterator it2=_groups.find(*it3);
+ auto const it2=_groups.find(grp);
if(it2!=_groups.end())
(*it2).second.push_back(fName);
else
{
- std::vector<std::string> grps2(1,fName);
- _groups[*it3]=grps2;
+ std::vector<std::string> const grps2(1,fName);
+ _groups[grp]=grps2;
}
}
}
{
std::vector<std::string> ret(_groups.size());
int i=0;
- for(std::map<std::string, std::vector<std::string> >::const_iterator it=_groups.begin();it!=_groups.end();it++,i++)
+ for(auto it=_groups.begin();it!=_groups.end();it++,i++)
ret[i]=(*it).first;
return ret;
}
{
std::vector<std::string> ret(_families.size());
int i=0;
- for(std::map<std::string, mcIdType >::const_iterator it=_families.begin();it!=_families.end();it++,i++)
+ for(auto it=_families.begin();it!=_families.end();it++,i++)
ret[i]=(*it).first;
return ret;
}
std::vector<std::string> MEDFileMesh::getGroupsOnSpecifiedLev(int meshDimRelToMaxExt) const
{
std::vector<std::string> ret;
- std::vector<std::string> allGrps(getGroupsNames());
+ std::vector<std::string> const allGrps(getGroupsNames());
const DataArrayIdType *arr=getFamilyFieldAtLevel(meshDimRelToMaxExt);
if(!arr)
return ret;
for(auto it2 : it.second)
{
auto it3 = _families.find( it2 );
- mcIdType famIdToTest = (*it3).second;
+ mcIdType const famIdToTest = (*it3).second;
if( famIdsInUse.find(famIdToTest) != famIdsInUse.end() )
{
ret.push_back( it.first );
*/
std::vector<mcIdType> MEDFileMesh::getGrpNonEmptyLevelsExt(const std::string& grp) const
{
- std::vector<std::string> fams(getFamiliesOnGroup(grp));
+ std::vector<std::string> const fams(getFamiliesOnGroup(grp));
return getFamsNonEmptyLevelsExt(fams);
}
*/
std::vector<mcIdType> MEDFileMesh::getGrpsNonEmptyLevels(const std::vector<std::string>& grps) const
{
- std::vector<std::string> fams(getFamiliesOnGroups(grps));
+ std::vector<std::string> const fams(getFamiliesOnGroups(grps));
return getFamsNonEmptyLevels(fams);
}
*/
std::vector<mcIdType> MEDFileMesh::getGrpsNonEmptyLevelsExt(const std::vector<std::string>& grps) const
{
- std::vector<std::string> fams(getFamiliesOnGroups(grps));
+ std::vector<std::string> const fams(getFamiliesOnGroups(grps));
return getFamsNonEmptyLevelsExt(fams);
}
*/
std::vector<mcIdType> MEDFileMesh::getGrpNonEmptyLevels(const std::string& grp) const
{
- std::vector<std::string> fams(getFamiliesOnGroup(grp));
+ std::vector<std::string> const fams(getFamiliesOnGroup(grp));
return getFamsNonEmptyLevels(fams);
}
*/
std::vector<mcIdType> MEDFileMesh::getFamNonEmptyLevels(const std::string& fam) const
{
- std::vector<std::string> fams(1,std::string(fam));
+ std::vector<std::string> const fams(1,std::string(fam));
return getFamsNonEmptyLevels(fams);
}
*/
std::vector<mcIdType> MEDFileMesh::getFamNonEmptyLevelsExt(const std::string& fam) const
{
- std::vector<std::string> fams(1,std::string(fam));
+ std::vector<std::string> const fams(1,std::string(fam));
return getFamsNonEmptyLevelsExt(fams);
}
}
newFams[grps[0]]=(*it).second;
std::vector<std::string>& grps2=groups[grps[0]];
- std::size_t pos=std::distance(grps2.begin(),std::find(grps2.begin(),grps2.end(),(*it).first));
+ std::size_t const pos=std::distance(grps2.begin(),std::find(grps2.begin(),grps2.end(),(*it).first));
grps2[pos]=grps[0];
}
else
void MEDFileMesh::removeGroupAtLevel(int meshDimRelToMaxExt, const std::string& name)
{
- std::map<std::string, std::vector<std::string> >::iterator it(_groups.find(name));
+ auto const it(_groups.find(name));
std::vector<std::string> grps(getGroupsNames());
if(it==_groups.end())
{
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
const std::vector<std::string> &famsOnGrp((*it).second);
- std::vector<mcIdType> famIds(getFamiliesIdsOnGroup(name));
+ std::vector<mcIdType> const famIds(getFamiliesIdsOnGroup(name));
const DataArrayIdType *famArr(getFamilyFieldAtLevel(meshDimRelToMaxExt));
if(!famArr)
return ;
if(idsToKill->empty())
return ;
std::vector<std::string> newFamsOnGrp;
- for(std::vector<std::string>::const_iterator itt=famsOnGrp.begin();itt!=famsOnGrp.end();itt++)
+ for(const auto & itt : famsOnGrp)
{
- if(!idsToKill->presenceOfValue(getFamilyId(*itt)))
- newFamsOnGrp.push_back(*itt);
+ if(!idsToKill->presenceOfValue(getFamilyId(itt)))
+ newFamsOnGrp.push_back(itt);
}
(*it).second=newFamsOnGrp;
}
*/
void MEDFileMesh::removeGroup(const std::string& name)
{
- std::map<std::string, std::vector<std::string> >::iterator it=_groups.find(name);
+ auto const it=_groups.find(name);
std::vector<std::string> grps(getGroupsNames());
if(it==_groups.end())
{
*/
void MEDFileMesh::removeFamily(const std::string& name)
{
- std::string oname(name);
- std::map<std::string, mcIdType >::iterator it=_families.find(oname);
+ std::string const oname(name);
+ auto const it=_families.find(oname);
std::vector<std::string> fams=getFamiliesNames();
if(it==_families.end())
{
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
_families.erase(it);
- for(std::map<std::string, std::vector<std::string> >::iterator it3=_groups.begin();it3!=_groups.end();it3++)
+ for(auto & _group : _groups)
{
- std::vector<std::string>& v=(*it3).second;
- std::vector<std::string>::iterator it4=std::find(v.begin(),v.end(),oname);
+ std::vector<std::string>& v=_group.second;
+ auto const it4=std::find(v.begin(),v.end(),oname);
if(it4!=v.end())
v.erase(it4);
}
else
{
ret.push_back((*it).first);
- std::vector<std::string> grpsOnEraseFam=getGroupsOnFamily((*it).first);
- for(std::vector<std::string>::const_iterator it2=grpsOnEraseFam.begin();it2!=grpsOnEraseFam.end();it2++)
+ std::vector<std::string> const grpsOnEraseFam=getGroupsOnFamily((*it).first);
+ for(const auto & it2 : grpsOnEraseFam)
{
- std::map<std::string, std::vector<std::string> >::iterator it3=grps.find(*it2);//it3!=grps.empty() thanks to copy
+ auto const it3=grps.find(it2);//it3!=grps.empty() thanks to copy
std::vector<std::string>& famv=(*it3).second;
- std::vector<std::string>::iterator it4=std::find(famv.begin(),famv.end(),(*it).first);//it4!=famv.end() thanks to copy
+ auto const it4=std::find(famv.begin(),famv.end(),(*it).first);//it4!=famv.end() thanks to copy
famv.erase(it4);
}
}
*/
void MEDFileMesh::removeFamiliesReferedByNoGroups()
{
- std::map<std::string,mcIdType> fams;
+ std::map<std::string,mcIdType> const fams;
std::set<std::string> sfams;
for(std::map<std::string,mcIdType>::const_iterator it=_families.begin();it!=_families.end();it++)
sfams.insert((*it).first);
for(std::map<std::string, std::vector<std::string> >::const_iterator it0=_groups.begin();it0!=_groups.end();it0++)
- for(std::vector<std::string>::const_iterator it1=(*it0).second.begin();it1!=(*it0).second.end();it1++)
- sfams.erase(*it1);
- for(std::set<std::string>::const_iterator it=sfams.begin();it!=sfams.end();it++)
- if(*it!=DFT_FAM_NAME)
- _families.erase(*it);
+ for(const auto & it1 : (*it0).second)
+ sfams.erase(it1);
+ for(const auto & sfam : sfams)
+ if(sfam!=DFT_FAM_NAME)
+ _families.erase(sfam);
}
/*!
checkOrphanFamilyZero();
removeFamiliesReferedByNoGroups();
//
- std::vector<int> levels(getNonEmptyLevelsExt());
+ std::vector<int> const levels(getNonEmptyLevelsExt());
std::set<mcIdType> idsRefed;
for(std::map<std::string,mcIdType>::const_iterator it=_families.begin();it!=_families.end();it++)
{
}
}
}
- for(std::vector<int>::const_iterator it=levels.begin();it!=levels.end();it++)
+ for(int const level : levels)
{
- const DataArrayIdType *fams(0);
+ const DataArrayIdType *fams(nullptr);
try
{
- fams=getFamilyFieldAtLevel(*it);
+ fams=getFamilyFieldAtLevel(level);
}
catch(INTERP_KERNEL::Exception& ) { }
if(!fams)
continue;
std::vector<bool> v(fams->getNumberOfTuples(),false);
- for(std::set<mcIdType>::const_iterator pt=idsRefed.begin();pt!=idsRefed.end();pt++)
- fams->switchOnTupleEqualTo(*pt,v);
+ for(long const pt : idsRefed)
+ fams->switchOnTupleEqualTo(pt,v);
MCAuto<DataArrayIdType> unfetchedIds(DataArrayIdType::BuildListOfSwitchedOff(v));
if(!unfetchedIds->empty())
{
MCAuto<DataArrayIdType> newFams(fams->deepCopy());
newFams->setPartOfValuesSimple3(0,unfetchedIds->begin(),unfetchedIds->end(),0,1,1);
- setFamilyFieldArr(*it,newFams);
+ setFamilyFieldArr(level,newFams);
}
}
removeOrphanFamilies();
for(auto fam : _families)
{
std::vector<std::string> grps( this->getGroupsOnFamily( fam.first ) );
- std::set<std::string> sgrps(grps.begin(),grps.end());
+ std::set<std::string> const sgrps(grps.begin(),grps.end());
setOfFamilies[sgrps].push_back(fam.first);
}
//
std::map<std::string, std::vector<std::string> > newGroups(_groups);
std::map<std::string,mcIdType> newFams(_families);
- std::vector<int> levels(getNonEmptyLevelsExt());
+ std::vector<int> const levels(getNonEmptyLevelsExt());
std::map<mcIdType, std::vector<mcIdType> > famIdsToSubstitute;
// iterate on all different set of groups
std::set<std::string> familiesToKill;
{
if( setOfCommonGrp.second.size()<=1 )
continue;
- std::string newFamName(setOfCommonGrp.second[0]);
+ std::string const newFamName(setOfCommonGrp.second[0]);
auto newFamID(_families[newFamName]);
for(auto grpToBeModified : setOfCommonGrp.first)
{
// apply modifications in datastructure
for(auto famIdsSubstSession : famIdsToSubstitute)
{
- for(std::vector<int>::const_iterator it=levels.begin();it!=levels.end();it++)
+ for(int const level : levels)
{
DataArrayIdType *fams(nullptr);
try
{
- fams=getFamilyFieldAtLevel(*it);
+ fams=getFamilyFieldAtLevel(level);
}
catch(INTERP_KERNEL::Exception& ) { }
if(!fams)
*/
void MEDFileMesh::checkOrphanFamilyZero() const
{
- for(std::map<std::string, std::vector<std::string> >::const_iterator it=_groups.begin();it!=_groups.end();it++)
+ for(const auto & _group : _groups)
{
- if(std::find((*it).second.begin(),(*it).second.end(),DFT_FAM_NAME)!=(*it).second.end())
+ if(std::find(_group.second.begin(),_group.second.end(),DFT_FAM_NAME)!=_group.second.end())
{
- std::ostringstream oss; oss << "MEDFileMesh::rearrangeFamilies : Groups \"" << (*it).first << "\" is lying on family \"" << DFT_FAM_NAME << "\" !";
+ std::ostringstream oss; oss << "MEDFileMesh::rearrangeFamilies : Groups \"" << _group.first << "\" is lying on family \"" << DFT_FAM_NAME << "\" !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
}
*/
void MEDFileMesh::changeGroupName(const std::string& oldName, const std::string& newName)
{
- std::string oname(oldName);
- std::map<std::string, std::vector<std::string> >::iterator it=_groups.find(oname);
+ std::string const oname(oldName);
+ auto const it=_groups.find(oname);
std::vector<std::string> grps=getGroupsNames();
if(it==_groups.end())
{
std::copy(grps.begin(),grps.end(),std::ostream_iterator<std::string>(oss," "));
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- std::string nname(newName);
- std::map<std::string, std::vector<std::string> >::iterator it2=_groups.find(nname);
+ std::string const nname(newName);
+ auto const it2=_groups.find(nname);
if(it2!=_groups.end())
{
std::ostringstream oss; oss << "Such groupname \"" << newName << "\" already exists ! Kill it before !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- std::vector<std::string> cpy=(*it).second;
+ std::vector<std::string> const cpy=(*it).second;
_groups.erase(it);
_groups[newName]=cpy;
}
*/
void MEDFileMesh::changeFamilyName(const std::string& oldName, const std::string& newName)
{
- std::string oname(oldName);
- std::map<std::string, mcIdType >::iterator it=_families.find(oname);
+ std::string const oname(oldName);
+ auto const it=_families.find(oname);
std::vector<std::string> fams=getFamiliesNames();
if(it==_families.end())
{
std::copy(fams.begin(),fams.end(),std::ostream_iterator<std::string>(oss," "));
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- std::string nname(newName);
- std::map<std::string, mcIdType >::iterator it2=_families.find(nname);
+ std::string const nname(newName);
+ auto const it2=_families.find(nname);
if(it2!=_families.end())
{
std::ostringstream oss; oss << "Such familyname \"" << newName << " already exists ! Kill it before !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- mcIdType cpy=(*it).second;
+ mcIdType const cpy=(*it).second;
_families.erase(it);
_families[newName]=cpy;
- for(std::map<std::string, std::vector<std::string> >::iterator it3=_groups.begin();it3!=_groups.end();it3++)
+ for(auto & _group : _groups)
{
- std::vector<std::string>& v=(*it3).second;
- std::vector<std::string>::iterator it4=std::find(v.begin(),v.end(),oname);
+ std::vector<std::string>& v=_group.second;
+ auto const it4=std::find(v.begin(),v.end(),oname);
if(it4!=v.end())
(*it4)=nname;
}
* \return bool - \c true if number of families and their ids are the same in the two
* meshes. Families with the id == \c 0 are not considered.
*/
-bool MEDFileMesh::areFamsEqual(const MEDFileMesh *other, std::string& what) const
+bool MEDFileMesh::areFamsEqual(const MEDFileMesh *other, std::string& /*what*/) const
{
if(_families==other->_families)
return true;
std::map<std::string,mcIdType> fam0;
std::map<std::string,mcIdType> fam1;
- for(std::map<std::string,mcIdType>::const_iterator it=_families.begin();it!=_families.end();it++)
- if((*it).second!=0)
- fam0[(*it).first]=(*it).second;
- for(std::map<std::string,mcIdType>::const_iterator it=other->_families.begin();it!=other->_families.end();it++)
- if((*it).second!=0)
- fam1[(*it).first]=(*it).second;
+ for(const auto & _familie : _families)
+ if(_familie.second!=0)
+ fam0[_familie.first]=_familie.second;
+ for(const auto & _familie : other->_families)
+ if(_familie.second!=0)
+ fam1[_familie.first]=_familie.second;
return fam0==fam1;
}
if(_groups==other->_groups)
return true;
bool ret=true;
- std::size_t sz=_groups.size();
+ std::size_t const sz=_groups.size();
if(sz!=other->_groups.size())
{
what="Groups differ because not same number !\n";
}
if(ret)
{
- std::map<std::string, std::vector<std::string> >::const_iterator it1=_groups.begin();
+ auto it1=_groups.begin();
for(std::size_t i=0;i<sz && ret;i++,it1++)
{
- std::map<std::string, std::vector<std::string> >::const_iterator it2=other->_groups.find((*it1).first);
+ auto const it2=other->_groups.find((*it1).first);
if(it2!=other->_groups.end())
{
- std::set<std::string> s1((*it1).second.begin(),(*it1).second.end());
- std::set<std::string> s2((*it2).second.begin(),(*it2).second.end());
+ std::set<std::string> const s1((*it1).second.begin(),(*it1).second.end());
+ std::set<std::string> const s2((*it2).second.begin(),(*it2).second.end());
ret=(s1==s2);
}
else
{
std::ostringstream oss; oss << "Groups description differs :\n";
oss << "First group description :\n";
- for(std::map<std::string, std::vector<std::string> >::const_iterator it=_groups.begin();it!=_groups.end();it++)
+ for(const auto & _group : _groups)
{
- oss << " Group \"" << (*it).first << "\" on following families :\n";
- for(std::vector<std::string>::const_iterator it2=(*it).second.begin();it2!=(*it).second.end();it2++)
- oss << " \"" << *it2 << "\n";
+ oss << " Group \"" << _group.first << "\" on following families :\n";
+ for(const auto & it2 : _group.second)
+ oss << " \"" << it2 << "\n";
}
oss << "Second group description :\n";
- for(std::map<std::string, std::vector<std::string> >::const_iterator it=other->_groups.begin();it!=other->_groups.end();it++)
+ for(const auto & _group : other->_groups)
{
- oss << " Group \"" << (*it).first << "\" on following families :\n";
- for(std::vector<std::string>::const_iterator it2=(*it).second.begin();it2!=(*it).second.end();it2++)
- oss << " \"" << *it2 << "\n";
+ oss << " Group \"" << _group.first << "\" on following families :\n";
+ for(const auto & it2 : _group.second)
+ oss << " \"" << it2 << "\n";
}
what+=oss.str();
}
*/
bool MEDFileMesh::existsGroup(const std::string& groupName) const
{
- std::string grpName(groupName);
+ std::string const grpName(groupName);
return _groups.find(grpName)!=_groups.end();
}
*/
bool MEDFileMesh::existsFamily(mcIdType famId) const
{
- for(std::map<std::string,mcIdType>::const_iterator it2=_families.begin();it2!=_families.end();it2++)
- if((*it2).second==famId)
+ for(const auto & _familie : _families)
+ if(_familie.second==famId)
return true;
return false;
}
*/
bool MEDFileMesh::existsFamily(const std::string& familyName) const
{
- std::string fname(familyName);
+ std::string const fname(familyName);
return _families.find(fname)!=_families.end();
}
*/
void MEDFileMesh::setFamilyId(const std::string& familyName, mcIdType id)
{
- std::string fname(familyName);
+ std::string const fname(familyName);
_families[fname]=id;
}
void MEDFileMesh::setFamilyIdUnique(const std::string& familyName, mcIdType id)
{
- std::string fname(familyName);
+ std::string const fname(familyName);
for(std::map<std::string,mcIdType>::const_iterator it=_families.begin();it!=_families.end();it++)
if((*it).second==id)
{
*/
void MEDFileMesh::addFamily(const std::string& familyName, mcIdType famId)
{
- std::string fname(familyName);
- std::map<std::string,mcIdType>::const_iterator it=_families.find(fname);
+ std::string const fname(familyName);
+ std::map<std::string,mcIdType>::const_iterator const it=_families.find(fname);
if(it==_families.end())
{
for(std::map<std::string,mcIdType>::const_iterator it2=_families.begin();it2!=_families.end();it2++)
*/
void MEDFileMesh::createGroupOnAll(int meshDimRelToMaxExt, const std::string& groupName)
{
- std::string grpName(groupName);
+ std::string const grpName(groupName);
std::vector<int> levs=getNonEmptyLevelsExt();
if(std::find(levs.begin(),levs.end(),meshDimRelToMaxExt)==levs.end())
{
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
const DataArrayIdType *fieldFamIds=getFamilyFieldAtLevel(meshDimRelToMaxExt);
- if(fieldFamIds==0)
+ if(fieldFamIds==nullptr)
throw INTERP_KERNEL::Exception("MEDFileMesh::createGroupOnAll : Family field arr ids is not defined for this level !");
MCAuto<DataArrayIdType> famIds=fieldFamIds->getDifferentValues();
std::vector<std::string> familiesOnWholeGroup;
- for(const mcIdType *it=famIds->begin();it!=famIds->end();it++)
+ for(long const it : *famIds)
{
bool tmp;
- familiesOnWholeGroup.push_back(findOrCreateAndGiveFamilyWithId(*it,tmp));
+ familiesOnWholeGroup.push_back(findOrCreateAndGiveFamilyWithId(it,tmp));
}
_groups[grpName]=familiesOnWholeGroup;
}
*/
bool MEDFileMesh::keepFamIdsOnlyOnLevs(const std::vector<mcIdType>& famIds, const std::vector<int>& vMeshDimRelToMaxExt)
{
- std::set<int> levsInput(vMeshDimRelToMaxExt.begin(),vMeshDimRelToMaxExt.end());
+ std::set<int> const levsInput(vMeshDimRelToMaxExt.begin(),vMeshDimRelToMaxExt.end());
std::vector<int> levs=getNonEmptyLevelsExt();
- std::set<int> levs2(levs.begin(),levs.end());
+ std::set<int> const levs2(levs.begin(),levs.end());
std::vector<int> levsToTest;
std::set_difference(levs2.begin(),levs2.end(),levsInput.begin(),levsInput.end(),std::back_insert_iterator< std::vector<int> >(levsToTest));
- std::set<mcIdType> famIds2(famIds.begin(),famIds.end());
+ std::set<mcIdType> const famIds2(famIds.begin(),famIds.end());
bool ret=true;
mcIdType maxFamId=1;
if(!_families.empty())
maxFamId=getMaxFamilyId()+1;
- std::vector<std::string> allFams=getFamiliesNames();
- for(std::vector<int>::const_iterator it=levsToTest.begin();it!=levsToTest.end();it++)
+ std::vector<std::string> const allFams=getFamiliesNames();
+ for(int const it : levsToTest)
{
- const DataArrayIdType *fieldFamIds=getFamilyFieldAtLevel(*it);
+ const DataArrayIdType *fieldFamIds=getFamilyFieldAtLevel(it);
if(fieldFamIds)
{
- MCAuto<DataArrayIdType> famIds3=fieldFamIds->getDifferentValues();
+ MCAuto<DataArrayIdType> const famIds3=fieldFamIds->getDifferentValues();
std::vector<mcIdType> tmp;
std::set_intersection(famIds3->begin(),famIds3->end(),famIds2.begin(),famIds2.end(),std::back_insert_iterator< std::vector<mcIdType> >(tmp));
- for(std::vector<mcIdType>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
+ for(long const it2 : tmp)
{
ret=false;
- std::string famName=getFamilyNameGivenId(*it2);
+ std::string const famName=getFamilyNameGivenId(it2);
std::ostringstream oss; oss << "Family_" << maxFamId;
- std::string zeName=CreateNameNotIn(oss.str(),allFams);
+ std::string const zeName=CreateNameNotIn(oss.str(),allFams);
addFamilyOnAllGroupsHaving(famName,zeName);
_families[zeName]=maxFamId;
- (const_cast<DataArrayIdType *>(fieldFamIds))->changeValue(*it2,maxFamId);
+ (const_cast<DataArrayIdType *>(fieldFamIds))->changeValue(it2,maxFamId);
maxFamId++;
}
}
*/
void MEDFileMesh::addFamilyOnGrp(const std::string& grpName, const std::string& famName)
{
- std::string grpn(grpName);
- std::string famn(famName);
+ std::string const grpn(grpName);
+ std::string const famn(famName);
if(grpn.empty() || famn.empty())
throw INTERP_KERNEL::Exception("MEDFileMesh::addFamilyOnGrp : input strings must be non null !");
std::vector<std::string> fams=getFamiliesNames();
std::copy(fams.begin(),fams.end(),std::ostream_iterator<std::string>(oss," ")); oss << ".";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- std::map<std::string, std::vector<std::string> >::iterator it=_groups.find(grpn);
+ auto const it=_groups.find(grpn);
if(it==_groups.end())
{
_groups[grpn].push_back(famn);
}
else
{
- std::vector<std::string>::iterator it2=std::find((*it).second.begin(),(*it).second.end(),famn);
+ auto const it2=std::find((*it).second.begin(),(*it).second.end(),famn);
if(it2==(*it).second.end())
(*it).second.push_back(famn);
}
*/
void MEDFileMesh::addFamilyOnAllGroupsHaving(const std::string& famName, const std::string& otherFamName)
{
- std::string famNameCpp(famName);
- std::string otherCpp(otherFamName);
- for(std::map<std::string, std::vector<std::string> >::iterator it=_groups.begin();it!=_groups.end();it++)
+ std::string const famNameCpp(famName);
+ std::string const otherCpp(otherFamName);
+ for(auto & _group : _groups)
{
- std::vector<std::string>& v=(*it).second;
+ std::vector<std::string>& v=_group.second;
if(std::find(v.begin(),v.end(),famNameCpp)!=v.end())
{
v.push_back(otherCpp);
std::vector<std::string> grpsNames(getGroupsNames());
if(std::find(grpsNames.begin(),grpsNames.end(),grpName)==grpsNames.end())
return ;
- std::vector<mcIdType> famIds(getFamiliesIdsOnGroup(grpName));
+ std::vector<mcIdType> const famIds(getFamiliesIdsOnGroup(grpName));
if(famArr->presenceOfValue(famIds))
{
std::ostringstream oss; oss << "MEDFileUMesh::addGroup : Group with name \"" << grpName << "\" already exists at specified level ! Destroy it before calling this method !";
{
if(!ids)
throw INTERP_KERNEL::Exception("MEDFileUMesh::addGroup : NULL pointer in input !");
- std::string grpName(ids->getName());
+ std::string const grpName(ids->getName());
if(grpName.empty())
throw INTERP_KERNEL::Exception("MEDFileUMesh::addGroup : empty group name ! MED file format do not accept empty group name !");
ids->checkStrictlyMonotonic(true);
else
{
familyIds.push_back(isNodeGroup?maxVal:-maxVal); idsPerfamiliyIds.push_back(ids2);
- std::string locFamName=FindOrCreateAndGiveFamilyWithId(families,isNodeGroup?maxVal:-maxVal,created);
+ std::string const locFamName=FindOrCreateAndGiveFamilyWithId(families,isNodeGroup?maxVal:-maxVal,created);
fams.push_back(locFamName);
if(existsFamily(*famId))
{
- std::string locFamName2=getFamilyNameGivenId(*famId); std::vector<std::string> v(2); v[0]=locFamName2; v[1]=locFamName;
+ std::string const locFamName2=getFamilyNameGivenId(*famId); std::vector<std::string> v(2); v[0]=locFamName2; v[1]=locFamName;
ChangeAllGroupsContainingFamily(groups,getFamilyNameGivenId(*famId),v);
}
maxVal++;
{
familyIds.push_back(isNodeGroup?maxVal:-maxVal); idsPerfamiliyIds.push_back(ret0); // modifying all other groups on *famId to lie on maxVal and on maxVal+1
familyIds.push_back(isNodeGroup?maxVal+1:-maxVal-1); idsPerfamiliyIds.push_back(ids2);//grp lie only on maxVal+1
- std::string n2(FindOrCreateAndGiveFamilyWithId(families,isNodeGroup?maxVal+1:-maxVal-1,created)); fams.push_back(n2);
+ std::string const n2(FindOrCreateAndGiveFamilyWithId(families,isNodeGroup?maxVal+1:-maxVal-1,created)); fams.push_back(n2);
if(existsFamily(*famId))
{
- std::string n1(FindOrCreateAndGiveFamilyWithId(families,isNodeGroup?maxVal:-maxVal,created)); std::vector<std::string> v(2); v[0]=n1; v[1]=n2;
+ std::string const n1(FindOrCreateAndGiveFamilyWithId(families,isNodeGroup?maxVal:-maxVal,created)); std::vector<std::string> v(2); v[0]=n1; v[1]=n2;
ChangeAllGroupsContainingFamily(groups,getFamilyNameGivenId(*famId),v);
}
maxVal+=2;
famArr->setPartOfValuesSimple3(familyIds[i],da->begin(),da->end(),0,1,1);
}
_families=families;
- std::map<std::string, std::vector<std::string> >::iterator itt(groups.find(grpName));
+ auto const itt(groups.find(grpName));
if(itt!=groups.end())
{
std::vector<std::string>& famsOnGrp((*itt).second);
void MEDFileMesh::ChangeAllGroupsContainingFamily(std::map<std::string, std::vector<std::string> >& groups, const std::string& familyNameToChange, const std::vector<std::string>& newFamiliesNames)
{
- std::string fam(familyNameToChange);
- for(std::map<std::string, std::vector<std::string> >::iterator it=groups.begin();it!=groups.end();it++)
+ std::string const fam(familyNameToChange);
+ for(auto & group : groups)
{
- std::vector<std::string>& fams((*it).second);
- std::vector<std::string>::iterator it2=std::find(fams.begin(),fams.end(),fam);
+ std::vector<std::string>& fams(group.second);
+ auto const it2=std::find(fams.begin(),fams.end(),fam);
if(it2!=fams.end())
{
fams.erase(it2);
*/
mcIdType MEDFileMesh::getFamilyId(const std::string& name) const
{
- std::map<std::string, mcIdType>::const_iterator it=_families.find(name);
+ auto const it=_families.find(name);
if(it==_families.end())
{
std::vector<std::string> fams(getFamiliesNames());
{
std::vector<mcIdType> ret(fams.size());
int i=0;
- for(std::vector<std::string>::const_iterator it=fams.begin();it!=fams.end();it++,i++)
+ for(auto it=fams.begin();it!=fams.end();it++,i++)
{
- std::map<std::string, mcIdType>::const_iterator it2=_families.find(*it);
+ auto const it2=_families.find(*it);
if(it2==_families.end())
{
std::vector<std::string> fams2=getFamiliesNames();
if(_families.empty())
throw INTERP_KERNEL::Exception("MEDFileMesh::getMaxFamilyId : no families set !");
mcIdType ret=-std::numeric_limits<mcIdType>::max();
- for(std::map<std::string,mcIdType>::const_iterator it=_families.begin();it!=_families.end();it++)
+ for(const auto & _familie : _families)
{
- ret=std::max(std::abs((*it).second),ret);
+ ret=std::max(std::abs(_familie.second),ret);
}
return ret;
}
if(_families.empty())
throw INTERP_KERNEL::Exception("MEDFileMesh::getMaxFamilyId : no families set !");
mcIdType ret=-std::numeric_limits<mcIdType>::max();
- for(std::map<std::string,mcIdType>::const_iterator it=_families.begin();it!=_families.end();it++)
+ for(const auto & _familie : _families)
{
- ret=std::max((*it).second,ret);
+ ret=std::max(_familie.second,ret);
}
return ret;
}
if(_families.empty())
throw INTERP_KERNEL::Exception("MEDFileMesh::getMinFamilyId : no families set !");
mcIdType ret=std::numeric_limits<mcIdType>::max();
- for(std::map<std::string,mcIdType>::const_iterator it=_families.begin();it!=_families.end();it++)
+ for(const auto & _familie : _families)
{
- ret=std::min((*it).second,ret);
+ ret=std::min(_familie.second,ret);
}
return ret;
}
mcIdType MEDFileMesh::getTheMaxAbsFamilyId() const
{
mcIdType m1=-std::numeric_limits<mcIdType>::max();
- for(std::map<std::string,mcIdType>::const_iterator it=_families.begin();it!=_families.end();it++)
- m1=std::max(std::abs((*it).second),m1);
- mcIdType m2=getMaxAbsFamilyIdInArrays();
+ for(const auto & _familie : _families)
+ m1=std::max(std::abs(_familie.second),m1);
+ mcIdType const m2=getMaxAbsFamilyIdInArrays();
return std::max(m1,m2);
}
mcIdType MEDFileMesh::getTheMaxFamilyId() const
{
mcIdType m1=-std::numeric_limits<mcIdType>::max();
- for(std::map<std::string,mcIdType>::const_iterator it=_families.begin();it!=_families.end();it++)
- m1=std::max((*it).second,m1);
- mcIdType m2=getMaxFamilyIdInArrays();
+ for(const auto & _familie : _families)
+ m1=std::max(_familie.second,m1);
+ mcIdType const m2=getMaxFamilyIdInArrays();
return std::max(m1,m2);
}
mcIdType MEDFileMesh::getTheMinFamilyId() const
{
mcIdType m1=std::numeric_limits<mcIdType>::max();
- for(std::map<std::string,mcIdType>::const_iterator it=_families.begin();it!=_families.end();it++)
- m1=std::min((*it).second,m1);
- mcIdType m2=getMinFamilyIdInArrays();
+ for(const auto & _familie : _families)
+ m1=std::min(_familie.second,m1);
+ mcIdType const m2=getMinFamilyIdInArrays();
return std::min(m1,m2);
}
{
MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
std::set<mcIdType> v;
- for(std::map<std::string,mcIdType>::const_iterator it=_families.begin();it!=_families.end();it++)
- v.insert((*it).second);
+ for(const auto & _familie : _families)
+ v.insert(_familie.second);
ret->alloc((mcIdType)v.size(),1);
std::copy(v.begin(),v.end(),ret->getPointer());
return ret.retn();
*/
DataArrayIdType *MEDFileMesh::computeAllFamilyIdsInUse() const
{
- std::vector<int> famLevs=getFamArrNonEmptyLevelsExt();
+ std::vector<int> const famLevs=getFamArrNonEmptyLevelsExt();
MCAuto<DataArrayIdType> ret;
- for(std::vector<int>::const_iterator it=famLevs.begin();it!=famLevs.end();it++)
+ for(int const famLev : famLevs)
{
- const DataArrayIdType *arr=getFamilyFieldAtLevel(*it);//arr not null due to spec of getFamArrNonEmptyLevelsExt
+ const DataArrayIdType *arr=getFamilyFieldAtLevel(famLev);//arr not null due to spec of getFamArrNonEmptyLevelsExt
MCAuto<DataArrayIdType> dv=arr->getDifferentValues();
if((DataArrayIdType *) ret)
ret=dv->buildUnion(ret);
*/
bool MEDFileMesh::ensureDifferentFamIdsPerLevel()
{
- std::vector<int> levs=getNonEmptyLevelsExt();
- std::set<mcIdType> allFamIds;
+ std::vector<int> const levs=getNonEmptyLevelsExt();
+ std::set<mcIdType> const allFamIds;
mcIdType maxId=getMaxFamilyId()+1;
std::map<int,std::vector<mcIdType> > famIdsToRenum;
- for(std::vector<int>::const_iterator it=levs.begin();it!=levs.end();it++)
+ for(int const lev : levs)
{
- const DataArrayIdType *fam=getFamilyFieldAtLevel(*it);
+ const DataArrayIdType *fam=getFamilyFieldAtLevel(lev);
if(fam)
{
MCAuto<DataArrayIdType> tmp=fam->getDifferentValues();
std::set<mcIdType> r2;
std::set_intersection(tmp->begin(),tmp->end(),allFamIds.begin(),allFamIds.end(),std::inserter(r2,r2.end()));
if(!r2.empty())
- famIdsToRenum[*it].insert(famIdsToRenum[*it].end(),r2.begin(),r2.end());
+ famIdsToRenum[lev].insert(famIdsToRenum[lev].end(),r2.begin(),r2.end());
std::set<mcIdType> r3;
std::set_union(tmp->begin(),tmp->end(),allFamIds.begin(),allFamIds.end(),std::inserter(r3,r3.end()));
}
MCAuto<DataArrayIdType> allIds=getAllFamiliesIdsReferenced();
for(std::map<int,std::vector<mcIdType> >::const_iterator it2=famIdsToRenum.begin();it2!=famIdsToRenum.end();it2++)
{
- DataArrayIdType *fam=const_cast<DataArrayIdType *>(getFamilyFieldAtLevel((*it2).first));
+ auto *fam=const_cast<DataArrayIdType *>(getFamilyFieldAtLevel((*it2).first));
mcIdType *famIdsToChange=fam->getPointer();
std::map<mcIdType,mcIdType> ren;
- for(std::vector<mcIdType>::const_iterator it3=(*it2).second.begin();it3!=(*it2).second.end();it3++,maxId++)
+ for(auto it3=(*it2).second.begin();it3!=(*it2).second.end();it3++,maxId++)
{
if(allIds->presenceOfValue(*it3))
{
- std::string famName=getFamilyNameGivenId(*it3);
- std::vector<std::string> grps=getGroupsOnFamily(famName);
+ std::string const famName=getFamilyNameGivenId(*it3);
+ std::vector<std::string> const grps=getGroupsOnFamily(famName);
ren[*it3]=maxId;
bool dummy;
- std::string newFam=findOrCreateAndGiveFamilyWithId(maxId,dummy);
- for(std::vector<std::string>::const_iterator it4=grps.begin();it4!=grps.end();it4++)
- addFamilyOnGrp((*it4),newFam);
+ std::string const newFam=findOrCreateAndGiveFamilyWithId(maxId,dummy);
+ for(const auto & grp : grps)
+ addFamilyOnGrp(grp,newFam);
}
}
MCAuto<DataArrayIdType> ids=fam->findIdsEqualList(&(*it2).second[0],&(*it2).second[0]+(*it2).second.size());
- for(const mcIdType *id=ids->begin();id!=ids->end();id++)
- famIdsToChange[*id]=ren[famIdsToChange[*id]];
+ for(long const id : *ids)
+ famIdsToChange[id]=ren[famIdsToChange[id]];
}
return false;
}
std::map<mcIdType,mcIdType> ren;
for(const mcIdType *it=tmp->begin();it!=tmp->end();it++,refId++)
ren[*it]=refId;
- mcIdType nbOfTuples=fam->getNumberOfTuples();
+ mcIdType const nbOfTuples=fam->getNumberOfTuples();
mcIdType *start=const_cast<DataArrayIdType *>(fam)->getPointer();
for(mcIdType *w=start;w!=start+nbOfTuples;w++)
*w=ren[*w];
{
if(allIds->presenceOfValue(*it))
{
- std::string famName=getFamilyNameGivenId(*it);
+ std::string const famName=getFamilyNameGivenId(*it);
families[famName]=ren[*it];
famsFetched.insert(famName);
}
std::map<mcIdType,mcIdType> ren;
for(const mcIdType *it=tmp->begin();it!=tmp->end();it++,refId--)
ren[*it]=refId;
- mcIdType nbOfTuples=fam->getNumberOfTuples();
+ mcIdType const nbOfTuples=fam->getNumberOfTuples();
mcIdType *start=const_cast<DataArrayIdType *>(fam)->getPointer();
for(mcIdType *w=start;w!=start+nbOfTuples;w++)
*w=ren[*w];
{
if(allIds->presenceOfValue(*it))
{
- std::string famName=getFamilyNameGivenId(*it);
+ std::string const famName=getFamilyNameGivenId(*it);
families[famName]=ren[*it];
famsFetched.insert(famName);
}
}
}
}
- for(std::set<int>::const_iterator it2=levsS.begin();it2!=levsS.end();it2++)
+ for(int const it2 : levsS)
{
- DataArrayIdType *fam=const_cast<DataArrayIdType*>(getFamilyFieldAtLevel(*it2));
+ auto *fam=const_cast<DataArrayIdType*>(getFamilyFieldAtLevel(it2));
if(fam)
{
MCAuto<DataArrayIdType> tmp=fam->getDifferentValues();
for(const mcIdType *it3=tmp->begin();it3!=tmp->end();it3++)
if(allIds->presenceOfValue(*it3))
{
- std::string famName=getFamilyNameGivenId(*it3);
+ std::string const famName=getFamilyNameGivenId(*it3);
families[famName]=0;
famsFetched.insert(famName);
}
}
//
std::vector<std::string> allFams=getFamiliesNames();
- std::set<std::string> allFamsS(allFams.begin(),allFams.end());
+ std::set<std::string> const allFamsS(allFams.begin(),allFams.end());
std::set<std::string> unFetchedIds;
std::set_difference(allFamsS.begin(),allFamsS.end(),famsFetched.begin(),famsFetched.end(),std::inserter(unFetchedIds,unFetchedIds.end()));
- for(std::set<std::string>::const_iterator it4=unFetchedIds.begin();it4!=unFetchedIds.end();it4++)
- families[*it4]=_families[*it4];
+ for(const auto & unFetchedId : unFetchedIds)
+ families[unFetchedId]=_families[unFetchedId];
_families=families;
}
std::map<mcIdType,mcIdType> ren;
for(const mcIdType *it=tmp->begin();it!=tmp->end();it++,refId++)
ren[*it]=refId;
- mcIdType nbOfTuples=fam->getNumberOfTuples();
+ mcIdType const nbOfTuples=fam->getNumberOfTuples();
mcIdType *start=const_cast<DataArrayIdType *>(fam)->getPointer();
for(mcIdType *w=start;w!=start+nbOfTuples;w++)
*w=ren[*w];
{
if(allIds->presenceOfValue(*it))
{
- std::string famName=getFamilyNameGivenId(*it);
+ std::string const famName=getFamilyNameGivenId(*it);
families[famName]=ren[*it];
famsFetched.insert(famName);
}
}
}
refId=-1;
- for(std::set<int>::const_reverse_iterator it2=levsS.rbegin();it2!=levsS.rend();it2++)
+ for(auto it2=levsS.rbegin();it2!=levsS.rend();it2++)
{
const DataArrayIdType *fam=getFamilyFieldAtLevel(*it2);
if(fam)
std::map<mcIdType,mcIdType> ren;
for(const mcIdType *it=tmp->begin();it!=tmp->end();it++,refId--)
ren[*it]=refId;
- mcIdType nbOfTuples=fam->getNumberOfTuples();
+ mcIdType const nbOfTuples=fam->getNumberOfTuples();
mcIdType *start=const_cast<DataArrayIdType *>(fam)->getPointer();
for(mcIdType *w=start;w!=start+nbOfTuples;w++)
*w=ren[*w];
{
if(allIds->presenceOfValue(*it))
{
- std::string famName=getFamilyNameGivenId(*it);
+ std::string const famName=getFamilyNameGivenId(*it);
families[famName]=ren[*it];
famsFetched.insert(famName);
}
}
//
std::vector<std::string> allFams=getFamiliesNames();
- std::set<std::string> allFamsS(allFams.begin(),allFams.end());
+ std::set<std::string> const allFamsS(allFams.begin(),allFams.end());
std::set<std::string> unFetchedIds;
std::set_difference(allFamsS.begin(),allFamsS.end(),famsFetched.begin(),famsFetched.end(),std::inserter(unFetchedIds,unFetchedIds.end()));
- for(std::set<std::string>::const_iterator it4=unFetchedIds.begin();it4!=unFetchedIds.end();it4++)
- families[*it4]=_families[*it4];
+ for(const auto & unFetchedId : unFetchedIds)
+ families[unFetchedId]=_families[unFetchedId];
_families=families;
}
*/
std::string MEDFileMesh::getFamilyNameGivenId(mcIdType id) const
{
- for(std::map<std::string,mcIdType>::const_iterator it=_families.begin();it!=_families.end();it++)
- if((*it).second==id)
- return (*it).first;
+ for(const auto & _familie : _families)
+ if(_familie.second==id)
+ return _familie.first;
std::ostringstream oss; oss << "MEDFileUMesh::getFamilyNameGivenId : no such family id : " << id;
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
*/
DataArrayIdType *MEDFileMesh::getGroupsArr(int meshDimRelToMaxExt, const std::vector<std::string>& grps, bool renum) const
{
- std::vector<std::string> fams2=getFamiliesOnGroups(grps);
+ std::vector<std::string> const fams2=getFamiliesOnGroups(grps);
return getFamiliesArr(meshDimRelToMaxExt,fams2,renum);
}
std::vector<std::string> grpsName2(grps.size());
int i=0;
- for(std::vector<const DataArrayIdType *>::const_iterator it=grps.begin();it!=grps.end();it++,i++)
+ for(auto it=grps.begin();it!=grps.end();it++,i++)
{
grpsName.insert((*it)->getName());
grpsName2[i]=(*it)->getName();
throw INTERP_KERNEL::Exception("MEDFileUMesh::setGroupsAtLevel : groups name must be different each other !");
if(grpsName.find(std::string(""))!=grpsName.end())
throw INTERP_KERNEL::Exception("MEDFileUMesh::setGroupsAtLevel : groups name must be different empty string !");
- mcIdType sz=getSizeAtLevel(meshDimRelToMaxExt);
+ mcIdType const sz=getSizeAtLevel(meshDimRelToMaxExt);
MCAuto<DataArrayIdType> fam;
std::vector< std::vector<mcIdType> > fidsOfGroups;
if(!renum)
grps2[ii]=MEDFileUMeshSplitL1::Renumber(getRevNumberFieldAtLevel(meshDimRelToMaxExt),grps[ii]);
grps2[ii]->setName(grps[ii]->getName());
}
- std::vector<const DataArrayIdType *> grps3(grps2.begin(),grps2.end());
+ std::vector<const DataArrayIdType *> const grps3(grps2.begin(),grps2.end());
fam=DataArrayIdType::MakePartition(grps3,sz,fidsOfGroups);
}
mcIdType offset=1;
if(!_families.empty())
offset=getMaxAbsFamilyId()+1;
TranslateFamilyIds(meshDimRelToMaxExt==1?offset:-offset,fam,fidsOfGroups);
- MCAuto<DataArrayIdType> ids=fam->getDifferentValues();
+ MCAuto<DataArrayIdType> const ids=fam->getDifferentValues();
appendFamilyEntries(ids,fidsOfGroups,grpsName2);
setFamilyFieldArr(meshDimRelToMaxExt,fam);
}
void MEDFileMesh::appendFamilyEntries(const DataArrayIdType *famIds, const std::vector< std::vector<mcIdType> >& fidsOfGrps, const std::vector<std::string>& grpNames)
{
std::map<mcIdType,std::string> famInv;
- for(const mcIdType *it=famIds->begin();it!=famIds->end();it++)
+ for(long const famId : *famIds)
{
std::ostringstream oss;
- oss << "Family_" << (*it);
- _families[oss.str()]=(*it);
- famInv[*it]=oss.str();
+ oss << "Family_" << famId;
+ _families[oss.str()]=famId;
+ famInv[famId]=oss.str();
}
int i=0;
- for(std::vector< std::vector<mcIdType> >::const_iterator it1=fidsOfGrps.begin();it1!=fidsOfGrps.end();it1++,i++)
+ for(auto it1=fidsOfGrps.begin();it1!=fidsOfGrps.end();it1++,i++)
{
- for(std::vector<mcIdType>::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
+ for(long const it2 : *it1)
{
- _groups[grpNames[i]].push_back(famInv[*it2]);
+ _groups[grpNames[i]].push_back(famInv[it2]);
}
}
}
std::vector<INTERP_KERNEL::NormalizedCellType> MEDFileMesh::getAllGeoTypes() const
{
- std::vector<int> levs(getNonEmptyLevels());
+ std::vector<int> const levs(getNonEmptyLevels());
std::vector<INTERP_KERNEL::NormalizedCellType> ret;
- for(std::vector<int>::const_iterator it=levs.begin();it!=levs.end();it++)
+ for(int const lev : levs)
{
- std::vector<INTERP_KERNEL::NormalizedCellType> elts(getGeoTypesAtLevel(*it));
+ std::vector<INTERP_KERNEL::NormalizedCellType> elts(getGeoTypesAtLevel(lev));
ret.insert(ret.end(),elts.begin(),elts.end());
}
return ret;
void MEDFileMesh::TranslateFamilyIds(mcIdType offset, DataArrayIdType *famArr, std::vector< std::vector<mcIdType> >& famIdsPerGrp)
{
famArr->applyLin(offset>0?1:-1,offset,0);
- for(std::vector< std::vector<mcIdType> >::iterator it1=famIdsPerGrp.begin();it1!=famIdsPerGrp.end();it1++)
+ for(auto & it1 : famIdsPerGrp)
{
if(offset<0)
- std::transform((*it1).begin(),(*it1).end(),(*it1).begin(),std::negate<mcIdType>());
- std::transform((*it1).begin(),(*it1).end(),(*it1).begin(),std::bind(std::plus<mcIdType>(),std::placeholders::_1,offset));
+ std::transform(it1.begin(),it1.end(),it1.begin(),std::negate<mcIdType>());
+ std::transform(it1.begin(),it1.end(),it1.begin(),std::bind(std::plus<mcIdType>(),std::placeholders::_1,offset));
}
}
if(std::find(namesToAvoid.begin(),namesToAvoid.end(),nameTry)==namesToAvoid.end())
return nameTry;
//attempt #1
- std::size_t len=nameTry.length();
+ std::size_t const len=nameTry.length();
for(std::size_t ii=1;ii<len;ii++)
{
std::string tmp=nameTry.substr(ii,len-ii);
}
//attempt #3
std::string tmp2;
- for(std::vector<std::string>::const_iterator it2=namesToAvoid.begin();it2!=namesToAvoid.end();it2++)
- tmp2+=(*it2);
+ for(const auto & it2 : namesToAvoid)
+ tmp2+=it2;
if(std::find(namesToAvoid.begin(),namesToAvoid.end(),tmp2)==namesToAvoid.end())
return tmp2;
throw INTERP_KERNEL::Exception("MEDFileMesh::CreateNameNotIn : impossible to find a not already used name !");
mcIdType MEDFileMesh::PutInThirdComponentOfCodeOffset(std::vector<mcIdType>& code, mcIdType strt)
{
- std::size_t nbOfChunks=code.size()/3;
+ std::size_t const nbOfChunks=code.size()/3;
if(code.size()%3!=0)
throw INTERP_KERNEL::Exception("MEDFileMesh::PutInThirdComponentOfCodeOffset : code has invalid size : should be of size 3*x !");
mcIdType ret=strt;
_name=m->getName();
else
{
- std::string name(m->getName());
+ std::string const name(m->getName());
if(!name.empty())
{
if(_name!=name)
_desc_name=m->getDescription();
else
{
- std::string name(m->getDescription());
+ std::string const name(m->getDescription());
if(!name.empty())
{
if(_desc_name!=name)
void MEDFileMesh::getFamilyRepr(std::ostream& oss) const
{
oss << "(**************************)\n(* FAMILIES OF THE MESH : *)\n(**************************)\n";
- for(std::map<std::string,mcIdType>::const_iterator it=_families.begin();it!=_families.end();it++)
+ for(const auto & _familie : _families)
{
- oss << "- Family with name \"" << (*it).first << "\" with number " << (*it).second << std::endl;
+ oss << "- Family with name \"" << _familie.first << "\" with number " << _familie.second << std::endl;
oss << " - Groups lying on this family : ";
- std::vector<std::string> grps=getGroupsOnFamily((*it).first);
+ std::vector<std::string> grps=getGroupsOnFamily(_familie.first);
std::copy(grps.begin(),grps.end(),std::ostream_iterator<std::string>(oss," "));
oss << std::endl << std::endl;
}
*/
MEDFileUMesh *MEDFileUMesh::New(const std::string& fileName, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return New(fid,mName,dt,it,mrs);
}
*/
MEDFileUMesh *MEDFileUMesh::New(const std::string& fileName, MEDFileMeshReadSelector *mrs)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return New(fid,mrs);
}
template<class T>
T *NewForTheFirstMeshInFile(med_idt fid, MEDFileMeshReadSelector *mrs)
{
- std::vector<std::string> ms(MEDLoaderNS::getMeshNamesFid(fid));
+ std::vector<std::string> ms((MEDLoaderNS::getMeshNamesFid(fid)));
if(ms.empty())
{
std::ostringstream oss; oss << MLMeshTraits<T>::ClassName << "::New : no meshes in file \"" << MEDFileWritable::FileNameFromFID(fid) << "\" !";
MCAuto<MEDFileUMesh> MEDFileUMesh::LoadConnectivityOnlyPartOf(const std::string& fileName, const std::string& mName, const std::vector<INTERP_KERNEL::NormalizedCellType>& types, const std::vector<mcIdType>& slicPerTyp, int dt, int it, MEDFileMeshReadSelector *mrs)
{
MEDFileUtilities::CheckFileForRead(fileName);
- MEDFileUtilities::AutoFid fid(MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY));
+ MEDFileUtilities::AutoFid const fid(MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY));
return MEDFileUMesh::LoadConnectivityOnlyPartOf(fid,mName,types,slicPerTyp,dt,it,mrs);
}
MEDFileUMesh *MEDFileUMesh::LoadPartOf(const std::string& fileName, const std::string& mName, const std::vector<INTERP_KERNEL::NormalizedCellType>& types, const std::vector<mcIdType>& slicPerTyp, int dt, int it, MEDFileMeshReadSelector *mrs)
{
MEDFileUtilities::CheckFileForRead(fileName);
- MEDFileUtilities::AutoFid fid(MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY));
+ MEDFileUtilities::AutoFid const fid(MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY));
return MEDFileUMesh::LoadPartOf(fid,mName,types,slicPerTyp,dt,it,mrs);
}
void MEDFileUMesh::LoadPartCoords(const std::string& fileName, const std::string& mName, int dt, int it, const std::vector<std::string>& infosOnComp, mcIdType startNodeId, mcIdType stopNodeId,
MCAuto<DataArrayDouble>& coords, MCAuto<PartDefinition>& partCoords, MCAuto<DataArrayIdType>& famCoords, MCAuto<DataArrayIdType>& numCoords, MCAuto<DataArrayAsciiChar>& nameCoords)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
MEDFileUMeshL2::LoadPartCoords(fid,infosOnComp,mName,dt,it,startNodeId,stopNodeId,coords,partCoords,famCoords,numCoords,nameCoords);
}
ret.push_back((const DataArrayIdType *)_rev_num_coords);
ret.push_back((const DataArrayAsciiChar *)_name_coords);
ret.push_back((const PartDefinition *)_part_coords);
- for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
- ret.push_back((const MEDFileUMeshSplitL1*) *it);
- for(std::vector< MCAuto<MEDFileEltStruct4Mesh> >::const_iterator it=_elt_str.begin();it!=_elt_str.end();it++)
- ret.push_back((const MEDFileEltStruct4Mesh *)*it);
+ for(const auto & _m : _ms)
+ ret.push_back((const MEDFileUMeshSplitL1*) _m);
+ for(const auto & it : _elt_str)
+ ret.push_back((const MEDFileEltStruct4Mesh *)it);
return ret;
}
if(_name_coords.isNotNull())
ret->_name_coords=_name_coords->deepCopy();
std::size_t i=0;
- for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++,i++)
+ for(auto it=_ms.begin();it!=_ms.end();it++,i++)
{
if((const MEDFileUMeshSplitL1 *)(*it))
ret->_ms[i]=(*it)->deepCopy(ret->_coords);
{
if(!MEDFileMesh::isEqual(other,eps,what))
return false;
- const MEDFileUMesh *otherC=dynamic_cast<const MEDFileUMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDFileUMesh *>(other);
if(!otherC)
{
what="Mesh types differ ! This is unstructured and other is NOT !";
otherC->clearNonDiscrAttributes();
const DataArrayDouble *coo1=_coords;
const DataArrayDouble *coo2=otherC->_coords;
- if((coo1==0 && coo2!=0) || (coo1!=0 && coo2==0))
+ if((coo1==nullptr && coo2!=nullptr) || (coo1!=nullptr && coo2==nullptr))
{
what="Mismatch of coordinates ! One is defined and not other !";
return false;
}
if(coo1)
{
- bool ret=coo1->isEqual(*coo2,eps);
+ bool const ret=coo1->isEqual(*coo2,eps);
if(!ret)
{
what="Coords differ !";
}
{
const DataArrayIdType *famc1(_fam_coords),*famc2(otherC->_fam_coords);
- if((famc1==0 && famc2!=0) || (famc1!=0 && famc2==0))
+ if((famc1==nullptr && famc2!=nullptr) || (famc1!=nullptr && famc2==nullptr))
{
what="Mismatch of families arr on nodes ! One is defined and not other !";
return false;
}
if(famc1)
{
- bool ret=famc1->isEqual(*famc2);
+ bool const ret=famc1->isEqual(*famc2);
if(!ret)
{
what="Families arr on node differ !";
}
{
const DataArrayIdType *numc1(_num_coords),*numc2(otherC->_num_coords);
- if((numc1==0 && numc2!=0) || (numc1!=0 && numc2==0))
+ if((numc1==nullptr && numc2!=nullptr) || (numc1!=nullptr && numc2==nullptr))
{
what="Mismatch of numbering arr on nodes ! One is defined and not other !";
return false;
}
if(numc1)
{
- bool ret=numc1->isEqual(*numc2);
+ bool const ret=numc1->isEqual(*numc2);
if(!ret)
{
what="Numbering arr on node differ !";
}
{
const DataArrayIdType *gnumc1(_global_num_coords),*gnumc2(otherC->_global_num_coords);
- if((gnumc1==0 && gnumc2!=0) || (gnumc1!=0 && gnumc2==0))
+ if((gnumc1==nullptr && gnumc2!=nullptr) || (gnumc1!=nullptr && gnumc2==nullptr))
{
what="Mismatch of numbering arr on nodes ! One is defined and not other !";
return false;
}
if(gnumc1)
{
- bool ret=gnumc1->isEqual(*gnumc2);
+ bool const ret=gnumc1->isEqual(*gnumc2);
if(!ret)
{
what="Global numbering arr on node differ !";
}
{
const DataArrayAsciiChar *namec1(_name_coords),*namec2(otherC->_name_coords);
- if((namec1==0 && namec2!=0) || (namec1!=0 && namec2==0))
+ if((namec1==nullptr && namec2!=nullptr) || (namec1!=nullptr && namec2==nullptr))
{
what="Mismatch of naming arr on nodes ! One is defined and not other !";
return false;
}
if(namec1)
{
- bool ret=namec1->isEqual(*namec2);
+ bool const ret=namec1->isEqual(*namec2);
if(!ret)
{
what="Names arr on node differ !";
what="Number of levels differs !";
return false;
}
- std::size_t sz=_ms.size();
+ std::size_t const sz=_ms.size();
for(std::size_t i=0;i<sz;i++)
{
const MEDFileUMeshSplitL1 *s1=_ms[i];
const MEDFileUMeshSplitL1 *s2=otherC->_ms[i];
- if((s1==0 && s2!=0) || (s1!=0 && s2==0))
+ if((s1==nullptr && s2!=nullptr) || (s1!=nullptr && s2==nullptr))
{
what="Mismatch of presence of sub levels !";
return false;
}
if(s1)
{
- bool ret=s1->isEqual(s2,eps,what);
+ bool const ret=s1->isEqual(s2,eps,what);
if(!ret)
return false;
}
}
else
{
- mcIdType nbCoo = _coords->getNumberOfTuples();
+ mcIdType const nbCoo = _coords->getNumberOfTuples();
if (_fam_coords.isNotNull())
_fam_coords->checkNbOfTuplesAndComp(nbCoo,1,"MEDFileUMesh::checkConsistency(): inconsistent internal node family array!");
if (_num_coords.isNotNull())
{
_num_coords->checkNbOfTuplesAndComp(nbCoo,1,"MEDFileUMesh::checkConsistency(): inconsistent internal node numbering array!");
mcIdType pos;
- mcIdType maxValue=_num_coords->getMaxValue(pos);
+ mcIdType const maxValue=_num_coords->getMaxValue(pos);
if (!_rev_num_coords || _rev_num_coords->getNumberOfTuples() != (maxValue+1))
throw INTERP_KERNEL::Exception("MEDFileUMesh::checkConsistency(): inconsistent internal revert node numbering array!");
}
if (_name_coords)
_name_coords->checkNbOfTuplesAndComp(nbCoo,MED_SNAME_SIZE,"MEDFileUMesh::checkConsistency(): inconsistent internal coord name array!");
// Now sub part check:
- for (std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();
- it != _ms.end(); it++)
- (*it)->checkConsistency();
+ for (const auto & _m : _ms)
+ _m->checkConsistency();
}
}
// For all sub-levels, numbering is either always null or with void intersection:
if (_ms.size())
{
- std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();
+ auto it=_ms.begin();
std::vector< const DataArrayIdType * > v;
- bool voidOrNot = ((*it)->_num == 0);
+ bool const voidOrNot = ((*it)->_num == nullptr);
for (it++; it != _ms.end(); it++)
- if( ((*it)->_num == 0) != voidOrNot )
+ if( ((*it)->_num == nullptr) != voidOrNot )
throw INTERP_KERNEL::Exception("MEDFileUMesh::checkConsistency(): inconsistent numbering between mesh sub-levels!");
else if (!voidOrNot)
v.push_back((*it)->_num);
_num_coords.nullify();
_rev_num_coords.nullify();
_global_num_coords.nullify();
- for (std::vector< MCAuto<MEDFileUMeshSplitL1> >::iterator it=_ms.begin(); it != _ms.end(); it++)
+ for (auto & _m : _ms)
{
- (*it)->_num.nullify();
- (*it)->_rev_num.nullify();
- (*it)->_global_num.nullify();
+ _m->_num.nullify();
+ _m->_rev_num.nullify();
+ _m->_global_num.nullify();
}
}
_num_coords.iAmATrollConstCast()->setName("");//This parameter is not discriminant for comparison
if(_name_coords.isNotNull())
_name_coords.iAmATrollConstCast()->setName("");//This parameter is not discriminant for comparison
- for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
+ for(const auto & _m : _ms)
{
- if((*it).isNotNull())
- (*it)->clearNonDiscrAttributes();
+ if(_m.isNotNull())
+ _m->clearNonDiscrAttributes();
}
}
void MEDFileUMesh::setName(const std::string& name)
{
- for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::iterator it=_ms.begin();it!=_ms.end();it++)
- if((*it).isNotNull())
- (*it)->setName(name);
+ for(auto & _m : _ms)
+ if(_m.isNotNull())
+ _m->setName(name);
MEDFileMesh::setName(name);
}
MEDFileUMesh::MEDFileUMesh()
-{
-}
+= default;
MEDFileUMesh::MEDFileUMesh(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
try
void MEDFileMesh::loadEquivalences(med_idt fid)
{
- int nbOfEq(MEDFileEquivalences::PresenceOfEquivalences(fid,_name));
+ int const nbOfEq(MEDFileEquivalences::PresenceOfEquivalences(fid,_name));
if(nbOfEq>0)
_equiv=MEDFileEquivalences::Load(fid,nbOfEq,this);
}
void MEDFileUMesh::dispatchLoadedPart(med_idt fid, const MEDFileUMeshL2& loaderl2, const std::string& mName, MEDFileMeshReadSelector *mrs)
{
- int lev=loaderl2.getNumberOfLevels();
+ int const lev=loaderl2.getNumberOfLevels();
_ms.resize(lev);
for(int i=0;i<lev;i++)
{
if(!loaderl2.emptyLev(i))
_ms[i]=new MEDFileUMeshSplitL1(loaderl2,mName,i);
else
- _ms[i]=0;
+ _ms[i]=nullptr;
}
MEDFileMeshL2::ReadFamiliesAndGrps(fid,mName,_families,_groups,mrs);
//
}
MEDFileUMesh::~MEDFileUMesh()
-{
-}
+= default;
void MEDFileUMesh::writeMeshLL(med_idt fid) const
{
INTERP_KERNEL::AutoPtr<char> desc=MEDLoaderBase::buildEmptyString(MED_COMMENT_SIZE);
MEDLoaderBase::safeStrCpy(_name.c_str(),MED_NAME_SIZE,maa,_too_long_str);
MEDLoaderBase::safeStrCpy(_desc_name.c_str(),MED_COMMENT_SIZE,desc,_too_long_str);
- int spaceDim=(int)(coo?coo->getNumberOfComponents():0);
+ int const spaceDim=(int)(coo?coo->getNumberOfComponents():0);
int mdim(0);
if(!_ms.empty())
mdim=getMeshDimension();
INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(spaceDim*MED_SNAME_SIZE);
for(int i=0;i<spaceDim;i++)
{
- std::string info=coo->getInfoOnComponent(i);
+ std::string const info=coo->getInfoOnComponent(i);
std::string c,u;
MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,_too_long_str);//MED_TAILLE_PNOM-1 to avoid to write '\0' on next compo
MEDFILESAFECALLERWR0(MEDmeshCr,(fid,maa,spaceDim,mdim,MED_UNSTRUCTURED_MESH,desc,"",MED_SORT_DTIT,MEDFileMeshL2::TraduceAxisTypeRev(getAxisType()),comp,unit));
if(_univ_wr_status)
MEDFILESAFECALLERWR0(MEDmeshUniversalNameWr,(fid,maa));
- std::string meshName(MEDLoaderBase::buildStringFromFortran(maa,MED_NAME_SIZE));
+ std::string const meshName(MEDLoaderBase::buildStringFromFortran(maa,MED_NAME_SIZE));
MEDFileUMeshL2::WriteCoords(fid,meshName,_iteration,_order,_time,_coords,_fam_coords,_num_coords,_name_coords,_global_num_coords);
- for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
- if(it->isNotNull())
+ for(const auto & _m : _ms)
+ if(_m.isNotNull())
{
- (*it)->checkCoordsConsistency(coo);
- (*it)->write(fid,meshName,mdim);
+ _m->checkCoordsConsistency(coo);
+ _m->write(fid,meshName,mdim);
}
MEDFileUMeshL2::WriteFamiliesAndGrps(fid,meshName,_families,_groups,_too_long_str);
}
{
std::vector<int> ret;
int lev=0;
- for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++,lev--)
- if((const MEDFileUMeshSplitL1 *)(*it)!=0)
+ for(auto it=_ms.begin();it!=_ms.end();it++,lev--)
+ if((const MEDFileUMeshSplitL1 *)(*it)!=nullptr)
if(!(*it)->empty())
ret.push_back(lev);
return ret;
if(famCoo)
ret.push_back(1);
int lev=0;
- for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++,lev--)
+ for(auto it=_ms.begin();it!=_ms.end();it++,lev--)
{
const MEDFileUMeshSplitL1 *cur(*it);
if(cur)
if(_num_coords.isNotNull())
ret.push_back(1);
int lev=0;
- for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++,lev--)
+ for(auto it=_ms.begin();it!=_ms.end();it++,lev--)
{
const MEDFileUMeshSplitL1 *cur(*it);
if(cur)
if(nameCoo)
ret.push_back(1);
int lev=0;
- for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++,lev--)
+ for(auto it=_ms.begin();it!=_ms.end();it++,lev--)
{
const MEDFileUMeshSplitL1 *cur(*it);
if(cur)
std::vector<mcIdType> MEDFileUMesh::getFamsNonEmptyLevels(const std::vector<std::string>& fams) const
{
std::vector<mcIdType> ret;
- std::vector<int> levs(getNonEmptyLevels());
- std::vector<mcIdType> famIds(getFamiliesIds(fams));
- for(std::vector<int>::const_iterator it=levs.begin();it!=levs.end();it++)
- if(_ms[-(*it)]->presenceOfOneFams(famIds))
- ret.push_back(*it);
+ std::vector<int> const levs(getNonEmptyLevels());
+ std::vector<mcIdType> const famIds(getFamiliesIds(fams));
+ for(int lev : levs)
+ if(_ms[-lev]->presenceOfOneFams(famIds))
+ ret.push_back(lev);
return ret;
}
const DataArrayIdType *famCoords(_fam_coords);
if(!famCoords)
return ret0;
- std::vector<mcIdType> famIds(getFamiliesIds(fams));
+ std::vector<mcIdType> const famIds(getFamiliesIds(fams));
if(famCoords->presenceOfValue(famIds))
{
std::vector<mcIdType> ret(ret0.size()+1);
mcIdType ret=-std::numeric_limits<mcIdType>::max(),tmp=-1;
if((const DataArrayIdType *)_fam_coords)
{
- mcIdType val=_fam_coords->getMaxValue(tmp);
+ mcIdType const val=_fam_coords->getMaxValue(tmp);
ret=std::max(ret,std::abs(val));
}
- for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
+ for(const auto & _m : _ms)
{
- if((const MEDFileUMeshSplitL1 *)(*it))
+ if((const MEDFileUMeshSplitL1 *)_m)
{
- const DataArrayIdType *da=(*it)->getFamilyField();
+ const DataArrayIdType *da=_m->getFamilyField();
if(da)
{
- mcIdType val=da->getMaxValue(tmp);
+ mcIdType const val=da->getMaxValue(tmp);
ret=std::max(ret,std::abs(val));
}
}
mcIdType ret=-std::numeric_limits<mcIdType>::max(),tmp=-1;
if((const DataArrayIdType *)_fam_coords)
{
- mcIdType val=_fam_coords->getMaxValue(tmp);
+ mcIdType const val=_fam_coords->getMaxValue(tmp);
ret=std::max(ret,val);
}
- for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
+ for(const auto & _m : _ms)
{
- if((const MEDFileUMeshSplitL1 *)(*it))
+ if((const MEDFileUMeshSplitL1 *)_m)
{
- const DataArrayIdType *da=(*it)->getFamilyField();
+ const DataArrayIdType *da=_m->getFamilyField();
if(da)
{
- mcIdType val=da->getMaxValue(tmp);
+ mcIdType const val=da->getMaxValue(tmp);
ret=std::max(ret,val);
}
}
mcIdType ret=std::numeric_limits<mcIdType>::max(),tmp=-1;
if((const DataArrayIdType *)_fam_coords)
{
- mcIdType val=_fam_coords->getMinValue(tmp);
+ mcIdType const val=_fam_coords->getMinValue(tmp);
ret=std::min(ret,val);
}
- for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
+ for(const auto & _m : _ms)
{
- if((const MEDFileUMeshSplitL1 *)(*it))
+ if((const MEDFileUMeshSplitL1 *)_m)
{
- const DataArrayIdType *da=(*it)->getFamilyField();
+ const DataArrayIdType *da=_m->getFamilyField();
if(da)
{
- mcIdType val=da->getMinValue(tmp);
+ mcIdType const val=da->getMinValue(tmp);
ret=std::min(ret,val);
}
}
int MEDFileUMesh::getMeshDimension() const
{
int lev=0;
- for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++,lev++)
- if((const MEDFileUMeshSplitL1 *)(*it)!=0)
+ for(auto it=_ms.begin();it!=_ms.end();it++,lev++)
+ if((const MEDFileUMeshSplitL1 *)(*it)!=nullptr)
return (*it)->getMeshDimension()+lev;
throw INTERP_KERNEL::Exception("MEDFileUMesh::getMeshDimension : impossible to find a mesh dimension !");
}
oss << _coords->getNumberOfTuples() << std::endl;
else
oss << MSG1 << std::endl;
- std::size_t nbOfLev=_ms.size();
+ std::size_t const nbOfLev=_ms.size();
oss << "- Number of levels allocated : " << nbOfLev << std::endl;
for(std::size_t i=0;i<nbOfLev;i++)
{
return false;
}
-mcIdType MEDFileUMesh::buildImplicitPartIfAny(INTERP_KERNEL::NormalizedCellType gt) const
+mcIdType MEDFileUMesh::buildImplicitPartIfAny(INTERP_KERNEL::NormalizedCellType /*gt*/) const
{
throw INTERP_KERNEL::Exception("MEDFileUMesh::buildImplicitPartIfAny : unstructured meshes do not have implicit part !");
}
void MEDFileUMesh::whichAreNodesFetched(const MEDFileField1TSStructItem& st, const MEDFileFieldGlobsReal *globs, std::vector<bool>& nodesFetched) const
{
- std::size_t sz(st.getNumberOfItems());
+ std::size_t const sz(st.getNumberOfItems());
for(std::size_t i=0;i<sz;i++)
{
- INTERP_KERNEL::NormalizedCellType curGt(st[i].getGeo());
+ INTERP_KERNEL::NormalizedCellType const curGt(st[i].getGeo());
const MEDCoupling1GTUMesh *m(getDirectUndergroundSingleGeoTypeMesh(curGt));
if(st[i].getPflName().empty())
m->computeNodeIdsAlg(nodesFetched);
if(!coords)
throw INTERP_KERNEL::Exception("MEDFileUMesh::cartesianize : coordinates are null !");
MCAuto<DataArrayDouble> coordsCart(_coords->cartesianize(getAxisType()));
- for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::iterator it=ret->_ms.begin();it!=ret->_ms.end();it++)
- if((const MEDFileUMeshSplitL1 *)(*it))
- *it=(*it)->shallowCpyUsingCoords(coordsCart);
+ for(auto & _m : ret->_ms)
+ if((const MEDFileUMeshSplitL1 *)_m)
+ _m=_m->shallowCpyUsingCoords(coordsCart);
ret->_coords=coordsCart;
ret->setAxisType(AX_CART);
return ret.retn();
bool MEDFileUMesh::presenceOfStructureElements() const
{
- for(std::vector< MCAuto<MEDFileEltStruct4Mesh> >::const_iterator it=_elt_str.begin();it!=_elt_str.end();it++)
- if((*it).isNotNull())
+ for(const auto & it : _elt_str)
+ if(it.isNotNull())
return true;
return false;
}
{
return tmp;
}
- return 0;
+ return nullptr;
}
/*!
{
checkCartesian();
synchronizeTinyInfoOnLeaves();
- std::vector<std::string> fams2=getFamiliesOnGroups(grps);
+ std::vector<std::string> const fams2=getFamiliesOnGroups(grps);
MCAuto<MEDCouplingUMesh> zeRet=getFamilies(meshDimRelToMaxExt,fams2,renum);
if(grps.size()==1 && ((MEDCouplingUMesh *)zeRet))
zeRet->setName(grps[0]);
if(!famIds.empty())
zeRet=l1->getFamilyPart(&famIds[0],&famIds[0]+famIds.size(),renum);
else
- zeRet=l1->getFamilyPart(0,0,renum);
+ zeRet=l1->getFamilyPart(nullptr,nullptr,renum);
if(fams.size()==1 && ((MEDCouplingUMesh *)zeRet))
zeRet->setName(fams[0]);
return zeRet.retn();
if(!famIds.empty())
da=_fam_coords->findIdsEqualList(&famIds[0],&famIds[0]+famIds.size());
else
- da=_fam_coords->findIdsEqualList(0,0);
+ da=_fam_coords->findIdsEqualList(nullptr,nullptr);
if(renum)
return MEDFileUMeshSplitL1::Renumber(_num_coords,da);
else
if(!famIds.empty())
return l1->getFamilyPartArr(&famIds[0],&famIds[0]+famIds.size(),renum);
else
- return l1->getFamilyPartArr(0,0,renum);
+ return l1->getFamilyPartArr(nullptr,nullptr,renum);
}
/*!
if(!renum)
{
MEDCouplingUMesh *umesh=MEDCouplingUMesh::New();
- MCAuto<DataArrayDouble> cc=_coords->deepCopy();
+ MCAuto<DataArrayDouble> const cc=_coords->deepCopy();
umesh->setCoords(cc);
MEDFileUMeshSplitL1::ClearNonDiscrAttributes(umesh);
umesh->setName(getName());
*/
void MEDFileUMesh::declarePartsUpdated() const
{
- for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
+ for(const auto & _m : _ms)
{
- const MEDFileUMeshSplitL1 *elt(*it);
+ const MEDFileUMeshSplitL1 *elt(_m);
if(elt)
elt->declarePartsUpdated();
}
*/
void MEDFileUMesh::forceComputationOfParts() const
{
- for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
+ for(const auto & _m : _ms)
{
- const MEDFileUMeshSplitL1 *elt(*it);
+ const MEDFileUMeshSplitL1 *elt(_m);
if(elt)
elt->forceComputationOfParts();
}
{
checkCartesian();
const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(gt));
- int lev=(int)cm.getDimension()-getMeshDimension();
+ int const lev=(int)cm.getDimension()-getMeshDimension();
const MEDFileUMeshSplitL1 *sp(getMeshAtLevSafe(lev));
return sp->getDirectUndergroundSingleGeoTypeMesh(gt);
}
{
std::vector< std::pair<int,mcIdType> > ret;
std::vector<int> nel(getNonEmptyLevels());
- for(std::vector<int>::reverse_iterator it=nel.rbegin();it!=nel.rend();it++)
+ for(auto it=nel.rbegin();it!=nel.rend();it++)
{
- std::vector<INTERP_KERNEL::NormalizedCellType> gt(getGeoTypesAtLevel(*it));
- for(std::vector<INTERP_KERNEL::NormalizedCellType>::const_iterator it1=gt.begin();it1!=gt.end();it1++)
+ std::vector<INTERP_KERNEL::NormalizedCellType> const gt(getGeoTypesAtLevel(*it));
+ for(auto it1 : gt)
{
- mcIdType nbCells(getNumberOfCellsWithType(*it1));
- ret.push_back(std::pair<int,mcIdType>(*it1,nbCells));
+ mcIdType const nbCells(getNumberOfCellsWithType(it1));
+ ret.push_back(std::pair<int,mcIdType>(it1,nbCells));
}
}
ret.push_back(std::pair<int,mcIdType>(INTERP_KERNEL::NORM_ERROR,getNumberOfNodes()));
DataArrayIdType *MEDFileUMesh::extractFamilyFieldOnGeoType(INTERP_KERNEL::NormalizedCellType gt) const
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(gt);
- int lev=(int)cm.getDimension()-getMeshDimension();
+ int const lev=(int)cm.getDimension()-getMeshDimension();
const MEDFileUMeshSplitL1 *sp(getMeshAtLevSafe(lev));
return sp->extractFamilyFieldOnGeoType(gt);
}
DataArrayIdType *MEDFileUMesh::extractNumberFieldOnGeoType(INTERP_KERNEL::NormalizedCellType gt) const
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(gt);
- int lev=(int)cm.getDimension()-getMeshDimension();
+ int const lev=(int)cm.getDimension()-getMeshDimension();
const MEDFileUMeshSplitL1 *sp(getMeshAtLevSafe(lev));
return sp->extractNumberFieldOnGeoType(gt);
}
int MEDFileUMesh::getRelativeLevOnGeoType(INTERP_KERNEL::NormalizedCellType gt) const
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(gt);
- int ret((int)cm.getDimension()-getMeshDimension());
+ int const ret((int)cm.getDimension()-getMeshDimension());
getMeshAtLevSafe(ret);//To test that returned value corresponds to a valid level.
return ret;
}
throw INTERP_KERNEL::Exception("Dimension request is invalid : asking for node level (1) !");
if(meshDimRelToMaxExt>1)
throw INTERP_KERNEL::Exception("Dimension request is invalid (>1) !");
- int tracucedRk=-meshDimRelToMaxExt;
+ int const tracucedRk=-meshDimRelToMaxExt;
if(tracucedRk>=(int)_ms.size())
throw INTERP_KERNEL::Exception("Invalid mesh dim relative to max given ! Too low !");
- if((const MEDFileUMeshSplitL1 *)_ms[tracucedRk]==0)
+ if((const MEDFileUMeshSplitL1 *)_ms[tracucedRk]==nullptr)
throw INTERP_KERNEL::Exception("On specified lev (or entity) no cells exists !");
return _ms[tracucedRk];
}
throw INTERP_KERNEL::Exception("Dimension request is invalid : asking for node level (1) !");
if(meshDimRelToMaxExt>1)
throw INTERP_KERNEL::Exception("Dimension request is invalid (>1) !");
- int tracucedRk=-meshDimRelToMaxExt;
+ int const tracucedRk=-meshDimRelToMaxExt;
if(tracucedRk>=(int)_ms.size())
throw INTERP_KERNEL::Exception("Invalid mesh dim relative to max given ! Too low !");
- if((const MEDFileUMeshSplitL1 *)_ms[tracucedRk]==0)
+ if((const MEDFileUMeshSplitL1 *)_ms[tracucedRk]==nullptr)
throw INTERP_KERNEL::Exception("On specified lev (or entity) no cells exists !");
return _ms[tracucedRk];
}
if(-meshDimRelToMax>=(int)_ms.size())
throw INTERP_KERNEL::Exception("MEDFileUMesh::checkMeshDimCoherency : The meshdim of mesh is not managed by 'this' !");
int i=0;
- for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++,i++)
+ for(auto it=_ms.begin();it!=_ms.end();it++,i++)
{
- if(((const MEDFileUMeshSplitL1*) (*it))!=0)
+ if(((const MEDFileUMeshSplitL1*) (*it))!=nullptr)
{
- int ref=(*it)->getMeshDimension();
+ int const ref=(*it)->getMeshDimension();
if(ref+i!=meshDim-meshDimRelToMax)
throw INTERP_KERNEL::Exception("MEDFileUMesh::checkMeshDimCoherency : no coherency between levels !");
}
if(coords==(DataArrayDouble *)_coords)
return ;
coords->checkAllocated();
- mcIdType nbOfTuples(coords->getNumberOfTuples());
+ mcIdType const nbOfTuples(coords->getNumberOfTuples());
_coords.takeRef(coords);
_fam_coords=DataArrayIdType::New();
_fam_coords->alloc(nbOfTuples,1);
_fam_coords->fillWithZero();
_num_coords.nullify(); _rev_num_coords.nullify(); _name_coords.nullify(); _global_num_coords.nullify();
- for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::iterator it=_ms.begin();it!=_ms.end();it++)
- if((MEDFileUMeshSplitL1 *)(*it))
- (*it)->setCoords(coords);
+ for(auto & _m : _ms)
+ if((MEDFileUMeshSplitL1 *)_m)
+ _m->setCoords(coords);
}
/*!
if(coords==(DataArrayDouble *)_coords)
return ;
coords->checkAllocated();
- mcIdType nbOfTuples(coords->getNumberOfTuples());
+ mcIdType const nbOfTuples(coords->getNumberOfTuples());
if(_coords.isNull())
{
_coords=coords;
}
else
{
- mcIdType oldNbTuples(_coords->getNumberOfTuples());
+ mcIdType const oldNbTuples(_coords->getNumberOfTuples());
if(oldNbTuples!=nbOfTuples)
throw INTERP_KERNEL::Exception("MEDFileUMesh::setCoordsForced : number of tuples is not the same -> invoke setCoords instead !");
_coords=coords;
coords->incrRef();
}
- for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::iterator it=_ms.begin();it!=_ms.end();it++)
- if((MEDFileUMeshSplitL1 *)(*it))
- (*it)->setCoords(coords);
+ for(auto & _m : _ms)
+ if((MEDFileUMeshSplitL1 *)_m)
+ _m->setCoords(coords);
}
/*!
*/
void MEDFileUMesh::optimizeFamilies()
{
- std::vector<int> levs=getNonEmptyLevelsExt();
+ std::vector<int> const levs=getNonEmptyLevelsExt();
std::set<mcIdType> allFamsIds;
- for(std::vector<int>::const_iterator it=levs.begin();it!=levs.end();it++)
+ for(int const lev : levs)
{
- const DataArrayIdType *ffield=getFamilyFieldAtLevel(*it);
+ const DataArrayIdType *ffield=getFamilyFieldAtLevel(lev);
MCAuto<DataArrayIdType> ids=ffield->getDifferentValues();
std::set<mcIdType> res;
std::set_union(ids->begin(),ids->end(),allFamsIds.begin(),allFamsIds.end(),std::inserter(res,res.begin()));
if(allFamsIds.find((*it).second)!=allFamsIds.end())
famNamesToKill.insert((*it).first);
}
- for(std::set<std::string>::const_iterator it=famNamesToKill.begin();it!=famNamesToKill.end();it++)
- _families.erase(*it);
- std::vector<std::string> grpNamesToKill;
- for(std::map<std::string, std::vector<std::string> >::iterator it=_groups.begin();it!=_groups.end();it++)
+ for(const auto & it : famNamesToKill)
+ _families.erase(it);
+ std::vector<std::string> const grpNamesToKill;
+ for(auto & _group : _groups)
{
std::vector<std::string> tmp;
- for(std::vector<std::string>::const_iterator it2=(*it).second.begin();it2!=(*it).second.end();it2++)
+ for(const auto & it2 : _group.second)
{
- if(famNamesToKill.find(*it2)==famNamesToKill.end())
- tmp.push_back(*it2);
+ if(famNamesToKill.find(it2)==famNamesToKill.end())
+ tmp.push_back(it2);
}
if(!tmp.empty())
- (*it).second=tmp;
+ _group.second=tmp;
else
- tmp.push_back((*it).first);
+ tmp.push_back(_group.first);
}
- for(std::vector<std::string>::const_iterator it=grpNamesToKill.begin();it!=grpNamesToKill.end();it++)
- _groups.erase(*it);
+ for(const auto & it : grpNamesToKill)
+ _groups.erase(it);
}
/**
throw INTERP_KERNEL::Exception("MEDFileUMesh::buildInnerBoundaryAlongM1Group : This method works only for mesh defined on level 0 and -1 !");
MUMesh m0=getMeshAtLevel(0);
MUMesh m1=getMeshAtLevel(-1);
- mcIdType nbNodes=m0->getNumberOfNodes();
+ mcIdType const nbNodes=m0->getNumberOfNodes();
MUMesh m11=getGroup(-1,grpNameM1);
- DataArrayIdType *tmp00=0, *tmp11=0,*tmp22=0;
+ DataArrayIdType *tmp00=nullptr, *tmp11=nullptr,*tmp22=nullptr;
// !!! The core of the duplication logic is in these 2 methods:
// !!!
// node renumbering of cells in m1 impacted by duplication of node but not in group 'grpNameM1' on level -1
DAInt descTmp0=DataArrayIdType::New(),descITmp0=DataArrayIdType::New(),revDescTmp0=DataArrayIdType::New(),revDescITmp0=DataArrayIdType::New();
MUMesh tmp0Desc=tmp0->buildDescendingConnectivity(descTmp0,descITmp0,revDescTmp0,revDescITmp0);
- descTmp0=0; descITmp0=0; revDescTmp0=0; revDescITmp0=0;
+ descTmp0=nullptr; descITmp0=nullptr; revDescTmp0=nullptr; revDescITmp0=nullptr;
DAInt cellsInM1ToRenumW2=tmp0Desc->getCellIdsLyingOnNodes(nodeIdsToDuplicate->begin(),nodeIdsToDuplicate->end(),false);
MUMesh cellsInM1ToRenumW3=static_cast<MEDCouplingUMesh *>(tmp0Desc->buildPartOfMySelf(cellsInM1ToRenumW2->begin(),cellsInM1ToRenumW2->end(),true));
- DataArrayIdType *cellsInM1ToRenumW4Tmp=0;
+ DataArrayIdType *cellsInM1ToRenumW4Tmp=nullptr;
m1->areCellsIncludedIn(cellsInM1ToRenumW3,2,cellsInM1ToRenumW4Tmp);
DAInt cellsInM1ToRenumW4(cellsInM1ToRenumW4Tmp);
DAInt cellsInM1ToRenumW5=cellsInM1ToRenumW4->findIdsInRange(0,m1->getNumberOfCells());
else
idd=getMinFamilyId()-1;
mcIdType globStart=0,start=0,end,globEnd;
- mcIdType nbOfChunks=szOfCellGrpOfSameType->getNumberOfTuples();
+ mcIdType const nbOfChunks=szOfCellGrpOfSameType->getNumberOfTuples();
for(mcIdType i=0;i<nbOfChunks;i++)
{
globEnd=globStart+szOfCellGrpOfSameType->getIJ(i,0);
fam=_fam_coords;
if(fam)
{
- mcIdType newNbOfNodes=getCoords()->getNumberOfTuples();
+ mcIdType const newNbOfNodes=getCoords()->getNumberOfTuples();
newFam=DataArrayIdType::New(); newFam->alloc(newNbOfNodes,1);
newFam->setPartOfValues1(fam,0,nbNodes,1,0,1,1,true);
newFam->setPartOfValuesSimple1(0,nbNodes,newNbOfNodes,1,0,1,1);
_num_coords.nullify(); _rev_num_coords.nullify(); _global_num_coords.nullify();
- for (std::vector< MCAuto<MEDFileUMeshSplitL1> >::iterator it=_ms.begin();
- it != _ms.end(); it++)
+ for (auto & _m : _ms)
{
- (*it)->_num = 0;
- (*it)->_rev_num = 0;
+ _m->_num = nullptr;
+ _m->_rev_num = nullptr;
}
nodesDuplicated=nodeIdsToDuplicate.retn();
cellsModified=cellsToModifyConn0.retn();
*/
bool MEDFileUMesh::unPolyze(std::vector<mcIdType>& oldCode, std::vector<mcIdType>& newCode, DataArrayIdType *& o2nRenumCell)
{
- o2nRenumCell=0; oldCode.clear(); newCode.clear();
+ o2nRenumCell=nullptr; oldCode.clear(); newCode.clear();
std::vector<int> levs=getNonEmptyLevels();
bool ret=false;
std::vector< const DataArrayIdType* > renumCellsSplited;//same than memorySaverIfThrow
std::vector< MCAuto<DataArrayIdType> > memorySaverIfThrow;//same than renumCellsSplited only in case of throw
mcIdType start=0;
mcIdType end=0;
- for(std::vector<int>::reverse_iterator it=levs.rbegin();it!=levs.rend();it++)
+ for(auto it=levs.rbegin();it!=levs.rend();it++)
{
MCAuto<MEDCouplingUMesh> m=getMeshAtLevel(*it);
std::vector<mcIdType> code1=m->getDistributionOfTypes();
end=PutInThirdComponentOfCodeOffset(code1,start);
oldCode.insert(oldCode.end(),code1.begin(),code1.end());
- bool hasChanged=m->unPolyze();
- DataArrayIdType *fake=0;
+ bool const hasChanged=m->unPolyze();
+ DataArrayIdType *fake=nullptr;
MCAuto<DataArrayIdType> o2nCellsPart=m->getLevArrPerCellTypes(MEDCouplingUMesh::MEDMEM_ORDER,
MEDCouplingUMesh::MEDMEM_ORDER+MEDCouplingUMesh::N_MEDMEM_ORDER,fake);
fake->decrRef();
/*! \cond HIDDEN_ITEMS */
struct MEDLoaderAccVisit1
{
- MEDLoaderAccVisit1():_new_nb_of_nodes(0) { }
+ MEDLoaderAccVisit1() = default;
mcIdType operator()(bool val) { return val?_new_nb_of_nodes++:-1; }
- mcIdType _new_nb_of_nodes;
+ mcIdType _new_nb_of_nodes{0};
};
/*! \endcond */
const DataArrayDouble *coo(getCoords());
if(!coo)
throw INTERP_KERNEL::Exception("MEDFileUMesh::zipCoords : no coordinates set in this !");
- mcIdType nbOfNodes(coo->getNumberOfTuples());
+ mcIdType const nbOfNodes(coo->getNumberOfTuples());
std::vector<bool> nodeIdsInUse(nbOfNodes,false);
- std::vector<int> neLevs(getNonEmptyLevels());
- for(std::vector<int>::const_iterator lev=neLevs.begin();lev!=neLevs.end();lev++)
+ std::vector<int> const neLevs(getNonEmptyLevels());
+ for(int const neLev : neLevs)
{
- const MEDFileUMeshSplitL1 *zeLev(getMeshAtLevSafe(*lev));
+ const MEDFileUMeshSplitL1 *zeLev(getMeshAtLevSafe(neLev));
if(zeLev->isMeshStoredSplitByType())
{
- std::vector<MEDCoupling1GTUMesh *> ms(zeLev->getDirectUndergroundSingleGeoTypeMeshes());
- for(std::vector<MEDCoupling1GTUMesh *>::const_iterator it=ms.begin();it!=ms.end();it++)
- if(*it)
- (*it)->computeNodeIdsAlg(nodeIdsInUse);
+ std::vector<MEDCoupling1GTUMesh *> const ms(zeLev->getDirectUndergroundSingleGeoTypeMeshes());
+ for(auto m : ms)
+ if(m)
+ m->computeNodeIdsAlg(nodeIdsInUse);
}
else
{
mesh->computeNodeIdsAlg(nodeIdsInUse);
}
}
- mcIdType nbrOfNodesInUse((mcIdType)std::count(nodeIdsInUse.begin(),nodeIdsInUse.end(),true));
+ auto nbrOfNodesInUse((mcIdType)std::count(nodeIdsInUse.begin(),nodeIdsInUse.end(),true));
if(nbrOfNodesInUse==nbOfNodes)
- return 0;//no need to update _part_coords
+ return nullptr;//no need to update _part_coords
MCAuto<DataArrayIdType> ret(DataArrayIdType::New()); ret->alloc(nbOfNodes,1);
std::transform(nodeIdsInUse.begin(),nodeIdsInUse.end(),ret->getPointer(),MEDLoaderAccVisit1());
MCAuto<DataArrayIdType> ret2(ret->invertArrayO2N2N2OBis(nbrOfNodesInUse));
- MCAuto<DataArrayDouble> newCoords(coo->selectByTupleIdSafe(ret2->begin(),ret2->end()));
+ MCAuto<DataArrayDouble> const newCoords(coo->selectByTupleIdSafe(ret2->begin(),ret2->end()));
MCAuto<DataArrayIdType> newFamCoords;
MCAuto<DataArrayAsciiChar> newNameCoords;
if((const DataArrayIdType *)_fam_coords)
if(_name_coords.isNotNull())
newNameCoords=static_cast<DataArrayAsciiChar *>(_name_coords->selectByTupleIdSafe(ret2->begin(),ret2->end()));
_coords=newCoords; _fam_coords=newFamCoords; _num_coords=newNumCoords; _global_num_coords=newGlobalNumCoords; _name_coords=newNameCoords; _rev_num_coords.nullify();
- for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::iterator it=_ms.begin();it!=_ms.end();it++)
+ for(auto & _m : _ms)
{
- if((MEDFileUMeshSplitL1*)*it)
+ if((MEDFileUMeshSplitL1*)_m)
{
- (*it)->renumberNodesInConn(ret->begin());
- (*it)->setCoords(_coords);
+ _m->renumberNodesInConn(ret->begin());
+ _m->setCoords(_coords);
}
}
// updates _part_coords
*/
DataArrayIdType *MEDFileUMesh::computeFetchedNodeIds() const
{
- std::vector<int> neLevs(this->getNonEmptyLevels());
+ std::vector<int> const neLevs(this->getNonEmptyLevels());
std::vector<bool> nodesHighlighted(this->getNumberOfNodes(),false);
for(auto lev : neLevs)
{
{
std::vector<int> levs(getNonEmptyLevels());
std::vector<bool> fetchedNodes(getNumberOfNodes(),false);
- for(std::map<int, MCAuto<DataArrayIdType> >::const_iterator it=extractDef.begin();it!=extractDef.end();it++)
+ for(const auto & it : extractDef)
{
- if((*it).first>1)
+ if(it.first>1)
throw INTERP_KERNEL::Exception("MEDFileUMesh::deduceNodeSubPartFromCellSubPart : invalid key ! Must be <=1 !");
- if((*it).second.isNull())
+ if(it.second.isNull())
throw INTERP_KERNEL::Exception("MEDFileUMesh::deduceNodeSubPartFromCellSubPart : presence of a value with null pointer !");
- if((*it).first==1)
+ if(it.first==1)
continue;
- if(std::find(levs.begin(),levs.end(),(*it).first)==levs.end())
+ if(std::find(levs.begin(),levs.end(),it.first)==levs.end())
{
- std::ostringstream oss; oss << "MEDFileUMesh::deduceNodeSubPartFromCellSubPart : invalid level " << (*it).first << " ! Not present in this !";
+ std::ostringstream oss; oss << "MEDFileUMesh::deduceNodeSubPartFromCellSubPart : invalid level " << it.first << " ! Not present in this !";
throw INTERP_KERNEL::Exception(oss.str());
}
- MCAuto<MEDCouplingUMesh> m(getMeshAtLevel((*it).first));
- MCAuto<MEDCouplingUMesh> mPart(m->buildPartOfMySelf((*it).second->begin(),(*it).second->end(),true));
+ MCAuto<MEDCouplingUMesh> m(getMeshAtLevel(it.first));
+ MCAuto<MEDCouplingUMesh> mPart(m->buildPartOfMySelf(it.second->begin(),it.second->end(),true));
mPart->computeNodeIdsAlg(fetchedNodes);
}
return DataArrayIdType::BuildListOfSwitchedOn(fetchedNodes);
{
MCAuto<MEDFileUMesh> ret(MEDFileUMesh::New()); ret->setName(getName()); ret->copyFamGrpMapsFrom(*this);
std::vector<int> levs(getNonEmptyLevels());
- for(std::map<int, MCAuto<DataArrayIdType> >::const_iterator it=extractDef.begin();it!=extractDef.end();it++)
+ for(const auto & it : extractDef)
{
- if((*it).first>1)
+ if(it.first>1)
throw INTERP_KERNEL::Exception("MEDFileUMesh::extractPart : invalid key ! Must be <=1 !");
- if((*it).second.isNull())
+ if(it.second.isNull())
throw INTERP_KERNEL::Exception("MEDFileUMesh::extractPart : presence of a value with null pointer !");
- if((*it).first==1)
+ if(it.first==1)
continue;
- if(std::find(levs.begin(),levs.end(),(*it).first)==levs.end())
+ if(std::find(levs.begin(),levs.end(),it.first)==levs.end())
{
- std::ostringstream oss; oss << "MEDFileUMesh::extractPart : invalid level " << (*it).first << " ! Not present in this !";
+ std::ostringstream oss; oss << "MEDFileUMesh::extractPart : invalid level " << it.first << " ! Not present in this !";
throw INTERP_KERNEL::Exception(oss.str());
}
- MCAuto<MEDCouplingUMesh> m(getMeshAtLevel((*it).first));
- MCAuto<MEDCouplingUMesh> mPart(m->buildPartOfMySelf((*it).second->begin(),(*it).second->end(),true));
- ret->setMeshAtLevel((*it).first,mPart);
- const DataArrayIdType *fam(getFamilyFieldAtLevel((*it).first)),*num(getNumberFieldAtLevel((*it).first));
+ MCAuto<MEDCouplingUMesh> m(getMeshAtLevel(it.first));
+ MCAuto<MEDCouplingUMesh> mPart(m->buildPartOfMySelf(it.second->begin(),it.second->end(),true));
+ ret->setMeshAtLevel(it.first,mPart);
+ const DataArrayIdType *fam(getFamilyFieldAtLevel(it.first)),*num(getNumberFieldAtLevel(it.first));
if(fam)
{
- MCAuto<DataArrayIdType> famPart(fam->selectByTupleIdSafe((*it).second->begin(),(*it).second->end()));
- ret->setFamilyFieldArr((*it).first,famPart);
+ MCAuto<DataArrayIdType> famPart(fam->selectByTupleIdSafe(it.second->begin(),it.second->end()));
+ ret->setFamilyFieldArr(it.first,famPart);
}
if(num)
{
- MCAuto<DataArrayIdType> numPart(num->selectByTupleIdSafe((*it).second->begin(),(*it).second->end()));
- ret->setFamilyFieldArr((*it).first,numPart);
+ MCAuto<DataArrayIdType> numPart(num->selectByTupleIdSafe(it.second->begin(),it.second->end()));
+ ret->setFamilyFieldArr(it.first,numPart);
}
}
- std::map<int, MCAuto<DataArrayIdType> >::const_iterator it2(extractDef.find(1));
+ auto const it2(extractDef.find(1));
if(it2!=extractDef.end())
{
const DataArrayDouble *coo(ret->getCoords());
MCAuto<DataArrayIdType> numPart(num->selectByTupleIdSafe((*it2).second->begin(),(*it2).second->end()));
ret->setFamilyFieldArr(1,numPart);
}
- for(std::map<int, MCAuto<DataArrayIdType> >::const_iterator it3=extractDef.begin();it3!=extractDef.end();it3++)
+ for(const auto & it3 : extractDef)
{
- if((*it3).first==1)
+ if(it3.first==1)
continue;
- MCAuto<MEDCouplingUMesh> m(ret->getMeshAtLevel((*it3).first));
+ MCAuto<MEDCouplingUMesh> m(ret->getMeshAtLevel(it3.first));
m->renumberNodesInConn(o2nNodes->begin());
- ret->setMeshAtLevel((*it3).first,m);
+ ret->setMeshAtLevel(it3.first,m);
}
}
return ret.retn();
m1D->checkConsistencyLight();
if(m1D->getMeshDimension()!=1)
throw INTERP_KERNEL::Exception("MEDFileUMesh::buildExtrudedMesh : input mesh must have a mesh dimension equal to one !");
- mcIdType nbRep(m1D->getNumberOfCells());
+ mcIdType const nbRep(m1D->getNumberOfCells());
std::vector<int> levs(getNonEmptyLevels());
- std::vector<std::string> grps(getGroupsNames());
+ std::vector<std::string> const grps(getGroupsNames());
std::vector< MCAuto<MEDCouplingUMesh> > zeList;
- DataArrayDouble *coords(0);
- std::size_t nbOfLevsOut(levs.size()+1);
+ DataArrayDouble *coords(nullptr);
+ std::size_t const nbOfLevsOut(levs.size()+1);
std::vector< MCAuto<DataArrayIdType> > o2ns(nbOfLevsOut);
- for(std::vector<int>::const_iterator lev=levs.begin();lev!=levs.end();lev++)
+ for(int const lev : levs)
{
- MCAuto<MEDCouplingUMesh> item(getMeshAtLevel(*lev));
+ MCAuto<MEDCouplingUMesh> item(getMeshAtLevel(lev));
item=item->clone(false);
- item->changeSpaceDimension(3+(*lev),0.);//no problem non const but change DataArrayDouble for coordinates do not alter data
+ item->changeSpaceDimension(3+lev,0.);//no problem non const but change DataArrayDouble for coordinates do not alter data
MCAuto<MEDCouplingUMesh> tmp(static_cast<MEDCouplingUMesh *>(m1D->deepCopy()));
- tmp->changeSpaceDimension(3+(*lev),0.);
+ tmp->changeSpaceDimension(3+lev,0.);
MCAuto<MEDCouplingUMesh> elt(item->buildExtrudedMesh(tmp,policy));
zeList.push_back(elt);
- if(*lev==0)
+ if(lev==0)
coords=elt->getCoords();
}
if(!coords)
throw INTERP_KERNEL::Exception("MEDFileUMesh::buildExtrudedMesh : internal error !");
- for(std::vector< MCAuto<MEDCouplingUMesh> >::iterator it=zeList.begin();it!=zeList.end();it++)
+ for(auto & it : zeList)
{
- (*it)->setName(getName());
- (*it)->setCoords(coords);
+ it->setName(getName());
+ it->setCoords(coords);
}
for(std::size_t ii=0;ii!=zeList.size();ii++)
{
- int lev(levs[ii]);
+ int const lev(levs[ii]);
MCAuto<MEDCouplingUMesh> elt(zeList[ii]);
if(lev<=-1)
{
//
for(std::size_t ii=0;ii!=zeList.size();ii++)
{
- int lev(levs[ii]);
+ int const lev(levs[ii]);
std::vector< MCAuto<DataArrayIdType> > outGrps;
std::vector< const DataArrayIdType * > outGrps2;
if(lev<=-1)
{
- for(std::vector<std::string>::const_iterator grp=grps.begin();grp!=grps.end();grp++)
+ for(const auto & grp : grps)
{
- MCAuto<DataArrayIdType> grpArr(getGroupArr(lev+1,*grp));
+ MCAuto<DataArrayIdType> grpArr(getGroupArr(lev+1,grp));
if(!grpArr->empty())
{
MCAuto<DataArrayIdType> grpArr1(grpArr->deepCopy()),grpArr2(grpArr->deepCopy());
- mcIdType offset0(zeList[ii]->getNumberOfCells());
- mcIdType offset1(offset0+getNumberOfCellsAtLevel(lev+1));
+ mcIdType const offset0(zeList[ii]->getNumberOfCells());
+ mcIdType const offset1(offset0+getNumberOfCellsAtLevel(lev+1));
grpArr1->applyLin(1,offset0); grpArr2->applyLin(1,offset1);
std::ostringstream oss; oss << grpArr2->getName() << "_top";
grpArr2->setName(oss.str());
}
}
//
- for(std::vector<std::string>::const_iterator grp=grps.begin();grp!=grps.end();grp++)
+ for(const auto & grp : grps)
{
- MCAuto<DataArrayIdType> grpArr(getGroupArr(lev,*grp));
+ MCAuto<DataArrayIdType> grpArr(getGroupArr(lev,grp));
if(!grpArr->empty())
{
- mcIdType nbCellsB4Extrusion(getNumberOfCellsAtLevel(lev));
+ mcIdType const nbCellsB4Extrusion(getNumberOfCellsAtLevel(lev));
std::vector< MCAuto<DataArrayIdType> > grpArrs(nbRep);
std::vector< const DataArrayIdType *> grpArrs2(nbRep);
for(int iii=0;iii<nbRep;iii++)
}
MCAuto<DataArrayIdType> grpArrExt(DataArrayIdType::Aggregate(grpArrs2));
grpArrExt->transformWithIndArr(o2ns[ii]->begin(),o2ns[ii]->end());
- std::ostringstream grpName; grpName << *grp << "_extruded";
+ std::ostringstream grpName; grpName << grp << "_extruded";
grpArrExt->setName(grpName.str());
outGrps.push_back(grpArrExt);
outGrps2.push_back(grpArrExt);
}
std::vector< MCAuto<DataArrayIdType> > outGrps;
std::vector< const DataArrayIdType * > outGrps2;
- for(std::vector<std::string>::const_iterator grp=grps.begin();grp!=grps.end();grp++)
+ for(const auto & grp : grps)
{
- MCAuto<DataArrayIdType> grpArr1(getGroupArr(levs.back(),*grp));
+ MCAuto<DataArrayIdType> grpArr1(getGroupArr(levs.back(),grp));
if(grpArr1->empty())
continue;
MCAuto<DataArrayIdType> grpArr2(grpArr1->deepCopy());
- std::ostringstream grpName; grpName << *grp << "_top";
+ std::ostringstream grpName; grpName << grp << "_top";
grpArr2->setName(grpName.str());
grpArr2->applyLin(1,getNumberOfCellsAtLevel(levs.back()));
outGrps.push_back(grpArr1); outGrps.push_back(grpArr2);
{
checkCartesian();
MCAuto<MEDFileUMesh> ret(MEDFileUMesh::New());
- mcIdType initialNbNodes(getNumberOfNodes());
+ mcIdType const initialNbNodes(getNumberOfNodes());
MCAuto<MEDCouplingUMesh> m0Tmp(getMeshAtLevel(0));
MCAuto<MEDCouplingUMesh> m0(dynamic_cast<MEDCouplingUMesh *>(m0Tmp->deepCopy()));
{
- MCAuto<DataArrayIdType> notUsed(m0->convertLinearCellsToQuadratic(conversionType));
+ MCAuto<DataArrayIdType> const notUsed(m0->convertLinearCellsToQuadratic(conversionType));
}
DataArrayDouble *zeCoords(m0->getCoords());
ret->setMeshAtLevel(0,m0);
- std::vector<int> levs(getNonEmptyLevels());
+ std::vector<int> const levs(getNonEmptyLevels());
const DataArrayIdType *famField(getFamilyFieldAtLevel(0));
if(famField)
{
}
ret->copyFamGrpMapsFrom(*this);
MCAuto<DataArrayDouble> partZeCoords(zeCoords->selectByTupleIdSafeSlice(initialNbNodes,zeCoords->getNumberOfTuples(),1));
- for(std::vector<int>::const_iterator lev=levs.begin();lev!=levs.end();lev++)
+ for(int const lev : levs)
{
- if(*lev==0)
+ if(lev==0)
continue;
- MCAuto<MEDCouplingUMesh> m1Tmp(getMeshAtLevel(*lev));
+ MCAuto<MEDCouplingUMesh> m1Tmp(getMeshAtLevel(lev));
MCAuto<MEDCouplingUMesh> m1(dynamic_cast<MEDCouplingUMesh *>(m1Tmp->deepCopy()));
if(m1->getMeshDimension()!=0)
{
{
- MCAuto<DataArrayIdType> notUsed(m1->convertLinearCellsToQuadratic(conversionType));
+ MCAuto<DataArrayIdType> const notUsed(m1->convertLinearCellsToQuadratic(conversionType));
}//kill unused notUsed var
MCAuto<DataArrayDouble> m1Coords(m1->getCoords()->selectByTupleIdSafeSlice(initialNbNodes,m1->getNumberOfNodes(),1));
- DataArrayIdType *b(0);
- bool a(partZeCoords->areIncludedInMe(m1Coords,eps,b));
- MCAuto<DataArrayIdType> bSafe(b);
+ DataArrayIdType *b(nullptr);
+ bool const a(partZeCoords->areIncludedInMe(m1Coords,eps,b));
+ MCAuto<DataArrayIdType> const bSafe(b);
if(!a)
{
- std::ostringstream oss; oss << "MEDFileUMesh::linearCellsToQuadratic : for level " << *lev << " problem to identify nodes generated !";
+ std::ostringstream oss; oss << "MEDFileUMesh::linearCellsToQuadratic : for level " << lev << " problem to identify nodes generated !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
b->applyLin(1,initialNbNodes);
m1->renumberNodesInConn(renum->begin());
}
m1->setCoords(zeCoords);
- ret->setMeshAtLevel(*lev,m1);
- famField=getFamilyFieldAtLevel(*lev);
+ ret->setMeshAtLevel(lev,m1);
+ famField=getFamilyFieldAtLevel(lev);
if(famField)
{
MCAuto<DataArrayIdType> famFieldCpy(famField->deepCopy());
- ret->setFamilyFieldArr(*lev,famFieldCpy);
+ ret->setFamilyFieldArr(lev,famFieldCpy);
}
}
return ret.retn();
m0->zipCoords();
DataArrayDouble *zeCoords(m0->getCoords());
ret->setMeshAtLevel(0,m0);
- std::vector<int> levs(getNonEmptyLevels());
+ std::vector<int> const levs(getNonEmptyLevels());
const DataArrayIdType *famField(getFamilyFieldAtLevel(0));
if(famField)
{
ret->setFamilyFieldArr(1,fam);
}
ret->copyFamGrpMapsFrom(*this);
- for(std::vector<int>::const_iterator lev=levs.begin();lev!=levs.end();lev++)
+ for(int const lev : levs)
{
- if(*lev==0)
+ if(lev==0)
continue;
- MCAuto<MEDCouplingUMesh> m1Tmp(getMeshAtLevel(*lev));
+ MCAuto<MEDCouplingUMesh> m1Tmp(getMeshAtLevel(lev));
MCAuto<MEDCouplingUMesh> m1(dynamic_cast<MEDCouplingUMesh *>(m1Tmp->deepCopy()));
m1->convertQuadraticCellsToLinear();
m1->zipCoords();
- DataArrayIdType *b(0);
- bool a(zeCoords->areIncludedInMe(m1->getCoords(),eps,b));
- MCAuto<DataArrayIdType> bSafe(b);
+ DataArrayIdType *b(nullptr);
+ bool const a(zeCoords->areIncludedInMe(m1->getCoords(),eps,b));
+ MCAuto<DataArrayIdType> const bSafe(b);
if(!a)
{
- std::ostringstream oss; oss << "MEDFileUMesh::quadraticToLinear : for level " << *lev << " problem to identify nodes generated !";
+ std::ostringstream oss; oss << "MEDFileUMesh::quadraticToLinear : for level " << lev << " problem to identify nodes generated !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
m1->renumberNodesInConn(b->begin());
m1->setCoords(zeCoords);
- ret->setMeshAtLevel(*lev,m1);
- famField=getFamilyFieldAtLevel(*lev);
+ ret->setMeshAtLevel(lev,m1);
+ famField=getFamilyFieldAtLevel(lev);
if(famField)
{
MCAuto<DataArrayIdType> famFieldCpy(famField->deepCopy());
- ret->setFamilyFieldArr(*lev,famFieldCpy);
+ ret->setFamilyFieldArr(lev,famFieldCpy);
}
}
return ret.retn();
}
const MEDFileUMesh *ref(meshes[0]);
int spaceDim(ref->getSpaceDimension()),meshDim(ref->getMeshDimension());
- std::vector<int> levs(ref->getNonEmptyLevels());
+ std::vector<int> const levs(ref->getNonEmptyLevels());
std::map<int, std::vector<const DataArrayIdType *> > m_fam,m_renum;
std::map<int, std::vector< MCAuto< MEDCouplingUMesh > > > m_mesh2;
std::map<int, std::vector<const MEDCouplingUMesh *> > m_mesh;
for(const auto& it3 : locMap1)
{
const std::string& famName = it3.first;
- mcIdType famNum = it3.second;
+ mcIdType const famNum = it3.second;
if (famNumMap_rev.count(famNum) || famNumMap.count(famName)) // Family number, or family name is already used!
{
bool needsRenum = true;
fam_conflict = true;
std::ostringstream oss;
oss << "Family_" << --min_fam_num; // New ID
- std::string new_name(oss.str());
+ std::string const new_name(oss.str());
substitute[famName] = new_name;
substituteN[famNum] = min_fam_num;
famNumMap[new_name] = min_fam_num;
for(const auto& level : levs)
{
- MCAuto<MEDCouplingUMesh> locMesh(msh->getMeshAtLevel(level));
+ MCAuto<MEDCouplingUMesh> const locMesh(msh->getMeshAtLevel(level));
m_mesh[level].push_back(locMesh); m_mesh2[level].push_back(locMesh);
m_renum[level].push_back(msh->getNumberFieldAtLevel(level));
MCAuto<MEDFileUMesh> ret(MEDFileUMesh::New());
MCAuto<DataArrayDouble> coo(DataArrayDouble::Aggregate(coos));
ret->setCoords(coo);
- if(std::find(fam_coos.begin(),fam_coos.end(),(const DataArrayIdType *)0)==fam_coos.end())
+ if(std::find(fam_coos.begin(),fam_coos.end(),(const DataArrayIdType *)nullptr)==fam_coos.end())
{
MCAuto<DataArrayIdType> fam_coo(DataArrayIdType::Aggregate(fam_coos));
ret->setFamilyFieldArr(1,fam_coo);
}
- if(std::find(num_coos.begin(),num_coos.end(),(const DataArrayIdType *)0)==num_coos.end())
+ if(std::find(num_coos.begin(),num_coos.end(),(const DataArrayIdType *)nullptr)==num_coos.end())
{
MCAuto<DataArrayIdType> num_coo(DataArrayIdType::Aggregate(num_coos));
ret->setRenumFieldArr(1,num_coo);
MCAuto<MEDCouplingUMesh> m3D(getMeshAtLevel(0)),m2D(getMeshAtLevel(-1));
if(m3D.isNull() || m2D.isNull())
throw INTERP_KERNEL::Exception("MEDFileUMesh::convertToExtrudedMesh : this must be defined both at level 0 and level -1 !");
- mcIdType zeId(std::numeric_limits<med_int>::max()-getFamilyId(GetSpeStr4ExtMesh()));
+ mcIdType const zeId(std::numeric_limits<med_int>::max()-getFamilyId(GetSpeStr4ExtMesh()));
MCAuto<MEDCouplingMappedExtrudedMesh> ret(MEDCouplingMappedExtrudedMesh::New(m3D,m2D,zeId));
return ret.retn();
}
{
clearNonDiscrAttributes();
forceComputationOfParts();
- tinyDouble.clear(); tinyInt.clear(); tinyStr.clear(); bigArraysI.clear(); bigArrayD=0;
+ tinyDouble.clear(); tinyInt.clear(); tinyStr.clear(); bigArraysI.clear(); bigArrayD=nullptr;
std::vector<mcIdType> layer0;
layer0.push_back(getAxisType());//0 i
layer0.push_back(_order); //1 i
}
_fam_coords=bigArraysI.back(); bigArraysI.pop_back();
_num_coords=bigArraysI.back(); bigArraysI.pop_back();
- _part_coords=0;
+ _part_coords=nullptr;
mcIdType isPd(layer0.back()); layer0.pop_back();
if(isPd!=-1)
{
for(mcIdType i=0;i<nbLevs;i++)
{
mcIdType lev(levs[i]);
- mcIdType pos(-lev);
+ mcIdType const pos(-lev);
_ms[pos]=MEDFileUMeshSplitL1::Unserialize(_name,_coords,layer1,bigArraysI);
}
}
const DataArrayDouble *coords(_coords);
if(!coords)
throw INTERP_KERNEL::Exception("MEDFileUMesh::addNodeGroup : no coords set !");
- mcIdType nbOfNodes(coords->getNumberOfTuples());
+ mcIdType const nbOfNodes(coords->getNumberOfTuples());
if(_fam_coords.isNull())
{ _fam_coords=DataArrayIdType::New(); _fam_coords->alloc(nbOfNodes,1); _fam_coords->fillWithZero(); }
//
*/
void MEDFileUMesh::setFamilyNameAttachedOnId(mcIdType id, const std::string& newFamName)
{
- std::string oldName=getFamilyNameGivenId(id);
+ std::string const oldName=getFamilyNameGivenId(id);
_families.erase(oldName);
_families[newFamName]=id;
}
std::vector<int>::const_iterator it=std::find(levSet.begin(),levSet.end(),meshDimRelToMax);
if(it==levSet.end())
throw INTERP_KERNEL::Exception("MEDFileUMesh::removeMeshAtLevel : the requested level is not existing !");
- int pos=(-meshDimRelToMax);
- _ms[pos]=0;
+ int const pos=(-meshDimRelToMax);
+ _ms[pos]=nullptr;
}
/*!
*/
void MEDFileUMesh::setMeshAtLevel(int meshDimRelToMax, MEDCoupling1GTUMesh *m)
{
- MCAuto<MEDFileUMeshSplitL1> elt(new MEDFileUMeshSplitL1(m));
+ MCAuto<MEDFileUMeshSplitL1> const elt(new MEDFileUMeshSplitL1(m));
checkAndGiveEntryInSplitL1(meshDimRelToMax,m)=elt;
}
*/
void MEDFileUMesh::setMeshAtLevel(int meshDimRelToMax, MEDCouplingUMesh *m, bool newOrOld)
{
- MCAuto<MEDFileUMeshSplitL1> elt(new MEDFileUMeshSplitL1(m,newOrOld));
+ MCAuto<MEDFileUMeshSplitL1> const elt(new MEDFileUMeshSplitL1(m,newOrOld));
checkAndGiveEntryInSplitL1(meshDimRelToMax,m)=elt;
}
std::vector<int> levSet=getNonEmptyLevels();
if(std::find(levSet.begin(),levSet.end(),meshDimRelToMax)==levSet.end())
{
- if((DataArrayDouble *)_coords==0)
+ if((DataArrayDouble *)_coords==nullptr)
{
DataArrayDouble *c=m->getCoords();
if(c)
}
if(m->getCoords()!=_coords)
throw INTERP_KERNEL::Exception("MEDFileUMesh::setMeshAtLevel : Invalid Given Mesh ! The coordinates are not the same ! try to use tryToShareSameCoords !");
- int sz=(-meshDimRelToMax)+1;
+ int const sz=(-meshDimRelToMax)+1;
if(sz>=(int)_ms.size())
_ms.resize(sz);
checkMeshDimCoherency(m->getMeshDimension(),meshDimRelToMax);
const MEDCouplingUMesh *mRef=ms[0];
if(!mRef)
throw INTERP_KERNEL::Exception("MEDFileUMesh::setMeshes : null instance in the first element of input meshes !");
- std::string name(mRef->getName());
+ std::string const name(mRef->getName());
const DataArrayDouble *coo(mRef->getCoords());
std::set<int> s;
int zeDim=-1;
{
if(ms.empty())
throw INTERP_KERNEL::Exception("MEDFileUMesh::setGroupsFromScratch : expecting a non empty vector !");
- int sz=(-meshDimRelToMax)+1;
+ int const sz=(-meshDimRelToMax)+1;
if(sz>=(int)_ms.size())
_ms.resize(sz);
checkMeshDimCoherency(ms[0]->getMeshDimension(),meshDimRelToMax);
DataArrayDouble *coo=checkMultiMesh(ms);
- if((DataArrayDouble *)_coords==0)
+ if((DataArrayDouble *)_coords==nullptr)
{
coo->incrRef();
_coords=coo;
{
if(ms.empty())
throw INTERP_KERNEL::Exception("MEDFileUMesh::setGroupsOnSetMesh : expecting a non empty vector !");
- int sz=(-meshDimRelToMax)+1;
+ int const sz=(-meshDimRelToMax)+1;
if(sz>=(int)_ms.size())
_ms.resize(sz);
checkMeshDimCoherency(ms[0]->getMeshDimension(),meshDimRelToMax);
DataArrayDouble *coo=checkMultiMesh(ms);
- if((DataArrayDouble *)_coords==0)
+ if((DataArrayDouble *)_coords==nullptr)
{
coo->incrRef();
_coords=coo;
int i=0;
for(std::vector<const MEDCouplingUMesh *>::const_iterator it=ms.begin();it!=ms.end();it++,i++)
{
- DataArrayIdType *arr=0;
+ DataArrayIdType *arr=nullptr;
bool test=m->areCellsIncludedIn(*it,_zipconn_pol,arr);
corr[i]=arr;
if(!test)
{
if(!famArr)
{
- _fam_coords=0;
+ _fam_coords=nullptr;
return ;
}
DataArrayDouble *coo(_coords);
}
if(meshDimRelToMaxExt>1)
throw INTERP_KERNEL::Exception("MEDFileUMesh::setFamilyFieldArr : Dimension request is invalid (>1) !");
- int traducedRk=-meshDimRelToMaxExt;
+ int const traducedRk=-meshDimRelToMaxExt;
if(traducedRk>=(int)_ms.size())
throw INTERP_KERNEL::Exception("Invalid mesh dim relative to max given ! Too low !");
- if((MEDFileUMeshSplitL1 *)_ms[traducedRk]==0)
+ if((MEDFileUMeshSplitL1 *)_ms[traducedRk]==nullptr)
throw INTERP_KERNEL::Exception("On specified lev (or entity) no cells exists !");
return _ms[traducedRk]->setFamilyArr(famArr);
}
}
if(meshDimRelToMaxExt>1)
throw INTERP_KERNEL::Exception("MEDFileUMesh::setRenumArr : Dimension request is invalid (>1) !");
- int traducedRk=-meshDimRelToMaxExt;
+ int const traducedRk=-meshDimRelToMaxExt;
if(traducedRk>=(int)_ms.size())
throw INTERP_KERNEL::Exception("Invalid mesh dim relative to max given ! Too low !");
- if((MEDFileUMeshSplitL1 *)_ms[traducedRk]==0)
+ if((MEDFileUMeshSplitL1 *)_ms[traducedRk]==nullptr)
throw INTERP_KERNEL::Exception("On specified lev (or entity) no cells exists !");
return _ms[traducedRk]->setRenumArr(renumArr);
}
{
if(!nameArr)
{
- _name_coords=0;
+ _name_coords=nullptr;
return ;
}
DataArrayDouble *coo(_coords);
}
if(meshDimRelToMaxExt>1)
throw INTERP_KERNEL::Exception("MEDFileUMesh::setNameFieldAtLevel : Dimension request is invalid (>1) !");
- int traducedRk=-meshDimRelToMaxExt;
+ int const traducedRk=-meshDimRelToMaxExt;
if(traducedRk>=(int)_ms.size())
throw INTERP_KERNEL::Exception("Invalid mesh dim relative to max given ! Too low !");
- if((MEDFileUMeshSplitL1 *)_ms[traducedRk]==0)
+ if((MEDFileUMeshSplitL1 *)_ms[traducedRk]==nullptr)
throw INTERP_KERNEL::Exception("On specified lev (or entity) no cells exists !");
return _ms[traducedRk]->setNameArr(nameArr);
}
if(_num_coords.isNotNull())
{
mcIdType pos;
- mcIdType maxValue=_num_coords->getMaxValue(pos);
+ mcIdType const maxValue=_num_coords->getMaxValue(pos);
_rev_num_coords=_num_coords->invertArrayN2O2O2N(maxValue+1);
}
}
mcIdType ret=-std::numeric_limits<mcIdType>::max(),tmp=-1;
if((const DataArrayIdType *)_fam_nodes)
{
- mcIdType val=_fam_nodes->getMaxValue(tmp);
+ mcIdType const val=_fam_nodes->getMaxValue(tmp);
ret=std::max(ret,std::abs(val));
}
if((const DataArrayIdType *)_fam_cells)
{
- mcIdType val=_fam_cells->getMaxValue(tmp);
+ mcIdType const val=_fam_cells->getMaxValue(tmp);
ret=std::max(ret,std::abs(val));
}
if((const DataArrayIdType *)_fam_faces)
{
- mcIdType val=_fam_faces->getMaxValue(tmp);
+ mcIdType const val=_fam_faces->getMaxValue(tmp);
ret=std::max(ret,std::abs(val));
}
return ret;
mcIdType ret=-std::numeric_limits<mcIdType>::max(),tmp=-1;
if((const DataArrayIdType *)_fam_nodes)
{
- mcIdType val=_fam_nodes->getMaxValue(tmp);
+ mcIdType const val=_fam_nodes->getMaxValue(tmp);
ret=std::max(ret,val);
}
if((const DataArrayIdType *)_fam_cells)
{
- mcIdType val=_fam_cells->getMaxValue(tmp);
+ mcIdType const val=_fam_cells->getMaxValue(tmp);
ret=std::max(ret,val);
}
if((const DataArrayIdType *)_fam_faces)
{
- mcIdType val=_fam_faces->getMaxValue(tmp);
+ mcIdType const val=_fam_faces->getMaxValue(tmp);
ret=std::max(ret,val);
}
return ret;
mcIdType ret=std::numeric_limits<mcIdType>::max(),tmp=-1;
if((const DataArrayIdType *)_fam_nodes)
{
- mcIdType val=_fam_nodes->getMinValue(tmp);
+ mcIdType const val=_fam_nodes->getMinValue(tmp);
ret=std::min(ret,val);
}
if((const DataArrayIdType *)_fam_cells)
{
- mcIdType val=_fam_cells->getMinValue(tmp);
+ mcIdType const val=_fam_cells->getMinValue(tmp);
ret=std::min(ret,val);
}
if((const DataArrayIdType *)_fam_faces)
{
- mcIdType val=_fam_faces->getMinValue(tmp);
+ mcIdType const val=_fam_faces->getMinValue(tmp);
ret=std::min(ret,val);
}
return ret;
{
if(!MEDFileMesh::isEqual(other,eps,what))
return false;
- const MEDFileStructuredMesh *otherC=dynamic_cast<const MEDFileStructuredMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDFileStructuredMesh *>(other);
if(!otherC)
{
what="Mesh types differ ! This is structured and other is NOT !";
}
const DataArrayIdType *famc1=_fam_nodes;
const DataArrayIdType *famc2=otherC->_fam_nodes;
- if((famc1==0 && famc2!=0) || (famc1!=0 && famc2==0))
+ if((famc1==nullptr && famc2!=nullptr) || (famc1!=nullptr && famc2==nullptr))
{
what="Mismatch of families arr on nodes ! One is defined and not other !";
return false;
}
if(famc1)
{
- bool ret=famc1->isEqual(*famc2);
+ bool const ret=famc1->isEqual(*famc2);
if(!ret)
{
what="Families arr on nodes differ !";
}
famc1=_fam_cells;
famc2=otherC->_fam_cells;
- if((famc1==0 && famc2!=0) || (famc1!=0 && famc2==0))
+ if((famc1==nullptr && famc2!=nullptr) || (famc1!=nullptr && famc2==nullptr))
{
what="Mismatch of families arr on cells ! One is defined and not other !";
return false;
}
if(famc1)
{
- bool ret=famc1->isEqual(*famc2);
+ bool const ret=famc1->isEqual(*famc2);
if(!ret)
{
what="Families arr on cells differ !";
}
famc1=_fam_faces;
famc2=otherC->_fam_faces;
- if((famc1==0 && famc2!=0) || (famc1!=0 && famc2==0))
+ if((famc1==nullptr && famc2!=nullptr) || (famc1!=nullptr && famc2==nullptr))
{
what="Mismatch of families arr on faces ! One is defined and not other !";
return false;
}
if(famc1)
{
- bool ret=famc1->isEqual(*famc2);
+ bool const ret=famc1->isEqual(*famc2);
if(!ret)
{
what="Families arr on faces differ !";
}
famc1=_num_nodes;
famc2=otherC->_num_nodes;
- if((famc1==0 && famc2!=0) || (famc1!=0 && famc2==0))
+ if((famc1==nullptr && famc2!=nullptr) || (famc1!=nullptr && famc2==nullptr))
{
what="Mismatch of numbering arr on nodes ! One is defined and not other !";
return false;
}
if(famc1)
{
- bool ret=famc1->isEqual(*famc2);
+ bool const ret=famc1->isEqual(*famc2);
if(!ret)
{
what="Numbering arr on nodes differ !";
}
famc1=_num_cells;
famc2=otherC->_num_cells;
- if((famc1==0 && famc2!=0) || (famc1!=0 && famc2==0))
+ if((famc1==nullptr && famc2!=nullptr) || (famc1!=nullptr && famc2==nullptr))
{
what="Mismatch of numbering arr on cells ! One is defined and not other !";
return false;
}
if(famc1)
{
- bool ret=famc1->isEqual(*famc2);
+ bool const ret=famc1->isEqual(*famc2);
if(!ret)
{
what="Numbering arr on cells differ !";
}
famc1=_num_faces;
famc2=otherC->_num_faces;
- if((famc1==0 && famc2!=0) || (famc1!=0 && famc2==0))
+ if((famc1==nullptr && famc2!=nullptr) || (famc1!=nullptr && famc2==nullptr))
{
what="Mismatch of numbering arr on faces ! One is defined and not other !";
return false;
}
if(famc1)
{
- bool ret=famc1->isEqual(*famc2);
+ bool const ret=famc1->isEqual(*famc2);
if(!ret)
{
what="Numbering arr on faces differ !";
}
const DataArrayAsciiChar *d1=_names_cells;
const DataArrayAsciiChar *d2=otherC->_names_cells;
- if((d1==0 && d2!=0) || (d1!=0 && d2==0))
+ if((d1==nullptr && d2!=nullptr) || (d1!=nullptr && d2==nullptr))
{
what="Mismatch of naming arr on cells ! One is defined and not other !";
return false;
}
if(d1)
{
- bool ret=d1->isEqual(*d2);
+ bool const ret=d1->isEqual(*d2);
if(!ret)
{
what="Naming arr on cells differ !";
}
d1=_names_faces;
d2=otherC->_names_faces;
- if((d1==0 && d2!=0) || (d1!=0 && d2==0))
+ if((d1==nullptr && d2!=nullptr) || (d1!=nullptr && d2==nullptr))
{
what="Mismatch of naming arr on faces ! One is defined and not other !";
return false;
}
if(d1)
{
- bool ret=d1->isEqual(*d2);
+ bool const ret=d1->isEqual(*d2);
if(!ret)
{
what="Naming arr on faces differ !";
}
d1=_names_nodes;
d2=otherC->_names_nodes;
- if((d1==0 && d2!=0) || (d1!=0 && d2==0))
+ if((d1==nullptr && d2!=nullptr) || (d1!=nullptr && d2==nullptr))
{
what="Mismatch of naming arr on nodes ! One is defined and not other !";
return false;
}
if(d1)
{
- bool ret=d1->isEqual(*d2);
+ bool const ret=d1->isEqual(*d2);
if(!ret)
{
what="Naming arr on nodes differ !";
if(!famIds.empty())
da=_fam_nodes->findIdsEqualList(&famIds[0],&famIds[0]+famIds.size());
else
- da=_fam_nodes->findIdsEqualList(0,0);
+ da=_fam_nodes->findIdsEqualList(nullptr,nullptr);
if(renum)
return MEDFileUMeshSplitL1::Renumber(_num_nodes,da);
else
if(!famIds.empty())
da=_fam_cells->findIdsEqualList(&famIds[0],&famIds[0]+famIds.size());
else
- da=_fam_cells->findIdsEqualList(0,0);
+ da=_fam_cells->findIdsEqualList(nullptr,nullptr);
if(renum)
return MEDFileUMeshSplitL1::Renumber(_num_cells,da);
else
if(!famIds.empty())
da=_fam_faces->findIdsEqualList(&famIds[0],&famIds[0]+famIds.size());
else
- da=_fam_faces->findIdsEqualList(0,0);
+ da=_fam_faces->findIdsEqualList(nullptr,nullptr);
if(renum)
return MEDFileUMeshSplitL1::Renumber(_num_faces,da);
else
{
case 0:
{
- mcIdType nbCells(mesh->getNumberOfCells());
+ mcIdType const nbCells(mesh->getNumberOfCells());
if(famArr)
famArr->checkNbOfTuplesAndComp(nbCells,1,"MEDFileStructuredMesh::setFamilyFieldArr : Problem in size of Family arr ! Mismatch with number of cells of mesh !");
_fam_cells=famArr;
}
case 1:
{
- mcIdType nbNodes(mesh->getNumberOfNodes());
+ mcIdType const nbNodes(mesh->getNumberOfNodes());
if(famArr)
famArr->checkNbOfTuplesAndComp(nbNodes,1,"MEDFileStructuredMesh::setFamilyFieldArr : Problem in size of Family arr ! Mismatch with number of nodes of mesh !");
_fam_nodes=famArr;
}
case -1:
{
- mcIdType nbCells(mesh->getNumberOfCellsOfSubLevelMesh());
+ mcIdType const nbCells(mesh->getNumberOfCellsOfSubLevelMesh());
if(famArr)
famArr->checkNbOfTuplesAndComp(nbCells,1,"MEDFileStructuredMesh::setFamilyFieldArr : Problem in size of Family arr ! Mismatch with number of faces of mesh !");
_fam_faces=famArr;
{
case 0:
{
- mcIdType nbCells=mesh->getNumberOfCells();
+ mcIdType const nbCells=mesh->getNumberOfCells();
renumArr->checkNbOfTuplesAndComp(nbCells,1,"MEDFileStructuredMesh::setRenumFieldArr : Problem in size of Renum arr ! Mismatch with number of cells of mesh !");
_num_cells=renumArr;
break;
}
case 1:
{
- mcIdType nbNodes=mesh->getNumberOfNodes();
+ mcIdType const nbNodes=mesh->getNumberOfNodes();
renumArr->checkNbOfTuplesAndComp(nbNodes,1,"MEDFileStructuredMesh::setRenumFieldArr : Problem in size of Family arr ! Mismatch with number of nodes of mesh !");
_num_nodes=renumArr;
break;
}
case -1:
{
- mcIdType nbCells=mesh->getNumberOfCellsOfSubLevelMesh();
+ mcIdType const nbCells=mesh->getNumberOfCellsOfSubLevelMesh();
renumArr->checkNbOfTuplesAndComp(nbCells,1,"MEDFileStructuredMesh::setRenumFieldArr : Problem in size of Renum arr ! Mismatch with number of faces of mesh !");
_num_faces=renumArr;
break;
{
case 0:
{
- mcIdType nbCells=mesh->getNumberOfCells();
+ mcIdType const nbCells=mesh->getNumberOfCells();
nameArr->checkNbOfTuplesAndComp(nbCells,MED_SNAME_SIZE,"MEDFileStructuredMesh::setNameFieldAtLevel : Problem in size of names arr ! Mismatch with number of cells of mesh !");
_names_cells=nameArr;
break;
}
case 1:
{
- mcIdType nbNodes=mesh->getNumberOfNodes();
+ mcIdType const nbNodes=mesh->getNumberOfNodes();
nameArr->checkNbOfTuplesAndComp(nbNodes,MED_SNAME_SIZE,"MEDFileStructuredMesh::setNameFieldAtLevel : Problem in size of names arr ! Mismatch with number of nodes of mesh !");
_names_nodes=nameArr;
break;
}
case -1:
{
- mcIdType nbCells=mesh->getNumberOfCellsOfSubLevelMesh();
+ mcIdType const nbCells=mesh->getNumberOfCellsOfSubLevelMesh();
nameArr->checkNbOfTuplesAndComp(nbCells,MED_SNAME_SIZE,"MEDFileStructuredMesh::setNameFieldAtLevel : Problem in size of names arr ! Mismatch with number of faces of mesh !");
_names_faces=nameArr;
break;
nameArr->incrRef();
}
-void MEDFileStructuredMesh::setGlobalNumFieldAtLevel(int meshDimRelToMaxExt, DataArrayIdType *globalNumArr)
+void MEDFileStructuredMesh::setGlobalNumFieldAtLevel(int /*meshDimRelToMaxExt*/, DataArrayIdType * /*globalNumArr*/)
{
throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::setGlobalNumFieldAtLevel : not implemented yet !");
}
if((const DataArrayIdType *)_num_cells)
{
mcIdType pos;
- mcIdType maxValue=_num_cells->getMaxValue(pos);
+ mcIdType const maxValue=_num_cells->getMaxValue(pos);
_rev_num_cells=_num_cells->invertArrayN2O2O2N(maxValue+1);
return _rev_num_cells;
}
if((const DataArrayIdType *)_num_nodes)
{
mcIdType pos;
- mcIdType maxValue=_num_nodes->getMaxValue(pos);
+ mcIdType const maxValue=_num_nodes->getMaxValue(pos);
_rev_num_nodes=_num_nodes->invertArrayN2O2O2N(maxValue+1);
return _rev_num_nodes;
}
}
}
-MCAuto<DataArrayIdType> MEDFileStructuredMesh::getGlobalNumFieldAtLevel(int meshDimRelToMaxExt) const
+MCAuto<DataArrayIdType> MEDFileStructuredMesh::getGlobalNumFieldAtLevel(int /*meshDimRelToMaxExt*/) const
{
throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getGlobalNumFieldAtLevel : not implemented yet for structured mesh !");
}
*/
bool MEDFileStructuredMesh::unPolyze(std::vector<mcIdType>& oldCode, std::vector<mcIdType>& newCode, DataArrayIdType *& o2nRenumCell)
{
- oldCode.clear(); newCode.clear(); o2nRenumCell=0;
+ oldCode.clear(); newCode.clear(); o2nRenumCell=nullptr;
return false;
}
void MEDFileStructuredMesh::releaseImplicitPartIfAny() const
{
- _faces_if_necessary=0;
+ _faces_if_necessary=nullptr;
}
/*!
}
case -1:
{
- int mdim(cmesh->getMeshDimension());
+ int const mdim(cmesh->getMeshDimension());
if(mdim<1)
throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getGeoTypesAtLevel : only one level available for structured meshes ! Input 0 is mandatory or 0D mesh !");
std::vector<INTERP_KERNEL::NormalizedCellType> ret(1,MEDCouplingStructuredMesh::GetGeoTypeGivenMeshDimension(mdim-1));
const DataArrayIdType *arr(globs->getProfile(st[0].getPflName()));
const MEDCouplingStructuredMesh *cmesh=getStructuredMesh();//cmesh not null because getNumberOfNodes called before
mcIdType sz(ToIdType(nodesFetched.size()));
- for(const mcIdType *work=arr->begin();work!=arr->end();work++)
+ for(long const work : *arr)
{
std::vector<mcIdType> conn;
- cmesh->getNodeIdsOfCell(*work,conn);
+ cmesh->getNodeIdsOfCell(work,conn);
for(std::vector<mcIdType>::const_iterator it=conn.begin();it!=conn.end();it++)
if(*it>=0 && *it<sz)
nodesFetched[*it]=true;
med_geometry_type MEDFileStructuredMesh::GetGeoTypeFromMeshDim(int meshDim)
{
- INTERP_KERNEL::NormalizedCellType ct(MEDCouplingStructuredMesh::GetGeoTypeGivenMeshDimension(meshDim));
+ INTERP_KERNEL::NormalizedCellType const ct(MEDCouplingStructuredMesh::GetGeoTypeGivenMeshDimension(meshDim));
return typmai3[ct];
}
MCAuto<DataArrayIdType>& famCells, MCAuto<DataArrayIdType>& numCells, MCAuto<DataArrayAsciiChar>& namesCells)
{
med_bool chgt=MED_FALSE,trsf=MED_FALSE;
- med_geometry_type geoTypeReq=MEDFileStructuredMesh::GetGeoTypeFromMeshDim(meshDim);
+ med_geometry_type const geoTypeReq=MEDFileStructuredMesh::GetGeoTypeFromMeshDim(meshDim);
mcIdType nbOfElt(0);
nbOfElt=MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_CELL,geoTypeReq,MED_FAMILY_NUMBER,MED_NODAL,&chgt,&trsf);
if(nbOfElt>0)
{
if(!mrs || mrs->isNodeFamilyFieldReading())
{
- mcIdType nbNodes(getNumberOfNodes());
+ mcIdType const nbNodes(getNumberOfNodes());
if(nbOfElt>nbNodes)
throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::loadStrMeshFromFile : invalid size of family node array regarding number of nodes in this ! File seems to be corrupted !");
MCAuto<DataArrayMedInt> miFamNodes=DataArrayMedInt::New();
_names_nodes->reAlloc(nbOfElt);//not a bug to avoid the memory corruption due to last \0 at the end
}
}
- int meshDim(getStructuredMesh()->getMeshDimension());
+ int const meshDim(getStructuredMesh()->getMeshDimension());
LoadStrMeshDAFromFile(fid,meshDim,dt,it,mName,mrs,_fam_cells,_num_cells,_names_cells);
if(meshDim>=1)
LoadStrMeshDAFromFile(fid,meshDim-1,dt,it,mName,mrs,_fam_faces,_num_faces,_names_faces);
void MEDFileStructuredMesh::writeStructuredLL(med_idt fid, const std::string& maa) const
{
- int meshDim(getStructuredMesh()->getMeshDimension());
+ int const meshDim(getStructuredMesh()->getMeshDimension());
med_geometry_type geoTypeReq(GetGeoTypeFromMeshDim(meshDim)),geoTypeReq2(GetGeoTypeFromMeshDim(meshDim-1));
//
if((const DataArrayIdType *)_fam_cells)
*/
MEDFileCMesh *MEDFileCMesh::New(const std::string& fileName, MEDFileMeshReadSelector *mrs)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return New(fid,mrs);
}
*/
MEDFileCMesh *MEDFileCMesh::New(const std::string& fileName, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return New(fid,mName,dt,it,mrs);
}
{
if(!MEDFileStructuredMesh::isEqual(other,eps,what))
return false;
- const MEDFileCMesh *otherC=dynamic_cast<const MEDFileCMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDFileCMesh *>(other);
if(!otherC)
{
what="Mesh types differ ! This is cartesian and other is NOT !";
otherC->clearNonDiscrAttributes();
const MEDCouplingCMesh *coo1=_cmesh;
const MEDCouplingCMesh *coo2=otherC->_cmesh;
- if((coo1==0 && coo2!=0) || (coo1!=0 && coo2==0))
+ if((coo1==nullptr && coo2!=nullptr) || (coo1!=nullptr && coo2==nullptr))
{
what="Mismatch of cartesian meshes ! One is defined and not other !";
return false;
}
if(coo1)
{
- bool ret=coo1->isEqual(coo2,eps);
+ bool const ret=coo1->isEqual(coo2,eps);
if(!ret)
{
what="cartesian meshes differ !";
}
MEDFileCMesh::MEDFileCMesh()
-{
-}
+= default;
MEDFileCMesh::MEDFileCMesh(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
try
MEDLoaderBase::safeStrCpy(_name.c_str(),MED_NAME_SIZE,maa,_too_long_str);
MEDLoaderBase::safeStrCpy(_desc_name.c_str(),MED_COMMENT_SIZE,desc,_too_long_str);
MEDLoaderBase::safeStrCpy(_dt_unit.c_str(),MED_LNAME_SIZE,dtunit,_too_long_str);
- int spaceDim(_cmesh->getSpaceDimension());
+ int const spaceDim(_cmesh->getSpaceDimension());
INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(spaceDim*MED_SNAME_SIZE);
INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(spaceDim*MED_SNAME_SIZE);
for(int i=0;i<spaceDim;i++)
{
- std::string info(_cmesh->getCoordsAt(i)->getInfoOnComponent(0));
+ std::string const info(_cmesh->getCoordsAt(i)->getInfoOnComponent(0));
std::string c,u;
MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE-1,comp+i*MED_SNAME_SIZE,_too_long_str);//MED_TAILLE_PNOM-1 to avoid to write '\0' on next compo
MEDFILESAFECALLERWR0(MEDmeshGridIndexCoordinateWr,(fid,maa,_iteration,_order,_time,i+1,ToMedInt(da->getNumberOfTuples()),da->getConstPointer()));
}
//
- std::string meshName(MEDLoaderBase::buildStringFromFortran(maa,MED_NAME_SIZE));
+ std::string const meshName(MEDLoaderBase::buildStringFromFortran(maa,MED_NAME_SIZE));
MEDFileStructuredMesh::writeStructuredLL(fid,meshName);
}
MEDFileCurveLinearMesh *MEDFileCurveLinearMesh::New(const std::string& fileName, MEDFileMeshReadSelector *mrs)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return New(fid,mrs);
}
MEDFileCurveLinearMesh *MEDFileCurveLinearMesh::New(const std::string& fileName, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return New(fid,mName,dt,it,mrs);
}
{
if(!MEDFileStructuredMesh::isEqual(other,eps,what))
return false;
- const MEDFileCurveLinearMesh *otherC=dynamic_cast<const MEDFileCurveLinearMesh *>(other);
+ const auto *otherC=dynamic_cast<const MEDFileCurveLinearMesh *>(other);
if(!otherC)
{
what="Mesh types differ ! This is curve linear and other is NOT !";
otherC->clearNonDiscrAttributes();
const MEDCouplingCurveLinearMesh *coo1=_clmesh;
const MEDCouplingCurveLinearMesh *coo2=otherC->_clmesh;
- if((coo1==0 && coo2!=0) || (coo1!=0 && coo2==0))
+ if((coo1==nullptr && coo2!=nullptr) || (coo1!=nullptr && coo2==nullptr))
{
what="Mismatch of curve linear meshes ! One is defined and not other !";
return false;
}
if(coo1)
{
- bool ret=coo1->isEqual(coo2,eps);
+ bool const ret=coo1->isEqual(coo2,eps);
if(!ret)
{
what="curve linear meshes differ !";
}
MEDFileCurveLinearMesh::MEDFileCurveLinearMesh()
-{
-}
+= default;
MEDFileCurveLinearMesh::MEDFileCurveLinearMesh(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
try
MEDLoaderBase::safeStrCpy(_name.c_str(),MED_NAME_SIZE,maa,_too_long_str);
MEDLoaderBase::safeStrCpy(_desc_name.c_str(),MED_COMMENT_SIZE,desc,_too_long_str);
MEDLoaderBase::safeStrCpy(_dt_unit.c_str(),MED_LNAME_SIZE,dtunit,_too_long_str);
- int spaceDim=_clmesh->getSpaceDimension();
- int meshDim=_clmesh->getMeshDimension();
+ int const spaceDim=_clmesh->getSpaceDimension();
+ int const meshDim=_clmesh->getMeshDimension();
INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(spaceDim*MED_SNAME_SIZE);
INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(spaceDim*MED_SNAME_SIZE);
const DataArrayDouble *coords=_clmesh->getCoords();
throw INTERP_KERNEL::Exception("MEDFileCurveLinearMesh::writeMeshLL : no coordinates set !");
for(int i=0;i<spaceDim;i++)
{
- std::string info(_clmesh->getCoords()->getInfoOnComponent(i));
+ std::string const info(_clmesh->getCoords()->getInfoOnComponent(i));
std::string c,u;
MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE-1,comp+i*MED_SNAME_SIZE,_too_long_str);//MED_TAILLE_PNOM-1 to avoid to write '\0' on next compo
MEDFILESAFECALLERWR0(MEDmeshNodeCoordinateWr,(fid,maa,_iteration,_order,_time,MED_FULL_INTERLACE,ToMedInt(coords->getNumberOfTuples()),coords->begin()));
//
- std::string meshName(MEDLoaderBase::buildStringFromFortran(maa,MED_NAME_SIZE));
+ std::string const meshName(MEDLoaderBase::buildStringFromFortran(maa,MED_NAME_SIZE));
MEDFileStructuredMesh::writeStructuredLL(fid,meshName);
}
MEDFileMeshMultiTS *MEDFileMeshMultiTS::New(const std::string& fileName)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return New(fid);
}
MEDFileMeshMultiTS *MEDFileMeshMultiTS::New(const std::string& fileName, const std::string& mName)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return New(fid,mName);
}
{
if ( MEDFileMesh* m = getOneTimeStep() )
return m->getJoints();
- return 0;
+ return nullptr;
}
/*!
for(std::vector< MCAuto<MEDFileMesh> >::const_iterator it=_mesh_one_ts.begin();it!=_mesh_one_ts.end();it++)
{
if ( jointsWritten )
- const_cast<MEDFileMesh&>(**it).setJoints( 0 );
+ const_cast<MEDFileMesh&>(**it).setJoints( nullptr );
else
jointsWritten = true;
void MEDFileMeshMultiTS::loadFromFile(med_idt fid, const std::string& mName)
{
- MEDFileJoints *joints(0);
+ MEDFileJoints *joints(nullptr);
if ( !_mesh_one_ts.empty() && getOneTimeStep() )
{
// joints of mName already read, pass them to MEDFileMesh::New() to prevent repeated reading
joints = getOneTimeStep()->getJoints();
}
_mesh_one_ts.clear(); //for the moment to be improved
- _mesh_one_ts.push_back( MEDFileMesh::New(fid,mName,-1,-1,0, joints ));
+ _mesh_one_ts.push_back( MEDFileMesh::New(fid,mName,-1,-1,nullptr, joints ));
}
MEDFileMeshMultiTS::MEDFileMeshMultiTS()
-{
-}
+= default;
MEDFileMeshMultiTS::MEDFileMeshMultiTS(med_idt fid)
try
MEDFileMeshes *MEDFileMeshes::New(const std::string& fileName)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return New(fid);
}
}
MEDFileMeshes::MEDFileMeshes()
-{
-}
+= default;
MEDFileMeshes::MEDFileMeshes(med_idt fid)
try
void MEDFileMeshes::simpleReprWithoutHeader(std::ostream& oss) const
{
- int nbOfMeshes=getNumberOfMeshes();
+ int const nbOfMeshes=getNumberOfMeshes();
oss << "There are " << nbOfMeshes << " meshes with the following names : \n";
std::vector<std::string> mns=getMeshesNames();
for(int i=0;i<nbOfMeshes;i++)
}
MEDFileMeshesIterator::~MEDFileMeshesIterator()
-{
-}
+= default;
MEDFileMesh *MEDFileMeshesIterator::nextt()
{
if(ms)
return ms->getMeshAtPos(_iter_id++);
else
- return 0;
+ return nullptr;
}
else
- return 0;
+ return nullptr;
}
INTERP_KERNEL::NormalizedCellType MEDFileMesh::ConvertFromMEDFileGeoType(med_geometry_type geoType)
#ifndef __MEDFILEMESH_HXX__
#define __MEDFILEMESH_HXX__
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDFileUtilities.txx"
+#include "MEDCouplingMemArray.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingMesh.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingUMesh.hxx"
+#include "MEDCoupling1GTUMesh.hxx"
+#include "MEDCouplingPointSet.hxx"
+#include "MEDCouplingStructuredMesh.hxx"
+#include "MEDCouplingCMesh.hxx"
+#include "MEDCouplingCurveLinearMesh.hxx"
#include "MEDLoaderDefines.hxx"
#include "MEDFileMeshLL.hxx"
-#include "MEDFileUtilities.txx"
#include "MEDCouplingPartDefinition.hxx"
#include "MEDFileMeshReadSelector.hxx"
#include "MEDFileJoint.hxx"
#include "MEDFileEquivalence.hxx"
+#include "med.h"
+#include "NormalizedGeometricTypes"
+#include <cstddef>
+#include <functional>
#include <map>
+#include <string>
+#include <ostream>
+#include <vector>
+#include <utility>
#include <list>
#include <set>
#include <memory>
class MEDFileMesh : public RefCountObject, public MEDFileWritableStandAlone
{
public:
- MEDLOADER_EXPORT static MEDFileMesh *New(const std::string& fileName, MEDFileMeshReadSelector *mrs=0);
- MEDLOADER_EXPORT static MEDFileMesh *New(med_idt fid, MEDFileMeshReadSelector *mrs=0);
+ MEDLOADER_EXPORT static MEDFileMesh *New(const std::string& fileName, MEDFileMeshReadSelector *mrs=nullptr);
+ MEDLOADER_EXPORT static MEDFileMesh *New(med_idt fid, MEDFileMeshReadSelector *mrs=nullptr);
MEDLOADER_EXPORT static MEDFileMesh *New(DataArrayByte *db) { return BuildFromMemoryChunk<MEDFileMesh>(db); }
- MEDLOADER_EXPORT static MEDFileMesh *New(const std::string& fileName, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=0, MEDFileJoints* joints=0);
- MEDLOADER_EXPORT static MEDFileMesh *New(med_idt fid, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=0, MEDFileJoints* joints=0);
- MEDLOADER_EXPORT void writeLL(med_idt fid) const;
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDLOADER_EXPORT static MEDFileMesh *New(const std::string& fileName, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=nullptr, MEDFileJoints* joints=nullptr);
+ MEDLOADER_EXPORT static MEDFileMesh *New(med_idt fid, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=nullptr, MEDFileJoints* joints=nullptr);
+ MEDLOADER_EXPORT void writeLL(med_idt fid) const override;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
MEDLOADER_EXPORT virtual MEDFileMesh *createNewEmpty() const = 0;
MEDLOADER_EXPORT virtual MEDFileMesh *deepCopy() const = 0;
MEDLOADER_EXPORT virtual MEDFileMesh *shallowCpy() const = 0;
MEDLOADER_EXPORT void setJoints( MEDFileJoints* joints );
MEDFileEquivalences *getEquivalences() { return _equiv; }
const MEDFileEquivalences *getEquivalences() const { return _equiv; }
- void killEquivalences() { _equiv=(MEDFileEquivalences *)0; }
+ void killEquivalences() { _equiv=(MEDFileEquivalences *)nullptr; }
void initializeEquivalences() { _equiv=MEDFileEquivalences::New(this); }
MEDLOADER_EXPORT static INTERP_KERNEL::NormalizedCellType ConvertFromMEDFileGeoType(med_geometry_type geoType);
MEDLOADER_EXPORT static med_geometry_type ConvertToMEDFileGeoType(INTERP_KERNEL::NormalizedCellType geoType);
static std::string CreateNameNotIn(const std::string& nameTry, const std::vector<std::string>& namesToAvoid);
static mcIdType PutInThirdComponentOfCodeOffset(std::vector<mcIdType>& code, mcIdType strt);
void writeJoints(med_idt fid) const;
- void loadJointsFromFile(med_idt fid, MEDFileJoints *toUseInstedOfReading=0);
+ void loadJointsFromFile(med_idt fid, MEDFileJoints *toUseInstedOfReading=nullptr);
void loadEquivalences(med_idt fid);
void deepCpyEquivalences(const MEDFileMesh& other);
bool areEquivalencesEqual(const MEDFileMesh *other, std::string& what) const;
{
friend class MEDFileMesh;
public:
- MEDLOADER_EXPORT static MEDFileUMesh *New(const std::string& fileName, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=0);
- MEDLOADER_EXPORT static MEDFileUMesh *New(med_idt fid, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=0);
- MEDLOADER_EXPORT static MEDFileUMesh *New(const std::string& fileName, MEDFileMeshReadSelector *mrs=0);
- MEDLOADER_EXPORT static MEDFileUMesh *New(med_idt fid, MEDFileMeshReadSelector *mrs=0);
+ MEDLOADER_EXPORT static MEDFileUMesh *New(const std::string& fileName, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=nullptr);
+ MEDLOADER_EXPORT static MEDFileUMesh *New(med_idt fid, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=nullptr);
+ MEDLOADER_EXPORT static MEDFileUMesh *New(const std::string& fileName, MEDFileMeshReadSelector *mrs=nullptr);
+ MEDLOADER_EXPORT static MEDFileUMesh *New(med_idt fid, MEDFileMeshReadSelector *mrs=nullptr);
MEDLOADER_EXPORT static MEDFileUMesh *New(DataArrayByte *db) { return BuildFromMemoryChunk<MEDFileUMesh>(db); }
MEDLOADER_EXPORT static MEDFileUMesh *New(const MEDCouplingMappedExtrudedMesh *mem);
MEDLOADER_EXPORT static MEDFileUMesh *New();
MEDLOADER_EXPORT static MCAuto<MEDFileUMesh> LoadConnectivityOnlyPartOf(med_idt fid, const std::string& mName, const std::vector<INTERP_KERNEL::NormalizedCellType>& types, const std::vector<mcIdType>& slicPerTyp, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=nullptr);
MEDLOADER_EXPORT static MEDFileUMesh *LoadPartOf(const std::string& fileName, const std::string& mName, const std::vector<INTERP_KERNEL::NormalizedCellType>& types, const std::vector<mcIdType>& slicPerTyp, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=nullptr);
MEDLOADER_EXPORT static MEDFileUMesh *LoadPartOf(med_idt fid, const std::string& mName, const std::vector<INTERP_KERNEL::NormalizedCellType>& types, const std::vector<mcIdType>& slicPerTyp, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=nullptr);
- MEDLOADER_EXPORT static MEDFileUMesh *LoadPartOfFromUserDistrib(med_idt fid, const std::string& mName, const std::map<INTERP_KERNEL::NormalizedCellType,std::vector<mcIdType>>& distrib, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=0);
+ MEDLOADER_EXPORT static MEDFileUMesh *LoadPartOfFromUserDistrib(med_idt fid, const std::string& mName, const std::map<INTERP_KERNEL::NormalizedCellType,std::vector<mcIdType>>& distrib, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=nullptr);
MEDLOADER_EXPORT static void LoadPartCoords(const std::string& fileName, const std::string& mName, int dt, int it, const std::vector<std::string>& infosOnComp, mcIdType startNodeId, mcIdType stopNodeId,
MCAuto<DataArrayDouble>& coords, MCAuto<PartDefinition>& partCoords, MCAuto<DataArrayIdType>& famCoords, MCAuto<DataArrayIdType>& numCoords, MCAuto<DataArrayAsciiChar>& nameCoords);
MEDLOADER_EXPORT static const char *GetSpeStr4ExtMesh() { return SPE_FAM_STR_EXTRUDED_MESH; }
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- MEDLOADER_EXPORT MEDFileMesh *createNewEmpty() const;
- MEDLOADER_EXPORT MEDFileUMesh *deepCopy() const;
- MEDLOADER_EXPORT MEDFileUMesh *shallowCpy() const;
- MEDLOADER_EXPORT bool isEqual(const MEDFileMesh *other, double eps, std::string& what) const;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ MEDLOADER_EXPORT MEDFileMesh *createNewEmpty() const override;
+ MEDLOADER_EXPORT MEDFileUMesh *deepCopy() const override;
+ MEDLOADER_EXPORT MEDFileUMesh *shallowCpy() const override;
+ MEDLOADER_EXPORT bool isEqual(const MEDFileMesh *other, double eps, std::string& what) const override;
MEDLOADER_EXPORT void checkConsistency() const;
MEDLOADER_EXPORT void checkSMESHConsistency() const;
MEDLOADER_EXPORT void clearNodeAndCellNumbers();
- MEDLOADER_EXPORT void clearNonDiscrAttributes() const;
- MEDLOADER_EXPORT void setName(const std::string& name);
+ MEDLOADER_EXPORT void clearNonDiscrAttributes() const override;
+ MEDLOADER_EXPORT void setName(const std::string& name) override;
MEDLOADER_EXPORT const std::vector< MCAuto<MEDFileEltStruct4Mesh> >& getAccessOfUndergroundEltStrs() const { return _elt_str; }
//
- MEDLOADER_EXPORT mcIdType getMaxAbsFamilyIdInArrays() const;
- MEDLOADER_EXPORT mcIdType getMaxFamilyIdInArrays() const;
- MEDLOADER_EXPORT mcIdType getMinFamilyIdInArrays() const;
- MEDLOADER_EXPORT int getMeshDimension() const;
- MEDLOADER_EXPORT int getSpaceDimension() const;
- MEDLOADER_EXPORT std::string simpleRepr() const;
- MEDLOADER_EXPORT std::string advancedRepr() const;
- MEDLOADER_EXPORT mcIdType getSizeAtLevel(int meshDimRelToMaxExt) const;
- MEDLOADER_EXPORT const DataArrayIdType *getFamilyFieldAtLevel(int meshDimRelToMaxExt) const;
- MEDLOADER_EXPORT DataArrayIdType *getFamilyFieldAtLevel(int meshDimRelToMaxExt);
- MEDLOADER_EXPORT const DataArrayIdType *getNumberFieldAtLevel(int meshDimRelToMaxExt) const;
- MEDLOADER_EXPORT const DataArrayIdType *getRevNumberFieldAtLevel(int meshDimRelToMaxExt) const;
- MEDLOADER_EXPORT const DataArrayAsciiChar *getNameFieldAtLevel(int meshDimRelToMaxExt) const;
- MEDLOADER_EXPORT MCAuto<DataArrayIdType> getGlobalNumFieldAtLevel(int meshDimRelToMaxExt) const;
+ MEDLOADER_EXPORT mcIdType getMaxAbsFamilyIdInArrays() const override;
+ MEDLOADER_EXPORT mcIdType getMaxFamilyIdInArrays() const override;
+ MEDLOADER_EXPORT mcIdType getMinFamilyIdInArrays() const override;
+ MEDLOADER_EXPORT int getMeshDimension() const override;
+ MEDLOADER_EXPORT int getSpaceDimension() const override;
+ MEDLOADER_EXPORT std::string simpleRepr() const override;
+ MEDLOADER_EXPORT std::string advancedRepr() const override;
+ MEDLOADER_EXPORT mcIdType getSizeAtLevel(int meshDimRelToMaxExt) const override;
+ MEDLOADER_EXPORT const DataArrayIdType *getFamilyFieldAtLevel(int meshDimRelToMaxExt) const override;
+ MEDLOADER_EXPORT DataArrayIdType *getFamilyFieldAtLevel(int meshDimRelToMaxExt) override;
+ MEDLOADER_EXPORT const DataArrayIdType *getNumberFieldAtLevel(int meshDimRelToMaxExt) const override;
+ MEDLOADER_EXPORT const DataArrayIdType *getRevNumberFieldAtLevel(int meshDimRelToMaxExt) const override;
+ MEDLOADER_EXPORT const DataArrayAsciiChar *getNameFieldAtLevel(int meshDimRelToMaxExt) const override;
+ MEDLOADER_EXPORT MCAuto<DataArrayIdType> getGlobalNumFieldAtLevel(int meshDimRelToMaxExt) const override;
MEDLOADER_EXPORT const PartDefinition *getPartDefAtLevel(int meshDimRelToMaxExt, INTERP_KERNEL::NormalizedCellType gt=INTERP_KERNEL::NORM_ERROR) const;
- MEDLOADER_EXPORT mcIdType getNumberOfNodes() const;
- MEDLOADER_EXPORT mcIdType getNumberOfCellsAtLevel(int meshDimRelToMaxExt) const;
- MEDLOADER_EXPORT bool hasImplicitPart() const;
- MEDLOADER_EXPORT mcIdType buildImplicitPartIfAny(INTERP_KERNEL::NormalizedCellType gt) const;
- MEDLOADER_EXPORT void releaseImplicitPartIfAny() const;
- MEDLOADER_EXPORT std::vector<INTERP_KERNEL::NormalizedCellType> getGeoTypesAtLevel(int meshDimRelToMax) const;
- MEDLOADER_EXPORT mcIdType getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType ct) const;
- MEDLOADER_EXPORT void whichAreNodesFetched(const MEDFileField1TSStructItem& st, const MEDFileFieldGlobsReal *globs, std::vector<bool>& nodesFetched) const;
- MEDLOADER_EXPORT MEDFileMesh *cartesianize() const;
- MEDLOADER_EXPORT bool presenceOfStructureElements() const;
- MEDLOADER_EXPORT void killStructureElements();
- MEDLOADER_EXPORT std::vector<int> getNonEmptyLevels() const;
- MEDLOADER_EXPORT std::vector<int> getNonEmptyLevelsExt() const;
- MEDLOADER_EXPORT std::vector<int> getFamArrNonEmptyLevelsExt() const;
- MEDLOADER_EXPORT std::vector<int> getNumArrNonEmptyLevelsExt() const;
- MEDLOADER_EXPORT std::vector<int> getNameArrNonEmptyLevelsExt() const;
- MEDLOADER_EXPORT std::vector<mcIdType> getFamsNonEmptyLevels(const std::vector<std::string>& fams) const;
- MEDLOADER_EXPORT std::vector<mcIdType> getFamsNonEmptyLevelsExt(const std::vector<std::string>& fams) const;
+ MEDLOADER_EXPORT mcIdType getNumberOfNodes() const override;
+ MEDLOADER_EXPORT mcIdType getNumberOfCellsAtLevel(int meshDimRelToMaxExt) const override;
+ MEDLOADER_EXPORT bool hasImplicitPart() const override;
+ MEDLOADER_EXPORT mcIdType buildImplicitPartIfAny(INTERP_KERNEL::NormalizedCellType gt) const override;
+ MEDLOADER_EXPORT void releaseImplicitPartIfAny() const override;
+ MEDLOADER_EXPORT std::vector<INTERP_KERNEL::NormalizedCellType> getGeoTypesAtLevel(int meshDimRelToMax) const override;
+ MEDLOADER_EXPORT mcIdType getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType ct) const override;
+ MEDLOADER_EXPORT void whichAreNodesFetched(const MEDFileField1TSStructItem& st, const MEDFileFieldGlobsReal *globs, std::vector<bool>& nodesFetched) const override;
+ MEDLOADER_EXPORT MEDFileMesh *cartesianize() const override;
+ MEDLOADER_EXPORT bool presenceOfStructureElements() const override;
+ MEDLOADER_EXPORT void killStructureElements() override;
+ MEDLOADER_EXPORT std::vector<int> getNonEmptyLevels() const override;
+ MEDLOADER_EXPORT std::vector<int> getNonEmptyLevelsExt() const override;
+ MEDLOADER_EXPORT std::vector<int> getFamArrNonEmptyLevelsExt() const override;
+ MEDLOADER_EXPORT std::vector<int> getNumArrNonEmptyLevelsExt() const override;
+ MEDLOADER_EXPORT std::vector<int> getNameArrNonEmptyLevelsExt() const override;
+ MEDLOADER_EXPORT std::vector<mcIdType> getFamsNonEmptyLevels(const std::vector<std::string>& fams) const override;
+ MEDLOADER_EXPORT std::vector<mcIdType> getFamsNonEmptyLevelsExt(const std::vector<std::string>& fams) const override;
MEDLOADER_EXPORT DataArrayDouble *getCoords() const;
MEDLOADER_EXPORT MEDCouplingUMesh *getGroup(int meshDimRelToMaxExt, const std::string& grp, bool renum=false) const;
MEDLOADER_EXPORT MEDCouplingUMesh *getGroups(int meshDimRelToMaxExt, const std::vector<std::string>& grps, bool renum=false) const;
MEDLOADER_EXPORT MEDCouplingUMesh *getFamily(int meshDimRelToMaxExt, const std::string& fam, bool renum=false) const;
MEDLOADER_EXPORT MEDCouplingUMesh *getFamilies(int meshDimRelToMaxExt, const std::vector<std::string>& fams, bool renum=false) const;
- MEDLOADER_EXPORT DataArrayIdType *getFamiliesArr(int meshDimRelToMaxExt, const std::vector<std::string>& fams, bool renum=false) const;
- MEDLOADER_EXPORT MEDCouplingUMesh *getMeshAtLevel(int meshDimRelToMax, bool renum=false) const;
- MEDLOADER_EXPORT std::vector<mcIdType> getDistributionOfTypes(int meshDimRelToMax) const;
+ MEDLOADER_EXPORT DataArrayIdType *getFamiliesArr(int meshDimRelToMaxExt, const std::vector<std::string>& fams, bool renum=false) const override;
+ MEDLOADER_EXPORT MEDCouplingUMesh *getMeshAtLevel(int meshDimRelToMax, bool renum=false) const override;
+ MEDLOADER_EXPORT std::vector<mcIdType> getDistributionOfTypes(int meshDimRelToMax) const override;
MEDLOADER_EXPORT std::vector< std::pair<int,mcIdType> > getAllDistributionOfTypes() const;
MEDLOADER_EXPORT MEDCouplingUMesh *getLevel0Mesh(bool renum=false) const;
MEDLOADER_EXPORT MEDCouplingUMesh *getLevelM1Mesh(bool renum=false) const;
MEDLOADER_EXPORT void setCoords(DataArrayDouble *coords);
MEDLOADER_EXPORT void setCoordsForced(DataArrayDouble *coords);
MEDLOADER_EXPORT void eraseGroupsAtLevel(int meshDimRelToMaxExt);
- MEDLOADER_EXPORT void setFamilyFieldArr(int meshDimRelToMaxExt, DataArrayIdType *famArr);
- MEDLOADER_EXPORT void setRenumFieldArr(int meshDimRelToMaxExt, DataArrayIdType *renumArr);
- MEDLOADER_EXPORT void setNameFieldAtLevel(int meshDimRelToMaxExt, DataArrayAsciiChar *nameArr);
- MEDLOADER_EXPORT void setGlobalNumFieldAtLevel(int meshDimRelToMaxExt, DataArrayIdType *globalNumArr);
- MEDLOADER_EXPORT void addNodeGroup(const DataArrayIdType *ids);
- MEDLOADER_EXPORT void addGroup(int meshDimRelToMaxExt, const DataArrayIdType *ids);
+ MEDLOADER_EXPORT void setFamilyFieldArr(int meshDimRelToMaxExt, DataArrayIdType *famArr) override;
+ MEDLOADER_EXPORT void setRenumFieldArr(int meshDimRelToMaxExt, DataArrayIdType *renumArr) override;
+ MEDLOADER_EXPORT void setNameFieldAtLevel(int meshDimRelToMaxExt, DataArrayAsciiChar *nameArr) override;
+ MEDLOADER_EXPORT void setGlobalNumFieldAtLevel(int meshDimRelToMaxExt, DataArrayIdType *globalNumArr) override;
+ MEDLOADER_EXPORT void addNodeGroup(const DataArrayIdType *ids) override;
+ MEDLOADER_EXPORT void addGroup(int meshDimRelToMaxExt, const DataArrayIdType *ids) override;
MEDLOADER_EXPORT void removeMeshAtLevel(int meshDimRelToMax);
MEDLOADER_EXPORT void setMeshAtLevel(int meshDimRelToMax, MEDCoupling1GTUMesh *m);
MEDLOADER_EXPORT void setMeshAtLevel(int meshDimRelToMax, MEDCouplingUMesh *m, bool newOrOld=false);
MEDLOADER_EXPORT std::map<mcIdType, std::map<mcIdType, mcIdType>> crackAlong(const std::string &grpNameM1, bool grpMustBeFullyDup=true);
MEDLOADER_EXPORT void openCrack(const std::map<mcIdType, std::map<mcIdType, mcIdType>> & c2o2nN, const double & factor);
MEDLOADER_EXPORT void buildInnerBoundaryAlongM1Group(const std::string& grpNameM1, DataArrayIdType *&nodesDuplicated, DataArrayIdType *&cellsModified, DataArrayIdType *&cellsNotModified);
- MEDLOADER_EXPORT bool unPolyze(std::vector<mcIdType>& oldCode, std::vector<mcIdType>& newCode, DataArrayIdType *& o2nRenumCell);
+ MEDLOADER_EXPORT bool unPolyze(std::vector<mcIdType>& oldCode, std::vector<mcIdType>& newCode, DataArrayIdType *& o2nRenumCell) override;
MEDLOADER_EXPORT DataArrayIdType *zipCoords();
MEDLOADER_EXPORT DataArrayIdType *computeFetchedNodeIds() const;
MEDLOADER_EXPORT DataArrayIdType *deduceNodeSubPartFromCellSubPart(const std::map<int, MCAuto<DataArrayIdType> >& extractDef) const;
MEDLOADER_EXPORT void unserialize(std::vector<double>& tinyDouble, std::vector<mcIdType>& tinyInt, std::vector<std::string>& tinyStr,
std::vector< MCAuto<DataArrayIdType> >& bigArraysI, MCAuto<DataArrayDouble>& bigArrayD);
private:
- MEDLOADER_EXPORT ~MEDFileUMesh();
- void writeMeshLL(med_idt fid) const;
+ MEDLOADER_EXPORT ~MEDFileUMesh() override;
+ void writeMeshLL(med_idt fid) const override;
MEDFileUMesh();
MEDFileUMesh(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs);
- void loadPartUMeshFromFile(med_idt fid, const std::string& mName, const std::vector<INTERP_KERNEL::NormalizedCellType>& types, const std::vector<mcIdType>& slicPerTyp, std::function<void(MEDFileUMeshL2&,med_idt fid, MeshOrStructMeshCls*,const std::string&,const std::vector<INTERP_KERNEL::NormalizedCellType>& types, const std::vector<mcIdType>&,int,int,MEDFileMeshReadSelector *)> functorOnUMeshL2, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=0);
- void loadPartUMeshFromFileFromUserDistrib(med_idt fid, const std::string& mName, const std::map<INTERP_KERNEL::NormalizedCellType,std::vector<mcIdType>>& distrib, std::function<void(MEDFileUMeshL2&,med_idt, MeshOrStructMeshCls*,const std::string&,const std::map<INTERP_KERNEL::NormalizedCellType,std::vector<mcIdType>>&,int,int,MEDFileMeshReadSelector *)> functorOnUMeshL2, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=0);
- void loadLL(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs);
+ void loadPartUMeshFromFile(med_idt fid, const std::string& mName, const std::vector<INTERP_KERNEL::NormalizedCellType>& types, const std::vector<mcIdType>& slicPerTyp, std::function<void(MEDFileUMeshL2&,med_idt fid, MeshOrStructMeshCls*,const std::string&,const std::vector<INTERP_KERNEL::NormalizedCellType>& types, const std::vector<mcIdType>&,int,int,MEDFileMeshReadSelector *)> functorOnUMeshL2, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=nullptr);
+ void loadPartUMeshFromFileFromUserDistrib(med_idt fid, const std::string& mName, const std::map<INTERP_KERNEL::NormalizedCellType,std::vector<mcIdType>>& distrib, std::function<void(MEDFileUMeshL2&,med_idt, MeshOrStructMeshCls*,const std::string&,const std::map<INTERP_KERNEL::NormalizedCellType,std::vector<mcIdType>>&,int,int,MEDFileMeshReadSelector *)> functorOnUMeshL2, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=nullptr);
+ void loadLL(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs) override;
void dispatchLoadedPart(med_idt fid, const MEDFileUMeshL2& loaderl2, const std::string& mName, MEDFileMeshReadSelector *mrs);
const MEDFileUMeshSplitL1 *getMeshAtLevSafe(int meshDimRelToMaxExt) const;
MEDFileUMeshSplitL1 *getMeshAtLevSafe(int meshDimRelToMaxExt);
void checkMeshDimCoherency(int meshDim, int meshDimRelToMax) const;
DataArrayDouble *checkMultiMesh(const std::vector<const MEDCouplingUMesh *>& ms) const;
- void synchronizeTinyInfoOnLeaves() const;
- void changeFamilyIdArr(mcIdType oldId, mcIdType newId);
- std::list< MCAuto<DataArrayIdType> > getAllNonNullFamilyIds() const;
+ void synchronizeTinyInfoOnLeaves() const override;
+ void changeFamilyIdArr(mcIdType oldId, mcIdType newId) override;
+ std::list< MCAuto<DataArrayIdType> > getAllNonNullFamilyIds() const override;
MCAuto<MEDFileUMeshSplitL1>& checkAndGiveEntryInSplitL1(int meshDimRelToMax, MEDCouplingPointSet *m);
static std::vector<std::shared_ptr<std::vector<mcIdType>>>
findConnectedComponents(
{
friend class MEDFileMesh;
public:
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- MEDLOADER_EXPORT mcIdType getMaxAbsFamilyIdInArrays() const;
- MEDLOADER_EXPORT mcIdType getMaxFamilyIdInArrays() const;
- MEDLOADER_EXPORT mcIdType getMinFamilyIdInArrays() const;
- MEDLOADER_EXPORT bool isEqual(const MEDFileMesh *other, double eps, std::string& what) const;
- MEDLOADER_EXPORT void clearNonDiscrAttributes() const;
- MEDLOADER_EXPORT DataArrayIdType *getFamiliesArr(int meshDimRelToMaxExt, const std::vector<std::string>& fams, bool renum=false) const;
- MEDLOADER_EXPORT const DataArrayIdType *getFamilyFieldAtLevel(int meshDimRelToMaxExt) const;
- MEDLOADER_EXPORT DataArrayIdType *getFamilyFieldAtLevel(int meshDimRelToMaxExt);
- MEDLOADER_EXPORT void setFamilyFieldArr(int meshDimRelToMaxExt, DataArrayIdType *famArr);
- MEDLOADER_EXPORT void setRenumFieldArr(int meshDimRelToMaxExt, DataArrayIdType *renumArr);
- MEDLOADER_EXPORT void setNameFieldAtLevel(int meshDimRelToMaxExt, DataArrayAsciiChar *nameArr);
- MEDLOADER_EXPORT void setGlobalNumFieldAtLevel(int meshDimRelToMaxExt, DataArrayIdType *globalNumArr);
- MEDLOADER_EXPORT void addNodeGroup(const DataArrayIdType *ids);
- MEDLOADER_EXPORT void addGroup(int meshDimRelToMaxExt, const DataArrayIdType *ids);
- MEDLOADER_EXPORT const DataArrayIdType *getNumberFieldAtLevel(int meshDimRelToMaxExt) const;
- MEDLOADER_EXPORT const DataArrayIdType *getRevNumberFieldAtLevel(int meshDimRelToMaxExt) const;
- MEDLOADER_EXPORT const DataArrayAsciiChar *getNameFieldAtLevel(int meshDimRelToMaxExt) const;
- MEDLOADER_EXPORT MCAuto<DataArrayIdType> getGlobalNumFieldAtLevel(int meshDimRelToMaxExt) const;
- MEDLOADER_EXPORT std::vector<int> getNonEmptyLevels() const;
- MEDLOADER_EXPORT std::vector<int> getNonEmptyLevelsExt() const;
- MEDLOADER_EXPORT std::vector<int> getFamArrNonEmptyLevelsExt() const;
- MEDLOADER_EXPORT std::vector<int> getNumArrNonEmptyLevelsExt() const;
- MEDLOADER_EXPORT std::vector<int> getNameArrNonEmptyLevelsExt() const;
- MEDLOADER_EXPORT MEDCouplingMesh *getMeshAtLevel(int meshDimRelToMax, bool renum=false) const;
- MEDLOADER_EXPORT std::vector<mcIdType> getFamsNonEmptyLevels(const std::vector<std::string>& fams) const;
- MEDLOADER_EXPORT std::vector<mcIdType> getFamsNonEmptyLevelsExt(const std::vector<std::string>& fams) const;
- MEDLOADER_EXPORT mcIdType getSizeAtLevel(int meshDimRelToMaxExt) const;
- MEDLOADER_EXPORT mcIdType getNumberOfNodes() const;
- MEDLOADER_EXPORT mcIdType getNumberOfCellsAtLevel(int meshDimRelToMaxExt) const;
- MEDLOADER_EXPORT bool hasImplicitPart() const;
- MEDLOADER_EXPORT mcIdType buildImplicitPartIfAny(INTERP_KERNEL::NormalizedCellType gt) const;
- MEDLOADER_EXPORT void releaseImplicitPartIfAny() const;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ MEDLOADER_EXPORT mcIdType getMaxAbsFamilyIdInArrays() const override;
+ MEDLOADER_EXPORT mcIdType getMaxFamilyIdInArrays() const override;
+ MEDLOADER_EXPORT mcIdType getMinFamilyIdInArrays() const override;
+ MEDLOADER_EXPORT bool isEqual(const MEDFileMesh *other, double eps, std::string& what) const override;
+ MEDLOADER_EXPORT void clearNonDiscrAttributes() const override;
+ MEDLOADER_EXPORT DataArrayIdType *getFamiliesArr(int meshDimRelToMaxExt, const std::vector<std::string>& fams, bool renum=false) const override;
+ MEDLOADER_EXPORT const DataArrayIdType *getFamilyFieldAtLevel(int meshDimRelToMaxExt) const override;
+ MEDLOADER_EXPORT DataArrayIdType *getFamilyFieldAtLevel(int meshDimRelToMaxExt) override;
+ MEDLOADER_EXPORT void setFamilyFieldArr(int meshDimRelToMaxExt, DataArrayIdType *famArr) override;
+ MEDLOADER_EXPORT void setRenumFieldArr(int meshDimRelToMaxExt, DataArrayIdType *renumArr) override;
+ MEDLOADER_EXPORT void setNameFieldAtLevel(int meshDimRelToMaxExt, DataArrayAsciiChar *nameArr) override;
+ MEDLOADER_EXPORT void setGlobalNumFieldAtLevel(int meshDimRelToMaxExt, DataArrayIdType *globalNumArr) override;
+ MEDLOADER_EXPORT void addNodeGroup(const DataArrayIdType *ids) override;
+ MEDLOADER_EXPORT void addGroup(int meshDimRelToMaxExt, const DataArrayIdType *ids) override;
+ MEDLOADER_EXPORT const DataArrayIdType *getNumberFieldAtLevel(int meshDimRelToMaxExt) const override;
+ MEDLOADER_EXPORT const DataArrayIdType *getRevNumberFieldAtLevel(int meshDimRelToMaxExt) const override;
+ MEDLOADER_EXPORT const DataArrayAsciiChar *getNameFieldAtLevel(int meshDimRelToMaxExt) const override;
+ MEDLOADER_EXPORT MCAuto<DataArrayIdType> getGlobalNumFieldAtLevel(int meshDimRelToMaxExt) const override;
+ MEDLOADER_EXPORT std::vector<int> getNonEmptyLevels() const override;
+ MEDLOADER_EXPORT std::vector<int> getNonEmptyLevelsExt() const override;
+ MEDLOADER_EXPORT std::vector<int> getFamArrNonEmptyLevelsExt() const override;
+ MEDLOADER_EXPORT std::vector<int> getNumArrNonEmptyLevelsExt() const override;
+ MEDLOADER_EXPORT std::vector<int> getNameArrNonEmptyLevelsExt() const override;
+ MEDLOADER_EXPORT MEDCouplingMesh *getMeshAtLevel(int meshDimRelToMax, bool renum=false) const override;
+ MEDLOADER_EXPORT std::vector<mcIdType> getFamsNonEmptyLevels(const std::vector<std::string>& fams) const override;
+ MEDLOADER_EXPORT std::vector<mcIdType> getFamsNonEmptyLevelsExt(const std::vector<std::string>& fams) const override;
+ MEDLOADER_EXPORT mcIdType getSizeAtLevel(int meshDimRelToMaxExt) const override;
+ MEDLOADER_EXPORT mcIdType getNumberOfNodes() const override;
+ MEDLOADER_EXPORT mcIdType getNumberOfCellsAtLevel(int meshDimRelToMaxExt) const override;
+ MEDLOADER_EXPORT bool hasImplicitPart() const override;
+ MEDLOADER_EXPORT mcIdType buildImplicitPartIfAny(INTERP_KERNEL::NormalizedCellType gt) const override;
+ MEDLOADER_EXPORT void releaseImplicitPartIfAny() const override;
MEDLOADER_EXPORT MEDCoupling1SGTUMesh *getImplicitFaceMesh() const;
- MEDLOADER_EXPORT std::vector<INTERP_KERNEL::NormalizedCellType> getGeoTypesAtLevel(int meshDimRelToMax) const;
- MEDLOADER_EXPORT mcIdType getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType ct) const;
- MEDLOADER_EXPORT void whichAreNodesFetched(const MEDFileField1TSStructItem& st, const MEDFileFieldGlobsReal *globs, std::vector<bool>& nodesFetched) const;
- MEDLOADER_EXPORT bool presenceOfStructureElements() const { return false; }
+ MEDLOADER_EXPORT std::vector<INTERP_KERNEL::NormalizedCellType> getGeoTypesAtLevel(int meshDimRelToMax) const override;
+ MEDLOADER_EXPORT mcIdType getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType ct) const override;
+ MEDLOADER_EXPORT void whichAreNodesFetched(const MEDFileField1TSStructItem& st, const MEDFileFieldGlobsReal *globs, std::vector<bool>& nodesFetched) const override;
+ MEDLOADER_EXPORT bool presenceOfStructureElements() const override { return false; }
MEDLOADER_EXPORT virtual const MEDCouplingStructuredMesh *getStructuredMesh() const = 0;
// tools
- MEDLOADER_EXPORT bool unPolyze(std::vector<mcIdType>& oldCode, std::vector<mcIdType>& newCode, DataArrayIdType *& o2nRenumCell);
+ MEDLOADER_EXPORT bool unPolyze(std::vector<mcIdType>& oldCode, std::vector<mcIdType>& newCode, DataArrayIdType *& o2nRenumCell) override;
protected:
- ~MEDFileStructuredMesh() { }
- void changeFamilyIdArr(mcIdType oldId, mcIdType newId);
- std::list< MCAuto<DataArrayIdType> > getAllNonNullFamilyIds() const;
+ ~MEDFileStructuredMesh() override = default;
+ void changeFamilyIdArr(mcIdType oldId, mcIdType newId) override;
+ std::list< MCAuto<DataArrayIdType> > getAllNonNullFamilyIds() const override;
void deepCpyAttributes();
void loadStrMeshFromFile(MEDFileStrMeshL2 *strm, med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs);
void writeStructuredLL(med_idt fid, const std::string& maa) const;
friend class MEDFileMesh;
public:
MEDLOADER_EXPORT static MEDFileCMesh *New();
- MEDLOADER_EXPORT static MEDFileCMesh *New(const std::string& fileName, MEDFileMeshReadSelector *mrs=0);
- MEDLOADER_EXPORT static MEDFileCMesh *New(med_idt fid, MEDFileMeshReadSelector *mrs=0);
+ MEDLOADER_EXPORT static MEDFileCMesh *New(const std::string& fileName, MEDFileMeshReadSelector *mrs=nullptr);
+ MEDLOADER_EXPORT static MEDFileCMesh *New(med_idt fid, MEDFileMeshReadSelector *mrs=nullptr);
MEDLOADER_EXPORT static MEDFileCMesh *New(DataArrayByte *db) { return BuildFromMemoryChunk<MEDFileCMesh>(db); }
- MEDLOADER_EXPORT static MEDFileCMesh *New(const std::string& fileName, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=0);
- MEDLOADER_EXPORT static MEDFileCMesh *New(med_idt fid, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=0);
+ MEDLOADER_EXPORT static MEDFileCMesh *New(const std::string& fileName, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=nullptr);
+ MEDLOADER_EXPORT static MEDFileCMesh *New(med_idt fid, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=nullptr);
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileCMesh"); }
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- MEDLOADER_EXPORT MEDFileMesh *createNewEmpty() const;
- MEDLOADER_EXPORT MEDFileCMesh *deepCopy() const;
- MEDLOADER_EXPORT MEDFileCMesh *shallowCpy() const;
- MEDLOADER_EXPORT bool isEqual(const MEDFileMesh *other, double eps, std::string& what) const;
- MEDLOADER_EXPORT int getMeshDimension() const;
- MEDLOADER_EXPORT int getSpaceDimension() const;
- MEDLOADER_EXPORT std::string simpleRepr() const;
- MEDLOADER_EXPORT std::string advancedRepr() const;
- MEDLOADER_EXPORT void clearNonDiscrAttributes() const;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ MEDLOADER_EXPORT MEDFileMesh *createNewEmpty() const override;
+ MEDLOADER_EXPORT MEDFileCMesh *deepCopy() const override;
+ MEDLOADER_EXPORT MEDFileCMesh *shallowCpy() const override;
+ MEDLOADER_EXPORT bool isEqual(const MEDFileMesh *other, double eps, std::string& what) const override;
+ MEDLOADER_EXPORT int getMeshDimension() const override;
+ MEDLOADER_EXPORT int getSpaceDimension() const override;
+ MEDLOADER_EXPORT std::string simpleRepr() const override;
+ MEDLOADER_EXPORT std::string advancedRepr() const override;
+ MEDLOADER_EXPORT void clearNonDiscrAttributes() const override;
MEDLOADER_EXPORT const MEDCouplingCMesh *getMesh() const;
MEDLOADER_EXPORT void setMesh(MEDCouplingCMesh *m);
- MEDLOADER_EXPORT MEDFileMesh *cartesianize() const;
+ MEDLOADER_EXPORT MEDFileMesh *cartesianize() const override;
private:
- ~MEDFileCMesh() { }
- const MEDCouplingStructuredMesh *getStructuredMesh() const;
- void writeMeshLL(med_idt fid) const;
+ ~MEDFileCMesh() override = default;
+ const MEDCouplingStructuredMesh *getStructuredMesh() const override;
+ void writeMeshLL(med_idt fid) const override;
MEDFileCMesh();
- void synchronizeTinyInfoOnLeaves() const;
+ void synchronizeTinyInfoOnLeaves() const override;
MEDFileCMesh(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs);
- void loadLL(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs);
+ void loadLL(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs) override;
private:
MCAuto<MEDCouplingCMesh> _cmesh;
};
friend class MEDFileMesh;
public:
MEDLOADER_EXPORT static MEDFileCurveLinearMesh *New();
- MEDLOADER_EXPORT static MEDFileCurveLinearMesh *New(const std::string& fileName, MEDFileMeshReadSelector *mrs=0);
- MEDLOADER_EXPORT static MEDFileCurveLinearMesh *New(med_idt fid, MEDFileMeshReadSelector *mrs=0);
+ MEDLOADER_EXPORT static MEDFileCurveLinearMesh *New(const std::string& fileName, MEDFileMeshReadSelector *mrs=nullptr);
+ MEDLOADER_EXPORT static MEDFileCurveLinearMesh *New(med_idt fid, MEDFileMeshReadSelector *mrs=nullptr);
MEDLOADER_EXPORT static MEDFileCurveLinearMesh *New(DataArrayByte *db) { return BuildFromMemoryChunk<MEDFileCurveLinearMesh>(db); }
- MEDLOADER_EXPORT static MEDFileCurveLinearMesh *New(const std::string& fileName, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=0);
- MEDLOADER_EXPORT static MEDFileCurveLinearMesh *New(med_idt fid, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=0);
+ MEDLOADER_EXPORT static MEDFileCurveLinearMesh *New(const std::string& fileName, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=nullptr);
+ MEDLOADER_EXPORT static MEDFileCurveLinearMesh *New(med_idt fid, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=nullptr);
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileCurveLinearMesh"); }
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- MEDLOADER_EXPORT MEDFileMesh *createNewEmpty() const;
- MEDLOADER_EXPORT MEDFileCurveLinearMesh *deepCopy() const;
- MEDLOADER_EXPORT MEDFileCurveLinearMesh *shallowCpy() const;
- MEDLOADER_EXPORT bool isEqual(const MEDFileMesh *other, double eps, std::string& what) const;
- MEDLOADER_EXPORT int getMeshDimension() const;
- MEDLOADER_EXPORT int getSpaceDimension() const;
- MEDLOADER_EXPORT std::string simpleRepr() const;
- MEDLOADER_EXPORT std::string advancedRepr() const;
- MEDLOADER_EXPORT void clearNonDiscrAttributes() const;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ MEDLOADER_EXPORT MEDFileMesh *createNewEmpty() const override;
+ MEDLOADER_EXPORT MEDFileCurveLinearMesh *deepCopy() const override;
+ MEDLOADER_EXPORT MEDFileCurveLinearMesh *shallowCpy() const override;
+ MEDLOADER_EXPORT bool isEqual(const MEDFileMesh *other, double eps, std::string& what) const override;
+ MEDLOADER_EXPORT int getMeshDimension() const override;
+ MEDLOADER_EXPORT int getSpaceDimension() const override;
+ MEDLOADER_EXPORT std::string simpleRepr() const override;
+ MEDLOADER_EXPORT std::string advancedRepr() const override;
+ MEDLOADER_EXPORT void clearNonDiscrAttributes() const override;
MEDLOADER_EXPORT const MEDCouplingCurveLinearMesh *getMesh() const;
MEDLOADER_EXPORT void setMesh(MEDCouplingCurveLinearMesh *m);
- MEDLOADER_EXPORT MEDFileMesh *cartesianize() const;
+ MEDLOADER_EXPORT MEDFileMesh *cartesianize() const override;
private:
- ~MEDFileCurveLinearMesh() { }
+ ~MEDFileCurveLinearMesh() override = default;
MEDFileCurveLinearMesh();
MEDFileCurveLinearMesh(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs);
- const MEDCouplingStructuredMesh *getStructuredMesh() const;
- void synchronizeTinyInfoOnLeaves() const;
- void writeMeshLL(med_idt fid) const;
- void loadLL(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs);//to imp
+ const MEDCouplingStructuredMesh *getStructuredMesh() const override;
+ void synchronizeTinyInfoOnLeaves() const override;
+ void writeMeshLL(med_idt fid) const override;
+ void loadLL(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs) override;//to imp
private:
MCAuto<MEDCouplingCurveLinearMesh> _clmesh;
};
MEDLOADER_EXPORT static MEDFileMeshMultiTS *New(const std::string& fileName, const std::string& mName);
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileMeshMultiTS"); }
MEDLOADER_EXPORT MEDFileMeshMultiTS *deepCopy() const;
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
MEDLOADER_EXPORT std::string getName() const;
MEDLOADER_EXPORT void setName(const std::string& newMeshName);
MEDLOADER_EXPORT bool changeNames(const std::vector< std::pair<std::string,std::string> >& modifTab);
MEDLOADER_EXPORT void cartesianizeMe();
MEDLOADER_EXPORT MEDFileMesh *getOneTimeStep() const;
- MEDLOADER_EXPORT void writeLL(med_idt fid) const;
+ MEDLOADER_EXPORT void writeLL(med_idt fid) const override;
MEDLOADER_EXPORT void setOneTimeStep(MEDFileMesh *mesh1TimeStep);
MEDLOADER_EXPORT MEDFileJoints *getJoints() const;
MEDLOADER_EXPORT void setJoints(MEDFileJoints* joints);
MEDLOADER_EXPORT bool presenceOfStructureElements() const;
MEDLOADER_EXPORT void killStructureElements();
private:
- ~MEDFileMeshMultiTS() { }
+ ~MEDFileMeshMultiTS() override = default;
void loadFromFile(med_idt fid, const std::string& mName);
MEDFileMeshMultiTS();
MEDFileMeshMultiTS(med_idt fid);
MEDLOADER_EXPORT static MEDFileMeshes *New(const std::string& fileName);
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileMeshes"); }
MEDLOADER_EXPORT MEDFileMeshes *deepCopy() const;
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
MEDLOADER_EXPORT std::string simpleRepr() const;
MEDLOADER_EXPORT void simpleReprWithoutHeader(std::ostream& oss) const;
- MEDLOADER_EXPORT void writeLL(med_idt fid) const;
+ MEDLOADER_EXPORT void writeLL(med_idt fid) const override;
MEDLOADER_EXPORT int getNumberOfMeshes() const;
MEDLOADER_EXPORT MEDFileMeshesIterator *iterator();
MEDLOADER_EXPORT MEDFileMesh *getMeshAtPos(int i) const;
MEDLOADER_EXPORT bool presenceOfStructureElements() const;
MEDLOADER_EXPORT void killStructureElements();
private:
- ~MEDFileMeshes() { }
+ ~MEDFileMeshes() override = default;
void checkConsistencyLight() const;
void loadFromFile(med_idt fid);
MEDFileMeshes();
// Author : Anthony Geay (CEA/DEN)
#include "MEDFileMeshElt.hxx"
+#include "MCType.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingPartDefinition.hxx"
+#include "MEDCoupling1GTUMesh.hxx"
+#include "MCIdType.hxx"
#include "MEDFileSafeCaller.txx"
#include "MEDFileMeshReadSelector.hxx"
#include "MEDFileBasis.hxx"
#include "CellModel.hxx"
#include "MEDFilterEntity.hxx"
+#include "med.h"
+#include "NormalizedGeometricTypes"
+#include "medmesh.h"
+#include <algorithm>
+#include <cstddef>
+#include <functional>
#include <iostream>
+#include <vector>
+#include <iterator>
+#include <sstream>
// From MEDLOader.cxx TU
med_entity_type entity, MEDFileMeshReadSelector *mrs)
{
med_bool changement,transformation;
- _fam=0;
+ _fam=nullptr;
if(MEDmeshnEntity(fid,mName,dt,it,entity,geoElt,MED_FAMILY_NUMBER,MED_NODAL,&changement,&transformation)>0)
{
if(!mrs || mrs->isCellFamilyFieldReading())
_fam=FromMedIntArray<mcIdType>( miFam );
}
}
- _num=0;
+ _num=nullptr;
if(MEDmeshnEntity(fid,mName,dt,it,entity,geoElt,MED_NUMBER,MED_NODAL,&changement,&transformation)>0)
{
if(!mrs || mrs->isCellNumFieldReading())
MCAuto<DataArrayMedInt> miNum=DataArrayMedInt::New();
miNum->alloc(curNbOfElem,1);
if(MEDmeshEntityNumberRd(fid,mName,dt,it,entity,geoElt,miNum->getPointer())!=0)
- miNum=0;
+ miNum=nullptr;
_num=FromMedIntArray<mcIdType>(miNum);
}
}
- _names=0;
+ _names=nullptr;
if(MEDmeshnEntity(fid,mName,dt,it,entity,geoElt,MED_NAME,MED_NODAL,&changement,&transformation)>0)
{
if(!mrs || mrs->isCellNameFieldReading())
_names=DataArrayAsciiChar::New();
_names->alloc(curNbOfElem+1,MED_SNAME_SIZE);//not a bug to avoid the memory corruption due to last \0 at the end
if(MEDmeshEntityNameRd(fid,mName,dt,it,entity,geoElt,_names->getPointer())!=0)
- _names=0;
+ _names=nullptr;
else
_names->reAlloc(curNbOfElem);//not a bug to avoid the memory corruption due to last \0 at the end
}
{
med_entity_type whichEntity;
if(!isExisting(fid,mName,dt,it,geoElt,whichEntity))
- return 0;
+ return nullptr;
return new MEDFileUMeshPerType(fid,mName,dt,it,mdim,geoElt,geoElt2,whichEntity,mrs);
}
MEDFileUMeshPerType *MEDFileUMeshPerType::NewPart(med_idt fid, const char *mName, int dt, int it, int mdim, INTERP_KERNEL::NormalizedCellType geoElt2, mcIdType strt, mcIdType stp, mcIdType step, MEDFileMeshReadSelector *mrs)
{
- int geoElt2i((int)geoElt2);
+ int const geoElt2i((int)geoElt2);
if(geoElt2i<0 || geoElt2i>=INTERP_KERNEL::NORM_MAXTYPE)
throw INTERP_KERNEL::Exception("MEDFileUMeshPerType::NewPart : Not recognized MEDCoupling/MEDLoader geometric type !");
- med_geometry_type geoElt(typmai3[geoElt2]);
+ med_geometry_type const geoElt(typmai3[geoElt2]);
med_entity_type whichEntity;
if(!isExisting(fid,mName,dt,it,geoElt,whichEntity))
throw INTERP_KERNEL::Exception("MEDFileUMeshPerType::NewPart : The specified geo type is not present in the specified mesh !");
MEDFileUMeshPerType *MEDFileUMeshPerType::NewPart(med_idt fid, const char *mName, int dt, int it, int mdim, INTERP_KERNEL::NormalizedCellType geoElt2, const std::vector<mcIdType>& distrib, MEDFileMeshReadSelector *mrs)
{
- int geoElt2i((int)geoElt2);
+ int const geoElt2i((int)geoElt2);
if(geoElt2i<0 || geoElt2i>=INTERP_KERNEL::NORM_MAXTYPE)
throw INTERP_KERNEL::Exception("MEDFileUMeshPerType::NewPart : Not recognized MEDCoupling/MEDLoader geometric type !");
- med_geometry_type geoElt(typmai3[geoElt2]);
+ med_geometry_type const geoElt(typmai3[geoElt2]);
med_entity_type whichEntity;
if(!isExisting(fid,mName,dt,it,geoElt,whichEntity))
throw INTERP_KERNEL::Exception("MEDFileUMeshPerType::NewPart : The specified geo type is not present in the specified mesh !");
for(int i=0;i<3;i++)
{
med_bool changement,transformation;
- mcIdType tmp(MEDmeshnEntity(fid,mName,dt,it,entities[i],geoElt,MED_CONNECTIVITY,MED_NODAL,&changement,&transformation));
+ mcIdType const tmp(MEDmeshnEntity(fid,mName,dt,it,entities[i],geoElt,MED_CONNECTIVITY,MED_NODAL,&changement,&transformation));
if(tmp>nbOfElt)
{
nbOfElt=tmp;
}
MEDFileUMeshPerType::MEDFileUMeshPerType()
-{
-}
+= default;
MEDFileUMeshPerType::MEDFileUMeshPerType(med_idt fid, const char *mName, int dt, int it, int mdim, med_geometry_type geoElt, INTERP_KERNEL::NormalizedCellType type,
med_entity_type entity, MEDFileMeshReadSelector *mrs)
{
med_bool changement,transformation;
- mcIdType curNbOfElem(MEDmeshnEntity(fid,mName,dt,it,entity,geoElt,MED_CONNECTIVITY,MED_NODAL,&changement,&transformation));
+ mcIdType const curNbOfElem(MEDmeshnEntity(fid,mName,dt,it,entity,geoElt,MED_CONNECTIVITY,MED_NODAL,&changement,&transformation));
const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(type));
if(!cm.isDynamic())
{
med_entity_type entity, const std::vector<mcIdType>& distrib, MEDFileMeshReadSelector *mrs)
{
med_bool changement,transformation;
- mcIdType curNbOfElem(MEDmeshnEntity(fid,mName,dt,it,entity,geoElt,MED_CONNECTIVITY,MED_NODAL,&changement,&transformation));
+ mcIdType const curNbOfElem(MEDmeshnEntity(fid,mName,dt,it,entity,geoElt,MED_CONNECTIVITY,MED_NODAL,&changement,&transformation));
const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(type));
MCAuto<DataArrayIdType> listOfIds=DataArrayIdType::New();
listOfIds->useArray(distrib.data(),false,DeallocType::C_DEALLOC,distrib.size(),1);
med_entity_type entity, mcIdType strt, mcIdType end, mcIdType step, MEDFileMeshReadSelector *mrs)
{
med_bool changement,transformation;
- mcIdType curNbOfElem(MEDmeshnEntity(fid,mName,dt,it,entity,geoElt,MED_CONNECTIVITY,MED_NODAL,&changement,&transformation));
+ mcIdType const curNbOfElem(MEDmeshnEntity(fid,mName,dt,it,entity,geoElt,MED_CONNECTIVITY,MED_NODAL,&changement,&transformation));
const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(type));
_pd=PartDefinition::New(strt,end,step);
if(!cm.isDynamic())
}
-void MEDFileUMeshPerType::loadFromStaticType(med_idt fid, const char *mName, int dt, int it, int mdim, mcIdType curNbOfElem, med_geometry_type geoElt, INTERP_KERNEL::NormalizedCellType type,
+void MEDFileUMeshPerType::loadFromStaticType(med_idt fid, const char *mName, int dt, int it, int /*mdim*/, mcIdType curNbOfElem, med_geometry_type geoElt, INTERP_KERNEL::NormalizedCellType type,
med_entity_type entity, MEDFileMeshReadSelector *mrs)
{
_m=MEDCoupling1SGTUMesh::New(mName,type);
- MEDCoupling1SGTUMesh *mc(dynamic_cast<MEDCoupling1SGTUMesh *>((MEDCoupling1GTUMesh *)_m));
+ auto *mc(dynamic_cast<MEDCoupling1SGTUMesh *>((MEDCoupling1GTUMesh *)_m));
MCAuto<DataArrayMedInt> conn(DataArrayMedInt::New());
- mcIdType nbOfNodesPerCell(mc->getNumberOfNodesPerCell());
+ mcIdType const nbOfNodesPerCell(mc->getNumberOfNodesPerCell());
conn->alloc(nbOfNodesPerCell*curNbOfElem,1);
MEDFILESAFECALLERRD0(MEDmeshElementConnectivityRd,(fid,mName,dt,it,entity,geoElt,MED_NODAL,MED_FULL_INTERLACE,conn->getPointer()));
std::transform(conn->begin(),conn->end(),conn->getPointer(),std::bind(std::plus<med_int>(),std::placeholders::_1,-1));
med_entity_type entity, MEDFileMeshReadSelector *mrs)
{
_m=MEDCoupling1SGTUMesh::New(mName,type);
- MEDCoupling1SGTUMesh *mc(dynamic_cast<MEDCoupling1SGTUMesh *>((MEDCoupling1GTUMesh *)_m));
+ auto *mc(dynamic_cast<MEDCoupling1SGTUMesh *>((MEDCoupling1GTUMesh *)_m));
MCAuto<DataArrayMedInt> conn(DataArrayMedInt::New());
- mcIdType nbOfNodesPerCell(mc->getNumberOfNodesPerCell());
+ mcIdType const nbOfNodesPerCell(mc->getNumberOfNodesPerCell());
if(!_pd)
throw INTERP_KERNEL::Exception("MEDFileUMeshPerType::loadPartStaticType : no part definition !");
- mcIdType nbOfEltsToLoad(_pd->getNumberOfElems());
+ mcIdType const nbOfEltsToLoad(_pd->getNumberOfElems());
conn->alloc(nbOfNodesPerCell*nbOfEltsToLoad,1);
{
MEDFilterEntity filter;
}
-void MEDFileUMeshPerType::loadPartOfCellCommonPart(med_idt fid, const char *mName, int dt, int it, int mdim, mcIdType curNbOfElem, med_geometry_type geoElt, med_entity_type entity, MEDFileMeshReadSelector *mrs)
+void MEDFileUMeshPerType::loadPartOfCellCommonPart(med_idt fid, const char *mName, int dt, int it, int /*mdim*/, mcIdType curNbOfElem, med_geometry_type geoElt, med_entity_type entity, MEDFileMeshReadSelector *mrs)
{
med_bool changement,transformation;
if(!_pd)
throw INTERP_KERNEL::Exception("MEDFileUMeshPerType::loadPartOfCellCommonPart : no part definition !");
- mcIdType nbOfEltsToLoad(_pd->getNumberOfElems());
- _fam=0;
+ mcIdType const nbOfEltsToLoad(_pd->getNumberOfElems());
+ _fam=nullptr;
if(MEDmeshnEntity(fid,mName,dt,it,entity,geoElt,MED_FAMILY_NUMBER,MED_NODAL,&changement,&transformation)>0)
{
if(!mrs || mrs->isCellFamilyFieldReading())
_fam=FromMedIntArray<mcIdType>(miFam);
}
}
- _num=0;
+ _num=nullptr;
if(MEDmeshnEntity(fid,mName,dt,it,entity,geoElt,MED_NUMBER,MED_NODAL,&changement,&transformation)>0)
{
if(!mrs || mrs->isCellNumFieldReading())
_num=FromMedIntArray<mcIdType>(miNum);
}
}
- _names=0;
+ _names=nullptr;
if(MEDmeshnEntity(fid,mName,dt,it,entity,geoElt,MED_NAME,MED_NODAL,&changement,&transformation)>0)
{
if(!mrs || mrs->isCellNameFieldReading())
MED_ALL_CONSTITUENT,MED_FULL_INTERLACE,MED_COMPACT_STMODE,MED_NO_PROFILE,
_pd);
if(MEDmeshEntityAttributeAdvancedRd(fid,mName,MED_NAME,dt,it,entity,geoElt,filter.getPtr(),_names->getPointer())!=0)
- _names=0;
+ _names=nullptr;
else
_names->reAlloc(nbOfEltsToLoad);//not a bug to avoid the memory corruption due to last \0 at the end
}
}
}
-void MEDFileUMeshPerType::loadPolyg(med_idt fid, const char *mName, int dt, int it, int mdim, mcIdType arraySize, med_geometry_type geoElt,
+void MEDFileUMeshPerType::loadPolyg(med_idt fid, const char *mName, int dt, int it, int /*mdim*/, mcIdType arraySize, med_geometry_type geoElt,
med_entity_type entity, MEDFileMeshReadSelector *mrs)
{
med_bool changement,transformation;
- mcIdType curNbOfElem(MEDmeshnEntity(fid,mName,dt,it,entity,geoElt,MED_INDEX_NODE,MED_NODAL,&changement,&transformation)-1);
+ mcIdType const curNbOfElem(MEDmeshnEntity(fid,mName,dt,it,entity,geoElt,MED_INDEX_NODE,MED_NODAL,&changement,&transformation)-1);
_m=MEDCoupling1DGTUMesh::New(mName,geoElt==MED_POLYGON?INTERP_KERNEL::NORM_POLYGON:INTERP_KERNEL::NORM_QPOLYG);
MCAuto<MEDCoupling1DGTUMesh> mc(DynamicCast<MEDCoupling1GTUMesh,MEDCoupling1DGTUMesh>(_m));
MCAuto<DataArrayMedInt> conn(DataArrayMedInt::New()),connI(DataArrayMedInt::New());
loadCommonPart(fid,mName,dt,it,curNbOfElem,geoElt,entity,mrs);
}
-void MEDFileUMeshPerType::loadPolyh(med_idt fid, const char *mName, int dt, int it, int mdim, mcIdType connFaceLgth, med_geometry_type geoElt,
+void MEDFileUMeshPerType::loadPolyh(med_idt fid, const char *mName, int dt, int it, int /*mdim*/, mcIdType connFaceLgth, med_geometry_type /*geoElt*/,
med_entity_type entity, MEDFileMeshReadSelector *mrs)
{
med_bool changement,transformation;
- med_int indexFaceLgth(MEDmeshnEntity(fid,mName,dt,it,MED_CELL,MED_POLYHEDRON,MED_INDEX_NODE,MED_NODAL,&changement,&transformation));
- mcIdType curNbOfElem(MEDmeshnEntity(fid,mName,dt,it,MED_CELL,MED_POLYHEDRON,MED_INDEX_FACE,MED_NODAL,&changement,&transformation)-1);
+ med_int const indexFaceLgth(MEDmeshnEntity(fid,mName,dt,it,MED_CELL,MED_POLYHEDRON,MED_INDEX_NODE,MED_NODAL,&changement,&transformation));
+ mcIdType const curNbOfElem(MEDmeshnEntity(fid,mName,dt,it,MED_CELL,MED_POLYHEDRON,MED_INDEX_FACE,MED_NODAL,&changement,&transformation)-1);
_m=MEDCoupling1DGTUMesh::New(mName,INTERP_KERNEL::NORM_POLYHED);
MCAuto<MEDCoupling1DGTUMesh> mc(DynamicCastSafe<MEDCoupling1GTUMesh,MEDCoupling1DGTUMesh>(_m));
INTERP_KERNEL::AutoPtr<med_int> index=new med_int[curNbOfElem+1];
loadCommonPart(fid,mName,dt,it,curNbOfElem,MED_POLYHEDRON,entity,mrs);
}
-void MEDFileUMeshPerType::Write(med_idt fid, const std::string& mname, int mdim, const MEDCoupling1GTUMesh *m, const DataArrayIdType *fam, const DataArrayIdType *num, const DataArrayAsciiChar *names)
+void MEDFileUMeshPerType::Write(med_idt fid, const std::string& mname, int /*mdim*/, const MEDCoupling1GTUMesh *m, const DataArrayIdType *fam, const DataArrayIdType *num, const DataArrayAsciiChar *names)
{
- mcIdType nbOfCells=m->getNumberOfCells();
+ mcIdType const nbOfCells=m->getNumberOfCells();
if(nbOfCells<1)
return ;
int dt,it;
- double timm=m->getTime(dt,it);
- INTERP_KERNEL::NormalizedCellType ikt=m->getTypeOfCell(0);
+ double const timm=m->getTime(dt,it);
+ INTERP_KERNEL::NormalizedCellType const ikt=m->getTypeOfCell(0);
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(ikt);
- med_geometry_type curMedType=typmai3[(int)ikt];
+ med_geometry_type const curMedType=typmai3[(int)ikt];
if(!cm.isDynamic())
{
- const MEDCoupling1SGTUMesh *m0(dynamic_cast<const MEDCoupling1SGTUMesh *>(m));
+ const auto *m0(dynamic_cast<const MEDCoupling1SGTUMesh *>(m));
if(!m0)
throw INTERP_KERNEL::Exception("MEDFileUMeshPerType::Write : internal error #1 !");
MCAuto<DataArrayMedInt> arr(DataArrayMedInt_Copy(m0->getNodalConnectivity()));
}
else
{
- const MEDCoupling1DGTUMesh *m0(dynamic_cast<const MEDCoupling1DGTUMesh *>(m));
+ const auto *m0(dynamic_cast<const MEDCoupling1DGTUMesh *>(m));
if(!m0)
throw INTERP_KERNEL::Exception("MEDFileUMeshPerType::Write : internal error #2 !");
if(ikt==INTERP_KERNEL::NORM_POLYGON || ikt==INTERP_KERNEL::NORM_QPOLYG)
else
{
const mcIdType *conn(m0->getNodalConnectivity()->begin()),*connI(m0->getNodalConnectivityIndex()->begin());
- mcIdType meshLgth=m0->getNodalConnectivityLength();
- mcIdType nbOfFaces=ToIdType(std::count(conn,conn+meshLgth,-1)+nbOfCells);
+ mcIdType const meshLgth=m0->getNodalConnectivityLength();
+ mcIdType const nbOfFaces=ToIdType(std::count(conn,conn+meshLgth,-1)+nbOfCells);
INTERP_KERNEL::AutoPtr<med_int> tab1=new med_int[nbOfCells+1];
med_int *w1=tab1; *w1=1;
INTERP_KERNEL::AutoPtr<med_int> tab2=new med_int[nbOfFaces+1];
{
const mcIdType *wend=std::find(w,conn+connI[i+1],-1);
bt=std::transform(w,wend,bt,std::bind(std::plus<mcIdType>(),std::placeholders::_1,1));
- std::size_t nbOfNode=std::distance(w,wend);
+ std::size_t const nbOfNode=std::distance(w,wend);
w2[1]=w2[0]+(med_int)nbOfNode;
if(wend!=conn+connI[i+1])
w=wend+1;
#ifndef __MEDFILEMESHELT_HXX__
#define __MEDFILEMESHELT_HXX__
+#include "MCType.hxx"
#include "MEDCouplingMemArray.hxx"
#include "MEDCoupling1GTUMesh.hxx"
#include "MEDCouplingPartDefinition.hxx"
#include "MCAuto.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "NormalizedGeometricTypes"
#include "med.h"
+#include <string>
+#include <cstddef>
+#include <vector>
namespace MEDCoupling
{
std::string getClassName() const override { return std::string("MEDFileUMeshPerTypeCommon"); }
void loadCommonPart(med_idt fid, const char *mName, int dt, int it, mcIdType curNbOfElem, med_geometry_type geoElt,
med_entity_type entity, MEDFileMeshReadSelector *mrs);
- std::size_t getHeapMemorySizeWithoutChildren() const;
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
const DataArrayIdType *getFam() const { return _fam; }
const DataArrayIdType *getNum() const { return _num; }
const DataArrayAsciiChar *getNames() const { return _names; }
std::string getClassName() const override { return std::string("MEDFileUMeshPerType"); }
static bool isExisting(med_idt fid, const char *mName, int dt, int it, med_geometry_type geoElt, med_entity_type& whichEntity);
- std::size_t getHeapMemorySizeWithoutChildren() const;
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
int getDim() const;
MEDCoupling1GTUMesh *getMesh() const { return const_cast<MEDCoupling1GTUMesh *>((const MEDCoupling1GTUMesh *)_m); }
const PartDefinition *getPartDef() const { return _pd; }
// Author : Anthony Geay (CEA/DEN)
#include "MEDFileMeshLL.hxx"
+#include "MEDCouplingCurveLinearMesh.hxx"
+#include "MEDCouplingMesh.hxx"
+#include "MEDCouplingMemArray.txx"
+#include "MEDFileBasis.hxx"
+#include "MCType.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingMap.txx"
+#include "MEDCouplingPartDefinition.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MCIdType.hxx"
+#include "MEDCoupling1GTUMesh.hxx"
#include "MEDFileMesh.hxx"
+#include "MEDFileMeshElt.hxx"
#include "MEDLoaderBase.hxx"
#include "MEDFileSafeCaller.txx"
#include "MEDFileMeshReadSelector.hxx"
#include "CellModel.hxx"
#include "MEDFilterEntity.hxx"
+#include "med.h"
+#include "NormalizedGeometricTypes"
+#include "medmesh.h"
+#include <algorithm>
+#include <cstddef>
+#include "medfamily.h"
+#include "medstructelement.h"
+#include <istream>
+#include <iterator>
+#include <map>
+#include <ostream>
#include <set>
+#include <string>
+#include <sstream>
+#include <vector>
+#include <utility>
#include <iomanip>
// From MEDLOader.cxx TU
med_int spaceDim, meshDim, nbSteps;
med_sorting_type stype;
med_axis_type axistype;
- med_int naxis(MEDmeshnAxis(fid,getID()));
+ med_int const naxis(MEDmeshnAxis(fid,getID()));
INTERP_KERNEL::AutoPtr<char> nameTmp(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
INTERP_KERNEL::AutoPtr<char> axisname(MEDLoaderBase::buildEmptyString(naxis*MED_SNAME_SIZE));
INTERP_KERNEL::AutoPtr<char> axisunit(MEDLoaderBase::buildEmptyString(naxis*MED_SNAME_SIZE));
- INTERP_KERNEL::AutoPtr<char> univTmp(MEDLoaderBase::buildEmptyString(MED_LNAME_SIZE));
+ INTERP_KERNEL::AutoPtr<char> const univTmp(MEDLoaderBase::buildEmptyString(MED_LNAME_SIZE));
if(MEDmeshInfo(fid,getID(),nameTmp,&spaceDim,&meshDim,&type_maillage,description.getPointer(),dtunit.getPointer(),
&stype,&nbSteps,&axistype,axisname,axisunit)!=0)
throw INTERP_KERNEL::Exception("A problem has been detected when trying to get info on mesh !");
std::vector<std::string> infosOnComp(naxis);
for(int i=0;i<naxis;i++)
{
- std::string info(MEDLoaderBase::buildUnionUnit(((char *)axisname)+i*MED_SNAME_SIZE,MED_SNAME_SIZE,((char *)axisunit)+i*MED_SNAME_SIZE,MED_SNAME_SIZE));
+ std::string const info(MEDLoaderBase::buildUnionUnit(((char *)axisname)+i*MED_SNAME_SIZE,MED_SNAME_SIZE,((char *)axisunit)+i*MED_SNAME_SIZE,MED_SNAME_SIZE));
infosOnComp[i]=info;
}
return infosOnComp;
return dtt;
}
-std::vector<std::string> StructMeshCls::getAxisInfoOnMesh(med_idt fid, const std::string& mName, MEDCoupling::MEDCouplingMeshType& meshType, MEDCoupling::MEDCouplingAxisType& axType, int& nstep, int& Mdim, MEDFileString& description, MEDFileString& dtunit, MEDFileString& univName) const
+std::vector<std::string> StructMeshCls::getAxisInfoOnMesh(med_idt fid, const std::string& /*mName*/, MEDCoupling::MEDCouplingMeshType& meshType, MEDCoupling::MEDCouplingAxisType& axType, int& nstep, int& /*Mdim*/, MEDFileString& description, MEDFileString& dtunit, MEDFileString& univName) const
{
INTERP_KERNEL::AutoPtr<char> msn(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
INTERP_KERNEL::AutoPtr<char> zeDescription(MEDLoaderBase::buildEmptyString(MED_COMMENT_SIZE));
med_axis_type medAxType;
- med_int nAxis(MEDsupportMeshnAxis(fid,getID()));
+ med_int const nAxis(MEDsupportMeshnAxis(fid,getID()));
INTERP_KERNEL::AutoPtr<char> axisName(new char[MED_SNAME_SIZE*nAxis+1]),axisUnit(new char[MED_SNAME_SIZE*nAxis+1]);
med_int spaceDim(0),meshDim(0);
MEDFILESAFECALLERRD0(MEDsupportMeshInfo,(fid,getID(),msn,&spaceDim,&meshDim,zeDescription,&medAxType,axisName,axisUnit));
- std::string descriptionCpp(MEDLoaderBase::buildStringFromFortran(zeDescription,MED_COMMENT_SIZE));
+ std::string const descriptionCpp(MEDLoaderBase::buildStringFromFortran(zeDescription,MED_COMMENT_SIZE));
description.set(descriptionCpp.c_str());
dtunit.clear(); univName.clear(); meshType=UNSTRUCTURED; nstep=1;
axType=MEDFileMeshL2::TraduceAxisType(medAxType);
std::vector<std::string> ret;
for(int i=0;i<nAxis;i++)
{
- std::string info(DataArray::BuildInfoFromVarAndUnit(MEDLoaderBase::buildStringFromFortran(axisName+i*MED_SNAME_SIZE,MED_SNAME_SIZE),
+ std::string const info(DataArray::BuildInfoFromVarAndUnit(MEDLoaderBase::buildStringFromFortran(axisName+i*MED_SNAME_SIZE,MED_SNAME_SIZE),
MEDLoaderBase::buildStringFromFortran(axisUnit+i*MED_SNAME_SIZE,MED_SNAME_SIZE)));
ret.push_back(info);
}
return ret;
}
-double StructMeshCls::checkMeshTimeStep(med_idt fid, const std::string& mName, int nstep, int dt, int it) const
+double StructMeshCls::checkMeshTimeStep(med_idt /*fid*/, const std::string& /*mName*/, int /*nstep*/, int /*dt*/, int /*it*/) const
{
return 0.;
}
char dtunit[MED_LNAME_SIZE+1];
med_int spaceDim,dim;
char nommaa[MED_NAME_SIZE+1];
- med_int n=MEDnMesh(fid);
+ med_int const n=MEDnMesh(fid);
char found(0);
int ret=-1;
med_sorting_type stype;
med_axis_type axistype=MED_UNDEF_AXIS_TYPE;
for(int i=0;i<n && found==0;i++)
{
- med_int naxis(MEDmeshnAxis(fid,i+1));
+ med_int const naxis(MEDmeshnAxis(fid,i+1));
INTERP_KERNEL::AutoPtr<char> axisname(MEDLoaderBase::buildEmptyString(naxis*MED_SNAME_SIZE)),axisunit(MEDLoaderBase::buildEmptyString(naxis*MED_SNAME_SIZE));
MEDFILESAFECALLERRD0(MEDmeshInfo,(fid,i+1,nommaa,&spaceDim,&dim,&type_maillage,maillage_description,dtunit,&stype,&nstep,&axistype,axisname,axisunit));
dtunit1=MEDLoaderBase::buildStringFromFortran(dtunit,sizeof(dtunit));
- std::string cur(MEDLoaderBase::buildStringFromFortran(nommaa,sizeof(nommaa)));
+ std::string const cur(MEDLoaderBase::buildStringFromFortran(nommaa,sizeof(nommaa)));
ms.push_back(cur);
if(cur==mName)
{
}
if(found==0)
{//last chance ! Is it a support mesh ?
- med_int nbSM(MEDnSupportMesh(fid));
+ med_int const nbSM(MEDnSupportMesh(fid));
for(int i=0;i<nbSM && found==0;i++)
{
- med_int naxis(MEDsupportMeshnAxis(fid,i+1));
+ med_int const naxis(MEDsupportMeshnAxis(fid,i+1));
INTERP_KERNEL::AutoPtr<char> axisname(MEDLoaderBase::buildEmptyString(naxis*MED_SNAME_SIZE)),axisunit(MEDLoaderBase::buildEmptyString(naxis*MED_SNAME_SIZE));
MEDFILESAFECALLERRD0(MEDsupportMeshInfo,(fid,i+1,nommaa,&spaceDim,&dim,maillage_description,&axistype,axisname,axisunit));
- std::string cur(MEDLoaderBase::buildStringFromFortran(nommaa,sizeof(nommaa)));
+ std::string const cur(MEDLoaderBase::buildStringFromFortran(nommaa,sizeof(nommaa)));
ms.push_back(cur);
if(cur==mName)
{
return ;
char nomfam[MED_NAME_SIZE+1];
med_int numfam;
- med_int nfam=MEDnFamily(fid,meshName.c_str());
+ med_int const nfam=MEDnFamily(fid,meshName.c_str());
std::vector< std::pair<std::string,std::pair<mcIdType,std::vector<std::string> > > > crudeFams(nfam);
for(int i=0;i<nfam;i++)
{
- med_int ngro=MEDnFamilyGroup(fid,meshName.c_str(),i+1);
- med_int natt=MEDnFamily23Attribute(fid,meshName.c_str(),i+1);
+ med_int const ngro=MEDnFamilyGroup(fid,meshName.c_str(),i+1);
+ med_int const natt=MEDnFamily23Attribute(fid,meshName.c_str(),i+1);
INTERP_KERNEL::AutoPtr<med_int> attide=new med_int[natt];
INTERP_KERNEL::AutoPtr<med_int> attval=new med_int[natt];
INTERP_KERNEL::AutoPtr<char> attdes=new char[MED_COMMENT_SIZE*natt+1];
INTERP_KERNEL::AutoPtr<char> gro=new char[MED_LNAME_SIZE*ngro+1];
MEDfamily23Info(fid,meshName.c_str(),i+1,nomfam,attide,attval,attdes,&numfam,gro);
- std::string famName(MEDLoaderBase::buildStringFromFortran(nomfam,MED_NAME_SIZE));
+ std::string const famName(MEDLoaderBase::buildStringFromFortran(nomfam,MED_NAME_SIZE));
std::vector<std::string> grps2(ngro);
for(int j=0;j<ngro;j++)
grps2[j]=MEDLoaderBase::buildStringFromFortran(gro+j*MED_LNAME_SIZE,MED_LNAME_SIZE);
crudeFams[i]=std::pair<std::string,std::pair<mcIdType,std::vector<std::string> > >(famName,std::pair<mcIdType,std::vector<std::string> >(numfam,grps2));
}
RenameFamiliesFromFileToMemInternal(crudeFams);
- for(std::vector< std::pair<std::string,std::pair<mcIdType,std::vector<std::string> > > >::const_iterator it0=crudeFams.begin();it0!=crudeFams.end();it0++)
+ for(const auto & crudeFam : crudeFams)
{
- fams[(*it0).first]=(*it0).second.first;
- for(std::vector<std::string>::const_iterator it1=(*it0).second.second.begin();it1!=(*it0).second.second.end();it1++)
- grps[*it1].push_back((*it0).first);
+ fams[crudeFam.first]=crudeFam.second.first;
+ for(auto it1=crudeFam.second.second.begin();it1!=crudeFam.second.second.end();it1++)
+ grps[*it1].push_back(crudeFam.first);
}
}
{
std::vector< std::pair<std::string,std::pair<mcIdType,std::vector<std::string> > > > crudeFams(fams.size());
std::size_t ii(0);
- for(std::map<std::string,mcIdType>::const_iterator it=fams.begin();it!=fams.end();it++,ii++)
+ for(auto it=fams.begin();it!=fams.end();it++,ii++)
{
std::vector<std::string> grpsOfFam;
- for(std::map<std::string, std::vector<std::string> >::const_iterator it1=grps.begin();it1!=grps.end();it1++)
+ for(const auto & grp : grps)
{
- if(std::find((*it1).second.begin(),(*it1).second.end(),(*it).first)!=(*it1).second.end())
- grpsOfFam.push_back((*it1).first);
+ if(std::find(grp.second.begin(),grp.second.end(),(*it).first)!=grp.second.end())
+ grpsOfFam.push_back(grp.first);
}
crudeFams[ii]=std::pair<std::string,std::pair<mcIdType,std::vector<std::string> > >((*it).first,std::pair<mcIdType,std::vector<std::string> >((*it).second,grpsOfFam));
}
RenameFamiliesFromMemToFileInternal(crudeFams);
- for(std::vector< std::pair<std::string,std::pair<mcIdType,std::vector<std::string> > > >::const_iterator it=crudeFams.begin();it!=crudeFams.end();it++)
+ for(const auto & crudeFam : crudeFams)
{
- std::size_t ngro((*it).second.second.size());
+ std::size_t const ngro(crudeFam.second.second.size());
INTERP_KERNEL::AutoPtr<char> groName=MEDLoaderBase::buildEmptyString(MED_LNAME_SIZE*ngro);
int i=0;
- for(std::vector<std::string>::const_iterator it2=(*it).second.second.begin();it2!=(*it).second.second.end();it2++,i++)
+ for(auto it2=crudeFam.second.second.begin();it2!=crudeFam.second.second.end();it2++,i++)
MEDLoaderBase::safeStrCpy2((*it2).c_str(),MED_LNAME_SIZE,groName+i*MED_LNAME_SIZE,tooLongStrPol);
INTERP_KERNEL::AutoPtr<char> famName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
- MEDLoaderBase::safeStrCpy((*it).first.c_str(),MED_NAME_SIZE,famName,tooLongStrPol);
- med_int ret=MEDfamilyCr(fid,mname.c_str(),famName,ToMedInt((*it).second.first),ToMedInt(ngro),groName);
+ MEDLoaderBase::safeStrCpy(crudeFam.first.c_str(),MED_NAME_SIZE,famName,tooLongStrPol);
+ med_int ret=MEDfamilyCr(fid,mname.c_str(),famName,ToMedInt(crudeFam.second.first),ToMedInt(ngro),groName);
ret++;
}
}
if(!func(fams))
return ;
ii=0;
- for(std::vector< std::pair<std::string,std::pair<mcIdType,std::vector<std::string> > > >::iterator it=crudeFams.begin();it!=crudeFams.end();it++,ii++)
+ for(auto it=crudeFams.begin();it!=crudeFams.end();it++,ii++)
(*it).first=fams[ii];
}
{
std::map<std::string,mcIdType> m;
std::set<std::string> s;
- for(std::vector< std::string >::const_iterator it=famNames.begin();it!=famNames.end();it++)
+ for(const auto & famName : famNames)
{
- if(s.find(*it)!=s.end())
- m[*it]=0;
- s.insert(*it);
+ if(s.find(famName)!=s.end())
+ m[famName]=0;
+ s.insert(famName);
}
if(m.empty())
return false;// the general case !
- for(std::vector< std::string >::iterator it=famNames.begin();it!=famNames.end();it++)
+ for(auto & famName : famNames)
{
- std::map<std::string,mcIdType>::iterator it2(m.find(*it));
+ auto const it2(m.find(famName));
if(it2!=m.end())
{
- std::ostringstream oss; oss << *it << ZE_SEP_FOR_FAMILY_KILLERS << std::setfill('0') << std::setw(ZE_SEP2_FOR_FAMILY_KILLERS) << (*it2).second++;
- *it=oss.str();
+ std::ostringstream oss; oss << famName << ZE_SEP_FOR_FAMILY_KILLERS << std::setfill('0') << std::setw(ZE_SEP2_FOR_FAMILY_KILLERS) << (*it2).second++;
+ famName=oss.str();
}
}
return true;
bool MEDFileMeshL2::RenameFamiliesFromMemToFile(std::vector< std::string >& famNames)
{
bool isSmthingStrange(false);
- for(std::vector< std::string >::const_iterator it=famNames.begin();it!=famNames.end();it++)
+ for(const auto & famName : famNames)
{
- std::size_t found((*it).find(ZE_SEP_FOR_FAMILY_KILLERS));
+ std::size_t const found(famName.find(ZE_SEP_FOR_FAMILY_KILLERS));
if(found!=std::string::npos)
isSmthingStrange=true;
}
return false;
// pattern matching
std::map< std::string, std::vector<std::string> > m;
- for(std::vector< std::string >::const_iterator it=famNames.begin();it!=famNames.end();it++)
+ for(const auto & famName : famNames)
{
- std::size_t found((*it).find(ZE_SEP_FOR_FAMILY_KILLERS));
+ std::size_t const found(famName.find(ZE_SEP_FOR_FAMILY_KILLERS));
if(found!=std::string::npos && found>=1)
{
- std::string s1((*it).substr(found+sizeof(ZE_SEP_FOR_FAMILY_KILLERS)-1));
+ std::string const s1(famName.substr(found+sizeof(ZE_SEP_FOR_FAMILY_KILLERS)-1));
if((int)s1.size()!=ZE_SEP2_FOR_FAMILY_KILLERS)
continue;
int k(-1);
std::istringstream iss(s1);
iss >> k;
- bool isOK((iss.rdstate() & ( std::istream::failbit | std::istream::eofbit)) == std::istream::eofbit);
+ bool const isOK((iss.rdstate() & ( std::istream::failbit | std::istream::eofbit)) == std::istream::eofbit);
if(isOK && k>=0)
{
- std::string s0((*it).substr(0,found));
- m[s0].push_back(*it);
+ std::string const s0(famName.substr(0,found));
+ m[s0].push_back(famName);
}
}
}
{
if((*it).second.size()==1)
continue;
- for(std::vector<std::string>::const_iterator it1=(*it).second.begin();it1!=(*it).second.end();it1++)
+ for(auto it1=(*it).second.begin();it1!=(*it).second.end();it1++)
zeMap[*it1]=(*it).first;
}
if(zeMap.empty())
return false;
// traduce
- for(std::vector< std::string >::iterator it=famNames.begin();it!=famNames.end();it++)
+ for(auto & famName : famNames)
{
- std::map<std::string,std::string>::iterator it1(zeMap.find(*it));
+ auto const it1(zeMap.find(famName));
if(it1!=zeMap.end())
- *it=(*it1).second;
+ famName=(*it1).second;
}
return true;
}
}
MEDFileUMeshL2::MEDFileUMeshL2()
-{
-}
+= default;
std::vector<std::string> MEDFileUMeshL2::loadCommonPart(med_idt fid, const MeshOrStructMeshCls *mId, const std::string& mName, int dt, int it, int& Mdim)
{
void MEDFileUMeshL2::loadAll(med_idt fid, const MeshOrStructMeshCls *mId, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
{
int Mdim;
- std::vector<std::string> infosOnComp(loadCommonPart(fid,mId,mName,dt,it,Mdim));
+ std::vector<std::string> const infosOnComp(loadCommonPart(fid,mId,mName,dt,it,Mdim));
if(Mdim==-4)
return ;
loadConnectivity(fid,Mdim,mName,dt,it,mrs);//to improve check (dt,it) coherency
* - dealing with optimized load of coordinates (loading only points fetched by the already loaded cells)
* - update the connectivity in \a this to fit the coordinates loaded just above
*/
-void MEDFileUMeshL2::dealWithCoordsInLoadPart(med_idt fid, const MeshOrStructMeshCls *mId, const std::string& mName, const std::vector<std::string>& infosOnComp, const std::vector<INTERP_KERNEL::NormalizedCellType>& types, const std::vector<mcIdType>& slicPerTyp, int dt, int it, MEDFileMeshReadSelector *mrs)
+void MEDFileUMeshL2::dealWithCoordsInLoadPart(med_idt fid, const MeshOrStructMeshCls * /*mId*/, const std::string& mName, const std::vector<std::string>& infosOnComp, const std::vector<INTERP_KERNEL::NormalizedCellType>& /*types*/, const std::vector<mcIdType>& /*slicPerTyp*/, int dt, int it, MEDFileMeshReadSelector *mrs)
{
med_bool changement,transformation;
- mcIdType nCoords(MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,MED_COORDINATE,MED_NO_CMODE,&changement,&transformation));
+ mcIdType const nCoords(MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,MED_COORDINATE,MED_NO_CMODE,&changement,&transformation));
std::vector<bool> fetchedNodeIds(nCoords,false);
- for(std::vector< std::vector< MCAuto<MEDFileUMeshPerType> > >::const_iterator it0=_per_type_mesh.begin();it0!=_per_type_mesh.end();it0++)
- for(std::vector< MCAuto<MEDFileUMeshPerType> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
- (*it1)->getMesh()->computeNodeIdsAlg(fetchedNodeIds);
+ for(const auto & it0 : _per_type_mesh)
+ for(const auto & it1 : it0)
+ it1->getMesh()->computeNodeIdsAlg(fetchedNodeIds);
if(!mrs || mrs->getNumberOfCoordsLoadSessions()==1)
{
- mcIdType nMin(ToIdType(std::distance(fetchedNodeIds.begin(),std::find(fetchedNodeIds.begin(),fetchedNodeIds.end(),true))));
+ mcIdType const nMin(ToIdType(std::distance(fetchedNodeIds.begin(),std::find(fetchedNodeIds.begin(),fetchedNodeIds.end(),true))));
mcIdType nMax(ToIdType(std::distance(fetchedNodeIds.rbegin(),std::find(fetchedNodeIds.rbegin(),fetchedNodeIds.rend(),true))));
nMax=nCoords-nMax;
- for(std::vector< std::vector< MCAuto<MEDFileUMeshPerType> > >::const_iterator it0=_per_type_mesh.begin();it0!=_per_type_mesh.end();it0++)
- for(std::vector< MCAuto<MEDFileUMeshPerType> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
- (*it1)->getMesh()->renumberNodesWithOffsetInConn(-nMin);
+ for(const auto & it0 : _per_type_mesh)
+ for(const auto & it1 : it0)
+ it1->getMesh()->renumberNodesWithOffsetInConn(-nMin);
this->loadPartCoords(fid,infosOnComp,mName,dt,it,nMin,nMax);
}
else
{
- mcIdType nbOfCooLS(mrs->getNumberOfCoordsLoadSessions());
+ mcIdType const nbOfCooLS(mrs->getNumberOfCoordsLoadSessions());
MCAuto<DataArrayIdType> fni(DataArrayIdType::BuildListOfSwitchedOn(fetchedNodeIds));
MCAuto< MapKeyVal<mcIdType, mcIdType> > o2n(fni->invertArrayN2O2O2NOptimized());
- for(std::vector< std::vector< MCAuto<MEDFileUMeshPerType> > >::const_iterator it0=_per_type_mesh.begin();it0!=_per_type_mesh.end();it0++)
- for(std::vector< MCAuto<MEDFileUMeshPerType> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
- (*it1)->getMesh()->renumberNodesInConn(o2n->data());
+ for(const auto & it0 : _per_type_mesh)
+ for(const auto & it1 : it0)
+ it1->getMesh()->renumberNodesInConn(o2n->data());
this->loadPartCoordsSlice(fid,infosOnComp,mName,dt,it,fni,nbOfCooLS);
}
}
void MEDFileUMeshL2::loadPart(med_idt fid, const MeshOrStructMeshCls *mId, const std::string& mName, const std::vector<INTERP_KERNEL::NormalizedCellType>& types, const std::vector<mcIdType>& slicPerTyp, int dt, int it, MEDFileMeshReadSelector *mrs)
{
int Mdim;
- std::vector<std::string> infosOnComp(loadPartConnectivityOnly(fid,mId,mName,types,slicPerTyp,dt,it,mrs,Mdim));
+ std::vector<std::string> const infosOnComp(loadPartConnectivityOnly(fid,mId,mName,types,slicPerTyp,dt,it,mrs,Mdim));
if(Mdim==-4)
return ;
loadPartOfConnectivity(fid,Mdim,mName,types,slicPerTyp,dt,it,mrs);
void MEDFileUMeshL2::loadPartFromUserDistrib(med_idt fid, const MeshOrStructMeshCls *mId, const std::string& mName, const std::map<INTERP_KERNEL::NormalizedCellType,std::vector<mcIdType>>& distrib, int dt, int it, MEDFileMeshReadSelector *mrs)
{
int Mdim;
- std::vector<std::string> infosOnComp(loadCommonPart(fid,mId,mName,dt,it,Mdim));
+ std::vector<std::string> const infosOnComp(loadCommonPart(fid,mId,mName,dt,it,Mdim));
if(Mdim==-4)
return ;
/* Second step : loading nodes */
med_bool changement,transformation;
- mcIdType nCoords(MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,MED_COORDINATE,MED_NO_CMODE,&changement,&transformation));
+ mcIdType const nCoords(MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,MED_COORDINATE,MED_NO_CMODE,&changement,&transformation));
std::vector<bool> fetchedNodeIds(nCoords,false);
- for(std::vector< std::vector< MCAuto<MEDFileUMeshPerType> > >::const_iterator it0=_per_type_mesh.begin();it0!=_per_type_mesh.end();it0++)
- for(std::vector< MCAuto<MEDFileUMeshPerType> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
- (*it1)->getMesh()->computeNodeIdsAlg(fetchedNodeIds); // for each node in the original mesh, which ones are laying on the current single geometrical type partial mesh
+ for(const auto & it0 : _per_type_mesh)
+ for(const auto & it1 : it0)
+ it1->getMesh()->computeNodeIdsAlg(fetchedNodeIds); // for each node in the original mesh, which ones are laying on the current single geometrical type partial mesh
if(!mrs || mrs->getNumberOfCoordsLoadSessions()==1)
{
// thus we want each node to be renumbered so that the sequence of their numbers form a range
MCAuto<DataArrayIdType> fni(DataArrayIdType::BuildListOfSwitchedOn(fetchedNodeIds));
MCAuto< MapKeyVal<mcIdType, mcIdType> > o2n(fni->invertArrayN2O2O2NOptimized());
- for(std::vector< std::vector< MCAuto<MEDFileUMeshPerType> > >::const_iterator it0=_per_type_mesh.begin();it0!=_per_type_mesh.end();it0++)
- for(std::vector< MCAuto<MEDFileUMeshPerType> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
- (*it1)->getMesh()->renumberNodesInConn(o2n->data());
+ for(const auto & it0 : _per_type_mesh)
+ for(const auto & it1 : it0)
+ it1->getMesh()->renumberNodesInConn(o2n->data());
// loading coordinates of fetched nodes
std::vector<mcIdType> distribNodes;
void MEDFileUMeshL2::loadPartOfConnectivity(med_idt fid, int mdim, const std::string& mName, const std::vector<INTERP_KERNEL::NormalizedCellType>& types, const std::vector<mcIdType>& slicPerTyp, int dt, int it, MEDFileMeshReadSelector *mrs)
{
- std::size_t nbOfTypes(types.size());
+ std::size_t const nbOfTypes(types.size());
if(slicPerTyp.size()!=3*nbOfTypes)
throw INTERP_KERNEL::Exception("MEDFileUMeshL2::loadPartOfConnectivity : The size of slicPerTyp array is expected to be equal to 3 times size of array types !");
- std::set<INTERP_KERNEL::NormalizedCellType> types2(types.begin(),types.end());
+ std::set<INTERP_KERNEL::NormalizedCellType> const types2(types.begin(),types.end());
if(types2.size()!=nbOfTypes)
throw INTERP_KERNEL::Exception("MEDFileUMeshL2::loadPartOfConnectivity : the geometric types in types array must appear once !");
_per_type_mesh.resize(1);
for(std::size_t ii=0;ii<nbOfTypes;ii++)
{
mcIdType strt(slicPerTyp[3*ii+0]),stp(slicPerTyp[3*ii+1]),step(slicPerTyp[3*ii+2]);
- MCAuto<MEDFileUMeshPerType> tmp(MEDFileUMeshPerType::NewPart(fid,mName.c_str(),dt,it,mdim,types[ii],strt,stp,step,mrs));
+ MCAuto<MEDFileUMeshPerType> const tmp(MEDFileUMeshPerType::NewPart(fid,mName.c_str(),dt,it,mdim,types[ii],strt,stp,step,mrs));
_per_type_mesh[0].push_back(tmp);
}
sortTypes();
std::map<INTERP_KERNEL::NormalizedCellType,std::vector<mcIdType>>::const_iterator iter;
for (iter = distrib.begin(); iter != distrib.end(); iter++)
{
- MCAuto<MEDFileUMeshPerType> tmp(MEDFileUMeshPerType::NewPart(fid,mName.c_str(),dt,it,mdim,iter->first/*type*/,iter->second/*distrib over the current type*/,mrs));
+ MCAuto<MEDFileUMeshPerType> const tmp(MEDFileUMeshPerType::NewPart(fid,mName.c_str(),dt,it,mdim,iter->first/*type*/,iter->second/*distrib over the current type*/,mrs));
_per_type_mesh[0].push_back(tmp);
}
sortTypes();
void MEDFileUMeshL2::loadCoords(med_idt fid, const std::vector<std::string>& infosOnComp, const std::string& mName, int dt, int it)
{
- int spaceDim((int)infosOnComp.size());
+ int const spaceDim((int)infosOnComp.size());
med_bool changement,transformation;
- med_int nCoords(MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,MED_COORDINATE,MED_NO_CMODE,&changement,&transformation));
+ med_int const nCoords(MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,MED_COORDINATE,MED_NO_CMODE,&changement,&transformation));
_coords=DataArrayDouble::New();
_coords->alloc(nCoords,spaceDim);
double *coordsPtr(_coords->getPointer());
_fam_coords=FromMedIntArray<mcIdType>(miFamCoord);
}
else
- _fam_coords=0;
+ _fam_coords=nullptr;
if(MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_NODE,MED_NO_GEOTYPE,MED_NUMBER,MED_NODAL,&changement,&transformation)>0)
{
MCAuto<DataArrayMedInt> miNumCoord=DataArrayMedInt::New();
_num_coords=FromMedIntArray<mcIdType>(miNumCoord);
}
else
- _num_coords=0;
+ _num_coords=nullptr;
if(MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_NODE,MED_NO_GEOTYPE,MED_NAME,MED_NODAL,&changement,&transformation)>0)
{
_name_coords=DataArrayAsciiChar::New();
_name_coords->reAlloc(nCoords);//not a bug to avoid the memory corruption due to last \0 at the end
}
else
- _name_coords=0;
+ _name_coords=nullptr;
if(MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_NODE,MED_NO_GEOTYPE,MED_GLOBAL_NUMBER,MED_NODAL,&changement,&transformation)>0)
{
MCAuto<DataArrayMedInt> miNumCoord=DataArrayMedInt::New();
void MEDFileUMeshL2::LoadPartCoords(med_idt fid, const std::vector<std::string>& infosOnComp, const std::string& mName, int dt, int it, const std::vector<mcIdType>& distribNodes,
MCAuto<DataArrayDouble>& _coords, MCAuto<PartDefinition>& _part_coords, MCAuto<DataArrayIdType>& _fam_coords, MCAuto<DataArrayIdType>& _num_coords, MCAuto<DataArrayAsciiChar>& _name_coords)
{
- med_int spaceDim((int)infosOnComp.size());
+ med_int const spaceDim((int)infosOnComp.size());
allocCoordsPartCoords(spaceDim,distribNodes,_coords,_part_coords);
_coords->setInfoOnComponents(infosOnComp);
fillPartCoords(fid,spaceDim,mName,dt,it,_part_coords,_coords,_fam_coords,_num_coords,_name_coords);
void MEDFileUMeshL2::LoadPartCoords(med_idt fid, const std::vector<std::string>& infosOnComp, const std::string& mName, int dt, int it, mcIdType nMin, mcIdType nMax,
MCAuto<DataArrayDouble>& _coords, MCAuto<PartDefinition>& _part_coords, MCAuto<DataArrayIdType>& _fam_coords, MCAuto<DataArrayIdType>& _num_coords, MCAuto<DataArrayAsciiChar>& _name_coords)
{
- med_int spaceDim((int)infosOnComp.size());
+ med_int const spaceDim((int)infosOnComp.size());
allocCoordsPartCoords(spaceDim,nMin,nMax,_coords,_part_coords);
_coords->setInfoOnComponents(infosOnComp);
fillPartCoords(fid,spaceDim,mName,dt,it,_part_coords,_coords,_fam_coords,_num_coords,_name_coords);
*/
void MEDFileUMeshL2::allocCoordsPartCoords(mcIdType spaceDim, const std::vector<mcIdType>& nodeIds, MCAuto<DataArrayDouble>& _coords, MCAuto<PartDefinition>& _part_coords)
{
- mcIdType nbNodesToLoad(nodeIds.size());
+ mcIdType const nbNodesToLoad(nodeIds.size());
_coords=DataArrayDouble::New();
_coords->alloc(nbNodesToLoad,spaceDim);
void MEDFileUMeshL2::allocCoordsPartCoords(mcIdType spaceDim, mcIdType nMin, mcIdType nMax, MCAuto<DataArrayDouble>& _coords, MCAuto<PartDefinition>& _part_coords)
{
_coords=DataArrayDouble::New();
- mcIdType nbNodesToLoad(nMax-nMin);
+ mcIdType const nbNodesToLoad(nMax-nMin);
_coords->alloc(nbNodesToLoad,spaceDim);
_part_coords=PartDefinition::New(nMin,nMax,1);
MCAuto<DataArrayDouble>& _coords, MCAuto<DataArrayIdType>& _fam_coords, MCAuto<DataArrayIdType>& _num_coords, MCAuto<DataArrayAsciiChar>& _name_coords)
{
med_bool changement,transformation;
- med_int nCoords(MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,MED_COORDINATE,MED_NO_CMODE,&changement,&transformation));
- mcIdType nbNodesToLoad = partCoords->getNumberOfElems();
+ med_int const nCoords(MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,MED_COORDINATE,MED_NO_CMODE,&changement,&transformation));
+ mcIdType const nbNodesToLoad = partCoords->getNumberOfElems();
// Based on the ids in \a partCoords, defining the appropriate med_filter (filter of block if the ids form a slice, a generic filter otherwise)
{
mcIdType partStart,partStop;
DataArray::GetSlice(nMin,nMax,1,ipart,nbOfCoordLS,partStart,partStop);
MCAuto<DataArrayIdType> idsNodeIdsToKeep(nodeIds->findIdsInRange(partStart,partStop));
- MCAuto<DataArrayIdType> nodeIdsToKeep( nodeIds->selectByTupleIdSafe(idsNodeIdsToKeep->begin(),idsNodeIdsToKeep->end()) );
+ MCAuto<DataArrayIdType> const nodeIdsToKeep( nodeIds->selectByTupleIdSafe(idsNodeIdsToKeep->begin(),idsNodeIdsToKeep->end()) );
LoadPartCoordsArray(fid,infosOnComp,mName,dt,it,nodeIdsToKeep,coords[ipart],famCoords[ipart],numCoords[ipart],nameCoords[ipart]);
}
_coords = DataArrayDouble::Aggregate(ToConstVect<DataArrayDouble>(coords));
void MEDFileUMeshL2::sortTypes()
{
std::set<int> mdims;
- std::vector< MCAuto<MEDFileUMeshPerType> > tmp(_per_type_mesh[0]);
+ std::vector< MCAuto<MEDFileUMeshPerType> > const tmp(_per_type_mesh[0]);
_per_type_mesh.clear();
- for(std::vector< MCAuto<MEDFileUMeshPerType> >::const_iterator it=tmp.begin();it!=tmp.end();it++)
- mdims.insert((*it)->getDim());
+ for(const auto & it : tmp)
+ mdims.insert(it->getDim());
if(mdims.empty())
return;
- int mdim=*mdims.rbegin();
+ int const mdim=*mdims.rbegin();
_per_type_mesh.resize(mdim+1);
for(int dim=mdim+1;dim!=0;dim--)
{
std::vector< MCAuto<MEDFileUMeshPerType> >& elt=_per_type_mesh[mdim+1-dim];
- for(std::vector< MCAuto<MEDFileUMeshPerType> >::const_iterator it=tmp.begin();it!=tmp.end();it++)
- if((*it)->getDim()==dim-1)
- elt.push_back(*it);
+ for(const auto & it : tmp)
+ if(it->getDim()==dim-1)
+ elt.push_back(it);
}
// suppression of contiguous empty levels at the end of _per_type_mesh.
int nbOfUselessLev=0;
bool isFirst=true;
- for(std::vector< std::vector< MCAuto<MEDFileUMeshPerType> > >::reverse_iterator it2=_per_type_mesh.rbegin();it2!=_per_type_mesh.rend();it2++)
+ for(auto it2=_per_type_mesh.rbegin();it2!=_per_type_mesh.rend();it2++)
{
if((*it2).empty() && isFirst)
{
bool MEDFileUMeshL2::isFamDefinedOnLev(int levId) const
{
- for(std::vector< MCAuto<MEDFileUMeshPerType> >::const_iterator it=_per_type_mesh[levId].begin();it!=_per_type_mesh[levId].end();it++)
- if((*it)->getFam()==0)
+ for(const auto & it : _per_type_mesh[levId])
+ if(it->getFam()==nullptr)
return false;
return true;
}
bool MEDFileUMeshL2::isNumDefinedOnLev(int levId) const
{
- for(std::vector< MCAuto<MEDFileUMeshPerType> >::const_iterator it=_per_type_mesh[levId].begin();it!=_per_type_mesh[levId].end();it++)
- if((*it)->getNum()==0)
+ for(const auto & it : _per_type_mesh[levId])
+ if(it->getNum()==nullptr)
return false;
return true;
}
bool MEDFileUMeshL2::isNamesDefinedOnLev(int levId) const
{
- for(std::vector< MCAuto<MEDFileUMeshPerType> >::const_iterator it=_per_type_mesh[levId].begin();it!=_per_type_mesh[levId].end();it++)
- if((*it)->getNames()==0)
+ for(const auto & it : _per_type_mesh[levId])
+ if(it->getNames()==nullptr)
return false;
return true;
}
_cmesh=MEDCouplingCMesh::New();
for(int i=0;i<Mdim;i++)
{
- med_data_type dataTypeReq=GetDataTypeCorrespondingToSpaceId(i);
+ med_data_type const dataTypeReq=GetDataTypeCorrespondingToSpaceId(i);
med_bool chgt=MED_FALSE,trsf=MED_FALSE;
- med_int nbOfElt(MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,dataTypeReq,MED_NO_CMODE,&chgt,&trsf));
+ med_int const nbOfElt(MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,dataTypeReq,MED_NO_CMODE,&chgt,&trsf));
MCAuto<DataArrayDouble> da=DataArrayDouble::New();
da->alloc(nbOfElt,1);
da->setInfoOnComponent(0,infosOnComp[i]);
}
MEDFileCLMeshL2::MEDFileCLMeshL2()
-{
-}
+= default;
void MEDFileCLMeshL2::loadAll(med_idt fid, const MeshOrStructMeshCls *mId, const std::string& mName, int dt, int it)
{
int Mdim;
MEDCoupling::MEDCouplingMeshType meshType;
MEDCoupling::MEDCouplingAxisType dummy3;
- std::vector<std::string> infosOnComp(getAxisInfoOnMesh(fid,mId,mName,meshType,dummy3,nstep,Mdim));
+ std::vector<std::string> const infosOnComp(getAxisInfoOnMesh(fid,mId,mName,meshType,dummy3,nstep,Mdim));
if(meshType!=CURVE_LINEAR)
throw INTERP_KERNEL::Exception("Invalid mesh type ! You are expected a structured one whereas in file it is not a structured !");
_time=mId->checkMeshTimeStep(fid,mName,nstep,dt,it);
MCAuto<DataArrayIdType> stGrid=FromMedIntArray<mcIdType>(miStGrid);
_clmesh->setNodeGridStructure(stGrid->begin(),stGrid->end());
med_bool chgt=MED_FALSE,trsf=MED_FALSE;
- med_int nbNodes(MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,MED_COORDINATE,MED_NO_CMODE,&chgt,&trsf));
+ med_int const nbNodes(MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,MED_COORDINATE,MED_NO_CMODE,&chgt,&trsf));
MCAuto<DataArrayDouble> da=DataArrayDouble::New();
da->alloc(nbNodes,infosOnComp.size());
da->setInfoOnComponents(infosOnComp);
MEDFileUMeshPermCompute::operator MEDCouplingUMesh *() const
{
_st->_num->updateTime();
- if((MEDCouplingUMesh *)_m==0)
+ if((MEDCouplingUMesh *)_m==nullptr)
{
updateTime();
_m=static_cast<MEDCouplingUMesh *>(_st->_m_by_types.getUmesh()->deepCopy());
{
}
-MEDFileUMeshSplitL1::MEDFileUMeshSplitL1(const MEDFileUMeshL2& l2, const std::string& mName, int id):_m(this)
+MEDFileUMeshSplitL1::MEDFileUMeshSplitL1(const MEDFileUMeshL2& l2, const std::string& /*mName*/, int id):_m(this)
{
const std::vector< MCAuto<MEDFileUMeshPerType> >& v=l2.getLev(id);
if(v.empty())
return;
- std::size_t sz=v.size();
+ std::size_t const sz=v.size();
std::vector<const MEDCoupling1GTUMesh *> ms(sz);
std::vector<const DataArrayIdType *> fams(sz),nums(sz);
std::vector<const DataArrayChar *> names(sz);
{
if (!_fam || _fam->getNumberOfTuples() != getSize())
throw INTERP_KERNEL::Exception("MEDFileUMeshSplitL1::checkConsistency(): internal family array has an invalid size!");
- mcIdType nbCells = getSize();
+ mcIdType const nbCells = getSize();
if (_num)
{
_num->checkNbOfTuplesAndComp(nbCells,1,"MEDFileUMeshSplitL1::checkConsistency(): inconsistent internal node numbering array!");
mcIdType pos;
- mcIdType maxValue=_num->getMaxValue(pos);
+ mcIdType const maxValue=_num->getMaxValue(pos);
if (!_rev_num || _rev_num->getNumberOfTuples() != (maxValue+1))
throw INTERP_KERNEL::Exception("MEDFileUMeshSplitL1::checkConsistency(): inconsistent internal revert node numbering array!");
}
return false;
const DataArrayIdType *d1=_fam;
const DataArrayIdType *d2=other->_fam;
- if((d1==0 && d2!=0) || (d1!=0 && d2==0))
+ if((d1==nullptr && d2!=nullptr) || (d1!=nullptr && d2==nullptr))
{
what="Presence of family arr in one sublevel and not in other!";
return false;
}
d1=_num;
d2=other->_num;
- if((d1==0 && d2!=0) || (d1!=0 && d2==0))
+ if((d1==nullptr && d2!=nullptr) || (d1!=nullptr && d2==nullptr))
{
what="Presence of cell numbering arr in one sublevel and not in other!";
return false;
}
const DataArrayAsciiChar *e1=_names;
const DataArrayAsciiChar *e2=other->_names;
- if((e1==0 && e2!=0) || (e1!=0 && e2==0))
+ if((e1==nullptr && e2!=nullptr) || (e1!=nullptr && e2==nullptr))
{
what="Presence of cell names arr in one sublevel and not in other!";
return false;
void MEDFileUMeshSplitL1::simpleRepr(std::ostream& oss) const
{
std::vector<mcIdType> code=_m_by_types.getDistributionOfTypes();
- std::size_t nbOfTypes=code.size()/3;
+ std::size_t const nbOfTypes=code.size()/3;
for(std::size_t i=0;i<nbOfTypes;i++)
{
- INTERP_KERNEL::NormalizedCellType typ=(INTERP_KERNEL::NormalizedCellType) code[3*i];
+ auto typ=(INTERP_KERNEL::NormalizedCellType) code[3*i];
oss << " - Number of cells with type " << INTERP_KERNEL::CellModel::GetCellModel(typ).getRepr() << " : " << code[3*i+1] << std::endl;
}
}
MEDCouplingUMesh *MEDFileUMeshSplitL1::getFamilyPart(const mcIdType *idsBg, const mcIdType *idsEnd, bool renum) const
{
MCAuto<DataArrayIdType> eltsToKeep=_fam->findIdsEqualList(idsBg,idsEnd);
- MEDCouplingUMesh *m=(MEDCouplingUMesh *)_m_by_types.getUmesh()->buildPartOfMySelf(eltsToKeep->begin(),eltsToKeep->end(),true);
+ auto *m=(MEDCouplingUMesh *)_m_by_types.getUmesh()->buildPartOfMySelf(eltsToKeep->begin(),eltsToKeep->end(),true);
if(renum)
return renumIfNeeded(m,eltsToKeep->begin());
return m;
{
const DataArrayIdType *fam(_fam);
if(!fam)
- return 0;
+ return nullptr;
mcIdType start(0),stop(0);
_m_by_types.getStartStopOfGeoTypeWithoutComputation(gt,start,stop);
return fam->selectByTupleIdSafeSlice(start,stop,1);
{
const DataArrayIdType *num(_num);
if(!num)
- return 0;
+ return nullptr;
mcIdType start(0),stop(0);
_m_by_types.getStartStopOfGeoTypeWithoutComputation(gt,start,stop);
return num->selectByTupleIdSafeSlice(start,stop,1);
{
if((DataArrayIdType *)_fam)
return _fam;
- mcIdType nbOfTuples=_m_by_types.getSize();
+ mcIdType const nbOfTuples=_m_by_types.getSize();
_fam=DataArrayIdType::New(); _fam->alloc(nbOfTuples,1); _fam->fillWithZero();
return _fam;
}
* This method ignores _m and _m_by_types.
*/
void MEDFileUMeshSplitL1::setGroupsFromScratch(const std::vector<const MEDCouplingUMesh *>& ms, std::map<std::string,mcIdType>& familyIds,
- std::map<std::string, std::vector<std::string> >& groups)
+ std::map<std::string, std::vector<std::string> >& /*groups*/)
{
std::vector< DataArrayIdType * > corr;
_m=MEDCouplingUMesh::FuseUMeshesOnSameCoords(ms,0,corr);
- std::vector< MCAuto<DataArrayIdType> > corrMSafe(corr.begin(),corr.end());
+ std::vector< MCAuto<DataArrayIdType> > const corrMSafe(corr.begin(),corr.end());
std::vector< std::vector<mcIdType> > fidsOfGroups;
- std::vector< const DataArrayIdType * > corr2(corr.begin(),corr.end());
+ std::vector< const DataArrayIdType * > const corr2(corr.begin(),corr.end());
_fam=DataArrayIdType::MakePartition(corr2,((MEDCouplingUMesh *)_m)->getNumberOfCells(),fidsOfGroups);
- mcIdType nbOfCells=((MEDCouplingUMesh *)_m)->getNumberOfCells();
+ mcIdType const nbOfCells=((MEDCouplingUMesh *)_m)->getNumberOfCells();
std::map<mcIdType,std::string> newfams;
std::map<mcIdType,mcIdType> famIdTrad;
TraduceFamilyNumber(fidsOfGroups,familyIds,famIdTrad,newfams);
void MEDFileUMeshSplitL1::checkCoordsConsistency(const DataArrayDouble *coords) const
{
- std::vector<MEDCoupling1GTUMesh *> ms(_m_by_types.getParts());
+ std::vector<MEDCoupling1GTUMesh *> const ms(_m_by_types.getParts());
for(auto mesh : ms)
{
if(mesh)
void MEDFileUMeshSplitL1::write(med_idt fid, const std::string& mName, int mdim) const
{
- std::vector<MEDCoupling1GTUMesh *> ms(_m_by_types.getParts());
+ std::vector<MEDCoupling1GTUMesh *> const ms(_m_by_types.getParts());
mcIdType start=0;
- for(std::vector<MEDCoupling1GTUMesh *>::const_iterator it=ms.begin();it!=ms.end();it++)
+ for(auto m : ms)
{
- mcIdType nbCells=(*it)->getNumberOfCells();
- mcIdType end=start+nbCells;
+ mcIdType const nbCells=m->getNumberOfCells();
+ mcIdType const end=start+nbCells;
MCAuto<DataArrayIdType> fam,num;
MCAuto<DataArrayAsciiChar> names;
if((const DataArrayIdType *)_fam)
num=_num->subArray(start,end);
if((const DataArrayAsciiChar *)_names)
names=static_cast<DataArrayAsciiChar *>(_names->subArray(start,end));
- MEDFileUMeshPerType::Write(fid,mName,mdim,(*it),fam,num,names);
+ MEDFileUMeshPerType::Write(fid,mName,mdim,m,fam,num,names);
start=end;
}
}
{
if(!famArr)
{
- _fam=0;
+ _fam=nullptr;
return ;
}
- mcIdType sz(_m_by_types.getSize());
+ mcIdType const sz(_m_by_types.getSize());
famArr->checkNbOfTuplesAndComp(sz,1,"MEDFileUMeshSplitL1::setFamilyArr : Problem in size of Family arr ! ");
famArr->incrRef();
_fam=famArr;
{
if(!renumArr)
{
- _num=0;
- _rev_num=0;
+ _num=nullptr;
+ _rev_num=nullptr;
return ;
}
- mcIdType sz(_m_by_types.getSize());
+ mcIdType const sz(_m_by_types.getSize());
renumArr->checkNbOfTuplesAndComp(sz,1,"MEDFileUMeshSplitL1::setRenumArr : Problem in size of numbering arr ! ");
renumArr->incrRef();
_num=renumArr;
{
if(!nameArr)
{
- _names=0;
+ _names=nullptr;
return ;
}
- mcIdType sz(_m_by_types.getSize());
+ mcIdType const sz(_m_by_types.getSize());
nameArr->checkNbOfTuplesAndComp(sz,MED_SNAME_SIZE,"MEDFileUMeshSplitL1::setNameArr : Problem in size of name arr ! ");
nameArr->incrRef();
_names=nameArr;
MEDCouplingUMesh *MEDFileUMeshSplitL1::Renumber2(const DataArrayIdType *renum, MEDCouplingUMesh *m, const mcIdType *cellIds)
{
- if(renum==0)
+ if(renum==nullptr)
return m;
- if(cellIds==0)
+ if(cellIds==nullptr)
m->renumberCells(renum->begin(),true);
else
{
DataArrayIdType *MEDFileUMeshSplitL1::Renumber(const DataArrayIdType *renum, const DataArrayIdType *da)
{
- if((const DataArrayIdType *)renum==0)
+ if((const DataArrayIdType *)renum==nullptr)
{
da->incrRef();
return const_cast<DataArrayIdType *>(da);
std::vector<mcIdType> MEDFileUMeshSplitL1::GetNewFamiliesNumber(mcIdType nb, const std::map<std::string,mcIdType>& families)
{
mcIdType id=-1;
- for(std::map<std::string,mcIdType>::const_iterator it=families.begin();it!=families.end();it++)
- id=std::max(id,(*it).second);
+ for(const auto & familie : families)
+ id=std::max(id,familie.second);
if(id==-1)
id=0;
std::vector<mcIdType> ret(nb);
return ret;
}
-void MEDFileUMeshSplitL1::TraduceFamilyNumber(const std::vector< std::vector<mcIdType> >& fidsGrps, std::map<std::string,mcIdType>& familyIds,
- std::map<mcIdType,mcIdType>& famIdTrad, std::map<mcIdType,std::string>& newfams)
+void MEDFileUMeshSplitL1::TraduceFamilyNumber(const std::vector< std::vector<mcIdType> >& /*fidsGrps*/, std::map<std::string,mcIdType>& /*familyIds*/,
+ std::map<mcIdType,mcIdType>& /*famIdTrad*/, std::map<mcIdType,std::string>& /*newfams*/)
{
- std::set<mcIdType> allfids;
+ std::set<mcIdType> const allfids;
//tony
}
mcIdType pos;
if(!_num->empty())
{
- mcIdType maxValue=_num->getMaxValue(pos);
+ mcIdType const maxValue=_num->getMaxValue(pos);
_rev_num=_num->invertArrayN2O2O2N(maxValue+1);
}
else
}
if(_mp_time>=_m_time)
{
- for(std::vector< MCAuto<MEDCoupling1GTUMesh> >::iterator it=_m_parts.begin();it!=_m_parts.end();it++)
+ for(auto & _m_part : _m_parts)
{
- MEDCoupling1GTUMesh *tmp(*it);
+ MEDCoupling1GTUMesh *tmp(_m_part);
if(tmp)
tmp->setName(name);
}
void MEDFileUMeshAggregateCompute::assignParts(const std::vector< const MEDCoupling1GTUMesh * >& mParts)
{
- std::size_t sz(mParts.size());
+ std::size_t const sz(mParts.size());
std::vector< MCAuto<MEDCoupling1GTUMesh> > ret(sz);
for(std::size_t i=0;i<sz;i++)
{
_m_parts=ret;
_part_def.clear(); _part_def.resize(sz);
_mp_time=std::max(_mp_time,_m_time)+1;
- _m=0;
+ _m=nullptr;
}
void MEDFileUMeshAggregateCompute::assignDefParts(const std::vector<const PartDefinition *>& partDefs)
{
if(_mp_time<_m_time)
throw INTERP_KERNEL::Exception("MEDFileUMeshAggregateCompute::assignDefParts : the parts require a computation !");
- std::size_t sz(partDefs.size());
+ std::size_t const sz(partDefs.size());
if(_part_def.size()!=partDefs.size() || _part_def.size()!=_m_parts.size())
throw INTERP_KERNEL::Exception("MEDFileUMeshAggregateCompute::assignDefParts : sizes of vectors of part definition mismatch !");
for(std::size_t i=0;i<sz;i++)
if(_mp_time<=_m_time)
return _m->getNumberOfCells();
mcIdType ret(0);
- for(std::vector< MCAuto<MEDCoupling1GTUMesh> >::const_iterator it=_m_parts.begin();it!=_m_parts.end();it++)
- ret+=(*it)->getNumberOfCells();
+ for(const auto & _m_part : _m_parts)
+ ret+=_m_part->getNumberOfCells();
return ret;
}
{
if(_mp_time>=_m_time)
{
- std::size_t sz(_m_parts.size());
+ std::size_t const sz(_m_parts.size());
std::vector<INTERP_KERNEL::NormalizedCellType> ret(sz);
for(std::size_t i=0;i<sz;i++)
ret[i]=_m_parts[i]->getCellModelEnum();
{
if(_mp_time>=_m_time)
{
- for(std::vector< MCAuto<MEDCoupling1GTUMesh> >::const_iterator it=_m_parts.begin();it!=_m_parts.end();it++)
+ for(const auto & _m_part : _m_parts)
{
- const MEDCoupling1GTUMesh *elt(*it);
+ const MEDCoupling1GTUMesh *elt(_m_part);
if(elt && elt->getCellModelEnum()==ct)
return elt->getNumberOfCells();
}
MEDCoupling1GTUMesh *MEDFileUMeshAggregateCompute::retrievePartWithoutComputation(INTERP_KERNEL::NormalizedCellType gt) const
{
std::vector<MEDCoupling1GTUMesh *> v(retrievePartsWithoutComputation());
- std::size_t sz(v.size());
+ std::size_t const sz(v.size());
for(std::size_t i=0;i<sz;i++)
{
if(v[i])
{
start=0; stop=0;
std::vector<MEDCoupling1GTUMesh *> v(retrievePartsWithoutComputation());
- std::size_t sz(v.size());
+ std::size_t const sz(v.size());
for(std::size_t i=0;i<sz;i++)
{
if(v[i])
{
if(_mp_time>_m_time)
{
- for(std::vector< MCAuto<MEDCoupling1GTUMesh> >::iterator it=_m_parts.begin();it!=_m_parts.end();it++)
+ for(auto & _m_part : _m_parts)
{
- MEDCoupling1GTUMesh *m(*it);
+ MEDCoupling1GTUMesh *m(_m_part);
if(m)
m->renumberNodesInConn(newNodeNumbersO2N);
}
return ;// no needs to compte parts they are already here !
}
std::vector<MEDCouplingUMesh *> ms(m->splitByType());
- std::vector< MCAuto<MEDCouplingUMesh> > msMSafe(ms.begin(),ms.end());
- std::size_t sz(msMSafe.size());
+ std::vector< MCAuto<MEDCouplingUMesh> > const msMSafe(ms.begin(),ms.end());
+ std::size_t const sz(msMSafe.size());
_m_parts.resize(sz);
for(std::size_t i=0;i<sz;i++)
_m_parts[i]=MEDCoupling1GTUMesh::New(ms[i]);
throw INTERP_KERNEL::Exception("MEDFileUMeshAggregateCompute::getPartDefOfWithoutComputation : the parts require a computation !");
if(_m_parts.size()!=_part_def.size())
throw INTERP_KERNEL::Exception("MEDFileUMeshAggregateCompute::getPartDefOfWithoutComputation : size of arrays are expected to be the same !");
- std::size_t sz(_m_parts.size());
+ std::size_t const sz(_m_parts.size());
for(std::size_t i=0;i<sz;i++)
{
const MEDCoupling1GTUMesh *mesh(_m_parts[i]);
{
if(_mp_time<_m_time)
throw INTERP_KERNEL::Exception("MEDFileUMeshAggregateCompute::serialize : the parts require a computation !");
- std::size_t sz(_m_parts.size());
+ std::size_t const sz(_m_parts.size());
tinyInt.push_back((mcIdType)sz);
for(std::size_t i=0;i<sz;i++)
{
if(!mesh)
throw INTERP_KERNEL::Exception("MEDFileUMeshAggregateCompute::serialize : one part is empty !");
tinyInt.push_back(mesh->getCellModelEnum());
- const MEDCoupling1SGTUMesh *mesh1(dynamic_cast<const MEDCoupling1SGTUMesh *>(mesh));
- const MEDCoupling1DGTUMesh *mesh2(dynamic_cast<const MEDCoupling1DGTUMesh *>(mesh));
+ const auto *mesh1(dynamic_cast<const MEDCoupling1SGTUMesh *>(mesh));
+ const auto *mesh2(dynamic_cast<const MEDCoupling1DGTUMesh *>(mesh));
if(mesh1)
{
DataArrayIdType *elt(mesh1->getNodalConnectivity());
if(elt)
elt->incrRef();
- MCAuto<DataArrayIdType> elt1(elt);
+ MCAuto<DataArrayIdType> const elt1(elt);
bigArraysI.push_back(elt1);
}
else if(mesh2)
void MEDFileUMeshAggregateCompute::unserialize(const std::string& name, DataArrayDouble *coo, std::vector<mcIdType>& tinyInt, std::vector< MCAuto<DataArrayIdType> >& bigArraysI)
{
- mcIdType nbParts(tinyInt.back()); tinyInt.pop_back();
+ mcIdType const nbParts(tinyInt.back()); tinyInt.pop_back();
_part_def.clear(); _part_def.resize(nbParts);
_m_parts.clear(); _m_parts.resize(nbParts);
for(mcIdType i=0;i<nbParts;i++)
{
- INTERP_KERNEL::NormalizedCellType tp((INTERP_KERNEL::NormalizedCellType) tinyInt.back()); tinyInt.pop_back();
+ auto tp((INTERP_KERNEL::NormalizedCellType) tinyInt.back()); tinyInt.pop_back();
MCAuto<MEDCoupling1GTUMesh> mesh(MEDCoupling1GTUMesh::New(name,tp));
mesh->setCoords(coo);
- MEDCoupling1SGTUMesh *mesh1(dynamic_cast<MEDCoupling1SGTUMesh *>((MEDCoupling1GTUMesh *) mesh));
- MEDCoupling1DGTUMesh *mesh2(dynamic_cast<MEDCoupling1DGTUMesh *>((MEDCoupling1GTUMesh *) mesh));
+ auto *mesh1(dynamic_cast<MEDCoupling1SGTUMesh *>((MEDCoupling1GTUMesh *) mesh));
+ auto *mesh2(dynamic_cast<MEDCoupling1DGTUMesh *>((MEDCoupling1GTUMesh *) mesh));
if(mesh1)
{
mesh1->setNodalConnectivity(bigArraysI.back()); bigArraysI.pop_back();
else
throw INTERP_KERNEL::Exception("MEDFileUMeshAggregateCompute::unserialize : unrecognized single geo type mesh !");
_m_parts[i]=mesh;
- mcIdType pdid(tinyInt.back()); tinyInt.pop_back();
+ mcIdType const pdid(tinyInt.back()); tinyInt.pop_back();
if(pdid!=-1)
_part_def[i]=PartDefinition::Unserialize(tinyInt,bigArraysI);
_mp_time=std::max(_mp_time,_m_time)+1;
std::size_t MEDFileUMeshAggregateCompute::getTimeOfParts() const
{
std::size_t ret(0);
- for(std::vector< MCAuto<MEDCoupling1GTUMesh> >::const_iterator it=_m_parts.begin();it!=_m_parts.end();it++)
+ for(const auto & _m_part : _m_parts)
{
- const MEDCoupling1GTUMesh *elt(*it);
+ const MEDCoupling1GTUMesh *elt(_m_part);
if(!elt)
throw INTERP_KERNEL::Exception("MEDFileUMeshAggregateCompute::getTimeOfParts : null obj in parts !");
ret=std::max(ret,elt->getTimeOfThis());
std::size_t MEDFileUMeshAggregateCompute::getHeapMemorySizeWithoutChildren() const
{
- std::size_t ret(_m_parts.size()*sizeof(MCAuto<MEDCoupling1GTUMesh>));
+ std::size_t const ret(_m_parts.size()*sizeof(MCAuto<MEDCoupling1GTUMesh>));
return ret;
}
std::vector<const BigMemoryObject *> MEDFileUMeshAggregateCompute::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
- for(std::vector< MCAuto<MEDCoupling1GTUMesh> >::const_iterator it=_m_parts.begin();it!=_m_parts.end();it++)
- ret.push_back((const MEDCoupling1GTUMesh *)*it);
+ for(const auto & _m_part : _m_parts)
+ ret.push_back((const MEDCoupling1GTUMesh *)_m_part);
ret.push_back((const MEDCouplingUMesh *)_m);
return ret;
}
ret._m=static_cast<MEDCoupling::MEDCouplingUMesh*>(_m->deepCopy());
ret._m->setCoords(coords);
}
- std::size_t sz(_part_def.size());
+ std::size_t const sz(_part_def.size());
ret._part_def.clear(); ret._part_def.resize(sz);
for(std::size_t i=0;i<sz;i++)
{
void MEDFileUMeshAggregateCompute::shallowCpyMeshes()
{
- for(std::vector< MCAuto<MEDCoupling1GTUMesh> >::iterator it=_m_parts.begin();it!=_m_parts.end();it++)
+ for(auto & _m_part : _m_parts)
{
- const MEDCoupling1GTUMesh *elt(*it);
+ const MEDCoupling1GTUMesh *elt(_m_part);
if(elt)
{
MCAuto<MEDCouplingMesh> elt2(elt->clone(false));
- *it=DynamicCastSafe<MEDCouplingMesh,MEDCoupling1GTUMesh>(elt2);
+ _m_part=DynamicCastSafe<MEDCouplingMesh,MEDCoupling1GTUMesh>(elt2);
}
}
const MEDCouplingUMesh *m(_m);
{
const MEDCouplingUMesh *m1(getUmesh());
const MEDCouplingUMesh *m2(other.getUmesh());
- if((m1==0 && m2!=0) || (m1!=0 && m2==0))
+ if((m1==nullptr && m2!=nullptr) || (m1!=nullptr && m2==nullptr))
{
what="Presence of mesh in one sublevel and not in other!";
return false;
return false;
}
}
- std::size_t sz(_part_def.size());
+ std::size_t const sz(_part_def.size());
if(sz!=other._part_def.size())
{
what=std::string("number of subdivision per geo type for part definition is not the same !");
what=std::string("a cell part def is defined only for one among this or other !");
return false;
}
- bool ret(pd0->isEqual(pd1,what));
+ bool const ret(pd0->isEqual(pd1,what));
if(!ret)
return false;
}
void MEDFileUMeshAggregateCompute::checkConsistency() const
{
if(_mp_time >= _m_time)
- for(std::vector< MCAuto<MEDCoupling1GTUMesh> >::const_iterator it=_m_parts.begin();
- it!=_m_parts.end(); it++)
- (*it)->checkConsistency();
+ for(const auto & _m_part : _m_parts)
+ _m_part->checkConsistency();
else
_m->checkConsistency();
}
void MEDFileUMeshAggregateCompute::clearNonDiscrAttributes() const
{
- for(std::vector< MCAuto<MEDCoupling1GTUMesh> >::const_iterator it=_m_parts.begin();it!=_m_parts.end();it++)
- MEDFileUMeshSplitL1::ClearNonDiscrAttributes(*it);
+ for(const auto & _m_part : _m_parts)
+ MEDFileUMeshSplitL1::ClearNonDiscrAttributes(_m_part);
MEDFileUMeshSplitL1::ClearNonDiscrAttributes(_m);
}
void MEDFileUMeshAggregateCompute::synchronizeTinyInfo(const MEDFileMesh& master) const
{
- for(std::vector< MCAuto<MEDCoupling1GTUMesh> >::const_iterator it=_m_parts.begin();it!=_m_parts.end();it++)
+ for(const auto & _m_part : _m_parts)
{
- const MEDCoupling1GTUMesh *tmp(*it);
+ const MEDCoupling1GTUMesh *tmp(_m_part);
if(tmp)
{
(const_cast<MEDCoupling1GTUMesh *>(tmp))->setName(master.getName().c_str());
bool MEDFileUMeshAggregateCompute::empty() const
{
if(_mp_time<_m_time)
- return ((const MEDCouplingUMesh *)_m)==0;
+ return ((const MEDCouplingUMesh *)_m)==nullptr;
//else _mp_time>=_m_time)
return _m_parts.empty();
}
else
{
std::vector<mcIdType> ret;
- for(std::vector< MCAuto<MEDCoupling1GTUMesh> >::const_iterator it=_m_parts.begin();it!=_m_parts.end();it++)
+ for(const auto & _m_part : _m_parts)
{
- const MEDCoupling1GTUMesh *tmp(*it);
+ const MEDCoupling1GTUMesh *tmp(_m_part);
if(!tmp)
throw INTERP_KERNEL::Exception("MEDFileUMeshAggregateCompute::getDistributionOfTypes : part mesh contains null instance !");
std::vector<mcIdType> ret0(tmp->getDistributionOfTypes());
else
{
mcIdType ret=0;
- for(std::vector< MCAuto<MEDCoupling1GTUMesh> >::const_iterator it=_m_parts.begin();it!=_m_parts.end();it++)
+ for(const auto & _m_part : _m_parts)
{
- const MEDCoupling1GTUMesh *m(*it);
+ const MEDCoupling1GTUMesh *m(_m_part);
if(!m)
throw INTERP_KERNEL::Exception("MEDFileUMeshAggregateCompute::getSize : part mesh contains null instance !");
ret+=m->getNumberOfCells();
void MEDFileUMeshAggregateCompute::setCoords(DataArrayDouble *coords)
{
- for(std::vector< MCAuto<MEDCoupling1GTUMesh> >::iterator it=_m_parts.begin();it!=_m_parts.end();it++)
+ for(auto & _m_part : _m_parts)
{
- MEDCoupling1GTUMesh *tmp(*it);
+ MEDCoupling1GTUMesh *tmp(_m_part);
if(tmp)
- (*it)->setCoords(coords);
+ _m_part->setCoords(coords);
}
MEDCouplingUMesh *m(_m);
if(m)
std::vector<const MEDCoupling::BigMemoryObject*> ret;
ret.push_back(_conn);
ret.push_back(_common);
- for(std::vector< MCAuto<DataArray> >::const_iterator it=_vars.begin();it!=_vars.end();it++)
- ret.push_back(*it);
+ for(const auto & _var : _vars)
+ ret.push_back(_var);
return ret;
}
}
MCAuto<MEDFileMeshSupports> mss(MEDFileMeshSupports::New(fid));
MCAuto<MEDFileStructureElements> mse(MEDFileStructureElements::New(fid,mss));
- mcIdType nbEntities(mse->getNumberOfNodesPerSE(_geo_type_name));
+ mcIdType const nbEntities(mse->getNumberOfNodesPerSE(_geo_type_name));
MCAuto<DataArrayMedInt> miConn=DataArrayMedInt::New(); miConn->alloc(nCells*nbEntities);
MEDFILESAFECALLERRD0(MEDmeshElementConnectivityRd,(fid,mName.c_str(),dt,it,MED_STRUCT_ELEMENT,_geo_type,MED_NODAL,MED_FULL_INTERLACE,miConn->getPointer()));
_conn=FromMedIntArray<mcIdType>(miConn);
_common=MEDFileUMeshPerTypeCommon::New();
_common->loadCommonPart(fid,mName.c_str(),dt,it,nCells,geoType,MED_STRUCT_ELEMENT,mrs);
std::vector<std::string> vns(mse->getVarAttsOf(_geo_type_name));
- std::size_t sz(vns.size());
+ std::size_t const sz(vns.size());
_vars.resize(sz);
for(std::size_t i=0;i<sz;i++)
{
#ifndef __MEDFILEMESHLL_HXX__
#define __MEDFILEMESHLL_HXX__
+#include "MEDCouplingMesh.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MCType.hxx"
#include "MEDFileBasis.hxx"
#include "MEDFileMeshElt.hxx"
#include "InterpKernelAutoPtr.hxx"
+#include "NormalizedGeometricTypes"
#include "med.h"
+#include <cstddef>
#include <map>
+#include <string>
+#include <ostream>
+#include <vector>
+#include <utility>
namespace MEDCoupling
{
protected:
MeshOrStructMeshCls(int mid):_mid(mid) { }
public:
- virtual ~MeshOrStructMeshCls() {}
+ virtual ~MeshOrStructMeshCls() = default;
int getID() const { return _mid; }
virtual std::vector<std::string> getAxisInfoOnMesh(med_idt fid, const std::string& mName, MEDCoupling::MEDCouplingMeshType& meshType, MEDCoupling::MEDCouplingAxisType& axType, int& nstep, int& Mdim, MEDFileString& description, MEDFileString& dtunit, MEDFileString& univName) const = 0;
virtual double checkMeshTimeStep(med_idt fid, const std::string& mName, int nstep, int dt, int it) const = 0;
{
public:
MeshCls(int mid):MeshOrStructMeshCls(mid) { }
- std::vector<std::string> getAxisInfoOnMesh(med_idt fid, const std::string& mName, MEDCoupling::MEDCouplingMeshType& meshType, MEDCoupling::MEDCouplingAxisType& axType, int& nstep, int& Mdim, MEDFileString& description, MEDFileString& dtunit, MEDFileString& univName) const;
- double checkMeshTimeStep(med_idt fid, const std::string& mName, int nstep, int dt, int it) const;
+ std::vector<std::string> getAxisInfoOnMesh(med_idt fid, const std::string& mName, MEDCoupling::MEDCouplingMeshType& meshType, MEDCoupling::MEDCouplingAxisType& axType, int& nstep, int& Mdim, MEDFileString& description, MEDFileString& dtunit, MEDFileString& univName) const override;
+ double checkMeshTimeStep(med_idt fid, const std::string& mName, int nstep, int dt, int it) const override;
};
class StructMeshCls : public MeshOrStructMeshCls
{
public:
StructMeshCls(int mid):MeshOrStructMeshCls(mid) { }
- std::vector<std::string> getAxisInfoOnMesh(med_idt fid, const std::string& mName, MEDCoupling::MEDCouplingMeshType& meshType, MEDCoupling::MEDCouplingAxisType& axType, int& nstep, int& Mdim, MEDFileString& description, MEDFileString& dtunit, MEDFileString& univName) const;
- double checkMeshTimeStep(med_idt fid, const std::string& mName, int nstep, int dt, int it) const;
+ std::vector<std::string> getAxisInfoOnMesh(med_idt fid, const std::string& mName, MEDCoupling::MEDCouplingMeshType& meshType, MEDCoupling::MEDCouplingAxisType& axType, int& nstep, int& Mdim, MEDFileString& description, MEDFileString& dtunit, MEDFileString& univName) const override;
+ double checkMeshTimeStep(med_idt fid, const std::string& mName, int nstep, int dt, int it) const override;
};
class MEDFileMeshL2 : public RefCountObject
{
public:
MEDFileMeshL2();
- std::size_t getHeapMemorySizeWithoutChildren() const;
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
const char *getName() const { return _name.getReprForWrite(); }
const char *getDescription() const { return _description.getReprForWrite(); }
const char *getUnivName() const { return _univ_name.getReprForWrite(); }
operator MEDCouplingUMesh *() const;
void operator=(MEDCouplingUMesh *m);
void updateTime() const;
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- std::size_t getHeapMemorySizeWithoutChildren() const;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
private:
const MEDFileUMeshSplitL1 *_st;
mutable std::size_t _mpt_time;
void renumberNodesInConnWithoutComputation(const mcIdType *newNodeNumbersO2N);
bool isStoredSplitByType() const;
std::size_t getTimeOfThis() const;
- std::size_t getHeapMemorySizeWithoutChildren() const;
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
MEDFileUMeshAggregateCompute deepCopy(DataArrayDouble *coords) const;
void shallowCpyMeshes();
bool isEqual(const MEDFileUMeshAggregateCompute& other, double eps, std::string& what) const;
MEDFileUMeshSplitL1(MEDCouplingUMesh *m, bool newOrOld);
std::string getClassName() const override { return std::string("MEDFileUMeshSplitL1"); }
void setName(const std::string& name);
- std::size_t getHeapMemorySizeWithoutChildren() const;
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
MEDFileUMeshSplitL1 *shallowCpyUsingCoords(DataArrayDouble *coords) const;
MEDFileUMeshSplitL1 *deepCopy(DataArrayDouble *coords) const;
void checkConsistency() const;
MCAuto<MEDFileUMeshPerTypeCommon> getMeshDef() const { return _common; }
const std::vector< MCAuto<DataArray> >& getVars() const { return _vars; }
private:
- std::size_t getHeapMemorySizeWithoutChildren() const;
- std::vector<const MEDCoupling::BigMemoryObject*> getDirectChildrenWithNull() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ std::vector<const MEDCoupling::BigMemoryObject*> getDirectChildrenWithNull() const override;
private:
- ~MEDFileEltStruct4Mesh() { }
+ ~MEDFileEltStruct4Mesh() override = default;
private:
MEDFileEltStruct4Mesh(med_idt fid, const std::string& mName, int dt, int it, int iterOnStEltOfMesh, MEDFileMeshReadSelector *mrs);
private:
#include "MEDFileMeshReadSelector.hxx"
#include "InterpKernelException.hxx"
+#include "MCIdType.hxx"
-#include <sstream>
+#include <ostream>
+#include <string>
using namespace MEDCoupling;
void MEDFileMeshReadSelector::setCellFamilyFieldReading(bool b)
{
unsigned int code(_code & 0xFFFFFFFE);
- unsigned int b2=b?1:0;
+ unsigned int const b2=b?1:0;
//b2<<=0;
code+=b2;
_code=code;
#include "MCIdType.hxx"
+#include <ostream>
#include <string>
namespace MEDCoupling
// Author : Anthony Geay (EDF R&D)
#include "MEDFileMeshSupport.hxx"
+#include "MCAuto.hxx"
+#include "MEDFileUtilities.hxx"
+#include "MCIdType.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "CellModel.hxx"
#include "MEDLoaderBase.hxx"
#include "MEDFileMeshLL.hxx"
#include "MEDFileSafeCaller.txx"
#include "InterpKernelAutoPtr.hxx"
+#include <algorithm>
+#include <iterator>
+#include <string>
+#include "med.h"
+#include "medmesh.h"
+#include <cstddef>
+#include <sstream>
+#include <vector>
+#include "NormalizedGeometricTypes"
using namespace MEDCoupling;
MEDFileMeshSupports *MEDFileMeshSupports::New(const std::string& fileName)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return New(fid);
}
MEDFileMeshSupports::MEDFileMeshSupports(med_idt fid)
{
- med_int nbSM(MEDnSupportMesh(fid));
+ med_int const nbSM(MEDnSupportMesh(fid));
_supports.resize(nbSM);
for(int i=0;i<nbSM;i++)
{
INTERP_KERNEL::AutoPtr<char> msn(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
INTERP_KERNEL::AutoPtr<char> description(MEDLoaderBase::buildEmptyString(MED_COMMENT_SIZE));
med_axis_type axType;
- med_int nAxis(MEDsupportMeshnAxis(fid,i+1));
+ med_int const nAxis(MEDsupportMeshnAxis(fid,i+1));
INTERP_KERNEL::AutoPtr<char> axisName(new char[MED_SNAME_SIZE*nAxis+1]),axisUnit(new char[MED_SNAME_SIZE*nAxis+1]);
med_int spaceDim(0),meshDim(0);
MEDFILESAFECALLERRD0(MEDsupportMeshInfo,(fid,i+1,msn,&spaceDim,&meshDim,description,&axType,axisName,axisUnit));
- std::string name(MEDLoaderBase::buildStringFromFortran(msn,MED_NAME_SIZE));
+ std::string const name(MEDLoaderBase::buildStringFromFortran(msn,MED_NAME_SIZE));
_supports[i]=MEDFileUMesh::New(fid,name);
}
}
MEDFileMeshSupports::MEDFileMeshSupports()
-{
-}
+= default;
MEDFileMeshSupports::~MEDFileMeshSupports()
-{
-}
+= default;
std::vector<const BigMemoryObject *> MEDFileMeshSupports::getDirectChildrenWithNull() const
{
- std::size_t sz(_supports.size());
+ std::size_t const sz(_supports.size());
std::vector<const BigMemoryObject *> ret(sz);
for(std::size_t i=0;i<sz;i++)
ret[i]=_supports[i];
void MEDFileMeshSupports::writeLL(med_idt fid) const
{
- for(std::vector< MCAuto<MEDFileUMesh> >::const_iterator it=_supports.begin();it!=_supports.end();it++)
- if((*it).isNotNull())
- (*it)->writeLL(fid);
+ for(const auto & _support : _supports)
+ if(_support.isNotNull())
+ _support->writeLL(fid);
}
std::vector<std::string> MEDFileMeshSupports::getSupMeshNames() const
{
std::vector<std::string> ret;
- for(std::vector< MCAuto<MEDFileUMesh> >::const_iterator it=_supports.begin();it!=_supports.end();it++)
- if((*it).isNotNull())
- ret.push_back((*it)->getName());
+ for(const auto & _support : _supports)
+ if(_support.isNotNull())
+ ret.push_back(_support->getName());
return ret;
}
const MEDFileUMesh *MEDFileMeshSupports::getSupMeshWithName(const std::string& name) const
{
std::vector<std::string> mns;
- for(std::vector< MCAuto<MEDFileUMesh> >::const_iterator it=_supports.begin();it!=_supports.end();it++)
+ for(const auto & _support : _supports)
{
- if((*it).isNotNull())
+ if(_support.isNotNull())
{
- std::string na((*it)->getName());
+ std::string const na(_support->getName());
if(na==name)
- return *it;
+ return _support;
else
mns.push_back(na);
}
#ifndef __MEDFILEMESHSUPPORT_HXX__
#define __MEDFILEMESHSUPPORT_HXX__
+#include "MCAuto.hxx"
+#include "MEDFileUtilities.hxx"
+#include "MCType.hxx"
#include "MEDLoaderDefines.hxx"
-#include "MEDFileUtilities.txx"
#include "MEDFileMesh.hxx"
#include "MEDCouplingRefCountObject.hxx"
+#include <string>
+#include "med.h"
+#include <cstddef>
+#include <vector>
+#include "NormalizedGeometricTypes"
namespace MEDCoupling
{
MEDLOADER_EXPORT static MEDFileMeshSupports *New();
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileMeshSupports"); }
public:
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDLOADER_EXPORT void writeLL(med_idt fid) const;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDLOADER_EXPORT void writeLL(med_idt fid) const override;
MEDLOADER_EXPORT std::vector<std::string> getSupMeshNames() const;
MEDLOADER_EXPORT const MEDFileUMesh *getSupMeshWithName(const std::string& name) const;
MEDLOADER_EXPORT mcIdType getNumberOfNodesInConnOf(TypeOfField entity, INTERP_KERNEL::NormalizedCellType gt, const std::string& name) const;
private:
MEDFileMeshSupports(med_idt fid);
MEDFileMeshSupports();
- ~MEDFileMeshSupports();
+ ~MEDFileMeshSupports() override;
private:
std::vector< MCAuto<MEDFileUMesh> > _supports;
};
// Author : Anthony Geay (CEA/DEN)
#include "MEDFileParameter.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MCAuto.hxx"
#include "MEDFileSafeCaller.txx"
+#include "MEDFileUtilities.hxx"
#include "MEDLoaderBase.hxx"
#include "MEDFileBasis.hxx"
#include "InterpKernelAutoPtr.hxx"
-
+#include "med.h"
+#include "medparameter.h"
+#include "medfile.h"
+
+#include <cmath>
+#include <cstddef>
+#include <ostream>
+#include <limits>
+#include <iterator>
+#include <algorithm>
#include <set>
+#include <string>
+#include <sstream>
+#include <vector>
+#include <utility>
using namespace MEDCoupling;
{
if(!MEDFileParameter1TS::isEqual(other,eps,what))
return false;
- const MEDFileParameterDouble1TSWTI *otherC=dynamic_cast<const MEDFileParameterDouble1TSWTI *>(other);
+ const auto *otherC=dynamic_cast<const MEDFileParameterDouble1TSWTI *>(other);
if(!otherC)
{ what="IsEqual fails because this is double parameter other no !"; return false; }
if(fabs(_arr-otherC->_arr)>eps)
void MEDFileParameterDouble1TSWTI::simpleRepr2(int bkOffset, std::ostream& oss) const
{
- std::string startOfLine(bkOffset,' ');
+ std::string const startOfLine(bkOffset,' ');
oss << startOfLine << "ParameterDoubleItem with (iteration,order) = (" << _iteration << "," << _order << ")" << std::endl;
oss << startOfLine << "Time associacited = " << _time << std::endl;
oss << startOfLine << "The value is ***** " << _arr << " *****" << std::endl;
void MEDFileParameterTinyInfo::mainRepr(int bkOffset, std::ostream& oss) const
{
- std::string startOfLine(bkOffset,' ');
+ std::string const startOfLine(bkOffset,' ');
oss << startOfLine << "Parameter with name \"" << _name << "\"" << std::endl;
oss << startOfLine << "Parameter with description \"" << _desc_name << "\"" << std::endl;
oss << startOfLine << "Parameter with unit name \"" << _dt_unit << "\"" << std::endl;
}
MEDFileParameterDouble1TS::MEDFileParameterDouble1TS()
-{
-}
+= default;
MEDFileParameterDouble1TS::MEDFileParameterDouble1TS(const std::string& fileName, const std::string& paramName, int dt, int it)
{
MEDFileUtilities::CheckFileForRead(fileName);
- MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
- med_int nbPar=MEDnParameter(fid);
+ MEDFileUtilities::AutoFid const fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
+ med_int const nbPar=MEDnParameter(fid);
std::ostringstream oss; oss << "MEDFileParameterDouble1TS : no double param name \"" << paramName << "\" ! Double Parameters available are : ";
INTERP_KERNEL::AutoPtr<char> pName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
INTERP_KERNEL::AutoPtr<char> descName=MEDLoaderBase::buildEmptyString(MED_COMMENT_SIZE);
{
med_int nbOfSteps;
MEDFILESAFECALLERRD0(MEDparameterInfo,(fid,i+1,pName,¶mType,descName,unitName,&nbOfSteps));
- std::string paramNameCpp=MEDLoaderBase::buildStringFromFortran(pName,MED_NAME_SIZE);
+ std::string const paramNameCpp=MEDLoaderBase::buildStringFromFortran(pName,MED_NAME_SIZE);
if(paramNameCpp==paramName && paramType==MED_FLOAT64)
{
_dt_unit=MEDLoaderBase::buildStringFromFortran(unitName,MED_SNAME_SIZE);
MEDFileParameterDouble1TS::MEDFileParameterDouble1TS(const std::string& fileName, const std::string& paramName)
{
MEDFileUtilities::CheckFileForRead(fileName);
- MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
- med_int nbPar=MEDnParameter(fid);
+ MEDFileUtilities::AutoFid const fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
+ med_int const nbPar=MEDnParameter(fid);
std::ostringstream oss; oss << "MEDFileParameterDouble1TS : no double param name \"" << paramName << "\" ! Double Parameters available are : ";
INTERP_KERNEL::AutoPtr<char> pName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
INTERP_KERNEL::AutoPtr<char> descName=MEDLoaderBase::buildEmptyString(MED_COMMENT_SIZE);
{
med_int nbOfSteps;
MEDFILESAFECALLERRD0(MEDparameterInfo,(fid,i+1,pName,¶mType,descName,unitName,&nbOfSteps));
- std::string paramNameCpp=MEDLoaderBase::buildStringFromFortran(pName,MED_NAME_SIZE);
+ std::string const paramNameCpp=MEDLoaderBase::buildStringFromFortran(pName,MED_NAME_SIZE);
if(paramNameCpp==paramName && paramType==MED_FLOAT64)
{
if(nbOfSteps>0)
MEDFileParameterDouble1TS::MEDFileParameterDouble1TS(const std::string& fileName)
{
MEDFileUtilities::CheckFileForRead(fileName);
- MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
- med_int nbPar=MEDnParameter(fid);
+ MEDFileUtilities::AutoFid const fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
+ med_int const nbPar=MEDnParameter(fid);
if(nbPar<1)
{
std::ostringstream oss2; oss2 << "No parameter in file \"" << fileName << "\" !";
med_parameter_type paramType;
med_int nbOfSteps;
MEDFILESAFECALLERRD0(MEDparameterInfo,(fid,1,pName,¶mType,descName,unitName,&nbOfSteps));
- std::string paramNameCpp=MEDLoaderBase::buildStringFromFortran(pName,MED_NAME_SIZE);
+ std::string const paramNameCpp=MEDLoaderBase::buildStringFromFortran(pName,MED_NAME_SIZE);
if(paramType==MED_FLOAT64)
{
if(nbOfSteps>0)
{
if(!MEDFileParameterDouble1TSWTI::isEqual(other,eps,what))
return false;
- const MEDFileParameterDouble1TS *otherC=dynamic_cast<const MEDFileParameterDouble1TS *>(other);
+ const auto *otherC=dynamic_cast<const MEDFileParameterDouble1TS *>(other);
if(!otherC)
{ what="Other is not of type MEDFileParameterDouble1TS as this"; return false; }
if(!isEqualStrings(*otherC,what))
void MEDFileParameterDouble1TS::write(const std::string& fileName, int mode) const
{
- med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
- MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),medmod);
+ med_access_mode const medmod=MEDFileUtilities::TraduceWriteMode(mode);
+ MEDFileUtilities::AutoFid const fid=MEDfileOpen(fileName.c_str(),medmod);
MEDFileParameterTinyInfo::writeLLHeader(fid,MED_FLOAT64);
MEDFileParameterDouble1TSWTI::writeAdvanced(fid,_name,*this);
}
MEDFileParameterMultiTS *MEDFileParameterMultiTS::New(const std::string& fileName)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return New(fid);
}
MEDFileParameterMultiTS *MEDFileParameterMultiTS::New(const std::string& fileName, const std::string& paramName)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return New(fid,paramName);
}
}
MEDFileParameterMultiTS::MEDFileParameterMultiTS()
-{
-}
+= default;
MEDFileParameterMultiTS::MEDFileParameterMultiTS(const MEDFileParameterMultiTS& other, bool deepCopy):MEDFileParameterTinyInfo(other),_param_per_ts(other._param_per_ts)
{
if(deepCopy)
- for(std::size_t i=0;i<_param_per_ts.size();i++)
+ for(auto & _param_per_t : _param_per_ts)
{
- const MEDFileParameter1TS *elt=_param_per_ts[i];
+ const MEDFileParameter1TS *elt=_param_per_t;
if(elt)
- _param_per_ts[i]=elt->deepCopy();
+ _param_per_t=elt->deepCopy();
}
}
MEDFileParameterMultiTS::MEDFileParameterMultiTS(med_idt fid)
{
- med_int nbPar(MEDnParameter(fid));
+ med_int const nbPar(MEDnParameter(fid));
if(nbPar<1)
{
std::ostringstream oss; oss << "MEDFileParameterMultiTS : no parameter in file \"" << FileNameFromFID(fid) << "\" !" ;
med_parameter_type paramType;
med_int nbOfSteps;
MEDFILESAFECALLERRD0(MEDparameterInfo,(fid,1,pName,¶mType,descName,unitName,&nbOfSteps));
- std::string paramNameCpp(MEDLoaderBase::buildStringFromFortran(pName,MED_NAME_SIZE));
+ std::string const paramNameCpp(MEDLoaderBase::buildStringFromFortran(pName,MED_NAME_SIZE));
_dt_unit=MEDLoaderBase::buildStringFromFortran(unitName,MED_SNAME_SIZE);
_name=paramNameCpp;
_desc_name=MEDLoaderBase::buildStringFromFortran(descName,MED_COMMENT_SIZE);
MEDFileParameterMultiTS::MEDFileParameterMultiTS(med_idt fid, const std::string& paramName)
{
- med_int nbPar(MEDnParameter(fid));
+ med_int const nbPar(MEDnParameter(fid));
std::ostringstream oss; oss << "MEDFileParameterDouble1TS : no double param name \"" << paramName << "\" ! Double Parameters available are : ";
INTERP_KERNEL::AutoPtr<char> pName(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
INTERP_KERNEL::AutoPtr<char> descName(MEDLoaderBase::buildEmptyString(MED_COMMENT_SIZE));
{
med_int nbOfSteps;
MEDFILESAFECALLERRD0(MEDparameterInfo,(fid,i+1,pName,¶mType,descName,unitName,&nbOfSteps));
- std::string paramNameCpp(MEDLoaderBase::buildStringFromFortran(pName,MED_NAME_SIZE));
+ std::string const paramNameCpp(MEDLoaderBase::buildStringFromFortran(pName,MED_NAME_SIZE));
if(paramNameCpp==paramName)
{
if(nbOfSteps>0)
std::vector<const BigMemoryObject *> MEDFileParameterMultiTS::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
- for(std::vector< MCAuto<MEDFileParameter1TS> >::const_iterator it=_param_per_ts.begin();it!=_param_per_ts.end();it++)
- ret.push_back((const MEDFileParameter1TS *)*it);
+ for(const auto & _param_per_t : _param_per_ts)
+ ret.push_back((const MEDFileParameter1TS *)_param_per_t);
return ret;
}
void MEDFileParameterMultiTS::write(const std::string& fileName, int mode) const
{
- med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
- MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),medmod);
+ med_access_mode const medmod=MEDFileUtilities::TraduceWriteMode(mode);
+ MEDFileUtilities::AutoFid const fid=MEDfileOpen(fileName.c_str(),medmod);
writeAdvanced(fid,*this);
}
void MEDFileParameterMultiTS::writeAdvanced(med_idt fid, const MEDFileWritable& mw) const
{
std::set<med_parameter_type> diffType;
- for(std::vector< MCAuto<MEDFileParameter1TS> >::const_iterator it=_param_per_ts.begin();it!=_param_per_ts.end();it++)
+ for(const auto & _param_per_t : _param_per_ts)
{
- const MEDFileParameter1TS *elt(*it);
+ const MEDFileParameter1TS *elt(_param_per_t);
if(dynamic_cast<const MEDFileParameterDouble1TSWTI *>(elt))
diffType.insert(MED_FLOAT64);
}
throw INTERP_KERNEL::Exception("MEDFileParameterMultiTS::writeAdvanced : impossible to mix type of data in parameters in MED file ! Only float64 or only int32 ...");
if(diffType.empty())
return;
- med_parameter_type typ(*diffType.begin());
+ med_parameter_type const typ(*diffType.begin());
MEDFileParameterTinyInfo::writeLLHeader(fid,typ);
- for(std::vector< MCAuto<MEDFileParameter1TS> >::const_iterator it=_param_per_ts.begin();it!=_param_per_ts.end();it++)
+ for(const auto & _param_per_t : _param_per_ts)
{
- const MEDFileParameter1TS *elt(*it);
+ const MEDFileParameter1TS *elt(_param_per_t);
if(elt)
elt->writeAdvanced(fid,_name,mw);
}
void MEDFileParameterMultiTS::simpleRepr2(int bkOffset, std::ostream& oss) const
{
MEDFileParameterTinyInfo::mainRepr(bkOffset,oss);
- for(std::vector< MCAuto<MEDFileParameter1TS> >::const_iterator it=_param_per_ts.begin();it!=_param_per_ts.end();it++)
+ for(const auto & _param_per_t : _param_per_ts)
{
- const MEDFileParameter1TS *elt(*it);
+ const MEDFileParameter1TS *elt(_param_per_t);
if(elt)
elt->simpleRepr2(bkOffset+2,oss);
}
double MEDFileParameterMultiTS::getDoubleValue(int iteration, int order) const
{
- int pos=getPosOfTimeStep(iteration,order);
+ int const pos=getPosOfTimeStep(iteration,order);
const MEDFileParameter1TS *elt=_param_per_ts[pos];
if(!elt)
{
oss << " exists but elt is empty !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- const MEDFileParameterDouble1TSWTI *eltC=dynamic_cast<const MEDFileParameterDouble1TSWTI *>(elt);
+ const auto *eltC=dynamic_cast<const MEDFileParameterDouble1TSWTI *>(elt);
if(!eltC)
{
std::ostringstream oss; oss << "MEDFileParameterMultiTS::getDoubleValue : time iteration it=" << iteration << " order=" << order;
{
int ret=0;
std::ostringstream oss; oss << "MEDFileParameterMultiTS::getPosOfTimeStep : no such iteration=" << iteration << " order=" << order << " ! Possibilities are :";
- for(std::vector< MCAuto<MEDFileParameter1TS> >::const_iterator it=_param_per_ts.begin();it!=_param_per_ts.end();it++,ret++)
+ for(auto it=_param_per_ts.begin();it!=_param_per_ts.end();it++,ret++)
{
const MEDFileParameter1TS *elt(*it);
if(elt)
{
int ret=0;
std::ostringstream oss; oss << "MEDFileParameterMultiTS::getPosGivenTime : no such time=" << time << " ! Possibilities are :";
- for(std::vector< MCAuto<MEDFileParameter1TS> >::const_iterator it=_param_per_ts.begin();it!=_param_per_ts.end();it++,ret++)
+ for(auto it=_param_per_ts.begin();it!=_param_per_ts.end();it++,ret++)
{
const MEDFileParameter1TS *elt(*it);
if(elt)
void MEDFileParameterMultiTS::eraseTimeStepIds(const int *startIds, const int *endIds)
{
std::vector<bool> b(_param_per_ts.size(),true);
- int len=(int)_param_per_ts.size();
+ int const len=(int)_param_per_ts.size();
for(const int *w=startIds;w!=endIds;w++)
if(*w>=0 && *w<len)
b[*w]=false;
{
std::ostringstream oss; oss << "MEDFileParameterMultiTS::eraseTimeStepIds : At pos #" << std::distance(startIds,w) << " value is " << *w << " should be in [0," << len << ") !"; throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- std::size_t newNb=std::count(b.begin(),b.end(),true);
+ std::size_t const newNb=std::count(b.begin(),b.end(),true);
std::vector< MCAuto<MEDFileParameter1TS> > paramPerTs(newNb);
std::size_t j=0;
for(std::size_t i=0;i<_param_per_ts.size();i++)
std::vector< std::pair<int,int> > MEDFileParameterMultiTS::getIterations() const
{
std::vector< std::pair<int,int> > ret;
- for(std::vector< MCAuto<MEDFileParameter1TS> >::const_iterator it=_param_per_ts.begin();it!=_param_per_ts.end();it++)
+ for(const auto & _param_per_t : _param_per_ts)
{
- const MEDFileParameter1TS *elt(*it);
+ const MEDFileParameter1TS *elt(_param_per_t);
if(elt)
ret.push_back(std::pair<int,int>(elt->getIteration(),elt->getOrder()));
}
{
std::vector< std::pair<int,int> > ret0;
ret1.clear();
- for(std::vector< MCAuto<MEDFileParameter1TS> >::const_iterator it=_param_per_ts.begin();it!=_param_per_ts.end();it++)
+ for(const auto & _param_per_t : _param_per_ts)
{
- const MEDFileParameter1TS *elt(*it);
+ const MEDFileParameter1TS *elt(_param_per_t);
if(elt)
{
ret0.push_back(std::pair<int,int>(elt->getIteration(),elt->getOrder()));
MEDFileParameters *MEDFileParameters::New(const std::string& fileName)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return New(fid);
}
MEDFileParameters::MEDFileParameters(med_idt fid)
{
- med_int nbPar=MEDnParameter(fid);
+ med_int const nbPar=MEDnParameter(fid);
_params.resize(nbPar);
INTERP_KERNEL::AutoPtr<char> pName(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
INTERP_KERNEL::AutoPtr<char> descName(MEDLoaderBase::buildEmptyString(MED_COMMENT_SIZE));
{
med_int nbOfSteps;
MEDFILESAFECALLERRD0(MEDparameterInfo,(fid,i+1,pName,¶mType,descName,unitName,&nbOfSteps));
- std::string paramNameCpp(MEDLoaderBase::buildStringFromFortran(pName,MED_NAME_SIZE));
+ std::string const paramNameCpp(MEDLoaderBase::buildStringFromFortran(pName,MED_NAME_SIZE));
_params[i]=MEDFileParameterMultiTS::New(fid,paramNameCpp);
}
}
MEDFileParameters::MEDFileParameters()
-{
-}
+= default;
std::size_t MEDFileParameters::getHeapMemorySizeWithoutChildren() const
{
std::vector<const BigMemoryObject *> MEDFileParameters::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
- for(std::vector< MCAuto<MEDFileParameterMultiTS> >::const_iterator it=_params.begin();it!=_params.end();it++)
- ret.push_back((const MEDFileParameterMultiTS *)*it);
+ for(const auto & _param : _params)
+ ret.push_back((const MEDFileParameterMultiTS *)_param);
return ret;
}
MEDFileParameters::MEDFileParameters(const MEDFileParameters& other, bool deepCopy):MEDFileWritableStandAlone(other),_params(other._params)
{
if(deepCopy)
- for(std::size_t i=0;i<_params.size();i++)
+ for(auto & _param : _params)
{
- const MEDFileParameterMultiTS *elt=_params[i];
+ const MEDFileParameterMultiTS *elt=_param;
if(elt)
- _params[i]=elt->deepCopy();
+ _param=elt->deepCopy();
}
}
void MEDFileParameters::writeLL(med_idt fid) const
{
- for(std::vector< MCAuto<MEDFileParameterMultiTS> >::const_iterator it=_params.begin();it!=_params.end();it++)
+ for(const auto & _param : _params)
{
- const MEDFileParameterMultiTS *elt(*it);
+ const MEDFileParameterMultiTS *elt(_param);
if(elt)
elt->writeAdvanced(fid,*this);
}
{
std::vector<std::string> ret(_params.size());
int i=0;
- for(std::vector< MCAuto<MEDFileParameterMultiTS> >::const_iterator it=_params.begin();it!=_params.end();it++,i++)
+ for(auto it=_params.begin();it!=_params.end();it++,i++)
{
const MEDFileParameterMultiTS *p=(*it);
if(p)
void MEDFileParameters::simpleReprWithoutHeader(std::ostream& oss) const
{
- for(std::vector< MCAuto<MEDFileParameterMultiTS> >::const_iterator it=_params.begin();it!=_params.end();it++)
+ for(const auto & _param : _params)
{
- const MEDFileParameterMultiTS *elt(*it);
+ const MEDFileParameterMultiTS *elt(_param);
if(elt)
elt->simpleRepr2(2,oss);
}
{
if(param)
param->incrRef();
- MCAuto<MEDFileParameterMultiTS> elt(param);
+ MCAuto<MEDFileParameterMultiTS> const elt(param);
_params.push_back(elt);
}
_params.resize(i+1);
if(param)
param->incrRef();
- MCAuto<MEDFileParameterMultiTS> elt(param);
+ MCAuto<MEDFileParameterMultiTS> const elt(param);
_params[i]=elt;
}
*/
MEDFileParameterMultiTS *MEDFileParameters::getParamWithName(const std::string& paramName) const
{
- int pos=getPosFromParamName(paramName);
+ int const pos=getPosFromParamName(paramName);
return getParamAtPos(pos);
}
std::ostringstream oss; oss << "MEDFileParameters::destroyParamAtPos : should be in [0," << _params.size() << ") !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- _params[i]=MCAuto<MEDFileParameterMultiTS>(0);
+ _params[i]=MCAuto<MEDFileParameterMultiTS>(nullptr);
}
int MEDFileParameters::getPosFromParamName(const std::string& paramName) const
{
std::ostringstream oss; oss << "MEDFileParameters::getPosFromParamName : no such name=" << paramName << " ! Possibilities are :";
int ret=0;
- for(std::vector< MCAuto<MEDFileParameterMultiTS> >::const_iterator it=_params.begin();it!=_params.end();it++,ret++)
+ for(auto it=_params.begin();it!=_params.end();it++,ret++)
{
const MEDFileParameterMultiTS *elt(*it);
if(elt)
#ifndef __MEDFILEPARAMETER_HXX__
#define __MEDFILEPARAMETER_HXX__
-#include "MEDLoaderDefines.hxx"
+#include "MEDCouplingRefCountObject.hxx"
#include "MEDFileUtilities.txx"
+#include "MEDLoaderDefines.hxx"
#include "MEDCouplingMemArray.hxx"
#include "MCAuto.hxx"
+#include <string>
+#include <ostream>
+#include "med.h"
+#include <cstddef>
+#include <vector>
+#include <utility>
namespace MEDCoupling
{
public:
MEDLOADER_EXPORT static MEDFileParameterDouble1TSWTI *New(int iteration, int order, double time);
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileParameterDouble1TSWTI"); }
- MEDLOADER_EXPORT MEDFileParameter1TS *deepCopy() const;
+ MEDLOADER_EXPORT MEDFileParameter1TS *deepCopy() const override;
MEDLOADER_EXPORT void setValue(double val) { _arr=val; }
MEDLOADER_EXPORT double getValue() const { return _arr; }
- MEDLOADER_EXPORT bool isEqual(const MEDFileParameter1TS *other, double eps, std::string& what) const;
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- MEDLOADER_EXPORT void readValue(med_idt fid, const std::string& name);
+ MEDLOADER_EXPORT bool isEqual(const MEDFileParameter1TS *other, double eps, std::string& what) const override;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ MEDLOADER_EXPORT void readValue(med_idt fid, const std::string& name) override;
MEDLOADER_EXPORT std::string simpleRepr() const;
protected:
MEDFileParameterDouble1TSWTI();
MEDFileParameterDouble1TSWTI(int iteration, int order, double time);
- void simpleRepr2(int bkOffset, std::ostream& oss) const;
+ void simpleRepr2(int bkOffset, std::ostream& oss) const override;
void finishLoading(med_idt fid, const std::string& name, int dt, int it, int nbOfSteps);
void finishLoading(med_idt fid, const std::string& name, int timeStepId);
- void writeAdvanced(med_idt fid, const std::string& name, const MEDFileWritable& mw) const;
+ void writeAdvanced(med_idt fid, const std::string& name, const MEDFileWritable& mw) const override;
protected:
double _arr;
};
MEDLOADER_EXPORT static MEDFileParameterDouble1TS *New(const std::string& fileName, const std::string& paramName);
MEDLOADER_EXPORT static MEDFileParameterDouble1TS *New(const std::string& fileName, const std::string& paramName, int dt, int it);
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileParameterDouble1TS"); }
- MEDLOADER_EXPORT virtual MEDFileParameter1TS *deepCopy() const;
- MEDLOADER_EXPORT virtual bool isEqual(const MEDFileParameter1TS *other, double eps, std::string& what) const;
+ MEDLOADER_EXPORT MEDFileParameter1TS *deepCopy() const override;
+ MEDLOADER_EXPORT bool isEqual(const MEDFileParameter1TS *other, double eps, std::string& what) const override;
MEDLOADER_EXPORT virtual std::string simpleRepr() const;
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
MEDLOADER_EXPORT void setName(const std::string& name) { _name=name; }
MEDLOADER_EXPORT std::string getName() const { return _name; }
MEDLOADER_EXPORT void write(const std::string& fileName, int mode) const;
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileParameterMultiTS"); }
MEDLOADER_EXPORT std::string getName() const { return _name; }
MEDLOADER_EXPORT void setName(const std::string& name) { _name=name; }
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
MEDLOADER_EXPORT MEDFileParameterMultiTS *deepCopy() const;
MEDLOADER_EXPORT bool isEqual(const MEDFileParameterMultiTS *other, double eps, std::string& what) const;
MEDLOADER_EXPORT void write(const std::string& fileName, int mode) const;
MEDLOADER_EXPORT static MEDFileParameters *New(DataArrayByte *db) { return BuildFromMemoryChunk<MEDFileParameters>(db); }
MEDLOADER_EXPORT static MEDFileParameters *New(const std::string& fileName);
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileParameters"); }
- MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
- MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const override;
+ MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
MEDLOADER_EXPORT MEDFileParameters *deepCopy() const;
MEDLOADER_EXPORT bool isEqual(const MEDFileParameters *other, double eps, std::string& what) const;
- MEDLOADER_EXPORT void writeLL(med_idt fid) const;
+ MEDLOADER_EXPORT void writeLL(med_idt fid) const override;
MEDLOADER_EXPORT std::vector<std::string> getParamsNames() const;
MEDLOADER_EXPORT std::string simpleRepr() const;
MEDLOADER_EXPORT void simpleReprWithoutHeader(std::ostream& oss) const;
#ifndef __MEDFILESAFECALLER_TXX__
#define __MEDFILESAFECALLER_TXX__
-#include "med.h"
-#include "InterpKernelException.hxx"
-#include <sstream>
// TXX extension to avoid to be installed.
// Author : Anthony Geay (EDF R&D)
#include "MEDFileStructureElement.hxx"
+#include "MCType.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MCIdType.hxx"
+#include "MEDFileBasis.hxx"
#include "MEDFileMeshSupport.hxx"
+#include "MEDFileUtilities.hxx"
#include "MEDLoaderBase.hxx"
#include "MEDFileMeshLL.hxx"
#include "MEDFileSafeCaller.txx"
#include "InterpKernelAutoPtr.hxx"
+#include <string>
+#include <cstddef>
+#include "NormalizedGeometricTypes"
+#include "med.h"
+#include "medstructelement.h"
+#include <sstream>
+#include <vector>
using namespace MEDCoupling;
MEDFileSEConstAtt::MEDFileSEConstAtt(med_idt fid, MEDFileStructureElement *father, int idCstAtt, const MEDFileUMesh *mesh):MEDFileSEHolder(father)
{
- std::string modelName(getModelName());
+ std::string const modelName(getModelName());
INTERP_KERNEL::AutoPtr<char> constattname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE)),profilename(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
med_attribute_type constatttype;
med_int nbCompo;
med_entity_type met;
med_int miPflSz;
MEDFILESAFECALLERRD0(MEDstructElementConstAttInfo,(fid,modelName.c_str(),idCstAtt+1,constattname,&constatttype,&nbCompo,&met,profilename,&miPflSz));
- std::string name(MEDLoaderBase::buildStringFromFortran(constattname,MED_NAME_SIZE));
+ std::string const name(MEDLoaderBase::buildStringFromFortran(constattname,MED_NAME_SIZE));
setName(name);
setProfile(MEDLoaderBase::buildStringFromFortran(profilename,MED_NAME_SIZE));
_tof=MEDFileMesh::ConvertFromMEDFileEntity(met);
MEDFileSEVarAtt::MEDFileSEVarAtt(med_idt fid, MEDFileStructureElement *father, int idVarAtt):MEDFileSEHolder(father)
{
- std::string modelName(getModelName());
+ std::string const modelName(getModelName());
INTERP_KERNEL::AutoPtr<char> varattname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE)),profilename(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
med_attribute_type varatttype;
{
std::vector<const BigMemoryObject *> MEDFileStructureElement::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
- for(std::vector< MCAuto<MEDFileSEConstAtt> >::const_iterator it=_cst_att.begin();it!=_cst_att.end();it++)
- ret.push_back(*it);
- for(std::vector< MCAuto<MEDFileSEVarAtt> >::const_iterator it=_var_att.begin();it!=_var_att.end();it++)
- ret.push_back(*it);
+ for(const auto & it : _cst_att)
+ ret.push_back(it);
+ for(const auto & it : _var_att)
+ ret.push_back(it);
return ret;
}
std::vector<std::string> MEDFileStructureElement::getVarAtts() const
{
std::vector<std::string> ret;
- for(std::vector< MCAuto<MEDFileSEVarAtt> >::const_iterator it=_var_att.begin();it!=_var_att.end();it++)
- if((*it).isNotNull())
- ret.push_back((*it)->getName());
+ for(const auto & it : _var_att)
+ if(it.isNotNull())
+ ret.push_back(it->getName());
return ret;
}
const MEDFileSEVarAtt *MEDFileStructureElement::getVarAtt(const std::string& varName) const
{
- for(std::vector< MCAuto<MEDFileSEVarAtt> >::const_iterator it=_var_att.begin();it!=_var_att.end();it++)
- if((*it).isNotNull())
- if((*it)->getName()==varName)
- return *it;
+ for(const auto & it : _var_att)
+ if(it.isNotNull())
+ if(it->getName()==varName)
+ return it;
std::ostringstream oss; oss << "MEDFileStructureElement::getVarAtt : no var att with name \"" << varName << "\" !";
throw INTERP_KERNEL::Exception(oss.str());
}
MEDFileStructureElements *MEDFileStructureElements::New(const std::string& fileName, const MEDFileMeshSupports *ms)
{
- MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(OpenMEDFileForRead(fileName));
return New(fid,ms);
}
std::vector<const BigMemoryObject *> MEDFileStructureElements::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
- for(std::vector< MCAuto<MEDFileStructureElement> >::const_iterator it=_elems.begin();it!=_elems.end();it++)
- ret.push_back(*it);
+ for(const auto & _elem : _elems)
+ ret.push_back(_elem);
return ret;
}
MEDFileStructureElements::MEDFileStructureElements(med_idt fid, const MEDFileMeshSupports *ms)
{
- med_int nbSE(MEDnStructElement(fid));
+ med_int const nbSE(MEDnStructElement(fid));
_elems.resize(nbSE);
for(int i=0;i<nbSE;i++)
_elems[i]=MEDFileStructureElement::New(fid,i,ms);
}
MEDFileStructureElements::MEDFileStructureElements()
-{
-}
+= default;
MEDFileStructureElements::~MEDFileStructureElements()
-{
-}
+= default;
int MEDFileStructureElements::getNumberOf() const
{
std::vector<int> MEDFileStructureElements::getDynGTAvail() const
{
std::vector<int> ret;
- for(std::vector< MCAuto<MEDFileStructureElement> >::const_iterator it=_elems.begin();it!=_elems.end();it++)
+ for(const auto & _elem : _elems)
{
- const MEDFileStructureElement *elt(*it);
+ const MEDFileStructureElement *elt(_elem);
if(elt)
ret.push_back(elt->getDynGT());
}
const MEDFileStructureElement *MEDFileStructureElements::getWithGT(int idGT) const
{
- for(std::vector< MCAuto<MEDFileStructureElement> >::const_iterator it=_elems.begin();it!=_elems.end();it++)
- if((*it).isNotNull())
+ for(const auto & _elem : _elems)
+ if(_elem.isNotNull())
{
- if((*it)->getDynGT()==idGT)
- return *it;
+ if(_elem->getDynGT()==idGT)
+ return _elem;
}
std::ostringstream oss; oss << "MEDFileStructureElements::getWithGT : no such geo type " << idGT << " !";
throw INTERP_KERNEL::Exception(oss.str());
if(seName=="MED_PARTICLE")
return 1;
const MEDFileStructureElement *se(getSEWithName(seName));
- std::string meshName(se->getMeshName());
+ std::string const meshName(se->getMeshName());
return _sup->getNumberOfNodesInConnOf(se->getEntity(),se->getGeoType(),meshName);
}
const MEDFileStructureElement *MEDFileStructureElements::getSEWithName(const std::string& seName) const
{
- for(std::vector< MCAuto<MEDFileStructureElement> >::const_iterator it=_elems.begin();it!=_elems.end();it++)
+ for(const auto & _elem : _elems)
{
- if((*it).isNotNull())
- if((*it)->getName()==seName)
- return *it;
+ if(_elem.isNotNull())
+ if(_elem->getName()==seName)
+ return _elem;
}
std::ostringstream oss; oss << "MEDFileStructureElements::getSEWithName : no such structure element with name " << seName << " !";
throw INTERP_KERNEL::Exception(oss.str());
#ifndef __MEDFILESTRUCTUREELEMENT_HXX__
#define __MEDFILESTRUCTUREELEMENT_HXX__
+#include "MEDFileUtilities.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MCType.hxx"
#include "MEDLoaderDefines.hxx"
-#include "MEDFileUtilities.txx"
#include "MEDFileMesh.hxx"
#include "MEDCouplingRefCountObject.hxx"
+#include <string>
+#include <cstddef>
+#include <vector>
+#include "med.h"
+#include "NormalizedGeometricTypes"
namespace MEDCoupling
{
static MEDFileSEConstAtt *New(med_idt fid, MEDFileStructureElement *father, int idCstAtt, const MEDFileUMesh *mesh);
public:
std::string getClassName() const override { return std::string("MEDFileSEConstAtt"); }
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- std::size_t getHeapMemorySizeWithoutChildren() const;
- void writeLL(med_idt fid) const;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ void writeLL(med_idt fid) const override;
void setProfile(const std::string& name);
std::string getProfile() const;
private:
static MEDFileSEVarAtt *New(med_idt fid, MEDFileStructureElement *father, int idVarAtt);
public:
std::string getClassName() const override { return std::string("MEDFileSEVarAtt"); }
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- std::size_t getHeapMemorySizeWithoutChildren() const;
- void writeLL(med_idt fid) const;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ void writeLL(med_idt fid) const override;
int getNbOfComponents() const { return _nb_compo; }
MCAuto<DataArray> getGenerator() const { return _gen; }
private:
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("MEDFileStructureElement"); }
MEDLOADER_EXPORT INTERP_KERNEL::NormalizedCellType getGeoType() const { return _geo_type; }
public:
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- std::size_t getHeapMemorySizeWithoutChildren() const;
- void writeLL(med_idt fid) const;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ void writeLL(med_idt fid) const override;
public:
static MCAuto<DataArray> BuildFrom(med_attribute_type mat);
static int EffectiveNbCompo(med_attribute_type mat, int nbCompo);
MEDLOADER_EXPORT const MEDFileSEVarAtt *getVarAttOf(const std::string &seName, const std::string& varName) const;
MEDLOADER_EXPORT const MEDFileUMesh *getSupMeshWithName(const std::string& name) const;
public:
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
- std::size_t getHeapMemorySizeWithoutChildren() const;
- void writeLL(med_idt fid) const;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ void writeLL(med_idt fid) const override;
private:
MEDFileStructureElements(med_idt fid, const MEDFileMeshSupports *ms);
MEDFileStructureElements();
- ~MEDFileStructureElements();
+ ~MEDFileStructureElements() override;
private:
std::vector< MCAuto<MEDFileStructureElement> > _elems;
MCConstAuto<MEDFileMeshSupports> _sup;
// Author : Anthony Geay (CEA/DEN)
#include "MEDFileUtilities.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MEDCouplingRefCountObject.hxx"
#include "MEDFileSafeCaller.txx"
#include "MEDLoaderBase.hxx"
#include "MEDLoader.hxx"
-#include "MEDFileBasis.hxx"
#include "InterpKernelAutoPtr.hxx"
+#include "med.h"
+#include "medfile.h"
#include <sstream>
-#include <fstream>
+#include <string>
const char MEDCoupling::MEDFileWritableStandAlone::DFT_FILENAME_IN_MEM[]="DftFileNameInMemory";
}
}
-void MEDFileUtilities::CheckMEDCode(int code, med_idt fid, const std::string& msg)
+void MEDFileUtilities::CheckMEDCode(int code, med_idt /*fid*/, const std::string& msg)
{
if(code<0)
{
void MEDFileUtilities::CheckFileForRead(const std::string& fileName)
{
- int status=MEDLoaderBase::getStatusOfFile(fileName);
+ int const status=MEDLoaderBase::getStatusOfFile(fileName);
std::ostringstream oss;
oss << " File : \"" << fileName << "\"";
switch(status)
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
}
- AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
+ AutoFid const fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
if(fid<0)
{
oss << " has been detected as unreadable by MED file : impossible to read anything !";
std::string MEDCoupling::MEDFileWritable::FileNameFromFID(med_idt fid)
{
- med_int lgth(MEDfileName(fid,0,0));
+ med_int const lgth(MEDfileName(fid,nullptr,0));
if(lgth<=0)
return std::string();
INTERP_KERNEL::AutoPtr<char> tmp(new char[lgth+1]);
*/
void MEDCoupling::MEDFileWritableStandAlone::write(const std::string& fileName, int mode) const
{
- med_access_mode medmod(MEDFileUtilities::TraduceWriteMode(mode));
- MEDFileUtilities::AutoFid fid(MEDfileOpen(fileName.c_str(),medmod));
+ med_access_mode const medmod(MEDFileUtilities::TraduceWriteMode(mode));
+ MEDFileUtilities::AutoFid const fid(MEDfileOpen(fileName.c_str(),medmod));
std::ostringstream oss; oss << "MEDFileWritableStandAlone : error on attempt to write in file : \"" << fileName << "\"";
MEDFileUtilities::CheckMEDCode((int)fid,fid,oss.str());
writeLL(fid);
void MEDCoupling::MEDFileWritableStandAlone::writeXX(const std::string& fileName, int mode, med_int maj, med_int min, med_int rel) const
{
#if ( MED_NUM_MAJEUR>4 || ( MED_NUM_MAJEUR==4 && MED_NUM_MINEUR>=1 ) )
- med_access_mode medmod(MEDFileUtilities::TraduceWriteMode(mode));
- MEDFileUtilities::AutoFid fid(MEDfileVersionOpen(fileName.c_str(),medmod,maj,min,rel));
+ med_access_mode const medmod(MEDFileUtilities::TraduceWriteMode(mode));
+ MEDFileUtilities::AutoFid const fid(MEDfileVersionOpen(fileName.c_str(),medmod,maj,min,rel));
writeLL(fid);
#else
std::ostringstream oss; oss << "MEDFileWritableStandAlone::write" << maj << min << " : the MED version used to compile medcoupling is " << MEDFileVersionStr() << " ! If you need this feature please use version >= 4.1.";
MEDCoupling::MCAuto<MEDCoupling::DataArrayByte> MEDCoupling::MEDFileWritableStandAlone::serialize() const
{
med_memfile memfile=MED_MEMFILE_INIT;
- memfile.app_image_ptr=0;
+ memfile.app_image_ptr=nullptr;
memfile.app_image_size=0;
//
- std::string dftFileName(GenerateUniqueDftFileNameInMem());
+ std::string const dftFileName(GenerateUniqueDftFileNameInMem());
{// very important to let this braces ! The AutoFid destructor must be called, to have a "clean" memfile.app_image_ptr pointer embedded in the returned object.
- MEDFileUtilities::AutoFid fid(MEDmemFileOpen(dftFileName.c_str(),&memfile,MED_FALSE,MED_ACC_CREAT));
+ MEDFileUtilities::AutoFid const fid(MEDmemFileOpen(dftFileName.c_str(),&memfile,MED_FALSE,MED_ACC_CREAT));
writeLL(fid);
}
//
#ifndef __MEDFILEUTILITIES_HXX__
#define __MEDFILEUTILITIES_HXX__
-#include "InterpKernelException.hxx"
#include "MEDLoaderDefines.hxx"
#include "MCAuto.hxx"
#include "MEDCouplingMemArray.hxx"
#include "med.h"
+#include <string>
namespace MEDFileUtilities
{
{
public:
MEDFileWritable();
- virtual ~MEDFileWritable() {}
+ virtual ~MEDFileWritable() = default;
void copyOptionsFrom(const MEDFileWritable& other) const;
int getTooLongStrPolicy() const;
void setTooLongStrPolicy(int newVal);
#ifndef __MEDFILEUTILITIES_TXX__
#define __MEDFILEUTILITIES_TXX__
+#include "MEDCouplingMemArray.hxx"
#include "MEDFileUtilities.hxx"
+#include "med.h"
+#include <string>
+#include "medfile.h"
template<class T>
T *MEDCoupling::MEDFileWritableStandAlone::BuildFromMemoryChunk(MEDCoupling::DataArrayByte *db)
med_memfile memfile=MED_MEMFILE_INIT;
memfile.app_image_ptr=db->getPointer();
memfile.app_image_size=db->getNbOfElems();
- std::string dftFileName(MEDCoupling::MEDFileWritableStandAlone::GenerateUniqueDftFileNameInMem());
+ std::string const dftFileName(MEDCoupling::MEDFileWritableStandAlone::GenerateUniqueDftFileNameInMem());
MEDFileUtilities::AutoFid fid(MEDmemFileOpen(dftFileName.c_str(),&memfile,MED_FALSE,MED_ACC_RDWR));
return T::New(fid);
}
#ifndef __MEDFILTERENTITY_HXX__
#define __MEDFILTERENTITY_HXX__
+#include "MCType.hxx"
+#include "MCAuto.hxx"
#include "MEDCouplingPartDefinition.hxx"
+#include "InterpKernelException.hxx"
+#include "MEDFileBasis.hxx"
#include "med.h"
+#include "medfilter.h"
+#include <algorithm>
+#include <iterator>
#include <memory>
+#include <vector>
namespace MEDCoupling
{
const med_int constituentSelect, const med_switch_mode switchMode, const med_storage_mode storageMode, const char * const profileName,
const PartDefinition* pd)
{
- const SlicePartDefinition *spd(dynamic_cast<const SlicePartDefinition *>(pd));
+ const auto *spd(dynamic_cast<const SlicePartDefinition *>(pd));
if(spd)
{
//Here, pd contains a slice, so it's more efficient to define a filter of block
//(which will load contiguous values)
- mcIdType nbOfEltsToLoad = spd->getNumberOfElems();
+ mcIdType const nbOfEltsToLoad = spd->getNumberOfElems();
mcIdType strt,end,step;
spd->getSlice(strt,end,step);
if(strt<0)
/*lastblocksize=useless because count=1*/0,_filter.get());
return;
}
- const DataArrayPartDefinition *dpd(dynamic_cast<const DataArrayPartDefinition *>(pd));
+ const auto *dpd(dynamic_cast<const DataArrayPartDefinition *>(pd));
if(dpd)
{
- mcIdType nbOfEltsToLoad = dpd->getNumberOfElems();
+ mcIdType const nbOfEltsToLoad = dpd->getNumberOfElems();
//convert to fortran indexing
std::vector<mcIdType> dpdPlus1;
// Author : Anthony Geay (CEA/DEN)
#include "MEDLoader.hxx"
+#include "MCIdType.hxx"
+#include "MCType.hxx"
+#include "MEDFileBasis.hxx"
+#include "MEDFileFieldMultiTS.hxx"
+#include "MEDFileField1TS.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingCMesh.hxx"
+#include "MEDCouplingCurveLinearMesh.hxx"
#include "MEDLoaderBase.hxx"
#include "MEDFileUtilities.hxx"
#include "MEDLoaderNS.hxx"
#include "InterpKernelAutoPtr.hxx"
+#include "NormalizedGeometricTypes"
+#include "MEDLoaderTraits.hxx"
#include "med.h"
+#include "medmesh.h"
+#include "medlibrary.h"
+#include "medfile.h"
+#include "medfield.h"
+#include "medfamily.h"
+#include <set>
+#include <iterator>
+#include <ostream>
+#include <map>
+#include <memory>
#include <string>
#include <limits>
#include <cstring>
#include <sstream>
-#include <fstream>
-#include <numeric>
-#include <iterator>
#include <algorithm>
-#include <memory>
+#include <vector>
+#include <utility>
extern med_geometry_type typmai[MED_N_CELL_FIXED_GEO];
extern med_geometry_type typmainoeud[1];
int MEDLoaderNS::readUMeshDimFromFile(const std::string& fileName, const std::string& meshName, std::vector<int>& possibilities)
{
possibilities.clear();
- MEDFileUtilities::AutoFid fid(MEDCoupling::OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(MEDCoupling::OpenMEDFileForRead(fileName));
int ret;
std::set<int> poss;
char nommaa[MED_NAME_SIZE+1];
med_mesh_type type_maillage;
med_int Sdim,Mdim;
std::string trueMeshName;
- int meshId=FromMedInt<int>(getIdFromMeshName(fid,meshName,trueMeshName));
+ int const meshId=FromMedInt<int>(getIdFromMeshName(fid,meshName,trueMeshName));
INTERP_KERNEL::AutoPtr<char> dt_unit=MEDLoaderBase::buildEmptyString(MED_LNAME_SIZE);
med_sorting_type sortingType;
med_int nstep;
med_axis_type axisType;
- med_int naxis(MEDmeshnAxis(fid,meshId));
+ med_int const naxis(MEDmeshnAxis(fid,meshId));
INTERP_KERNEL::AutoPtr<char> axisname=MEDLoaderBase::buildEmptyString(naxis*MED_SNAME_SIZE);
INTERP_KERNEL::AutoPtr<char> axisunit=MEDLoaderBase::buildEmptyString(naxis*MED_SNAME_SIZE);
MEDFILESAFECALLERRD0(MEDmeshInfo,(fid,meshId,nommaa,&Sdim,&Mdim,&type_maillage,maillage_description,dt_unit,&sortingType,&nstep,&axisType,axisname,axisunit));
// endlimitation
for(int i=0;i<MED_N_CELL_GEO_FIXED_CON;i++)
{
- med_geometry_type curMedType=typmai[i];
+ med_geometry_type const curMedType=typmai[i];
med_bool changement,transformation;
- med_int curNbOfElemM(MEDmeshnEntity(fid,nommaa,numdt,numit,MED_CELL,curMedType,MED_CONNECTIVITY,MED_NODAL,&changement,&transformation));
- med_int curNbOfElemF(MEDmeshnEntity(fid,nommaa,numdt,numit,MED_CELL,curMedType,MED_CONNECTIVITY,MED_NODAL,&changement,&transformation));//limitation
+ med_int const curNbOfElemM(MEDmeshnEntity(fid,nommaa,numdt,numit,MED_CELL,curMedType,MED_CONNECTIVITY,MED_NODAL,&changement,&transformation));
+ med_int const curNbOfElemF(MEDmeshnEntity(fid,nommaa,numdt,numit,MED_CELL,curMedType,MED_CONNECTIVITY,MED_NODAL,&changement,&transformation));//limitation
med_int curNbOfElem;
med_entity_type whichEntity;
MEDLoaderNS::dispatchElems(curNbOfElemM,curNbOfElemF,curNbOfElem,whichEntity);
if(curNbOfElem>0)
{
- INTERP_KERNEL::NormalizedCellType type=typmai2[i];
- int curDim=(int)INTERP_KERNEL::CellModel::GetCellModel(type).getDimension();
+ INTERP_KERNEL::NormalizedCellType const type=typmai2[i];
+ int const curDim=(int)INTERP_KERNEL::CellModel::GetCellModel(type).getDimension();
poss.insert(curDim);
}
}
if(!poss.empty())
{
ret=*poss.rbegin();
- for(std::set<int>::const_reverse_iterator it=poss.rbegin();it!=poss.rend();it++)
+ for(auto it=poss.rbegin();it!=poss.rend();it++)
possibilities.push_back(*it-ret);
}
else
trueMeshName=meshes[0];
return 1;
}
- std::string meshNameStr(meshName);
+ std::string const meshNameStr(meshName);
std::vector<std::string> meshes=getMeshNamesFid(fid);
if(meshes.empty())
throw INTERP_KERNEL::Exception("No mesh in file");
- std::vector<std::string>::iterator iter=std::find(meshes.begin(),meshes.end(),meshNameStr);
+ auto const iter=std::find(meshes.begin(),meshes.end(),meshNameStr);
if(iter==meshes.end())
{
std::ostringstream os2;
char nommaa[MED_NAME_SIZE+1];
med_axis_type axistype;
med_sorting_type stype;
- med_int n=MEDnMesh(fid);
+ med_int const n=MEDnMesh(fid);
std::vector<std::string> ret(n);
for(int i=0;i<n;i++)
{
- med_int naxis(MEDmeshnAxis(fid,i+1));
+ med_int const naxis(MEDmeshnAxis(fid,i+1));
INTERP_KERNEL::AutoPtr<char> axisname=MEDLoaderBase::buildEmptyString(naxis*MED_SNAME_SIZE);
INTERP_KERNEL::AutoPtr<char> axisunit=MEDLoaderBase::buildEmptyString(naxis*MED_SNAME_SIZE);
med_int nstep;
MEDFILESAFECALLERRD0(MEDmeshInfo,(fid,i+1,nommaa,&space_dim,&mesh_dim,&type_maillage,maillage_description,dtunit,&stype,&nstep,&axistype,axisname,axisunit));
- std::string cur=MEDLoaderBase::buildStringFromFortran(nommaa,sizeof(nommaa));
+ std::string const cur=MEDLoaderBase::buildStringFromFortran(nommaa,sizeof(nommaa));
ret[i]=cur;
}
return ret;
char buf[SZ];
std::fill(buf,buf+SZ,'\0');
const char START_EXPECTED[]="MED-";
- med_err ret(MEDlibraryStrVersion(buf));
+ med_err const ret(MEDlibraryStrVersion(buf));
if(ret!=0)
throw INTERP_KERNEL::Exception("MEDFileVersionStr : fail to find version of MED file ! It looks very bad !");
- std::string zeRet(buf);
- std::size_t pos(zeRet.find(START_EXPECTED,0));
+ std::string const zeRet(buf);
+ std::size_t const pos(zeRet.find(START_EXPECTED,0));
if(pos!=0)
{
std::ostringstream oss; oss << "MEDFileVersionStr : internal error ! The MEDFile returned version (\"" << zeRet << "\") has not the right pattern !";
std::string MEDCoupling::MEDFileVersionOfFileStr(const std::string& fileName)
{
#if MED_NUM_MAJEUR>3 || ( MED_NUM_MAJEUR==3 && ( (MED_NUM_MINEUR==2 && MED_NUM_RELEASE>=1) || MED_NUM_MINEUR>=3) )
- MEDFileUtilities::AutoFid fid(MEDCoupling::OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(MEDCoupling::OpenMEDFileForRead(fileName));
const int SZ=20;
const char START_EXPECTED[]="MED-";
char buf[SZ];
std::fill(buf,buf+SZ,'\0');
MEDFILESAFECALLERRD0(MEDfileStrVersionRd,(fid,buf));
- std::string ret(buf);
- std::size_t pos(ret.find(START_EXPECTED,0));
+ std::string const ret(buf);
+ std::size_t const pos(ret.find(START_EXPECTED,0));
if(pos!=0)
{
std::ostringstream oss; oss << "MEDFileVersionOfFileStr : internal error ! The MEDFile returned version (\"" << ret << "\") has not the right pattern !";
void MEDCoupling::MEDFileVersion(int& major, int& minor, int& release)
{
med_int majj,minn,rell;
- med_err ret(MEDlibraryNumVersion(&majj,&minn,&rell));
+ med_err const ret(MEDlibraryNumVersion(&majj,&minn,&rell));
if(ret!=0)
throw INTERP_KERNEL::Exception("MEDFileVersion : fail to call MEDlibraryNumVersion ! It looks very bad !");
major=FromMedInt<int>(majj);
*/
std::vector< std::vector< std::pair<INTERP_KERNEL::NormalizedCellType,int> > > MEDCoupling::GetUMeshGlobalInfo(const std::string& fileName, const std::string& meshName, int &meshDim, int& spaceDim, mcIdType& numberOfNodes)
{
- MEDFileUtilities::AutoFid fid(MEDCoupling::OpenMEDFileForRead(fileName));
- std::set<int> poss;
+ MEDFileUtilities::AutoFid const fid(MEDCoupling::OpenMEDFileForRead(fileName));
+ std::set<int> const poss;
char nommaa[MED_NAME_SIZE+1];
char maillage_description[MED_COMMENT_SIZE+1];
med_mesh_type type_maillage;
std::string trueMeshName;
- int meshId=MEDLoaderNS::getIdFromMeshName(fid,meshName,trueMeshName);
+ int const meshId=MEDLoaderNS::getIdFromMeshName(fid,meshName,trueMeshName);
INTERP_KERNEL::AutoPtr<char> dt_unit=MEDLoaderBase::buildEmptyString(MED_LNAME_SIZE);
med_sorting_type sortingType;
med_int nstep, mDim, sDim;
med_axis_type axisType;
- med_int naxis(MEDmeshnAxis(fid,meshId));
+ med_int const naxis(MEDmeshnAxis(fid,meshId));
INTERP_KERNEL::AutoPtr<char> axisname=MEDLoaderBase::buildEmptyString(naxis*MED_SNAME_SIZE);
INTERP_KERNEL::AutoPtr<char> axisunit=MEDLoaderBase::buildEmptyString(naxis*MED_SNAME_SIZE);
MEDFILESAFECALLERRD0(MEDmeshInfo,(fid,meshId,nommaa,&sDim,&mDim,&type_maillage,maillage_description,dt_unit,&sortingType,&nstep,&axisType,axisname,axisunit));
med_bool changement,transformation;
for(int i=0;i<MED_N_CELL_FIXED_GEO;i++)
{
- med_geometry_type curMedType=typmai[i];
- med_int curNbOfElemM(MEDmeshnEntity(fid,nommaa,numdt,numit,MED_CELL,curMedType,MED_CONNECTIVITY,MED_NODAL,&changement,&transformation));
+ med_geometry_type const curMedType=typmai[i];
+ med_int const curNbOfElemM(MEDmeshnEntity(fid,nommaa,numdt,numit,MED_CELL,curMedType,MED_CONNECTIVITY,MED_NODAL,&changement,&transformation));
if(curNbOfElemM>0)
{
- INTERP_KERNEL::NormalizedCellType typp=typmai2[i];
- int mdimCell=INTERP_KERNEL::CellModel::GetCellModel(typp).getDimension();
+ INTERP_KERNEL::NormalizedCellType const typp=typmai2[i];
+ int const mdimCell=INTERP_KERNEL::CellModel::GetCellModel(typp).getDimension();
dims.push_back(mdimCell);
geoTypes.push_back(std::pair<INTERP_KERNEL::NormalizedCellType,int>(typp,curNbOfElemM));
}
}
- int maxLev=*std::max_element(dims.begin(),dims.end());
- int lowLev=*std::min_element(dims.begin(),dims.end());
- int nbOfLevels=maxLev-lowLev+1;
+ int const maxLev=*std::max_element(dims.begin(),dims.end());
+ int const lowLev=*std::min_element(dims.begin(),dims.end());
+ int const nbOfLevels=maxLev-lowLev+1;
std::vector< std::vector< std::pair<INTERP_KERNEL::NormalizedCellType,int> > > ret(nbOfLevels);
for(std::size_t i=0;i<dims.size();i++)
{
std::vector<std::string> MEDCoupling::GetMeshNames(const std::string& fileName)
{
- MEDFileUtilities::AutoFid fid(MEDCoupling::OpenMEDFileForRead(fileName));
+ MEDFileUtilities::AutoFid const fid(MEDCoupling::OpenMEDFileForRead(fileName));
return MEDLoaderNS::getMeshNamesFid(fid);
}
std::vector< std::pair<std::string,std::string> > MEDCoupling::GetComponentsNamesOfField(const std::string& fileName, const std::string& fieldName)
{
- MEDFileUtilities::AutoFid fid(MEDCoupling::OpenMEDFileForRead(fileName));
- med_int nbFields(MEDnField(fid));
+ MEDFileUtilities::AutoFid const fid(MEDCoupling::OpenMEDFileForRead(fileName));
+ med_int const nbFields(MEDnField(fid));
std::vector<std::string> fields(nbFields);
med_field_type typcha;
for(int i=0;i<nbFields;i++)
{
- med_int ncomp(MEDfieldnComponent(fid,i+1));
+ med_int const ncomp(MEDfieldnComponent(fid,i+1));
INTERP_KERNEL::AutoPtr<char> comp=new char[ncomp*MED_SNAME_SIZE+1];
INTERP_KERNEL::AutoPtr<char> unit=new char[ncomp*MED_SNAME_SIZE+1];
INTERP_KERNEL::AutoPtr<char> dt_unit=MEDLoaderBase::buildEmptyString(MED_LNAME_SIZE);
INTERP_KERNEL::AutoPtr<char> maa_ass=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
INTERP_KERNEL::AutoPtr<char> nomcha=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
MEDFILESAFECALLERRD0(MEDfieldInfo,(fid,i+1,nomcha,maa_ass,&localmesh,&typcha,comp,unit,dt_unit,&nbPdt));
- std::string meshName=MEDLoaderBase::buildStringFromFortran(maa_ass,MED_NAME_SIZE);
- std::string curFieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE+1);
+ std::string const meshName=MEDLoaderBase::buildStringFromFortran(maa_ass,MED_NAME_SIZE);
+ std::string const curFieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE+1);
if(curFieldName==fieldName)
{
std::vector< std::pair<std::string,std::string> > ret(ncomp);
void MEDCoupling::GetFamiliesGroupsInfo(const std::string& fileName, const std::string& meshName, std::map<std::string,mcIdType>& families, std::map<std::string,std::vector<std::string>>& groupsOnFam)
{
- MEDFileUtilities::AutoFid fid(MEDCoupling::OpenMEDFileForRead(fileName));
- med_int nbFams(MEDnFamily(fid,meshName.c_str()));
+ MEDFileUtilities::AutoFid const fid(MEDCoupling::OpenMEDFileForRead(fileName));
+ med_int const nbFams(MEDnFamily(fid,meshName.c_str()));
char nomfam[MED_NAME_SIZE+1];
for(med_int i=0;i<nbFams;++i)
{
med_int nbGrps(MEDnFamilyGroup(fid,meshName.c_str(),FromMedInt<int>(i+1))),famId;
- std::unique_ptr<char[]> gro{new char[MED_LNAME_SIZE*nbGrps+1]};
+ std::unique_ptr<char[]> const gro{new char[MED_LNAME_SIZE*nbGrps+1]};
MEDFILESAFECALLERRD0(MEDfamilyInfo,(fid,meshName.c_str(),FromMedInt<int>(i+1),nomfam,&famId,gro.get()));
- std::string fam(MEDLoaderBase::buildStringFromFortran(nomfam,MED_NAME_SIZE));
+ std::string const fam(MEDLoaderBase::buildStringFromFortran(nomfam,MED_NAME_SIZE));
families[fam] = FromMedInt<mcIdType>(famId);
std::vector<std::string> v(nbGrps);
std::copy(MEDVectorStringIterator(0,gro.get()),MEDVectorStringIterator(nbGrps,gro.get()),v.begin());
{
std::vector<std::string> ret;
//
- MEDFileUtilities::AutoFid fid(MEDCoupling::OpenMEDFileForRead(fileName));
- med_int nbFields=MEDnField(fid);
+ MEDFileUtilities::AutoFid const fid(MEDCoupling::OpenMEDFileForRead(fileName));
+ med_int const nbFields=MEDnField(fid);
//
med_field_type typcha;
INTERP_KERNEL::AutoPtr<char> dt_unit=MEDLoaderBase::buildEmptyString(MED_LNAME_SIZE);
//
for(int i=0;i<nbFields;i++)
{
- med_int ncomp(MEDfieldnComponent(fid,i+1));
+ med_int const ncomp(MEDfieldnComponent(fid,i+1));
INTERP_KERNEL::AutoPtr<char> comp=new char[ncomp*MED_SNAME_SIZE+1];
INTERP_KERNEL::AutoPtr<char> unit=new char[ncomp*MED_SNAME_SIZE+1];
med_int nbPdt;
INTERP_KERNEL::AutoPtr<char> maa_ass=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
MEDFILESAFECALLERRD0(MEDfieldInfo,(fid,i+1,nomcha,maa_ass,&localmesh,&typcha,comp,unit,dt_unit,&nbPdt));
- std::string meshName=MEDLoaderBase::buildStringFromFortran(maa_ass,MED_NAME_SIZE);
- std::string curFieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE+1);
+ std::string const meshName=MEDLoaderBase::buildStringFromFortran(maa_ass,MED_NAME_SIZE);
+ std::string const curFieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE+1);
if(curFieldName==fieldName)
ret.push_back(meshName);
}
std::vector<std::string> MEDCoupling::GetMeshFamiliesNames(const std::string& fileName, const std::string& meshName)
{
- MEDFileUtilities::AutoFid fid(MEDCoupling::OpenMEDFileForRead(fileName));
- med_int nfam=MEDnFamily(fid,meshName.c_str());
+ MEDFileUtilities::AutoFid const fid(MEDCoupling::OpenMEDFileForRead(fileName));
+ med_int const nfam=MEDnFamily(fid,meshName.c_str());
std::vector<std::string> ret(nfam);
char nomfam[MED_NAME_SIZE+1];
med_int numfam;
for(int i=0;i<nfam;i++)
{
- med_int ngro=MEDnFamilyGroup(fid,meshName.c_str(),i+1);
- med_int natt=MEDnFamily23Attribute(fid,meshName.c_str(),i+1);
+ med_int const ngro=MEDnFamilyGroup(fid,meshName.c_str(),i+1);
+ med_int const natt=MEDnFamily23Attribute(fid,meshName.c_str(),i+1);
INTERP_KERNEL::AutoPtr<med_int> attide=new med_int[natt];
INTERP_KERNEL::AutoPtr<med_int> attval=new med_int[natt];
INTERP_KERNEL::AutoPtr<char> attdes=new char[MED_COMMENT_SIZE*natt+1];
INTERP_KERNEL::AutoPtr<char> gro=new char[MED_LNAME_SIZE*ngro+1];
MEDfamily23Info(fid,meshName.c_str(),i+1,nomfam,attide,attval,attdes,&numfam,gro);
- std::string cur=MEDLoaderBase::buildStringFromFortran(nomfam,sizeof(nomfam));
+ std::string const cur=MEDLoaderBase::buildStringFromFortran(nomfam,sizeof(nomfam));
ret[i]=cur;
}
return ret;
std::vector<std::string> MEDCoupling::GetMeshFamiliesNamesOnGroup(const std::string& fileName, const std::string& meshName, const std::string& grpName)
{
- MEDFileUtilities::AutoFid fid(MEDCoupling::OpenMEDFileForRead(fileName));
- med_int nfam=MEDnFamily(fid,meshName.c_str());
+ MEDFileUtilities::AutoFid const fid(MEDCoupling::OpenMEDFileForRead(fileName));
+ med_int const nfam=MEDnFamily(fid,meshName.c_str());
std::vector<std::string> ret;
char nomfam[MED_NAME_SIZE+1];
med_int numfam;
for(int i=0;i<nfam;i++)
{
- med_int ngro=MEDnFamilyGroup(fid,meshName.c_str(),i+1);
- med_int natt=MEDnFamily23Attribute(fid,meshName.c_str(),i+1);
+ med_int const ngro=MEDnFamilyGroup(fid,meshName.c_str(),i+1);
+ med_int const natt=MEDnFamily23Attribute(fid,meshName.c_str(),i+1);
INTERP_KERNEL::AutoPtr<med_int> attide=new med_int[natt];
INTERP_KERNEL::AutoPtr<med_int> attval=new med_int[natt];
INTERP_KERNEL::AutoPtr<char> attdes=new char[MED_COMMENT_SIZE*natt+1];
INTERP_KERNEL::AutoPtr<char> gro=new char[MED_LNAME_SIZE*ngro+1];
MEDfamily23Info(fid,meshName.c_str(),i+1,nomfam,attide,attval,attdes,&numfam,gro);
- std::string cur=MEDLoaderBase::buildStringFromFortran(nomfam,sizeof(nomfam));
+ std::string const cur=MEDLoaderBase::buildStringFromFortran(nomfam,sizeof(nomfam));
for(int j=0;j<ngro;j++)
{
- std::string cur2=MEDLoaderBase::buildStringFromFortran(gro+j*MED_LNAME_SIZE,MED_LNAME_SIZE);
+ std::string const cur2=MEDLoaderBase::buildStringFromFortran(gro+j*MED_LNAME_SIZE,MED_LNAME_SIZE);
if(cur2==grpName)
ret.push_back(cur);
}
std::vector<std::string> MEDCoupling::GetMeshGroupsNamesOnFamily(const std::string& fileName, const std::string& meshName, const std::string& famName)
{
- MEDFileUtilities::AutoFid fid(MEDCoupling::OpenMEDFileForRead(fileName));
- med_int nfam(MEDnFamily(fid,meshName.c_str()));
+ MEDFileUtilities::AutoFid const fid(MEDCoupling::OpenMEDFileForRead(fileName));
+ med_int const nfam(MEDnFamily(fid,meshName.c_str()));
std::vector<std::string> ret;
char nomfam[MED_NAME_SIZE+1];
med_int numfam;
bool found=false;
for(int i=0;i<nfam && !found;i++)
{
- med_int ngro=MEDnFamilyGroup(fid,meshName.c_str(),i+1);
- med_int natt=MEDnFamily23Attribute(fid,meshName.c_str(),i+1);
+ med_int const ngro=MEDnFamilyGroup(fid,meshName.c_str(),i+1);
+ med_int const natt=MEDnFamily23Attribute(fid,meshName.c_str(),i+1);
INTERP_KERNEL::AutoPtr<med_int> attide=new med_int[natt];
INTERP_KERNEL::AutoPtr<med_int> attval=new med_int[natt];
INTERP_KERNEL::AutoPtr<char> attdes=new char[MED_COMMENT_SIZE*natt+1];
INTERP_KERNEL::AutoPtr<char> gro=new char[MED_LNAME_SIZE*ngro+1];
MEDfamily23Info(fid,meshName.c_str(),i+1,nomfam,attide,attval,attdes,&numfam,gro);
- std::string cur=MEDLoaderBase::buildStringFromFortran(nomfam,sizeof(nomfam));
+ std::string const cur=MEDLoaderBase::buildStringFromFortran(nomfam,sizeof(nomfam));
found=(cur==famName);
if(found)
for(int j=0;j<ngro;j++)
{
- std::string cur2=MEDLoaderBase::buildStringFromFortran(gro+j*MED_LNAME_SIZE,MED_LNAME_SIZE);
+ std::string const cur2=MEDLoaderBase::buildStringFromFortran(gro+j*MED_LNAME_SIZE,MED_LNAME_SIZE);
ret.push_back(cur2);
}
}
std::vector<std::string> MEDCoupling::GetMeshGroupsNames(const std::string& fileName, const std::string& meshName)
{
- MEDFileUtilities::AutoFid fid(MEDCoupling::OpenMEDFileForRead(fileName));
- med_int nfam=MEDnFamily(fid,meshName.c_str());
+ MEDFileUtilities::AutoFid const fid(MEDCoupling::OpenMEDFileForRead(fileName));
+ med_int const nfam=MEDnFamily(fid,meshName.c_str());
std::vector<std::string> ret;
char nomfam[MED_NAME_SIZE+1];
med_int numfam;
for(int i=0;i<nfam;i++)
{
- med_int ngro=MEDnFamilyGroup(fid,meshName.c_str(),i+1);
- med_int natt=MEDnFamily23Attribute(fid,meshName.c_str(),i+1);
+ med_int const ngro=MEDnFamilyGroup(fid,meshName.c_str(),i+1);
+ med_int const natt=MEDnFamily23Attribute(fid,meshName.c_str(),i+1);
INTERP_KERNEL::AutoPtr<med_int> attide=new med_int[natt];
INTERP_KERNEL::AutoPtr<med_int> attval=new med_int[natt];
INTERP_KERNEL::AutoPtr<char> attdes=new char[MED_COMMENT_SIZE*natt+1];
MEDfamily23Info(fid,meshName.c_str(),i+1,nomfam,attide,attval,attdes,&numfam,gro);
for(int j=0;j<ngro;j++)
{
- std::string cur=MEDLoaderBase::buildStringFromFortran(gro+j*MED_LNAME_SIZE,MED_LNAME_SIZE);
+ std::string const cur=MEDLoaderBase::buildStringFromFortran(gro+j*MED_LNAME_SIZE,MED_LNAME_SIZE);
if(std::find(ret.begin(),ret.end(),cur)==ret.end())
ret.push_back(cur);
}
oss << " The name of the mesh in file is \"" << fs->getMeshName() << "\"!";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- int nbTS(fs->getNumberOfTS());
+ int const nbTS(fs->getNumberOfTS());
if(nbTS==0)
return ret;
for(int i=0;i<nbTS;i++)
{
MCAuto<MEDFileAnyTypeField1TS> f1ts(fs->getTimeStepAtPos(i));
- std::vector<MEDCoupling::TypeOfField> tof(f1ts->getTypesOfFieldAvailable());
- for(std::vector<MEDCoupling::TypeOfField>::const_iterator it=tof.begin();it!=tof.end();it++)
- if(std::find(ret.begin(),ret.end(),*it)==ret.end())
- ret.push_back(*it);
+ std::vector<MEDCoupling::TypeOfField> const tof(f1ts->getTypesOfFieldAvailable());
+ for(auto it : tof)
+ if(std::find(ret.begin(),ret.end(),it)==ret.end())
+ ret.push_back(it);
}
// sort ret to put before ON_NODES then ON_CELLS then the remaining.
std::vector<MEDCoupling::TypeOfField> ret2;
ret2.push_back(ON_NODES);
if(std::find(ret.begin(),ret.end(),ON_CELLS)!=ret.end())
ret2.push_back(ON_CELLS);
- for(std::vector<MEDCoupling::TypeOfField>::const_iterator it=ret.begin();it!=ret.end();it++)
- if(*it!=ON_NODES && *it!=ON_CELLS)
- ret2.push_back(*it);
+ for(auto it : ret)
+ if(it!=ON_NODES && it!=ON_CELLS)
+ ret2.push_back(it);
return ret2;
}
std::vector<std::string> MEDCoupling::GetAllFieldNames(const std::string& fileName)
{
std::vector<std::string> ret;
- MEDFileUtilities::AutoFid fid(MEDCoupling::OpenMEDFileForRead(fileName));
- med_int nbFields=MEDnField(fid);
+ MEDFileUtilities::AutoFid const fid(MEDCoupling::OpenMEDFileForRead(fileName));
+ med_int const nbFields=MEDnField(fid);
med_field_type typcha;
for(int i=0;i<nbFields;i++)
{
- med_int ncomp(MEDfieldnComponent(fid,i+1));
+ med_int const ncomp(MEDfieldnComponent(fid,i+1));
INTERP_KERNEL::AutoPtr<char> comp=new char[ncomp*MED_SNAME_SIZE+1];
INTERP_KERNEL::AutoPtr<char> unit=new char[ncomp*MED_SNAME_SIZE+1];
INTERP_KERNEL::AutoPtr<char> nomcha=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
std::vector<std::string> MEDCoupling::GetAllFieldNamesOnMesh(const std::string& fileName, const std::string& meshName)
{
std::vector<std::string> ret;
- MEDFileUtilities::AutoFid fid(MEDCoupling::OpenMEDFileForRead(fileName));
- med_int nbFields=MEDnField(fid);
+ MEDFileUtilities::AutoFid const fid(MEDCoupling::OpenMEDFileForRead(fileName));
+ med_int const nbFields=MEDnField(fid);
//
med_field_type typcha;
char *maa_ass=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
//
for(int i=0;i<nbFields;i++)
{
- med_int ncomp(MEDfieldnComponent(fid,i+1));
+ med_int const ncomp(MEDfieldnComponent(fid,i+1));
INTERP_KERNEL::AutoPtr<char> comp=new char[ncomp*MED_SNAME_SIZE+1];
INTERP_KERNEL::AutoPtr<char> unit=new char[ncomp*MED_SNAME_SIZE+1];
INTERP_KERNEL::AutoPtr<char> dt_unit=new char[MED_LNAME_SIZE+1];
med_int nbPdt;
med_bool localmesh;
MEDFILESAFECALLERRD0(MEDfieldInfo,(fid,i+1,nomcha,maa_ass,&localmesh,&typcha,comp,unit,dt_unit,&nbPdt));
- std::string curFieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE+1);
- std::string curMeshName=MEDLoaderBase::buildStringFromFortran(maa_ass,MED_NAME_SIZE+1);
+ std::string const curFieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE+1);
+ std::string const curMeshName=MEDLoaderBase::buildStringFromFortran(maa_ass,MED_NAME_SIZE+1);
//
if(curMeshName==meshName)
ret.push_back(curFieldName);
std::vector<std::string> MEDCoupling::GetCellFieldNamesOnMesh(const std::string& fileName, const std::string& meshName)
{
std::vector<std::string> ret;
- MEDFileUtilities::AutoFid fid(MEDCoupling::OpenMEDFileForRead(fileName));
- med_int nbFields=MEDnField(fid);
+ MEDFileUtilities::AutoFid const fid(MEDCoupling::OpenMEDFileForRead(fileName));
+ med_int const nbFields=MEDnField(fid);
//
med_field_type typcha;
//med_int nbpdtnor=0,pflsize,*pflval,lnsize;
//
for(int i=0;i<nbFields;i++)
{
- med_int ncomp(MEDfieldnComponent(fid,i+1));
+ med_int const ncomp(MEDfieldnComponent(fid,i+1));
INTERP_KERNEL::AutoPtr<char> comp=new char[ncomp*MED_SNAME_SIZE+1];
INTERP_KERNEL::AutoPtr<char> unit=new char[ncomp*MED_SNAME_SIZE+1];
MEDFILESAFECALLERRD0(MEDfieldInfo,(fid,i+1,nomcha,maa_ass,&localmesh,&typcha,comp,unit,dt_unit,&nbPdt));
- std::string curFieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE+1);
- std::string curMeshName=MEDLoaderBase::buildStringFromFortran(maa_ass,MED_NAME_SIZE+1);
+ std::string const curFieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE+1);
+ std::string const curMeshName=MEDLoaderBase::buildStringFromFortran(maa_ass,MED_NAME_SIZE+1);
med_int profilesize,nbi;
if(curMeshName==meshName)
{
if(nbPdt>0)
{
MEDFILESAFECALLERRD0(MEDfieldComputingStepInfo,(fid,nomcha,1,&numdt,&numo,&dt));
- med_int nbOfVal(MEDfieldnValueWithProfile(fid,nomcha,numdt,numo,MED_CELL,typmai[j],1,MED_COMPACT_PFLMODE,
+ med_int const nbOfVal(MEDfieldnValueWithProfile(fid,nomcha,numdt,numo,MED_CELL,typmai[j],1,MED_COMPACT_PFLMODE,
pflname,&profilesize,locname,&nbi));
if(nbOfVal>0)
{
std::vector<std::string> MEDCoupling::GetNodeFieldNamesOnMesh(const std::string& fileName, const std::string& meshName)
{
std::vector<std::string> ret;
- MEDFileUtilities::AutoFid fid(MEDCoupling::OpenMEDFileForRead(fileName));
- med_int nbFields=MEDnField(fid);
+ MEDFileUtilities::AutoFid const fid(MEDCoupling::OpenMEDFileForRead(fileName));
+ med_int const nbFields=MEDnField(fid);
char pflname[MED_NAME_SIZE+1]="";
char locname[MED_NAME_SIZE+1]="";
//
//
for(int i=0;i<nbFields;i++)
{
- med_int ncomp(MEDfieldnComponent(fid,i+1));
+ med_int const ncomp(MEDfieldnComponent(fid,i+1));
INTERP_KERNEL::AutoPtr<char> comp=new char[ncomp*MED_SNAME_SIZE+1];
INTERP_KERNEL::AutoPtr<char> unit=new char[ncomp*MED_SNAME_SIZE+1];
med_int nbPdt;
MEDFILESAFECALLERRD0(MEDfieldInfo,(fid,i+1,nomcha,maa_ass,&localmesh,&typcha,comp,unit,dt_unit,&nbPdt));
- std::string curFieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE+1);
- std::string curMeshName=MEDLoaderBase::buildStringFromFortran(maa_ass,MED_NAME_SIZE+1);
+ std::string const curFieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE+1);
+ std::string const curMeshName=MEDLoaderBase::buildStringFromFortran(maa_ass,MED_NAME_SIZE+1);
if(nbPdt>0)
{
med_int profilesize,nbi;
MEDFILESAFECALLERRD0(MEDfieldComputingStepInfo,(fid,nomcha,1,&numdt,&numo,&dt));
- med_int nbOfVal(MEDfieldnValueWithProfile(fid,nomcha,numdt,numo,MED_NODE,MED_NONE,1,MED_COMPACT_PFLMODE,
+ med_int const nbOfVal(MEDfieldnValueWithProfile(fid,nomcha,numdt,numo,MED_NODE,MED_NONE,1,MED_COMPACT_PFLMODE,
pflname,&profilesize,locname,&nbi));
if(curMeshName==meshName && nbOfVal>0)
{
std::vector< std::pair< std::pair<int,int>, double> > MEDCoupling::GetAllFieldIterations(const std::string& fileName, const std::string& fieldName)
{
std::vector< std::pair< std::pair<int,int>, double > > ret;
- MEDFileUtilities::AutoFid fid(MEDCoupling::OpenMEDFileForRead(fileName));
- med_int nbFields=MEDnField(fid);
+ MEDFileUtilities::AutoFid const fid(MEDCoupling::OpenMEDFileForRead(fileName));
+ med_int const nbFields=MEDnField(fid);
//
med_field_type typcha;
med_int numdt=0,numo=0;
std::ostringstream oss; oss << "GetAllFieldIterations : No field with name \"" << fieldName<< "\" in file \"" << fileName << "\" ! Possible fields are : ";
for(int i=0;i<nbFields;i++)
{
- med_int ncomp(MEDfieldnComponent(fid,i+1));
+ med_int const ncomp(MEDfieldnComponent(fid,i+1));
INTERP_KERNEL::AutoPtr<char> comp=new char[ncomp*MED_SNAME_SIZE+1];
INTERP_KERNEL::AutoPtr<char> unit=new char[ncomp*MED_SNAME_SIZE+1];
med_int nbPdt;
MEDFILESAFECALLERRD0(MEDfieldInfo,(fid,i+1,nomcha,maa_ass,&localmesh,&typcha,comp,unit,dt_unit,&nbPdt));
- std::string curFieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE+1);
+ std::string const curFieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE+1);
if(curFieldName==fieldName)
{
for(int k=0;k<nbPdt;k++)
double MEDCoupling::GetTimeAttachedOnFieldIteration(const std::string& fileName, const std::string& fieldName, int iteration, int order)
{
- MEDFileUtilities::AutoFid fid(MEDCoupling::OpenMEDFileForRead(fileName));
- med_int nbFields=MEDnField(fid);
+ MEDFileUtilities::AutoFid const fid(MEDCoupling::OpenMEDFileForRead(fileName));
+ med_int const nbFields=MEDnField(fid);
//
med_field_type typcha;
med_int numdt=0,numo=0;
double ret=std::numeric_limits<double>::max();
for(int i=0;i<nbFields && !found;i++)
{
- med_int ncomp(MEDfieldnComponent(fid,i+1));
+ med_int const ncomp(MEDfieldnComponent(fid,i+1));
INTERP_KERNEL::AutoPtr<char> comp=new char[ncomp*MED_SNAME_SIZE+1];
INTERP_KERNEL::AutoPtr<char> unit=new char[ncomp*MED_SNAME_SIZE+1];
med_int nbPdt;
MEDFILESAFECALLERRD0(MEDfieldInfo,(fid,i+1,nomcha,maa_ass,&local,&typcha,comp,unit,dt_unit,&nbPdt));
- std::string curFieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE+1);
+ std::string const curFieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE+1);
if(curFieldName==fieldName)
{
found=true;
std::vector< std::pair<int,int> > MEDCoupling::GetCellFieldIterations(const std::string& fileName, const std::string& meshName, const std::string& fieldName)
{
- std::string meshNameCpp(meshName);
+ std::string const meshNameCpp(meshName);
std::vector< std::pair<int,int> > ret;
- MEDFileUtilities::AutoFid fid(MEDCoupling::OpenMEDFileForRead(fileName));
- med_int nbFields=MEDnField(fid);
+ MEDFileUtilities::AutoFid const fid(MEDCoupling::OpenMEDFileForRead(fileName));
+ med_int const nbFields=MEDnField(fid);
//
med_field_type typcha;
med_int numdt=0,numo=0;
std::set<std::string> s2;
for(int i=0;i<nbFields;i++)
{
- med_int ncomp(MEDfieldnComponent(fid,i+1));
+ med_int const ncomp(MEDfieldnComponent(fid,i+1));
INTERP_KERNEL::AutoPtr<char> comp=new char[ncomp*MED_SNAME_SIZE+1];
INTERP_KERNEL::AutoPtr<char> unit=new char[ncomp*MED_SNAME_SIZE+1];
med_int nbPdt;
MEDFILESAFECALLERRD0(MEDfieldInfo,(fid,i+1,nomcha,maa_ass,&localmesh,&typcha,comp,unit,dt_unit,&nbPdt));
- std::string curFieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE+1);
+ std::string const curFieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE+1);
if(curFieldName==fieldName)
{
bool found=false;
{
med_int profilesize,nbi;
MEDFILESAFECALLERRD0(MEDfieldComputingStepInfo,(fid,nomcha,k+1,&numdt,&numo,&dt));
- med_int nbOfVal(MEDfieldnValueWithProfile(fid,nomcha,numdt,numo,MED_CELL,typmai[j],1,MED_COMPACT_PFLMODE,
+ med_int const nbOfVal(MEDfieldnValueWithProfile(fid,nomcha,numdt,numo,MED_CELL,typmai[j],1,MED_COMPACT_PFLMODE,
pflname,&profilesize,locname,&nbi));
- std::string maa_ass_cpp(maa_ass);
+ std::string const maa_ass_cpp(maa_ass);
if(nbOfVal>0)
{
if(meshNameCpp==maa_ass_cpp)
std::vector< std::pair<int,int> > MEDCoupling::GetNodeFieldIterations(const std::string& fileName, const std::string& meshName, const std::string& fieldName)
{
- std::string meshNameCpp(meshName);
+ std::string const meshNameCpp(meshName);
std::vector< std::pair<int,int> > ret;
- MEDFileUtilities::AutoFid fid(MEDCoupling::OpenMEDFileForRead(fileName));
- med_int nbFields=MEDnField(fid);
+ MEDFileUtilities::AutoFid const fid(MEDCoupling::OpenMEDFileForRead(fileName));
+ med_int const nbFields=MEDnField(fid);
//
med_field_type typcha;
med_int numdt=0,numo=0;
std::set<std::string> s2;
for(int i=0;i<nbFields;i++)
{
- med_int ncomp(MEDfieldnComponent(fid,i+1));
+ med_int const ncomp(MEDfieldnComponent(fid,i+1));
INTERP_KERNEL::AutoPtr<char> comp=new char[ncomp*MED_SNAME_SIZE+1];
INTERP_KERNEL::AutoPtr<char> unit=new char[ncomp*MED_SNAME_SIZE+1];
med_int nbPdt;
MEDFILESAFECALLERRD0(MEDfieldInfo,(fid,i+1,nomcha,maa_ass,&localmesh,&typcha,comp,unit,dt_unit,&nbPdt));
- std::string curFieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE+1);
+ std::string const curFieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE+1);
if(curFieldName==fieldName)
{
for(int k=0;k<nbPdt;k++)
{
med_int profilesize,nbi;
MEDFILESAFECALLERRD0(MEDfieldComputingStepInfo,(fid,nomcha,k+1,&numdt,&numo,&dt));
- med_int nbOfVal(MEDfieldnValueWithProfile(fid,nomcha,numdt,numo,MED_NODE,MED_NONE,1,MED_COMPACT_PFLMODE,
+ med_int const nbOfVal(MEDfieldnValueWithProfile(fid,nomcha,numdt,numo,MED_NODE,MED_NONE,1,MED_COMPACT_PFLMODE,
pflname,&profilesize,locname,&nbi));
- std::string maa_ass_cpp(maa_ass);
+ std::string const maa_ass_cpp(maa_ass);
if(nbOfVal>0)
{
if(meshNameCpp==maa_ass_cpp)
MEDCoupling::CheckFileForRead(fileName);
MCAuto<MEDFileMesh> mm(MEDFileMesh::New(fileName,meshName));
MEDFileMesh *mmPtr(mm);
- MEDFileUMesh *mmuPtr=dynamic_cast<MEDFileUMesh *>(mmPtr);
+ auto *mmuPtr=dynamic_cast<MEDFileUMesh *>(mmPtr);
if(mmuPtr)
return mmuPtr->getMeshAtLevel(meshDimRelToMax,true);
- MEDFileCMesh *mmcPtr=dynamic_cast<MEDFileCMesh *>(mmPtr);
+ auto *mmcPtr=dynamic_cast<MEDFileCMesh *>(mmPtr);
if(mmcPtr)
{
const MEDCouplingCMesh *ret(mmcPtr->getMesh()); ret->incrRef();
return const_cast<MEDCouplingCMesh *>(ret);
}
- MEDFileCurveLinearMesh *mmc2Ptr=dynamic_cast<MEDFileCurveLinearMesh *>(mmPtr);
+ auto *mmc2Ptr=dynamic_cast<MEDFileCurveLinearMesh *>(mmPtr);
if(mmc2Ptr)
{
const MEDCouplingCurveLinearMesh *ret(mmc2Ptr->getMesh()); ret->incrRef();
MEDCoupling::CheckFileForRead(fileName);
MCAuto<MEDFileMesh> mm(MEDFileMesh::New(fileName));
MEDFileMesh *mmPtr(mm);
- MEDFileUMesh *mmuPtr=dynamic_cast<MEDFileUMesh *>(mmPtr);
+ auto *mmuPtr=dynamic_cast<MEDFileUMesh *>(mmPtr);
if(mmuPtr)
return mmuPtr->getMeshAtLevel(meshDimRelToMax,true);
- MEDFileCMesh *mmcPtr=dynamic_cast<MEDFileCMesh *>(mmPtr);
+ auto *mmcPtr=dynamic_cast<MEDFileCMesh *>(mmPtr);
if(mmcPtr)
{
const MEDCouplingCMesh *ret(mmcPtr->getMesh()); ret->incrRef();
return const_cast<MEDCouplingCMesh *>(ret);
}
- MEDFileCurveLinearMesh *mmc2Ptr=dynamic_cast<MEDFileCurveLinearMesh *>(mmPtr);
+ auto *mmc2Ptr=dynamic_cast<MEDFileCurveLinearMesh *>(mmPtr);
if(mmc2Ptr)
{
const MEDCouplingCurveLinearMesh *ret(mmc2Ptr->getMesh()); ret->incrRef();
MEDCoupling::CheckFileForRead(fileName);
MCAuto<MEDFileMesh> mm(MEDFileMesh::New(fileName,meshName));
MEDFileMesh *mmPtr(mm);
- MEDFileUMesh *mmuPtr=dynamic_cast<MEDFileUMesh *>(mmPtr);
+ auto *mmuPtr=dynamic_cast<MEDFileUMesh *>(mmPtr);
if(!mmuPtr)
{
std::ostringstream oss; oss << "ReadUMeshFromFile : With fileName=\""<< fileName << "\", meshName=\""<< meshName << "\" exists but it is not an unstructured mesh !";
MEDCoupling::CheckFileForRead(fileName);
MCAuto<MEDFileMesh> mm(MEDFileMesh::New(fileName));
MEDFileMesh *mmPtr(mm);
- MEDFileUMesh *mmuPtr=dynamic_cast<MEDFileUMesh *>(mmPtr);
+ auto *mmuPtr=dynamic_cast<MEDFileUMesh *>(mmPtr);
if(!mmuPtr)
{
std::ostringstream oss; oss << "ReadUMeshFromFile : With fileName=\""<< fileName << "\", meshName (the first) =\""<< mm->getName() << "\" exists but it is not an unstructured mesh !";
MEDCoupling::CheckFileForRead(fileName);
MCAuto<MEDFileMesh> mm(MEDFileMesh::New(fileName,meshName));
MEDFileMesh *mmPtr(mm);
- MEDFileUMesh *mmuPtr=dynamic_cast<MEDFileUMesh *>(mmPtr);
+ auto *mmuPtr=dynamic_cast<MEDFileUMesh *>(mmPtr);
if(!mmuPtr)
{
std::ostringstream oss; oss << "ReadUMeshFromFamilies : With fileName=\""<< fileName << "\", meshName (the first) =\""<< mm->getName() << "\" exists but it is not an unstructured mesh !";
MEDCoupling::CheckFileForRead(fileName);
MCAuto<MEDFileMesh> mm=MEDFileMesh::New(fileName,meshName);
MEDFileMesh *mmPtr(mm);
- MEDFileUMesh *mmuPtr=dynamic_cast<MEDFileUMesh *>(mmPtr);
+ auto *mmuPtr=dynamic_cast<MEDFileUMesh *>(mmPtr);
if(!mmuPtr)
{
std::ostringstream oss; oss << "ReadUMeshFromGroups : With fileName=\""<< fileName << "\", meshName (the first) =\""<< mm->getName() << "\" exists but it is not an unstructured mesh !";
MCAuto<MEDCoupling::MEDCouplingField> MEDCoupling::ReadField(const std::string& fileName)
{
std::vector<std::string> fieldNames(GetAllFieldNames(fileName));
- std::size_t sz(fieldNames.size());
+ std::size_t const sz(fieldNames.size());
if(sz==0)
{
std::ostringstream oss;
oss << "In file \"" << fileName << "\" there are more than one field !" << std::endl;
oss << "You are invited to use ReadField(fileName, fieldName) instead to avoid misleading concerning field you want to read !" << std::endl;
oss << "For information, fields available are :" << std::endl;
- for(std::vector<std::string>::const_iterator it=fieldNames.begin();it!=fieldNames.end();it++)
- oss << " - \"" << *it << "\"" << std::endl;
+ for(const auto & fieldName : fieldNames)
+ oss << " - \"" << fieldName << "\"" << std::endl;
throw INTERP_KERNEL::Exception(oss.str());
}
return ReadField(fileName,fieldNames[0]);
MCAuto<MEDCoupling::MEDCouplingField> MEDCoupling::ReadField(const std::string& fileName, const std::string& fieldName)
{
std::vector< std::pair< std::pair<int,int>, double> > iterations(GetAllFieldIterations(fileName,fieldName));
- std::size_t sz(iterations.size());
+ std::size_t const sz(iterations.size());
if(sz==0)
{
std::ostringstream oss;
oss << "In file \"" << fileName << "\" field \"" << fieldName << "\" exists but with more than one time steps !" << std::endl;
oss << "You are invited to use ReadField(fileName, fieldName, iteration, order) instead to avoid misleading concerning time steps." << std::endl;
oss << "For information, time steps available for field \"" << fieldName << "\" are :" << std::endl;
- for(std::vector< std::pair< std::pair<int,int>, double> >::const_iterator it=iterations.begin();it!=iterations.end();it++)
- oss << " - " << (*it).first.first << ", " << (*it).first.second << " (" << (*it).second << ")" << std::endl;
+ for(const auto & iteration : iterations)
+ oss << " - " << iteration.first.first << ", " << iteration.first.second << " (" << iteration.second << ")" << std::endl;
throw INTERP_KERNEL::Exception(oss.str());
}
return ReadField(fileName,fieldName,iterations[0].first.first,iterations[0].first.second);
//Retrieving mesh of rank 0 and field on rank 0 too.
MCAuto<MEDFileMesh> mm=MEDFileMesh::New(fileName,meshName);
MEDFileMesh *mmPtr(mm);
- MEDFileUMesh *mmuPtr=dynamic_cast<MEDFileUMesh *>(mmPtr);
+ auto *mmuPtr=dynamic_cast<MEDFileUMesh *>(mmPtr);
if(!mmuPtr)
throw INTERP_KERNEL::Exception("ReadFieldsOnSameMesh : only unstructured mesh is managed !");
MCAuto<MEDCouplingUMesh> m=mmuPtr->getMeshAtLevel(meshDimRelToMax);
if(o2n)
m2->renumberCells(o2n->begin(),true);
int i=0;
- for(std::vector<std::pair<int,int> >::const_iterator it=its.begin();it!=its.end();it++,i++)
+ for(auto it=its.begin();it!=its.end();it++,i++)
{
MCAuto<MEDFileField1TS> ff=MEDFileField1TS::New(fileName,fieldName,(*it).first,(*it).second);
MCAuto<MEDCouplingFieldDouble> retElt=ff->getFieldOnMeshAtLevel(type,m);
retSafe[i]=retElt;
}
i=0;
- for(std::vector<std::pair<int,int> >::const_iterator it=its.begin();it!=its.end();it++,i++)
+ for(auto it=its.begin();it!=its.end();it++,i++)
ret[i]=retSafe[i].retn();
return ret;
}
namespace MEDCoupling
{
template<class T>
- MCAuto<typename Traits<T>::FieldType> ReadFieldCellLikeT(typename MLFieldTraits<T>::F1TSType *ff, MEDCoupling::TypeOfField type, const std::string& fileName, const std::string& meshName, int meshDimRelToMax, const std::string& fieldName, int iteration, int order)
+ MCAuto<typename Traits<T>::FieldType> ReadFieldCellLikeT(typename MLFieldTraits<T>::F1TSType *ff, MEDCoupling::TypeOfField type, const std::string& fileName, const std::string& meshName, int meshDimRelToMax, const std::string& /*fieldName*/, int /*iteration*/, int /*order*/)
{
MCAuto<MEDFileMesh> mm(MEDFileMesh::New(fileName,meshName));
MCAuto<MEDFileUMesh> muPtr(MEDCoupling::DynamicCast<MEDFileMesh,MEDFileUMesh>(mm));
}
template<class T>
- MCAuto<typename Traits<T>::FieldType> ReadFieldNodeT(typename MLFieldTraits<T>::F1TSType *ff, const std::string& fileName, const std::string& meshName, int meshDimRelToMax, const std::string& fieldName, int iteration, int order)
+ MCAuto<typename Traits<T>::FieldType> ReadFieldNodeT(typename MLFieldTraits<T>::F1TSType *ff, const std::string& fileName, const std::string& meshName, int meshDimRelToMax, const std::string& /*fieldName*/, int /*iteration*/, int /*order*/)
{
MCAuto<MEDFileMesh> mm(MEDFileMesh::New(fileName,meshName));
MCAuto<MEDCouplingMesh> m(mm->getMeshAtLevel(meshDimRelToMax,false));
MCAuto<DataArrayIdType> pflSafe(pfl);
MCAuto<DataArrayIdType> mp(m->getCellIdsFullyIncludedInNodeIds(pfl->begin(),pfl->end()));
MCAuto<MEDCouplingUMesh> mzip(static_cast<MEDCouplingUMesh *>(m->buildPartAndReduceNodes(mp->begin(),mp->end(),arr2)));
- MCAuto<DataArrayIdType> arr2Safe(arr2);
+ MCAuto<DataArrayIdType> const arr2Safe(arr2);
MCAuto<DataArrayIdType> arr3(arr2->invertArrayO2N2N2O(mzip->getNumberOfNodes()));
MCAuto<DataArrayIdType> pflSorted(pflSafe->deepCopy()); pflSorted->sort(true);
if(!arr3->isEqualWithoutConsideringStr(*pflSorted))
{
if(!mesh)
throw INTERP_KERNEL::Exception("WriteMesh : input mesh is null !");
- const MEDCouplingUMesh *um(dynamic_cast<const MEDCouplingUMesh *>(mesh));
+ const auto *um(dynamic_cast<const MEDCouplingUMesh *>(mesh));
if(um)
{
WriteUMesh(fileName,um,writeFromScratch);
return ;
}
- int mod=writeFromScratch?2:0;
- const MEDCoupling1GTUMesh *um2(dynamic_cast<const MEDCoupling1GTUMesh *>(mesh));
+ int const mod=writeFromScratch?2:0;
+ const auto *um2(dynamic_cast<const MEDCoupling1GTUMesh *>(mesh));
if(um2)
{
MCAuto<MEDFileUMesh> mmu(MEDFileUMesh::New());
mmu->write(fileName,mod);
return ;
}
- const MEDCouplingCMesh *um3(dynamic_cast<const MEDCouplingCMesh *>(mesh));
+ const auto *um3(dynamic_cast<const MEDCouplingCMesh *>(mesh));
if(um3)
{
MCAuto<MEDFileCMesh> mmc(MEDFileCMesh::New());
mmc->write(fileName,mod);
return ;
}
- const MEDCouplingCurveLinearMesh *um4(dynamic_cast<const MEDCouplingCurveLinearMesh *>(mesh));
+ const auto *um4(dynamic_cast<const MEDCouplingCurveLinearMesh *>(mesh));
if(um4)
{
MCAuto<MEDFileCurveLinearMesh> mmc(MEDFileCurveLinearMesh::New());
{
if(!mesh)
throw INTERP_KERNEL::Exception("WriteUMesh : input mesh is null !");
- int mod=writeFromScratch?2:0;
+ int const mod=writeFromScratch?2:0;
MCAuto<MEDFileUMesh> m(MEDFileUMesh::New());
AssignStaticWritePropertiesTo(*m);
MCAuto<MEDCouplingUMesh> mcpy(static_cast<MEDCouplingUMesh *>(mesh->deepCopy()));
void MEDCoupling::WriteUMeshesPartition(const std::string& fileName, const std::string& meshNameC, const std::vector<const MEDCoupling::MEDCouplingUMesh *>& meshes, bool writeFromScratch)
{
- std::string meshName(meshNameC);
+ std::string const meshName(meshNameC);
if(meshName.empty())
throw INTERP_KERNEL::Exception("Trying to write a unstructured mesh with no name ! MED file format needs a not empty mesh name : change 2nd parameter !");
- int status=MEDLoaderBase::getStatusOfFile(fileName);
+ int const status=MEDLoaderBase::getStatusOfFile(fileName);
if(status!=MEDLoaderBase::EXIST_RW && status!=MEDLoaderBase::NOT_EXIST)
{
std::ostringstream oss; oss << "File with name \'" << fileName << "\' has not valid permissions !";
AssignStaticWritePropertiesTo(*m);
m->setGroupsFromScratch(0,meshes,true);
m->setName(meshNameC);
- int mod=writeFromScratch?2:0;
+ int const mod=writeFromScratch?2:0;
m->write(fileName,mod);
}
void MEDCoupling::WriteUMeshes(const std::string& fileName, const std::vector<const MEDCoupling::MEDCouplingUMesh *>& meshes, bool writeFromScratch)
{
- int mod(writeFromScratch?2:0);
+ int const mod(writeFromScratch?2:0);
MCAuto<MEDFileUMesh> m(MEDFileUMesh::New());
AssignStaticWritePropertiesTo(*m);
m->setMeshes(meshes,true);
AssignStaticWritePropertiesTo(*ff);
MCAuto<typename MEDCoupling::Traits<T>::FieldType> f2(f->deepCopy());
const MEDCouplingMesh *m(f2->getMesh());
- const MEDCouplingUMesh *um(dynamic_cast<const MEDCouplingUMesh *>(m));
- const MEDCoupling1GTUMesh *um2(dynamic_cast<const MEDCoupling1GTUMesh *>(m));
- const MEDCouplingCMesh *um3(dynamic_cast<const MEDCouplingCMesh *>(m));
- const MEDCouplingCurveLinearMesh *um4(dynamic_cast<const MEDCouplingCurveLinearMesh *>(m));
- MCAuto<MEDFileMesh> mm;
- int mod(writeFromScratch?2:0);
+ const auto *um(dynamic_cast<const MEDCouplingUMesh *>(m));
+ const auto *um2(dynamic_cast<const MEDCoupling1GTUMesh *>(m));
+ const auto *um3(dynamic_cast<const MEDCouplingCMesh *>(m));
+ const auto *um4(dynamic_cast<const MEDCouplingCurveLinearMesh *>(m));
+ MCAuto<MEDFileMesh> const mm;
+ int const mod(writeFromScratch?2:0);
if(um)
{
MCAuto<MEDFileUMesh> mmu(MEDFileUMesh::New());
if(!f)
throw INTERP_KERNEL::Exception("WriteField : input field is NULL !");
f->checkConsistencyLight();
- int status(MEDLoaderBase::getStatusOfFile(fileName));
+ int const status(MEDLoaderBase::getStatusOfFile(fileName));
if(status!=MEDLoaderBase::EXIST_RW && status!=MEDLoaderBase::NOT_EXIST)
{
std::ostringstream oss; oss << "File with name \'" << fileName << "\' has not valid permissions !";
std::vector<std::string> meshNames(GetMeshNames(fileName));
if(!f->getMesh())
throw INTERP_KERNEL::Exception("WriteField : trying to write a field with no mesh !");
- std::string fileNameCpp(f->getMesh()->getName());
+ std::string const fileNameCpp(f->getMesh()->getName());
if(std::find(meshNames.begin(),meshNames.end(),fileNameCpp)==meshNames.end())
MEDLoaderNS::writeFieldWithoutReadingAndMappingOfMeshInFile<T>(fileName,f,false);
else
MCAuto<MEDFileMesh> mm(MEDFileMesh::New(fileName,f->getMesh()->getName().c_str()));
AssignStaticWritePropertiesTo(*mm);
const MEDFileMesh *mmPtr(mm);
- const MEDFileUMesh *mmuPtr(dynamic_cast<const MEDFileUMesh *>(mmPtr));
+ const auto *mmuPtr(dynamic_cast<const MEDFileUMesh *>(mmPtr));
if(!mmuPtr)
throw INTERP_KERNEL::Exception("WriteField : only umeshes are supported now !");
MCAuto< typename MEDCoupling::Traits<T>::FieldType > f2(f->deepCopy());
- MEDCouplingUMesh *m(dynamic_cast<MEDCouplingUMesh *>(const_cast<MEDCouplingMesh *>(f2->getMesh())));
+ auto *m(dynamic_cast<MEDCouplingUMesh *>(const_cast<MEDCouplingMesh *>(f2->getMesh())));
if(!m)
throw INTERP_KERNEL::Exception("WriteField : only umesh in input field supported !");
MCAuto<DataArrayIdType> o2n(m->getRenumArrForMEDFileFrmt());
m->tryToShareSameCoordsPermute(*mread,_EPS_FOR_NODE_COMP);
else
mread->setCoords(m->getCoords());
- DataArrayIdType *part(NULL);
- bool b(mread->areCellsIncludedIn(m,_COMP_FOR_CELL,part));
- MCAuto<DataArrayIdType> partSafe(part);
+ DataArrayIdType *part(nullptr);
+ bool const b(mread->areCellsIncludedIn(m,_COMP_FOR_CELL,part));
+ MCAuto<DataArrayIdType> const partSafe(part);
if(!b)
{
std::ostringstream oss; oss << "WriteField : The file \""<< fileName << "\" already contains a mesh named \""<< f->getMesh()->getName() << "\" and this mesh in the file is not compatible (a subpart) with the mesh you intend to write ! This is maybe due to a too strict policy ! Try with to lease it by calling SetCompPolicyForCell !";
}
else
{
- DataArrayIdType *part(NULL);
- bool b(mread->getCoords()->areIncludedInMe(m->getCoords(),_EPS_FOR_NODE_COMP,part));
- MCAuto<DataArrayIdType> partSafe(part);
+ DataArrayIdType *part(nullptr);
+ bool const b(mread->getCoords()->areIncludedInMe(m->getCoords(),_EPS_FOR_NODE_COMP,part));
+ MCAuto<DataArrayIdType> const partSafe(part);
if(!b)
{
std::ostringstream oss; oss << "WriteField : The file \""<< fileName << "\" already contains a mesh named \""<< f->getMesh()->getName() << "\" and this mesh in the file is not compatible (a subpart regarding nodes) with the mesh you intend to write ! This is maybe due to a too strict epsilon ! Try with to lease it by calling SetEpsilonForNodeComp !";
if(!f)
throw INTERP_KERNEL::Exception("WriteField : input field is null !");
{
- const MEDCoupling::MEDCouplingFieldDouble *f1(dynamic_cast<const MEDCoupling::MEDCouplingFieldDouble *>(f));
+ const auto *f1(dynamic_cast<const MEDCoupling::MEDCouplingFieldDouble *>(f));
if(f1)
{
WriteFieldT<double>(fileName,f1,writeFromScratch);
}
}
{
- const MEDCoupling::MEDCouplingFieldInt32 *f1(dynamic_cast<const MEDCoupling::MEDCouplingFieldInt32 *>(f));
+ const auto *f1(dynamic_cast<const MEDCoupling::MEDCouplingFieldInt32 *>(f));
if(f1)
{
WriteFieldT<int>(fileName,f1,writeFromScratch);
}
}
{
- const MEDCoupling::MEDCouplingFieldInt64 *f1(dynamic_cast<const MEDCoupling::MEDCouplingFieldInt64 *>(f));
+ const auto *f1(dynamic_cast<const MEDCoupling::MEDCouplingFieldInt64 *>(f));
if(f1)
{
WriteFieldT<Int64>(fileName,f1,writeFromScratch);
}
{
- const MEDCoupling::MEDCouplingFieldFloat *f1(dynamic_cast<const MEDCoupling::MEDCouplingFieldFloat *>(f));
+ const auto *f1(dynamic_cast<const MEDCoupling::MEDCouplingFieldFloat *>(f));
if(f1)
{
WriteFieldT<float>(fileName,f1,writeFromScratch);
if(!f)
throw INTERP_KERNEL::Exception("WriteFieldUsingAlreadyWrittenMeshT : input field is null !");
f->checkConsistencyLight();
- int status(MEDLoaderBase::getStatusOfFile(fileName));
+ int const status(MEDLoaderBase::getStatusOfFile(fileName));
if(status!=MEDLoaderBase::EXIST_RW)
{
std::ostringstream oss; oss << "File with name \'" << fileName << "\' has not valid permissions or not exists !";
}
MCAuto< typename MLFieldTraits<T>::F1TSType > f1ts(MLFieldTraits<T>::F1TSType::New());
AssignStaticWritePropertiesTo(*f1ts);
- MEDCouplingUMesh *m(dynamic_cast<MEDCouplingUMesh *>(const_cast<MEDCouplingMesh *>(f->getMesh())));
+ auto *m(dynamic_cast<MEDCouplingUMesh *>(const_cast<MEDCouplingMesh *>(f->getMesh())));
if(m)
{
MCAuto<DataArrayIdType> o2n(m->getRenumArrForMEDFileFrmt());
if(!f)
throw INTERP_KERNEL::Exception("WriteFieldUsingAlreadyWrittenMesh : input field is null !");
{
- const MEDCoupling::MEDCouplingFieldDouble *f1(dynamic_cast<const MEDCoupling::MEDCouplingFieldDouble *>(f));
+ const auto *f1(dynamic_cast<const MEDCoupling::MEDCouplingFieldDouble *>(f));
if(f1)
{
WriteFieldUsingAlreadyWrittenMeshT<double>(fileName,f1);
}
}
{
- const MEDCoupling::MEDCouplingFieldInt32 *f1(dynamic_cast<const MEDCoupling::MEDCouplingFieldInt32 *>(f));
+ const auto *f1(dynamic_cast<const MEDCoupling::MEDCouplingFieldInt32 *>(f));
if(f1)
{
WriteFieldUsingAlreadyWrittenMeshT<int>(fileName,f1);
}
}
{
- const MEDCoupling::MEDCouplingFieldInt64 *f1(dynamic_cast<const MEDCoupling::MEDCouplingFieldInt64 *>(f));
+ const auto *f1(dynamic_cast<const MEDCoupling::MEDCouplingFieldInt64 *>(f));
if(f1)
{
WriteFieldUsingAlreadyWrittenMeshT<Int64>(fileName,f1);
}
}
{
- const MEDCoupling::MEDCouplingFieldFloat *f1(dynamic_cast<const MEDCoupling::MEDCouplingFieldFloat *>(f));
+ const auto *f1(dynamic_cast<const MEDCoupling::MEDCouplingFieldFloat *>(f));
if(f1)
{
WriteFieldUsingAlreadyWrittenMeshT<float>(fileName,f1);
#pragma once
#include "MEDLoaderDefines.hxx"
-#include "InterpKernelException.hxx"
#include "MEDCouplingRefCountObject.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
#include "MCAuto.hxx"
#include "MCIdType.hxx"
+#include "NormalizedGeometricTypes"
-#include <list>
+#include <string>
+#include <utility>
+#include <map>
#include <vector>
namespace MEDCoupling
#include "MEDLoaderBase.hxx"
#include "InterpKernelException.hxx"
+#include <algorithm>
#include <sstream>
#include <fstream>
#include <cstring>
#include <iostream>
+#include <string>
const char MEDLoaderBase::WHITE_SPACES[]=" \n";
ifs.close();
return NOT_EXIST;
}
- std::ofstream ofs(fileName.c_str(),std::ios_base::app);
+ std::ofstream const ofs(fileName.c_str(),std::ios_base::app);
if((ofs.rdstate() & std::ofstream::failbit)!=0)
{
return EXIST_RDONLY;
void MEDLoaderBase::getDirAndBaseName(const std::string& fullName, std::string& dirName, std::string& baseName)
{
- std::size_t pos=fullName.find_last_of(getPathSep());
+ std::size_t const pos=fullName.find_last_of(getPathSep());
if(pos!=std::string::npos)
{
dirName=fullName.substr(0,pos);
void MEDLoaderBase::splitIntoNameAndUnit(const std::string& s, std::string& name, std::string& unit)
{
- std::string::size_type f1=s.find_first_of('[');
- std::string::size_type f2=s.find_last_of(']');
+ std::string::size_type const f1=s.find_first_of('[');
+ std::string::size_type const f2=s.find_last_of(']');
if(f1!=std::string::npos && f2!=std::string::npos)
{
if(f1<f2)
void MEDLoaderBase::strip(std::string& s)
{
- std::string::size_type f1=s.find_first_not_of(' ');
+ std::string::size_type const f1=s.find_first_not_of(' ');
if(f1==std::string::npos)
{
s="";
return ;
}
- std::string::size_type f2=s.find_last_not_of(' ');
+ std::string::size_type const f2=s.find_last_not_of(' ');
s=s.substr(f1,f2-f1+1);
}
}
else if(behaviour==1)
{
- std::string s=zipString(src,maxLgth);
+ std::string const s=zipString(src,maxLgth);
std::cerr << "A string : \"" << src << "\" has been detected to be too long for MED File ( > " << maxLgth << ") : ";
std::cerr << "zipping to : " << s << "\n";
strcpy(dest,s.c_str());
}
else if(behaviour==1)
{
- std::string s=zipString(src,maxLgth);
+ std::string const s=zipString(src,maxLgth);
std::cerr << "A string : \"" << src << "\" has been detected to be too long for MED File ( > " << maxLgth << ") : ";
std::cerr << "zipping to : " << s << "\n";
strcpy(dest,s.c_str());
return ;
}
}
- std::size_t n(strlen(src));
+ std::size_t const n(strlen(src));
std::fill(dest,dest+maxLgth,' ');
strncpy(dest,src,n);
}
std::string MEDLoaderBase::buildStringFromFortran(const char *expr, int lgth)
{
- std::string ret(expr,lgth);
- std::string whiteSpaces(WHITE_SPACES);
- std::size_t lgthReal=strlen(ret.c_str());
+ std::string const ret(expr,lgth);
+ std::string const whiteSpaces(WHITE_SPACES);
+ std::size_t const lgthReal=strlen(ret.c_str());
std::string ret2=ret.substr(0,lgthReal);
- std::size_t found=ret2.find_last_not_of(whiteSpaces);
+ std::size_t const found=ret2.find_last_not_of(whiteSpaces);
if (found!=std::string::npos)
ret2.erase(found+1);
else
{
for(std::string::iterator it=s.begin();it!=s.end();it++)
{
- char tmp=*it;
+ char const tmp=*it;
int sz=1;
for(std::string::iterator it2=it+1;it2!=s.end() && *it2==tmp;it2++)
sz++;
#define __MEDLOADERBASE_HXX__
#include "MEDLoaderDefines.hxx"
-#include "InterpKernelException.hxx"
+#include <cstddef>
#include <string>
class MEDLOADER_EXPORT MEDLoaderBase
#ifndef __MEDLOADERNS_HXX__
#define __MEDLOADERNS_HXX__
+#include "MEDCouplingTraits.hxx"
#include <vector>
#include <string>
template<class T>
struct MEDLOADER_EXPORT MLFieldTraits
{
- typedef T EltType;
+ using EltType = T;
};
class MEDFileFieldMultiTS;
template<>
struct MEDLOADER_EXPORT MLFieldTraits<double>
{
- typedef MEDFileFieldMultiTSWithoutSDA FMTSWSDAType;
- typedef MEDFileFieldMultiTS FMTSType;
- typedef MEDFileField1TS F1TSType;
- typedef MEDFileField1TSWithoutSDA F1TSWSDAType;
+ using FMTSWSDAType = MEDFileFieldMultiTSWithoutSDA;
+ using FMTSType = MEDFileFieldMultiTS;
+ using F1TSType = MEDFileField1TS;
+ using F1TSWSDAType = MEDFileField1TSWithoutSDA;
};
template<>
struct MEDLOADER_EXPORT MLFieldTraits<float>
{
- typedef MEDFileFloatFieldMultiTSWithoutSDA FMTSWSDAType;
- typedef MEDFileFloatFieldMultiTS FMTSType;
- typedef MEDFileFloatField1TS F1TSType;
- typedef MEDFileFloatField1TSWithoutSDA F1TSWSDAType;
+ using FMTSWSDAType = MEDFileFloatFieldMultiTSWithoutSDA;
+ using FMTSType = MEDFileFloatFieldMultiTS;
+ using F1TSType = MEDFileFloatField1TS;
+ using F1TSWSDAType = MEDFileFloatField1TSWithoutSDA;
};
template<>
struct MEDLOADER_EXPORT MLFieldTraits<Int32>
{
- typedef MEDFileInt32FieldMultiTSWithoutSDA FMTSWSDAType;
- typedef MEDFileInt32FieldMultiTS FMTSType;
- typedef MEDFileInt32Field1TS F1TSType;
- typedef MEDFileInt32Field1TSWithoutSDA F1TSWSDAType;
+ using FMTSWSDAType = MEDFileInt32FieldMultiTSWithoutSDA;
+ using FMTSType = MEDFileInt32FieldMultiTS;
+ using F1TSType = MEDFileInt32Field1TS;
+ using F1TSWSDAType = MEDFileInt32Field1TSWithoutSDA;
};
template<>
struct MEDLOADER_EXPORT MLFieldTraits<Int64>
{
- typedef MEDFileInt64FieldMultiTSWithoutSDA FMTSWSDAType;
- typedef MEDFileInt64FieldMultiTS FMTSType;
- typedef MEDFileInt64Field1TS F1TSType;
- typedef MEDFileInt64Field1TSWithoutSDA F1TSWSDAType;
+ using FMTSWSDAType = MEDFileInt64FieldMultiTSWithoutSDA;
+ using FMTSType = MEDFileInt64FieldMultiTS;
+ using F1TSType = MEDFileInt64Field1TS;
+ using F1TSWSDAType = MEDFileInt64Field1TSWithoutSDA;
};
template<class T>
#include "MEDMESHConverterUtilities.hxx"
-#include "libmesh5.hxx"
+#include <string>
+#include <clocale>
namespace MeshFormat
{
Localizer::Localizer()
{
- _locale = setlocale(LC_NUMERIC, NULL);
+ _locale = setlocale(LC_NUMERIC, nullptr);
setlocale(LC_NUMERIC, "C");
}
# include <string>
# include <sstream>
#include <iostream>
-# include <vector>
#include <cstring>
namespace MeshFormat
#include "MeshFormatReader.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MCType.hxx"
#include "MEDFileMesh.hxx"
#include "MEDFileField.hxx"
#include "MEDFileData.hxx"
#include "MEDCouplingFieldDouble.hxx"
+#include "NormalizedGeometricTypes"
#include "libmesh5.hxx"
#include "MEDMESHConverterUtilities.hxx"
+#include <algorithm>
#include <cstring>
-#include <fstream>
+#include <map>
+#include <string>
+#include <vector>
+#include <utility>
namespace MEDCoupling {
MeshFormatReader::MeshFormatReader():_myMeshName("MESH")
{}
MeshFormatReader::~MeshFormatReader()
-{}
+= default;
MEDCoupling::MCAuto<MEDCoupling::MEDFileData> MeshFormatReader::loadInMedFileDS()
{
_myStatus = perform();
- if(_myStatus != MeshFormat::DRS_OK) return 0;
+ if(_myStatus != MeshFormat::DRS_OK) return nullptr;
if ( !_uMesh->getName().c_str() || strlen( _uMesh->getName().c_str() ) == 0 )
_uMesh->setName( _myMeshName );
MeshFormat::Status MeshFormatReader::perform()
{
- MeshFormat::Localizer loc;
+ MeshFormat::Localizer const loc;
- MeshFormat::Status status = MeshFormat::DRS_OK;
+ MeshFormat::Status const status = MeshFormat::DRS_OK;
// open the file
setNodes(coordArray);
- int nbEdges = _reader.GmfStatKwd(_myCurrentFileId, MeshFormat::GmfEdges);
- int nbTria = _reader.GmfStatKwd(_myCurrentFileId, MeshFormat::GmfTriangles);
- int nbQuad = _reader.GmfStatKwd(_myCurrentFileId, MeshFormat::GmfQuadrilaterals);
- int nbTet = _reader.GmfStatKwd( _myCurrentFileId, MeshFormat::GmfTetrahedra );
- int nbPyr = _reader.GmfStatKwd(_myCurrentFileId, MeshFormat::GmfPyramids);
- int nbHex = _reader.GmfStatKwd(_myCurrentFileId, MeshFormat::GmfHexahedra);
- int nbPrism = _reader.GmfStatKwd(_myCurrentFileId, MeshFormat::GmfPrisms);
+ int const nbEdges = _reader.GmfStatKwd(_myCurrentFileId, MeshFormat::GmfEdges);
+ int const nbTria = _reader.GmfStatKwd(_myCurrentFileId, MeshFormat::GmfTriangles);
+ int const nbQuad = _reader.GmfStatKwd(_myCurrentFileId, MeshFormat::GmfQuadrilaterals);
+ int const nbTet = _reader.GmfStatKwd( _myCurrentFileId, MeshFormat::GmfTetrahedra );
+ int const nbPyr = _reader.GmfStatKwd(_myCurrentFileId, MeshFormat::GmfPyramids);
+ int const nbHex = _reader.GmfStatKwd(_myCurrentFileId, MeshFormat::GmfHexahedra);
+ int const nbPrism = _reader.GmfStatKwd(_myCurrentFileId, MeshFormat::GmfPrisms);
_dim1NbEl = nbEdges;
_dim2NbEl = nbTria + nbQuad;
MeshFormat::Status MeshFormatReader::performFields()
{
- MeshFormat::Status status = MeshFormat::DRS_OK;
+ MeshFormat::Status const status = MeshFormat::DRS_OK;
_fields = MEDCoupling::MEDFileFields::New();
}
- MeshFormat::GmfKwdCod kwd = meshFormatSol[0];
+ MeshFormat::GmfKwdCod const kwd = meshFormatSol[0];
int NmbSol, NmbTypes, NmbReals, TypesTab[ GmfMaxTyp ];
NmbSol = _reader.GmfStatKwd( _myCurrentFileId, kwd, &NmbTypes, &NmbReals, TypesTab );
if(NmbSol)
double* values = fieldValues->getPointer();
int ref;
- double *val = new double[nbComp];
+ auto *val = new double[nbComp];
- bool isOnAll = (_uMesh->getNumberOfNodes()== nmbSol);
+ bool const isOnAll = (_uMesh->getNumberOfNodes()== nmbSol);
for(int i = 1; i<= nmbSol; i++)
timeStamp->setMesh( dimMesh );
- std::string name = "Field_on_Vertex";
+ std::string const name = "Field_on_Vertex";
timeStamp->setName(name);
timeStamp->setArray(fieldValues);
// set an order
MeshFormat::Status MeshFormatReader::setNodes( MEDCoupling::DataArrayDouble* coordArray)
{
- MeshFormat::Status status = MeshFormat::DRS_OK;
- int nbNodes = _reader.GmfStatKwd(_myCurrentFileId, MeshFormat::GmfVertices);
+ MeshFormat::Status const status = MeshFormat::DRS_OK;
+ int const nbNodes = _reader.GmfStatKwd(_myCurrentFileId, MeshFormat::GmfVertices);
if ( nbNodes < 1 )
return addMessage( "No nodes in the mesh", /*fatal=*/true );
nCoords[1] = y;
nCoords[2] = z;
std::copy(coordPointer, coordPointer+_dim, coordPrt);
- MeshFormatElement e(MeshFormat::GmfVertices, i-1);
+ MeshFormatElement const e(MeshFormat::GmfVertices, i-1);
_fams.insert(std::pair <int, MeshFormatElement> (ref, e), 1);
coordPrt += _dim;
nCoords[1] = y;
nCoords[2] = z;
std::copy(coordPointer, coordPointer+_dim, coordPrt);
- MeshFormatElement e(MeshFormat::GmfVertices, i-1);
+ MeshFormatElement const e(MeshFormat::GmfVertices, i-1);
_fams.insert(std::pair <int, MeshFormatElement> (ref, e), 1);
coordPrt += _dim;
}
int ref;
// read extra vertices for quadratic edges
std::vector<int> quadNodesAtEdges( nbEdges + 1, -1 );
- if ( int nbQuadEdges = _reader.GmfStatKwd(_myCurrentFileId, MeshFormat::GmfExtraVerticesAtEdges))
+ if ( int const nbQuadEdges = _reader.GmfStatKwd(_myCurrentFileId, MeshFormat::GmfExtraVerticesAtEdges))
{
_reader.GmfGotoKwd(_myCurrentFileId, MeshFormat::GmfExtraVerticesAtEdges);
for ( int i = 1; i <= nbQuadEdges; ++i )
mcIdType nodalConnPerCell[3] = {iN[0], iN[1], midN};
backward_shift(nodalConnPerCell, 3);
dimMesh1->insertNextCell(INTERP_KERNEL::NORM_SEG3, 3,nodalConnPerCell);
- MeshFormatElement e(MeshFormat::GmfEdges, i-1);
+ MeshFormatElement const e(MeshFormat::GmfEdges, i-1);
_fams.insert(std::pair <int, MeshFormatElement> (ref, e), 1 -_dim);
}
else
mcIdType nodalConnPerCell[2] = {iN[0], iN[1]};
backward_shift(nodalConnPerCell, 2);
dimMesh1->insertNextCell(INTERP_KERNEL::NORM_SEG2, 2,nodalConnPerCell);
- MeshFormatElement e(MeshFormat::GmfEdges, i-1);
+ MeshFormatElement const e(MeshFormat::GmfEdges, i-1);
_fams.insert(std::pair <int, MeshFormatElement> (ref, e), 1 -_dim);
}
}
int ref;
// read extra vertices for quadratic triangles
std::vector< std::vector<int> > quadNodesAtTriangles( nbTria + 1 );
- if ( int nbQuadTria = _reader.GmfStatKwd(_myCurrentFileId, MeshFormat::GmfExtraVerticesAtTriangles ))
+ if ( int const nbQuadTria = _reader.GmfStatKwd(_myCurrentFileId, MeshFormat::GmfExtraVerticesAtTriangles ))
{
_reader.GmfGotoKwd( _myCurrentFileId, MeshFormat::GmfExtraVerticesAtTriangles );
for ( int i = 1; i <= nbQuadTria; ++i )
mcIdType nodalConnPerCell[6] = {iN[0], iN[1], iN[2], midN[0], midN[1], midN[2]};
backward_shift(nodalConnPerCell, 6);
dimMesh2->insertNextCell(INTERP_KERNEL::NORM_TRI6, 6, nodalConnPerCell);
- MeshFormatElement e(MeshFormat::GmfTriangles, i-1);
+ MeshFormatElement const e(MeshFormat::GmfTriangles, i-1);
_fams.insert(std::pair <int, MeshFormatElement> (ref, e), 2 -_dim);
}
else
mcIdType nodalConnPerCell[3] = {iN[0], iN[1], iN[2]};
backward_shift(nodalConnPerCell, 3);
dimMesh2->insertNextCell(INTERP_KERNEL::NORM_TRI3,3,nodalConnPerCell);
- MeshFormatElement e(MeshFormat::GmfTriangles, i-1);
+ MeshFormatElement const e(MeshFormat::GmfTriangles, i-1);
_fams.insert(std::pair <int, MeshFormatElement> (ref, e), 2 -_dim);
}
if ( !midN.empty() ) MeshFormat::FreeVector( midN );
int ref;
// read extra vertices for quadratic quadrangles
std::vector< std::vector<int> > quadNodesAtQuadrilaterals( nbQuad + 1 );
- if ( int nbQuadQuad = _reader.GmfStatKwd( _myCurrentFileId, MeshFormat::GmfExtraVerticesAtQuadrilaterals ))
+ if ( int const nbQuadQuad = _reader.GmfStatKwd( _myCurrentFileId, MeshFormat::GmfExtraVerticesAtQuadrilaterals ))
{
_reader.GmfGotoKwd(_myCurrentFileId, MeshFormat::GmfExtraVerticesAtQuadrilaterals);
for ( int i = 1; i <= nbQuadQuad; ++i )
};
backward_shift(nodalConnPerCell, 8);
dimMesh2->insertNextCell(INTERP_KERNEL::NORM_QUAD8,8, nodalConnPerCell);
- MeshFormatElement e(MeshFormat::GmfQuadrilaterals, i-1);
+ MeshFormatElement const e(MeshFormat::GmfQuadrilaterals, i-1);
_fams.insert(std::pair <int, MeshFormatElement> (ref, e), 2 -_dim);
}
else if ( midN.size() > 8-4 ) // QUAD9
};
backward_shift(nodalConnPerCell, 9);
dimMesh2->insertNextCell(INTERP_KERNEL::NORM_QUAD9,9, nodalConnPerCell);
- MeshFormatElement e(MeshFormat::GmfQuadrilaterals, i-1);
+ MeshFormatElement const e(MeshFormat::GmfQuadrilaterals, i-1);
_fams.insert(std::pair <int, MeshFormatElement> (ref, e), 2 -_dim);
}
else // QUAD4
mcIdType nodalConnPerCell[4] = {iN[0], iN[1], iN[2], iN[3]};
backward_shift(nodalConnPerCell, 4);
dimMesh2->insertNextCell(INTERP_KERNEL::NORM_QUAD4, 4, nodalConnPerCell);
- MeshFormatElement e(MeshFormat::GmfQuadrilaterals, i-1);
+ MeshFormatElement const e(MeshFormat::GmfQuadrilaterals, i-1);
_fams.insert(std::pair <int, MeshFormatElement> (ref, e), 2 -_dim);
}
if ( !midN.empty() ) MeshFormat::FreeVector( midN );
int ref;
// read extra vertices for quadratic tetrahedra
std::vector< std::vector<int> > quadNodesAtTetrahedra( nbTet + 1 );
- if ( int nbQuadTetra = _reader.GmfStatKwd( _myCurrentFileId, MeshFormat::GmfExtraVerticesAtTetrahedra ))
+ if ( int const nbQuadTetra = _reader.GmfStatKwd( _myCurrentFileId, MeshFormat::GmfExtraVerticesAtTetrahedra ))
{
_reader.GmfGotoKwd(_myCurrentFileId, MeshFormat::GmfExtraVerticesAtTetrahedra);
for ( int i = 1; i <= nbQuadTetra; ++i )
};
backward_shift(nodalConnPerCell, 10);
dimMesh3->insertNextCell(INTERP_KERNEL::NORM_TETRA10, 10,nodalConnPerCell);
- MeshFormatElement e(MeshFormat::GmfTetrahedra, i-1);
+ MeshFormatElement const e(MeshFormat::GmfTetrahedra, i-1);
_fams.insert(std::pair <int, MeshFormatElement> (ref, e), 3 -_dim);
}
else // TETRA4
mcIdType nodalConnPerCell[4] = {iN[0], iN[2], iN[1], iN[3]};
backward_shift(nodalConnPerCell, 4);
dimMesh3->insertNextCell(INTERP_KERNEL::NORM_TETRA4,4, nodalConnPerCell);
- MeshFormatElement e(MeshFormat::GmfTetrahedra, i-1);
+ MeshFormatElement const e(MeshFormat::GmfTetrahedra, i-1);
_fams.insert(std::pair <int, MeshFormatElement> (ref, e), 3 -_dim);
}
if ( !midN.empty() ) MeshFormat::FreeVector( midN );
mcIdType nodalConnPerCell[5] = {iN[3], iN[2], iN[1], iN[0], iN[4]};
backward_shift(nodalConnPerCell, 5);
dimMesh3->insertNextCell(INTERP_KERNEL::NORM_PYRA5, 5,nodalConnPerCell);
- MeshFormatElement e(MeshFormat::GmfPyramids, i-1);
+ MeshFormatElement const e(MeshFormat::GmfPyramids, i-1);
_fams.insert(std::pair <int, MeshFormatElement> (ref, e), 3 -_dim);
}
int ref;
// read extra vertices for quadratic hexahedra
std::vector< std::vector<int> > quadNodesAtHexahedra( nbHex + 1 );
- if ( int nbQuadHexa = _reader.GmfStatKwd( _myCurrentFileId, MeshFormat::GmfExtraVerticesAtHexahedra ))
+ if ( int const nbQuadHexa = _reader.GmfStatKwd( _myCurrentFileId, MeshFormat::GmfExtraVerticesAtHexahedra ))
{
_reader.GmfGotoKwd(_myCurrentFileId, MeshFormat::GmfExtraVerticesAtHexahedra);
for ( int i = 1; i <= nbQuadHexa; ++i )
};
backward_shift(nodalConnPerCell, 20);
dimMesh3->insertNextCell(INTERP_KERNEL::NORM_HEXA20,20, nodalConnPerCell);
- MeshFormatElement e(MeshFormat::GmfHexahedra, i-1);
+ MeshFormatElement const e(MeshFormat::GmfHexahedra, i-1);
_fams.insert(std::pair <int, MeshFormatElement> (ref, e), 3 -_dim);
};
backward_shift(nodalConnPerCell, 27);
dimMesh3->insertNextCell(INTERP_KERNEL::NORM_HEXA27,27, nodalConnPerCell);
- MeshFormatElement e(MeshFormat::GmfHexahedra, i-1);
+ MeshFormatElement const e(MeshFormat::GmfHexahedra, i-1);
_fams.insert(std::pair <int, MeshFormatElement> (ref, e), 3 -_dim);
}
};
backward_shift(nodalConnPerCell, 8);
dimMesh3->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8, nodalConnPerCell);
- MeshFormatElement e(MeshFormat::GmfHexahedra, i-1);
+ MeshFormatElement const e(MeshFormat::GmfHexahedra, i-1);
_fams.insert(std::pair <int, MeshFormatElement> (ref, e), 3 -_dim);
}
mcIdType nodalConnPerCell[8] = {iN[0], iN[2], iN[1], iN[3], iN[5], iN[4]};
backward_shift(nodalConnPerCell, 8);
dimMesh3->insertNextCell(INTERP_KERNEL::NORM_PENTA6, 6,nodalConnPerCell);
- MeshFormatElement e(MeshFormat::GmfPrisms, i-1);
+ MeshFormatElement const e(MeshFormat::GmfPrisms, i-1);
_fams.insert(std::pair <int, MeshFormatElement> (ref, e), 3 -_dim);
}
}
-INTERP_KERNEL::NormalizedCellType MeshFormatReader::toMedType(MeshFormat::GmfKwdCod kwd)
+INTERP_KERNEL::NormalizedCellType MeshFormatReader::toMedType(MeshFormat::GmfKwdCod /*kwd*/)
{
INTERP_KERNEL::NormalizedCellType type;
//~switch (kwd)
void MeshFormatReader::buildCellsFamilies()
{
- std::vector<int> levs = _uMesh->getNonEmptyLevels();
- for (size_t iDim = 0; iDim<levs.size(); iDim++ )
+ std::vector<int> const levs = _uMesh->getNonEmptyLevels();
+ for (int const dimRelMax : levs)
{
- int dimRelMax = levs[iDim];
std::map <int, std::vector<MeshFormatElement>* > famDim = _fams.getMapAtLevel(dimRelMax);
std::map <int, std::vector<MeshFormatElement>* >::const_iterator _meshFormatFamsIt = famDim.begin();
- std::vector< const MEDCoupling::DataArrayIdType* > fams;
+ std::vector< const MEDCoupling::DataArrayIdType* > const fams;
MEDCoupling::DataArrayIdType* cellIds = MEDCoupling::DataArrayIdType::New();
cellIds->alloc(_uMesh->getSizeAtLevel(dimRelMax), 1);
cellIds->fillWithZero();
for(; _meshFormatFamsIt!= famDim.end(); ++_meshFormatFamsIt)
{
const int famId = _meshFormatFamsIt->first;
- std::string famName ="FromMeshGemsFormatAttributFamily_"+std::to_string(famId);
+ std::string const famName ="FromMeshGemsFormatAttributFamily_"+std::to_string(famId);
std::vector <MeshFormatElement>* cellsInFam = _meshFormatFamsIt->second;
if (!famId) continue;
- std::vector <MeshFormatElement>::iterator cellsInFamIt = cellsInFam->begin();
+ auto cellsInFamIt = cellsInFam->begin();
_uMesh->addFamily(famName, famId);
for ( ; cellsInFamIt !=cellsInFam->end(); ++cellsInFamIt)
void MeshFormatReader::buildNodesFamilies()
{
- std::vector<int> levs = _uMesh->getNonEmptyLevels();
- int dimRelMax = 1;
+ std::vector<int> const levs = _uMesh->getNonEmptyLevels();
+ int const dimRelMax = 1;
std::map <int, std::vector<MeshFormatElement>* > famDim = _fams.getMapAtLevel(dimRelMax);
std::map <int, std::vector<MeshFormatElement>* >::const_iterator _meshFormatFamsIt = famDim.begin();
- std::vector< const MEDCoupling::DataArrayIdType* > fams;
+ std::vector< const MEDCoupling::DataArrayIdType* > const fams;
MEDCoupling::DataArrayIdType* cellIds = MEDCoupling::DataArrayIdType::New();
cellIds->alloc(_uMesh->getSizeAtLevel(dimRelMax), 1);
cellIds->fillWithZero();
if (!famId) continue;
bool thisIsACellFamily = false;
- for (size_t iDim = 0; iDim<levs.size(); iDim++ )
+ for (int const dimMesh : levs)
{
- int dimMesh = levs[iDim];
std::map <int, std::vector<MeshFormatElement>* > famDimAtLevel = _fams.getMapAtLevel(dimMesh);
- std::map <int, std::vector<MeshFormatElement>* >::iterator famDimAtLevelId = famDimAtLevel.find(famId);
+ auto const famDimAtLevelId = famDimAtLevel.find(famId);
if (famDimAtLevelId != famDimAtLevel.end())
{
thisIsACellFamily = true;
}
if (thisIsACellFamily) continue;
- std::string famName ="FromMeshGemsFormatAttributFamily_"+std::to_string(famId);
+ std::string const famName ="FromMeshGemsFormatAttributFamily_"+std::to_string(famId);
std::vector <MeshFormatElement>* cellsInFam = _meshFormatFamsIt->second;
- std::vector <MeshFormatElement>::iterator cellsInFamIt = cellsInFam->begin();
+ auto cellsInFamIt = cellsInFam->begin();
_uMesh->addFamily(famName, famId);
for ( ; cellsInFamIt !=cellsInFam->end(); ++cellsInFamIt)
#include <map>
#include <algorithm>
#include <utility>
-#include <iterator>
#include "MCAuto.hxx"
#include "InterpKernelException.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
+#include "MEDLoaderDefines.hxx"
+#include "MEDCouplingRefCountObject.hxx"
#include "MCType.hxx"
#include "MEDMESHConverterUtilities.hxx"
#include "libmesh5.hxx"
+#include "NormalizedGeometricTypes"
-#include <fstream>
#if !defined(WIN32) && !defined(__APPLE__)
-#include <features.h>
#endif
namespace MEDCoupling
private:
void insertPairInMap(std::map<int, std::vector<MeshFormatElement> *> &aMap, std::pair<int, MeshFormatElement> addToFamily)
{
- std::map<int, std::vector<MeshFormatElement> *>::iterator it = aMap.find(addToFamily.first);
+ auto const it = aMap.find(addToFamily.first);
if (it != aMap.end())
{
aMap[addToFamily.first]->push_back(addToFamily.second);
}
else
{
- std::vector<MeshFormatElement> *tmpVec = new std::vector<MeshFormatElement>;
+ auto *tmpVec = new std::vector<MeshFormatElement>;
tmpVec->push_back(addToFamily.second);
aMap.insert(std::pair<int, std::vector<MeshFormatElement> *>(addToFamily.first, tmpVec));
}
if (!aMap.size())
return;
- std::map<int, std::vector<MeshFormatElement> *>::iterator itTmp = aMap.find(removeFromFamily.first);
+ auto const itTmp = aMap.find(removeFromFamily.first);
if (itTmp == aMap.end())
return;
else
private:
void freeMap(std::map<int, std::vector<MeshFormatElement> *> &aMap)
{
- std::map<int, std::vector<MeshFormatElement> *>::iterator it = aMap.begin();
+ auto it = aMap.begin();
for (; it != aMap.end(); ++it)
delete it->second;
}
//
#include "MeshFormatWriter.hxx"
+#include "MEDFileFieldMultiTS.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingUMesh.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingRefCountObject.hxx"
#include "MEDFileMesh.hxx"
#include "MEDFileField.hxx"
#include "MEDFileData.hxx"
#include "MEDCouplingFieldDouble.hxx"
+#include "NormalizedGeometricTypes"
#include "libmesh5.hxx"
#include "MEDMESHConverterUtilities.hxx"
#include <cstring>
#include <algorithm>
-#include <map>
#include <cstdlib>
-#include <fstream>
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
namespace MEDCoupling {
MeshFormatWriter::MeshFormatWriter()
-{}
+= default;
MeshFormatWriter::MeshFormatWriter(const std::string& meshFileName,
const std::vector<std::string>& fieldFileNames):_meshFileName(meshFileName),
_fieldFileNames(fieldFileNames)
{}
MeshFormatWriter::~MeshFormatWriter()
-{}
+= default;
void MeshFormatWriter::setMeshFileName(const std::string& meshFileName)
{
_meshFileName = meshFileName;
void MeshFormatWriter::write()
{
- MeshFormat::Localizer loc;
+ MeshFormat::Localizer const loc;
MEDCoupling::MCAuto<MEDCoupling::MEDCouplingMesh > mesh = _mesh->getMeshAtLevel( 1 );
MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh = mesh->buildUnstructured();
MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh3;
std::vector<int> dims = _mesh->getNonEmptyLevelsExt();
- int dim = _mesh->getMeshDimension();
+ int const dim = _mesh->getMeshDimension();
bool threeDElements = false;
bool twoDElements = false;
bool OneDElements = false;
if (dims.size() != 0)
{
- bool maxLevelDimElments = ( std::find(dims.begin(), dims.end(), 0) != dims.end() );
- bool nextToMaxLevelDimElments = ( std::find(dims.begin(), dims.end(), -1) != dims.end() );
- bool nextToNextToMaxLevelDimElments = (std::find(dims.begin(), dims.end(), -2) != dims.end() );
+ bool const maxLevelDimElments = ( std::find(dims.begin(), dims.end(), 0) != dims.end() );
+ bool const nextToMaxLevelDimElments = ( std::find(dims.begin(), dims.end(), -1) != dims.end() );
+ bool const nextToNextToMaxLevelDimElments = (std::find(dims.begin(), dims.end(), -2) != dims.end() );
threeDElements = (dim == 3) ? maxLevelDimElments : false ;
twoDElements = (dim == 3) ? nextToMaxLevelDimElments : maxLevelDimElments ;
OneDElements = (dim == 3) ? nextToNextToMaxLevelDimElments : nextToMaxLevelDimElments;
MEDCoupling::MCAuto< MEDCoupling::MEDCouplingMesh > mesh0 = _mesh->getMeshAtLevel(1);
- MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh0 = mesh0->buildUnstructured();
+ MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > const umesh0 = mesh0->buildUnstructured();
// nodes
getNodes(umesh0);
}
- int dim = _mesh->getMeshDimension(); // dim mesh field lying to
+ int const dim = _mesh->getMeshDimension(); // dim mesh field lying to
std::vector<std::string>::const_iterator fieldFileIt = _fieldFileNames.begin();
int iField = 0;
- std::vector<int> levs {0} ;
+ std::vector<int> const levs {0} ;
for (; fieldFileIt !=_fieldFileNames.end(); ++fieldFileIt)
{
// Open files
std::vector< std::vector<MEDCoupling::TypeOfField> > fTypes = f->getTypesOfFieldAvailable();
std::vector< std::pair<int,int> > iters = f->getIterations();
const std::vector<std::string>& compInfo = f->getInfo();
- std::pair<int,int> it = iters[0];
+ std::pair<int,int> const it = iters[0];
//~// Open File for writing
_myCurrentFileId = _writer.GmfOpenMesh( fieldFileIt->c_str(), GmfWrite, _version, _dim );
const MEDCoupling::DataArrayDouble* valsArray = f->getUndergroundDataArray(iteration, order);
int typTab[] = { getGmfSolKwd((int)compSize, _dim) };
_writer.GmfSetKwd(_myCurrentFileId, MeshFormat::GmfSolAtVertices, (int)valsVec[0][0].second, 1, typTab);
- double* valTab0 = new double[compSize];
+ auto* valTab0 = new double[compSize];
double* valTab;
for ( size_t i = valsVec[0][0].first; i < (std::size_t)valsVec[0][0].second; ++i )
{
MeshFormat::Status MeshFormatWriter::setFieldOnCells(MEDCoupling::MEDFileFieldMultiTS * f, int iteration, int order, std::vector<int> levs )
{
- int dim = _mesh->getMeshDimension(); // dim mesh field lying to
- int absDim = f->getNonEmptyLevels(iteration, order, f->getMeshName(), levs);
+ int const dim = _mesh->getMeshDimension(); // dim mesh field lying to
+ int const absDim = f->getNonEmptyLevels(iteration, order, f->getMeshName(), levs);
- MEDCoupling::MEDCouplingFieldDouble** cellToNodeFldb = new MEDCoupling::MEDCouplingFieldDouble* [(int)levs.size()] ;
- MEDCoupling::MEDCouplingFieldDouble** fldb = new MEDCoupling::MEDCouplingFieldDouble* [(int)levs.size()] ;
+ auto** cellToNodeFldb = new MEDCoupling::MEDCouplingFieldDouble* [(int)levs.size()] ;
+ auto** fldb = new MEDCoupling::MEDCouplingFieldDouble* [(int)levs.size()] ;
for (size_t k = 0; k<levs.size(); k++) fldb[k] = f->field( iteration, order,_mesh );
MEDCoupling::DataArrayDouble* timeStamp = cellToNodeFldb[j]->getArray();
double* values = timeStamp->getPointer();
- int typ = getGmfSolKwd((int)nbComp, _dim) ;
+ int const typ = getGmfSolKwd((int)nbComp, _dim) ;
if(typ == -1)
{
addMessage( MeshFormat::Comment(" error with Number of Component ") << nbComp, /*fatal=*/true );
for (int ii =0; ii<_dim; ii++)
for (int jj =ii; jj<_dim; jj++)
{
- int kk = _dim*(_dim-1)/2- (_dim-ii)*(_dim-ii-1)/2+jj;
+ int const kk = _dim*(_dim-1)/2- (_dim-ii)*(_dim-ii-1)/2+jj;
symTensor[kk] = fullTensor[ii+jj*_dim];
}
}
}
bool MeshFormatWriter::checkFileName()
{
- bool ret = true;
+ bool const ret = true;
return ret;
}
bool MeshFormatWriter::checkFieldFileName()
{
- bool ret = true;
+ bool const ret = true;
return ret;
}
void MeshFormatWriter::forward_shift(std::vector<MEDCoupling::mcIdType> &conn)
{
- std::vector<MEDCoupling::mcIdType>::iterator it = conn.begin();
+ auto it = conn.begin();
for (; it != conn.end(); ++it) *it = *it+1;
}
std::copy(coordPrt, coordPrt+_dim, xyz);
- MeshFormatNode e(xyz[0], xyz[1], xyz[2], idNode);
+ MeshFormatNode const e(xyz[0], xyz[1], xyz[2], idNode);
_idNodeToNode.insert(std::pair <int, MeshFormatNode> (idNode, e));
coordPrt+= _dim;
idNode++;
}
linkFamilyToNodes();
- std::map <int, MeshFormatNode>::iterator itNode = _idNodeToNode.begin();
+ auto itNode = _idNodeToNode.begin();
for (; itNode!= _idNodeToNode.end(); ++itNode)
_dim == 3? _writer.GmfSetLin( _myCurrentFileId, MeshFormat::GmfVertices, itNode->second.xyz[0],
itNode->second.xyz[1], itNode->second.xyz[2], std::abs(itNode->second._famId) ) :
}
-void MeshFormatWriter::getNSEG2(MEDCoupling::mcIdType nbEdgesNSEG2, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh1)
+void MeshFormatWriter::getNSEG2(MEDCoupling::mcIdType /*nbEdgesNSEG2*/, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh1)
{
MEDCoupling::MCAuto<MEDCoupling::DataArrayIdType> elementId = umesh1->giveCellsWithType(INTERP_KERNEL::NORM_SEG2);
std::map<int, MeshFormatCell> idCellToCell;
- for ( const mcIdType *it=elementId->begin(); it!=elementId->end(); it++ )
+ for (long const it : *elementId)
{
std::vector<MEDCoupling::mcIdType> conn;
- umesh1->getNodeIdsOfCell(*it, conn) ;
+ umesh1->getNodeIdsOfCell(it, conn) ;
forward_shift(conn);
- MeshFormatCell e(INTERP_KERNEL::NORM_SEG2, (int)*it);
+ MeshFormatCell e(INTERP_KERNEL::NORM_SEG2, (int)it);
e.setConn(conn);
- idCellToCell.insert(std::pair <int, MeshFormatCell> (*it, e));
+ idCellToCell.insert(std::pair <int, MeshFormatCell> (it, e));
}
_typeToIdCellToCell.insert(std::pair <INTERP_KERNEL::NormalizedCellType, std::map<int, MeshFormatCell> >(INTERP_KERNEL::NORM_SEG2, idCellToCell) );
}
-void MeshFormatWriter::getNSEG3( MEDCoupling::mcIdType nbEdgesNSEG3, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh1)
+void MeshFormatWriter::getNSEG3( MEDCoupling::mcIdType /*nbEdgesNSEG3*/, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh1)
{
MEDCoupling::MCAuto<MEDCoupling::DataArrayIdType> elementId = umesh1->giveCellsWithType(INTERP_KERNEL::NORM_SEG3);
std::map<int, MeshFormatCell> idCellToCell;
- for ( const mcIdType *it=elementId->begin(); it!=elementId->end(); it++ )
+ for (long const it : *elementId)
{
std::vector<MEDCoupling::mcIdType> conn;
- umesh1->getNodeIdsOfCell(*it, conn) ;
+ umesh1->getNodeIdsOfCell(it, conn) ;
forward_shift(conn);
- MeshFormatCell e(INTERP_KERNEL::NORM_SEG3, (int)*it);
+ MeshFormatCell e(INTERP_KERNEL::NORM_SEG3, (int)it);
e.setConn(conn);
- idCellToCell.insert(std::pair <int, MeshFormatCell> (*it, e));
+ idCellToCell.insert(std::pair <int, MeshFormatCell> (it, e));
}
_typeToIdCellToCell.insert(std::pair <INTERP_KERNEL::NormalizedCellType, std::map<int, MeshFormatCell> >(INTERP_KERNEL::NORM_SEG3, idCellToCell) );
}
-void MeshFormatWriter::getTRI3( MEDCoupling::mcIdType nbTRI3, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh2)
+void MeshFormatWriter::getTRI3( MEDCoupling::mcIdType /*nbTRI3*/, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh2)
{
MEDCoupling::MCAuto<MEDCoupling::DataArrayIdType> elementId = umesh2->giveCellsWithType(INTERP_KERNEL::NORM_TRI3);
std::map<int, MeshFormatCell> idCellToCell;
- for ( const mcIdType *it=elementId->begin(); it!=elementId->end(); it++ )
+ for (long const it : *elementId)
{
std::vector<MEDCoupling::mcIdType> conn;
- umesh2->getNodeIdsOfCell(*it, conn) ;
+ umesh2->getNodeIdsOfCell(it, conn) ;
forward_shift(conn);
- MeshFormatCell e(INTERP_KERNEL::NORM_TRI3, (int)*it);
+ MeshFormatCell e(INTERP_KERNEL::NORM_TRI3, (int)it);
e.setConn(conn);
- idCellToCell.insert(std::pair <int, MeshFormatCell> (*it, e));
+ idCellToCell.insert(std::pair <int, MeshFormatCell> (it, e));
}
_typeToIdCellToCell.insert(std::pair <INTERP_KERNEL::NormalizedCellType, std::map<int, MeshFormatCell> >(INTERP_KERNEL::NORM_TRI3, idCellToCell) );
}
-void MeshFormatWriter::getTRI6( MEDCoupling::mcIdType nbTRI6, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh2)
+void MeshFormatWriter::getTRI6( MEDCoupling::mcIdType /*nbTRI6*/, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh2)
{
MEDCoupling::MCAuto<MEDCoupling::DataArrayIdType> elementId = umesh2->giveCellsWithType(INTERP_KERNEL::NORM_TRI6);
std::map<int, MeshFormatCell> idCellToCell;
- for ( const mcIdType *it=elementId->begin(); it!=elementId->end(); it++ )
+ for (long const it : *elementId)
{
std::vector<MEDCoupling::mcIdType> conn;
- umesh2->getNodeIdsOfCell(*it, conn) ;
+ umesh2->getNodeIdsOfCell(it, conn) ;
forward_shift(conn);
- MeshFormatCell e(INTERP_KERNEL::NORM_TRI6, (int)*it);
+ MeshFormatCell e(INTERP_KERNEL::NORM_TRI6, (int)it);
e.setConn(conn);
- idCellToCell.insert(std::pair <int, MeshFormatCell> (*it, e));
+ idCellToCell.insert(std::pair <int, MeshFormatCell> (it, e));
}
_typeToIdCellToCell.insert(std::pair <INTERP_KERNEL::NormalizedCellType, std::map<int, MeshFormatCell> >(INTERP_KERNEL::NORM_TRI6, idCellToCell) );
}
-void MeshFormatWriter::getQUAD4( MEDCoupling::mcIdType nbQUAD4, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh2)
+void MeshFormatWriter::getQUAD4( MEDCoupling::mcIdType /*nbQUAD4*/, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh2)
{
MEDCoupling::MCAuto<MEDCoupling::DataArrayIdType> elementId = umesh2->giveCellsWithType(INTERP_KERNEL::NORM_QUAD4);
std::map<int, MeshFormatCell> idCellToCell;
- for ( const mcIdType *it=elementId->begin(); it!=elementId->end(); it++ )
+ for (long const it : *elementId)
{
std::vector<MEDCoupling::mcIdType> conn;
- umesh2->getNodeIdsOfCell(*it, conn) ;
+ umesh2->getNodeIdsOfCell(it, conn) ;
forward_shift(conn);
- MeshFormatCell e(INTERP_KERNEL::NORM_QUAD4, (int)*it);
+ MeshFormatCell e(INTERP_KERNEL::NORM_QUAD4, (int)it);
e.setConn(conn);
- idCellToCell.insert(std::pair <int, MeshFormatCell> (*it, e));
+ idCellToCell.insert(std::pair <int, MeshFormatCell> (it, e));
}
_typeToIdCellToCell.insert(std::pair <INTERP_KERNEL::NormalizedCellType, std::map<int, MeshFormatCell> >(INTERP_KERNEL::NORM_QUAD4, idCellToCell) );
}
-void MeshFormatWriter::getQUAD8(MEDCoupling::mcIdType nbQUAD8, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh2)
+void MeshFormatWriter::getQUAD8(MEDCoupling::mcIdType /*nbQUAD8*/, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh2)
{
MEDCoupling::MCAuto<MEDCoupling::DataArrayIdType> elementId = umesh2->giveCellsWithType(INTERP_KERNEL::NORM_QUAD8);
std::map<int, MeshFormatCell> idCellToCell;
- for ( const mcIdType *it=elementId->begin(); it!=elementId->end(); it++ )
+ for (long const it : *elementId)
{
std::vector<MEDCoupling::mcIdType> conn;
- umesh2->getNodeIdsOfCell(*it, conn) ;
+ umesh2->getNodeIdsOfCell(it, conn) ;
forward_shift(conn);
- MeshFormatCell e(INTERP_KERNEL::NORM_QUAD8, (int)*it);
+ MeshFormatCell e(INTERP_KERNEL::NORM_QUAD8, (int)it);
e.setConn(conn);
- idCellToCell.insert(std::pair <int, MeshFormatCell> (*it, e));
+ idCellToCell.insert(std::pair <int, MeshFormatCell> (it, e));
}
_typeToIdCellToCell.insert(std::pair <INTERP_KERNEL::NormalizedCellType, std::map<int, MeshFormatCell> >(INTERP_KERNEL::NORM_QUAD8, idCellToCell) );
}
-void MeshFormatWriter::getQUAD9(MEDCoupling::mcIdType nbQUAD9, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh2)
+void MeshFormatWriter::getQUAD9(MEDCoupling::mcIdType /*nbQUAD9*/, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh2)
{
MEDCoupling::MCAuto<MEDCoupling::DataArrayIdType> elementId = umesh2->giveCellsWithType(INTERP_KERNEL::NORM_QUAD9);
std::map<int, MeshFormatCell> idCellToCell;
- for ( const mcIdType *it=elementId->begin(); it!=elementId->end(); it++ )
+ for (long const it : *elementId)
{
std::vector<MEDCoupling::mcIdType> conn;
- umesh2->getNodeIdsOfCell(*it, conn) ;
+ umesh2->getNodeIdsOfCell(it, conn) ;
forward_shift(conn);
- MeshFormatCell e(INTERP_KERNEL::NORM_QUAD9, (int)*it);
+ MeshFormatCell e(INTERP_KERNEL::NORM_QUAD9, (int)it);
e.setConn(conn);
- idCellToCell.insert(std::pair <int, MeshFormatCell> (*it, e));
+ idCellToCell.insert(std::pair <int, MeshFormatCell> (it, e));
}
_typeToIdCellToCell.insert(std::pair <INTERP_KERNEL::NormalizedCellType, std::map<int, MeshFormatCell> >(INTERP_KERNEL::NORM_QUAD9, idCellToCell) );
}
-void MeshFormatWriter::getTETRA4(MEDCoupling::mcIdType nbTETRA4, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh3)
+void MeshFormatWriter::getTETRA4(MEDCoupling::mcIdType /*nbTETRA4*/, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh3)
{
MEDCoupling::MCAuto<MEDCoupling::DataArrayIdType> elementId = umesh3->giveCellsWithType(INTERP_KERNEL::NORM_TETRA4);
std::map<int, MeshFormatCell> idCellToCell;
- for ( const mcIdType *it=elementId->begin(); it!=elementId->end(); it++ )
+ for (long const it : *elementId)
{
std::vector<MEDCoupling::mcIdType> conn;
- umesh3->getNodeIdsOfCell(*it, conn) ;
+ umesh3->getNodeIdsOfCell(it, conn) ;
forward_shift(conn);
- MeshFormatCell e(INTERP_KERNEL::NORM_TETRA4, (int)*it);
+ MeshFormatCell e(INTERP_KERNEL::NORM_TETRA4, (int)it);
e.setConn(conn);
- idCellToCell.insert(std::pair <int, MeshFormatCell> (*it, e));
+ idCellToCell.insert(std::pair <int, MeshFormatCell> (it, e));
}
_typeToIdCellToCell.insert(std::pair <INTERP_KERNEL::NormalizedCellType, std::map<int, MeshFormatCell> >(INTERP_KERNEL::NORM_TETRA4, idCellToCell) );
}
-void MeshFormatWriter::getTETRA10(MEDCoupling::mcIdType nbTETRA10, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh3)
+void MeshFormatWriter::getTETRA10(MEDCoupling::mcIdType /*nbTETRA10*/, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh3)
{
MEDCoupling::MCAuto<MEDCoupling::DataArrayIdType> elementId = umesh3->giveCellsWithType(INTERP_KERNEL::NORM_TETRA10);
std::map<int, MeshFormatCell> idCellToCell;
- for ( const mcIdType *it=elementId->begin(); it!=elementId->end(); it++ )
+ for (long const it : *elementId)
{
std::vector<MEDCoupling::mcIdType> conn;
- umesh3->getNodeIdsOfCell(*it, conn) ;
+ umesh3->getNodeIdsOfCell(it, conn) ;
forward_shift(conn);
- MeshFormatCell e(INTERP_KERNEL::NORM_TETRA10, (int)*it);
+ MeshFormatCell e(INTERP_KERNEL::NORM_TETRA10, (int)it);
e.setConn(conn);
- idCellToCell.insert(std::pair <int, MeshFormatCell> (*it, e));
+ idCellToCell.insert(std::pair <int, MeshFormatCell> (it, e));
}
_typeToIdCellToCell.insert(std::pair <INTERP_KERNEL::NormalizedCellType, std::map<int, MeshFormatCell> >(INTERP_KERNEL::NORM_TETRA10, idCellToCell) );
}
-void MeshFormatWriter::getPYRA5(MEDCoupling::mcIdType nbPYRA5, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh3)
+void MeshFormatWriter::getPYRA5(MEDCoupling::mcIdType /*nbPYRA5*/, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh3)
{
MEDCoupling::MCAuto<MEDCoupling::DataArrayIdType> elementId = umesh3->giveCellsWithType(INTERP_KERNEL::NORM_PYRA5);
std::map<int, MeshFormatCell> idCellToCell;
- for ( const mcIdType *it=elementId->begin(); it!=elementId->end(); it++ )
+ for (long const it : *elementId)
{
std::vector<MEDCoupling::mcIdType> conn;
- umesh3->getNodeIdsOfCell(*it, conn) ;
+ umesh3->getNodeIdsOfCell(it, conn) ;
forward_shift(conn);
- MeshFormatCell e(INTERP_KERNEL::NORM_PYRA5, (int)*it);
+ MeshFormatCell e(INTERP_KERNEL::NORM_PYRA5, (int)it);
e.setConn(conn);
- idCellToCell.insert(std::pair <int, MeshFormatCell> (*it, e));
+ idCellToCell.insert(std::pair <int, MeshFormatCell> (it, e));
}
_typeToIdCellToCell.insert(std::pair <INTERP_KERNEL::NormalizedCellType, std::map<int, MeshFormatCell> >(INTERP_KERNEL::NORM_PYRA5, idCellToCell) );
}
-void MeshFormatWriter::getHEXA8(MEDCoupling::mcIdType nbHEXA8, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh3)
+void MeshFormatWriter::getHEXA8(MEDCoupling::mcIdType /*nbHEXA8*/, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh3)
{
MEDCoupling::MCAuto<MEDCoupling::DataArrayIdType> elementId = umesh3->giveCellsWithType(INTERP_KERNEL::NORM_HEXA8);
std::map<int, MeshFormatCell> idCellToCell;
- for ( const mcIdType *it=elementId->begin(); it!=elementId->end(); it++ )
+ for (long const it : *elementId)
{
std::vector<MEDCoupling::mcIdType> conn;
- umesh3->getNodeIdsOfCell(*it, conn) ;
+ umesh3->getNodeIdsOfCell(it, conn) ;
forward_shift(conn);
- MeshFormatCell e(INTERP_KERNEL::NORM_HEXA8, (int)*it);
+ MeshFormatCell e(INTERP_KERNEL::NORM_HEXA8, (int)it);
e.setConn(conn);
- idCellToCell.insert(std::pair <int, MeshFormatCell> (*it, e));
+ idCellToCell.insert(std::pair <int, MeshFormatCell> (it, e));
}
_typeToIdCellToCell.insert(std::pair <INTERP_KERNEL::NormalizedCellType, std::map<int, MeshFormatCell> >(INTERP_KERNEL::NORM_HEXA8, idCellToCell) );
}
-void MeshFormatWriter::getHEXA20(MEDCoupling::mcIdType nbHEXA20, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh3)
+void MeshFormatWriter::getHEXA20(MEDCoupling::mcIdType /*nbHEXA20*/, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh3)
{
MEDCoupling::MCAuto<MEDCoupling::DataArrayIdType> elementId = umesh3->giveCellsWithType(INTERP_KERNEL::NORM_HEXA20);
std::map<int, MeshFormatCell> idCellToCell;
- for ( const mcIdType *it=elementId->begin(); it!=elementId->end(); it++ )
+ for (long const it : *elementId)
{
std::vector<MEDCoupling::mcIdType> conn;
- umesh3->getNodeIdsOfCell(*it, conn) ;
+ umesh3->getNodeIdsOfCell(it, conn) ;
forward_shift(conn);
- MeshFormatCell e(INTERP_KERNEL::NORM_HEXA20, (int)*it);
+ MeshFormatCell e(INTERP_KERNEL::NORM_HEXA20, (int)it);
e.setConn(conn);
- idCellToCell.insert(std::pair <int, MeshFormatCell> (*it, e));
+ idCellToCell.insert(std::pair <int, MeshFormatCell> (it, e));
}
_typeToIdCellToCell.insert(std::pair <INTERP_KERNEL::NormalizedCellType, std::map<int, MeshFormatCell> >(INTERP_KERNEL::NORM_HEXA20, idCellToCell) );
}
-void MeshFormatWriter::getHEXA27(MEDCoupling::mcIdType nbHEXA27, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh3)
+void MeshFormatWriter::getHEXA27(MEDCoupling::mcIdType /*nbHEXA27*/, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh3)
{
MEDCoupling::MCAuto<MEDCoupling::DataArrayIdType> elementId = umesh3->giveCellsWithType(INTERP_KERNEL::NORM_HEXA27);
std::map<int, MeshFormatCell> idCellToCell;
- for ( const mcIdType *it=elementId->begin(); it!=elementId->end(); it++ )
+ for (long const it : *elementId)
{
std::vector<MEDCoupling::mcIdType> conn;
- umesh3->getNodeIdsOfCell(*it, conn) ;
+ umesh3->getNodeIdsOfCell(it, conn) ;
forward_shift(conn);
- MeshFormatCell e(INTERP_KERNEL::NORM_HEXA27, (int)*it);
+ MeshFormatCell e(INTERP_KERNEL::NORM_HEXA27, (int)it);
e.setConn(conn);
- idCellToCell.insert(std::pair <int, MeshFormatCell> (*it, e));
+ idCellToCell.insert(std::pair <int, MeshFormatCell> (it, e));
}
_typeToIdCellToCell.insert(std::pair <INTERP_KERNEL::NormalizedCellType, std::map<int, MeshFormatCell> >(INTERP_KERNEL::NORM_HEXA27, idCellToCell) );
}
-void MeshFormatWriter::getPENTA6(MEDCoupling::mcIdType nbPENTA6, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh3)
+void MeshFormatWriter::getPENTA6(MEDCoupling::mcIdType /*nbPENTA6*/, MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh3)
{
MEDCoupling::MCAuto<MEDCoupling::DataArrayIdType> elementId = umesh3->giveCellsWithType(INTERP_KERNEL::NORM_PENTA6);
std::map<int, MeshFormatCell> idCellToCell;
- for ( const mcIdType *it=elementId->begin(); it!=elementId->end(); it++ )
+ for (long const it : *elementId)
{
std::vector<MEDCoupling::mcIdType> conn;
- umesh3->getNodeIdsOfCell(*it, conn) ;
+ umesh3->getNodeIdsOfCell(it, conn) ;
forward_shift(conn);
- MeshFormatCell e(INTERP_KERNEL::NORM_PENTA6, (int)*it);
+ MeshFormatCell e(INTERP_KERNEL::NORM_PENTA6, (int)it);
e.setConn(conn);
- idCellToCell.insert(std::pair <int, MeshFormatCell> (*it, e));
+ idCellToCell.insert(std::pair <int, MeshFormatCell> (it, e));
}
_typeToIdCellToCell.insert(std::pair <INTERP_KERNEL::NormalizedCellType, std::map<int, MeshFormatCell> >(INTERP_KERNEL::NORM_PENTA6, idCellToCell) );
}
const MEDCoupling::mcIdType * nodeIdsIt = nodeIds->begin(), * famIDEnd = nodeIds->end();
for(; nodeIdsIt< famIDEnd; ++nodeIdsIt) {
- std::map <int, MeshFormatNode>::iterator itNode = _idNodeToNode.find((int)*nodeIdsIt);
+ auto const itNode = _idNodeToNode.find((int)*nodeIdsIt);
if (itNode == _idNodeToNode.end()) continue;
else itNode->second._famId =(int) famIt->second;
void MeshFormatWriter::linkFamilyToCells()
{
- std::vector<int> levs = _mesh->getNonEmptyLevels();
- for (size_t iDim = 0; iDim < levs.size(); iDim++ )
+ std::vector<int> const levs = _mesh->getNonEmptyLevels();
+ for (int const meshDimRelToMax : levs)
{
- int meshDimRelToMax = levs[iDim];
MEDCoupling::MCAuto< MEDCoupling::MEDCouplingMesh > mesh = _mesh->getMeshAtLevel( meshDimRelToMax);
MEDCoupling::MCAuto< MEDCoupling::MEDCouplingUMesh > umesh0 = mesh->buildUnstructured();
const MEDCoupling::DataArrayIdType * famIdsField = _mesh->getFamilyFieldAtLevel(meshDimRelToMax);
for (; famID < famIDEnd; ++famID)
{
if (!(*famID)) continue; // "FAMILLE_ZERO"
- std::string famName = _mesh->getFamilyNameGivenId(*famID);
+ std::string const famName = _mesh->getFamilyNameGivenId(*famID);
MEDCoupling::MCAuto<MEDCoupling::DataArrayIdType> cellIds = _mesh->getFamilyArr( meshDimRelToMax, famName);
const MEDCoupling::mcIdType * cellIdsIt = cellIds->begin(), *cellIDEnd = cellIds->end();
for(; cellIdsIt< cellIDEnd; ++cellIdsIt)
{
- INTERP_KERNEL::NormalizedCellType type = umesh0->getTypeOfCell(*cellIdsIt); //TODO
- std::map<INTERP_KERNEL::NormalizedCellType, std::map <int, MeshFormatCell> >::iterator itCellMap = _typeToIdCellToCell.find(type);
+ INTERP_KERNEL::NormalizedCellType const type = umesh0->getTypeOfCell(*cellIdsIt); //TODO
+ auto const itCellMap = _typeToIdCellToCell.find(type);
if (itCellMap == _typeToIdCellToCell.end()) continue;
else
{
- std::map <int, MeshFormatCell>::iterator itCell = itCellMap->second.find((int)*cellIdsIt);
+ auto const itCell = itCellMap->second.find((int)*cellIdsIt);
if (itCell == itCellMap->second.end()) continue;
else itCell->second._famId = (int)*famID;
}
void MeshFormatWriter::writeCells()
{
- std::map < INTERP_KERNEL::NormalizedCellType, std::map<int, MeshFormatCell> >::iterator typeCellMapIt = _typeToIdCellToCell.begin();
+ auto typeCellMapIt = _typeToIdCellToCell.begin();
for (; typeCellMapIt!= _typeToIdCellToCell.end(); ++typeCellMapIt)
{
- std::map<int, MeshFormatCell>::iterator cellMapIt = typeCellMapIt->second.begin();
+ auto cellMapIt = typeCellMapIt->second.begin();
switch (typeCellMapIt->first)
{
case INTERP_KERNEL::NORM_SEG2 :
#ifndef MESHFORMATWRITER_HXX
#define MESHFORMATWRITER_HXX
-#include <vector>
+#include <algorithm>
+#include <cstddef>
+#include <iterator>
+#include <map>
#include <string>
#include <string>
+#include <vector>
#include "MCAuto.hxx"
-#include "InterpKernelException.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
+#include "NormalizedGeometricTypes"
+#include "MEDLoaderDefines.hxx"
+#include "MEDCouplingUMesh.hxx"
#include "MCType.hxx"
#include "MEDMESHConverterUtilities.hxx"
#include "libmesh5.hxx"
#include "MEDFileMesh.hxx"
-#include <fstream>
namespace MEDCoupling
{
#include "SauvMedConvertor.hxx"
#include "CellModel.hxx"
+#include "InterpKernelException.hxx"
+#include "MCIdType.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingUMesh.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingRefCountObject.hxx"
#include "MEDFileMesh.hxx"
#include "MEDFileField.hxx"
#include "MEDFileData.hxx"
#include "MEDCouplingFieldDouble.hxx"
+#include "NormalizedGeometricTypes"
+#include "SauvUtilities.hxx"
+#include <algorithm>
+#include <cstdio>
#include <iostream>
#include <cassert>
#include <cmath>
+#include <map>
+#include <list>
#include <queue>
#include <limits>
#include <cstdlib>
#include <cstring>
#include <fcntl.h>
+#include <vector>
+#include <utility>
+#include <set>
+#include <sstream>
#ifdef WIN32
#include <io.h>
#endif
#ifdef HAS_XDR
-#include <rpc/types.h>
#include <rpc/xdr.h>
#endif
inline void reverse(const Cell & aCell, const std::vector<std::pair<int,int> > & swapVec )
{
Cell* ma = const_cast<Cell*>(&aCell);
- for ( unsigned i = 0; i < swapVec.size(); ++i )
- std::swap( ma->_nodes[ swapVec[i].first ],
- ma->_nodes[ swapVec[i].second ]);
+ for (const auto & i : swapVec)
+ std::swap( ma->_nodes[ i.first ],
+ ma->_nodes[ i.second ]);
if ( swapVec.empty() )
ma->_reverse = true;
else
return i1->_number < i2->_number;
}
};
- typedef std::map< const Cell*, unsigned, TCellByIDCompare > TCellToOrderMap;
+ using TCellToOrderMap = std::map<const Cell *, unsigned int, TCellByIDCompare>;
//================================================================================
/*!
// check if relocation table is necessary
bool isRelocated = false;
unsigned newOrder = 0;
- TCellToOrderMap::iterator c2oIt = cell2order.begin(), c2oEnd = cell2order.end();
+ auto c2oIt = cell2order.begin(), c2oEnd = cell2order.end();
for ( ; !isRelocated && c2oIt != c2oEnd; ++c2oIt, ++newOrder )
isRelocated = ( c2oIt->second != newOrder );
namespace // define default GAUSS points
{
- typedef std::vector<double> TDoubleVector;
- typedef double* TCoordSlice;
- typedef int TInt;
+ using TDoubleVector = std::vector<double>;
+ using TCoordSlice = double *;
+ using TInt = int;
//---------------------------------------------------------------
//! Shape function definitions
//---------------------------------------------------------------
//---------------------------------------------------------------
TSeg2a::TSeg2a():TShapeFun(1,2)
{
- TInt aNbRef = GetNbRef();
+ TInt const aNbRef = GetNbRef();
for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
//---------------------------------------------------------------
TSeg3a::TSeg3a():TShapeFun(1,3)
{
- TInt aNbRef = GetNbRef();
+ TInt const aNbRef = GetNbRef();
for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
TTria3a::TTria3a():
TShapeFun(2,3)
{
- TInt aNbRef = GetNbRef();
+ TInt const aNbRef = GetNbRef();
for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
//---------------------------------------------------------------
TTria6a::TTria6a():TShapeFun(2,6)
{
- TInt aNbRef = GetNbRef();
+ TInt const aNbRef = GetNbRef();
for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
TTria3b::TTria3b():
TShapeFun(2,3)
{
- TInt aNbRef = GetNbRef();
+ TInt const aNbRef = GetNbRef();
for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
TTria6b::TTria6b():
TShapeFun(2,6)
{
- TInt aNbRef = GetNbRef();
+ TInt const aNbRef = GetNbRef();
for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
TQuad4a::TQuad4a():
TShapeFun(2,4)
{
- TInt aNbRef = GetNbRef();
+ TInt const aNbRef = GetNbRef();
for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
TQuad8a::TQuad8a():
TShapeFun(2,8)
{
- TInt aNbRef = GetNbRef();
+ TInt const aNbRef = GetNbRef();
for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
TQuad4b::TQuad4b():
TShapeFun(2,4)
{
- TInt aNbRef = GetNbRef();
+ TInt const aNbRef = GetNbRef();
for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
TQuad8b::TQuad8b():
TShapeFun(2,8)
{
- TInt aNbRef = GetNbRef();
+ TInt const aNbRef = GetNbRef();
for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
TTetra4a::TTetra4a():
TShapeFun(3,4)
{
- TInt aNbRef = GetNbRef();
+ TInt const aNbRef = GetNbRef();
for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
TTetra10a::TTetra10a():
TShapeFun(3,10)
{
- TInt aNbRef = GetNbRef();
+ TInt const aNbRef = GetNbRef();
for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
TTetra4b::TTetra4b():
TShapeFun(3,4)
{
- TInt aNbRef = GetNbRef();
+ TInt const aNbRef = GetNbRef();
for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
TTetra10b::TTetra10b():
TShapeFun(3,10)
{
- TInt aNbRef = GetNbRef();
+ TInt const aNbRef = GetNbRef();
for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
THexa8a::THexa8a():
TShapeFun(3,8)
{
- TInt aNbRef = GetNbRef();
+ TInt const aNbRef = GetNbRef();
for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
THexa20a::THexa20a(TInt theDim, TInt theNbRef):
TShapeFun(theDim,theNbRef)
{
- std::size_t aNbRef = myRefCoord.size();
+ std::size_t const aNbRef = myRefCoord.size();
for(std::size_t aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
THexa27a::THexa27a():
THexa20a(3,27)
{
- std::size_t aNbRef = myRefCoord.size();
+ std::size_t const aNbRef = myRefCoord.size();
for(std::size_t aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
THexa8b::THexa8b():
TShapeFun(3,8)
{
- TInt aNbRef = GetNbRef();
+ TInt const aNbRef = GetNbRef();
for(TInt aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
THexa20b::THexa20b(TInt theDim, TInt theNbRef):
TShapeFun(theDim,theNbRef)
{
- std::size_t aNbRef = myRefCoord.size();
+ std::size_t const aNbRef = myRefCoord.size();
for(std::size_t aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
TPenta6a::TPenta6a():
TShapeFun(3,6)
{
- std::size_t aNbRef = myRefCoord.size();
+ std::size_t const aNbRef = myRefCoord.size();
for(std::size_t aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
TPenta6b::TPenta6b():
TShapeFun(3,6)
{
- std::size_t aNbRef = myRefCoord.size();
+ std::size_t const aNbRef = myRefCoord.size();
for(std::size_t aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
TPenta15a::TPenta15a():
TShapeFun(3,15)
{
- std::size_t aNbRef = myRefCoord.size();
+ std::size_t const aNbRef = myRefCoord.size();
for(std::size_t aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
TPenta15b::TPenta15b():
TShapeFun(3,15)
{
- std::size_t aNbRef = myRefCoord.size();
+ std::size_t const aNbRef = myRefCoord.size();
for(std::size_t aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
TPyra5a::TPyra5a():
TShapeFun(3,5)
{
- std::size_t aNbRef = myRefCoord.size();
+ std::size_t const aNbRef = myRefCoord.size();
for(std::size_t aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
TPyra5b::TPyra5b():
TShapeFun(3,5)
{
- std::size_t aNbRef = myRefCoord.size();
+ std::size_t const aNbRef = myRefCoord.size();
for(std::size_t aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
TPyra13a::TPyra13a():
TShapeFun(3,13)
{
- std::size_t aNbRef = myRefCoord.size();
+ std::size_t const aNbRef = myRefCoord.size();
for(std::size_t aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
TPyra13b::TPyra13b():
TShapeFun(3,13)
{
- std::size_t aNbRef = myRefCoord.size();
+ std::size_t const aNbRef = myRefCoord.size();
for(std::size_t aRefId = 0; aRefId < aNbRef; aRefId++){
TCoordSlice aCoord = GetCoord(aRefId);
switch(aRefId){
static const int seg3 [] = {0,2,1};
if ( conn.empty() )
{
- conn.resize( MaxMedCellType + 1, 0 );
+ conn.resize( MaxMedCellType + 1, nullptr );
conn[ NORM_HEXA20 ] = hexa20;
conn[ NORM_PENTA15] = penta15;
conn[ NORM_PYRA13 ] = pyra13;
//================================================================================
Cell::Cell(const Cell& ma)
- : _nodes(ma._nodes), _reverse(ma._reverse), _sortedNodeIDs(0), _number(ma._number)
+ : _nodes(ma._nodes), _reverse(ma._reverse), _number(ma._number)
{
if ( ma._sortedNodeIDs )
{
SauvUtilities::Link Cell::link(int i) const
{
- std::size_t i2 = ( i + 1 ) % _nodes.size();
+ std::size_t const i2 = ( i + 1 ) % _nodes.size();
if ( _reverse )
return std::make_pair( _nodes[i2]->_number, _nodes[i]->_number );
else
{
if ( !_sortedNodeIDs )
{
- size_t l=_nodes.size();
+ size_t const l=_nodes.size();
_sortedNodeIDs = new TID[ l ];
for (size_t i=0; i!=l; ++i)
else if ( !_cells.empty() )
sizze = _cells.size();
else
- for ( size_t i = 0; i < _groups.size(); ++i )
- sizze += _groups[i]->size();
+ for (auto _group : _groups)
+ sizze += _group->size();
return ToIdType( sizze );
}
if (_file >= 0)
{
::close (_file);
- if (_start != 0L)
+ if (_start != nullptr)
{
delete [] _start;
//delete [] _tmpBuf;
- _start = 0;
+ _start = nullptr;
}
_file = -1;
}
}
else
{
- _curPos = 0;
+ _curPos = nullptr;
}
}
}
else
{
- _curPos = 0;
+ _curPos = nullptr;
}
}
// 53619906 | SCALAIRE
// 53619907 | -63312600499 1 0 0 0 -2 0 2
// where -63312600499 is actually -633 and 12600499
- char hold=_curPos[_width];
+ char const hold=_curPos[_width];
_curPos[_width] = '\0';
- int result = atoi( _curPos );
+ int const result = atoi( _curPos );
_curPos[_width] = hold;
return result;
//return atoi(str());
*/
//================================================================================
-XDRReader::XDRReader(const char* fileName) :FileReader(fileName), _xdrs_file(NULL)
+XDRReader::XDRReader(const char* fileName) :FileReader(fileName), _xdrs_file(nullptr)
{
}
xdr_destroy((XDR*)_xdrs);
free((XDR*)_xdrs);
::fclose(_xdrs_file);
- _xdrs_file = NULL;
+ _xdrs_file = nullptr;
}
#endif
}
xdr_destroy((XDR*)_xdrs);
free((XDR*)_xdrs);
fclose(_xdrs_file);
- _xdrs_file = NULL;
+ _xdrs_file = nullptr;
}
}
#endif
_xdr_kind = _xdr_kind_char;
if(nbValues*width)
{
- unsigned int nels = nbValues*width;
+ unsigned int const nels = nbValues*width;
_xdr_cvals = (char*)malloc((nels+1)*sizeof(char));
#ifdef HAS_XDR
xdr_string((XDR*)_xdrs, &_xdr_cvals, nels);
if(nbValues)
{
#ifdef HAS_XDR
- unsigned int nels = nbValues;
+ unsigned int const nels = nbValues;
unsigned int actual_nels;
_xdr_ivals = (int*)malloc(nels*sizeof(int));
xdr_array((XDR*)_xdrs, (char **)&_xdr_ivals, &actual_nels, nels, sizeof(int), (xdrproc_t)xdr_int);
if(nbValues)
{
#ifdef HAS_XDR
- unsigned int nels = nbValues;
+ unsigned int const nels = nbValues;
unsigned int actual_nels;
_xdr_dvals = (double*)malloc(nels*sizeof(double));
xdr_array((XDR*)_xdrs, (char **)&_xdr_dvals, &actual_nels, nels, sizeof(double), (xdrproc_t)xdr_double);
// correct pointers to sub-groups
for ( size_t j = 0; j < _groups[i]._groups.size(); ++j )
{
- std::size_t iG = _groups[i]._groups[j] - &_groups[0];
+ std::size_t const iG = _groups[i]._groups[j] - &_groups[0];
newGroups[i]._groups[j] = & newGroups[ iG ];
}
}
// fix given groups
if ( groupsToFix )
- for ( size_t i = 0; i < groupsToFix->size(); ++i )
- if ( (*groupsToFix)[i] )
+ for (auto & i : *groupsToFix)
+ if ( i )
{
- std::size_t iG = (*groupsToFix)[i] - &_groups[0];
- (*groupsToFix)[i] = & newGroups[ iG ];
+ std::size_t const iG = i - &_groups[0];
+ i = & newGroups[ iG ];
}
// fix field supports
for ( int isNode = 0; isNode < 2; ++isNode )
{
- std::vector<DoubleField* >& fields = isNode ? _nodeFields : _cellFields;
- for ( size_t i = 0; i < fields.size(); ++i )
+ std::vector<DoubleField* > const& fields = isNode ? _nodeFields : _cellFields;
+ for (auto & field : fields)
{
- if ( !fields[i] ) continue;
- for ( size_t j = 0; j < fields[i]->_sub.size(); ++j )
- if ( fields[i]->_sub[j]._support )
+ if ( !field ) continue;
+ for (auto & j : field->_sub)
+ if ( j._support )
{
- std::size_t iG = fields[i]->_sub[j]._support - &_groups[0];
- fields[i]->_sub[j]._support = & newGroups[ iG ];
+ std::size_t const iG = j._support - &_groups[0];
+ j._support = & newGroups[ iG ];
}
- if ( fields[i]->_group )
+ if ( field->_group )
{
- std::size_t iG = fields[i]->_group - &_groups[0];
- fields[i]->_group = & newGroups[ iG ];
+ std::size_t const iG = field->_group - &_groups[0];
+ field->_group = & newGroups[ iG ];
}
}
}
// 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();
+ for (auto & _group : _groups)
+ if ( !_group._isProfile )
+ _group._name.clear();
// IMP 0020434: mapping GIBI names to MED names
std::set<int> treatedGroups;
- std::list<nameGIBItoMED>::iterator itGIBItoMED = _listGIBItoMED_mail.begin();
+ auto itGIBItoMED = _listGIBItoMED_mail.begin();
for (; itGIBItoMED != _listGIBItoMED_mail.end(); itGIBItoMED++)
{
if ( (int)_groups.size() < itGIBItoMED->gibi_id ) continue;
}
else if ( !grp._refNames.empty() && grp._refNames.back().empty() )
{
- for ( unsigned i = 0; i < grp._refNames.size(); ++i )
- if ( grp._refNames[i].empty() )
- grp._refNames[i] = _mapStrings[ (*itGIBItoMED).med_id ];
+ for (auto & _refName : grp._refNames)
+ if ( _refName.empty() )
+ _refName = _mapStrings[ (*itGIBItoMED).med_id ];
}
else
{
// 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 )
+ for (auto & grp : _groups)
{
- 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 (auto & _cell : grp._cells)
+ _cell->_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;
+ for (auto & _group : grp._groups)
+ for (auto & _cell : _group->_cells)
+ _cell->_reverse = true;
}
}
// remove non-marked cells (with _reverse == false)
while ( cellsIt.nextType() )
{
std::set<Cell> & cells = _cellsByType[ cellsIt.type() ];
- std::set<Cell>::iterator cIt = cells.begin();
+ auto cIt = cells.begin();
while ( cIt != cells.end() )
if ( cIt->_reverse )
{
void IntermediateMED::setFieldLongNames(std::set< std::string >& usedNames)
{
- std::list<nameGIBItoMED>::iterator itGIBItoMED = _listGIBItoMED_cham.begin();
+ auto itGIBItoMED = _listGIBItoMED_cham.begin();
for (; itGIBItoMED != _listGIBItoMED_cham.end(); itGIBItoMED++)
{
if (itGIBItoMED->gibi_pile == PILE_FIELD)
for (itGIBItoMED =_listGIBItoMED_comp.begin(); itGIBItoMED != _listGIBItoMED_comp.end(); itGIBItoMED++)
{
- std::string medName = _mapStrings[itGIBItoMED->med_id];
- std::string gibiName = _mapStrings[itGIBItoMED->gibi_id];
+ std::string const medName = _mapStrings[itGIBItoMED->med_id];
+ std::string const gibiName = _mapStrings[itGIBItoMED->gibi_id];
- bool name_found = false;
+ bool const name_found = false;
for ( int isNodal = 0; isNodal < 2 && !name_found; ++isNodal )
{
std::vector<DoubleField* > & fields = isNodal ? _nodeFields : _cellFields;
if (medName.find( fields[ifi]->_name + "." ) == 0 )
{
std::vector<DoubleField::_Sub_data>& aSubDs = fields[ifi]->_sub;
- std::size_t nbSub = aSubDs.size();
+ std::size_t const 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)
{
- std::string medNameCompo = medName.substr( fields[ifi]->_name.size() + 1 );
+ std::string const medNameCompo = medName.substr( fields[ifi]->_name.size() + 1 );
fields[ifi]->_sub[isu].compName(ico) = medNameCompo;
}
}
}
} // iterate on _listGIBItoMED_comp
- for ( size_t i = 0; i < _nodeFields.size() ; i++)
- usedNames.insert( _nodeFields[i]->_name );
- for ( size_t i = 0; i < _cellFields.size() ; i++)
- usedNames.insert( _cellFields[i]->_name );
+ for (auto & _nodeField : _nodeFields)
+ usedNames.insert( _nodeField->_name );
+ for (auto & _cellField : _cellFields)
+ usedNames.insert( _cellField->_name );
}
//================================================================================
void IntermediateMED::decreaseHierarchicalDepthOfSubgroups()
{
- for (size_t i=0; i!=_groups.size(); ++i)
+ for (auto & grp : _groups)
{
- Group& grp = _groups[i];
for (size_t j = 0; j < grp._groups.size(); ++j )
{
Group & sub_grp = *grp._groups[j];
// 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] );
+ for (auto & _group : grp._groups)
+ if ( !_group->empty() )
+ newSubGroups.push_back( _group );
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)
+ for (auto & grp : _groups)
{
- 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)
+ for (auto & grp : _groups)
{
- Group& grp = _groups[i];
if ( !grp._name.empty() && !grp.empty() )
{
groups2convert.insert( &grp );
}
}
// erase groups that are not in groups2convert and not _isProfile
- for (size_t i=0; i!=_groups.size(); ++i)
+ for (auto & _group : _groups)
{
- Group* grp = &_groups[i];
+ Group* grp = &_group;
if ( !grp->_isProfile && !groups2convert.count( grp ) )
{
grp->_cells.clear();
void IntermediateMED::detectMixDimGroups()
{
//hasMixedCells = false;
- for ( size_t i=0; i < _groups.size(); ++i )
+ for (auto & grp : _groups)
{
- Group& grp = _groups[i];
if ( grp._groups.size() < 2 )
continue;
// check if sub-groups have different dimension
- unsigned dim1 = getDim( &grp );
+ unsigned const dim1 = getDim( &grp );
for ( size_t j = 1; j < grp._groups.size(); ++j )
{
- unsigned dim2 = getDim( grp._groups[j] );
+ unsigned const dim2 = getDim( grp._groups[j] );
if ( dim1 != dim2 )
{
grp._cells.clear();
// ------------------------------------
// fix connectivity of quadratic edges
// ------------------------------------
- std::set<Cell>& quadEdges = _cellsByType[ INTERP_KERNEL::NORM_SEG3 ];
+ std::set<Cell> const& quadEdges = _cellsByType[ INTERP_KERNEL::NORM_SEG3 ];
if ( !quadEdges.empty() )
{
elemIt = quadEdges.begin(), elemEnd = quadEdges.end();
std::map<Link, std::list<const Cell*> > linkFacesMap;
std::map<Link, std::list<const Cell*> >::iterator lfIt, lfIt2;
- for (size_t i=0; i!=_groups.size(); ++i)
+ for (auto & grp : _groups)
{
- Group& grp = _groups[i];
if ( !grp._cells.empty() && getDimension( grp._cellType ) == 2 )
for ( size_t j = 0; j < grp._cells.size(); ++j )
if ( faces.insert( grp._cells[j] ).second )
// loop on links of <face>
for ( int i = 0; i < (int)face->_nodes.size(); ++i )
{
- Link link = face->link( i );
+ Link const link = face->link( i );
// find the neighbor faces
lfIt = linkFacesMap.find( link );
int nbFaceByLink = 0;
if ( lfIt != linkFacesMap.end() )
{
std::list<const Cell*> & fList = lfIt->second;
- std::list<const Cell*>::iterator fIt = fList.begin();
+ auto fIt = fList.begin();
assert( fIt != fList.end() );
for ( ; fIt != fList.end(); fIt++, nbFaceByLink++ )
{
// reverse and remove badFace from linkFacesMap
for ( int j = 0; j < (int)badFace->_nodes.size(); ++j )
{
- Link badlink = badFace->link( j );
+ Link const badlink = badFace->link( j );
if ( badlink == link ) continue;
lfIt2 = linkFacesMap.find( badlink );
if ( lfIt2 != linkFacesMap.end() )
{
std::list<const Cell*> & ff = lfIt2->second;
- std::list<const Cell*>::iterator lfIt3 = find( ff.begin(), ff.end(), badFace );
+ auto const lfIt3 = find( ff.begin(), ff.end(), badFace );
// check if badFace has been found,
// else we can't erase it
// case of degenerated face in edge
linkFacesMap.erase( lfIt );
}
// add good neighbors to the queue
- Link revLink( link.second, link.first );
+ Link const revLink( link.second, link.first );
lfIt = linkFacesMap.find( revLink );
if ( lfIt != linkFacesMap.end() )
{
std::list<const Cell*> & fList = lfIt->second;
- std::list<const Cell*>::iterator fIt = fList.begin();
+ auto fIt = fList.begin();
for ( ; fIt != fList.end(); fIt++, nbFaceByLink++ )
{
ml.push_back( *fIt );
{
if ( manifold )
{
- std::list<const Cell*>::iterator ii = ml.begin();
+ auto ii = ml.begin();
std::cout << nbFaceByLink << " faces by 1 link:" << std::endl;
for( ; ii!= ml.end(); ii++ )
std::cout << "in sub-mesh <" << fgm[ *ii ]->_name << "> " << **ii << std::endl;
vec[0] = normal[1] * vec01[2] - normal[2] * vec01[1];
vec[1] = normal[2] * vec01[0] - normal[0] * vec01[2];
vec[2] = normal[0] * vec01[1] - normal[1] * vec01[0];
- double dot2 = vec[0]*vec03[0] + vec[1]*vec03[1] + vec[2]*vec03[2]; // vec*vec03
+ double const dot2 = vec[0]*vec03[0] + vec[1]*vec03[1] + vec[2]*vec03[2]; // vec*vec03
if ( dot2 < 0 ) // concave -> reverse normal
{
normal[0] *= -1;
tbDir[2] = n[0][2] - n[3][2];
// compare 2 directions: normal and top-bottom
- double dot = normal[0]*tbDir[0] + normal[1]*tbDir[1] + normal[2]*tbDir[2];
+ double const dot = normal[0]*tbDir[0] + normal[1]*tbDir[1] + normal[2]*tbDir[2];
if ( dot < 0. ) // need reverse
reverse( *elemIt, swapVec );
int NodeContainer::numberNodes()
{
int id = 1;
- for ( size_t i = 0; i < _nodes.size(); ++i )
- for ( size_t j = 0; j < _nodes[i].size(); ++j )
- if ( _nodes[i][j].isUsed() )
- _nodes[i][j]._number = id++;
+ for (auto & _node : _nodes)
+ for (auto & j : _node)
+ if ( j.isUsed() )
+ j._number = id++;
return id-1;
}
if ( elemIt->_number < minNumber ) minNumber = elemIt->_number;
if ( elemIt->_number > maxNumber ) maxNumber = elemIt->_number;
}
- mcIdType typeSize = ToIdType( typeCells->size() );
+ mcIdType const typeSize = ToIdType( typeCells->size() );
if ( typeSize != maxNumber - minNumber + 1 )
ok = false;
if ( prevNbElems+1 != (int)minNumber )
prevNbCells += ToIdType( cells->size() );
// fill dimMesh
- TCellType cellType = dimCells.type();
+ TCellType const cellType = dimCells.type();
nodalConnOfCell = &connectivity[0];
for ( size_t i = 0; i < cells->size(); ++i, nodalConnOfCell += nbCellNodes )
dimMesh->insertNextCell( cellType, nbCellNodes, nodalConnOfCell );
std::vector< Group* > groupVec;
if ( grp._groups.empty() ) groupVec.push_back( & grp );
else groupVec = grp._groups;
- for ( size_t iG = 0; iG < groupVec.size(); ++iG )
+ for (auto aG : groupVec)
{
- Group* aG = groupVec[ iG ];
if ( (int)getDim( aG ) != dim )
continue;
- for ( size_t iC = 0; iC < aG->_cells.size(); ++iC )
- cell2order.insert( cell2order.end(), std::make_pair( aG->_cells[iC], orderInGroup++ ));
+ for (auto & _cell : aG->_cells)
+ cell2order.insert( cell2order.end(), std::make_pair( _cell, orderInGroup++ ));
}
if ( cell2order.empty() )
continue;
- bool isSelfIntersect = ( orderInGroup != cell2order.size() );
+ bool const isSelfIntersect = ( orderInGroup != cell2order.size() );
if ( isSelfIntersect ) // self intersecting group
{
std::ostringstream msg;
bool IntermediateMED::isOnAll( const Group* grp, int & dimRel ) const
{
- int dim = getDim( grp );
+ int const dim = getDim( grp );
mcIdType nbElems = 0;
if ( dim == 0 )
dimRel = dim - meshDim;
}
- bool onAll = ( nbElems == grp->size() );
+ bool const onAll = ( nbElems == grp->size() );
return onAll;
}
MEDCoupling::MEDFileFields * IntermediateMED::makeMEDFileFields(MEDCoupling::MEDFileUMesh* mesh)
{
- if ( _nodeFields.empty() && _cellFields.empty() ) return 0;
+ if ( _nodeFields.empty() && _cellFields.empty() ) return nullptr;
// set long names
std::set< std::string > usedFieldNames;
double * valPtr = values->getPointer();
if ( uniteSubs )
{
- mcIdType nbElems = fld->_group->size();
+ mcIdType const 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 );
// set gauss points
if ( timeStamp->getTypeOfField() == MEDCoupling::ON_GAUSS_PT )
{
- TGaussDef gaussDef( fld->_sub[iSub]._support->_cellType,
+ TGaussDef const gaussDef( fld->_sub[iSub]._support->_cellType,
fld->_sub[iSub].nbGauss() );
timeStamp->setGaussLocalizationOnType( fld->_sub[iSub]._support->_cellType,
gaussDef.myRefCoords,
}
else
{
- std::string::size_type pos = base.rfind('_');
+ std::string::size_type const pos = base.rfind('_');
if ( pos != std::string::npos )
base = base.substr( 0, pos+1 );
else
bool DoubleField::hasSameComponentsBySupport() const
{
- std::vector< _Sub_data >::const_iterator sub_data = _sub.begin();
+ auto sub_data = _sub.begin();
const _Sub_data& first_sub_data = *sub_data;
for ( ++sub_data ; sub_data != _sub.end(); ++sub_data )
{
mcIdType valsShift = 0;
for ( mcIdType iS = iSub-1, shift = elemShift; shift > 0; --iS)
{
- mcIdType nbE = _sub[iS]._support->size();
+ mcIdType const nbE = _sub[iS]._support->size();
shift -= nbE;
valsShift += nbE * _sub[iS].nbComponents() * _sub[iS].nbGauss();
}
if ( isConstField )
for ( mcIdType iE = 0; iE < nbElems; ++iE )
{
- mcIdType iMed = valsShift + nbValsByElem * ( relocTable.empty() ? iE : relocTable[iE+elemShift]-elemShift );
+ mcIdType const iMed = valsShift + nbValsByElem * ( relocTable.empty() ? iE : relocTable[iE+elemShift]-elemShift );
for ( iComp = 0; iComp < nbComponents; ++iComp )
valPtr[ iMed + iComp ] = compValues[iComp][ 0 ];
}
else
for ( mcIdType iE = 0; iE < nbElems; ++iE )
{
- mcIdType iMed = valsShift + nbValsByElem * ( relocTable.empty() ? iE : relocTable[iE+elemShift]-elemShift );
+ mcIdType const 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 ];
IntermediateMED::~IntermediateMED()
{
- for ( size_t i = 0; i < _nodeFields.size(); ++i )
- if ( _nodeFields[i] )
- delete _nodeFields[i];
+ for (auto & _nodeField : _nodeFields)
+ if ( _nodeField )
+ delete _nodeField;
_nodeFields.clear();
- for ( size_t i = 0; i < _cellFields.size(); ++i )
- if ( _cellFields[i] )
- delete _cellFields[i];
+ for (auto & _cellField : _cellFields)
+ if ( _cellField )
+ delete _cellField;
_cellFields.clear();
- for ( size_t i = 0; i < _groups.size(); ++i )
- if ( _groups[i]._medGroup )
- _groups[i]._medGroup->decrRef();
+ for (auto & _group : _groups)
+ if ( _group._medGroup )
+ _group._medGroup->decrRef();
}
//================================================================================
while ( ++myCurType < myTypeEnd )
if ( !myImed->_cellsByType[myCurType].empty() && ( myDim < 0 || dim(false) == myDim ))
return & myImed->_cellsByType[myCurType];
- return 0;
+ return nullptr;
}
/*!
* \brief return dimension of cells returned by the last or further next()
#ifndef __SauvMedConvertor_HXX__
#define __SauvMedConvertor_HXX__
-#include "InterpKernelException.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
+#include "MCIdType.hxx"
#include "MEDCouplingRefCountObject.hxx"
#include "SauvUtilities.hxx"
#include "MCType.hxx"
+#include "NormalizedGeometricTypes"
+#include <utility>
+#include <cstddef>
+#include <ostream>
+#include <string>
+#include <cstdio>
#include <vector>
#include <set>
#include <map>
struct IntermediateMED;
// ==============================================================================
- typedef mcIdType TID; // an ID countered from 1
- typedef std::pair<TID,TID> Link; // a pair of node numbers
+ using TID = mcIdType; // an ID countered from 1
+ using Link = std::pair<TID, TID>; // a pair of node numbers
typedef INTERP_KERNEL::NormalizedCellType TCellType;
// ==============================================================================
struct Node
{
- TID _number;
+ TID _number{0};
size_t _coordID;
- Node():_number(0){}
+ Node()= default;
bool isUsed() const { return _number != 0; }
};
struct Cell
{
std::vector< Node* > _nodes;
- mutable bool _reverse; // to reverse orientation of a face only
- mutable TID* _sortedNodeIDs; // for comparison
- mutable TID _number;
+ mutable bool _reverse{false}; // to reverse orientation of a face only
+ mutable TID* _sortedNodeIDs{nullptr}; // for comparison
+ mutable TID _number{0};
- Cell(size_t nnNodes=0) : _nodes(nnNodes),_reverse(false),_sortedNodeIDs(0),_number(0) {}
+ Cell(size_t nnNodes=0) : _nodes(nnNodes) {}
Cell(const Cell& ma);
- void init() const { if ( _sortedNodeIDs ) delete [] _sortedNodeIDs; _sortedNodeIDs = 0; }
+ void init() const { if ( _sortedNodeIDs ) delete [] _sortedNodeIDs; _sortedNodeIDs = nullptr; }
~Cell() { init(); }
const TID* getSortedNodes() const; // creates if needed and return _sortedNodeIDs
// ==============================================================================
struct Group
{
- TCellType _cellType;
+ TCellType _cellType{INTERP_KERNEL::NORM_ERROR};
std::string _name;
std::vector<const Cell*> _cells;
std::vector< Group* > _groups; // des sous-groupes composant le Group
- bool _isProfile; // is a field support or not
+ bool _isProfile{false}; // is a field support or not
std::vector<std::string> _refNames; /* names of groups referring this one;
_refNames is resized according to nb of references
while reading a group (pile 1) and it is filled with
reference is converted into a copy of the medGroup
(issue 0021311)
*/
- MEDCoupling::DataArrayIdType* _medGroup; // result of conversion
+ MEDCoupling::DataArrayIdType* _medGroup{nullptr}; // result of conversion
std::vector< mcIdType > _relocTable; // for _cells[i] gives its index in _medGroup
bool empty() const { return _cells.empty() && _groups.empty(); }
mcIdType size() const;
- Group():_cellType(INTERP_KERNEL::NORM_ERROR), _isProfile(false), _medGroup(NULL) {}
+ Group() {}
};
// ==============================================================================
std::string _name;
std::string _description; // field description
std::vector< _Sub_data > _sub;
- Group* _group; /* if _group == NULL then each subcomponent makes a
+ Group* _group{nullptr}; /* if _group == NULL then each subcomponent makes a
separate med field, else all subcomponents
are converted into timestamps of one med field.
The latter is possible only if nb of components in all subs
is the same and supports of subcomponents do not overlap
*/
std::vector< std::vector< double > > _comp_values;
- MEDCoupling::MEDFileFieldMultiTS* _curMedField;
+ MEDCoupling::MEDFileFieldMultiTS* _curMedField{nullptr};
DoubleField( int nb_sub, int total_nb_comp )
- : _sub(nb_sub), _group(NULL), _curMedField(NULL) { _comp_values.reserve( total_nb_comp ); }
+ : _sub(nb_sub) { _comp_values.reserve( total_nb_comp ); }
~DoubleField();
std::vector< double >& addComponent( int nb_values ); // return a vector ready to fill in
bool hasCommonSupport() const { return _group; } // true if there is one support for all subs
*/
struct IntermediateMED
{
- unsigned _spaceDim;
- unsigned _nbNodes;
+ unsigned _spaceDim{0};
+ unsigned _nbNodes{0};
NodeContainer _points;
std::vector<double> _coords;
std::vector<Group> _groups;
std::list<nameGIBItoMED> _listGIBItoMED_comp; // to read from table "MED_COMP" of PILE_TABLES
std::map<int,std::string> _mapStrings; // to read from PILE_STRINGS
- IntermediateMED(): _spaceDim(0), _nbNodes(0) {}
+ IntermediateMED() = default;
~IntermediateMED();
Node* getNode( TID nID ) { return _points.getNode( nID ); }
mcIdType getNbCellsOfType( TCellType type ) const { return ToIdType(_cellsByType[type].size()); }
const Cell* insert(TCellType type, const Cell& ma) { return &( *_cellsByType[type].insert( ma ).first ); }
- Group* addNewGroup(std::vector<SauvUtilities::Group*>* groupsToFix=0);
+ Group* addNewGroup(std::vector<SauvUtilities::Group*>* groupsToFix=nullptr);
MEDCoupling::MEDFileData* convertInMEDFileDS();
private:
{
public:
ASCIIReader(const char* fileName);
- virtual ~ASCIIReader();
- virtual bool isASCII() const;
- virtual bool open();
- virtual bool getNextLine (char* & line, bool raiseOEF = true );
- virtual void initNameReading(int nbValues, int width = 8);
- virtual void initIntReading(int nbValues);
- virtual void initDoubleReading(int nbValues);
- virtual bool more() const;
- virtual void next();
- virtual int getInt() const;
- virtual float getFloat() const;
- virtual double getDouble() const;
- virtual std::string getName() const;
+ ~ASCIIReader() override;
+ bool isASCII() const override;
+ bool open() override;
+ bool getNextLine (char* & line, bool raiseOEF = true ) override;
+ void initNameReading(int nbValues, int width = 8) override;
+ void initIntReading(int nbValues) override;
+ void initDoubleReading(int nbValues) override;
+ bool more() const override;
+ void next() override;
+ int getInt() const override;
+ float getFloat() const override;
+ double getDouble() const override;
+ std::string getName() const override;
int lineNb() const { return _lineNb; }
std::string getClassName() const override { return std::string("ASCIIReader"); }
private:
{
public:
XDRReader(const char* fileName);
- virtual ~XDRReader();
- virtual bool isASCII() const;
- virtual bool open();
- virtual bool getNextLine (char* & line, bool raiseOEF = true );
- virtual void initNameReading(int nbValues, int width = 8);
- virtual void initIntReading(int nbValues);
- virtual void initDoubleReading(int nbValues);
- virtual bool more() const;
- virtual void next();
- virtual int getInt() const;
- virtual float getFloat() const;
- virtual double getDouble() const;
- virtual std::string getName() const;
+ ~XDRReader() override;
+ bool isASCII() const override;
+ bool open() override;
+ bool getNextLine (char* & line, bool raiseOEF = true ) override;
+ void initNameReading(int nbValues, int width = 8) override;
+ void initIntReading(int nbValues) override;
+ void initDoubleReading(int nbValues) override;
+ bool more() const override;
+ void next() override;
+ int getInt() const override;
+ float getFloat() const override;
+ double getDouble() const override;
+ std::string getName() const override;
std::string getClassName() const override { return std::string("XDRReader"); }
private:
#include "SauvReader.hxx"
+#include "InterpKernelException.hxx"
#include "SauvMedConvertor.hxx"
#include "MCAuto.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
#include "MEDCouplingRefCountObject.hxx"
+#include "SauvUtilities.hxx"
+#include "NormalizedGeometricTypes"
+#include <clocale>
+#include <cstdlib>
#include <cstring>
-#include <sstream>
+#include <map>
+#include <set>
#include <iostream>
+#include <string>
+#include <vector>
+#include <utility>
using namespace MEDCoupling;
using namespace SauvUtilities;
public:
Localizer()
{
- _locale = setlocale(LC_NUMERIC, NULL);
+ _locale = setlocale(LC_NUMERIC, nullptr);
setlocale(LC_NUMERIC, "C");
}
~Localizer()
parser = new XDRReader( fileName.c_str() );
if ( parser->open() )
{
- SauvReader* reader = new SauvReader;
+ auto* reader = new SauvReader;
reader->_fileReader = parser.retn();
return reader;
}
parser = new ASCIIReader( fileName.c_str() );
if ( parser->open() )
{
- SauvReader* reader = new SauvReader;
+ auto* reader = new SauvReader;
reader->_fileReader = parser.retn();
return reader;
}
MEDCoupling::MEDFileData * SauvReader::loadInMEDFileDS()
{
- Localizer loc; // localization, to read numbers in "C" locale
+ Localizer const loc; // localization, to read numbers in "C" locale
SauvUtilities::IntermediateMED iMed; // intermadiate DS
_iMed = &iMed;
for (int object=0; object!=nbObjects; ++object) // loop on sub-groups
{
initIntReading( 5 );
- int castemCellType = getIntNext();
- int nbSubGroups = getIntNext();
- int nbReferences = getIntNext();
- int nbNodesPerElem = getIntNext();
- int nbElements = getIntNext();
+ int const castemCellType = getIntNext();
+ int const nbSubGroups = getIntNext();
+ int const nbReferences = getIntNext();
+ int const nbNodesPerElem = getIntNext();
+ int const nbElements = getIntNext();
_iMed->_groups.push_back(Group());
SauvUtilities::Group & group = _iMed->_groups.back();
ma.init();
for ( int n = 0; n < nbNodesPerElem; ++n )
{
- int nodeID = getIntNext();
+ int const nodeID = getIntNext();
pNode = _iMed->getNode( nodeID );
ma._nodes[n] = pNode;
_iMed->_nbNodes += ( !pNode->isUsed() );
// set group names
for (i=0; i!=(int)objectNames.size(); ++i)
{
- int grpID = nameIndices[i];
+ int const grpID = nameIndices[i];
SauvUtilities::Group & grp = _iMed->_groups[ grpID-1 ];
if ( !grp._name.empty() ) // a group has several names
{ // create a group with subgroup grp and named grp.name
for (int object=0; object!=nbObjects; ++object) // pour chaque Group
{
initIntReading(1);
- int nb_vals = getIntNext();
+ int const nb_vals = getIntNext();
initDoubleReading(nb_vals);
for(int i=0; i<nb_vals; i++) next();
}
if ( isXRD() )
{
initIntReading(1);
- int nb_vals = getIntNext();
+ int const nb_vals = getIntNext();
initIntReading(nb_vals);
for(int i=0; i<nb_vals; i++) next();
}
if ( isXRD() )
{
initIntReading(1);
- int nb_vals = getIntNext();
+ int const nb_vals = getIntNext();
initDoubleReading(nb_vals);
for(int i=0; i<nb_vals; i++) next();
}
if ( isXRD() )
{
initIntReading(1);
- int nb_vals = getIntNext();
+ int const nb_vals = getIntNext();
initIntReading(nb_vals);
for(int i=0; i<nb_vals; i++) next();
}
for (int object=0; object!=nbObjects; ++object) // pour chaque Group
{
initIntReading(2);
- int len = getIntNext();
- int nb_vals = getIntNext();
- int nb_char = len*nb_vals;
+ int const len = getIntNext();
+ int const nb_vals = getIntNext();
+ int const nb_char = len*nb_vals;
int nb_char_tmp = 0;
- int fixed_length = 71;
+ int const fixed_length = 71;
while (nb_char_tmp < nb_char)
{
- int remain_len = nb_char - nb_char_tmp;
+ int const remain_len = nb_char - nb_char_tmp;
int width;
if ( remain_len > fixed_length )
{
{
// see wrmodl.eso
initIntReading(10);
- int n1 = getIntNext();
- int nm2 = getIntNext();
- int nm3 = getIntNext();
- int nm4 = getIntNext();
- int nm5 = getIntNext();
- int n45 = getIntNext();
+ int const n1 = getIntNext();
+ int const nm2 = getIntNext();
+ int const nm3 = getIntNext();
+ int const nm4 = getIntNext();
+ int const nm5 = getIntNext();
+ int const n45 = getIntNext();
/*int nm6 =*/ getIntNext();
/*int nm7 =*/ getIntNext();
next();
next();
- int nm1 = n1 * n45;
- int nm9 = n1 * 16;
+ int const nm1 = n1 * n45;
+ int const nm9 = n1 * 16;
for (initIntReading(nm1); more(); next());
for (initIntReading(nm9); more(); next());
for (initNameReading(nm5, 8); more(); next());
void SauvReader::read_PILE_NOEUDS (const int nbObjects, std::vector<std::string>&, std::vector<int>&)
{
initIntReading(1);
- int nb_indices = getIntNext();
+ int const nb_indices = getIntNext();
if (nb_indices != nbObjects)
THROW_IK_EXCEPTION("Error of reading PILE NUMERO " << PILE_NOEUDS << lineNb() );
for ( initIntReading( nbObjects ); more(); next() )
{
- int coordID = getInt();
+ int const coordID = getInt();
_iMed->getNode( index()+1 )->_coordID = coordID;
}
}
*/
//================================================================================
-void SauvReader::read_PILE_COORDONNEES (const int nbObjects, std::vector<std::string>&, std::vector<int>&)
+void SauvReader::read_PILE_COORDONNEES (const int /*nbObjects*/, std::vector<std::string>&, std::vector<int>&)
{
initIntReading(1);
- int nbReals = getIntNext();
+ int const nbReals = getIntNext();
if ( nbReals < (int)(_iMed->_nbNodes*(_iMed->_spaceDim+1)) )
THROW_IK_EXCEPTION("Error of reading PILE NUMERO " << PILE_COORDONNEES << lineNb() );
void SauvReader::setFieldSupport(const vector<SauvUtilities::Group*>& supports,
SauvUtilities::DoubleField* field)
{
- SauvUtilities::Group* group = NULL;
- set<SauvUtilities::Group*> sup_set( supports.begin(), supports.end() );
+ SauvUtilities::Group* group = nullptr;
+ set<SauvUtilities::Group*> const sup_set( supports.begin(), supports.end() );
if ( sup_set.size() == 1 ) // one or equal supports
{
group = supports[0];
map<int,int> nbGaussByCellType;
for ( size_t i = 0; i < supports.size(); ++i )
{
- map<int,int>::iterator ct2ng = nbGaussByCellType.find( supports[i]->_cellType );
+ auto const ct2ng = nbGaussByCellType.find( supports[i]->_cellType );
if ( ct2ng == nbGaussByCellType.end() )
nbGaussByCellType[ supports[i]->_cellType ] = field->_sub[i].nbGauss();
else if ( ct2ng->second != field->_sub[i].nbGauss() )
return;
}
- bool isSameCellType = ( nbGaussByCellType.size() == 1 );
+ bool const isSameCellType = ( nbGaussByCellType.size() == 1 );
// try to find an existing composite group with the same sub-groups
if ( isSameCellType )
for ( size_t i = 0; i < _iMed->_groups.size() && !group; ++i )
isSwapped = false;
for ( std::size_t i = 1; i < groups.size(); ++i )
{
- std::size_t nbN1 = groups[i-1]->empty() ? 0 : groups[i-1]->_cells[0]->_nodes.size();
- std::size_t nbN2 = groups[i ]->empty() ? 0 : groups[i ]->_cells[0]->_nodes.size();
+ std::size_t const nbN1 = groups[i-1]->empty() ? 0 : groups[i-1]->_cells[0]->_nodes.size();
+ std::size_t const nbN2 = groups[i ]->empty() ? 0 : groups[i ]->_cells[0]->_nodes.size();
if ( nbN1 > nbN2 )
{
isSwapped = isModified = true;
size_t iFromSub = 0, iNewSub = 0, iNewComp = 0;
for ( ; iFromSub < field->_sub.size(); iFromSub += groups.size() )
{
- size_t iFromComp = iNewComp;
- for ( size_t iG = 0; iG < groups.size(); ++iG )
+ size_t const iFromComp = iNewComp;
+ for (auto & group : groups)
{
size_t iComp = iFromComp;
for ( size_t iSub = iFromSub; iSub < field->_sub.size(); ++iSub )
- if ( field->_sub[ iSub ]._support == groups[ iG ] )
+ if ( field->_sub[ iSub ]._support == group )
{
newSub[ iNewSub++ ] = field->_sub[ iSub ];
int iC = 0, nbC = field->_sub[ iSub ].nbComponents();
unsigned i;
for ( i = 0; i < indices_objets_nommes.size(); ++i )
{
- int fieldIndex = indices_objets_nommes[ i ];
+ int const fieldIndex = indices_objets_nommes[ i ];
if ( fields[ fieldIndex - 1 ] )
fields[ fieldIndex - 1 ]->_name = objets_nommes[ i ];
}
std::vector<std::string>& objectNames,
std::vector<int>& nameIndices)
{
- _iMed->_nodeFields.resize( nbObjects, (SauvUtilities::DoubleField*) 0 );
+ _iMed->_nodeFields.resize( nbObjects, (SauvUtilities::DoubleField*) nullptr );
for (int object=0; object!=nbObjects; ++object) // loop on fields
{
// EXAMPLE ( with no values )
initIntReading( nb_sub * 3 );
for ( i_sub = 0; i_sub < nb_sub; ++i_sub )
{
- int supId = -getIntNext(); // (a) reference to support
+ int const supId = -getIntNext(); // (a) reference to support
if ( supId < 1 || supId > (int)_iMed->_groups.size() )
THROW_IK_EXCEPTION("Wrong mesh reference: "<< supId << lineNb() );
supports[ i_sub ] = &_iMed->_groups[ supId-1 ]; // (a) reference to support
}
// create a field if there are values
- SauvUtilities::DoubleField* fdouble = 0;
+ SauvUtilities::DoubleField* fdouble = nullptr;
if ( total_nb_values > 0 )
fdouble = new DoubleField( nb_sub, total_nb_comp );
_iMed->_nodeFields[ object ] = fdouble;
for ( i_comp = 0; i_comp < nb_comps[ i_sub ]; ++i_comp, next() )
{
// store component name
- string compName = getName();
+ string const compName = getName();
if ( fdouble )
fdouble->_sub[ i_sub ].compName( i_comp ) = compName;
}
// (17) 1.00000000000000E+02 1.00000000000000E+02 1.00000000000000E+02
// (18) ...
- _iMed->_cellFields.resize( nbObjects, (SauvUtilities::DoubleField*) 0 );
+ _iMed->_cellFields.resize( nbObjects, (SauvUtilities::DoubleField*) nullptr );
for (int object=0; object!=nbObjects; ++object) // pour chaque field
{
initIntReading( 4 );
int i_sub, nb_sub = getIntNext(); // (1) <nb_sub> 2 6 <title length>
next(); // skip "2"
next(); // skip "6"
- int title_length = getIntNext(); // <title length>
+ int const title_length = getIntNext(); // <title length>
if ( nb_sub < 1 )
THROW_IK_EXCEPTION("Error of field reading: wrong nb of subcomponents " << nb_sub << lineNb() );
vector<int> nb_comp( nb_sub );
for ( i_sub = 0; i_sub < nb_sub; ++i_sub )
{ // (3)
- int supportId = -getIntNext(); // <reference to support>
+ int const supportId = -getIntNext(); // <reference to support>
next(); // ignore <address>
nb_comp [ i_sub ] = getIntNext(); // <nb of components in the sub>
for ( int i = 0; i < 6; ++i ) next(); // ignore 6 ints, in example "0 0 0 -2 0 3"
// loop on subcomponents of a field, each of which refers to
// a certain support and has its own number of components;
// read component values
- SauvUtilities::DoubleField* fdouble = 0;
+ SauvUtilities::DoubleField* fdouble = nullptr;
for ( i_sub = 0; i_sub < nb_sub; ++ i_sub )
{
vector<string> comp_names( nb_comp[ i_sub ]), comp_type( nb_comp[ i_sub ]);
<< ">" << lineNb() );
}
// now type is known, create a field, one for all subs
- bool isReal = (nb_comp[i_sub] > 0) ? (comp_type[0] == "REAL*8") : true;
+ bool const isReal = (nb_comp[i_sub] > 0) ? (comp_type[0] == "REAL*8") : true;
if ( !fdouble && total_nb_comp )
{
if ( !isReal )
{
// (9) nb of values
initIntReading( 4 );
- int nb_val_by_elem = getIntNext();
+ int const nb_val_by_elem = getIntNext();
int nb_values = getIntNext();
next();
next();
{
// IMP 0020434: mapping GIBI names to MED names
- string table_med_mail = "MED_MAIL";
- string table_med_cham = "MED_CHAM";
- string table_med_comp = "MED_COMP";
+ string const table_med_mail = "MED_MAIL";
+ string const table_med_cham = "MED_CHAM";
+ string const table_med_comp = "MED_COMP";
int table_med_mail_id = -1;
int table_med_cham_id = -1;
int table_med_comp_id = -1;
// read tables "MED_MAIL", "MED_CHAM" and "MED_COMP", that keeps correspondence
// between GIBI names (8 symbols if any) and MED names (possibly longer)
initIntReading(1);
- int nb_table_vals = getIntNext();
+ int const nb_table_vals = getIntNext();
if (nb_table_vals < 0)
THROW_IK_EXCEPTION("Error of reading PILE NUMERO 10" << lineNb() );
//================================================================================
void SauvReader::read_PILE_STRINGS (const int nbObjects,
- std::vector<std::string>& objectNames,
- std::vector<int>& nameIndices)
+ std::vector<std::string>& /*objectNames*/,
+ std::vector<int>& /*nameIndices*/)
{
// IMP 0020434: mapping GIBI names to MED names
initIntReading(2);
- int stringLen = getIntNext();
- int nbSubStrings = getIntNext();
+ int const stringLen = getIntNext();
+ int const nbSubStrings = getIntNext();
if (nbSubStrings != nbObjects)
THROW_IK_EXCEPTION("Error of reading PILE NUMERO 27" << lineNb() );
const int fixedLength = 71;
while ((int)aWholeString.length() < stringLen)
{
- int remainLen = (int)(stringLen - aWholeString.length());
+ int const remainLen = (int)(stringLen - aWholeString.length());
int len;
if ( remainLen > fixedLength )
{
while ((int)aWholeString.length() < stringLen)
{
getNextLine( line );
- int remainLen = (int)(stringLen - aWholeString.length());
+ int const remainLen = (int)(stringLen - aWholeString.length());
if ( remainLen > fixedLength )
{
aWholeString += line + 1;
#define __SAUVREADER_HXX__
#include "MEDLoaderDefines.hxx"
-#include "InterpKernelException.hxx"
#include "SauvUtilities.hxx"
#include "MEDCouplingRefCountObject.hxx"
+#include <cstddef>
#include <vector>
#include <string>
#include <set>
public:
MEDLOADER_EXPORT static SauvReader* New(const std::string& fileName);
MEDLOADER_EXPORT MEDCoupling::MEDFileData * loadInMEDFileDS();
- MEDLOADER_EXPORT ~SauvReader();
+ MEDLOADER_EXPORT ~SauvReader() override;
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("SauvReader"); }
private:
- std::size_t getHeapMemorySizeWithoutChildren() const;
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
void readRecord2();
void readRecord4();
void readRecord7();
void next() { _fileReader->next(); }
int index() const { return _fileReader->index(); }
int getInt() const { return _fileReader->getInt(); }
- int getIntNext() { int i = getInt(); next(); return i; }
+ int getIntNext() { int const i = getInt(); next(); return i; }
float getFloat() const { return _fileReader->getFloat(); }
double getDouble() const { return _fileReader->getDouble(); }
std::string getName() const { return _fileReader->getName(); }
#include "MEDLoaderDefines.hxx"
#include "MEDCouplingRefCountObject.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
+#include "NormalizedGeometricTypes"
+#include <cstddef>
#include <string>
#include <sstream>
+#include <vector>
namespace SauvUtilities
{
{
public:
FileReader(const char* fileName);
- virtual ~FileReader() {}
+ ~FileReader() override = default;
virtual bool isASCII() const = 0;
virtual bool open() = 0;
virtual double getDouble() const = 0;
virtual std::string getName() const = 0;
protected:
- std::size_t getHeapMemorySizeWithoutChildren() const { return 0; }
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const { return std::vector<const BigMemoryObject *>(); }
+ std::size_t getHeapMemorySizeWithoutChildren() const override { return 0; }
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override { return std::vector<const BigMemoryObject *>(); }
protected:
std::string _fileName;
int _iRead, _nbToRead;
#include "SauvWriter.hxx"
#include "InterpKernelException.hxx"
+#include "MCIdType.hxx"
+#include "MEDFileFieldMultiTS.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingUMesh.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingMemArray.hxx"
#include "MEDFileMesh.hxx"
#include "MEDFileField.hxx"
#include "MEDFileData.hxx"
#include "CellModel.hxx"
+#include "NormalizedGeometricTypes"
+#include "SauvUtilities.hxx"
+#include <cctype>
#include <fstream>
-#include <sstream>
#include <iostream>
#include <cstdlib>
#include <iomanip>
+#include <map>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
using namespace MEDCoupling;
using namespace SauvUtilities;
if ( !name.empty() )
{
// cut off leading white spaces
- string::size_type firstChar = name.find_first_not_of(" \t");
+ string::size_type const firstChar = name.find_first_not_of(" \t");
if (firstChar < name.length())
{
name = name.substr(firstChar);
name = ""; // only whitespaces there - remove them
}
// cut off trailing white spaces
- string::size_type lastChar = name.find_last_not_of(" \t");
+ string::size_type const lastChar = name.find_last_not_of(" \t");
if (lastChar < name.length())
name = name.substr(0, lastChar + 1);
}
if (!healedName.empty())
{
string name = healedName;
- std::size_t len = name.length();
+ std::size_t const len = name.length();
for (std::size_t i = 0; i < len; ++i)
name[i] = (char)toupper(name[i]);
{
INFOS_MED("Save <" << theName << "> as <" << name << ">");
- map<string,int>::iterator it = nameMap.find(name);
+ auto const it = nameMap.find(name);
if (it != nameMap.end())
{
// There is already such name in the map.
// a. Replace in the map the old pair by the current one
- int old_ind = nameMap[name];
+ int const old_ind = nameMap[name];
nameMap[name] = ind;
// b. Rebuild the old pair (which was in the map,
// it seems to be built automatically by step II)
if (new_loc_index > 0)
{
// prefix
- string str = name.substr(0,5);
+ string const str = name.substr(0,5);
if (namePrefixesMap.find(str) != namePrefixesMap.end())
{
- int old_loc_index = namePrefixesMap[str];
+ int const old_loc_index = namePrefixesMap[str];
if (new_loc_index < old_loc_index) new_loc_index = old_loc_index;
}
namePrefixesMap[str] = new_loc_index;
if (len > 5) name = name.substr(0,5);
// numeric suffix
- map<string,int>::iterator name2ind = namePrefixesMap.insert( make_pair( name, 0 )).first;
+ auto const name2ind = namePrefixesMap.insert( make_pair( name, 0 )).first;
string numSuffix = SauvUtilities::toString( ++(name2ind->second) );
if ( numSuffix.size() + name.size() > 8 )
for ( int i = 0; i < fields->getNumberOfFields(); ++i )
{
MEDFileAnyTypeFieldMultiTS * fB = fields->getFieldAtPos(i);
- MEDFileFieldMultiTS * f = dynamic_cast<MEDFileFieldMultiTS *>(fB);
+ auto * f = dynamic_cast<MEDFileFieldMultiTS *>(fB);
if(!f)
continue;// fields on int32 not managed
if ( f->getMeshName() == _fileMesh->getName() )
// fill names of SubMesh'es and count nb of sauv sub-meshes they will be stored into
nbSauvObjects = 0;
map<string,int> namePrefixMap;
- for ( size_t i = 0; i < _subs.size(); ++i )
+ for (auto & sm : _subs)
{
- SubMesh& sm = _subs[i];
-
sm._nbSauvObjects = 0;
if ( sm._subs.empty() )
{
void SauvWriter::fillFamilySubMeshes()
{
- SubMesh* nilSm = (SubMesh*) 0;
- std::vector<int> dims = _fileMesh->getNonEmptyLevelsExt();
- for ( size_t iDim = 0; iDim < dims.size(); ++iDim )
+ auto* nilSm = (SubMesh*) nullptr;
+ std::vector<int> const dims = _fileMesh->getNonEmptyLevelsExt();
+ for (int const dimRelExt : dims)
{
- int dimRelExt = dims[ iDim ];
MCAuto< MEDCouplingMesh > mesh = _fileMesh->getMeshAtLevel(dimRelExt);
const DataArrayIdType * famIds = _fileMesh->getFamilyFieldAtLevel(dimRelExt);
if ( !famIds ) continue;
if ( *famID != curFamID )
{
curFamID = *famID;
- map< mcIdType, SubMesh* >::iterator f2s = _famIDs2Sub.insert( make_pair( curFamID, nilSm )).first;
+ auto const f2s = _famIDs2Sub.insert( make_pair( curFamID, nilSm )).first;
if ( !f2s->second )
f2s->second = addSubMesh( "", dimRelExt ); // no names for families
curSubMesh = f2s->second;
}
- INTERP_KERNEL::NormalizedCellType cellType =
+ INTERP_KERNEL::NormalizedCellType const cellType =
dimRelExt == 1 ? INTERP_KERNEL::NORM_POINT1 : mesh->getTypeOfCell( cellID );
curSubMesh->_cellIDsByType[ cellType ].push_back( cellID );
}
void SauvWriter::fillGroupSubMeshes()
{
const map<string, vector<string> >& grpFams = _fileMesh->getGroupInfo();
- map<string, vector<string> >::const_iterator g2ff = grpFams.begin();
+ auto g2ff = grpFams.begin();
for ( ; g2ff != grpFams.end(); ++g2ff )
{
const string& groupName = g2ff->first;
if ( famNames.empty() ) continue;
std::vector<SubMesh*> famSubMeshes( famNames.size() );
std::size_t k = 0;
- for ( size_t i = 0; i < famNames.size(); ++i )
+ for (const auto & famName : famNames)
{
- mcIdType famID = _fileMesh->getFamilyId( famNames[i].c_str() );
- map< mcIdType, SubMesh* >::iterator i2f = _famIDs2Sub.find( famID );
+ mcIdType const famID = _fileMesh->getFamilyId( famName.c_str() );
+ auto const i2f = _famIDs2Sub.find( famID );
if ( i2f != _famIDs2Sub.end() )
{
famSubMeshes[ k ] = i2f->second;
void SauvWriter::fillProfileSubMeshes()
{
_profile2Sub.clear();
- SubMesh* nilSm = (SubMesh*) 0;
+ auto* nilSm = (SubMesh*) nullptr;
for ( int isOnNodes = 0; isOnNodes < 2; ++isOnNodes )
{
vector< MCAuto< MEDFileFieldMultiTS > >
fields = isOnNodes ? _nodeFields : _cellFields;
- for ( size_t i = 0; i < fields.size(); ++i )
+ for (auto & field : fields)
{
- vector< pair<int,int> > iters = fields[i]->getIterations();
+ vector< pair<int,int> > iters = field->getIterations();
vector<INTERP_KERNEL::NormalizedCellType> types;
vector< vector<TypeOfField> > typesF;
vector< vector<string> > pfls, locs;
- fields[i]->getFieldSplitedByType( iters[0].first, iters[0].second,
+ field->getFieldSplitedByType( iters[0].first, iters[0].second,
_fileMesh->getName().c_str(), types, typesF, pfls, locs);
int dimRelExt;
for ( size_t iType = 0; iType < types.size(); ++iType )
dimRelExt = getDimension( types[iType] ) - _fileMesh->getMeshDimension();
for ( size_t iPfl = 0; iPfl < pfls[iType].size(); ++iPfl )
{
- bool isOnAll = pfls[iType][iPfl].empty();
+ bool const isOnAll = pfls[iType][iPfl].empty();
if ( isOnAll ) pfls[iType][iPfl] = noProfileName( types[iType] );
- map< string, SubMesh* >::iterator pfl2sm =
+ auto const pfl2sm =
_profile2Sub.insert( make_pair( pfls[iType][iPfl], nilSm )).first;
if ( !pfl2sm->second )
{
SubMesh* sm = pfl2sm->second = addSubMesh( "", dimRelExt ); // no names for profiles
- const DataArrayIdType * pfl = isOnAll ? 0 : fields[i]->getProfile( pfls[iType][iPfl].c_str() );
+ const DataArrayIdType * pfl = isOnAll ? nullptr : field->getProfile( pfls[iType][iPfl].c_str() );
makeProfileIDs( sm, types[iType], pfl );
}
}
int SauvWriter::evaluateNbProfileSubMeshes() const
{
std::size_t nb = 0;
- for ( std::size_t i = 0; i < _nodeFields.size(); ++i )
- nb += 1 + _nodeFields[i]->getPflsReallyUsed().size();
+ for (const auto & _nodeField : _nodeFields)
+ nb += 1 + _nodeField->getPflsReallyUsed().size();
- for ( std::size_t i = 0; i < _cellFields.size(); ++i )
+ for (const auto & _cellField : _cellFields)
{
- nb += _cellFields[i]->getPflsReallyUsed().size();
+ nb += _cellField->getPflsReallyUsed().size();
- vector< pair<int,int> > iters = _cellFields[i]->getIterations();
+ vector< pair<int,int> > iters = _cellField->getIterations();
vector<INTERP_KERNEL::NormalizedCellType> types;
vector< vector<TypeOfField> > typesF;
vector< vector<string> > pfls, locs;
- _cellFields[i]->getFieldSplitedByType( iters[0].first, iters[0].second,
+ _cellField->getFieldSplitedByType( iters[0].first, iters[0].second,
_fileMesh->getName().c_str(), types, typesF, pfls, locs);
nb += 2 * types.size(); // x 2 - a type can be on nodes and on cells at the same time
}
{
MCAuto< MEDCouplingMesh >
mesh = _fileMesh->getMeshAtLevel(sm->_dimRelExt);
- const MEDCouplingUMesh* uMesh = dynamic_cast< const MEDCouplingUMesh* > ((const MEDCouplingMesh*) mesh );
+ const auto* uMesh = dynamic_cast< const MEDCouplingUMesh* > ((const MEDCouplingMesh*) mesh );
if ( sm->_dimRelExt == 1 ) type = INTERP_KERNEL::NORM_POINT1;
vector< mcIdType >& ids = sm->_cellIDsByType[ type ];
code[1] = mesh->getNumberOfCellsWithType( type );
code[2] = -1;
}
- vector<const DataArrayIdType *> idsPerType( 1, profile );
+ vector<const DataArrayIdType *> const idsPerType( 1, profile );
MCAuto<DataArrayIdType>
resIDs = uMesh->checkTypeConsistencyAndContig( code, idsPerType );
if (( const DataArrayIdType *) resIDs )
// * 8001 FORMAT(8(1X,A8))
TFieldCounter fcount( *_sauvFile, 8 );
*_sauvFile << left;
- map<string,int>::const_iterator nameNbIt = nameNbMap.begin();
+ auto nameNbIt = nameNbMap.begin();
for ( ; nameNbIt != nameNbMap.end(); nameNbIt++, fcount++ )
*_sauvFile << " " << setw(8) << nameNbIt->first;
fcount.stop();
for ( unsigned int iSub = 0; iSub < _subs.size(); ++iSub )
{
- SubMesh& sm = _subs[iSub];
+ SubMesh const& sm = _subs[iSub];
if ( sm._nbSauvObjects < 1 ) continue;
// The first record of each sub-mesh writes
const vector<mcIdType>& cellIDs = sm._cellIDsByType[iType];
if ( cellIDs.empty() ) continue;
- INTERP_KERNEL::NormalizedCellType
+ auto
cellType = INTERP_KERNEL::NormalizedCellType( iType );
const INTERP_KERNEL::CellModel &
cell = INTERP_KERNEL::CellModel::GetCellModel( cellType );
- int castemType = SauvUtilities::med2gibiGeom( cellType );
- unsigned nbElemNodes = cell.getNumberOfNodes();
- std::size_t nbElems = cellIDs.size();
+ int const castemType = SauvUtilities::med2gibiGeom( cellType );
+ unsigned const nbElemNodes = cell.getNumberOfNodes();
+ std::size_t const nbElems = cellIDs.size();
*_sauvFile << setw(8) << castemType
<< zeroI8
void SauvWriter::writeCompoundSubMesh(int iSub)
{
- SubMesh& sm = _subs[iSub];
+ SubMesh const& sm = _subs[iSub];
if ( sm._nbSauvObjects < 1 || sm._subs.empty()) return;
vector< int > subIDs;
- for ( size_t i = 0; i < sm._subs.size(); ++i ) // loop on sub-meshes of families
- for ( int j = 0; j < sm._subs[i]->_nbSauvObjects; ++j )
- subIDs.push_back( sm._subs[i]->_id + j );
+ for (auto & _sub : sm._subs) // loop on sub-meshes of families
+ for ( int j = 0; j < _sub->_nbSauvObjects; ++j )
+ subIDs.push_back( _sub->_id + j );
*_sauvFile << zeroI8
<< setw(8) << subIDs.size()
{
for ( int j = 0; j < dim; ++j, fcount++ )
{
- double coo = coordArray->getIJ( i, j );
- bool zero = ( -precision < coo && coo < precision );
+ double const coo = coordArray->getIJ( i, j );
+ bool const zero = ( -precision < coo && coo < precision );
*_sauvFile << setw(22) << ( zero ? 0.0 : coo );
}
*_sauvFile << density;
void SauvWriter::writeLongNames()
{
- int nbTables =
+ int const nbTables =
3 - _longNames[ LN_MAIL ].empty() - _longNames[ LN_CHAM ].empty() - _longNames[ LN_COMP ].empty();
if (nbTables == 0) return;
*_sauvFile << setw(8) << longNames.size()*4 << endl; // Nb of table values
- vector<nameGIBItoMED>::iterator itGIBItoMED = longNames.begin();
+ auto itGIBItoMED = longNames.begin();
for (; itGIBItoMED != longNames.end(); itGIBItoMED++, iStr++)
{
// PILE of i-th key (med name)
for ( unsigned int iF = 0; iF < flds.size(); ++iF )
{
- string name = addName( nameNbMap, fldNamePrefixMap, flds[iF]->getName(), iF+1 );
+ string const name = addName( nameNbMap, fldNamePrefixMap, flds[iF]->getName(), iF+1 );
nameGIBItoMED aMEDName;
aMEDName.gibi_pile = isNodal ? PILE_NODES_FIELD : PILE_FIELD;
aMEDName.gibi_id = iF+1;
const vector<string>& compInfo,
map<string, string>& mapMedToGibi)
{
- for ( size_t i = 0; i < compInfo.size(); ++i )
- mapMedToGibi[compInfo[i]] = cleanName( compInfo[i] );
+ for (const auto & i : compInfo)
+ mapMedToGibi[i] = cleanName( i );
int compIndex = 1;
- map<string, string>::iterator namesIt = mapMedToGibi.begin();
+ auto namesIt = mapMedToGibi.begin();
for (; namesIt != mapMedToGibi.end(); namesIt++)
{
string & compGibiName = (*namesIt).second;
while (mapMedToGibi.count(compGibiName) > 0); // real component name could be CXXX
}
- string compMedName = fieldName + "." + namesIt->first;
+ string const compMedName = fieldName + "." + namesIt->first;
nameGIBItoMED aMEDName;
aMEDName.med_name = compMedName;
aMEDName.gibi_pile = PILE_STRINGS;
// (5) cree par muc pri
// (6)
// (7) 2
- for ( size_t iF = 0; iF < _nodeFields.size(); ++iF )
+ for (auto & _nodeField : _nodeFields)
{
// (1) write nb subcomponents, nb components(total)
- vector< pair<int,int> > iters = _nodeFields[iF]->getIterations();
- const vector<string>& compInfo = _nodeFields[iF]->getInfo();
+ vector< pair<int,int> > const iters = _nodeField->getIterations();
+ const vector<string>& compInfo = _nodeField->getInfo();
const std::size_t nbSub = iters.size();
const std::size_t nbComp = compInfo.size();
const std::size_t totalNbComp = nbSub * nbComp;
// write support, number of values and number of components
fcount.init(10);
vector< mcIdType > vals(3);
- for ( std::size_t iIt = 0; iIt < iters.size(); ++iIt )
+ for (auto it : iters)
{
- pair<int,int> it = iters[iIt];
-
vector<INTERP_KERNEL::NormalizedCellType> types;
vector< vector<TypeOfField> > typesF;
vector< vector<string> > pfls, locs;
vector< vector< std::pair<mcIdType,mcIdType> > > valsVec;
- valsVec=_nodeFields[iF]->getFieldSplitedByType( it.first, it.second, _fileMesh->getName().c_str(),
+ valsVec=_nodeField->getFieldSplitedByType( it.first, it.second, _fileMesh->getName().c_str(),
types, typesF, pfls, locs);
// believe that there can be only one type in a nodal field,
// so do not use a loop on types
if ( pfls[0][0].empty() ) pfls[0][0] = noProfileName( types[0] );
- map< string, SubMesh* >::iterator pfl2Sub = _profile2Sub.find( pfls[0][0] );
+ auto const pfl2Sub = _profile2Sub.find( pfls[0][0] );
if ( pfl2Sub == _profile2Sub.end() )
THROW_IK_EXCEPTION( "SauvWriter::writeNodalFields(): no sub-mesh for profile |"
<< pfls[0][0] << "|");
// (3) Write names of components
map<string, string> mapMedToGibi;
- makeCompNames( _nodeFields[iF]->getName(), compInfo, mapMedToGibi );
+ makeCompNames( _nodeField->getName(), compInfo, mapMedToGibi );
fcount.init(8);
*_sauvFile << left;
for ( std::size_t iIt = 0; iIt < iters.size(); ++iIt )
*_sauvFile << " " << setw(8) << 0;
fcount.stop();
- string description = _nodeFields[iF]->getName();
+ string const description = _nodeField->getName();
*_sauvFile << endl; // (5) TYPE
*_sauvFile << setw(72) << description.substr(0,71) << endl; // (6) TITRE
//*_sauvFile << endl; // (7) 0 attributes
// write values of each component
fcount.init( 3 ); // 3 values per a line
- for ( std::size_t iIt = 0; iIt < iters.size(); ++iIt )
+ for (auto it : iters)
{
- pair<int,int> it = iters[iIt];
-
vector<INTERP_KERNEL::NormalizedCellType> types;
vector< vector<TypeOfField> > typesF;
vector< vector<string> > pfls, locs;
vector< vector< std::pair<mcIdType,mcIdType> > > valsVec;
- valsVec = _nodeFields[iF]->getFieldSplitedByType( it.first, it.second, _fileMesh->getName().c_str(),
+ valsVec = _nodeField->getFieldSplitedByType( it.first, it.second, _fileMesh->getName().c_str(),
types, typesF, pfls, locs);
// believe that there can be only one type in a nodal field,
// so do not perform a loop on types
- const DataArrayDouble* valsArray = _nodeFields[iF]->getUndergroundDataArray(it.first, it.second);
+ const DataArrayDouble* valsArray = _nodeField->getUndergroundDataArray(it.first, it.second);
for ( size_t j = 0; j < compInfo.size(); ++j )
{
for ( size_t i = valsVec[0][0].first; i < (std::size_t)valsVec[0][0].second; ++i, fcount++ )
{
// count nb of sub-components
std::size_t iSub, nbSub = 0;
- vector< pair<int,int> > iters = _cellFields[iF]->getIterations();
- for ( std::size_t iIt = 0; iIt < iters.size(); ++iIt )
+ vector< pair<int,int> > const iters = _cellFields[iF]->getIterations();
+ for (auto it : iters)
{
- pair<int,int> it = iters[iIt];
-
vector<INTERP_KERNEL::NormalizedCellType> types;
vector< vector<TypeOfField> > typesF;
vector< vector<string> > pfls, locs;
vector< vector< std::pair<mcIdType,mcIdType> > > valsVec;
valsVec = _cellFields[iF]->getFieldSplitedByType( it.first, it.second, _fileMesh->getName().c_str(),
types, typesF, pfls, locs);
- for ( size_t i = 0; i < valsVec.size(); ++i )
- nbSub += valsVec[i].size();
+ for (const auto & i : valsVec)
+ nbSub += i.size();
}
// (1) write nb sub-components, title length
*_sauvFile << setw(8) << nbSub
<< setw(8) << 6 // whatever
<< setw(8) << 72 << endl; // title length
// (2) title
- string title = _cellFields[iF]->getName();
+ string const title = _cellFields[iF]->getName();
*_sauvFile << setw(72) << title.substr(0,71) << endl;
*_sauvFile << setw(72) << " " << endl;
const vector<string>& compInfo = _cellFields[iF]->getInfo();
vals[2] = ToIdType( compInfo.size() );
fcount.init(10);
- for ( std::size_t iIt = 0; iIt < iters.size(); ++iIt )
+ for (auto it : iters)
{
- pair<int,int> it = iters[iIt];
-
vector<INTERP_KERNEL::NormalizedCellType> types;
vector< vector<TypeOfField> > typesF;
vector< vector<string> > pfls, locs;
for ( size_t iP = 0; iP < pfls[iType].size(); ++iP )
{
if ( pfls[iType][iP].empty() ) pfls[iType][iP] = noProfileName( types[iType] );
- map< string, SubMesh* >::iterator pfl2Sub = _profile2Sub.find( pfls[iType][iP] );
+ auto const pfl2Sub = _profile2Sub.find( pfls[iType][iP] );
if ( pfl2Sub == _profile2Sub.end() )
THROW_IK_EXCEPTION( "SauvWriter::writeElemFields(): no sub-mesh for profile |"
<< pfls[iType][iP] << "|");
// loop on sub-components of a field, each of which refers to
// a certain support and has its own number of components
- for ( std::size_t iIt = 0; iIt < iters.size(); ++iIt )
+ for (auto it : iters)
{
- pair<int,int> it = iters[iIt];
writeElemTimeStamp( iF, it.first, it.second );
}
} // loop on cell fields
*/
//================================================================================
-void SauvWriter::writeElemTimeStamp(int iF, int iter, int order)
+void SauvWriter::writeElemTimeStamp(int iF, int iter, int order)
{
// (6) 317767 317761 317755 317815
// (7) YOUN NU H SIGY
int nbPntPerCell = 1;
if ( !locs[iType][iP].empty() )
{
- int locID = _cellFields[iF]->getLocalizationId( locs[iType][iP].c_str() );
+ int const locID = _cellFields[iF]->getLocalizationId( locs[iType][iP].c_str() );
nbPntPerCell = _cellFields[iF]->getNbOfGaussPtPerCell( locID );
}
else if ( typesF[iType][iP] == ON_GAUSS_NE )
#include "MEDLoaderDefines.hxx"
#include "MEDCouplingRefCountObject.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
+#include "NormalizedGeometricTypes"
#include "SauvUtilities.hxx"
#include "MCAuto.hxx"
#include "MCType.hxx"
+#include <cstddef>
+#include <fstream>
#include <vector>
#include <string>
#include <map>
MEDLOADER_EXPORT std::string getClassName() const override { return std::string("SauvWriter"); }
private:
SauvWriter();
- std::size_t getHeapMemorySizeWithoutChildren() const;
- std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ std::size_t getHeapMemorySizeWithoutChildren() const override;
+ std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const override;
/*!
* \brief Class representing a GIBI sub-mesh (described in the pile 1 of the SAUVE file).
* It stands for a named med sub-mesh (family, etc) and contains either cell IDs or other sub-meshes.
// Author : Anthony Geay (CEA/DEN)
#include "MEDLoaderTest.hxx"
-#include "MEDCouplingCMesh.hxx"
+#include "InterpKernelException.hxx"
+#include "MCIdType.hxx"
+#include "MEDCouplingFieldInt.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MCAuto.hxx"
#include "MEDLoader.hxx"
#include "MEDLoaderBase.hxx"
#include "MEDCouplingUMesh.hxx"
#include "MEDCouplingFieldFloat.hxx"
#include "MEDCouplingFieldInt64.hxx"
#include "MEDCouplingMemArray.hxx"
+#include "NormalizedGeometricTypes"
#include "TestInterpKernelUtils.hxx" // getResourceFile()
#include "MEDFileMesh.hxx"
#include <algorithm>
+#include <cmath>
+#include <cppunit/TestAssert.h>
+#include <functional>
+#include <math.h>
+#include <cstdint>
#include <numeric>
+#include <vector>
+#include <utility>
+#include <set>
using namespace MEDCoupling;
{
MEDCouplingFieldDouble *f1=buildVecFieldOnCells_1();
WriteField("file6.med",f1,true);
- MEDCouplingFieldDouble *f2=dynamic_cast<MEDCouplingFieldDouble *>(ReadFieldCell("file6.med",f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),0,1));
+ auto *f2=dynamic_cast<MEDCouplingFieldDouble *>(ReadFieldCell("file6.med",f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),0,1));
CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
f1->decrRef();
f2->decrRef();
WriteFieldUsingAlreadyWrittenMesh(fileName,f1_int64);
WriteFieldUsingAlreadyWrittenMesh(fileName,f1_fl);
//retrieving time steps...
- MEDCouplingFieldDouble *f2=dynamic_cast<MEDCouplingFieldDouble *>(ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),8,9));
+ auto *f2=dynamic_cast<MEDCouplingFieldDouble *>(ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),8,9));
f1->setTime(10.,8,9);
tmp[0]=VAL1;
CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
CPPUNIT_ASSERT(f1_int->isEqual(f2_int,1e-12,0)); // exact equality for int values
f2_int->decrRef();
f1_int->decrRef();
- MEDCouplingFieldInt64 *f2_int64=dynamic_cast<MEDCouplingFieldInt64 *>(ReadFieldCell(fileName,f1_int64->getMesh()->getName().c_str(),0,f1_int64->getName().c_str(),8,9));
+ auto *f2_int64=dynamic_cast<MEDCouplingFieldInt64 *>(ReadFieldCell(fileName,f1_int64->getMesh()->getName().c_str(),0,f1_int64->getName().c_str(),8,9));
CPPUNIT_ASSERT(f1_int64->isEqual(f2_int64,1e-12,0)); // exact equality for int values
f2_int64->decrRef();
f1_int64->decrRef();
- MEDCouplingFieldFloat *f2_fl=dynamic_cast<MEDCouplingFieldFloat *>(ReadFieldCell(fileName,f1_fl->getMesh()->getName().c_str(),0,f1_fl->getName().c_str(),8,9));
+ auto *f2_fl=dynamic_cast<MEDCouplingFieldFloat *>(ReadFieldCell(fileName,f1_fl->getMesh()->getName().c_str(),0,f1_fl->getName().c_str(),8,9));
CPPUNIT_ASSERT(f1_fl->isEqual(f2_fl,1e-12,1e-07f)); // float comparison
f2_fl->decrRef();
f1_fl->decrRef();
const char fileName[]="file10.med";
MEDCouplingUMesh *mesh1=build3DMesh_1();
const mcIdType part1[5]={1,2,4,13,15};
- MEDCouplingUMesh *mesh2=(MEDCouplingUMesh *)mesh1->buildPartOfMySelf(part1,part1+5,true);
+ auto *mesh2=(MEDCouplingUMesh *)mesh1->buildPartOfMySelf(part1,part1+5,true);
mesh2->setName("mesh2");
const mcIdType part2[4]={3,4,13,14};
- MEDCouplingUMesh *mesh3=(MEDCouplingUMesh *)mesh1->buildPartOfMySelf(part2,part2+4,true);
+ auto *mesh3=(MEDCouplingUMesh *)mesh1->buildPartOfMySelf(part2,part2+4,true);
mesh3->setName("mesh3");
MEDCouplingUMesh *mesh4=MEDCouplingUMesh::New();
mesh4->setName("mesh4");
MEDCouplingUMesh *mesh5=ReadUMeshFromFile(fileName,mnane);
mesh1->setName(mnane);
const mcIdType part3[18]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17};
- MEDCouplingUMesh *mesh6=(MEDCouplingUMesh *)mesh5->buildPartOfMySelf(part3,part3+18,true);
+ auto *mesh6=(MEDCouplingUMesh *)mesh5->buildPartOfMySelf(part3,part3+18,true);
mesh6->setName(mnane);
mesh5->decrRef();
CPPUNIT_ASSERT(mesh6->isEqual(mesh1,1e-12));
mesh2_2->decrRef();
//
std::vector<std::string> ret(GetMeshFamiliesNamesOnGroup(fileName,"3DToto","3DMesh_1"));
- std::set<std::string> s(ret.begin(),ret.end());
+ std::set<std::string> const s(ret.begin(),ret.end());
std::set<std::string> ref_s;
ref_s.insert("Family_-2");
ref_s.insert("Family_-3");
da->decrRef();
WriteUMesh(fileName,mesh1,true);
const mcIdType part1[5]={1,2,4,13,15};
- MEDCouplingUMesh *mesh2=(MEDCouplingUMesh *)mesh1->buildPartOfMySelf(part1,part1+5,true);
+ auto *mesh2=(MEDCouplingUMesh *)mesh1->buildPartOfMySelf(part1,part1+5,true);
mesh2->setName(mesh1->getName().c_str());// <- important for the test
//
- mcIdType nbOfCells=mesh2->getNumberOfCells();
+ mcIdType const nbOfCells=mesh2->getNumberOfCells();
CPPUNIT_ASSERT_EQUAL(ToIdType(5),nbOfCells);
MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
f1->setName("VectorFieldOnCells");
//
WriteField(fileName,f1,false);// <- false important for the test
//
- MEDCouplingFieldDouble *f2=dynamic_cast<MEDCouplingFieldDouble *>(ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,7));
+ auto *f2=dynamic_cast<MEDCouplingFieldDouble *>(ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,7));
std::vector<MEDCoupling::TypeOfField> types=GetTypesOfField(fileName,f1->getMesh()->getName().c_str(),f1->getName().c_str());
CPPUNIT_ASSERT_EQUAL(1,(int)types.size());
CPPUNIT_ASSERT(types[0]==ON_CELLS);
const char fileName[]="file19.med";
const char fileName2[]="file20.med";
MEDCouplingUMesh *m=build2DMesh_1();
- mcIdType nbOfNodes=m->getNumberOfNodes();
+ mcIdType const nbOfNodes=m->getNumberOfNodes();
WriteUMesh(fileName,m,true);
MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME);
f1->setName("VFieldOnNodes");
(const_cast<MEDCouplingMesh *>(f2->getMesh()))->setName(f1->getMesh()->getName().c_str());
WriteField(fileName,f2,false);// <- false important for the test
//
- MEDCouplingFieldDouble *f3=dynamic_cast<MEDCouplingFieldDouble *>(ReadFieldNode(fileName,f2->getMesh()->getName().c_str(),0,f2->getName().c_str(),2,7));
+ auto *f3=dynamic_cast<MEDCouplingFieldDouble *>(ReadFieldNode(fileName,f2->getMesh()->getName().c_str(),0,f2->getName().c_str(),2,7));
f3->checkConsistencyLight();
CPPUNIT_ASSERT(f3->isEqual(f2,1e-12,1e-12));
f3->decrRef();
f1->renumberNodes(renumArr);
f1->checkConsistencyLight();
WriteField(fileName,f1,false);// <- false important for the test
- MEDCouplingFieldDouble *f2=dynamic_cast<MEDCouplingFieldDouble *>(ReadFieldNode(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,7));
+ auto *f2=dynamic_cast<MEDCouplingFieldDouble *>(ReadFieldNode(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,7));
CPPUNIT_ASSERT(f2->isEqual(f1,1e-12,1e-12));
//
f2->decrRef();
const mcIdType renumber1[6]={2,1,5,0,3,4};
f1->renumberCells(renumber1,false);
WriteField(fileName,f1,true);
- MEDCouplingFieldDouble *f2=dynamic_cast<MEDCouplingFieldDouble *>((MEDCouplingField *)ReadFieldCell(fileName,mesh->getName().c_str(),0,f1->getName().c_str(),2,7));
+ auto *f2=dynamic_cast<MEDCouplingFieldDouble *>((MEDCouplingField *)ReadFieldCell(fileName,mesh->getName().c_str(),0,f1->getName().c_str(),2,7));
CPPUNIT_ASSERT(f2->isEqual(f1,1e-12,1e-12));
f2->decrRef();
//
CPPUNIT_ASSERT(fs[2]->isEqual(f_3,1e-12,1e-12));
CPPUNIT_ASSERT(mm==fs[1]->getMesh());// <- important for the test
CPPUNIT_ASSERT(mm==fs[2]->getMesh());// <- important for the test
- for(std::vector<MEDCouplingFieldDouble *>::iterator iter=fs.begin();iter!=fs.end();iter++)
- (*iter)->decrRef();
+ for(auto & f : fs)
+ f->decrRef();
//
f_1->decrRef();
f_2->decrRef();
const double vec[3]={0.,0.,1.};
std::vector<mcIdType> nodes;
m3d->findNodesOnPlane(pt,vec,1e-12,nodes);
- MEDCouplingUMesh *m2d=(MEDCouplingUMesh *)m3d->buildFacePartOfMySelfNode(&nodes[0],&nodes[0]+nodes.size(),true);
+ auto *m2d=(MEDCouplingUMesh *)m3d->buildFacePartOfMySelfNode(&nodes[0],&nodes[0]+nodes.size(),true);
const mcIdType renumber[5]={1,2,0,4,3};
m2d->renumberCells(renumber,false);
m2d->setName("ExampleOfMultiDimW");
f1->setTime(3.14,2,7);
f1->checkConsistencyLight();
WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
- MEDCouplingFieldDouble *f2=dynamic_cast<MEDCouplingFieldDouble *>((MEDCouplingField *)ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),-1,f1->getName().c_str(),2,7));
+ auto *f2=dynamic_cast<MEDCouplingFieldDouble *>((MEDCouplingField *)ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),-1,f1->getName().c_str(),2,7));
CPPUNIT_ASSERT(f2->isEqual(f1,1e-12,1e-12));
f1->decrRef();
f2->decrRef();
CPPUNIT_ASSERT_EQUAL(ON_NODES,ts[0]);
CPPUNIT_ASSERT_EQUAL(ON_CELLS,ts[1]);
//
- MEDCouplingFieldDouble *f3=dynamic_cast<MEDCouplingFieldDouble *>((MEDCouplingField *)ReadFieldNode(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,7));
+ auto *f3=dynamic_cast<MEDCouplingFieldDouble *>((MEDCouplingField *)ReadFieldNode(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,7));
CPPUNIT_ASSERT(f3->isEqual(f2,1e-12,1e-12));
f3->decrRef();
f3=dynamic_cast<MEDCouplingFieldDouble *>((MEDCouplingField *)ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,7));
using namespace std;
using namespace INTERP_KERNEL;
- string fileName= INTERP_TEST::getResourceFile("pointe.med", 3);
+ string const fileName= INTERP_TEST::getResourceFile("pointe.med", 3);
vector<string> meshNames=GetMeshNames(fileName.c_str());
CPPUNIT_ASSERT_EQUAL(1,(int)meshNames.size());
MEDCouplingUMesh *mesh=ReadUMeshFromFile(fileName.c_str(),meshNames[0].c_str(),0);
CPPUNIT_ASSERT_EQUAL(-1,its1[0].first);
CPPUNIT_ASSERT_EQUAL(-1,its1[0].second);
//
- MEDCouplingFieldDouble *field0=dynamic_cast<MEDCouplingFieldDouble *>((MEDCouplingField *)ReadFieldCell(fileName.c_str(),meshNames[0].c_str(),0,fieldsName[0].c_str(),its0[0].first,its0[0].second));
+ auto *field0=dynamic_cast<MEDCouplingFieldDouble *>((MEDCouplingField *)ReadFieldCell(fileName.c_str(),meshNames[0].c_str(),0,fieldsName[0].c_str(),its0[0].first,its0[0].second));
field0->checkConsistencyLight();
CPPUNIT_ASSERT(field0->getName()==fieldsName[0]);
CPPUNIT_ASSERT_EQUAL(1,(int)field0->getNumberOfComponents());
std::transform(field0->getArray()->getPointer(),field0->getArray()->getPointer()+16,expectedValues,diffValue,std::minus<double>());
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::max_element(diffValue,diffValue+16),1e-12);
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::min_element(diffValue,diffValue+16),1e-12);
- const MEDCouplingUMesh *constMesh=dynamic_cast<const MEDCouplingUMesh *>(field0->getMesh());
+ const auto *constMesh=dynamic_cast<const MEDCouplingUMesh *>(field0->getMesh());
CPPUNIT_ASSERT(constMesh);
CPPUNIT_ASSERT_EQUAL(3,constMesh->getSpaceDimension());
CPPUNIT_ASSERT_EQUAL(3,constMesh->getMeshDimension());
CPPUNIT_ASSERT_DOUBLES_EQUAL(46.,std::accumulate(constMesh->getCoords()->getConstPointer(),constMesh->getCoords()->getConstPointer()+57,0),1e-12);
field0->decrRef();
//
- MEDCouplingFieldDouble *field1=dynamic_cast<MEDCouplingFieldDouble *>((MEDCouplingField *)ReadFieldCell(fileName.c_str(),meshNames[0].c_str(),0,fieldsName[1].c_str(),its1[0].first,its1[0].second));
+ auto *field1=dynamic_cast<MEDCouplingFieldDouble *>((MEDCouplingField *)ReadFieldCell(fileName.c_str(),meshNames[0].c_str(),0,fieldsName[1].c_str(),its1[0].first,its1[0].second));
field1->checkConsistencyLight();
CPPUNIT_ASSERT(field1->getName()==fieldsName[1]);
CPPUNIT_ASSERT_EQUAL(3,(int)field1->getNumberOfComponents());
CPPUNIT_ASSERT_EQUAL(-1,its0Node[1].second);
CPPUNIT_ASSERT_EQUAL(2,its0Node[2].first);
CPPUNIT_ASSERT_EQUAL(-1,its0Node[2].second);
- MEDCouplingFieldDouble *field0Nodes=dynamic_cast<MEDCouplingFieldDouble *>((MEDCouplingField *)ReadFieldNode(fileName.c_str(),meshNames[0].c_str(),0,fieldsNameNode[0].c_str(),its0Node[0].first,its0Node[0].second));
+ auto *field0Nodes=dynamic_cast<MEDCouplingFieldDouble *>((MEDCouplingField *)ReadFieldNode(fileName.c_str(),meshNames[0].c_str(),0,fieldsNameNode[0].c_str(),its0Node[0].first,its0Node[0].second));
field0Nodes->checkConsistencyLight();
CPPUNIT_ASSERT(field0Nodes->getName()==fieldsNameNode[0]);
CPPUNIT_ASSERT_EQUAL(1,(int)field0Nodes->getNumberOfComponents());
using namespace std;
using namespace INTERP_KERNEL;
- string fileName=INTERP_TEST::getResourceFile("polygones.med", 3);
+ string const fileName=INTERP_TEST::getResourceFile("polygones.med", 3);
vector<string> meshNames=GetMeshNames(fileName.c_str());
CPPUNIT_ASSERT_EQUAL(1,(int)meshNames.size());
CPPUNIT_ASSERT(meshNames[0]=="Bord");
CPPUNIT_ASSERT(fieldsName[2]=="bord_:_non-ortho");
std::vector<std::pair<int,int> > its0=GetCellFieldIterations(fileName.c_str(),meshNames[0].c_str(),fieldsName[0].c_str());
CPPUNIT_ASSERT_EQUAL(1,(int)its0.size());
- MEDCouplingFieldDouble *field=dynamic_cast<MEDCouplingFieldDouble *>((MEDCouplingField *)ReadFieldCell(fileName.c_str(),meshNames[0].c_str(),0,fieldsName[0].c_str(),its0[0].first,its0[0].second));
+ auto *field=dynamic_cast<MEDCouplingFieldDouble *>((MEDCouplingField *)ReadFieldCell(fileName.c_str(),meshNames[0].c_str(),0,fieldsName[0].c_str(),its0[0].first,its0[0].second));
field->checkConsistencyLight();
CPPUNIT_ASSERT(field->getName()==fieldsName[0]);
CPPUNIT_ASSERT_EQUAL(1,(int)field->getNumberOfComponents());
CPPUNIT_ASSERT_EQUAL(538,(int)field->getNumberOfTuples());
- const MEDCouplingUMesh *constMesh=dynamic_cast<const MEDCouplingUMesh *>(field->getMesh());
+ const auto *constMesh=dynamic_cast<const MEDCouplingUMesh *>(field->getMesh());
CPPUNIT_ASSERT(constMesh);
CPPUNIT_ASSERT_EQUAL(3,constMesh->getSpaceDimension());
CPPUNIT_ASSERT_EQUAL(2,constMesh->getMeshDimension());
using namespace std;
using namespace INTERP_KERNEL;
- string fileName=INTERP_TEST::getResourceFile("poly3D.med", 3);
+ string const fileName=INTERP_TEST::getResourceFile("poly3D.med", 3);
vector<string> meshNames=GetMeshNames(fileName.c_str());
CPPUNIT_ASSERT_EQUAL(1,(int)meshNames.size());
CPPUNIT_ASSERT(meshNames[0]=="poly3D");
{
MEDCouplingUMesh *m3dsurfBase=build3DSurfMesh_1();
mcIdType numbers[5]={0,1,2,3,5};
- MEDCouplingUMesh *m3dsurf=(MEDCouplingUMesh *)m3dsurfBase->buildPartOfMySelf(numbers,numbers+5,false);
+ auto *m3dsurf=(MEDCouplingUMesh *)m3dsurfBase->buildPartOfMySelf(numbers,numbers+5,false);
m3dsurfBase->decrRef();
MEDCouplingUMesh *m1dBase=build1DMesh_1();
mcIdType numbers2[4]={0,1,2,3};
- MEDCouplingUMesh *m1d=(MEDCouplingUMesh *)m1dBase->buildPartOfMySelf(numbers2,numbers2+4,false);
+ auto *m1d=(MEDCouplingUMesh *)m1dBase->buildPartOfMySelf(numbers2,numbers2+4,false);
m1dBase->decrRef();
m1d->changeSpaceDimension(3);
const double vec[3]={0.,1.,0.};
MEDCouplingFieldDouble *MEDLoaderTest::buildVecFieldOnCells_1()
{
MEDCouplingUMesh *mesh=build3DSurfMesh_1();
- mcIdType nbOfCells=mesh->getNumberOfCells();
+ mcIdType const nbOfCells=mesh->getNumberOfCells();
MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
f1->setName("VectorFieldOnCells");
f1->setMesh(mesh);
MEDCouplingFieldInt *MEDLoaderTest::buildIntVecFieldOnCells_1()
{
MEDCouplingUMesh *mesh=build3DSurfMesh_1();
- mcIdType nbOfCells=mesh->getNumberOfCells();
+ mcIdType const nbOfCells=mesh->getNumberOfCells();
MEDCouplingFieldInt *f1=MEDCouplingFieldInt::New(ON_CELLS,ONE_TIME);
f1->setName("IntVectorFieldOnCells");
f1->setMesh(mesh);
MEDCouplingFieldInt64 *MEDLoaderTest::buildInt64VecFieldOnCells_1()
{
MEDCouplingUMesh *mesh=build3DSurfMesh_1();
- mcIdType nbOfCells=mesh->getNumberOfCells();
+ mcIdType const nbOfCells=mesh->getNumberOfCells();
MEDCouplingFieldInt64 *f1=MEDCouplingFieldInt64::New(ON_CELLS,ONE_TIME);
f1->setName("Int64VectorFieldOnCells");
f1->setMesh(mesh);
MEDCouplingFieldFloat *MEDLoaderTest::buildFloatVecFieldOnCells_1()
{
MEDCouplingUMesh *mesh=build3DSurfMesh_1();
- mcIdType nbOfCells=mesh->getNumberOfCells();
+ mcIdType const nbOfCells=mesh->getNumberOfCells();
MEDCouplingFieldFloat *f1=MEDCouplingFieldFloat::New(ON_CELLS,ONE_TIME);
f1->setName("FloatVectorFieldOnCells");
f1->setMesh(mesh);
MEDCouplingFieldDouble *MEDLoaderTest::buildVecFieldOnNodes_1()
{
MEDCouplingUMesh *mesh=build3DSurfMesh_1();
- mcIdType nbOfNodes=mesh->getNumberOfNodes();
+ mcIdType const nbOfNodes=mesh->getNumberOfNodes();
MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME);
f1->setName("VectorFieldOnNodes");
f1->setMesh(mesh);
const double gsCoo1[12]={ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b,
2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 };
const double wg1[6]={ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 };
- std::vector<double> _refCoo1(refCoo1,refCoo1+6);
+ std::vector<double> const _refCoo1(refCoo1,refCoo1+6);
std::vector<double> _gsCoo1(gsCoo1,gsCoo1+12);
std::vector<double> _wg1(wg1,wg1+6);
MEDCouplingUMesh *m=build2DMesh_2();
f->setMesh(m);
f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
const double refCoo2[12]={-1.0,1.0, -1.0,-1.0, 1.0,-1.0, -1.0,0.0, 0.0,-1.0, 0.0,0.0 };
- std::vector<double> _refCoo2(refCoo2,refCoo2+12);
+ std::vector<double> const _refCoo2(refCoo2,refCoo2+12);
std::vector<double> _gsCoo2(_gsCoo1);
std::vector<double> _wg2(_wg1);
_gsCoo2.resize(6); _wg2.resize(3);
const double refCoo3[8]={ 0.,0., 1.,0., 1.,1., 0.,1. };
- std::vector<double> _refCoo3(refCoo3,refCoo3+8);
+ std::vector<double> const _refCoo3(refCoo3,refCoo3+8);
_gsCoo1.resize(4); _wg1.resize(2);
f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_QUAD4,_refCoo3,_gsCoo1,_wg1);
f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_TRI6,_refCoo2,_gsCoo2,_wg2);
#define __MEDLOADERTEST_HXX__
#include "MEDCouplingFieldInt.hxx" // this one can not use a class forward
+#include <cppunit/TestFixture.h>
+#include "MEDCouplingTraits.hxx"
#include <cppunit/extensions/HelperMacros.h>
namespace MEDCoupling
#include "SauvLoaderTest.hxx"
+#include "MCAuto.hxx"
+#include "MCIdType.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingUMesh.hxx"
+#include "NormalizedGeometricTypes"
+#include "MEDFileMesh.hxx"
+#include "MEDFileField.hxx"
+#include "MEDFileFieldMultiTS.hxx"
+#include "MEDCouplingMesh.hxx"
#include "SauvReader.hxx"
#include "SauvWriter.hxx"
#include "MEDFileData.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "MEDCouplingMemArray.hxx"
#include "TestInterpKernelUtils.hxx" // getResourceFile()
+#include <algorithm>
+#include <cppunit/TestAssert.h>
+#include <iostream>
+#include <cstddef>
+#include <map>
+#include <stdio.h>
+#include <vector>
+#include <utility>
#ifdef WIN32
#include <windows.h>
# include <unistd.h>
#endif
-#include <vector>
#include <string>
using namespace MEDCoupling;
void SauvLoaderTest::testSauv2Med()
{
// read a file containing all types of readable piles
- std::string file = INTERP_TEST::getResourceFile("allPillesTest.sauv", 3);
+ std::string const file = INTERP_TEST::getResourceFile("allPillesTest.sauv", 3);
MCAuto<SauvReader> sr=SauvReader::New(file.c_str());
MCAuto<MEDFileData> d2=sr->loadInMEDFileDS();
// write MED
// read SAUV and check groups
MCAuto<SauvReader> sr=SauvReader::New(sauvFile);
MCAuto<MEDFileData> d2=sr->loadInMEDFileDS();
- MEDFileUMesh* m2 = static_cast<MEDFileUMesh*>( d2->getMeshes()->getMeshAtPos(0) );
+ auto* m2 = static_cast<MEDFileUMesh*>( d2->getMeshes()->getMeshAtPos(0) );
MCAuto<MEDCouplingUMesh> group1 = m2->getGroup(0, "Group1");
CPPUNIT_ASSERT_EQUAL(1,(int)group1->getNumberOfCells());
MCAuto<MEDCouplingUMesh> group2 = m2->getGroup(0, "Group2");
void SauvLoaderTest::testSauv2MedOnA3SubsField()
{
// read SAUV
- std::string sauvFile = INTERP_TEST::getResourceFile("portico_3subs.sauv", 3);
+ std::string const sauvFile = INTERP_TEST::getResourceFile("portico_3subs.sauv", 3);
MCAuto<SauvReader> sr=SauvReader::New(sauvFile.c_str());
MCAuto<MEDFileData> d2=sr->loadInMEDFileDS();
// check mesh
- MEDFileUMesh* m2 = static_cast<MEDFileUMesh*>(d2->getMeshes()->getMeshAtPos(0));
+ auto* m2 = static_cast<MEDFileUMesh*>(d2->getMeshes()->getMeshAtPos(0));
MCAuto<MEDCouplingUMesh> mesh1d = m2->getMeshAtLevel(0);
- MCAuto<MEDCouplingFieldDouble> length1dField = mesh1d->getMeasureField(0);
+ MCAuto<MEDCouplingFieldDouble> length1dField = mesh1d->getMeasureField(false);
std::cout << "Length of 1d elements: " << length1dField->accumulate(0) << std::endl;
CPPUNIT_ASSERT_DOUBLES_EQUAL(3, length1dField->accumulate(0), 1e-12);
// check field
// Check first component of the field
// 2 gauss points per element => 12 values
- double values[12] = {
+ double const values[12] = {
-7.687500000000e-03,
-7.687500000000e-03,
-4.562500000000e-03,
void SauvLoaderTest::testMed2Sauv()
{
// read pointe.med
- std::string file = INTERP_TEST::getResourceFile("pointe.med", 3);
+ std::string const file = INTERP_TEST::getResourceFile("pointe.med", 3);
MCAuto<MEDFileData> pointeMed=MEDFileData::New(file.c_str());
// add 3 faces to pointeMed
- MEDFileUMesh* pointeMedMesh = static_cast<MEDFileUMesh*>(pointeMed->getMeshes()->getMeshAtPos(0));
+ auto* pointeMedMesh = static_cast<MEDFileUMesh*>(pointeMed->getMeshes()->getMeshAtPos(0));
MCAuto<MEDCouplingUMesh> pointeM1D = MEDCouplingUMesh::New();
DataArrayDouble *coords = pointeMedMesh->getCoords();
pointeM1D->setCoords( coords );
MCAuto<MEDFileData> d2=sr->loadInMEDFileDS();
CPPUNIT_ASSERT_EQUAL(1,d2->getNumberOfMeshes());
CPPUNIT_ASSERT_EQUAL(4,d2->getNumberOfFields());
- MEDFileUMesh * m = static_cast<MEDFileUMesh*>( d2->getMeshes()->getMeshAtPos(0) );
+ auto * m = static_cast<MEDFileUMesh*>( d2->getMeshes()->getMeshAtPos(0) );
CPPUNIT_ASSERT_EQUAL(std::string("maa1"),std::string(m->getName() ));
CPPUNIT_ASSERT_EQUAL(3,m->getMeshDimension());
std::vector<std::string > groups = m->getGroupsNames();
DataArrayDouble *coo = m->getCoords();
DataArrayDouble *pointeCoo = pointeMedMesh->getCoords();
CPPUNIT_ASSERT(coo->isEqualWithoutConsideringStr(*pointeCoo,1e-12));
- MCAuto<MEDCouplingFieldDouble> vol = um0->getMeasureField(0);
- MCAuto<MEDCouplingFieldDouble> pointeVol = pointeUM0->getMeasureField(0);
+ MCAuto<MEDCouplingFieldDouble> vol = um0->getMeasureField(false);
+ MCAuto<MEDCouplingFieldDouble> pointeVol = pointeUM0->getMeasureField(false);
CPPUNIT_ASSERT_DOUBLES_EQUAL( vol->accumulate(0), pointeVol->accumulate(0),1e-12);
// check fields
// fieldnodedouble
void SauvLoaderTest::testCellsWithLingNames()
{
// test IMP 3285: [CEA 1778] SauvReader: only keep the meshes named in the table MED_MAIL
- std::string file = INTERP_TEST::getResourceFile("test_MED_MAIL.sauv", 3);
+ std::string const file = INTERP_TEST::getResourceFile("test_MED_MAIL.sauv", 3);
MCAuto<SauvReader> sr=SauvReader::New(file.c_str());
MCAuto<MEDFileData> d2=sr->loadInMEDFileDS();
// check that the mesh contains
// - Nombre de mailles de type MED_QUAD4 : 43
// - Nombre de mailles de type MED_HEXA8 : 24
// - Nombre de mailles de type MED_PENTA6 : 3
- MEDFileUMesh* m = static_cast<MEDFileUMesh*>( d2->getMeshes()->getMeshAtPos(0));
+ auto* m = static_cast<MEDFileUMesh*>( d2->getMeshes()->getMeshAtPos(0));
CPPUNIT_ASSERT_EQUAL(ToIdType(6), m->getNumberOfCellsWithType( INTERP_KERNEL::NORM_TRI3 ));
CPPUNIT_ASSERT_EQUAL(ToIdType(43), m->getNumberOfCellsWithType( INTERP_KERNEL::NORM_QUAD4 ));
CPPUNIT_ASSERT_EQUAL(ToIdType(24), m->getNumberOfCellsWithType( INTERP_KERNEL::NORM_HEXA8 ));
#else
const char* fileToRemove[nbFilesToRemove] = { "allPillesTest.med", "pointe.sauv", "mesh_with_void_family.sauv" };
#endif
- for ( int i = 0; i < nbFilesToRemove; ++i )
+ for (auto & i : fileToRemove)
{
#ifdef WIN32
if (GetFileAttributes(fileToRemove[i]) != INVALID_FILE_ATTRIBUTES)
#else
- if (access(fileToRemove[i], F_OK) == 0)
+ if (access(i, F_OK) == 0)
#endif
#if defined(WIN32) && defined(UNICODE)
_wremove(fileToRemove[i]);
#else
- remove(fileToRemove[i]);
+ remove(i);
#endif
}
}
#ifndef __SauvLoaderTest_HXX__
#define __SauvLoaderTest_HXX__
+#include <cppunit/TestFixture.h>
#include <cppunit/extensions/HelperMacros.h>
-#include "MEDLoaderTest.hxx"
namespace MEDCoupling
{
void testCellsWithLingNames();
public:
- void tearDown();
+ void tearDown() override;
};
}
//
// Author : Anthony Geay (CEA/DEN)
-#include "CppUnitTest.hxx"
#include "MEDLoaderTest.hxx"
#include "CrackAlgoTest.hxx"
+#include <cppunit/extensions/HelperMacros.h>
CPPUNIT_TEST_SUITE_REGISTRATION( MEDCoupling::MEDLoaderTest );
CPPUNIT_TEST_SUITE_REGISTRATION( MEDCoupling::CrackAlgoTest );
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-#include "CppUnitTest.hxx"
#include "SauvLoaderTest.hxx"
+#include <cppunit/extensions/HelperMacros.h>
CPPUNIT_TEST_SUITE_REGISTRATION( MEDCoupling::SauvLoaderTest );
-#include "BasicMainTest.hxx"
// see MeshGems/Docs/meshgems_formats_description.pdf
extern const char* GmfKwdFmt[ GmfMaxKwd + 1 ][4];
// occ/24009
+#include <cstdio>
#include "MEDLoaderDefines.hxx"
/*----------------------------------------------------------*/
/* Structures */
#include "MEDPARTITIONER_ConnectZone.hxx"
+#include "MCIdType.hxx"
+#include "MCAuto.hxx"
+#include "MCType.hxx"
#include "MEDCouplingSkyLineArray.hxx"
#include <map>
+#include <utility>
+#include <vector>
using namespace MEDCoupling;
,_description("")
,_local_domain_number(0)
,_distant_domain_number(0)
- ,_local_mesh(0)
- ,_distant_mesh(0)
- ,_node_corresp(0)
- ,_face_corresp(0)
+ ,_local_mesh(nullptr)
+ ,_distant_mesh(nullptr)
+ ,_node_corresp(nullptr)
+ ,_face_corresp(nullptr)
{
}
MEDPARTITIONER::ConnectZone::~ConnectZone()
{
- for(std::map < std::pair <mcIdType, mcIdType>,MEDCouplingSkyLineArray * >::iterator iter=_entity_corresp.begin(); iter!=_entity_corresp.end();iter++)
+ for(auto & iter : _entity_corresp)
{
- iter->second->decrRef();
+ iter.second->decrRef();
}
}
,_description(myConnectZone._description)
,_local_domain_number(myConnectZone._local_domain_number)
,_distant_domain_number(myConnectZone._distant_domain_number)
- ,_local_mesh(0)
- ,_distant_mesh(0)
+ ,_local_mesh(nullptr)
+ ,_distant_mesh(nullptr)
,_node_corresp(myConnectZone._node_corresp)
,_face_corresp(myConnectZone._face_corresp)
,_entity_corresp(myConnectZone._entity_corresp)
bool MEDPARTITIONER::ConnectZone::isEntityCorrespPresent(mcIdType localEntity, mcIdType distantEntity) const
{
typedef std::map<std::pair<mcIdType,mcIdType>, MEDCouplingSkyLineArray*>::const_iterator map_iter;
- for(map_iter iter=_entity_corresp.begin(); iter != _entity_corresp.end(); iter++)
+ for(const auto & iter : _entity_corresp)
{
- if ((iter->first).first==localEntity && (iter->first).second==distantEntity)
+ if ((iter.first).first==localEntity && (iter.first).second==distantEntity)
return true;
}
return false;
{
typedef std::map<std::pair<mcIdType,mcIdType>, MEDCouplingSkyLineArray*>::const_iterator map_iter;
- for(map_iter iter=_entity_corresp.begin();iter!=_entity_corresp.end();iter++)
+ for(const auto & iter : _entity_corresp)
{
- if ((iter->first).first==localEntity && (iter->first).second==distantEntity)
- return iter->second->getIndex();
+ if ((iter.first).first==localEntity && (iter.first).second==distantEntity)
+ return iter.second->getIndex();
}
- return 0;
+ return nullptr;
}
const mcIdType *MEDPARTITIONER::ConnectZone::getEntityCorrespValue(mcIdType localEntity,
{
typedef std::map<std::pair<mcIdType,mcIdType>, MEDCouplingSkyLineArray*>::const_iterator map_iter;
- for (map_iter iter=_entity_corresp.begin();iter!=_entity_corresp.end();iter++)
+ for (const auto & iter : _entity_corresp)
{
- if ((iter->first).first==localEntity && (iter->first).second==distantEntity)
- return iter->second->getValues();
+ if ((iter.first).first==localEntity && (iter.first).second==distantEntity)
+ return iter.second->getValues();
}
- return 0;
+ return nullptr;
}
mcIdType MEDPARTITIONER::ConnectZone::getEntityCorrespNumber(mcIdType localEntity,
{
typedef std::map<std::pair<mcIdType,mcIdType>, MEDCouplingSkyLineArray*>::const_iterator map_iter;
- for(map_iter iter=_entity_corresp.begin();iter!=_entity_corresp.end();iter++)
+ for(const auto & iter : _entity_corresp)
{
- if((iter->first).first==localEntity && (iter->first).second==distantEntity)
- return iter->second->getNumberOf();
+ if((iter.first).first==localEntity && (iter.first).second==distantEntity)
+ return iter.second->getNumberOf();
}
return 0;
}
{
typedef std::map<std::pair<mcIdType,mcIdType>, MEDCouplingSkyLineArray*>::const_iterator map_iter;
- for (map_iter iter=_entity_corresp.begin(); iter != _entity_corresp.end(); iter++)
+ for (const auto & iter : _entity_corresp)
{
- if ((iter->first).first==localEntity && (iter->first).second==distantEntity)
- return iter->second->getLength();
+ if ((iter.first).first==localEntity && (iter.first).second==distantEntity)
+ return iter.second->getLength();
}
return 0;
}
{
typedef std::map<std::pair<mcIdType,mcIdType>, MEDCouplingSkyLineArray*>::const_iterator map_iter;
- for (map_iter iter=_entity_corresp.begin(); iter != _entity_corresp.end(); iter++)
+ for (const auto & iter : _entity_corresp)
{
- if ((iter->first).first==localEntity && (iter->first).second==distantEntity)
- return iter->second;
+ if ((iter.first).first==localEntity && (iter.first).second==distantEntity)
+ return iter.second;
}
- return 0;
+ return nullptr;
}
std::vector< std::pair< mcIdType,mcIdType > > MEDPARTITIONER::ConnectZone::getEntities() const
{
std::vector< std::pair< mcIdType,mcIdType > > types;
- std::map<std::pair<mcIdType,mcIdType>, MEDCouplingSkyLineArray*>::const_iterator
+ auto
iter = _entity_corresp.begin();
for ( ; iter != _entity_corresp.end(); iter++)
{
void MEDPARTITIONER::ConnectZone::setNodeCorresp(MEDCouplingSkyLineArray* array)
{
- MCAuto<MEDCouplingSkyLineArray> arr(array);
+ MCAuto<MEDCouplingSkyLineArray> const arr(array);
_node_corresp = arr;
}
void MEDPARTITIONER::ConnectZone::setFaceCorresp(MEDCouplingSkyLineArray* array)
{
- MCAuto<MEDCouplingSkyLineArray> arr (array);
+ MCAuto<MEDCouplingSkyLineArray> const arr (array);
_face_corresp = arr;
}
void MEDPARTITIONER::ConnectZone::setEntityCorresp(mcIdType localEntity, mcIdType distantEntity,
MEDCouplingSkyLineArray *array)
{
- MEDCouplingSkyLineArray * nullArray = 0;
+ MEDCouplingSkyLineArray * nullArray = nullptr;
std::map < std::pair <mcIdType,mcIdType>, MEDCouplingSkyLineArray * >::iterator it;
it = _entity_corresp.insert
( std::make_pair( std::make_pair(localEntity,distantEntity), nullArray )).first;
#ifndef __MEDPARTITIONER_CONNECTZONE_HXX__
#define __MEDPARTITIONER_CONNECTZONE_HXX__
+#include "MCIdType.hxx"
#include "MEDPARTITIONER.hxx"
#include "MCAuto.hxx"
-#include "MCType.hxx"
+#include <utility>
namespace MEDCoupling
{
#include "MEDPARTITIONER_Graph.hxx"
+#include "MCIdType.hxx"
+#include "MCType.hxx"
#include "MEDCouplingSkyLineArray.hxx"
#include <set>
namespace MEDPARTITIONER
{
Graph::Graph():
- _graph(0),_partition(0),
- _edge_weight(0),_cell_weight(0)
+ _graph(nullptr),_partition(nullptr),
+ _edge_weight(nullptr),_cell_weight(nullptr)
{
}
Graph::Graph(MEDCoupling::MEDCouplingSkyLineArray *array, int *edgeweight):
- _graph(array),_partition(0),
- _edge_weight(edgeweight),_cell_weight(0)
+ _graph(array),_partition(nullptr),
+ _edge_weight(edgeweight),_cell_weight(nullptr)
{
}
Graph::~Graph()
- {
- }
+ = default;
int Graph::nbDomains() const
{
if ( _partition.isNotNull() )
if ( MEDCoupling::DataArrayIdType* array = _partition->getValuesArray() )
{
- for ( const mcIdType * dom = array->begin(); dom != array->end(); ++dom )
- domains.insert( *dom );
+ for (long const dom : *array)
+ domains.insert( dom );
}
return (int)domains.size();
}
#ifndef __MEDPARTITIONER_GRAPH_HXX__
#define __MEDPARTITIONER_GRAPH_HXX__
+#include "MCIdType.hxx"
#include "MEDPARTITIONER.hxx"
#include "MCAuto.hxx"
-#include "MCType.hxx"
#include <string>
class MEDPARTITIONER_EXPORT Graph
{
public:
- typedef enum {METIS,SCOTCH,PTSCOTCH} splitter_type;
+ using splitter_type = enum {METIS,SCOTCH,PTSCOTCH};
Graph();
//creates a graph from a SKYLINEARRAY- WARNING!! Graph takes ownership of the array.
- Graph(MEDCouplingSkyLineArray* graph, int* edgeweight=0);
+ Graph(MEDCouplingSkyLineArray* graph, int* edgeweight=nullptr);
virtual ~Graph();
void setEdgesWeights(int *edgeweight) { _edge_weight=edgeweight; }
void setVerticesWeights(int *cellweight) { _cell_weight=cellweight; }
//computes partitioning of the graph
- virtual void partGraph(int ndomain, const std::string& options_string="", ParaDomainSelector *sel=0) = 0;
+ virtual void partGraph(int ndomain, const std::string& options_string="", ParaDomainSelector *sel=nullptr) = 0;
//returns the partitioning
const mcIdType *getPart() const;
//
#include "MEDPARTITIONER_JointFinder.hxx"
+
+#include <algorithm>
+#include <cstddef>
+#include <iostream>
+#include <utility>
+#include <map>
+#include <vector>
+
+#include "MCType.hxx"
+#include "MCIdType.hxx"
#include "MEDPARTITIONER_MeshCollection.hxx"
#include "MEDPARTITIONER_Topology.hxx"
#include "MEDPARTITIONER_ParaDomainSelector.hxx"
#include "MEDPARTITIONER_Utils.hxx"
#include "MEDCouplingUMesh.hxx"
-#include "BBTree.txx"
/*!
* Method contributing to the distant cell graph
}
MEDPARTITIONER::JointFinder::~JointFinder()
-{
-}
+= default;
void MEDPARTITIONER::JointFinder::findCommonDistantNodes()
{
- int nbdomain=_topology->nbDomain();
+ int const nbdomain=_topology->nbDomain();
_distant_node_cell.resize(nbdomain);
_node_node.resize(nbdomain);
for (int i=0; i<nbdomain; i++)
_distant_node_cell[i].resize(nbdomain);
_node_node[i].resize(nbdomain);
}
- int nbproc=_domain_selector->nbProcs();
- std::vector<BBTreeOfDim* > bbtree(nbdomain,(BBTreeOfDim*) 0);
- std::vector<double* > bbxi(nbdomain,(double*) 0);
- std::vector<MEDCoupling::DataArrayIdType*> rev(nbdomain,(MEDCoupling::DataArrayIdType*) 0);
- std::vector<MEDCoupling::DataArrayIdType*> revIndx(nbdomain,(MEDCoupling::DataArrayIdType*) 0);
+ int const nbproc=_domain_selector->nbProcs();
+ std::vector<BBTreeOfDim* > bbtree(nbdomain,(BBTreeOfDim*) nullptr);
+ std::vector<double* > bbxi(nbdomain,(double*) nullptr);
+ std::vector<MEDCoupling::DataArrayIdType*> rev(nbdomain,(MEDCoupling::DataArrayIdType*) nullptr);
+ std::vector<MEDCoupling::DataArrayIdType*> revIndx(nbdomain,(MEDCoupling::DataArrayIdType*) nullptr);
//int meshDim=-1;
int spaceDim=-1;
rev[mydomain] = MEDCoupling::DataArrayIdType::New();
revIndx[mydomain] = MEDCoupling::DataArrayIdType::New();
myMesh->getReverseNodalConnectivity(rev[mydomain],revIndx[mydomain]);
- double* bbx=new double[2*spaceDim*myMesh->getNumberOfNodes()];
+ auto* bbx=new double[2*spaceDim*myMesh->getNumberOfNodes()];
for (int i=0; i<myMesh->getNumberOfNodes()*spaceDim; i++)
{
const double* coords=myMesh->getCoords()->getConstPointer();
bbx[2*i]=(coords[i])-1e-12;
bbx[2*i+1]=bbx[2*i]+2e-12;
}
- bbtree[mydomain]=new BBTreeOfDim( spaceDim, bbx,0,0,myMesh->getNumberOfNodes(),-1e-12);
+ bbtree[mydomain]=new BBTreeOfDim( spaceDim, bbx,nullptr,0,myMesh->getNumberOfNodes(),-1e-12);
//keep bbx because need it in getIntersectingElems
//no delete [] bbx yet
bbxi[mydomain]=bbx;
if (_domain_selector->isMyDomain(isource))
{
//preparing data for treatment on target proc
- int targetProc = _domain_selector->getProcessorID(itarget);
+ int const targetProc = _domain_selector->getProcessorID(itarget);
std::vector<double> vec(spaceDim*sourceMesh->getNumberOfNodes());
std::copy(sourceMesh->getCoords()->getConstPointer(),sourceMesh->getCoords()->getConstPointer()+sourceMesh->getNumberOfNodes()*spaceDim,&vec[0]);
if (_domain_selector->isMyDomain(itarget))
{
//receiving data from source proc
- int sourceProc = isource%nbproc;
+ int const sourceProc = isource%nbproc;
std::vector<double> recvVec;
RecvDoubleVec(recvVec,sourceProc);
std::map<mcIdType,mcIdType> commonNodes; // (local nodes, distant nodes) list
for (mcIdType inode=0; inode<ToIdType(recvVec.size()/spaceDim); inode++)
{
- double* bbox=new double[2*spaceDim];
+ auto* bbox=new double[2*spaceDim];
for (int i=0; i<spaceDim; i++)
{
bbox[2*i]=recvVec[inode*spaceDim+i]-1e-12;
}
std::vector<mcIdType> nodeCellCorrespondency;
- for (std::map<mcIdType,mcIdType>::iterator iter=commonNodes.begin(); iter!=commonNodes.end(); iter++)
+ for (auto & commonNode : commonNodes)
{
- _node_node[itarget][isource].push_back(std::make_pair(iter->first, iter->second));//storing node pairs in a vector
+ _node_node[itarget][isource].push_back(std::make_pair(commonNode.first, commonNode.second));//storing node pairs in a vector
const mcIdType* revIndxPtr=revIndx[itarget]->getConstPointer();
const mcIdType* revPtr=rev[itarget]->getConstPointer();
- for (mcIdType icell=revIndxPtr[iter->first]; icell<revIndxPtr[iter->first+1]; icell++)
+ for (mcIdType icell=revIndxPtr[commonNode.first]; icell<revIndxPtr[commonNode.first+1]; icell++)
{
- nodeCellCorrespondency.push_back(iter->second); //
- mcIdType globalCell=_topology->convertCellToGlobal(itarget,revPtr[icell]);
+ nodeCellCorrespondency.push_back(commonNode.second); //
+ mcIdType const globalCell=_topology->convertCellToGlobal(itarget,revPtr[icell]);
nodeCellCorrespondency.push_back(globalCell);
}
}
//free rev(nbdomain) revIndx(nbdomain) bbtree(nbdomain) bbxi(nbdomain)
for (int i=0; i<nbdomain; i++)
{
- if (rev[i]!=0)
+ if (rev[i]!=nullptr)
rev[i]->decrRef();
- if (revIndx[i]!=0)
+ if (revIndx[i]!=nullptr)
revIndx[i]->decrRef();
- if (bbtree[i]!=0)
+ if (bbtree[i]!=nullptr)
delete bbtree[i];
- if (bbxi[i]!=0)
+ if (bbxi[i]!=nullptr)
delete [] bbxi[i];
}
void MEDPARTITIONER::JointFinder::print()
//it is for debug on small arrays under mpi 2,3 cpus
{
- int nbdomain=_topology->nbDomain();
+ int const nbdomain=_topology->nbDomain();
//MPI_Barrier(MPI_COMM_WORLD);
if (MyGlobals::_Is0verbose>0)
std::cout << "\nJointFinder print node-node (nn)iproc|itarget|isource|i|inodefirst-inodesecond\n\n" <<
#ifndef __MEDPARTITIONER_JOINTFINDER_HXX__
#define __MEDPARTITIONER_JOINTFINDER_HXX__
+#include "MCIdType.hxx"
#include "MEDPARTITIONER.hxx"
-#include "MCType.hxx"
#include <map>
+#include <utility>
#include <vector>
namespace MEDPARTITIONER
//
#include "MEDPARTITIONER_MEDPartitioner.hxx"
+#include "MCType.hxx"
+#include "MCAuto.hxx"
#include "MEDPARTITIONER_MeshCollection.hxx"
#include "MEDPARTITIONER_Topology.hxx"
#include "MEDPARTITIONER_ParaDomainSelector.hxx"
#include "MEDPARTITIONER_ParallelTopology.hxx"
#include "MEDPARTITIONER_Utils.hxx"
#include "MEDPARTITIONER_Graph.hxx"
+#include <string>
#ifdef MED_ENABLE_METIS
# include "MEDPARTITIONER_MetisGraph.hxx"
#endif
#include "MEDCouplingUMesh.hxx"
#include "MEDCouplingSkyLineArray.hxx"
-#include <iostream>
#include <vector>
const char MEDPARTITIONER::MEDPartitioner::METIS_PART_ALG[]="Metis";
const char MEDPARTITIONER::MEDPartitioner::PTSCOTCH_PART_ALG[]="PTScotch";
MEDPARTITIONER::MEDPartitioner::MEDPartitioner(const std::string& filename, int ndomains, const std::string& library,bool create_boundary_faces, bool create_joints, bool mesure_memory):
- _input_collection( 0 ), _output_collection( 0 ), _new_topology( 0 )
+ _input_collection( nullptr ), _output_collection( nullptr ), _new_topology( nullptr )
{
MyGlobals::_World_Size = 1;
MyGlobals::_Rank = 0;
_input_collection=new MeshCollection(filename,parallelizer);
_input_collection->setParaDomainSelector( ¶llelizer );
- MEDPARTITIONER::ParallelTopology* aPT =
+ auto* aPT =
(MEDPARTITIONER::ParallelTopology*) _input_collection->getTopology();
aPT->setGlobalNumerotationDefault( _input_collection->getParaDomainSelector() );
_input_collection->prepareFieldDescriptions();
}
MEDPARTITIONER::MEDPartitioner::MEDPartitioner(const MEDCoupling::MEDFileData* filedata, int ndomains, const std::string& library,bool create_boundary_faces, bool create_joints, bool mesure_memory):
- _input_collection( 0 ), _output_collection( 0 ), _new_topology( 0 )
+ _input_collection( nullptr ), _output_collection( nullptr ), _new_topology( nullptr )
{
MyGlobals::_World_Size = 1;
MyGlobals::_Rank = 0;
_input_collection->setParaDomainSelector( ¶llelizer );
_input_collection->retrieveDriver()->readMEDFileData(filedata);
- MEDPARTITIONER::ParallelTopology* aPT =
+ auto* aPT =
(MEDPARTITIONER::ParallelTopology*) _input_collection->getTopology();
aPT->setGlobalNumerotationDefault( _input_collection->getParaDomainSelector() );
_input_collection->prepareFieldDescriptions();
}
MEDPARTITIONER::MEDPartitioner::MEDPartitioner(const MEDCoupling::MEDFileData* filedata, MEDPARTITIONER ::Graph* graph, bool create_boundary_faces, bool create_joints, bool mesure_memory):
- _input_collection( 0 ), _output_collection( 0 ), _new_topology( 0 )
+ _input_collection( nullptr ), _output_collection( nullptr ), _new_topology( nullptr )
{
MyGlobals::_World_Size = 1;
MyGlobals::_Rank = 0;
_input_collection->setParaDomainSelector( ¶llelizer );
_input_collection->retrieveDriver()->readMEDFileData(filedata);
- MEDPARTITIONER::ParallelTopology* aPT =
+ auto* aPT =
(MEDPARTITIONER::ParallelTopology*) _input_collection->getTopology();
aPT->setGlobalNumerotationDefault( _input_collection->getParaDomainSelector() );
_input_collection->prepareFieldDescriptions();
MEDPARTITIONER::MEDPartitioner::~MEDPartitioner()
{
- delete _input_collection; _input_collection = 0;
- delete _output_collection; _output_collection = 0;
- delete _new_topology; _new_topology = 0;
+ delete _input_collection; _input_collection = nullptr;
+ delete _output_collection; _output_collection = nullptr;
+ delete _new_topology; _new_topology = nullptr;
}
-void MEDPARTITIONER::MEDPartitioner::createPartitionCollection(int ndomains, const std::string& library,bool create_boundary_faces, bool create_joints, bool mesure_memory)
+void MEDPARTITIONER::MEDPartitioner::createPartitionCollection(int ndomains, const std::string& library,bool /*create_boundary_faces*/, bool /*create_joints*/, bool /*mesure_memory*/)
{
//ParallelTopology* aPT = (ParallelTopology*) _input_collection->getTopology();
if (library == "metis")
MEDPARTITIONER::Graph* MEDPARTITIONER::MEDPartitioner::Graph(MEDCoupling::MEDCouplingSkyLineArray* graph, Graph::splitter_type split, int* edgeweight, DataArrayIdType *vlbloctab)
{
- MEDPARTITIONER::Graph* cellGraph=0;
+ MEDPARTITIONER::Graph* cellGraph=nullptr;
// will be destroyed by XXXGraph class:
MEDCoupling::MCAuto<MEDCoupling::MEDCouplingSkyLineArray> arr(MEDCoupling::MEDCouplingSkyLineArray::New(graph->getIndexArray(), graph->getValuesArray()));
switch (split)
#include "MEDPARTITIONER_Graph.hxx"
#include "MCType.hxx"
-#include <map>
+#include <string>
#include <vector>
namespace MEDCoupling
MEDPartitioner(const std::string& filename, int ndomains=1, const std::string& library="metis",bool create_boundary_faces=false, bool create_joints=false, bool mesure_memory=false);
MEDPartitioner(const MEDCoupling::MEDFileData* fileData, int ndomains=1, const std::string& library="metis",bool create_boundary_faces=false, bool create_joints=false, bool mesure_memory=false);
MEDPartitioner(const MEDCoupling::MEDFileData* fileData, Graph* graph, bool create_boundary_faces=false, bool create_joints=false, bool mesure_memory=false);
- static MEDPARTITIONER::Graph* Graph(MEDCoupling::MEDCouplingSkyLineArray* graph, Graph::splitter_type split=Graph::METIS, int* edgeweight=0, DataArrayIdType* vlbloctab=0);
+ static MEDPARTITIONER::Graph* Graph(MEDCoupling::MEDCouplingSkyLineArray* graph, Graph::splitter_type split=Graph::METIS, int* edgeweight=nullptr, DataArrayIdType* vlbloctab=nullptr);
static std::vector<std::string> AvailableAlgorithms();
static std::vector<std::string> AllAlgorithms();
static bool HasMetisAlg();
#include "MEDPARTITIONER_MeshCollection.hxx"
+#include "MCType.hxx"
+#include "MCIdType.hxx"
#include "MEDPARTITIONER_ConnectZone.hxx"
#include "MEDPARTITIONER_Graph.hxx"
#include "MEDPARTITIONER_MeshCollectionDriver.hxx"
#include "MEDPARTITIONER_Topology.hxx"
#include "MEDPARTITIONER_UserGraph.hxx"
#include "MEDPARTITIONER_Utils.hxx"
+#include <cstddef>
+#include "NormalizedGeometricTypes"
+#include <sstream>
#ifdef HAVE_MPI
#include "MEDPARTITIONER_JointFinder.hxx"
#include "MCAuto.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "MEDCouplingMemArray.hxx"
-#include "MEDCouplingNormalizedUnstructuredMesh.hxx"
#include "MEDCouplingSkyLineArray.hxx"
#include "MEDCouplingUMesh.hxx"
#include "MEDLoader.hxx"
#include "MEDPARTITIONER_ScotchGraph.hxx"
#endif
-#include <set>
#include <vector>
#include <string>
-#include <limits>
#include <iostream>
#include <fstream>
MEDPARTITIONER::MeshCollection::MeshCollection()
- : _topology(0),
+ : _topology(nullptr),
_owns_topology(false),
- _driver(0),
- _domain_selector( 0 ),
+ _driver(nullptr),
+ _domain_selector( nullptr ),
_i_non_empty_mesh(-1),
_driver_type(MEDPARTITIONER::MedXml),
_subdomain_boundary_creates( MyGlobals::_Create_Boundary_Faces ),
_family_splitting(false),
_create_empty_groups(false),
- _joint_finder(0)
+ _joint_finder(nullptr)
{
}
bool create_empty_groups)
: _topology(topology),
_owns_topology(false),
- _driver(0),
+ _driver(nullptr),
_domain_selector( initialCollection._domain_selector ),
_i_non_empty_mesh(-1),
_name(initialCollection._name),
_subdomain_boundary_creates(MyGlobals::_Create_Boundary_Faces),
_family_splitting(family_splitting),
_create_empty_groups(create_empty_groups),
- _joint_finder(0)
+ _joint_finder(nullptr)
{
std::vector<std::vector<std::vector<mcIdType> > > new2oldIds(initialCollection.getTopology()->nbDomain());
std::vector<MEDCoupling::DataArrayIdType*> o2nRenumber;
{
if (MyGlobals::_Verbose>10)
std::cout << "proc " << MyGlobals::_Rank << " : castCellMeshes" << std::endl;
- if (_topology==0)
+ if (_topology==nullptr)
throw INTERP_KERNEL::Exception("Topology has not been defined on call to castCellMeshes");
int nbNewDomain=_topology->nbDomain();
_mesh.resize(nbNewDomain);
o2nRenumber.resize(nbNewDomain,0);
- int rank=MyGlobals::_Rank;
+ int const rank=MyGlobals::_Rank;
//splitting the initial domains into smaller bits
std::vector<std::vector<MEDCoupling::MEDCouplingUMesh*> > splitMeshes;
splitMeshes.resize(nbNewDomain);
for (int inew=0; inew<nbNewDomain; inew++)
{
- splitMeshes[inew].resize(nbOldDomain, (MEDCoupling::MEDCouplingUMesh*)0);
+ splitMeshes[inew].resize(nbOldDomain, (MEDCoupling::MEDCouplingUMesh*)nullptr);
}
for (int iold=0; iold<nbOldDomain; iold++)
{
if (!isParallelMode() || initialCollection._domain_selector->isMyDomain(iold))
{
- mcIdType size=(initialCollection._mesh)[iold]->getNumberOfCells();
+ mcIdType const size=(initialCollection._mesh)[iold]->getNumberOfCells();
std::vector<mcIdType> globalids(size);
initialCollection.getTopology()->getCellList(iold, &globalids[0]);
std::vector<mcIdType> ilocalnew(size); //local
{
double* bbox;
- BBTreeOfDim* tree = 0;
+ BBTreeOfDim* tree = nullptr;
int dim = 3;
if (!isParallelMode() || (_domain_selector->isMyDomain(iold)))
{
MEDCoupling::DataArrayDouble* coords = initialCollection.getMesh(iold)->getCoords();
double* coordsPtr=coords->getPointer();
dim = (int)coords->getNumberOfComponents();
- mcIdType nvertices=initialCollection.getMesh(iold)->getNumberOfNodes();
+ mcIdType const nvertices=initialCollection.getMesh(iold)->getNumberOfNodes();
bbox=new double[nvertices*2*dim];
for (int i=0; i<nvertices*dim;i++)
bbox[i*2]=coordsPtr[i]-1e-8;
bbox[i*2+1]=coordsPtr[i]+1e-8;
}
- tree=new BBTreeOfDim( dim, bbox,0,0,nvertices,1e-9);
+ tree=new BBTreeOfDim( dim, bbox,nullptr,0,nvertices,1e-9);
}
for (int inew=0; inew<_topology->nbDomain(); inew++)
using MEDPARTITIONER::BBTreeOfDim;
//if (!&meshOne || !&meshTwo) return; //empty or not existing
double* bbox;
- BBTreeOfDim* tree = 0;
- mcIdType nv1=meshOne.getNumberOfNodes();
+ BBTreeOfDim* tree = nullptr;
+ mcIdType const nv1=meshOne.getNumberOfNodes();
MEDCoupling::DataArrayDouble* coords=meshOne.getCoords();
- int dim = (int)coords->getNumberOfComponents();
+ int const dim = (int)coords->getNumberOfComponents();
bbox=new double[nv1*2*dim];
double* coordsPtr=coords->getPointer();
bbox[i*2]=coordsPtr[i]-1e-8;
bbox[i*2+1]=coordsPtr[i]+1e-8;
}
- tree=new BBTreeOfDim( dim, bbox,0,0,nv1,1e-9);
+ tree=new BBTreeOfDim( dim, bbox,nullptr,0,nv1,1e-9);
mcIdType nv2=meshTwo.getNumberOfNodes();
nodeIds.resize(nv2,-1);
if (MyGlobals::_Verbose>10)
std::cout << "proc " << MyGlobals::_Rank << " : castFaceMeshes" << std::endl;
- if (_topology==0)
+ if (_topology==nullptr)
throw INTERP_KERNEL::Exception("Topology has not been defined on call to castFaceMeshes");
int nbNewDomain=_topology->nbDomain();
splitMeshes.resize(nbNewDomain);
for (int inew=0; inew<nbNewDomain; inew++)
{
- splitMeshes[inew].resize(nbOldDomain, (MEDCoupling::MEDCouplingUMesh*)0);
+ splitMeshes[inew].resize(nbOldDomain, (MEDCoupling::MEDCouplingUMesh*)nullptr);
}
new2oldIds.resize(nbOldDomain);
for (int iold=0; iold<nbOldDomain; iold++) new2oldIds[iold].resize(nbNewDomain);
for (int iold=0; iold<nbOldDomain; iold++)
{
MEDCoupling::MEDCouplingUMesh *umesh=splitMeshes[inew][iold];
- if (umesh!=0)
+ if (umesh!=nullptr)
if (umesh->getNumberOfCells()>0)
myMeshes.push_back(umesh);
}
- MEDCoupling::MEDCouplingUMesh *bndMesh = 0;
+ MEDCoupling::MEDCouplingUMesh *bndMesh = nullptr;
if ( _subdomain_boundary_creates &&
_mesh[inew] &&
_mesh[inew]->getNumberOfCells()>0 )
MEDCoupling::DataArrayDouble* targetCoords=targetMesh.computeCellCenterOfMass();
const double* tc=targetCoords->getConstPointer();
mcIdType targetSize=targetMesh.getNumberOfCells();
- mcIdType sourceSize=sourceMesh.getNumberOfCells();
+ mcIdType const sourceSize=sourceMesh.getNumberOfCells();
if (MyGlobals::_Verbose>200)
std::cout<<"remap vers target de taille "<<targetSize<<std::endl;
std::vector<mcIdType> ccI;
const BBTreeOfDim* tree;
bool cleantree=false;
- MEDCoupling::DataArrayDouble* sourceBBox=0;
- int dim = (int)targetCoords->getNumberOfComponents();
- if (myTree==0)
+ MEDCoupling::DataArrayDouble* sourceBBox=nullptr;
+ int const dim = (int)targetCoords->getNumberOfComponents();
+ if (myTree==nullptr)
{
sourceBBox=sourceMesh.computeCellCenterOfMass()->computeBBoxPerTuple(1e-8);
- tree=new BBTreeOfDim( dim, sourceBBox->getConstPointer(),0,0, sourceBBox->getNumberOfTuples(),1e-10);
+ tree=new BBTreeOfDim( dim, sourceBBox->getConstPointer(),nullptr,0, sourceBBox->getNumberOfTuples(),1e-10);
cleantree=true;
}
else tree=myTree;
targetCoords->decrRef();
if (cleantree) delete tree;
- if (sourceBBox !=0) sourceBBox->decrRef();
+ if (sourceBBox !=nullptr) sourceBBox->decrRef();
}
void MEDPARTITIONER::MeshCollection::castAllFields(MeshCollection& initialCollection, std::string nameArrayTo)
if (nameArrayTo!="cellFieldDouble")
throw INTERP_KERNEL::Exception("Error castAllField only on cellFieldDouble");
- std::string nameTo="typeData=6"; //resume the type of field casted
+ std::string const nameTo="typeData=6"; //resume the type of field casted
// send-recv operations
- std::size_t ioldMax=initialCollection.getMesh().size();
- std::size_t inewMax=this->getMesh().size();
- std::size_t iFieldMax=initialCollection.getFieldDescriptions().size();
+ std::size_t const ioldMax=initialCollection.getMesh().size();
+ std::size_t const inewMax=this->getMesh().size();
+ std::size_t const iFieldMax=initialCollection.getFieldDescriptions().size();
if (MyGlobals::_Verbose>10)
std::cout << "castAllFields with:\n" << ReprVectorOfString(initialCollection.getFieldDescriptions()) << std::endl;
//see collection.prepareFieldDescriptions()
for (std::size_t ifield=0; ifield<iFieldMax; ifield++)
{
- std::string descriptionField=initialCollection.getFieldDescriptions()[ifield];
+ std::string const descriptionField=initialCollection.getFieldDescriptions()[ifield];
if (descriptionField.find(nameTo)==std::string::npos)
continue; //only nameTo accepted in Fields name description
#ifdef HAVE_MPI
//sending arrays for distant domains
if (isParallelMode() && _domain_selector->isMyDomain(iold) && !_domain_selector->isMyDomain(inew))
{
- int target=_domain_selector->getProcessorID(inew);
+ int const target=_domain_selector->getProcessorID(inew);
MEDCoupling::DataArrayDouble* field=initialCollection.getField(descriptionField,iold);
if (MyGlobals::_Verbose>10)
std::cout << "proc " << _domain_selector->rank() << " : castAllFields sendDouble" << std::endl;
//receiving arrays from distant domains
if (isParallelMode() && !_domain_selector->isMyDomain(iold) && _domain_selector->isMyDomain(inew))
{
- int source=_domain_selector->getProcessorID(iold);
+ int const source=_domain_selector->getProcessorID(iold);
//receive vector
if (MyGlobals::_Verbose>10)
std::cout << "proc " << _domain_selector->rank() << " : castAllFields recvDouble" << std::endl;
if (MyGlobals::_Verbose>300)
std::cout << "proc " << MyGlobals::_Rank << " : remapDoubleField " << key << " size " << ccI->getNbOfElems() << std::endl;
- mcIdType nbcell=this->getMesh()[inew]->getNumberOfCells();
- std::size_t nbcomp=fromArray->getNumberOfComponents();
- int nbPtGauss=StrToInt(ExtractFromDescription(descriptionField, "nbPtGauss="));
+ mcIdType const nbcell=this->getMesh()[inew]->getNumberOfCells();
+ std::size_t const nbcomp=fromArray->getNumberOfComponents();
+ int const nbPtGauss=StrToInt(ExtractFromDescription(descriptionField, "nbPtGauss="));
std::string tag="inewFieldDouble="+IntToStr(inew);
key=descriptionField+SerializeFromString(tag);
- mcIdType fromArrayNbOfElem=fromArray->getNbOfElems();
+ mcIdType const fromArrayNbOfElem=fromArray->getNbOfElems();
mcIdType fromArrayNbOfComp=ToIdType(fromArray->getNumberOfComponents());
- mcIdType fromArrayNbOfCell=fromArrayNbOfElem/fromArrayNbOfComp/nbPtGauss;
+ mcIdType const fromArrayNbOfCell=fromArrayNbOfElem/fromArrayNbOfComp/nbPtGauss;
if (MyGlobals::_Verbose>1000)
{
" nbComponents " << fromArray->getNumberOfComponents() << std::endl;
}
- MEDCoupling::DataArrayDouble* field=0;
+ MEDCoupling::DataArrayDouble* field=nullptr;
std::map<std::string,MEDCoupling::DataArrayDouble*>::iterator it2;
it2=_map_dataarray_double.find(key);
if (it2==_map_dataarray_double.end())
else
{
//replaced by setPartOfValuesAdv if nbPtGauss==1
- mcIdType iMax=ccI->getNbOfElems();
+ mcIdType const iMax=ccI->getNbOfElems();
mcIdType* pccI=ccI->getPointer();
double* pField=field->getPointer();
double* pFrom=fromArray->getPointer();
isource=pccI[i+1];
if ((itarget<0) || (itarget>=nbcell) || (isource<0) || (isource>=fromArrayNbOfCell))
throw INTERP_KERNEL::Exception("Error field override");
- mcIdType ita=itarget*delta;
- mcIdType iso=isource*delta;
+ mcIdType const ita=itarget*delta;
+ mcIdType const iso=isource*delta;
for (mcIdType k=0; k<delta; k++) pField[ita+k]=pFrom[iso+k]; //components and gausspoints
}
}
if ( corresp.empty() )
continue;
- MEDPARTITIONER::ConnectZone* cz = 0;
+ MEDPARTITIONER::ConnectZone* cz = nullptr;
for ( size_t i = 0; i < czVec.size() && !cz; ++i )
if ( czVec[i] &&
czVec[i]->getLocalDomainNumber () == idomain &&
if ( types1.size() < 1 || types2.size() < 1 )
continue; // parallel mode?
- MEDPARTITIONER::ConnectZone* cz21 = 0; // zone 2 -> 1
+ MEDPARTITIONER::ConnectZone* cz21 = nullptr; // zone 2 -> 1
for ( size_t j = 0; j < czVec.size() && !cz21; ++j )
if ( czVec[j] &&
czVec[j]->getLocalDomainNumber () == cz->getDistantDomainNumber() &&
}
}// split and sort
- cz->setEntityCorresp( 0, 0, 0, 0 ); // erase ids computed by _topology
+ cz->setEntityCorresp( 0, 0, nullptr, 0 ); // erase ids computed by _topology
if ( cz21 )
- cz21->setEntityCorresp( 0, 0, 0, 0 );
+ cz21->setEntityCorresp( 0, 0, nullptr, 0 );
} // loop on czVec
if ( cz->getDistantDomainNumber() < cz->getLocalDomainNumber() )
continue; // treat a pair of domains once
- MEDPARTITIONER::ConnectZone* cz21 = 0; // zone 2 -> 1
+ MEDPARTITIONER::ConnectZone* cz21 = nullptr; // zone 2 -> 1
for ( size_t j = 0; j < czVec.size() && !cz21; ++j )
if ( czVec[j] &&
czVec[j]->getLocalDomainNumber () == cz->getDistantDomainNumber() &&
{
for (unsigned int inew2 = inew1+1; inew2 < nbMeshes; inew2++ )
{
- MEDCouplingUMesh* mesh1 = 0;
- MEDCouplingUMesh* mesh2 = 0;
+ MEDCouplingUMesh* mesh1 = nullptr;
+ MEDCouplingUMesh* mesh2 = nullptr;
//MEDCouplingUMesh* recvMesh = 0;
bool mesh1Here = true, mesh2Here = true;
if (isParallelMode())
_group_info.erase( groupName );
// get family IDs array
- mcIdType* famIDs = 0;
- int inew = (is2nd ? inew2 : inew1 );
+ mcIdType* famIDs = nullptr;
+ int const inew = (is2nd ? inew2 : inew1 );
mcIdType totalNbFaces = _face_mesh[ inew ] ? _face_mesh[ inew ]->getNumberOfCells() : 0;
- std::string cle = Cle1ToStr( "faceFamily_toArray", inew );
+ std::string const cle = Cle1ToStr( "faceFamily_toArray", inew );
if ( !_map_dataarray_int.count(cle) )
{
if ( totalNbFaces > 0 )
* \param filename name of the master file containing the list of all the MED files
*/
MEDPARTITIONER::MeshCollection::MeshCollection(const std::string& filename)
- : _topology(0),
+ : _topology(nullptr),
_owns_topology(true),
- _driver(0),
- _domain_selector( 0 ),
+ _driver(nullptr),
+ _domain_selector( nullptr ),
_i_non_empty_mesh(-1),
_driver_type(MEDPARTITIONER::Undefined),
_subdomain_boundary_creates(MyGlobals::_Create_Boundary_Faces),
_family_splitting(false),
_create_empty_groups(false),
- _joint_finder(0)
+ _joint_finder(nullptr)
{
try
{
}
catch(...)
{ // Handle all exceptions
- if ( _driver ) delete _driver; _driver=0;
+ if ( _driver ) delete _driver; _driver=nullptr;
try
{
_driver=new MeshCollectionMedAsciiDriver(this);
catch(...)
{
delete _driver;
- _driver=0;
+ _driver=nullptr;
throw INTERP_KERNEL::Exception("file does not comply with any recognized format");
}
}
* \param domainSelector - selector of domains to load
*/
MEDPARTITIONER::MeshCollection::MeshCollection(const std::string& filename, ParaDomainSelector& domainSelector)
- : _topology(0),
+ : _topology(nullptr),
_owns_topology(true),
- _driver(0),
+ _driver(nullptr),
_domain_selector( &domainSelector ),
_i_non_empty_mesh(-1),
_driver_type(MEDPARTITIONER::Undefined),
_subdomain_boundary_creates(MyGlobals::_Create_Boundary_Faces),
_family_splitting(false),
_create_empty_groups(false),
- _joint_finder(0)
+ _joint_finder(nullptr)
{
- std::string myfile=filename;
+ std::string const myfile=filename;
std::size_t found=myfile.find(".xml");
if (found!=std::string::npos) //file .xml
{
}
catch(...)
{ // Handle all exceptions
- delete _driver; _driver=0;
+ delete _driver; _driver=nullptr;
throw INTERP_KERNEL::Exception("file medpartitioner_xxx.xml does not comply with any recognized format");
}
}
catch(...)
{
delete _driver;
- _driver=0;
+ _driver=nullptr;
throw INTERP_KERNEL::Exception("file name with no extension does not comply with any recognized format");
}
}
* \param meshname name of the mesh that is to be read
*/
MEDPARTITIONER::MeshCollection::MeshCollection(const std::string& filename, const std::string& meshname)
- : _topology(0),
+ : _topology(nullptr),
_owns_topology(true),
- _driver(0),
- _domain_selector( 0 ),
+ _driver(nullptr),
+ _domain_selector( nullptr ),
_i_non_empty_mesh(-1),
_name(meshname),
_driver_type(MEDPARTITIONER::MedXml),
_subdomain_boundary_creates(MyGlobals::_Create_Boundary_Faces),
_family_splitting(false),
_create_empty_groups(false),
- _joint_finder(0)
+ _joint_finder(nullptr)
{
try // avoid memory leak in case of inexistent filename
{
catch (...)
{
delete _driver;
- _driver=0;
+ _driver=nullptr;
throw INTERP_KERNEL::Exception("problem reading .med files");
}
if ( _mesh[0] && _mesh[0]->getNumberOfNodes() > 0 )
MEDPARTITIONER::MeshCollection::~MeshCollection()
{
- for (std::size_t i=0; i<_mesh.size();i++)
- if (_mesh[i]!=0) _mesh[i]->decrRef();
+ for (auto & i : _mesh)
+ if (i!=nullptr) i->decrRef();
- for (std::size_t i=0; i<_cell_family_ids.size();i++)
- if (_cell_family_ids[i]!=0)
- _cell_family_ids[i]->decrRef();
+ for (auto & _cell_family_id : _cell_family_ids)
+ if (_cell_family_id!=nullptr)
+ _cell_family_id->decrRef();
- for (std::size_t i=0; i<_face_mesh.size();i++)
- if (_face_mesh[i]!=0)
- _face_mesh[i]->decrRef();
+ for (auto & i : _face_mesh)
+ if (i!=nullptr)
+ i->decrRef();
- for (std::size_t i=0; i<_face_family_ids.size();i++)
- if (_face_family_ids[i]!=0)
- _face_family_ids[i]->decrRef();
+ for (auto & _face_family_id : _face_family_ids)
+ if (_face_family_id!=nullptr)
+ _face_family_id->decrRef();
for (std::map<std::string, MEDCoupling::DataArrayIdType*>::iterator it=_map_dataarray_int.begin() ; it!=_map_dataarray_int.end(); it++ )
if ((*it).second!=0)
(*it).second->decrRef();
delete _driver;
- if (_topology!=0 && _owns_topology)
+ if (_topology!=nullptr && _owns_topology)
delete _topology;
#ifdef HAVE_MPI
delete _joint_finder;
{
//suppresses link with driver so that it can be changed for writing
delete _driver;
- _driver=0;
+ _driver=nullptr;
retrieveDriver()->write (filename.c_str(), _domain_selector);
}
*/
MEDPARTITIONER::MeshCollectionDriver* MEDPARTITIONER::MeshCollection::retrieveDriver()
{
- if (_driver==0)
+ if (_driver==nullptr)
{
switch(_driver_type)
{
int MEDPARTITIONER::MeshCollection::getNbOfLocalMeshes() const
{
int nb=0;
- for (size_t i=0; i<_mesh.size(); i++)
+ for (auto i : _mesh)
{
- if (_mesh[i]) nb++;
+ if (i) nb++;
}
return nb;
}
mcIdType MEDPARTITIONER::MeshCollection::getNbOfLocalCells() const
{
mcIdType nb=0;
- for (size_t i=0; i<_mesh.size(); i++)
+ for (auto i : _mesh)
{
- if (_mesh[i]) nb=nb+_mesh[i]->getNumberOfCells();
+ if (i) nb=nb+i->getNumberOfCells();
}
return nb;
}
mcIdType MEDPARTITIONER::MeshCollection::getNbOfLocalFaces() const
{
mcIdType nb=0;
- for (size_t i=0; i<_face_mesh.size(); i++)
+ for (auto i : _face_mesh)
{
- if (_face_mesh[i]) nb=nb+_face_mesh[i]->getNumberOfCells();
+ if (i) nb=nb+i->getNumberOfCells();
}
return nb;
}
void MEDPARTITIONER::MeshCollection::setTopology(Topology* topo, bool takeOwneship)
{
- if (_topology!=0)
+ if (_topology!=nullptr)
{
throw INTERP_KERNEL::Exception("topology is already set");
}
* \param edgeweight returns the pointer to the table that contains the edgeweights
* (only used if indivisible regions are required)
*/
-void MEDPARTITIONER::MeshCollection::buildCellGraph(MEDCoupling::MEDCouplingSkyLineArray* & array, int *& edgeweights )
+void MEDPARTITIONER::MeshCollection::buildCellGraph(MEDCoupling::MEDCouplingSkyLineArray* & array, int *& /*edgeweights*/ )
{
using std::map;
* \param edgeweight returns the pointer to the table that contains the edgeweights
* (only used if indivisible regions are required)
*/
-void MEDPARTITIONER::MeshCollection::buildParallelCellGraph(MEDCoupling::MEDCouplingSkyLineArray* & array, int *& edgeweights )
+void MEDPARTITIONER::MeshCollection::buildParallelCellGraph(MEDCoupling::MEDCouplingSkyLineArray* & array, int *& /*edgeweights*/ )
{
using std::multimap;
using std::vector;
std::multimap<mcIdType,mcIdType> cell2cell;
std::vector<std::vector<std::multimap<mcIdType,mcIdType> > > commonDistantNodes;
- int nbdomain=_topology->nbDomain();
+ int const nbdomain=_topology->nbDomain();
#ifdef HAVE_MPI
if (isParallelMode())
{
MEDCoupling::DataArrayIdType* index=MEDCoupling::DataArrayIdType::New();
MEDCoupling::DataArrayIdType* revConn=MEDCoupling::DataArrayIdType::New();
- mcIdType nbNodes=_mesh[idomain]->getNumberOfNodes();
+ mcIdType const nbNodes=_mesh[idomain]->getNumberOfNodes();
_mesh[idomain]->getReverseNodalConnectivity(revConn,index);
//problem saturation over 1 000 000 nodes for 1 proc
if (MyGlobals::_Verbose>100)
{
for (mcIdType icell=index_ptr[i]; icell<index_ptr[i+1]; icell++)
{
- mcIdType globalNode=_topology->convertNodeToGlobal(idomain,i);
- mcIdType globalCell=_topology->convertCellToGlobal(idomain,revConnPtr[icell]);
+ mcIdType const globalNode=_topology->convertNodeToGlobal(idomain,i);
+ mcIdType const globalCell=_topology->convertCellToGlobal(idomain,revConnPtr[icell]);
node2cell.insert(make_pair(globalNode, globalCell));
}
}
for (int iother=0; iother<nbdomain; iother++)
{
std::multimap<mcIdType,mcIdType>::iterator it;
- int isource=idomain;
- int itarget=iother;
+ int const isource=idomain;
+ int const itarget=iother;
for (it=_joint_finder->getDistantNodeCell()[isource][itarget].begin();
it!=_joint_finder->getDistantNodeCell()[isource][itarget].end(); it++)
{
for (int idomain=0; idomain<nbdomain; idomain++)
{
if (isParallelMode() && !_domain_selector->isMyDomain(idomain)) continue;
- mcIdType nbCells=_mesh[idomain]->getNumberOfCells();
+ mcIdType const nbCells=_mesh[idomain]->getNumberOfCells();
for (mcIdType icell=0; icell<nbCells; icell++)
{
mcIdType size=0;
- mcIdType globalCell=_topology->convertCellToGlobal(idomain,icell);
+ mcIdType const globalCell=_topology->convertCellToGlobal(idomain,icell);
multimap<mcIdType,mcIdType>::iterator it;
pair<multimap<mcIdType,mcIdType>::iterator,multimap<mcIdType,mcIdType>::iterator> ret;
ret=cell2cell.equal_range(globalCell);
if (nbdomain <1)
throw INTERP_KERNEL::Exception("Number of subdomains must be > 0");
- MEDCoupling::MEDCouplingSkyLineArray* array=0;
- int* edgeweights=0;
+ MEDCoupling::MEDCouplingSkyLineArray* array=nullptr;
+ int* edgeweights=nullptr;
if (_topology->nbDomain()>1 || isParallelMode())
buildParallelCellGraph(array,edgeweights);
else
buildCellGraph(array,edgeweights);
- Graph* cellGraph = 0;
+ Graph* cellGraph = nullptr;
switch (split)
{
case Graph::METIS:
}
//!user-defined weights
- if (user_edge_weights!=0)
+ if (user_edge_weights!=nullptr)
cellGraph->setEdgesWeights(user_edge_weights);
- if (user_vertices_weights!=0)
+ if (user_vertices_weights!=nullptr)
cellGraph->setVerticesWeights(user_vertices_weights);
if (MyGlobals::_Is0verbose>10)
if (MyGlobals::_Is0verbose>10)
std::cout << "building new topology" << std::endl;
//cellGraph is a shared pointer
- Topology *topology=0;
+ Topology *topology=nullptr;
topology=new ParallelTopology (cellGraph, getTopology(), nbdomain, getMeshDimension());
//cleaning
delete [] edgeweights;
*/
MEDPARTITIONER::Topology* MEDPARTITIONER::MeshCollection::createPartition(const int* partition)
{
- MEDCoupling::MEDCouplingSkyLineArray* array=0;
- int* edgeweights=0;
+ MEDCoupling::MEDCouplingSkyLineArray* array=nullptr;
+ int* edgeweights=nullptr;
if ( _topology->nbDomain()>1)
buildParallelCellGraph(array,edgeweights);
cellGraph=new UserGraph(array, partition, _topology->nbCells());
//cellGraph is a shared pointer
- Topology *topology=0;
+ Topology *topology=nullptr;
int nbdomain=(int)domains.size();
topology=new ParallelTopology (cellGraph, getTopology(), nbdomain, getMeshDimension());
// if (array!=0) delete array;
//getField look for and read it if not done, and assume decrRef() in ~MeshCollection;
//something like MCAuto<MEDCouplingFieldDouble> f2=ReadFieldCell(name,f1->getMesh()->getName(),0,f1->getName(),0,1);
{
- int rank=MyGlobals::_Rank;
+ int const rank=MyGlobals::_Rank;
std::string tag="ioldFieldDouble="+IntToStr(iold);
std::string descriptionIold=descriptionField+SerializeFromString(tag);
if (_map_dataarray_double.find(descriptionIold)!=_map_dataarray_double.end())
}
//here vector(procs*fields) of serialised vector(description) data
_field_descriptions=r2;
- std::size_t nbfields=_field_descriptions.size(); //on all domains
+ std::size_t const nbfields=_field_descriptions.size(); //on all domains
if ((nbfields%nbfiles)!=0)
{
if (MyGlobals::_Rank==0)
throw INTERP_KERNEL::Exception("incoherent number of fields references in all files .med\n");
}
_field_descriptions.resize(nbfields/nbfiles);
- for (std::size_t i=0; i<_field_descriptions.size(); i++)
+ for (auto & _field_description : _field_descriptions)
{
- std::string str=_field_descriptions[i];
+ std::string str=_field_description;
str=EraseTagSerialized(str,"idomain=");
str=EraseTagSerialized(str,"fileName=");
- _field_descriptions[i]=str;
+ _field_description=str;
}
}
std::vector< mcIdType > faceOnCell;
std::vector< mcIdType > faceNotOnCell;
- mcIdType nbface=mfac->getNumberOfCells();
+ mcIdType const nbface=mfac->getNumberOfCells();
for (mcIdType iface=0; iface<nbface; iface++)
{
bool ok;
std::cout << "filterFaceOnCell problem 1" << std::endl;
continue;
}
- mcIdType nbcell=revIndxC[inod+1]-revIndxC[inod];
+ mcIdType const nbcell=revIndxC[inod+1]-revIndxC[inod];
for (mcIdType j=0; j<nbcell; j++) //look for each cell with inod
{
- mcIdType icel=revC[revIndxC[inod]+j];
+ mcIdType const icel=revC[revIndxC[inod]+j];
std::vector< mcIdType > inodesCell;
mcel->getNodeIdsOfCell(icel, inodesCell);
ok=isFaceOncell(inodesFace, inodesCell);
mfac->decrRef();
// filter the face families
- std::string key = Cle1ToStr("faceFamily_toArray",inew);
+ std::string const key = Cle1ToStr("faceFamily_toArray",inew);
if ( getMapDataArrayInt().count( key ))
{
MEDCoupling::DataArrayIdType * & fam = getMapDataArrayInt()[ key ];
#ifndef __MEDPARTITIONER_MESHCOLLECTION_HXX__
#define __MEDPARTITIONER_MESHCOLLECTION_HXX__
+#include "MCType.hxx"
+#include "MCIdType.hxx"
+#include "MEDCouplingMemArray.hxx"
#include "MEDPARTITIONER.hxx"
#include "MEDPARTITIONER_Graph.hxx"
#include "MEDPARTITIONER_Utils.hxx"
#include "MEDCouplingSkyLineArray.hxx"
#include <map>
+#include <utility>
#include <vector>
#include <string>
-#include "BBTree.txx"
namespace MEDCoupling
{
//creation and partition of the associated graph
Topology* createPartition(int nbdomain, Graph::splitter_type type = Graph::METIS,
- const std::string& ="", int* edgeweights=0, int* verticesweights=0);
+ const std::string& ="", int* edgeweights=nullptr, int* verticesweights=nullptr);
//creation of a user specified partition
Topology* createPartition(const int* partition);
#include "MEDPARTITIONER_MeshCollectionDriver.hxx"
+#include "MCType.hxx"
+#include "MCIdType.hxx"
+#include "MCAuto.hxx"
+#include "MEDFileFieldMultiTS.hxx"
+#include "MEDFileField1TS.hxx"
#include "MEDPARTITIONER_ConnectZone.hxx"
#include "MEDPARTITIONER_MeshCollection.hxx"
#include "MEDPARTITIONER_ParaDomainSelector.hxx"
#include "MEDFileMesh.hxx"
#include "MEDLoader.hxx"
+#include <cstddef>
#include <map>
-#include <set>
+#include <sstream>
+#include <utility>
#include <vector>
#include <string>
-#include <fstream>
#include <iostream>
-#include <libxml/tree.h>
-#include <libxml/parser.h>
-#include <libxml/xpath.h>
-#include <libxml/xpathInternals.h>
-#include "med.h"
+#include "NormalizedGeometricTypes"
using namespace MEDPARTITIONER;
(_collection->getCZ()).clear();
- ParallelTopology* aPT = new ParallelTopology((_collection->getMesh()));
+ auto* aPT = new ParallelTopology((_collection->getMesh()));
_collection->setTopology(aPT, true);
_collection->setName(meshname);
_collection->setDomainNames(meshname);
void MeshCollectionDriver::readMEDFileData(const MEDCoupling::MEDFileData* filedata)
{
const int nbDomains = filedata->getMeshes()->getNumberOfMeshes();
- _collection->getMesh() .resize( nbDomains, 0 );
- _collection->getFaceMesh() .resize( nbDomains, 0 );
- _collection->getCellFamilyIds().resize( nbDomains, 0 );
- _collection->getFaceFamilyIds().resize( nbDomains, 0 );
+ _collection->getMesh() .resize( nbDomains, nullptr );
+ _collection->getFaceMesh() .resize( nbDomains, nullptr );
+ _collection->getCellFamilyIds().resize( nbDomains, nullptr );
+ _collection->getFaceFamilyIds().resize( nbDomains, nullptr );
for (int i=0; i<nbDomains; i++)
{
- MEDCoupling::MEDFileUMesh *mfm = dynamic_cast<MEDCoupling::MEDFileUMesh *>(filedata->getMeshes()->getMeshAtPos(i));
+ auto *mfm = dynamic_cast<MEDCoupling::MEDFileUMesh *>(filedata->getMeshes()->getMeshAtPos(i));
readData(mfm,i);
if ( mfm && mfm->getMeshDimension() > 0 )
_collection->setNonEmptyMesh( i );
}
- ParallelTopology* aPT = new ParallelTopology(_collection->getMesh());
+ auto* aPT = new ParallelTopology(_collection->getMesh());
_collection->setTopology(aPT, true);
if ( nbDomains > 0 )
{
void MeshCollectionDriver::readSubdomain(int idomain)
{
- std::string meshname=MyGlobals::_Mesh_Names[idomain];
- std::string file=MyGlobals::_File_Names[idomain];
+ std::string const meshname=MyGlobals::_Mesh_Names[idomain];
+ std::string const file=MyGlobals::_File_Names[idomain];
readFileData(file,meshname,idomain);
std::vector<std::string> localInformation;
- std::string str;
+ std::string const str;
localInformation.push_back(str+"ioldDomain="+IntToStr(idomain));
localInformation.push_back(str+"meshName="+meshname);
MyGlobals::_General_Informations.push_back(SerializeFromVectorOfString(localInformation));
- std::vector<std::string> localFields=BrowseAllFieldsOnMesh(file, meshname, idomain);
+ std::vector<std::string> const localFields=BrowseAllFieldsOnMesh(file, meshname, idomain);
if (localFields.size()>0)
MyGlobals::_Field_Descriptions.push_back(SerializeFromVectorOfString(localFields));
}
std::string finalMeshName="";
if (MyGlobals::_General_Informations.size()!=0)
{
- std::size_t found=MyGlobals::_General_Informations[0].find("finalMeshName=");
+ std::size_t const found=MyGlobals::_General_Informations[0].find("finalMeshName=");
if ((found!=std::string::npos) && (found>0))
{
finalMeshName=ExtractFromDescription(MyGlobals::_General_Informations[0], "finalMeshName=");
j1st->pushCorrespondence( corr );
}
- std::vector< std::pair< mcIdType,mcIdType > > types = cz->getEntities();
+ std::vector< std::pair< mcIdType,mcIdType > > const types = cz->getEntities();
INTERP_KERNEL::NormalizedCellType t1, t2;
- for ( size_t it = 0; it < types.size(); ++it )
+ for (auto & type : types)
{
const MEDCouplingSkyLineArray * cellCorr =
- cz->getEntityCorresp( types[it].first, types[it].second );
+ cz->getEntityCorresp( type.first, type.second );
if ( cellCorr && cellCorr->getNumberOf() > 0 )
{
- t1 = INTERP_KERNEL::NormalizedCellType( types[it].first );
- t2 = INTERP_KERNEL::NormalizedCellType( types[it].second );
+ t1 = INTERP_KERNEL::NormalizedCellType( type.first );
+ t2 = INTERP_KERNEL::NormalizedCellType( type.second );
MCAuto< MEDFileJointCorrespondence>
corr = MEDFileJointCorrespondence::New( cellCorr->getValuesArray(), t1, t2 );
j1st->pushCorrespondence( corr );
return mfm;
}
-MEDCoupling::MEDCouplingFieldDouble* MeshCollectionDriver::getField(std::string key, std::string description, MEDCoupling::DataArrayDouble* data, MEDCoupling::MEDFileMesh* mfm, int idomain) const
+MEDCoupling::MEDCouplingFieldDouble* MeshCollectionDriver::getField(std::string /*key*/, std::string description, MEDCoupling::DataArrayDouble* data, MEDCoupling::MEDFileMesh* mfm, int /*idomain*/) const
{
- std::string desc=description;
+ std::string const desc=description;
if (MyGlobals::_Verbose>20)
std::cout << "proc " << MyGlobals::_Rank << " : write field " << desc << std::endl;
std::string meshName, fieldName;
int typeField, DT, IT, entity;
FieldShortDescriptionToData(desc, fieldName, typeField, entity, DT, IT);
- double time=StrToDouble(ExtractFromDescription(desc, "time="));
- int typeData=StrToInt(ExtractFromDescription(desc, "typeData="));
- std::string entityName=ExtractFromDescription(desc, "entityName=");
- MEDCoupling::MEDCouplingFieldDouble* field=0;
+ double const time=StrToDouble(ExtractFromDescription(desc, "time="));
+ int const typeData=StrToInt(ExtractFromDescription(desc, "typeData="));
+ std::string const entityName=ExtractFromDescription(desc, "entityName=");
+ MEDCoupling::MEDCouplingFieldDouble* field=nullptr;
if (typeData!=6)
{
std::cout << "WARNING : writeMedFile : typeData " << typeData << " not implemented for fields\n";
r1=SelectTagsInVectorOfString(r1,"DT="+IntToStr(DT));
r1=SelectTagsInVectorOfString(r1,"IT="+IntToStr(IT));
//not saved in file? field->setDescription(ExtractFromDescription(r1[0], "fieldDescription="));
- std::size_t nbc=StrToInt(ExtractFromDescription(r1[0], "nbComponents="));
+ std::size_t const nbc=StrToInt(ExtractFromDescription(r1[0], "nbComponents="));
if (nbc==da->getNumberOfComponents())
{
for (unsigned int i=0; i<nbc; i++)
MEDCoupling::MEDFileMesh* mfm = getMesh( idomain );
mfm->write(distfilename,2);
- std::string key="/inewFieldDouble="+IntToStr(idomain)+"/";
+ std::string const key="/inewFieldDouble="+IntToStr(idomain)+"/";
std::map<std::string,MEDCoupling::DataArrayDouble*>::iterator it;
int nbfFieldFound=0;
for (it=_collection->getMapDataArrayDouble().begin() ; it!=_collection->getMapDataArrayDouble().end(); it++)
{
- size_t found=(*it).first.find(key);
+ size_t const found=(*it).first.find(key);
if (found==std::string::npos)
continue;
- MEDCoupling::MEDCouplingFieldDouble* field=0;
+ MEDCoupling::MEDCouplingFieldDouble* field=nullptr;
field = getField(key, (*it).first, (*it).second, mfm, idomain);
nbfFieldFound++;
try
MEDCoupling::MEDFileMesh* mfm = getMesh( i );
meshes->pushMesh(mfm);
- std::string key="/inewFieldDouble="+IntToStr(i)+"/";
+ std::string const key="/inewFieldDouble="+IntToStr(i)+"/";
std::map<std::string,MEDCoupling::DataArrayDouble*>::iterator it;
MEDCoupling::MEDFileFieldMultiTS* fieldsMTS = MEDCoupling::MEDFileFieldMultiTS::New();
for (it=_collection->getMapDataArrayDouble().begin() ; it!=_collection->getMapDataArrayDouble().end(); it++)
{
- size_t found=(*it).first.find(key);
+ size_t const found=(*it).first.find(key);
if (found==std::string::npos)
continue;
- MEDCoupling::MEDCouplingFieldDouble* field=0;
+ MEDCoupling::MEDCouplingFieldDouble* field=nullptr;
field=getField(key, (*it).first, (*it).second, mfm, i);
MEDCoupling::MEDFileField1TS* f1ts = MEDCoupling::MEDFileField1TS::New();
f1ts->setFieldNoProfileSBT(field);
#include "MEDPARTITIONER.hxx"
-#include <vector>
#include <string>
namespace MEDCoupling
{
public:
MeshCollectionDriver(MeshCollection*);
- virtual ~MeshCollectionDriver() { }
- virtual int read(const char*, ParaDomainSelector* sel=0) = 0;
+ virtual ~MeshCollectionDriver() = default;
+ virtual int read(const char*, ParaDomainSelector* sel=nullptr) = 0;
int readSeq(const char*,const char*);
MEDCoupling::MEDFileData *getMEDFileData();
- virtual void write(const char*, ParaDomainSelector* sel=0) const = 0;
+ virtual void write(const char*, ParaDomainSelector* sel=nullptr) const = 0;
void readMEDFileData(const MEDCoupling::MEDFileData* filedata);
protected:
void readSubdomain(int idomain);
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+#include "MCIdType.hxx"
#include "MEDPARTITIONER_ParallelTopology.hxx"
#include "MEDPARTITIONER_MeshCollectionDriver.hxx"
#include "MEDPARTITIONER_MeshCollection.hxx"
#include "MEDCouplingUMesh.hxx"
#include "MEDLoader.hxx"
-#include <map>
-#include <set>
+#include <cstddef>
+#include <cstdlib>
#include <vector>
#include <string>
#include <fstream>
#include <iostream>
#include <sstream>
-#include <libxml/tree.h>
-#include <libxml/parser.h>
-#include <libxml/xpath.h>
-#include <libxml/xpathInternals.h>
using namespace MEDPARTITIONER;
{
readMEDFileData(filedata);
- std::vector<MEDPARTITIONER::ConnectZone*> cz; // to fill from filedata
+ std::vector<MEDPARTITIONER::ConnectZone*> const cz; // to fill from filedata
std::vector<mcIdType*> cellglobal;
std::vector<mcIdType*> nodeglobal;
std::vector<mcIdType*> faceglobal;
- std::size_t size = _collection->getMesh().size();
+ std::size_t const size = _collection->getMesh().size();
cellglobal.resize(size);
nodeglobal.resize(size);
faceglobal.resize(size);
for ( unsigned int idomain = 0; idomain < size; ++idomain )
{
- cellglobal[idomain]=0;
- faceglobal[idomain]=0;
- nodeglobal[idomain]=0;
+ cellglobal[idomain]=nullptr;
+ faceglobal[idomain]=nullptr;
+ nodeglobal[idomain]=nullptr;
if ( (_collection->getMesh())[idomain] && (_collection->getMesh())[idomain]->getNumberOfNodes() > 0 )
_collection->setNonEmptyMesh(idomain);
}
//creation of topology from mesh and connect zones
- ParallelTopology* aPT = new ParallelTopology((_collection->getMesh()), cz, cellglobal, nodeglobal, faceglobal);
+ auto* aPT = new ParallelTopology((_collection->getMesh()), cz, cellglobal, nodeglobal, faceglobal);
_collection->setTopology(aPT,true);
return 0;
//reading information about the domain
std::string mesh,host;
int idomain;
- cellglobal[i]=0;
- faceglobal[i]=0;
- nodeglobal[i]=0;
+ cellglobal[i]=nullptr;
+ faceglobal[i]=nullptr;
+ nodeglobal[i]=nullptr;
asciiinput >> mesh >> idomain >> MyGlobals::_Mesh_Names[i] >> host >> MyGlobals::_File_Names[i];
}
//creation of topology from mesh and connect zones
- ParallelTopology* aPT = new ParallelTopology((_collection->getMesh()), (_collection->getCZ()), cellglobal, nodeglobal, faceglobal);
+ auto* aPT = new ParallelTopology((_collection->getMesh()), (_collection->getCZ()), cellglobal, nodeglobal, faceglobal);
_collection->setTopology(aPT, true);
for (int i=0; i<nbdomain; i++)
*/
void MeshCollectionMedAsciiDriver::write(const char* filename, ParaDomainSelector* domainSelector) const
{
- std::size_t nbdomains=_collection->getMesh().size();
+ std::size_t const nbdomains=_collection->getMesh().size();
std::vector<std::string> filenames;
filenames.resize(nbdomains);
#include "MEDPARTITIONER.hxx"
#include "MEDPARTITIONER_MeshCollectionDriver.hxx"
+#include <string>
namespace MEDPARTITIONER
{
{
public:
MeshCollectionMedAsciiDriver(MeshCollection*);
- virtual ~MeshCollectionMedAsciiDriver() { }
- int read(const char*, ParaDomainSelector* sel=0);
+ ~MeshCollectionMedAsciiDriver() override = default;
+ int read(const char*, ParaDomainSelector* sel=nullptr) override;
int read(MEDCoupling::MEDFileData*);
- void write(const char*, ParaDomainSelector* sel=0) const;
+ void write(const char*, ParaDomainSelector* sel=nullptr) const override;
private:
std::string _master_filename;
};
#include "MEDCouplingUMesh.hxx"
#include "MEDLoader.hxx"
-#include "MEDFileMesh.hxx"
+#include "libxml/xmlstring.h"
-#include <map>
-#include <set>
+#include <cstdio>
+#include <ctime>
#include <vector>
#include <string>
#include <cstring>
-#include <fstream>
#include <sstream>
#include <iostream>
#ifdef WIN32
#include <libxml/tree.h>
#include <libxml/parser.h>
#include <libxml/xpath.h>
-#include <libxml/xpathInternals.h>
using namespace MEDPARTITIONER;
//number of domains
xmlXPathContextPtr xpathCtx = xmlXPathNewContext(master_doc);
xmlXPathObjectPtr xpathObj = xmlXPathEvalExpression(BAD_CAST "//splitting/subdomain", xpathCtx);
- if (xpathObj==0 || xpathObj->nodesetval->nodeNr ==0)
+ if (xpathObj==nullptr || xpathObj->nodesetval->nodeNr ==0)
throw INTERP_KERNEL::Exception("Xml Master File does not contain /MED/splitting/subdomain node");
//as subdomain has only one property which is "number"
//mesh name
xmlXPathFreeObject(xpathObj);
xpathObj = xmlXPathEvalExpression(BAD_CAST "//content/mesh", xpathCtx);
- if (xpathObj==0 || xpathObj->nodesetval->nodeNr ==0)
+ if (xpathObj==nullptr || xpathObj->nodesetval->nodeNr ==0)
throw INTERP_KERNEL::Exception("Xml Master File does not contain /MED/content/mesh node");
_collection->setName( (const char*)xpathObj->nodesetval->nodeTab[0]->properties->children->content);
const char filechar[]="//files/subfile";
xmlXPathFreeObject(xpathObj);
xpathObj = xmlXPathEvalExpression(BAD_CAST filechar, xpathCtx);
- if (xpathObj==0 || xpathObj->nodesetval->nodeNr ==0)
+ if (xpathObj==nullptr || xpathObj->nodesetval->nodeNr ==0)
throw INTERP_KERNEL::Exception("Xml Master File does not contain /MED/files/subfile nodes");
- int nbfiles = xpathObj->nodesetval ->nodeNr;
+ int const nbfiles = xpathObj->nodesetval ->nodeNr;
for (int i=0; i<nbfiles;i++)
{
//reading information about the domain
- std::string host;
+ std::string const host;
//reading file names
std::ostringstream name_search_string;
name_search_string<<"//files/subfile[@id=\""<<i+1<<"\"]/name";
xmlXPathObjectPtr xpathObjfilename =
xmlXPathEvalExpression(BAD_CAST name_search_string.str().c_str(),xpathCtx);
- if (xpathObjfilename->nodesetval ==0)
+ if (xpathObjfilename->nodesetval ==nullptr)
throw INTERP_KERNEL::Exception("Error retrieving a file name from subfile of Xml Master File");
MyGlobals::_File_Names[i]=(const char*)xpathObjfilename->nodesetval->nodeTab[0]->children->content;
mesh_search_string<<"//mapping/mesh/chunk[@subdomain=\""<<i+1<<"\"]/name";
xmlXPathObjectPtr xpathMeshObj = xmlXPathEvalExpression(BAD_CAST mesh_search_string.str().c_str(),xpathCtx);
- if (xpathMeshObj->nodesetval ==0)
+ if (xpathMeshObj->nodesetval ==nullptr)
throw INTERP_KERNEL::Exception("Error retrieving mesh name from chunk of Xml Master File");
MyGlobals::_Mesh_Names[i]=(const char*)xpathMeshObj->nodesetval->nodeTab[0]->children->content;
throw INTERP_KERNEL::Exception("I/O error reading parallel MED file");
}
- ParallelTopology* aPT = new ParallelTopology(_collection->getMesh());
+ auto* aPT = new ParallelTopology(_collection->getMesh());
//creation of topology from mesh and connect zones
if ( _collection->isParallelMode() )
{
*/
void MeshCollectionMedXmlDriver::write(const char* filename, ParaDomainSelector* domainSelector) const
{
- xmlDocPtr master_doc = 0;
- xmlNodePtr root_node = 0, node, node2;
+ xmlDocPtr master_doc = nullptr;
+ xmlNodePtr root_node = nullptr, node, node2;
char buff[256];
//Creating the Xml document
master_doc = xmlNewDoc(BAD_CAST "1.0");
- root_node = xmlNewNode(0, BAD_CAST "root");
+ root_node = xmlNewNode(nullptr, BAD_CAST "root");
xmlDocSetRootElement(master_doc,root_node);
//Creating child nodes
// Version tag
- node = xmlNewChild(root_node, 0, BAD_CAST "version",0);
+ node = xmlNewChild(root_node, nullptr, BAD_CAST "version",nullptr);
xmlNewProp(node, BAD_CAST "maj", BAD_CAST "2");
xmlNewProp(node, BAD_CAST "min", BAD_CAST "3");
xmlNewProp(node, BAD_CAST "ver", BAD_CAST "1");
,st.wDay);
#endif
- node = xmlNewChild(root_node,0, BAD_CAST "description",0);
+ node = xmlNewChild(root_node,nullptr, BAD_CAST "description",nullptr);
xmlNewProp(node, BAD_CAST "what", BAD_CAST _collection->getDescription().c_str());
xmlNewProp(node, BAD_CAST "when", BAD_CAST date);
//Content tag
- node =xmlNewChild(root_node,0, BAD_CAST "content",0);
- node2 = xmlNewChild(node, 0, BAD_CAST "mesh",0);
+ node =xmlNewChild(root_node,nullptr, BAD_CAST "content",nullptr);
+ node2 = xmlNewChild(node, nullptr, BAD_CAST "mesh",nullptr);
xmlNewProp(node2, BAD_CAST "name", BAD_CAST _collection->getName().c_str());
//Splitting tag
- node=xmlNewChild(root_node,0,BAD_CAST "splitting",0);
- node2=xmlNewChild(node,0,BAD_CAST "subdomain",0);
+ node=xmlNewChild(root_node,nullptr,BAD_CAST "splitting",nullptr);
+ node2=xmlNewChild(node,nullptr,BAD_CAST "subdomain",nullptr);
sprintf(buff, "%d", (int)_collection->getMesh().size());
xmlNewProp(node2, BAD_CAST "number", BAD_CAST buff);
- node2=xmlNewChild(node,0,BAD_CAST "global_numbering",0);
+ node2=xmlNewChild(node,nullptr,BAD_CAST "global_numbering",nullptr);
xmlNewProp(node2, BAD_CAST "present", BAD_CAST "yes");
//Files tag
- xmlNodePtr file_node=xmlNewChild(root_node,0,BAD_CAST "files",0);
+ xmlNodePtr file_node=xmlNewChild(root_node,nullptr,BAD_CAST "files",nullptr);
//Mapping tag
- node = xmlNewChild(root_node,0,BAD_CAST "mapping",0);
- xmlNodePtr mesh_node = xmlNewChild(node, 0, BAD_CAST "mesh",0);
+ node = xmlNewChild(root_node,nullptr,BAD_CAST "mapping",nullptr);
+ xmlNodePtr mesh_node = xmlNewChild(node, nullptr, BAD_CAST "mesh",nullptr);
xmlNewProp(mesh_node, BAD_CAST "name", BAD_CAST _collection->getName().c_str());
- int nbdomains= _collection->getNbOfGlobalMeshes();
+ int const nbdomains= _collection->getNbOfGlobalMeshes();
//loop on the domains
std::string finalMeshName="";
if (MyGlobals::_General_Informations.size()!=0)
{
- std::size_t found=MyGlobals::_General_Informations[0].find("finalMeshName=");
+ std::size_t const found=MyGlobals::_General_Informations[0].find("finalMeshName=");
if ((found!=std::string::npos) && (found>0))
{
finalMeshName=ExtractFromDescription(MyGlobals::_General_Informations[0], "finalMeshName=");
if (domainSelector->rank()==0)
{
//updating the ascii description file
- node = xmlNewChild(file_node, 0, BAD_CAST "subfile",0);
+ node = xmlNewChild(file_node, nullptr, BAD_CAST "subfile",nullptr);
sprintf (buff,"%d",idomain+1);
xmlNewProp(node, BAD_CAST "id", BAD_CAST buff);
- xmlNewChild(node,0,BAD_CAST "name",BAD_CAST distfilename.c_str());
- xmlNewChild(node,0,BAD_CAST "machine",BAD_CAST "localhost");
+ xmlNewChild(node,nullptr,BAD_CAST "name",BAD_CAST distfilename.c_str());
+ xmlNewChild(node,nullptr,BAD_CAST "machine",BAD_CAST "localhost");
- node = xmlNewChild(mesh_node,0, BAD_CAST "chunk",0);
+ node = xmlNewChild(mesh_node,nullptr, BAD_CAST "chunk",nullptr);
xmlNewProp(node, BAD_CAST "subdomain", BAD_CAST buff);
- xmlNewChild(node,0,BAD_CAST "name", BAD_CAST finalMeshName.c_str());
+ xmlNewChild(node,nullptr,BAD_CAST "name", BAD_CAST finalMeshName.c_str());
//xmlNewChild(node,0,BAD_CAST "name", BAD_CAST ((_collection->getMesh())[idomain]->getName()).c_str());
}
}
#include "MEDPARTITIONER.hxx"
#include "MEDPARTITIONER_MeshCollectionDriver.hxx"
+#include <string>
namespace MEDPARTITIONER
{
{
public:
MeshCollectionMedXmlDriver(MeshCollection*);
- virtual ~MeshCollectionMedXmlDriver() { }
- int read(const char*, ParaDomainSelector* sel=0);
- void write(const char*, ParaDomainSelector* sel=0) const;
+ ~MeshCollectionMedXmlDriver() override = default;
+ int read(const char*, ParaDomainSelector* sel=nullptr) override;
+ void write(const char*, ParaDomainSelector* sel=nullptr) const override;
private :
std::string _master_filename;
};
//
#include "MEDPARTITIONER_MetisGraph.hxx"
+#include "MCIdType.hxx"
#include "MEDPARTITIONER_ParaDomainSelector.hxx"
#include "MEDPARTITIONER_Utils.hxx"
#include "MEDCouplingSkyLineArray.hxx"
-#include "InterpKernelException.hxx"
#include <iostream>
+#include <string>
+#include <vector>
extern "C"
{
}
METISGraph::~METISGraph()
-{
-}
+= default;
void METISGraph::partGraph(int ndomain,
const std::string& options_string,
- ParaDomainSelector *parallelizer)
+ ParaDomainSelector * /*parallelizer*/)
{
using std::vector;
if (MyGlobals::_Verbose>10)
//constraints
int * vwgt=_cell_weight;
int * adjwgt=_edge_weight;
- int wgtflag=(_edge_weight!=0)?1:0+(_cell_weight!=0)?2:0;
+ int wgtflag=(_edge_weight!=nullptr)?1:0+(_cell_weight!=nullptr)?2:0;
//base 0 or 1
int base=0;
//ndomain
{
public:
METISGraph();
- METISGraph(MEDCoupling::MEDCouplingSkyLineArray*, int *edgeweight=0);
- virtual ~METISGraph();
- void partGraph(int ndomain, const std::string& options_string="", ParaDomainSelector *sel=0);
+ METISGraph(MEDCoupling::MEDCouplingSkyLineArray*, int *edgeweight=nullptr);
+ ~METISGraph() override;
+ void partGraph(int ndomain, const std::string& options_string="", ParaDomainSelector *sel=nullptr) override;
};
}
//
#include "MEDPARTITIONER_PTScotchGraph.hxx"
+#include "MEDPARTITIONER_Graph.hxx"
#include "MEDPARTITIONER_Utils.hxx"
+#include "MCIdType.hxx"
#include "MEDCouplingSkyLineArray.hxx"
#include "MEDCouplingMemArray.hxx"
#include "MCType.hxx"
+#include "scotch.h"
#include <cstdio>
-#include <memory>
#include <mpi.h>
+#include <string>
#ifdef MED_ENABLE_PTSCOTCH
extern "C"
}
PTSCOTCHGraph::~PTSCOTCHGraph()
-{
-}
+= default;
-void PTSCOTCHGraph::partGraph(int ndomain, const std::string& options_string, ParaDomainSelector* sel)
+void PTSCOTCHGraph::partGraph(int ndomain, const std::string& options_string, ParaDomainSelector* /*sel*/)
{
if (MyGlobals::_Verbose>10)
std::cout << "proc " << MyGlobals::_Rank << " : PTSCOTCHGraph::partGraph" << std::endl;
//number of graph vertices
int n = FromIdType<int>(_graph->getNumberOf());
//graph
- mcIdType * xadj=const_cast<mcIdType*>(_graph->getIndex());
- mcIdType * adjncy=const_cast<mcIdType*>(_graph->getValues());
+ auto * xadj=const_cast<mcIdType*>(_graph->getIndex());
+ auto * adjncy=const_cast<mcIdType*>(_graph->getValues());
//ndomain
- int nparts=ndomain;
+ int const nparts=ndomain;
#if !defined(MED_ENABLE_PTSCOTCH)
throw INTERP_KERNEL::Exception("PTSCOTCHGraph::partGraph : PTSCOTCH is not available. Check your products, please.");
n, // vertlocnbr , nb of local graph nodes
n, // vertlocmax , should be set to vertlocnbr for graphs without holes
xadj, // vertloctab[vertnbr+1] , index vertex table
- 0, // vendloctab , index end vertex table if disjoint, set to zero
+ nullptr, // vendloctab , index end vertex table if disjoint, set to zero
cellWeightPtr, // veloloctab , graph vertices loads, set to zero
vlbloctab, // vlblocltab , vertex label array : global vertex index
xadj[n], // edgelocnbr , number of edges
xadj[n], // edgelocsiz , same as edgelocnbr if edgeloctab is compact
adjncy, // edgeloctab[edgelocnbr], global indexes of edges
- 0, // edgegsttab , optional, should be computed internally, set to zero
+ nullptr, // edgegsttab , optional, should be computed internally, set to zero
edgeWeightPtr); // edloloctab , graph edges loads, set to zero
SCOTCH_Strat scotch_strategy;
class MEDPARTITIONER_EXPORT PTSCOTCHGraph : public Graph
{
public:
- PTSCOTCHGraph() { }
- PTSCOTCHGraph(MEDCoupling::MEDCouplingSkyLineArray* , int *edgeweight=0, DataArrayIdType *vlbloctab=0);
- virtual ~PTSCOTCHGraph();
- void partGraph(int ndomain, const std::string& options_string="", ParaDomainSelector* sel=0);
+ PTSCOTCHGraph() = default;
+ PTSCOTCHGraph(MEDCoupling::MEDCouplingSkyLineArray* , int *edgeweight=nullptr, DataArrayIdType *vlbloctab=nullptr);
+ ~PTSCOTCHGraph() override;
+ void partGraph(int ndomain, const std::string& options_string="", ParaDomainSelector* sel=nullptr) override;
protected:
MEDCoupling::DataArrayIdType *_vlbloctab;
};
//
#include "MEDPARTITIONER_ParMetisGraph.hxx"
+#include "MCIdType.hxx"
#include "MEDPARTITIONER_ParaDomainSelector.hxx"
#include "MEDPARTITIONER_Utils.hxx"
#include "InterpKernelException.hxx"
#include <iostream>
+#include <string>
+#include <vector>
#ifdef MED_ENABLE_PARMETIS
#include <parmetis.h>
}
ParMETISGraph::~ParMETISGraph()
-{
-}
+= default;
void ParMETISGraph::partGraph(int ndomain,
- const std::string& options_string,
- ParaDomainSelector *parallelizer)
+ const std::string& /*options_string*/,
+ ParaDomainSelector * /*parallelizer*/)
{
using std::vector;
vector<int> ran,vx,va; //for randomize
std::cout << "proc " << MyGlobals::_Rank << " : ParMETISGraph::partGraph" << std::endl;
// number of graph vertices
- int n=FromIdType<int>(_graph->getNumberOf());
+ int const n=FromIdType<int>(_graph->getNumberOf());
//graph
#ifdef MEDCOUPLING_USE_64BIT_IDS
std::vector<int> indexVec( _graph->getIndex(), _graph->getIndexArray()->end() );
//constraints
int * vwgt=_cell_weight;
int * adjwgt=_edge_weight;
- int wgtflag=(_edge_weight!=0)?1:0+(_cell_weight!=0)?2:0;
+ int const wgtflag=(_edge_weight!=nullptr)?1:0+(_cell_weight!=nullptr)?2:0;
//base 0 or 1
- int base=0;
+ int const base=0;
//ndomain
- int nparts=ndomain;
+ int const nparts=ndomain;
//options
/*
(0=default_option,option,random_seed) see defs.h
#define PMV3_OPTION_PSR 3
seems no changes int options[4]={1,0,33,0}; //test for a random seed of 33
*/
- int options[4]={0,0,0,0};
+ int const options[4]={0,0,0,0};
// output parameters
int edgecut;
#if !defined(MED_ENABLE_PARMETIS)
{
public:
ParMETISGraph();
- ParMETISGraph(MEDCoupling::MEDCouplingSkyLineArray*, int *edgeweight=0);
- virtual ~ParMETISGraph();
- void partGraph(int ndomain, const std::string& options_string="", ParaDomainSelector *sel=0);
+ ParMETISGraph(MEDCoupling::MEDCouplingSkyLineArray*, int *edgeweight=nullptr);
+ ~ParMETISGraph() override;
+ void partGraph(int ndomain, const std::string& options_string="", ParaDomainSelector *sel=nullptr) override;
};
}
//
#include "MEDPARTITIONER_ParaDomainSelector.hxx"
-#include "MEDPARTITIONER_UserGraph.hxx"
+#include "MEDPARTITIONER_Graph.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MEDCouplingPointSet.hxx"
+#include "MEDCouplingMesh.hxx"
#include "MEDPARTITIONER_Utils.hxx"
#include "MEDPARTITIONER_Utils.hxx"
#include "MEDCouplingSkyLineArray.hxx"
#include "MCIdType.hxx"
+#include <cstddef>
#include <iostream>
-#include <numeric>
+#include <linux/sysinfo.h>
#ifdef HAVE_MPI
}
MEDPARTITIONER::ParaDomainSelector::~ParaDomainSelector()
-{
-}
+= default;
/*!
* \brief Return true if is running on different hosts
int size;
MPI_Get_processor_name( name_here, &size);
- int next_proc = (rank() + 1) % nbProcs();
- int prev_proc = (rank() - 1 + nbProcs()) % nbProcs();
- int tag = 1111111;
+ int const next_proc = (rank() + 1) % nbProcs();
+ int const prev_proc = (rank() - 1 + nbProcs()) % nbProcs();
+ int const tag = 1111111;
MPI_Status status;
MPI_Sendrecv((void*)&name_here[0], MPI_MAX_PROCESSOR_NAME, MPI_CHAR, next_proc, tag,
_nb_vert_of_procs[0] = 0; // base = 0
for (int i=0; i<nb_domains; ++i)
{
- int rankk = getProcessorID(i);
+ int const rankk = getProcessorID(i);
_nb_vert_of_procs[rankk+1] += all_nb_elems[i*2];
}
for (std::size_t i=1; i<_nb_vert_of_procs.size(); ++i)
*/
std::unique_ptr<MEDPARTITIONER::Graph> MEDPARTITIONER::ParaDomainSelector::gatherGraph(const Graph* graph) const
{
- Graph* glob_graph = 0;
+ Graph* glob_graph = nullptr;
evaluateMemory();
#ifdef HAVE_MPI
for ( std::size_t i = 1; i < _nb_vert_of_procs.size(); ++i )
index_size_of_proc[i-1] = FromIdType<int>(_nb_vert_of_procs[ i ] - _nb_vert_of_procs[ i-1 ]);
- mcIdType index_size = 1 + _cell_shift_by_domain.back();
- mcIdType *graph_index = new mcIdType[ index_size ];
+ mcIdType const index_size = 1 + _cell_shift_by_domain.back();
+ auto *graph_index = new mcIdType[ index_size ];
const mcIdType *index = graph->getGraph()->getIndex();
MCAuto< DataArrayInt > nb_vert_of_procs = FromIdTypeVec( _nb_vert_of_procs );
int *proc_index_displacement = nb_vert_of_procs->getPointer();
// update graph_index
for ( int i = 1; i < nbProcs(); ++i )
{
- mcIdType shift = graph_index[ proc_index_displacement[i]-1 ]-graph_index[0];
+ mcIdType const shift = graph_index[ proc_index_displacement[i]-1 ]-graph_index[0];
for ( int j = proc_index_displacement[i]; j < proc_index_displacement[i+1]; ++j )
graph_index[ j ] += shift;
}
// Gather values
// --------------
- mcIdType value_size = graph_index[ index_size-1 ] - graph_index[ 0 ];
- mcIdType *graph_value = new mcIdType[ value_size ];
+ mcIdType const value_size = graph_index[ index_size-1 ] - graph_index[ 0 ];
+ auto *graph_value = new mcIdType[ value_size ];
const mcIdType *value = graph->getGraph()->getValues();
MPI_Allgatherv((void*) value, // send local value
// Gather partition
// -----------------
- mcIdType * partition = new mcIdType[ _cell_shift_by_domain.back() ];
+ auto * partition = new mcIdType[ _cell_shift_by_domain.back() ];
const mcIdType* part = graph->getPart();
MPI_Allgatherv((void*) part, // send local partition
if ( _nb_cell_pairs_by_joint.empty() )
_nb_cell_pairs_by_joint.resize( _nb_result_domains*(_nb_result_domains+1), 0);
- int joint_id = jointId( loc_domain, dist_domain );
+ int const joint_id = jointId( loc_domain, dist_domain );
_nb_cell_pairs_by_joint[ joint_id ] = nb_cell_pairs;
}
evaluateMemory();
{
evaluateMemory();
- int joint_id = jointId( loc_domain, dist_domain );
+ int const joint_id = jointId( loc_domain, dist_domain );
return _nb_cell_pairs_by_joint[ joint_id ];
}
// (got in gatherNbOf( MED_FACE )).
evaluateMemory();
- mcIdType total_nb_faces = _face_shift_by_domain.empty() ? 0 : _face_shift_by_domain.back();
+ mcIdType const total_nb_faces = _face_shift_by_domain.empty() ? 0 : _face_shift_by_domain.back();
mcIdType id = total_nb_faces + 1;
if ( _nb_cell_pairs_by_joint.empty() )
throw INTERP_KERNEL::Exception("gatherNbCellPairs() must be called before");
- int joint_id = jointId( loc_domain, dist_domain );
+ int const joint_id = jointId( loc_domain, dist_domain );
for ( int j = 0; j < joint_id; ++j )
id += _nb_cell_pairs_by_joint[ j ];
{
int* loc_ids_dist = new int[ loc_ids_here.size()];
#ifdef HAVE_MPI
- int dest = getProcessorID( dist_domain );
- int tag = 2002 + jointId( loc_domain, dist_domain );
+ int const dest = getProcessorID( dist_domain );
+ int const tag = 2002 + jointId( loc_domain, dist_domain );
MPI_Status status;
MPI_Sendrecv((void*)&loc_ids_here[0], (int)loc_ids_here.size(), MPI_INT, dest, tag,
(void*) loc_ids_dist, (int)loc_ids_here.size(), MPI_INT, dest, tag,
if (mesh.getNumberOfCells()>0) //no sends if empty
{
- MEDCoupling::DataArrayIdType *v1Local=0;
- MEDCoupling::DataArrayDouble *v2Local=0;
+ MEDCoupling::DataArrayIdType *v1Local=nullptr;
+ MEDCoupling::DataArrayDouble *v2Local=nullptr;
//serialization of local mesh to send data to distant proc.
mesh.serialize(v1Local,v2Local);
int nbLocalElems=0;
- mcIdType* ptLocal=0;
+ mcIdType* ptLocal=nullptr;
if(v1Local) //if empty getNbOfElems() is 1!
{
nbLocalElems=FromIdType<int>(v1Local->getNbOfElems()); // if empty be 1!
}
MPI_Send(ptLocal, nbLocalElems, MPI_ID_TYPE, target, 1111, MPI_COMM_WORLD);
int nbLocalElems2=0;
- double *ptLocal2=0;
+ double *ptLocal2=nullptr;
if(v2Local) //if empty be 0!
{
nbLocalElems2=FromIdType<int>(v2Local->getNbOfElems());
mesh->resizeForUnserialization(tinyInfoDistant,v1Distant,v2Distant,unusedTinyDistantSts);
int nbDistElem=0;
- mcIdType *ptDist=0;
+ mcIdType *ptDist=nullptr;
if(v1Distant)
{
nbDistElem=FromIdType<int>(v1Distant->getNbOfElems());
ptDist=v1Distant->getPointer();
}
MPI_Recv(ptDist, nbDistElem, MPI_ID_TYPE, source,1111, MPI_COMM_WORLD, &status);
- double *ptDist2=0;
+ double *ptDist2=nullptr;
nbDistElem=0;
if(v2Distant)
{
int used_memory = 0;
#if !defined WIN32 && !defined __APPLE__
struct sysinfo si;
- int err = sysinfo( &si );
+ int const err = sysinfo( &si );
if ( !err )
used_memory = (int)(( si.totalram - si.freeram + si.totalswap - si.freeswap ) * si.mem_unit ) / 1024;
#endif
#ifndef __MEDPARTITIONER_PARADOMAINSELECTOR_HXX__
#define __MEDPARTITIONER_PARADOMAINSELECTOR_HXX__
+#include "MCIdType.hxx"
#include "MEDPARTITIONER.hxx"
-#include "MCType.hxx"
#include <memory>
#include <vector>
#include "InterpKernelHashMap.hxx"
#include "MCIdType.hxx"
-#include <set>
-#include <map>
+#include <cstddef>
+#include <utility>
#include <vector>
#include <iostream>
for (int idomain=0; idomain<_nb_domain; idomain++)
{
_loc_to_glob[idomain].resize(_nb_cells[idomain]);
- mcIdType domainCellShift=domainSelector->getDomainCellShift(idomain);
+ mcIdType const domainCellShift=domainSelector->getDomainCellShift(idomain);
for (mcIdType i=0; i<_nb_cells[idomain]; i++)
{
mcIdType global=domainCellShift+i ;
for (int idomain=0; idomain<_nb_domain; idomain++)
{
_node_loc_to_glob[idomain].resize(_nb_nodes[idomain]);
- mcIdType domainNodeShift=domainSelector->getDomainNodeShift(idomain);
+ mcIdType const domainNodeShift=domainSelector->getDomainNodeShift(idomain);
for (mcIdType i=0; i<_nb_nodes[idomain]; i++)
{
mcIdType global=domainNodeShift+i ;
_nb_domain=(int)meshes.size();
mcIdType index_global=0;
mcIdType index_node_global=0;
- mcIdType index_face_global=0;
+ mcIdType const index_face_global=0;
_nb_cells.resize(_nb_domain);
_nb_nodes.resize(_nb_domain);
for (mcIdType i=0; i< nb_node; i++)
{
mcIdType local= node_corresp[i*2];
- mcIdType distant = node_corresp[i*2+1];
+ mcIdType const distant = node_corresp[i*2+1];
local2distant.insert(std::make_pair(local, std::make_pair(distant_ip,distant)));
}
}
int icellProc=0; //all cells of my domains are concatenated in part
for (int iold=0; iold<oldTopology->nbDomain(); iold++)
{
- mcIdType ioldNbCell=oldTopology->getCellNumber(iold);
+ mcIdType const ioldNbCell=oldTopology->getCellNumber(iold);
//std::cout<<"proc "<<MyGlobals::_Rank<<" : cell number old domain "<<iold<<" : "<<ioldNbCell<<std::endl;
//if not my old domains getCellNumber is 0
std::vector<mcIdType> globalids(ioldNbCell);
int iGlobDom = FromIdType<int>(part[ iGlob ]);
for ( mcIdType i = index[ iGlob ]; i < index[ iGlob+1 ]; i++ )
{
- mcIdType iGlobNear = value[ i ];
+ mcIdType const iGlobNear = value[ i ];
if ( iGlob > iGlobNear )
continue; // treat ( iGlob, iGlobNear ) pair once
int iGlobNearDom = FromIdType<int>(part[ iGlobNear ]);
std::vector< mcIdType > & corresp = cellCorresp[ idomain ][ idomainNear ];
if ( corresp.empty() )
continue;
- MEDPARTITIONER::ConnectZone* cz = new MEDPARTITIONER::ConnectZone();
+ auto* cz = new MEDPARTITIONER::ConnectZone();
cz->setName( "Connect Zone defined by MEDPARTITIONER" );
cz->setDistantDomainNumber( idomainNear );
cz->setLocalDomainNumber ( idomain );
ParallelTopology::~ParallelTopology()
{
- for ( size_t i = 0; i < _connect_zones.size(); ++i )
+ for (auto & _connect_zone : _connect_zones)
{
- delete _connect_zones[i];
- _connect_zones[i] = 0;
+ delete _connect_zone;
+ _connect_zone = nullptr;
}
_connect_zones.clear();
}
for (mcIdType inode=0; inode<nbnodes; inode++)
{
// cout <<" inode :"<<inode<< " global = "<<type_connectivity[type][inode];
- mcIdType global = nodes[inode];
+ mcIdType const global = nodes[inode];
typedef INTERP_KERNEL::HashMultiMap<mcIdType,std::pair<int,mcIdType> >::iterator mmiter;
std::pair<mmiter,mmiter> range=_node_glob_to_loc.equal_range(global);
for (mmiter it=range.first; it !=range.second; it++)
#ifndef __MEDPARTITIONER_PARALLELTOPOLOGY_HXX__
#define __MEDPARTITIONER_PARALLELTOPOLOGY_HXX__
+#include "MCIdType.hxx"
#include "MEDPARTITIONER.hxx"
#include "MEDPARTITIONER_Topology.hxx"
#include "InterpKernelHashMap.hxx"
#include <set>
+#include <utility>
#include <vector>
namespace MEDPARTITIONER
std::vector<mcIdType*>&,
std::vector<mcIdType*>&);
ParallelTopology(Graph* graph, Topology* oldTopology, int nbdomain, int mesh_dimension);
- ~ParallelTopology();
+ ~ParallelTopology() override;
void setGlobalNumerotationDefault(ParaDomainSelector* domainSelector);
/*! converts a list of global cell numbers
* to a distributed array with local cell numbers
*/
- void convertGlobalNodeList(const mcIdType*, mcIdType,mcIdType*,int*);
- void convertGlobalNodeList(const mcIdType*, mcIdType,mcIdType*,int);
- void convertGlobalNodeListWithTwins(const mcIdType* face_list, mcIdType nbnode, mcIdType*& local, int*& ip, mcIdType*& full_array, mcIdType& size);
+ void convertGlobalNodeList(const mcIdType*, mcIdType,mcIdType*,int*) override;
+ void convertGlobalNodeList(const mcIdType*, mcIdType,mcIdType*,int) override;
+ void convertGlobalNodeListWithTwins(const mcIdType* face_list, mcIdType nbnode, mcIdType*& local, int*& ip, mcIdType*& full_array, mcIdType& size) override;
/*! converts a list of global node numbers
* to a distributed array with local cell numbers
*/
- void convertGlobalCellList(const mcIdType*, mcIdType , mcIdType*, int *);
+ void convertGlobalCellList(const mcIdType*, mcIdType , mcIdType*, int *) override;
/*! converts a list of global face numbers
* to a distributed array with local face numbers
*/
- void convertGlobalFaceList(const mcIdType*, mcIdType , mcIdType*, int *);
- void convertGlobalFaceList(const mcIdType*, mcIdType , mcIdType*, int);
- void convertGlobalFaceListWithTwins(const mcIdType* face_list, mcIdType nbface, mcIdType*& local, int*& ip, mcIdType*& full_array,mcIdType& size);
+ void convertGlobalFaceList(const mcIdType*, mcIdType , mcIdType*, int *) override;
+ void convertGlobalFaceList(const mcIdType*, mcIdType , mcIdType*, int) override;
+ void convertGlobalFaceListWithTwins(const mcIdType* face_list, mcIdType nbface, mcIdType*& local, int*& ip, mcIdType*& full_array,mcIdType& size) override;
/*! converting node global numberings to local numberings */
- void convertToLocal2ndVersion(mcIdType* nodes, mcIdType nbnodes, int idomain);
+ void convertToLocal2ndVersion(mcIdType* nodes, mcIdType nbnodes, int idomain) override;
/*! converting node local numbering to global */
- mcIdType convertNodeToGlobal(int ip, mcIdType icell) const { return _node_loc_to_glob[ip][icell]; }
+ mcIdType convertNodeToGlobal(int ip, mcIdType icell) const override { return _node_loc_to_glob[ip][icell]; }
/*! converting face local numbering to global */
- mcIdType convertFaceToGlobal(int ip, mcIdType iface) const { return _face_loc_to_glob[ip][iface]; }
+ mcIdType convertFaceToGlobal(int ip, mcIdType iface) const override { return _face_loc_to_glob[ip][iface]; }
/*! converting cell global numbering to local */
- mcIdType convertCellToGlobal(int ip, mcIdType icell) const { return _loc_to_glob[ip][icell]; }
+ mcIdType convertCellToGlobal(int ip, mcIdType icell) const override { return _loc_to_glob[ip][icell]; }
- void convertNodeToGlobal(int ip, const mcIdType* local, mcIdType n, mcIdType *global) const
+ void convertNodeToGlobal(int ip, const mcIdType* local, mcIdType n, mcIdType *global) const override
{
for (mcIdType i=0; i<n; i++)
global[i]=_node_loc_to_glob[ip][local[i]];
}
- void convertCellToGlobal(int ip, const mcIdType* local, mcIdType n, mcIdType *global) const
+ void convertCellToGlobal(int ip, const mcIdType* local, mcIdType n, mcIdType *global) const override
{
for (mcIdType i=0; i<n; i++)
global[i]=_loc_to_glob[ip][local[i]];
}
- void convertFaceToGlobal(int ip, const mcIdType* local, mcIdType n, mcIdType *global) const
+ void convertFaceToGlobal(int ip, const mcIdType* local, mcIdType n, mcIdType *global) const override
{
for (mcIdType i=0; i<n; i++)
global[i]=_face_loc_to_glob[ip][local[i]];
}
- int nbDomain() const { return _nb_domain; }
+ int nbDomain() const override { return _nb_domain; }
- mcIdType nbCells() const { return _nb_total_cells; }
+ mcIdType nbCells() const override { return _nb_total_cells; }
- mcIdType nbNodes() const { return _nb_total_nodes; }
+ mcIdType nbNodes() const override { return _nb_total_nodes; }
- mcIdType nbCells( int idomain) const { return _nb_cells[idomain]; }
+ mcIdType nbCells( int idomain) const override { return _nb_cells[idomain]; }
/*! retrieving number of nodes */
- mcIdType getNodeNumber(int idomain) const { return _nb_nodes[idomain]; }
+ mcIdType getNodeNumber(int idomain) const override { return _nb_nodes[idomain]; }
- mcIdType getNodeNumber() const;
+ mcIdType getNodeNumber() const override;
- void getNodeList(int idomain, mcIdType* list) const;
+ void getNodeList(int idomain, mcIdType* list) const override;
/*! retrieving cell numbers after merging in parallel mode */
- std::vector<mcIdType> & getFusedCellNumbers(int idomain) { return _cell_loc_to_glob_fuse[idomain]; }
+ std::vector<mcIdType> & getFusedCellNumbers(int idomain) override { return _cell_loc_to_glob_fuse[idomain]; }
- const std::vector<mcIdType>& getFusedCellNumbers(int idomain) const { return _cell_loc_to_glob_fuse[idomain]; }
+ const std::vector<mcIdType>& getFusedCellNumbers(int idomain) const override { return _cell_loc_to_glob_fuse[idomain]; }
/*! retrieving face numbers after merging in parallel mode */
- std::vector<mcIdType> & getFusedFaceNumbers(int idomain) { return _face_loc_to_glob_fuse[idomain]; }
+ std::vector<mcIdType> & getFusedFaceNumbers(int idomain) override { return _face_loc_to_glob_fuse[idomain]; }
- const std::vector<mcIdType>& getFusedFaceNumbers(int idomain) const { return _face_loc_to_glob_fuse[idomain]; }
+ const std::vector<mcIdType>& getFusedFaceNumbers(int idomain) const override { return _face_loc_to_glob_fuse[idomain]; }
/*! retrieving number of nodes */
- mcIdType getCellNumber(int idomain) const { return _nb_cells[idomain]; }
+ mcIdType getCellNumber(int idomain) const override { return _nb_cells[idomain]; }
mcIdType getCellDomainNumber(int global) const { return (_glob_to_loc.find(global)->second).first; }
- void getCellList(int idomain, mcIdType* list) const;
+ void getCellList(int idomain, mcIdType* list) const override;
- mcIdType getFaceNumber(int idomain) const { return _nb_faces[idomain]; }
+ mcIdType getFaceNumber(int idomain) const override { return _nb_faces[idomain]; }
- mcIdType getFaceNumber() const;
+ mcIdType getFaceNumber() const override;
- void getFaceList(int idomain, mcIdType* list) const;
+ void getFaceList(int idomain, mcIdType* list) const override;
/*! converting a global cell number to a local representation (domain + local number) */
- std::pair<int,mcIdType> convertGlobalCell(mcIdType iglobal) const { return _glob_to_loc.find(iglobal)->second; }
+ std::pair<int,mcIdType> convertGlobalCell(mcIdType iglobal) const override { return _glob_to_loc.find(iglobal)->second; }
- mcIdType convertGlobalFace(mcIdType iglobal, int idomain);
+ mcIdType convertGlobalFace(mcIdType iglobal, int idomain) override;
- mcIdType convertGlobalNode(mcIdType iglobal, int idomain);
+ mcIdType convertGlobalNode(mcIdType iglobal, int idomain) override;
- std::vector<MEDPARTITIONER::ConnectZone*>& getCZ();
+ std::vector<MEDPARTITIONER::ConnectZone*>& getCZ() override;
//adding a face to the topology
- void appendFace(int idomain, mcIdType ilocal, mcIdType iglobal);
+ void appendFace(int idomain, mcIdType ilocal, mcIdType iglobal) override;
//return max global face number
- mcIdType getMaxGlobalFace() const;
+ mcIdType getMaxGlobalFace() const override;
private:
bool hasCellWithNodes( const MeshCollection&, int dom, const std::set<mcIdType>& nodes );
private:
//mapping global -> local
- typedef INTERP_KERNEL::HashMultiMap<mcIdType,std::pair<int,mcIdType> > TGlob2DomainLoc;
+ using TGlob2DomainLoc = INTERP_KERNEL::HashMultiMap<mcIdType, std::pair<int, mcIdType>>;
TGlob2DomainLoc _glob_to_loc;
TGlob2DomainLoc _node_glob_to_loc;
std::vector<std::vector <mcIdType> > _face_loc_to_glob_fuse; // glob nums after merging
//mapping global -> local
- typedef INTERP_KERNEL::HashMultiMap<mcIdType,std::pair<int,mcIdType> > TGlob2LocsMap;
+ using TGlob2LocsMap = INTERP_KERNEL::HashMultiMap<mcIdType, std::pair<int, mcIdType>>;
TGlob2LocsMap _face_glob_to_loc;
//mapping local -> global
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+#include "MCIdType.hxx"
#include "MEDPARTITIONER_Graph.hxx"
#include "MEDPARTITIONER_ScotchGraph.hxx"
#include "MEDPARTITIONER_Utils.hxx"
#include "MEDCouplingSkyLineArray.hxx"
+#include <iostream>
#include <cstdio>
+#include <string>
+#include <vector>
#ifdef MED_ENABLE_SCOTCH
extern "C"
}
SCOTCHGraph::~SCOTCHGraph()
-{
-}
+= default;
-void SCOTCHGraph::partGraph(int ndomain, const std::string& options_string, ParaDomainSelector* sel)
+void SCOTCHGraph::partGraph(int ndomain, const std::string& options_string, ParaDomainSelector* /*sel*/)
{
if (MyGlobals::_Verbose>10)
std::cout << "proc " << MyGlobals::_Rank << " : SCOTCHGraph::partGraph" << std::endl;
//number of graph vertices
- int n = FromIdType<int>(_graph->getNumberOf());
+ int const n = FromIdType<int>(_graph->getNumberOf());
//graph
#ifdef MEDCOUPLING_USE_64BIT_IDS
std::vector<int> indexVec( _graph->getIndex(), _graph->getIndexArray()->end() );
int * adjncy=const_cast<int*>(_graph->getValues());
#endif
//ndomain
- int nparts=ndomain;
+ int const nparts=ndomain;
#if !defined(MED_ENABLE_SCOTCH)
throw INTERP_KERNEL::Exception("SCOTCHGraph::partGraph : SCOTCH is not available. Check your products, please.");
{
public:
SCOTCHGraph();
- SCOTCHGraph(MEDCoupling::MEDCouplingSkyLineArray*, int* edgeweight=0);
- virtual ~SCOTCHGraph();
- void partGraph(int ndomain, const std::string& options_string="", ParaDomainSelector* sel=0);
+ SCOTCHGraph(MEDCoupling::MEDCouplingSkyLineArray*, int* edgeweight=nullptr);
+ ~SCOTCHGraph() override;
+ void partGraph(int ndomain, const std::string& options_string="", ParaDomainSelector* sel=nullptr) override;
};
}
#ifndef __MEDPARTITIONER_TOPOLOGY_HXX__
#define __MEDPARTITIONER_TOPOLOGY_HXX__
+#include "MCIdType.hxx"
#include "MEDPARTITIONER.hxx"
-#include "MCType.hxx"
-#include <map>
+#include <utility>
#include <vector>
namespace MEDCoupling
class MEDPARTITIONER_EXPORT Topology
{
public:
- Topology() { }
+ Topology() = default;
Topology(std::vector<MEDCoupling::MEDCouplingUMesh*>, std::vector<MEDPARTITIONER::ConnectZone*>) { }
- virtual ~Topology() { }
+ virtual ~Topology() = default;
/*! converts a list of global cell numbers
* to a distributed array with local cell numbers
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+#include "MCIdType.hxx"
#include "MEDPARTITIONER_Graph.hxx"
#include "MEDPARTITIONER_UserGraph.hxx"
#include "MEDCouplingSkyLineArray.hxx"
#include <iostream>
+#include <string>
#include <vector>
using namespace MEDPARTITIONER;
* (domain numbers range from 0 to ndomain-1
* \param n number of cells in the mesh
*/
-UserGraph::UserGraph(MEDCoupling::MEDCouplingSkyLineArray *array, const int *partition, mcIdType n):Graph(array,0)
+UserGraph::UserGraph(MEDCoupling::MEDCouplingSkyLineArray *array, const int *partition, mcIdType n):Graph(array,nullptr)
{
std::vector<mcIdType> index(n+1),value(n);
}
UserGraph::~UserGraph()
-{
-}
+= default;
-void UserGraph::partGraph(int ndomain, const std::string& options, ParaDomainSelector* sel)
+void UserGraph::partGraph(int /*ndomain*/, const std::string& /*options*/, ParaDomainSelector* /*sel*/)
{
std::cerr << "MEDPARTITIONER::UserGraph::partGraph() should not have to be used" << std::endl;
}
#ifndef __MEDPARTITIONER_USERGRAPH_HXX__
#define __MEDPARTITIONER_USERGRAPH_HXX__
+#include "MCIdType.hxx"
#include "MEDPARTITIONER.hxx"
#include "MEDPARTITIONER_Graph.hxx"
{
public:
UserGraph(MEDCoupling::MEDCouplingSkyLineArray*, const int*, mcIdType);
- virtual ~UserGraph();
- void partGraph(int, const std::string& options=std::string(""), ParaDomainSelector *sel=0);
+ ~UserGraph() override;
+ void partGraph(int, const std::string& options=std::string(""), ParaDomainSelector *sel=nullptr) override;
};
}
#endif
#include "MEDPARTITIONER_Utils.hxx"
+#include "MCIdType.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "BBTree.txx"
#include "MEDLoader.hxx"
#include "MEDLoaderBase.hxx"
-#include "MEDFileUtilities.hxx"
-#include "CellModel.hxx"
#include "MEDCouplingUMesh.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "InterpKernelException.hxx"
#include "MCAuto.hxx"
#include "InterpKernelAutoPtr.hxx"
+#include "med.h"
+#include "medfile.h"
+#include "medfield.h"
-#include <fstream>
+#include <cstdlib>
+#include <algorithm>
#include <iostream>
#include <iomanip>
+#include <map>
#include <sstream>
#include <string>
#include <cstring>
+#include <vector>
+#include <utility>
using namespace MEDPARTITIONER;
srand( MyGlobals::_Randomize );
for (int i=0; i<size; i++)
{
- int ii=rand()%size;
- int tmp=res[ii];
+ int const ii=rand()%size;
+ int const tmp=res[ii];
res[ii]=res[i];
res[i]=tmp;
}
std::cerr << "MEDPARTITIONER::RandomizeAdj only works on one proc!" << std::endl;
return;
}
- std::size_t size=ran.size();
+ std::size_t const size=ran.size();
std::vector<int> invran(size);
for (unsigned int i=0; i<size; i++)
invran[ran[i]]=i;
vx.resize(size+1);
- int lga=xadj[size];
+ int const lga=xadj[size];
va.resize(lga);
int jj=0;
vx[0]=0;
for (std::size_t i=0; i<size; i++)
{
- int ir=ran[i];
+ int const ir=ran[i];
int ii=xadj[ir];
- int lgj=xadj[ir+1]-ii;
+ int const lgj=xadj[ir+1]-ii;
for (int j=0; j<lgj; j++)
{
va[jj]=invran[adjncy[ii]];
//int adjncy[13]={1,4,0,2,4,1,3,4,2,4,4,3,4};
int xadj[6]={0,2,5,9,12,13};
int adjncy[13]={0,0,1,1,1,2,2,2,2,3,3,3,4};
- int size=5;
+ int const size=5;
std::vector<int> r=CreateRandomSize(size);
std::vector<int> vx,va;
RandomizeAdj(&xadj[0],&adjncy[0],r,vx,va);
if (vec.size()==0)
return std::string(" NONE\n");
std::ostringstream oss;
- for (std::vector<std::string>::const_iterator i=vec.begin(); i!=vec.end(); ++i)
- oss << " -> '" << *i << "'" << std::endl;
+ for (const auto & i : vec)
+ oss << " -> '" << i << "'" << std::endl;
return oss.str();
}
if (vec.size()==0)
return std::string(" NONE\n");
std::ostringstream oss;
- for (std::vector<std::string>::const_iterator i=vec.begin(); i!=vec.end(); ++i)
- oss << separator << *i;
+ for (const auto & i : vec)
+ oss << separator << i;
return oss.str();
}
if (mymap.size()==0)
return std::string(" NONE\n");
std::ostringstream oss;
- for (std::map<std::string,mcIdType>::const_iterator i=mymap.begin(); i!=mymap.end(); ++i)
- oss << " -> [" << (*i).first << "]=" << (*i).second << std::endl;
+ for (const auto & i : mymap)
+ oss << " -> [" << i.first << "]=" << i.second << std::endl;
return oss.str();
}
if (mymap.size()==0)
return std::string(" NONE\n");
std::ostringstream oss;
- for (std::map< std::string,std::vector<std::string> >::const_iterator i=mymap.begin(); i!=mymap.end(); ++i)
- oss << " -> [" << (*i).first << "]=" << std::endl << ReprVectorOfString((*i).second) << std::endl;
+ for (const auto & i : mymap)
+ oss << " -> [" << i.first << "]=" << std::endl << ReprVectorOfString(i.second) << std::endl;
return oss.str();
}
if (vec.size()==0)
return std::string(" NONE\n");
std::ostringstream oss;
- for (std::vector<std::string>::const_iterator i=vec.begin(); i!=vec.end(); ++i)
+ for (const auto & i : vec)
{
oss << " ->";
- oss << ReprVectorOfString(DeserializeToVectorOfString(*i), separator) << std::endl;
+ oss << ReprVectorOfString(DeserializeToVectorOfString(i), separator) << std::endl;
}
return oss.str();
}
std::string MEDPARTITIONER::SerializeFromVectorOfString(const std::vector<std::string>& vec)
{
std::ostringstream oss;
- for (std::vector<std::string>::const_iterator i=vec.begin(); i!=vec.end(); ++i)
- oss<< std::setw(5) << (*i).size() << "/" << *i << "/";
+ for (const auto & i : vec)
+ oss<< std::setw(5) << i.size() << "/" << i << "/";
return oss.str();
}
{
std::vector<std::string> res;
std::size_t pos=0;
- std::size_t posmax=str.size();
+ std::size_t const posmax=str.size();
if (posmax==0)
return res; //empty vector
std::size_t length;
std::string MEDPARTITIONER::EraseTagSerialized(const std::string& fromStr, const std::string& tag)
{
- std::vector<std::string> vec=DeserializeToVectorOfString(fromStr);
+ std::vector<std::string> const vec=DeserializeToVectorOfString(fromStr);
std::vector<std::string> res;
- for (std::size_t i=0; i<vec.size(); i++)
+ for (const auto & i : vec)
{
- if (vec[i].find(tag)==std::string::npos)
- res.push_back(vec[i]);
+ if (i.find(tag)==std::string::npos)
+ res.push_back(i);
}
return MEDPARTITIONER::SerializeFromVectorOfString(res);
}
std::vector<std::string> MEDPARTITIONER::VectorizeFromMapOfStringInt(const std::map<std::string,mcIdType>& mymap)
{
std::vector<std::string> res;
- for (std::map<std::string,mcIdType>::const_iterator i=mymap.begin(); i!=mymap.end(); ++i)
+ for (const auto & i : mymap)
{
std::ostringstream oss;
- oss << (*i).second << "/" << (*i).first;
+ oss << i.second << "/" << i.first;
res.push_back(oss.str());
}
return res;
std::map<std::string,mcIdType> MEDPARTITIONER::DevectorizeToMapOfStringInt(const std::vector<std::string>& vec)
{
std::map<std::string,mcIdType> res;
- for (std::vector<std::string>::const_iterator i=vec.begin(); i!=vec.end(); ++i)
+ for (const auto & i : vec)
{
- std::size_t pos=0;
- std::size_t posmax=(*i).size();
- std::size_t found=(*i).find('/'); //first slash
+ std::size_t const pos=0;
+ std::size_t const posmax=i.size();
+ std::size_t const found=i.find('/'); //first slash
if ((found==std::string::npos) || (found<1))
throw INTERP_KERNEL::Exception("Error aIntNumber/anyString is expected");
mcIdType second;
- std::istringstream iss((*i).substr(pos,found));
+ std::istringstream iss(i.substr(pos,found));
iss >> second;
- std::string first=(*i).substr(pos+found+1,posmax-found);
- std::map<std::string,mcIdType>::iterator it=res.find(first);
+ std::string const first=i.substr(pos+found+1,posmax-found);
+ auto const it=res.find(first);
if (it!=res.end())
if ((*it).second!=second)
throw INTERP_KERNEL::Exception("Error not the same map value");
std::vector<std::string> MEDPARTITIONER::VectorizeFromMapOfStringVectorOfString(const std::map< std::string,std::vector<std::string> >& mymap)
{
std::vector<std::string> res;
- for (std::map< std::string,std::vector<std::string> >::const_iterator i=mymap.begin(); i!=mymap.end(); ++i)
+ for (const auto & i : mymap)
{
- std::vector<std::string> vs=(*i).second; //a vector of string;
+ std::vector<std::string> vs=i.second; //a vector of string;
std::ostringstream oss;
- oss << "Keymap/" << (*i).first << "/" << (*i).second.size();
+ oss << "Keymap/" << i.first << "/" << i.second.size();
vs.insert(vs.begin(), oss.str());
res.push_back(SerializeFromVectorOfString(vs));
}
std::map< std::string,std::vector<std::string> > MEDPARTITIONER::DevectorizeToMapOfStringVectorOfString(const std::vector<std::string>& vec)
{
std::map< std::string,std::vector<std::string> > res;
- for (std::vector<std::string>::const_iterator i=vec.begin(); i!=vec.end(); ++i)
+ for (const auto & i : vec)
{
- std::vector<std::string> vs=DeserializeToVectorOfString(*i);
+ std::vector<std::string> vs=DeserializeToVectorOfString(i);
- std::string enTete=vs[0];
- std::size_t posmax=enTete.size();
- std::size_t foundKey=enTete.find("Keymap/");
- std::size_t foundSizeVector=enTete.find_last_of('/');
+ std::string const enTete=vs[0];
+ std::size_t const posmax=enTete.size();
+ std::size_t const foundKey=enTete.find("Keymap/");
+ std::size_t const foundSizeVector=enTete.find_last_of('/');
if ((foundKey==std::string::npos) || (foundKey!=0) || ((foundKey+7)>=foundSizeVector))
throw INTERP_KERNEL::Exception("Error Keymap/anyString/aIntNumber is expected");
int sizeVector;
std::istringstream iss(enTete.substr(foundSizeVector+1,posmax-foundSizeVector));
iss >> sizeVector;
- std::string keymap=enTete.substr(foundKey+7,foundSizeVector-foundKey-7);
+ std::string const keymap=enTete.substr(foundKey+7,foundSizeVector-foundKey-7);
for (int ii=1; ii<=sizeVector; ii++)
res[keymap].push_back(vs[ii]); //add unconditionally,so merge duplicates in second vector
}
std::vector<std::string> res;
if (vec.size()==0)
return res;
- for (std::vector<std::string>::const_iterator i=vec.begin(); i!=vec.end(); ++i)
+ for (const auto & i : vec)
{
- if ((*i).find(tag)!=std::string::npos) res.push_back(*i);
+ if (i.find(tag)!=std::string::npos) res.push_back(i);
}
return res;
}
if (vec.size()==0) return res;
//shit for unique and unique_copy for the duplicate CONSECUTIVE elements
//I do not want to sort
- for (std::vector<std::string>::const_iterator i=vec.begin(); i!=vec.end(); ++i)
+ for (const auto & i : vec)
{
bool found=false;
- for (std::vector<std::string>::const_iterator j=res.begin(); j!=res.end(); ++j)
+ for (const auto & re : res)
{
- if ((*i).compare(*j)==0)
+ if (i.compare(re)==0)
{
found=true;
break;
}
}
- if (!found) res.push_back(*i);
+ if (!found) res.push_back(i);
}
return res;
}
std::map< std::string,std::vector<std::string> > MEDPARTITIONER::DeleteDuplicatesInMapOfStringVectorOfString(const std::map< std::string,std::vector<std::string> >& mymap)
{
std::map< std::string,std::vector<std::string> > res;
- for (std::map< std::string,std::vector<std::string> >::const_iterator i=mymap.begin(); i!=mymap.end(); ++i)
- res[(*i).first]=DeleteDuplicatesInVectorOfString((*i).second);
+ for (const auto & i : mymap)
+ res[i.first]=DeleteDuplicatesInVectorOfString(i.second);
return res;
}
void MEDPARTITIONER::Cle1ToData(const std::string& key, std::string& s, int& inew)
{
- std::size_t posmax=key.size();
- std::size_t found=key.find(' ');
+ std::size_t const posmax=key.size();
+ std::size_t const found=key.find(' ');
if ((found==std::string::npos) || (found<1))
throw INTERP_KERNEL::Exception("Error 'aStringWithoutWhitespace aInt' is expected");
s=key.substr(0,found);
void MEDPARTITIONER::Cle2ToData(const std::string& key, std::string& s, int& inew, int& iold)
{
- std::size_t posmax=key.size();
- std::size_t found=key.find(' ');
+ std::size_t const posmax=key.size();
+ std::size_t const found=key.find(' ');
if ((found==std::string::npos) || (found<1))
throw INTERP_KERNEL::Exception("Error 'aStringWithoutWhitespace aInt aInt' is expected");
s=key.substr(0,found);
res=res.substr(0,found);
return res;
}
- std::size_t lg=StrToInt(description.substr(found-6,found));
+ std::size_t const lg=StrToInt(description.substr(found-6,found));
beg+=tag.length();
return description.substr(beg,lg-tag.length());
}
std::vector<std::string> res;
if (fd->getArray())
{
- std::size_t nb=fd->getArray()->getNumberOfComponents();
+ std::size_t const nb=fd->getArray()->getNumberOfComponents();
res.push_back("nbComponents="); res.back()+=IntToStr((int)nb);
for (unsigned int i=0; i<nb; i++)
{
std::vector<std::string> MEDPARTITIONER::BrowseAllFields(const std::string& myfile)
{
std::vector<std::string> res;
- std::vector<std::string> meshNames=MEDCoupling::GetMeshNames(myfile);
+ std::vector<std::string> const meshNames=MEDCoupling::GetMeshNames(myfile);
- for (std::size_t i=0; i<meshNames.size(); i++)
+ for (const auto & meshName : meshNames)
{
- std::vector<std::string> fieldNames=
- MEDCoupling::GetAllFieldNamesOnMesh(myfile,meshNames[i]);
- for (std::size_t j = 0; j < fieldNames.size(); j++)
+ std::vector<std::string> const fieldNames=
+ MEDCoupling::GetAllFieldNamesOnMesh(myfile,meshName);
+ for (const auto & fieldName : fieldNames)
{
- std::vector< MEDCoupling::TypeOfField > typeFields=
- MEDCoupling::GetTypesOfField(myfile, meshNames[i], fieldNames[j]);
- for (std::size_t k = 0; k < typeFields.size(); k++)
+ std::vector< MEDCoupling::TypeOfField > const typeFields=
+ MEDCoupling::GetTypesOfField(myfile, meshName, fieldName);
+ for (auto & typeField : typeFields)
{
- std::vector< std::pair< int, int > > its=
- GetFieldIterations(typeFields[k], myfile, meshNames[i], fieldNames[j]);
+ std::vector< std::pair< int, int > > const its=
+ GetFieldIterations(typeField, myfile, meshName, fieldName);
if (MyGlobals::_Is0verbose>100)
- std::cout<< "fieldName " << fieldNames[j] << " typeField " << typeFields[k] << " its.size() " << its.size() << std::endl;
- for (std::size_t m = 0; m < its.size(); m++)
+ std::cout<< "fieldName " << fieldName << " typeField " << typeField << " its.size() " << its.size() << std::endl;
+ for (auto & it : its)
{
std::vector<std::string> resi;
resi.push_back("fileName="); resi.back()+=myfile;
- resi.push_back("meshName="); resi.back()+=meshNames[i];
- resi.push_back("fieldName="); resi.back()+=fieldNames[j];
- resi.push_back("typeField="); resi.back()+=IntToStr((int)typeFields[k]);
- resi.push_back("DT="); resi.back()+=IntToStr((int)its[m].first);
- resi.push_back("IT="); resi.back()+=IntToStr((int)its[m].second);
+ resi.push_back("meshName="); resi.back()+=meshName;
+ resi.push_back("fieldName="); resi.back()+=fieldName;
+ resi.push_back("typeField="); resi.back()+=IntToStr((int)typeField);
+ resi.push_back("DT="); resi.back()+=IntToStr((int)it.first);
+ resi.push_back("IT="); resi.back()+=IntToStr((int)it.second);
res.push_back(SerializeFromVectorOfString(resi));
}
}
return res;
}
-std::vector<std::string> MEDPARTITIONER::GetInfosOfField(const char *fileName, const char *meshName, const int idomain)
+std::vector<std::string> MEDPARTITIONER::GetInfosOfField(const char *fileName, const char * /*meshName*/, const int idomain)
{
const int lggeom=10;
const med_geometry_type GEOMTYPE[lggeom]={ //MED_N_CELL_FIXED_GEO] = {
};
std::vector<std::string> res;
- med_idt fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
- med_int nbFields=MEDnField(fid);
+ med_idt const fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
+ med_int const nbFields=MEDnField(fid);
if (MyGlobals::_Verbose>20)
std::cout << "on filename " << fileName << " nbOfField " << nbFields << std::endl;
//
//
for(int i=1; i<=nbFields; i++)
{
- med_int ncomp=MEDfieldnComponent(fid,i);
+ med_int const ncomp=MEDfieldnComponent(fid,i);
INTERP_KERNEL::AutoPtr<char> comp=new char[ncomp*MED_SNAME_SIZE+1];
INTERP_KERNEL::AutoPtr<char> unit=new char[ncomp*MED_SNAME_SIZE+1];
INTERP_KERNEL::AutoPtr<char> dt_unit=new char[MED_LNAME_SIZE+1];
med_int nbPdt;
MEDfieldInfo(fid,i,nomcha,maa_ass,&localmesh,&typcha,comp,unit,dt_unit,&nbPdt);
- std::string curFieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE+1);
- std::string curMeshName=MEDLoaderBase::buildStringFromFortran(maa_ass,MED_NAME_SIZE+1);
+ std::string const curFieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE+1);
+ std::string const curMeshName=MEDLoaderBase::buildStringFromFortran(maa_ass,MED_NAME_SIZE+1);
for (int k=1; k<=nbPdt; k++)
{
MEDfieldComputingStepInfo(fid,nomcha,k,&numdt,&numo,&dt);
for (int j=0; j<lggeom; j++)
{
med_int profilesize=0,nbi=0;
- med_entity_type enttype=ENTITYTYPE[ie];
+ med_entity_type const enttype=ENTITYTYPE[ie];
//enttype=MED_NODE;enttype=MED_CELL;enttype=MED_NODE_ELEMENT;
char pflname[MED_NAME_SIZE+1]="";
char locname[MED_NAME_SIZE+1]="";
- med_int nbofprofile=MEDfieldnProfile(fid,nomcha,numdt,numo,enttype,GEOMTYPE[j],pflname,locname);
- int profileit=1;
+ med_int const nbofprofile=MEDfieldnProfile(fid,nomcha,numdt,numo,enttype,GEOMTYPE[j],pflname,locname);
+ int const profileit=1;
if (enttype==MED_NODE)
{
- med_geometry_type mygeomtype=MED_UNDEF_ENTITY_TYPE;
- med_int nbOfVal=MEDfieldnValueWithProfile(fid,nomcha,numdt,numo,enttype,mygeomtype,profileit,
+ med_geometry_type const mygeomtype=MED_UNDEF_ENTITY_TYPE;
+ med_int const nbOfVal=MEDfieldnValueWithProfile(fid,nomcha,numdt,numo,enttype,mygeomtype,profileit,
MED_COMPACT_PFLMODE,pflname,&profilesize,locname,&nbi);
if (nbOfVal>0)
{
}
else
{
- med_geometry_type mygeomtype=GEOMTYPE[j];
- med_int nbOfVal=MEDfieldnValueWithProfile(fid,nomcha,numdt,numo,enttype,mygeomtype,profileit,
+ med_geometry_type const mygeomtype=GEOMTYPE[j];
+ med_int const nbOfVal=MEDfieldnValueWithProfile(fid,nomcha,numdt,numo,enttype,mygeomtype,profileit,
MED_COMPACT_PFLMODE,pflname,&profilesize,locname,&nbi);
if (nbOfVal>0)
{
_PgetIntersectingElems = & BBTreeOfDim::_getIntersectingElems< 1 >;
break;
default:
- _tree=0;
+ _tree=nullptr;
throw INTERP_KERNEL::Exception("BBTreeOfDim(): wrong space dimension");
}
}
void BBTreeOfDim::getElementsAroundPoint( const double* coordsPtr,
std::vector<mcIdType>& elems ) const
{
- BBTreeOfDim* me = (BBTreeOfDim*) this;
+ auto* me = (BBTreeOfDim*) this;
(me->*_PgetElementsAroundPoint) ( coordsPtr, elems );
}
void BBTreeOfDim::getIntersectingElems(const double* bb,
std::vector<mcIdType>& elems) const
{
- BBTreeOfDim* me = (BBTreeOfDim*) this;
+ auto* me = (BBTreeOfDim*) this;
(me->*_PgetIntersectingElems) ( bb, elems );
}
}
#ifndef __MEDPARTITIONER_UTILS_HXX__
#define __MEDPARTITIONER_UTILS_HXX__
+#include "MCIdType.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MEDCouplingMesh.hxx"
+#include "MCAuto.hxx"
#include "MEDPARTITIONER.hxx"
#include "MEDCouplingUMesh.hxx"
#include "BBTree.txx"
+#include <cstddef>
#include <string>
#include <vector>
#include <map>
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+#include "MCType.hxx"
+#include "MEDCouplingMemArray.hxx"
#include "MEDPARTITIONER_Utils.hxx"
#include "MEDLoader.hxx"
-#include "MEDLoaderBase.hxx"
-#include "MEDFileUtilities.hxx"
-#include "CellModel.hxx"
-#include "MEDCouplingUMesh.hxx"
-#include "MEDCouplingFieldDouble.hxx"
#include "InterpKernelException.hxx"
-#include "MCAuto.hxx"
-#include "MEDCouplingMemArray.txx"
-#include "InterpKernelAutoPtr.hxx"
-#include <fstream>
+#include <cstddef>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <string>
+#include <vector>
#ifdef HAVE_MPI
*/
std::vector<std::string> MEDPARTITIONER::SendAndReceiveVectorOfString(const std::vector<std::string>& vec, const int source, const int target)
{
- int rank=MyGlobals::_Rank;
+ int const rank=MyGlobals::_Rank;
MPI_Status status;
- int tag = 111001;
+ int const tag = 111001;
if (rank == source)
{
- std::string str=SerializeFromVectorOfString(vec);
- int size=(int)str.length();
+ std::string const str=SerializeFromVectorOfString(vec);
+ int const size=(int)str.length();
MPI_Send( &size, 1, MPI_INT, target, tag, MPI_COMM_WORLD );
MPI_Send( (void*)str.data(), (int)str.length(), MPI_CHAR, target, tag+100, MPI_COMM_WORLD );
}
if (rank == target)
{
MPI_Recv(&recSize, 1, MPI_INT, source, tag, MPI_COMM_WORLD, &status);
- std::string recData(recSize,'x');
+ std::string const recData(recSize,'x');
MPI_Recv((void*)recData.data(), recSize, MPI_CHAR, source, tag+100, MPI_COMM_WORLD, &status);
return DeserializeToVectorOfString(recData); //not empty one for target proc
}
if (MyGlobals::_World_Size==1) //nothing to do
return vec;
- int world_size=MyGlobals::_World_Size;
+ int const world_size=MyGlobals::_World_Size;
std::string str=SerializeFromVectorOfString(vec);
std::vector<int> indexes(world_size);
- int size=(int)str.length();
+ int const size=(int)str.length();
MPI_Allgather(&size, 1, MPI_INT,
&indexes[0], 1, MPI_INT, MPI_COMM_WORLD);
*/
void MEDPARTITIONER::SendDoubleVec(const std::vector<double>& vec, const int target)
{
- int tag = 111002;
+ int const tag = 111002;
int size=(int)vec.size();
if (MyGlobals::_Verbose>1000)
std::cout << "proc " << MyGlobals::_Rank << " : --> SendDoubleVec " << size << std::endl;
*/
std::vector<double>* MEDPARTITIONER::RecvDoubleVec(const int source)
{
- int tag = 111002;
+ int const tag = 111002;
int size;
#ifdef HAVE_MPI
MPI_Status status;
void MEDPARTITIONER::RecvDoubleVec(std::vector<double>& vec, const int source)
{
- int tag = 111002;
+ int const tag = 111002;
int size;
#ifdef HAVE_MPI
MPI_Status status;
*/
void MEDPARTITIONER::SendIntVec(const std::vector<mcIdType>& vec, const int target)
{
- int tag = 111003;
+ int const tag = 111003;
int size=(int)vec.size();
if (MyGlobals::_Verbose>1000)
std::cout << "proc " << MyGlobals::_Rank << " : --> SendIntVec " << size << std::endl;
*/
std::vector<int> *MEDPARTITIONER::RecvIntVec(const int source)
{
- int tag = 111003;
+ int const tag = 111003;
int size;
#ifdef HAVE_MPI
MPI_Status status;
void MEDPARTITIONER::RecvIntVec(std::vector<mcIdType>& vec, const int source)
{
- int tag = 111003;
+ int const tag = 111003;
int size;
#ifdef HAVE_MPI
MPI_Status status;
*/
void MEDPARTITIONER::SendDataArrayInt(const MEDCoupling::DataArrayInt *da, const int target)
{
- if (da==0)
+ if (da==nullptr)
throw INTERP_KERNEL::Exception("Problem send DataArrayInt* NULL");
- int tag = 111004;
+ int const tag = 111004;
int size[3];
size[0]=(int)da->getNbOfElems();
size[1]=(int)da->getNumberOfTuples();
*/
MEDCoupling::DataArrayInt *MEDPARTITIONER::RecvDataArrayInt(const int source)
{
- int tag = 111004;
+ int const tag = 111004;
int size[3];
#ifdef HAVE_MPI
MPI_Status status;
*/
void MEDPARTITIONER::SendDataArrayDouble(const MEDCoupling::DataArrayDouble *da, const int target)
{
- if (da==0)
+ if (da==nullptr)
throw INTERP_KERNEL::Exception("Problem send DataArrayDouble* NULL");
- int tag = 111005;
+ int const tag = 111005;
int size[3];
size[0]=(int)da->getNbOfElems();
size[1]=(int)da->getNumberOfTuples();
*/
MEDCoupling::DataArrayDouble* MEDPARTITIONER::RecvDataArrayDouble(const int source)
{
- int tag = 111005;
+ int const tag = 111005;
int size[3];
#ifdef HAVE_MPI
MPI_Status status;
void MEDPARTITIONER::TestMapOfStringIntMpi()
{
- int rank=MyGlobals::_Rank;
+ int const rank=MyGlobals::_Rank;
std::map<std::string,mcIdType> myMap;
myMap["one"]=1;
myMap["two"]=22; //a bug
void MEDPARTITIONER::TestMapOfStringVectorOfStringMpi()
{
- int rank=MyGlobals::_Rank;
+ int const rank=MyGlobals::_Rank;
std::vector<std::string> myVector;
std::ostringstream oss;
oss << "hello from " << std::setw(5) << MyGlobals::_Rank << " " << std::string(rank+1,'n') << " next is an empty one";
void MEDPARTITIONER::TestDataArrayMpi()
{
- int rank=MyGlobals::_Rank;
+ int const rank=MyGlobals::_Rank;
//int
{
MEDCoupling::DataArrayInt* send=MEDCoupling::DataArrayInt::New();
- MEDCoupling::DataArrayInt* recv=0;
- int nbOfTuples=5;
- int numberOfComponents=3;
+ MEDCoupling::DataArrayInt* recv=nullptr;
+ int const nbOfTuples=5;
+ int const numberOfComponents=3;
send->alloc(nbOfTuples,numberOfComponents);
std::vector<int> vals;
for (int j=0; j<nbOfTuples; j++)
//double
{
MEDCoupling::DataArrayDouble* send=MEDCoupling::DataArrayDouble::New();
- MEDCoupling::DataArrayDouble* recv=0;
- int nbOfTuples=5;
- int numberOfComponents=3;
+ MEDCoupling::DataArrayDouble* recv=nullptr;
+ int const nbOfTuples=5;
+ int const numberOfComponents=3;
send->alloc(nbOfTuples,numberOfComponents);
std::vector<double> vals;
for (int j=0; j<nbOfTuples; j++)
void MEDPARTITIONER::TestPersistantMpi0To1(int taille, int nb)
{
double temps_debut=MPI_Wtime();
- int rank=MyGlobals::_Rank;
+ int const rank=MyGlobals::_Rank;
std::vector<int> x, y;
- int tag=111111;
+ int const tag=111111;
MPI_Request requete0, requete1;
MPI_Status statut;
int ok=0;
void MEDPARTITIONER::TestPersistantMpiRingOnCommSplit(int size, int nb)
{
double temps_debut=MPI_Wtime();
- int rank=MyGlobals::_Rank;
+ int const rank=MyGlobals::_Rank;
MPI_Comm newcomm;
int color=1;
- int rankMax=4;
+ int const rankMax=4;
if (rank>=rankMax)
color=MPI_UNDEFINED;
//MPI_Comm_dup (MPI_COMM_WORLD, &newcomm) ;
#include "MEDPARTITIONERTest.hxx"
+#include "MCIdType.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MCType.hxx"
+#include "MCAuto.hxx"
#include "MEDPARTITIONER_MeshCollection.hxx"
#include "MEDPARTITIONER_ParallelTopology.hxx"
#include "MEDPARTITIONER_ParaDomainSelector.hxx"
#include "CellModel.hxx"
#include "MEDFileMesh.hxx"
#include "MEDLoader.hxx"
-#include "MEDLoaderBase.hxx"
#include "MEDCouplingUMesh.hxx"
#include "MEDCouplingMappedExtrudedMesh.hxx"
#include "MEDCouplingFieldDouble.hxx"
-#include "MEDCouplingMemArray.hxx"
+#include "MEDCouplingMemArray.txx"
#include "MEDCouplingMultiFields.hxx"
+#include "NormalizedGeometricTypes"
#include <cppunit/TestAssert.h>
-#include <sstream>
+#include <iostream>
+#include <memory>
#include <fstream>
#include <cmath>
-#include <list>
-#include <stdexcept>
#include <cstdlib>
+#include <string>
#include <vector>
#ifdef WIN32
#include<direct.h>
if (my_file.good())
return execName;
}
- execName = getcwd(NULL, 0);
+ execName = getcwd(nullptr, 0);
#ifndef WIN32
execName += "/../../MEDPartitioner/medpartitioner";
#else
std::copy(conn.begin()+i*8,conn.begin()+(i+1)*8,onehexa);
if (false) //(_verbose)
{
- for (int j=0; j<8; j++) cout<<onehexa[j]<<" ";
+ for (long const j : onehexa) cout<<j<<" ";
cout<<endl;
}
mesh->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,onehexa);
for (int j=0; j<=_nj; j++)
for (int i=0; i<=_ni; i++)
{
- int k=j;
+ int const k=j;
coor.push_back(i+.1);
coor.push_back(j+.2);
coor.push_back(k+.3);
}
int ii;
- int k=0;
+ int const k=0;
for (int j=0; j<_nj; j++)
for (int i=0; i<_ni; i++)
{
std::copy(conn.begin()+i*4,conn.begin()+(i+1)*4,onequa);
if (false) //(_verbose)
{
- for (int j=0; j<4; j++) cout<<onequa[j]<<" ";
+ for (long const j : onequa) cout<<j<<" ";
cout<<endl;
}
mesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,onequa);
for (int j=0; j<=_nj; j++)
for (int i=0; i<=_ni; i++)
{
- int k=0;
+ int const k=0;
coor.push_back(i+.1);
coor.push_back(j+.2);
coor.push_back(k+.3);
}
int ii;
- int k=0;
+ int const k=0;
for (int j=0; j<_nj; j++)
for (int i=0; i<_ni; i++)
{
std::copy(conn.begin()+i*4,conn.begin()+(i+1)*4,onequa);
if (false) //(_verbose)
{
- for (int j=0; j<4; j++) cout<<onequa[j]<<" ";
+ for (long const j : onequa) cout<<j<<" ";
cout<<endl;
}
mesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,onequa);
}
MEDCouplingUMesh *mesh=ReadUMeshFromFile(myfileName.c_str(),_mesh_name.c_str(),0);
- mcIdType nbOfCells=mesh->getNumberOfCells();
+ mcIdType const nbOfCells=mesh->getNumberOfCells();
MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
f1->setName("VectorFieldOnCells");
f1->setDescription("DescriptionOfFieldOnCells"); //not saved in file?
}
MEDCouplingUMesh *mesh=ReadUMeshFromFile(_file_name.c_str(),_mesh_name.c_str(),0);
- mcIdType nbOfNodes=mesh->getNumberOfNodes();
+ mcIdType const nbOfNodes=mesh->getNumberOfNodes();
MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME);
f1->setName("VectorFieldOnNodes");
f1->setDescription("DescriptionOfFieldOnNodes"); //not saved in file?
DataArrayDouble* coords=mesh->getCoords();
//int nbOfComp=coords->getNumberOfComponents(); //be 3D
- mcIdType nbOfTuple=coords->getNumberOfTuples();
+ mcIdType const nbOfTuple=coords->getNumberOfTuples();
double* ptr=coords->getPointer();
double* ptrini=ptrInit;
for (mcIdType i=0; i<nbOfTuple; i++)
//more nbptgauss=8 by default needs set MEDCouplingFieldDiscretizationPerCell
//theory: (may be) http://www.code-aster.org/V2/doc/v9/fr/man_r/r3/r3.06.03.pdf
- int nbptgauss=8; //nb pt de gauss by cell
- mcIdType nbcell=f3->getMesh()->getNumberOfCells();
- mcIdType nb=nbcell*nbptgauss;
- int nbcomp=2;
+ int const nbptgauss=8; //nb pt de gauss by cell
+ mcIdType const nbcell=f3->getMesh()->getNumberOfCells();
+ mcIdType const nb=nbcell*nbptgauss;
+ int const nbcomp=2;
array->alloc(nb,nbcomp);
double *ptr=array->getPointer();
int ii=0;
createTestMeshes();
MyGlobals::_World_Size=1;
MyGlobals::_Rank=0;
- string fileName=_file_name_with_faces;
+ string const fileName=_file_name_with_faces;
MEDPARTITIONER::ParaDomainSelector parallelizer(false);
- MEDPARTITIONER::MeshCollection collection(fileName,parallelizer);
+ MEDPARTITIONER::MeshCollection const collection(fileName,parallelizer);
CPPUNIT_ASSERT(collection.isParallelMode());
CPPUNIT_ASSERT_EQUAL(3, collection.getMeshDimension());
CPPUNIT_ASSERT(collection.getName()=="testMesh");
{
setSmallSize();
createHugeTestMesh(_ni, _nj, _nk, 2, 2, 2, 32); //xml but not so huge
- string fileName=_file_name_huge_xml;
+ string const fileName=_file_name_huge_xml;
MEDPARTITIONER::ParaDomainSelector parallelizer(false);
- MEDPARTITIONER::MeshCollection collection(fileName,parallelizer);
+ MEDPARTITIONER::MeshCollection const collection(fileName,parallelizer);
CPPUNIT_ASSERT(collection.isParallelMode());
CPPUNIT_ASSERT_EQUAL(3, collection.getMeshDimension());
CPPUNIT_ASSERT(collection.getName()=="testMesh");
setSmallSize();
createTestMeshes();
//MyGlobals::_Verbose=500;
- string fileName=_file_name_with_faces;
- int ndomains=2;
+ string const fileName=_file_name_with_faces;
+ int const ndomains=2;
bool split_family=false;
bool empty_groups=false;
MEDPARTITIONER::ParaDomainSelector parallelizer(false);
MEDPARTITIONER::MeshCollection collection(fileName,parallelizer);
- MEDPARTITIONER::ParallelTopology* aPT = (MEDPARTITIONER::ParallelTopology*) collection.getTopology();
+ auto* aPT = (MEDPARTITIONER::ParallelTopology*) collection.getTopology();
aPT->setGlobalNumerotationDefault(collection.getParaDomainSelector());
//Creating the graph and partitioning it
auto_ptr< MEDPARTITIONER::Topology > new_topo;
{
setSmallSize();
createHugeTestMesh(_ni, _nj, _nk, 2, 2, 2, 32); //xml on 2*2*2 meshes but not so huge
- string fileName=_file_name_huge_xml;
+ string const fileName=_file_name_huge_xml;
bool split_family=false;
bool empty_groups=false;
MEDPARTITIONER::ParaDomainSelector parallelizer(false);
MEDPARTITIONER::MeshCollection collection(fileName,parallelizer);
- MEDPARTITIONER::ParallelTopology* aPT = (MEDPARTITIONER::ParallelTopology*) collection.getTopology();
+ auto* aPT = (MEDPARTITIONER::ParallelTopology*) collection.getTopology();
aPT->setGlobalNumerotationDefault(collection.getParaDomainSelector());
for (int ndomains=2 ; ndomains<=16 ; ndomains++)
//#if !defined(HAVE_MPI)
setSmallSize();
createTestMeshes();
- std::string MetisOrScotch("metis");
+ std::string const MetisOrScotch("metis");
launchMetisOrScotchMedpartitionerOnTestMeshes(MetisOrScotch);
verifyMetisOrScotchMedpartitionerOnSmallSizeForMesh(MetisOrScotch);
verifyMetisOrScotchMedpartitionerOnSmallSizeForFieldOnCells(MetisOrScotch);
std::vector<MEDCoupling::MEDCouplingUMesh*>cellMeshes=collection.getMesh();
CPPUNIT_ASSERT_EQUAL(5, (int) cellMeshes.size());
mcIdType nbcells=0;
- for (std::size_t i = 0; i < cellMeshes.size(); i++)
- nbcells+=cellMeshes[i]->getNumberOfCells();
+ for (auto & cellMeshe : cellMeshes)
+ nbcells+=cellMeshe->getNumberOfCells();
CPPUNIT_ASSERT_EQUAL(cellMesh->getNumberOfCells(), nbcells);
std::vector<MEDCoupling::MEDCouplingUMesh*>faceMeshes=collection.getFaceMesh();
CPPUNIT_ASSERT_EQUAL(5, (int) faceMeshes.size());
mcIdType nbfaces=0;
- for (std::size_t i=0; i < faceMeshes.size(); i++)
- nbfaces+=faceMeshes[i]->getNumberOfCells();
+ for (auto & faceMeshe : faceMeshes)
+ nbfaces+=faceMeshe->getNumberOfCells();
CPPUNIT_ASSERT_EQUAL(faceMesh->getNumberOfCells(), nbfaces);
//merge split meshes and test equality
mcIdType* pc=corr[1]->getPointer();
for (int i = 0; i < nbcells; i++)
{
- std::size_t i1=pc[i]*nbcomp;
- std::size_t i2=i*nbcomp;
+ std::size_t const i1=pc[i]*nbcomp;
+ std::size_t const i2=i*nbcomp;
for (std::size_t j = 0; j < nbcomp; j++)
{
if (p1[i1+j]==p2[i2+j]) nbequal++;
}
int nbequal=0;
- int nbptgauss=8;
+ int const nbptgauss=8;
std::size_t nbcomp=field1->getNumberOfComponents();
double* p1=f1->getPointer();
double* p2=f2->getPointer();
mcIdType* pc=corr[1]->getPointer();
for (int i = 0; i < nbcells; i++)
{
- std::size_t i1=pc[i]*nbcomp*nbptgauss;
- std::size_t i2=i*nbcomp*nbptgauss;
+ std::size_t const i1=pc[i]*nbcomp*nbptgauss;
+ std::size_t const i2=i*nbcomp*nbptgauss;
for (std::size_t j = 0; j < nbcomp*nbptgauss; j++)
{
if (p1[i1+j]==p2[i2+j]) nbequal++;
const int ndomains = 4;
ParaDomainSelector parallelizer(false);
MeshCollection collection(fileName,parallelizer);
- ParallelTopology* aPT = (ParallelTopology*) collection.getTopology();
+ auto* aPT = (ParallelTopology*) collection.getTopology();
aPT->setGlobalNumerotationDefault(collection.getParaDomainSelector());
std::unique_ptr< Topology > new_topo;
#ifndef __MEDPARTITIONERTEST_HXX__
#define __MEDPARTITIONERTEST_HXX__
+#include <cppunit/TestFixture.h>
#ifdef WIN32
# if defined MEDPARTITIONERTEST_EXPORTS || defined MEDPARTITIONERTest_EXPORTS
# define MEDPARTITIONERTEST_EXPORT __declspec( dllexport )
#include <cppunit/extensions/HelperMacros.h>
-#include <set>
#include <string>
-#include <iostream>
#include "MEDCouplingUMesh.hxx"
#include "MEDCouplingMappedExtrudedMesh.hxx"
void deleteTestMeshes();
//for CPPUNIT_TEST
- void setUp();
- void tearDown();
+ void setUp() override;
+ void tearDown() override;
void testMeshCollectionSingle();
void testMeshCollectionXml();
#if defined(MED_ENABLE_METIS)
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+#include "MCType.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingRefCountObject.hxx"
#include "MEDPARTITIONERTest.hxx"
#include "MEDPARTITIONER_MeshCollection.hxx"
#include "MEDPARTITIONER_ParaDomainSelector.hxx"
#include "MEDPARTITIONER_Utils.hxx"
-#include "CellModel.hxx"
#include "MEDFileMesh.hxx"
#include "MEDLoader.hxx"
-#include "MEDLoaderBase.hxx"
#include "MEDCouplingUMesh.hxx"
#include "MEDCouplingMappedExtrudedMesh.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include <cppunit/TestAssert.h>
-#include <sstream>
+#include <fstream>
+#include <iostream>
#include <cmath>
-#include <list>
-#include <stdexcept>
#include <cstdlib>
-#include <vector>
+#include <string>
#include <unistd.h> // get_current_dir_name()
{
execName=getenv("MEDCOUPLING_ROOT_DIR");
execName+="/bin/medpartitioner_para";
- std::ifstream my_file(execName.c_str());
+ std::ifstream const my_file(execName.c_str());
if (my_file.good())
return execName;
}
input=targetName+".xml";
MEDPARTITIONER::ParaDomainSelector parallelizer(false);
- MEDPARTITIONER::MeshCollection collection(input,parallelizer);
+ MEDPARTITIONER::MeshCollection const collection(input,parallelizer);
CPPUNIT_ASSERT_EQUAL(3, collection.getMeshDimension());
std::vector<MEDCoupling::MEDCouplingUMesh*>cellMeshes=collection.getMesh();
CPPUNIT_ASSERT_EQUAL(5, (int) cellMeshes.size());
int* pc=corr[1]->getPointer();
for (int i = 0; i < nbcells; i++)
{
- int i1=pc[i]*nbcomp;
- int i2=i*nbcomp;
+ int const i1=pc[i]*nbcomp;
+ int const i2=i*nbcomp;
for (int j = 0; j < nbcomp; j++)
{
if (p1[i1+j]==p2[i2+j]) nbequal++;
}
int nbequal=0;
- int nbptgauss=8;
+ int const nbptgauss=8;
int nbcomp=field1->getNumberOfComponents();
double* p1=f1->getPointer();
double* p2=f2->getPointer();
int* pc=corr[1]->getPointer();
for (int i = 0; i < nbcells; i++)
{
- int i1=pc[i]*nbcomp*nbptgauss;
- int i2=i*nbcomp*nbptgauss;
+ int const i1=pc[i]*nbcomp*nbptgauss;
+ int const i2=i*nbcomp*nbptgauss;
for (int j = 0; j < nbcomp*nbptgauss; j++)
{
if (p1[i1+j]==p2[i2+j]) nbequal++;
//include all MEDPARTITIONER Test
#include "MEDPARTITIONERTest.hxx"
+#include <cppunit/extensions/HelperMacros.h>
//Registers the fixture into the 'registry'
CPPUNIT_TEST_SUITE_REGISTRATION( MEDPARTITIONERTest );
#include "MEDPARTITIONER_Utils.hxx"
*/
+#include "InterpKernelException.hxx"
#include "MEDPARTITIONER_MeshCollection.hxx"
#include "MEDPARTITIONER_ParallelTopology.hxx"
#include "MEDPARTITIONER_ParaDomainSelector.hxx"
#include "MEDPARTITIONER_Utils.hxx"
+#include <stdio.h>
+#include <memory>
+#include <cstdio>
+#include <exception>
#include <string>
#include <fstream>
#include <cstring>
#include <cstdlib>
#include <iostream>
+#include <vector>
using namespace std;
using namespace MEDPARTITIONER;
// Defining options
// by parsing the command line
- bool split_family=false;
- bool empty_groups=false;
+ bool const split_family=false;
+ bool const empty_groups=false;
bool mesure_memory=false;
- bool filter_face=true;
+ bool const filter_face=true;
string input;
string output;
- string meshname;
+ string const meshname;
string library="metis"; //default
int ndomains;
int help=0;
MyGlobals::_Create_Joints=0;
// Primitive parsing of command-line options
- string desc ("Available options of medpartitioner V1.0:\n"
+ string const desc ("Available options of medpartitioner V1.0:\n"
"\t--help : produces this help message\n"
"\t--verbose : echoes arguments\n"
"\t--input-file=<string> : name of the input .med file or .xml master file\n"
//testing whether it is possible to write a file at the specified location
if (MyGlobals::_Rank==0)
{
- string outputtest = output + ".testioms.";
- ofstream testfile (outputtest.c_str());
+ string const outputtest = output + ".testioms.";
+ ofstream const testfile (outputtest.c_str());
if (testfile.fail())
{
cerr << "output-file directory does not exist or is in read-only access" << endl;
}*/
MEDPARTITIONER::ParaDomainSelector parallelizer(mesure_memory);
MEDPARTITIONER::MeshCollection collection(input,parallelizer);
- MEDPARTITIONER::ParallelTopology* aPT = (MEDPARTITIONER::ParallelTopology*) collection.getTopology();
+ auto* aPT = (MEDPARTITIONER::ParallelTopology*) collection.getTopology();
aPT->setGlobalNumerotationDefault(collection.getParaDomainSelector());
//to have unique valid fields names/pointers/descriptions for partitionning
collection.prepareFieldDescriptions();
r2=SelectTagsInVectorOfString(r2,"meshName=");
if (r2.size()==(collection.getMesh()).size())
{
- for (std::size_t i=0; i<r2.size(); i++)
- r2[i]=EraseTagSerialized(r2[i],"ioldDomain=");
+ for (auto & i : r2)
+ i=EraseTagSerialized(i,"ioldDomain=");
r2=DeleteDuplicatesInVectorOfString(r2);
if (r2.size()==1)
{
- string finalMesh="finalMeshName="+ExtractFromDescription(r2[0], "meshName=");
+ string const finalMesh="finalMeshName="+ExtractFromDescription(r2[0], "meshName=");
finalInformations.push_back(SerializeFromString(finalMesh));
}
}
r2=SelectTagsInVectorOfString(r1,"fieldName=");
r2=SelectTagsInVectorOfString(r2,"nbComponents=");
//may be yes? or not?
- for (std::size_t i=0; i<r2.size(); i++)
- r2[i]=EraseTagSerialized(r2[i],"ioldFieldDouble=");
+ for (auto & i : r2)
+ i=EraseTagSerialized(i,"ioldFieldDouble=");
r2=DeleteDuplicatesInVectorOfString(r2);
- for (std::size_t i=0; i<r2.size(); i++)
- finalInformations.push_back(r2[i]);
+ for (const auto & i : r2)
+ finalInformations.push_back(i);
MyGlobals::_General_Informations=finalInformations;
if (MyGlobals::_Is0verbose)
*/
-#include "MEDPARTITIONER_MeshCollection.hxx"
-#include "MEDPARTITIONER_ParallelTopology.hxx"
-#include "MEDPARTITIONER_ParaDomainSelector.hxx"
#include "MEDPARTITIONER_Utils.hxx"
-#include "MEDLoader.hxx"
-#include <fstream>
#include <iostream>
-#include <iomanip>
-#include <sstream>
-#include <string>
#include <cstring>
#ifdef HAVE_MPI
using namespace std;
using namespace MEDPARTITIONER;
-int main(int argc, char** argv)
+int main(int /*argc*/, char** /*argv*/)
{
#if !defined(MED_ENABLE_PARMETIS)
cout << "Sorry, no one split method is available. Please, compile with ParMETIS."<<endl;
// Author : Anthony Geay (EDF R&D)
#include "ParaMEDFileMesh.hxx"
+#include "InterpKernelAutoPtr.hxx"
#include "MCAuto.hxx"
+#include "MCIdType.hxx"
+#include "MEDCouplingMesh.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingRefCountObject.hxx"
#include "MEDFileMesh.hxx"
#include "MEDFileMeshLL.hxx"
-#include "MEDLoader.hxx"
#include "MEDFileField1TS.hxx"
#include "MEDFileUtilities.hxx"
#include "MEDFileEntities.hxx"
-#include <iostream>
-#include <fstream>
+#include "med.h"
+#include "NormalizedGeometricTypes"
+#include "MEDLoader.hxx"
+#include <string>
// From MEDLOader.cxx TU
* Loads mesh \a mName in parallel using a custom partition of the mesh cells among the processes.
* See ParaMEDFileUMesh::ParaNew for detailed description.
*/
-MEDFileUMesh *ParaMEDFileUMesh::NewPrivate(med_idt fid, const MPI_Comm& com, const std::map<INTERP_KERNEL::NormalizedCellType,std::vector<mcIdType>>& distrib, const std::string& fileName, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
+MEDFileUMesh *ParaMEDFileUMesh::NewPrivate(med_idt fid, const MPI_Comm& com, const std::map<INTERP_KERNEL::NormalizedCellType,std::vector<mcIdType>>& distrib, const std::string& /*fileName*/, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
{
MCAuto<MEDFileUMesh> ret;
for(std::map<INTERP_KERNEL::NormalizedCellType,std::vector<mcIdType>>::const_iterator iter=distrib.begin(); iter!= distrib.end(); iter++)
#include "mpi.h"
#include <string>
-#include <vector>
-#include <map>
-#include "MCIdType.hxx"
#include "MEDCouplingRefCountObject.hxx"
#include "NormalizedGeometricTypes"
+#include "MCIdType.hxx"
namespace MEDCoupling
{
class ParaMEDFileMesh
{
public:
- static MEDFileMesh *New(int iPart, int nbOfParts, const std::string& fileName, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=0);
- static MEDFileMesh *ParaNew(int iPart, int nbOfParts, const MPI_Comm& com, const MPI_Info& nfo, const std::string& fileName, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=0);
+ static MEDFileMesh *New(int iPart, int nbOfParts, const std::string& fileName, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=nullptr);
+ static MEDFileMesh *ParaNew(int iPart, int nbOfParts, const MPI_Comm& com, const MPI_Info& nfo, const std::string& fileName, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=nullptr);
};
class ParaMEDFileUMesh
{
public:
- static MEDFileUMesh *New(int iPart, int nbOfParts, const std::string& fileName, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=0);
- static MEDFileUMesh *ParaNew(int iPart, int nbOfParts, const MPI_Comm& com, const MPI_Info& nfo, const std::string& fileName, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=0);
- static MEDFileUMesh *ParaNew(const std::map<INTERP_KERNEL::NormalizedCellType,std::vector<mcIdType>>&, const MPI_Comm& com, const MPI_Info& nfo, const std::string& fileName, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=0);
+ static MEDFileUMesh *New(int iPart, int nbOfParts, const std::string& fileName, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=nullptr);
+ static MEDFileUMesh *ParaNew(int iPart, int nbOfParts, const MPI_Comm& com, const MPI_Info& nfo, const std::string& fileName, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=nullptr);
+ static MEDFileUMesh *ParaNew(const std::map<INTERP_KERNEL::NormalizedCellType,std::vector<mcIdType>>&, const MPI_Comm& com, const MPI_Info& nfo, const std::string& fileName, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=nullptr);
private:
static MEDFileUMesh *NewPrivate(med_idt fid, int iPart, int nbOfParts, const std::string& fileName, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs);
#include "BlockTopology.hxx"
#include "MEDCouplingUMesh.hxx"
+#include <cstddef>
#include <fstream>
#include <sstream>
using namespace MEDCoupling;
ParaMEDLoader::ParaMEDLoader()
-{
-}
+= default;
void ParaMEDLoader::WriteParaMesh(const char *fileName, MEDCoupling::ParaMESH *mesh)
{
if(!mesh->getBlockTopology()->getProcGroup()->containsMyRank())
return ;
- int myRank=mesh->getBlockTopology()->getProcGroup()->myRank();
- int nbDomains=mesh->getBlockTopology()->getProcGroup()->size();
+ int const myRank=mesh->getBlockTopology()->getProcGroup()->myRank();
+ int const nbDomains=mesh->getBlockTopology()->getProcGroup()->size();
std::vector<std::string> fileNames(nbDomains);
for(int i=0;i<nbDomains;i++)
{
//
#include "BlockTopology.hxx"
+#include "MCType.hxx"
#include "MEDCouplingMemArray.hxx"
#include "MEDCouplingCMesh.hxx"
#include "CommInterface.hxx"
+#include "ParaIdType.hxx"
#include "ProcessorGroup.hxx"
#include "MPIProcessorGroup.hxx"
#include "ComponentTopology.hxx"
#include "InterpKernelUtilities.hxx"
-#include <vector>
+#include <cstddef>
#include <algorithm>
#include <utility>
#include <iostream>
+#include <vector>
using namespace std;
*/
BlockTopology::BlockTopology(const ProcessorGroup& group, mcIdType nb_elem):_dimension(1),_proc_group(&group),_owns_processor_group(false)
{
- mcIdType* nbelems_per_proc = new mcIdType[group.size()];
- const MPIProcessorGroup* mpi_group=dynamic_cast<const MPIProcessorGroup*>(_proc_group);
+ auto* nbelems_per_proc = new mcIdType[group.size()];
+ const auto* mpi_group=dynamic_cast<const MPIProcessorGroup*>(_proc_group);
const MPI_Comm* comm=mpi_group->getComm();
mcIdType nbtemp=nb_elem;
mpi_group->getCommInterface().allGather(&nbtemp, 1, MPI_ID_TYPE,
{
int subdomain_id=0;
mcIdType position=global;
- mcIdType size=_nb_elems;
- std::size_t size_procs=_proc_group->size();
+ mcIdType const size=_nb_elems;
+ std::size_t const size_procs=_proc_group->size();
mcIdType increment=size;
vector<mcIdType>axis_position(_dimension);
vector<mcIdType>axis_offset(_dimension);
std::size_t axis_size=_local_array_indices[idim].size()-1;
mcIdType axis_nb_elem=_local_array_indices[idim][axis_size];
increment=increment/axis_nb_elem;
- int proc_increment = (int)(size_procs/axis_size);
- mcIdType axis_pos=position/increment;
+ int const proc_increment = (int)(size_procs/axis_size);
+ mcIdType const axis_pos=position/increment;
position=position%increment;
int iaxis=1;
while (_local_array_indices[idim][iaxis]<=axis_pos)
mcIdType axis_nb_elem=_local_array_indices[idim][axis_size];
increment=axis_nb_elem==0?0:increment/axis_nb_elem;
proc_increment = proc_increment/axis_size;
- std::size_t proc_axis=subdomain_id/proc_increment;
+ std::size_t const proc_axis=subdomain_id/proc_increment;
subdomain_id=subdomain_id%proc_increment;
mcIdType local_axis_nb_elem=_local_array_indices[idim][proc_axis+1]-_local_array_indices[idim][proc_axis];
local_increment = (local_axis_nb_elem==0)?0:(local_increment/local_axis_nb_elem);
for (int i=_dimension-1; i>=0; i--)
{
increment *=_nb_procs_per_dim[i];
- int idim=position%increment;
+ int const idim=position%increment;
position=position/increment;
mcIdType imin=_local_array_indices[i][idim];
mcIdType imax=_local_array_indices[i][idim+1];
std::vector<std::pair<int,mcIdType> > BlockTopology::getLocalArrayMinMax() const
{
vector<pair<int,mcIdType> > local_indices (_dimension);
- int myrank=_proc_group->myRank();
+ int const myrank=_proc_group->myRank();
int increment=1;
for (int i=_dimension-1; i>=0; i--)
{
increment *=_nb_procs_per_dim[i];
- int idim=myrank%increment;
+ int const idim=myrank%increment;
local_indices[i].first=(int)_local_array_indices[i][idim];
local_indices[i].second=_local_array_indices[i][idim+1];
cout << local_indices[i].first << " "<< local_indices[i].second<<endl;
//serializing the comm group
mcIdType size_comm=_proc_group->size();
buffer.push_back(size_comm);
- MPIProcessorGroup world_group(_proc_group->getCommInterface());
+ MPIProcessorGroup const world_group(_proc_group->getCommInterface());
for (int i=0; i<size_comm;i++)
{
int world_rank=world_group.translateRank(_proc_group, i);
_local_array_indices[i][j]=*(ptr_serializer++);
}
set<int> procs;
- mcIdType size_comm=*(ptr_serializer++);
+ mcIdType const size_comm=*(ptr_serializer++);
for (int i=0; i<size_comm; i++)
procs.insert((int)*(ptr_serializer++));
#ifndef __BLOCKTOPOLOGY_HXX__
#define __BLOCKTOPOLOGY_HXX__
+#include "MCType.hxx"
+#include "CommInterface.hxx"
#include "Topology.hxx"
#include "ProcessorGroup.hxx"
+#include <utility>
#include <vector>
namespace MEDCoupling
BlockTopology(const ProcessorGroup& group, MEDCouplingCMesh *grid);
BlockTopology(const BlockTopology& geom_topo, const ComponentTopology& comp_topo);
BlockTopology(const ProcessorGroup& group, mcIdType nb_elem);
- virtual ~BlockTopology();
+ ~BlockTopology() override;
void release();
//!Retrieves the number of elements for a given topology
- mcIdType getNbElements()const { return _nb_elems; }
- mcIdType getNbLocalElements() const;
- const ProcessorGroup* getProcGroup()const { return _proc_group; }
+ mcIdType getNbElements()const override { return _nb_elems; }
+ mcIdType getNbLocalElements() const override;
+ const ProcessorGroup* getProcGroup()const override { return _proc_group; }
std::pair<int,mcIdType> globalToLocal (const mcIdType) const ;
mcIdType localToGlobal (const std::pair<int,mcIdType>) const;
std::vector<std::pair<int,mcIdType> > getLocalArrayMinMax() const ;
#include "ByStringMPIProcessorGroup.hxx"
-#include <iostream>
-#include <set>
-#include <algorithm>
+#include <cstddef>
+#include <string>
+#include "MPIProcessorGroup.hxx"
#include "mpi.h"
using namespace std;
}
ByStringMPIProcessorGroup::~ByStringMPIProcessorGroup()
- {
- }
+ = default;
ByStringMPIProcessorGroup *ByStringMPIProcessorGroup::deepCopy() const
{
#define __BYSTRINGMPIPROCESSORGROUP_HXX__
#include "MPIProcessorGroup.hxx"
+#include <string>
namespace MEDCoupling
{
ByStringMPIProcessorGroup(const CommInterface& interface);
ByStringMPIProcessorGroup(const CommInterface& interface, const std::string& simCodeTag, const MPI_Comm& world_comm=MPI_COMM_WORLD);
ByStringMPIProcessorGroup(const ByStringMPIProcessorGroup& other);
- virtual ~ByStringMPIProcessorGroup();
- virtual ByStringMPIProcessorGroup *deepCopy() const;
+ ~ByStringMPIProcessorGroup() override;
+ ByStringMPIProcessorGroup *deepCopy() const override;
};
}
//
#include "CommInterface.hxx"
+#include "MCType.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingMemArray.hxx"
namespace MEDCoupling
{
#pragma once
+#include "MCType.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingTraits.hxx"
#include "ParaIdType.hxx"
#include "MEDCouplingMemArray.hxx"
+#include <limits>
+#include <cstddef>
#include <mpi.h>
-#include <memory>
#include <numeric>
+#include <memory>
namespace MEDCoupling
{
class CommInterface
{
public:
- CommInterface() { }
- virtual ~CommInterface() { }
+ CommInterface() = default;
+ virtual ~CommInterface() = default;
int worldSize() const {
int size;
MPI_Comm_size(MPI_COMM_WORLD, &size);
#include "ComponentTopology.hxx"
#include "ProcessorGroup.hxx"
-#include "InterpolationUtils.hxx"
namespace MEDCoupling
{
*/
ComponentTopology::ComponentTopology(int nb_comp, ProcessorGroup* group):_proc_group(group)
{
- int nb_blocks=group->size();
+ int const nb_blocks=group->size();
if (nb_blocks>nb_comp)
throw INTERP_KERNEL::Exception("ComponentTopology Number of components must be larger than number of blocks");
/* Generic constructor for \a nb_comp components equally parted
* in \a nb_blocks blocks
*/
- ComponentTopology::ComponentTopology(int nb_comp, int nb_blocks):_proc_group(0)
+ ComponentTopology::ComponentTopology(int nb_comp, int nb_blocks):_proc_group(nullptr)
{
if (nb_blocks>nb_comp)
throw INTERP_KERNEL::Exception("ComponentTopology Number of components must be larger than number of blocks");
}
//!Constructor for one block of \a nb_comp components
- ComponentTopology::ComponentTopology(int nb_comp):_proc_group(0)
+ ComponentTopology::ComponentTopology(int nb_comp):_proc_group(nullptr)
{
_component_array.resize(2);
}
//! Constructor for one component
- ComponentTopology::ComponentTopology():_proc_group(0)
+ ComponentTopology::ComponentTopology():_proc_group(nullptr)
{
_component_array.resize(2);
_component_array[0]=0;
}
ComponentTopology::~ComponentTopology()
- {
- }
+ = default;
int ComponentTopology::nbLocalComponents() const
{
- if (_proc_group==0)
+ if (_proc_group==nullptr)
return nbComponents();
int nbcomp;
- int myrank = _proc_group->myRank();
+ int const myrank = _proc_group->myRank();
if (myrank!=-1)
nbcomp = _component_array[myrank+1]-_component_array[myrank];
else
int ComponentTopology::firstLocalComponent() const
{
- if (_proc_group==0)
+ if (_proc_group==nullptr)
return 0;
int icomp;
- int myrank = _proc_group->myRank();
+ int const myrank = _proc_group->myRank();
if (myrank!=-1)
icomp = _component_array[myrank];
else
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-#include "CommInterface.hxx"
-#include "Topology.hxx"
-#include "BlockTopology.hxx"
-#include "ComponentTopology.hxx"
-#include "ParaFIELD.hxx"
-#include "ParaMESH.hxx"
#include "DEC.hxx"
-#include "ICoCoMEDDoubleField.hxx"
-#include "MPIProcessorGroup.hxx"
#include <cmath>
namespace MEDCoupling
{
- DEC::DEC():_comm_interface(0)
+ DEC::DEC():_comm_interface(nullptr)
{
}
}
DEC::~DEC()
- {
- }
+ = default;
}
#ifndef __DEC_HXX__
#define __DEC_HXX__
-#include "MEDCouplingFieldDouble.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
#include "DECOptions.hxx"
namespace MEDCoupling
{
protected:
std::string _method;
- bool _asynchronous;
- TimeInterpolationMethod _timeInterpolationMethod;
- AllToAllMethod _allToAllMethod;
- bool _forcedRenormalization;
+ bool _asynchronous{false};
+ TimeInterpolationMethod _timeInterpolationMethod{WithoutTimeInterp};
+ AllToAllMethod _allToAllMethod{Native};
+ bool _forcedRenormalization{false};
public:
- DECOptions():_method("P0"),
- _asynchronous(false),
- _timeInterpolationMethod(WithoutTimeInterp),
- _allToAllMethod(Native),
- _forcedRenormalization(false)
+ DECOptions():_method("P0")
+
{
}
#include "DisjointDEC.hxx"
#include "CommInterface.hxx"
+#include "DEC.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
+#include "MEDCouplingPointSet.hxx"
+#include "MEDCouplingMesh.hxx"
+#include "MEDCouplingRefCountObject.hxx"
#include "Topology.hxx"
-#include "BlockTopology.hxx"
#include "ComponentTopology.hxx"
#include "ParaFIELD.hxx"
#include "ParaMESH.hxx"
-#include "ICoCoField.hxx"
#include "ICoCoMEDDoubleField.hxx"
#include "MPIProcessorGroup.hxx"
#include <cmath>
-#include <iostream>
namespace MEDCoupling
{
DisjointDEC::DisjointDEC(ProcessorGroup& source_group, ProcessorGroup& target_group):
- _local_field(0),
+ _local_field(nullptr),
_source_group(&source_group),
_target_group(&target_group),
- _comm_interface(0),
+ _comm_interface(nullptr),
_owns_field(false),
_owns_groups(false),
_union_comm(MPI_COMM_NULL)
DisjointDEC::DisjointDEC(const DisjointDEC& s):
DEC(s),
- _local_field(0),
- _union_group(0),
- _source_group(0),
- _target_group(0),
- _comm_interface(0),
+ _local_field(nullptr),
+ _union_group(nullptr),
+ _source_group(nullptr),
+ _target_group(nullptr),
+ _comm_interface(nullptr),
_owns_field(false),
_owns_groups(false),
_union_comm(MPI_COMM_NULL)
DisjointDEC::DisjointDEC(const std::set<int>& source_ids,
const std::set<int>& target_ids,
const MPI_Comm& world_comm):
- _local_field(0),
- _comm_interface(0),
+ _local_field(nullptr),
+ _comm_interface(nullptr),
_owns_field(false),
_owns_groups(true),
_union_comm(MPI_COMM_NULL)
{
- MEDCoupling::CommInterface comm;
+ MEDCoupling::CommInterface const comm;
// Create the list of procs including source and target
std::set<int> union_ids; // source and target ids in world_comm
union_ids.insert(source_ids.begin(),source_ids.end());
delete[] union_ranks_world;
if (_union_comm==MPI_COMM_NULL)
{ // This process is not in union
- _source_group=0;
- _target_group=0;
- _union_group=0;
+ _source_group=nullptr;
+ _target_group=nullptr;
+ _union_group=nullptr;
comm.groupFree(&union_group);
comm.groupFree(&world_group);
return;
void DisjointDEC::checkPartitionGroup() const
{
int size = -1;
- MPIProcessorGroup * tgt = static_cast<MPIProcessorGroup *>(_target_group);
- MPIProcessorGroup * src = static_cast<MPIProcessorGroup *>(_source_group);
+ auto * tgt = static_cast<MPIProcessorGroup *>(_target_group);
+ auto * src = static_cast<MPIProcessorGroup *>(_source_group);
MPI_Comm comm_t = tgt->getWorldComm();
MPI_Comm comm_s = src->getWorldComm();
if (comm_t != comm_s)
local_group=_target_group;
else
throw INTERP_KERNEL::Exception("Invalid procgroup for field attachment to DEC");
- ParaMESH *paramesh=new ParaMESH(static_cast<MEDCouplingPointSet *>(const_cast<MEDCouplingMesh *>(field->getMesh())),*local_group,field->getMesh()->getName());
- ParaFIELD *tmp=new ParaFIELD(field, paramesh, *local_group);
+ auto *paramesh=new ParaMESH(static_cast<MEDCouplingPointSet *>(const_cast<MEDCouplingMesh *>(field->getMesh())),*local_group,field->getMesh()->getName());
+ auto *tmp=new ParaFIELD(field, paramesh, *local_group);
tmp->setOwnSupport(true);
attachLocalField(tmp,true);
//_comm_interface=&(local_group->getCommInterface());
if (_source_group->containsMyRank())
for (int icomp=0; icomp<(int)_local_field->getField()->getArray()->getNumberOfComponents(); icomp++)
{
- double total_norm = _local_field->getVolumeIntegral(icomp+1,isWAbs);
+ double const total_norm = _local_field->getVolumeIntegral(icomp+1,isWAbs);
double source_norm = total_norm;
_comm_interface->broadcast(&source_norm, 1, MPI_DOUBLE, 0,* dynamic_cast<MPIProcessorGroup*>(_union_group)->getComm());
{
for (int icomp=0; icomp<(int)_local_field->getField()->getArray()->getNumberOfComponents(); icomp++)
{
- double total_norm = _local_field->getVolumeIntegral(icomp+1,isWAbs);
+ double const total_norm = _local_field->getVolumeIntegral(icomp+1,isWAbs);
double source_norm=total_norm;
_comm_interface->broadcast(&source_norm, 1, MPI_DOUBLE, 0,* dynamic_cast<MPIProcessorGroup*>(_union_group)->getComm());
{
if (_local_field)
{
- TypeOfField entity = _local_field->getField()->getTypeOfField();
+ TypeOfField const entity = _local_field->getField()->getTypeOfField();
if ( getMethod() == "P0" )
{
if ( entity != ON_CELLS )
#define __DISJOINTDEC_HXX__
#include "MEDCouplingFieldDouble.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
#include "DEC.hxx"
#include <mpi.h>
class DisjointDEC : public DEC
{
public:
- DisjointDEC():_local_field(0),_union_group(0),_source_group(0),_target_group(0),
- _comm_interface(0),
+ DisjointDEC():_local_field(nullptr),_union_group(nullptr),_source_group(nullptr),_target_group(nullptr),
+ _comm_interface(nullptr),
_owns_field(false),_owns_groups(false),
_union_comm(MPI_COMM_NULL)
{ }
DisjointDEC &operator=(const DisjointDEC& s);
DisjointDEC(const std::set<int>& src_ids, const std::set<int>& trg_ids,
const MPI_Comm& world_comm=MPI_COMM_WORLD);
- virtual ~DisjointDEC();
+ ~DisjointDEC() override;
void setNature(NatureOfField nature);
void attachLocalField( MEDCouplingFieldDouble *field);
virtual void prepareTargetDE() = 0;
virtual void recvData() = 0;
virtual void sendData() = 0;
- void sendRecvData(bool way=true);
- virtual void synchronize() = 0;
+ void sendRecvData(bool way=true) override;
+ void synchronize() override = 0;
virtual void computeProcGroup() { }
void renormalizeTargetField(bool isWAbs);
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+#include <cstddef>
#include <mpi.h>
#include "CommInterface.hxx"
#include "ElementLocator.hxx"
+#include "MEDCouplingFieldDouble.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
+#include "MCType.hxx"
+#include "ParaIdType.hxx"
+#include "MEDCouplingMemArray.hxx"
#include "Topology.hxx"
-#include "BlockTopology.hxx"
#include "ParaFIELD.hxx"
#include "ParaMESH.hxx"
#include "ProcessorGroup.hxx"
#include "MPIProcessorGroup.hxx"
-#include "MEDCouplingFieldDouble.hxx"
#include "MCAuto.hxx"
-#include "DirectedBoundingBox.hxx"
-#include <map>
-#include <set>
#include <limits>
+#include <string>
+#include <vector>
+#include <set>
+#include <map>
using namespace std;
const MPI_Comm *ElementLocator::getCommunicator() const
{
- MPIProcessorGroup* group=static_cast<MPIProcessorGroup*> (_union_group);
+ auto* group=static_cast<MPIProcessorGroup*> (_union_group);
return group->getComm();
}
MEDCouplingPointSet*& distant_mesh,
mcIdType*& distant_ids)
{
- int rank = _union_group->translateRank(&_distant_group,idistantrank);
+ int const rank = _union_group->translateRank(&_distant_group,idistantrank);
if (find(_distant_proc_ids.begin(), _distant_proc_ids.end(),rank)==_distant_proc_ids.end())
return;
#endif
DataArrayIdType *distant_ids_send;
- MEDCouplingPointSet *send_mesh = (MEDCouplingPointSet *)_local_para_field.getField()->buildSubMeshData(elems->begin(),elems->end(),distant_ids_send);
+ auto *send_mesh = (MEDCouplingPointSet *)_local_para_field.getField()->buildSubMeshData(elems->begin(),elems->end(),distant_ids_send);
_exchangeMesh(send_mesh, distant_mesh, idistantrank, distant_ids_send, distant_ids);
distant_ids_send->decrRef();
void ElementLocator::exchangeMethod(const std::string& sourceMeth, int idistantrank, std::string& targetMeth)
{
CommInterface comm_interface=_union_group->getCommInterface();
- MPIProcessorGroup* group=static_cast<MPIProcessorGroup*> (_union_group);
+ auto* group=static_cast<MPIProcessorGroup*> (_union_group);
const MPI_Comm* comm=(group->getComm());
MPI_Status status;
// it must be converted to union numbering before communication
- int idistRankInUnion = group->translateRank(&_distant_group,idistantrank);
+ int const idistRankInUnion = group->translateRank(&_distant_group,idistantrank);
char *recv_buffer=new char[4];
std::vector<char> send_buffer(4);
std::copy(sourceMeth.begin(),sourceMeth.end(),send_buffer.begin());
*/
void ElementLocator::_computeBoundingBoxes()
{
- CommInterface comm_interface =_union_group->getCommInterface();
- MPIProcessorGroup* group=static_cast<MPIProcessorGroup*> (_union_group);
+ CommInterface const comm_interface =_union_group->getCommInterface();
+ auto* group=static_cast<MPIProcessorGroup*> (_union_group);
const MPI_Comm* comm = group->getComm();
_local_cell_mesh_space_dim = -1;
if(_local_cell_mesh->getMeshDimension() != -1)
if ( dbbData.size() < bbSize ) dbbData.resize(bbSize,0);
double * minmax= &dbbData[0];
#else
- int bbSize = 2*_local_cell_mesh_space_dim;
+ int const bbSize = 2*_local_cell_mesh_space_dim;
_domain_bounding_boxes = new double[bbSize*_union_group->size()];
- double * minmax=new double [bbSize];
+ auto * minmax=new double [bbSize];
if(_local_cell_mesh->getMeshDimension() != -1)
_local_cell_mesh->getBoundingBox(minmax);
else
for (int i=0; i< _distant_group.size(); i++)
{
- int rank=_union_group->translateRank(&_distant_group,i);
+ int const rank=_union_group->translateRank(&_distant_group,i);
if (_intersectsBoundingBox(rank))
{
const double eps = 1e-12;
for (int idim=0; idim < _local_cell_mesh_space_dim; idim++)
{
- bool intersects = (distant_bb[idim*2]<local_bb[idim*2+1]+eps)
+ bool const intersects = (distant_bb[idim*2]<local_bb[idim*2+1]+eps)
&& (local_bb[idim*2]<distant_bb[idim*2+1]+eps);
if (!intersects) return false;
}
tinyInfoLocal.push_back(distant_ids_send->getNumberOfTuples());
tinyInfoDistant.resize(tinyInfoLocal.size());
std::fill(tinyInfoDistant.begin(),tinyInfoDistant.end(),0);
- MPIProcessorGroup* group=static_cast<MPIProcessorGroup*> (_union_group);
+ auto* group=static_cast<MPIProcessorGroup*> (_union_group);
const MPI_Comm* comm=group->getComm();
MPI_Status status;
// iproc_distant is the number of proc in distant group
// it must be converted to union numbering before communication
- int iprocdistant_in_union = group->translateRank(&_distant_group,
+ int const iprocdistant_in_union = group->translateRank(&_distant_group,
iproc_distant);
comm_interface.sendRecv(&tinyInfoLocal[0], (int)tinyInfoLocal.size(), MPI_ID_TYPE, iprocdistant_in_union, 1112,
&tinyInfoDistant[0], (int)tinyInfoDistant.size(), MPI_ID_TYPE,iprocdistant_in_union,1112,
*comm, &status);
- DataArrayIdType *v1Local=0;
- DataArrayDouble *v2Local=0;
+ DataArrayIdType *v1Local=nullptr;
+ DataArrayDouble *v2Local=nullptr;
DataArrayIdType *v1Distant=DataArrayIdType::New();
DataArrayDouble *v2Distant=DataArrayDouble::New();
//serialization of local mesh to send data to distant proc.
{
policy.resize(_distant_proc_ids.size());
int procId=0;
- CommInterface comm;
+ CommInterface const comm;
MPI_Status status;
for(vector<int>::const_iterator iter=_distant_proc_ids.begin();iter!=_distant_proc_ids.end();iter++,procId++)
{
void ElementLocator::sendSumToLazySideW(const std::vector< std::vector<mcIdType> >& distantLocEltIds, const std::vector< std::vector<double> >& partialSumRelToDistantIds)
{
int procId=0;
- CommInterface comm;
+ CommInterface const comm;
for(vector<int>::const_iterator iter=_distant_proc_ids.begin();iter!=_distant_proc_ids.end();iter++,procId++)
{
const vector<mcIdType>& eltIds=distantLocEltIds[procId];
void ElementLocator::recvSumFromLazySideW(std::vector< std::vector<double> >& globalSumRelToDistantIds)
{
int procId=0;
- CommInterface comm;
+ CommInterface const comm;
MPI_Status status;
for(vector<int>::const_iterator iter=_distant_proc_ids.begin();iter!=_distant_proc_ids.end();iter++,procId++)
{
void ElementLocator::sendLocalIdsToLazyProcsW(const std::vector< std::vector<mcIdType> >& distantLocEltIds)
{
int procId=0;
- CommInterface comm;
+ CommInterface const comm;
for(vector<int>::const_iterator iter=_distant_proc_ids.begin();iter!=_distant_proc_ids.end();iter++,procId++)
{
const vector<mcIdType>& eltIds=distantLocEltIds[procId];
void ElementLocator::recvGlobalIdsFromLazyProcsW(const std::vector< std::vector<mcIdType> >& distantLocEltIds, std::vector< std::vector<mcIdType> >& globalIds)
{
int procId=0;
- CommInterface comm;
+ CommInterface const comm;
MPI_Status status;
globalIds.resize(_distant_proc_ids.size());
for(vector<int>::const_iterator iter=_distant_proc_ids.begin();iter!=_distant_proc_ids.end();iter++,procId++)
void ElementLocator::recvCandidatesGlobalIdsFromLazyProcsW(std::vector< std::vector<mcIdType> >& globalIds)
{
int procId=0;
- CommInterface comm;
+ CommInterface const comm;
MPI_Status status;
globalIds.resize(_distant_proc_ids.size());
for(vector<int>::const_iterator iter=_distant_proc_ids.begin();iter!=_distant_proc_ids.end();iter++,procId++)
void ElementLocator::sendPartialSumToLazyProcsW(const std::vector<mcIdType>& distantGlobIds, const std::vector<double>& sum)
{
int procId=0;
- CommInterface comm;
+ CommInterface const comm;
int lgth=(int)distantGlobIds.size();
for(vector<int>::const_iterator iter=_distant_proc_ids.begin();iter!=_distant_proc_ids.end();iter++,procId++)
{
void ElementLocator::sendCandidatesForAddElementsW(const std::vector<mcIdType>& distantGlobIds)
{
int procId=0;
- CommInterface comm;
+ CommInterface const comm;
int lgth=(int)distantGlobIds.size();
for(vector<int>::const_iterator iter=_distant_proc_ids.begin();iter!=_distant_proc_ids.end();iter++,procId++)
{
void ElementLocator::recvAddElementsFromLazyProcsW(std::vector<std::vector<mcIdType> >& elementsToAdd)
{
int procId=0;
- CommInterface comm;
+ CommInterface const comm;
MPI_Status status;
int lgth=(int)_distant_proc_ids.size();
elementsToAdd.resize(lgth);
*/
int ElementLocator::sendPolicyToWorkingSideL()
{
- CommInterface comm;
+ CommInterface const comm;
int toSend;
DataArrayIdType *isCumulative=_local_para_field.returnCumulativeGlobalNumbering();
if(isCumulative)
{
_values_added.resize(_local_para_field.getField()->getNumberOfTuples());
int procId=0;
- CommInterface comm;
+ CommInterface const comm;
_ids_per_working_proc.resize(_distant_proc_ids.size());
MPI_Status status;
for(vector<int>::const_iterator iter=_distant_proc_ids.begin();iter!=_distant_proc_ids.end();iter++,procId++)
void ElementLocator::sendToWorkingSideL()
{
int procId=0;
- CommInterface comm;
+ CommInterface const comm;
for(vector<int>::const_iterator iter=_distant_proc_ids.begin();iter!=_distant_proc_ids.end();iter++,procId++)
{
vector<mcIdType>& ids=_ids_per_working_proc[procId];
void ElementLocator::recvLocalIdsFromWorkingSideL()
{
int procId=0;
- CommInterface comm;
+ CommInterface const comm;
_ids_per_working_proc.resize(_distant_proc_ids.size());
MPI_Status status;
for(vector<int>::const_iterator iter=_distant_proc_ids.begin();iter!=_distant_proc_ids.end();iter++,procId++)
void ElementLocator::sendGlobalIdsToWorkingSideL()
{
int procId=0;
- CommInterface comm;
+ CommInterface const comm;
DataArrayIdType *globalIds=_local_para_field.returnGlobalNumbering();
const mcIdType *globalIdsC=globalIds->getConstPointer();
for(vector<int>::const_iterator iter=_distant_proc_ids.begin();iter!=_distant_proc_ids.end();iter++,procId++)
{
std::size_t procId=0;
std::size_t wProcSize=_distant_proc_ids.size();
- CommInterface comm;
+ CommInterface const comm;
_ids_per_working_proc.resize(wProcSize);
_values_per_working_proc.resize(wProcSize);
MPI_Status status;
{
std::size_t procId=0;
std::size_t wProcSize=_distant_proc_ids.size();
- CommInterface comm;
+ CommInterface const comm;
_ids_per_working_proc3.resize(wProcSize);
MPI_Status status;
std::map<int,double> sums;
void ElementLocator::sendAddElementsToWorkingSideL()
{
int procId=0;
- CommInterface comm;
+ CommInterface const comm;
for(vector<int>::const_iterator iter=_distant_proc_ids.begin();iter!=_distant_proc_ids.end();iter++,procId++)
{
const std::vector<mcIdType>& vals=_ids_per_working_proc3[procId];
void ElementLocator::sendCandidatesGlobalIdsToWorkingSideL()
{
int procId=0;
- CommInterface comm;
+ CommInterface const comm;
DataArrayIdType *globalIds=_local_para_field.returnGlobalNumbering();
const mcIdType *globalIdsC=globalIds->getConstPointer();
MCAuto<DataArrayIdType> candidates=_local_para_field.getSupport()->getCellMesh()->findBoundaryNodes();
#ifndef __ELEMENTLOCATOR_HXX__
#define __ELEMENTLOCATOR_HXX__
-#include "InterpolationOptions.hxx"
-#include "MEDCouplingNatureOfField.hxx"
-#include "MCType.hxx"
-
#include <mpi.h>
+
+#include <string>
#include <vector>
-#include <set>
+
+#include "InterpolationOptions.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
namespace MEDCoupling
{
MEDCouplingPointSet*& target_mesh,
mcIdType*& distant_ids);
void exchangeMethod(const std::string& sourceMeth, int idistantrank, std::string& targetMeth);
- const std::vector<int>& getDistantProcIds() const { return _distant_proc_ids; }
+ const std::vector<int> &getDistantProcIds() const
+ {
+ return _distant_proc_ids;
+ }
const MPI_Comm *getCommunicator() const;
NatureOfField getLocalNature() const;
//! This method is used to informed if there is -1D mesh on distant_group side or on local_group side.
int _local_cell_mesh_space_dim;
bool _is_m1d_corr;
MEDCouplingPointSet* _local_face_mesh;
- std::vector<MEDCouplingPointSet*> _distant_cell_meshes;
- std::vector<MEDCouplingPointSet*> _distant_face_meshes;
+ std::vector<MEDCouplingPointSet *> _distant_cell_meshes;
+ std::vector<MEDCouplingPointSet *> _distant_face_meshes;
double* _domain_bounding_boxes;
const ProcessorGroup& _distant_group;
const ProcessorGroup& _local_group;
const MPI_Comm *_comm;
//Attributes only used by lazy side
std::vector<double> _values_added;
- std::vector< std::vector<mcIdType> > _ids_per_working_proc;
- std::vector< std::vector<mcIdType> > _ids_per_working_proc3;
- std::vector< std::vector<double> > _values_per_working_proc;
- public:
+ std::vector<std::vector<mcIdType> > _ids_per_working_proc;
+ std::vector<std::vector<mcIdType> > _ids_per_working_proc3;
+ std::vector<std::vector<double> > _values_per_working_proc;
+
+ public:
static const int CUMULATIVE_POLICY=3;
static const int NO_POST_TREATMENT_POLICY=7;
};
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+#include <cstddef>
+#include <iostream>
#include <mpi.h>
+#include <utility>
#include "CommInterface.hxx"
+#include "ExplicitTopology.hxx"
+#include "MCType.hxx"
+#include "ParaIdType.hxx"
+#include "MEDCouplingRefCountObject.hxx"
#include "Topology.hxx"
-#include "BlockTopology.hxx"
#include "ComponentTopology.hxx"
#include "ParaFIELD.hxx"
#include "MPIProcessorGroup.hxx"
#include "ExplicitCoincidentDEC.hxx"
-#include "ExplicitMapping.hxx"
#include "InterpKernelUtilities.hxx"
using namespace std;
/*! Constructor
*/
ExplicitCoincidentDEC::ExplicitCoincidentDEC():
- _toposource(0),_topotarget(0),
- _targetgroup(0), _sourcegroup(0),
- _sendcounts(0), _recvcounts(0),
- _senddispls(0), _recvdispls(0),
- _recvbuffer(0), _sendbuffer(0),
+ _toposource(nullptr),_topotarget(nullptr),
+ _targetgroup(nullptr), _sourcegroup(nullptr),
+ _sendcounts(nullptr), _recvcounts(nullptr),
+ _senddispls(nullptr), _recvdispls(nullptr),
+ _recvbuffer(nullptr), _sendbuffer(nullptr),
_distant_elems(), _explicit_mapping()
{
}
ExplicitCoincidentDEC::~ExplicitCoincidentDEC()
- {
- }
+ = default;
/*! Synchronization process for exchanging topologies
*/
if (!_toposource->getProcGroup()->containsMyRank())
return;
- MPIProcessorGroup* group=new MPIProcessorGroup(_sourcegroup->getCommInterface());
+ auto* group=new MPIProcessorGroup(_sourcegroup->getCommInterface());
// Warning : the size of the target side is implicitly deduced
//from the size of MPI_COMM_WORLD
- int target_size = _toposource->getProcGroup()->getCommInterface().worldSize()- _toposource->getProcGroup()->size() ;
+ int const target_size = _toposource->getProcGroup()->getCommInterface().worldSize()- _toposource->getProcGroup()->size() ;
vector<int>* target_arrays=new vector<int>[target_size];
- mcIdType nb_local = _toposource-> getNbLocalElements();
+ mcIdType const nb_local = _toposource-> getNbLocalElements();
std::size_t union_size=group->size();
for (int ielem=0; ielem<nb_local; ielem++)
{
- int ncomp = _toposource->getNbComponents();
+ int const ncomp = _toposource->getNbComponents();
for (int icomp=0; icomp<ncomp; icomp++)
{
_sendbuffer[ielem*ncomp+icomp]=value[bufferindex[ielem]*ncomp+icomp];
{
if (!_topotarget->getProcGroup()->containsMyRank())
return;
- MPIProcessorGroup* group=new MPIProcessorGroup(_topotarget->getProcGroup()->getCommInterface());
+ auto* group=new MPIProcessorGroup(_topotarget->getProcGroup()->getCommInterface());
vector < vector <mcIdType> > source_arrays(_sourcegroup->size());
- mcIdType nb_local = _topotarget-> getNbLocalElements();
+ mcIdType const nb_local = _topotarget-> getNbLocalElements();
for (mcIdType ielem=0; ielem< nb_local ; ielem++)
{
//pair<int,mcIdType> source_local =_distant_elems[ielem];
for (int iproc=0; iproc < _sourcegroup->size(); iproc++)
{
//converts the rank in target to the rank in union communicator
- int unionrank=group->translateRank(_sourcegroup,iproc);
+ int const unionrank=group->translateRank(_sourcegroup,iproc);
_recvcounts[unionrank]=(int)(source_arrays[iproc].size()*_topotarget->getNbComponents());
}
for (std::size_t i=1; i<union_size; i++)
{
MPI_Status status;
- mcIdType* serializer=0;
+ mcIdType* serializer=nullptr;
mcIdType size;
- MPIProcessorGroup* group=new MPIProcessorGroup(*_comm_interface);
+ auto* group=new MPIProcessorGroup(*_comm_interface);
// The send processors serialize the send topology
// and send the buffers to the recv procs
- if (toposend !=0 && toposend->getProcGroup()->containsMyRank())
+ if (toposend !=nullptr && toposend->getProcGroup()->containsMyRank())
{
toposend->serialize(serializer, size);
for (int iproc=0; iproc< group->size(); iproc++)
{
- int itarget=iproc;
+ int const itarget=iproc;
if (!toposend->getProcGroup()->contains(itarget))
{
_comm_interface->send(&size,1,MPI_ID_TYPE, itarget,tag+itarget,*(group->getComm()));
else
{
vector <int> size2(group->size());
- int myworldrank=group->myRank();
+ int const myworldrank=group->myRank();
for (int iproc=0; iproc<group->size();iproc++)
{
- int isource = iproc;
+ int const isource = iproc;
if (!toporecv->getProcGroup()->contains(isource))
{
mcIdType nbelem;
_comm_interface->recv(&nbelem, 1, MPI_ID_TYPE, isource, tag+myworldrank, *(group->getComm()), &status);
- mcIdType* buffer = new mcIdType[nbelem];
+ auto* buffer = new mcIdType[nbelem];
_comm_interface->recv(buffer, (int)nbelem, MPI_ID_TYPE, isource,tag+myworldrank, *(group->getComm()), &status);
- ExplicitTopology* topotemp=new ExplicitTopology();
+ auto* topotemp=new ExplicitTopology();
topotemp->unserialize(buffer, *_comm_interface);
delete[] buffer;
for (mcIdType ielem=0; ielem<toporecv->getNbLocalElements(); ielem++)
{
- mcIdType global = toporecv->localToGlobal(ielem);
- mcIdType sendlocal=topotemp->globalToLocal(global);
+ mcIdType const global = toporecv->localToGlobal(ielem);
+ mcIdType const sendlocal=topotemp->globalToLocal(global);
if (sendlocal!=-1)
{
size2[iproc]++;
void ExplicitCoincidentDEC::transferMappingToSource()
{
- MPIProcessorGroup* group=new MPIProcessorGroup(*_comm_interface);
+ auto* group=new MPIProcessorGroup(*_comm_interface);
// sending source->target mapping which is stored by target
//in _distant_elems from target to source
- if (_topotarget!=0 && _topotarget->getProcGroup()->containsMyRank())
+ if (_topotarget!=nullptr && _topotarget->getProcGroup()->containsMyRank())
{
- int world_size = _topotarget->getProcGroup()->getCommInterface().worldSize() ;
+ int const world_size = _topotarget->getProcGroup()->getCommInterface().worldSize() ;
int* nb_transfer_union=new int[world_size];
int* dummy_recv=new int[world_size];
for (int i=0; i<world_size; i++)
}
int* recvcounts=new int[world_size];
int* recvdispls=new int[world_size];
- int *dummyrecv=0;
+ int *dummyrecv=nullptr;
for (int i=0; i <world_size; i++)
{
recvcounts[i]=0;
//receiving in the source subdomains the mapping sent by targets
else
{
- int world_size = _toposource->getProcGroup()->getCommInterface().worldSize() ;
+ int const world_size = _toposource->getProcGroup()->getCommInterface().worldSize() ;
int* nb_transfer_union=new int[world_size];
int* dummy_send=new int[world_size];
for (int i=0; i<world_size; i++)
int total_size=0;
for (int i=0; i< world_size; i++)
total_size+=nb_transfer_union[i];
- int nbtarget = _targetgroup->size();
+ int const nbtarget = _targetgroup->size();
int* targetranks = new int[ nbtarget];
for (int i=0; i<nbtarget; i++)
targetranks[i]=group->translateRank(_targetgroup,i);
- mcIdType* mappingbuffer= new mcIdType [total_size*2];
+ auto* mappingbuffer= new mcIdType [total_size*2];
int* sendcounts= new int [world_size];
int* senddispls = new int [world_size];
int* recvcounts=new int[world_size];
recvdispls[i]=recvdispls[i-1]+recvcounts[i-1];
}
- int *dummysend=0;
+ int *dummysend=nullptr;
for (int i=0; i <world_size; i++)
{
sendcounts[i]=0;
_recvbuffer, _recvcounts, _recvdispls, MPI_DOUBLE,MPI_COMM_WORLD);
cout<<"end AllToAll"<<endl;
mcIdType nb_local = _topotarget->getNbLocalElements();
- double* value=new double[nb_local*_topotarget->getNbComponents()];
+ auto* value=new double[nb_local*_topotarget->getNbComponents()];
vector<int> counters(_sourcegroup->size());
counters[0]=0;
for (int i=0; i<_sourcegroup->size()-1; i++)
{
- MPIProcessorGroup* group=new MPIProcessorGroup(*_comm_interface);
- int worldrank=group->translateRank(_sourcegroup,i);
+ auto* group=new MPIProcessorGroup(*_comm_interface);
+ int const worldrank=group->translateRank(_sourcegroup,i);
counters[i+1]=counters[i]+_recvcounts[worldrank];
}
#include "ExplicitMapping.hxx"
#include "ExplicitTopology.hxx"
-#include <map>
namespace MEDCoupling
{
{
public:
ExplicitCoincidentDEC();
- virtual ~ExplicitCoincidentDEC();
- void synchronize();
+ ~ExplicitCoincidentDEC() override;
+ void synchronize() override;
void broadcastTopology(BlockTopology*&, int tag);
void broadcastTopology(const ExplicitTopology* toposend, ExplicitTopology* toporecv, int tag);
void transferMappingToSource();
- void prepareSourceDE();
- void prepareTargetDE();
- void recvData();
- void sendData();
+ void prepareSourceDE() override;
+ void prepareTargetDE() override;
+ void recvData() override;
+ void sendData() override;
private:
ExplicitTopology* _toposource;
ExplicitTopology* _topotarget;
//
#include "ExplicitMapping.hxx"
+#include <utility>
+#include "MCIdType.hxx"
+#include <vector>
+#include <map>
namespace MEDCoupling
{
ExplicitMapping::ExplicitMapping():
_mapping(), _distant_domains(),
- _numbers(0), _domains(0), _comm_buffer(0),
- _buffer_index(0), _send_counts(0)
+ _numbers(nullptr), _domains(nullptr), _comm_buffer(nullptr),
+ _buffer_index(nullptr), _send_counts(nullptr)
{ }
ExplicitMapping::~ExplicitMapping()
{
- if (_domains!=0) delete[] _domains;
- if (_numbers!=0) delete[] _numbers;
- if (_comm_buffer!=0) delete[] _comm_buffer;
+ if (_domains!=nullptr) delete[] _domains;
+ if (_numbers!=nullptr) delete[] _numbers;
+ if (_comm_buffer!=nullptr) delete[] _comm_buffer;
}
void ExplicitMapping::pushBackElem(std::pair<int,mcIdType> idistant)
{
if (_distant_domains.empty())
{
- for (std::vector <std::pair<int,mcIdType> >::const_iterator iter= _mapping.begin();
- iter!=_mapping.end();
- iter++)
- _distant_domains.insert(iter->first);
+ for (const auto & iter : _mapping)
+ _distant_domains.insert(iter.first);
}
return (int)_distant_domains.size();
}
int ExplicitMapping::getDistantDomain(int i)
{
- if (_domains==0)
+ if (_domains==nullptr)
computeNumbers();
return _domains[i];
int ExplicitMapping::getNbDistantElems(int i)
{
- if (_numbers==0)
+ if (_numbers==nullptr)
computeNumbers();
return _numbers[i];
}
for (int i=1; i<(int)_distant_domains.size();i++)
offsets[i]=offsets[i-1]+_numbers[i-1];
- for (int i=0; i<(int)_mapping.size(); i++)
+ for (auto & i : _mapping)
{
- mcIdType offset= offsets[_mapping[i].first];
+ mcIdType const offset= offsets[i.first];
_comm_buffer[offset*2]=idproc;
- _comm_buffer[offset*2+1]=_mapping[i].second;
- offsets[_mapping[i].first]++;
+ _comm_buffer[offset*2+1]=i.second;
+ offsets[i.first]++;
}
return _comm_buffer;
}
void ExplicitMapping::computeNumbers()
{
std::map <int,int> counts;
- if (_numbers==0)
+ if (_numbers==nullptr)
{
_numbers=new int[nbDistantDomains()];
_domains=new int[nbDistantDomains()];
- for (int i=0; i<(int)_mapping.size(); i++)
+ for (auto & i : _mapping)
{
- if ( counts.find(_mapping[i].first) == counts.end())
- counts.insert(std::make_pair(_mapping[i].first,1));
+ if ( counts.find(i.first) == counts.end())
+ counts.insert(std::make_pair(i.first,1));
else
- (counts[_mapping[i].first])++;
+ (counts[i.first])++;
}
int counter=0;
for (std::map<int,int>::const_iterator iter=counts.begin();
#include "MCIdType.hxx"
+#include <utility>
#include <vector>
-#include <map>
#include <set>
namespace MEDCoupling
//
#include "CommInterface.hxx"
-#include "ProcessorGroup.hxx"
+#include "MCType.hxx"
#include "MPIProcessorGroup.hxx"
#include "ParaMESH.hxx"
-#include "Topology.hxx"
#include "ExplicitTopology.hxx"
#include "BlockTopology.hxx"
-#include "ComponentTopology.hxx"
-#include <vector>
+#include <iostream>
#include <algorithm>
using namespace std;
{
ExplicitTopology::ExplicitTopology():
- _proc_group(NULL), _nb_elems(0), _nb_components(0),
- _loc2glob(NULL), _glob2loc()
+ _proc_group(nullptr), _nb_elems(0), _nb_components(0),
+ _loc2glob(nullptr), _glob2loc()
{}
ExplicitTopology::ExplicitTopology(const ParaMESH& paramesh ):
ExplicitTopology::~ExplicitTopology()
{
- if (_loc2glob != 0) delete[] _loc2glob;
+ if (_loc2glob != nullptr) delete[] _loc2glob;
}
* after communication. Uses the same structure as the one used for serialize()
*
* */
-void ExplicitTopology::unserialize(const mcIdType* serializer,const CommInterface& comm_interface)
+void ExplicitTopology::unserialize(const mcIdType* serializer,const CommInterface& /*comm_interface*/)
{
const mcIdType* ptr_serializer=serializer;
cout << "unserialize..."<<endl;
#ifndef __EXPLICITTOPOLOGY_HXX__
#define __EXPLICITTOPOLOGY_HXX__
+#include "MCType.hxx"
+#include "CommInterface.hxx"
#include "ProcessorGroup.hxx"
#include "InterpKernelHashMap.hxx"
+#include "Topology.hxx"
-#include <vector>
#include <utility>
-#include <iostream>
namespace MEDCoupling
{
class ParaMESH;
- class Topology;
class ComponentTopology;
/*!
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+#include <cstddef>
#include <mpi.h>
-#include "CommInterface.hxx"
+#include <string>
+#include <utility>
+#include "DisjointDEC.hxx"
+#include "MCType.hxx"
+#include "MCAuto.hxx"
+#include "InterpKernelException.hxx"
#include "Topology.hxx"
-#include "BlockTopology.hxx"
#include "ComponentTopology.hxx"
#include "ParaFIELD.hxx"
-#include "MPIProcessorGroup.hxx"
-#include "ParaMESH.hxx"
-#include "DEC.hxx"
#include "InterpolationMatrix.hxx"
#include "InterpKernelDEC.hxx"
#include "ElementLocator.hxx"
{
InterpKernelDEC::InterpKernelDEC():
DisjointDEC(),
- _interpolation_matrix(0)
+ _interpolation_matrix(nullptr)
{
}
*/
InterpKernelDEC::InterpKernelDEC(ProcessorGroup& source_group, ProcessorGroup& target_group):
DisjointDEC(source_group, target_group),
- _interpolation_matrix(0)
+ _interpolation_matrix(nullptr)
{
}
InterpKernelDEC::InterpKernelDEC(const std::set<int>& src_ids, const std::set<int>& trg_ids,
const MPI_Comm& world_comm):
DisjointDEC(src_ids,trg_ids,world_comm),
- _interpolation_matrix(0)
+ _interpolation_matrix(nullptr)
{
}
*/
InterpKernelDEC::InterpKernelDEC(ProcessorGroup& generic_group, const std::string& source_group, const std::string& target_group):
DisjointDEC(generic_group.getProcIDsByName(source_group),generic_group.getProcIDsByName(target_group)),
- _interpolation_matrix(0)
+ _interpolation_matrix(nullptr)
{
}
ElementLocator locator(*_local_field, *_target_group, *_source_group);
//transferring option from InterpKernelDEC to ElementLocator
locator.copyOptions(*this);
- MEDCouplingPointSet* distant_mesh=0;
- mcIdType* distant_ids=0;
+ MEDCouplingPointSet* distant_mesh=nullptr;
+ mcIdType* distant_ids=nullptr;
std::string distantMeth;
for (int i=0; i<_target_group->size(); i++)
{
// int idistant_proc = (i+_source_group->myRank())%_target_group->size();
- int idistant_proc=i;
+ int const idistant_proc=i;
//gathers pieces of the target meshes that can intersect the local mesh
locator.exchangeMesh(idistant_proc,distant_mesh,distant_ids);
- if (distant_mesh !=0)
+ if (distant_mesh !=nullptr)
{
locator.exchangeMethod(_method,idistant_proc,distantMeth);
//adds the contribution of the distant mesh on the local one
- int idistant_proc_in_union=_union_group->translateRank(_target_group,idistant_proc);
+ int const idistant_proc_in_union=_union_group->translateRank(_target_group,idistant_proc);
//std::cout <<"add contribution from proc "<<idistant_proc_in_union<<" to proc "<<_union_group->myRank()<<std::endl;
_interpolation_matrix->addContribution(*distant_mesh,idistant_proc_in_union,distant_ids,_method,distantMeth);
distant_mesh->decrRef();
delete [] distant_ids;
- distant_mesh=0;
- distant_ids=0;
+ distant_mesh=nullptr;
+ distant_ids=nullptr;
}
}
_interpolation_matrix->finishContributionW(locator);
ElementLocator locator(*_local_field, *_source_group, *_target_group);
//transferring option from InterpKernelDEC to ElementLocator
locator.copyOptions(*this);
- MEDCouplingPointSet* distant_mesh=0;
- mcIdType* distant_ids=0;
+ MEDCouplingPointSet* distant_mesh=nullptr;
+ mcIdType* distant_ids=nullptr;
for (int i=0; i<_source_group->size(); i++)
{
// int idistant_proc = (i+_target_group->myRank())%_source_group->size();
- int idistant_proc=i;
+ int const idistant_proc=i;
//gathers pieces of the target meshes that can intersect the local mesh
locator.exchangeMesh(idistant_proc,distant_mesh,distant_ids);
//std::cout << " Data sent from "<<_union_group->myRank()<<" to source proc "<< idistant_proc<<std::endl;
- if (distant_mesh!=0)
+ if (distant_mesh!=nullptr)
{
std::string distantMeth;
locator.exchangeMethod(_method,idistant_proc,distantMeth);
distant_mesh->decrRef();
delete [] distant_ids;
- distant_mesh=0;
- distant_ids=0;
+ distant_mesh=nullptr;
+ distant_ids=nullptr;
}
}
_interpolation_matrix->finishContributionL(locator);
#define __INTERPKERNELDEC_HXX__
#include "DisjointDEC.hxx"
+#include "MCAuto.hxx"
+#include "MCType.hxx"
#include "MxN_Mapping.hxx"
#include "InterpolationOptions.hxx"
+#include <string>
namespace MEDCoupling
{
InterpKernelDEC(const std::set<int>& src_ids, const std::set<int>& trg_ids, const MPI_Comm& world_comm=MPI_COMM_WORLD);
InterpKernelDEC(ProcessorGroup& generic_group, const std::string& source_group, const std::string& target_group);
InterpKernelDEC(ProcessorGroup& generic_group, const std::string& interaction_group);
- virtual ~InterpKernelDEC();
+ ~InterpKernelDEC() override;
void release();
- void synchronize();
+ void synchronize() override;
void synchronizeWithDefaultValue(double val);
MCAuto<DataArrayIdType> retrieveNonFetchedIds() const;
- void recvData();
+ void recvData() override;
void recvData(double time);
- void sendData();
+ void sendData() override;
void sendData(double time , double deltatime);
- void prepareSourceDE() { }
- void prepareTargetDE() { }
+ void prepareSourceDE() override { }
+ void prepareTargetDE() override { }
private:
MCAuto<DataArrayIdType> retrieveNonFetchedIdsSource() const;
MCAuto<DataArrayIdType> retrieveNonFetchedIdsTarget() const;
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+#include "DECOptions.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingNormalizedUnstructuredMesh.txx"
+#include "Interpolation2D.hxx"
+#include "Interpolation3D.hxx"
+#include "Interpolation2D3D.hxx"
+#include "Interpolation2D1D.hxx"
+#include "Interpolation1D.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
+#include "MCAuto.hxx"
+#include "InterpKernelException.hxx"
#include "ParaMESH.hxx"
#include "ParaFIELD.hxx"
#include "ProcessorGroup.hxx"
#include "MxN_Mapping.hxx"
#include "InterpolationMatrix.hxx"
-#include "TranslationRotationMatrix.hxx"
-#include "Interpolation.hxx"
-#include "Interpolation1D.txx"
#include "Interpolation2DCurve.hxx"
-#include "Interpolation2D.txx"
#include "Interpolation3DSurf.hxx"
#include "Interpolation3D.txx"
#include "Interpolation2D3D.txx"
#include "Interpolation2D1D.txx"
#include "MEDCouplingUMesh.hxx"
-#include "MEDCouplingNormalizedUnstructuredMesh.txx"
#include "InterpolationOptions.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
#include "ElementLocator.hxx"
#include <algorithm>
+#include <string>
+#include <cstddef>
+#include <utility>
+#include <sstream>
+#include <limits>
using namespace std;
_source_group(source_group),
_target_group(target_group)
{
- mcIdType nbelems = source_field->getField()->getNumberOfTuples();
+ mcIdType const nbelems = source_field->getField()->getNumberOfTuples();
_row_offsets.resize(nbelems+1);
_coeffs.resize(nbelems);
_target_volume.resize(nbelems);
}
InterpolationMatrix::~InterpolationMatrix()
- {
- }
+ = default;
/*!
//creating the interpolator structure
vector<map<mcIdType,double> > surfaces;
//computation of the intersection volumes between source and target elements
- MEDCouplingUMesh *distant_supportC=dynamic_cast<MEDCouplingUMesh *>(&distant_support);
- MEDCouplingUMesh *source_supportC=dynamic_cast<MEDCouplingUMesh *>(_source_support);
+ auto *distant_supportC=dynamic_cast<MEDCouplingUMesh *>(&distant_support);
+ auto *source_supportC=dynamic_cast<MEDCouplingUMesh *>(_source_support);
if ( distant_support.getMeshDimension() == -1 )
{
if(source_supportC->getMeshDimension()==2 && source_supportC->getSpaceDimension()==2)
{
throw INTERP_KERNEL::Exception("no interpolator exists for these mesh and space dimensions ");
}
- bool needTargetSurf=isSurfaceComputationNeeded(targetMeth);
+ bool const needTargetSurf=isSurfaceComputationNeeded(targetMeth);
- MEDCouplingFieldDouble *target_triangle_surf=0;
+ MEDCouplingFieldDouble *target_triangle_surf=nullptr;
if(needTargetSurf)
target_triangle_surf = distant_support.getMeasureField(getMeasureAbsStatus());
fillDSFromVM(iproc_distant,distant_elems,surfaces,target_triangle_surf);
void InterpolationMatrix::finishContributionW(ElementLocator& elementLocator)
{
- NatureOfField nature=elementLocator.getLocalNature();
+ NatureOfField const nature=elementLocator.getLocalNature();
switch(nature)
{
case IntensiveMaximum:
void InterpolationMatrix::finishContributionL(ElementLocator& elementLocator)
{
- NatureOfField nature=elementLocator.getLocalNature();
+ NatureOfField const nature=elementLocator.getLocalNature();
switch(nature)
{
case IntensiveMaximum:
void InterpolationMatrix::computeConservVolDenoL(ElementLocator& elementLocator)
{
- int pol1=elementLocator.sendPolicyToWorkingSideL();
+ int const pol1=elementLocator.sendPolicyToWorkingSideL();
if(pol1==ElementLocator::NO_POST_TREATMENT_POLICY)
{
elementLocator.recvFromWorkingSideL();
throw INTERP_KERNEL::Exception("Not managed policy detected on lazy side : not implemented !");
}
- void InterpolationMatrix::computeIntegralDenoW(ElementLocator& elementLocator)
+ void InterpolationMatrix::computeIntegralDenoW(ElementLocator& /*elementLocator*/)
{
MEDCouplingFieldDouble *source_triangle_surf = _source_support->getMeasureField(getMeasureAbsStatus());
_deno_multiply.resize(_coeffs.size());
_deno_reverse_multiply=_target_volume;
}
- void InterpolationMatrix::computeRevIntegralDenoW(ElementLocator& elementLocator)
+ void InterpolationMatrix::computeRevIntegralDenoW(ElementLocator& /*elementLocator*/)
{
_deno_multiply=_target_volume;
MEDCouplingFieldDouble *source_triangle_surf = _source_support->getMeasureField(getMeasureAbsStatus());
*/
void InterpolationMatrix::prepare()
{
- mcIdType nbelems = _source_field->getField()->getNumberOfTuples();
+ mcIdType const nbelems = _source_field->getField()->getNumberOfTuples();
for (mcIdType ielem=0; ielem < nbelems; ielem++)
{
_row_offsets[ielem+1]+=_row_offsets[ielem];
#ifndef __INTERPOLATIONMATRIX_HXX__
#define __INTERPOLATIONMATRIX_HXX__
+#include "MCType.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingFieldDouble.hxx"
+#include "MEDCouplingPointSet.hxx"
#include "MPIAccessDEC.hxx"
#include "MxN_Mapping.hxx"
#include "InterpolationOptions.hxx"
#include "DECOptions.hxx"
+#include "ParaFIELD.hxx"
+#include <string>
+#include <vector>
+#include <utility>
namespace MEDCoupling
{
//
#include "LinearTimeInterpolator.hxx"
+#include "TimeInterpolator.hxx"
using namespace std;
}
LinearTimeInterpolator::~LinearTimeInterpolator()
- {
- }
+ = default;
void LinearTimeInterpolator::doInterp( double time0, double time1, double time,
- int recvcount , int nbuff0, int nbuff1,
+ int recvcount , int /*nbuff0*/, int /*nbuff1*/,
int **recvbuff0, int **recvbuff1, int *result )
{
for(int i = 0 ; i < recvcount ; i++ )
}
void LinearTimeInterpolator::doInterp( double time0, double time1, double time,
- int recvcount , int nbuff0, int nbuff1,
+ int recvcount , int /*nbuff0*/, int /*nbuff1*/,
double **recvbuff0, double **recvbuff1,
double *result )
{
#include "TimeInterpolator.hxx"
-#include <map>
-#include <iostream>
namespace MEDCoupling
{
public:
LinearTimeInterpolator( double InterpPrecision=0, int nStepBefore=1,
int nStepAfter=1 ) ;
- virtual ~LinearTimeInterpolator();
+ ~LinearTimeInterpolator() override;
void doInterp( double time0, double time1, double time, int recvcount,
int nbuff0, int nbuff1,
- int **recvbuff0, int **recvbuff1, int *result );
+ int **recvbuff0, int **recvbuff1, int *result ) override;
void doInterp( double time0, double time1, double time, int recvcount,
int nbuff0, int nbuff1,
- double **recvbuff0, double **recvbuff1, double *result );
+ double **recvbuff0, double **recvbuff1, double *result ) override;
};
}
#include "MPIAccess/MPIAccess.hxx"
-#include "InterpolationUtils.hxx"
+#include "MPIProcessorGroup.hxx"
+#include <cstddef>
+#include <cstdlib>
#include <iostream>
+#include <limits>
using namespace std;
int MPIAccess::newRequest( MPI_Datatype datatype, int tag , int destsourcerank ,
bool fromsourcerank , bool asynchronous )
{
- RequestStruct *mpiaccessstruct = new RequestStruct;
+ auto *mpiaccessstruct = new RequestStruct;
mpiaccessstruct->MPITag = tag ;
mpiaccessstruct->MPIDatatype = datatype ;
mpiaccessstruct->MPITarget = destsourcerank ;
// Returns in ArrayOfSendRequests with the dimension "size" all the
// SendRequestIds
- int MPIAccess::sendRequestIds(int size, int *ArrayOfSendRequests)
+ int MPIAccess::sendRequestIds(int /*size*/, int *ArrayOfSendRequests)
{
int destrank ;
int i = 0 ;
// Returns in ArrayOfRecvRequests with the dimension "size" all the
// RecvRequestIds
- int MPIAccess::recvRequestIds(int size, int *ArrayOfRecvRequests)
+ int MPIAccess::recvRequestIds(int /*size*/, int *ArrayOfRecvRequests)
{
int sourcerank ;
int i = 0 ;
int MPItag = newSendTag( datatype, target , aMethodIdent , false , RequestId ) ;
if ( aMethodIdent == _message_time )
{
- TimeMessage *aTimeMsg = (TimeMessage *) buffer ;
+ auto *aTimeMsg = (TimeMessage *) buffer ;
aTimeMsg->tag = MPItag ;
}
deleteRequest( RequestId ) ;
{
int sts = MPI_SUCCESS ;
RequestId = -1 ;
- if ( OutCount != NULL )
+ if ( OutCount != nullptr )
*OutCount = -1 ;
if ( count )
{
setMPICompleted( RequestId , true ) ;
deleteStatus( RequestId ) ;
}
- if ( OutCount != NULL )
+ if ( OutCount != nullptr )
*OutCount = outcount ;
if ( _trace )
cout << "MPIAccess::Recv" << _my_rank << " RecvRequestId "
int MPItag = newSendTag( datatype, target , aMethodIdent , true , RequestId ) ;
if ( aMethodIdent == _message_time )
{
- TimeMessage *aTimeMsg = (TimeMessage *) buffer ;
+ auto *aTimeMsg = (TimeMessage *) buffer ;
aTimeMsg->tag = MPItag ;
}
MPI_Request *aSendRequest = MPIRequest( RequestId ) ;
<< RecvRequestId << " outcount " << outcount << endl ;
}
}
- if ( OutCount != NULL )
+ if ( OutCount != nullptr )
{
*OutCount = outcount ;
if ( _trace )
return status ;
}
- int MPIAccess::waitAny(int count, int *array_of_RequestIds, int &RequestId)
+ int MPIAccess::waitAny(int /*count*/, int * /*array_of_RequestIds*/, int &RequestId)
{
int status = MPI_ERR_OTHER ;
RequestId = -1 ;
return status ;
}
- int MPIAccess::testAny(int count, int *array_of_RequestIds, int &RequestId, int &flag)
+ int MPIAccess::testAny(int /*count*/, int * /*array_of_RequestIds*/, int &RequestId, int &flag)
{
int status = MPI_ERR_OTHER ;
RequestId = -1 ;
return retstatus ;
}
- int MPIAccess::waitSome(int count, int *array_of_RequestIds, int outcount,
- int *outarray_of_RequestIds)
+ int MPIAccess::waitSome(int /*count*/, int * /*array_of_RequestIds*/, int /*outcount*/,
+ int * /*outarray_of_RequestIds*/)
{
int status = MPI_ERR_OTHER ;
cout << "MPIAccess::WaitSome not yet implemented" << endl ;
return status ;
}
- int MPIAccess::testSome(int count, int *array_of_RequestIds, int outcounts,
- int *outarray_of_RequestIds)
+ int MPIAccess::testSome(int /*count*/, int * /*array_of_RequestIds*/, int /*outcounts*/,
+ int * /*outarray_of_RequestIds*/)
{
int status = MPI_ERR_OTHER ;
cout << "MPIAccess::TestSome not yet implemented" << endl ;
#define __MPIACCESS_HXX__
#include "CommInterface.hxx"
-#include "ProcessorGroup.hxx"
#include "MPIProcessorGroup.hxx"
-#include <map>
+#include <cstddef>
+#include <iostream>
#include <list>
#include <vector>
-#include <iostream>
+#include <map>
namespace MEDCoupling
{
int ISend(void* buffer, int count, MPI_Datatype datatype, int target,
int &RequestId) ;
int recv(void* buffer, int count, MPI_Datatype datatype, int source,
- int &RequestId, int *OutCount=NULL) ;
+ int &RequestId, int *OutCount=nullptr) ;
int IRecv(void* buffer, int count, MPI_Datatype datatype, int source,
int &RequestId) ;
int sendRecv(void* sendbuf, int sendcount, MPI_Datatype sendtype, int dest,
int &SendRequestId, void* recvbuf, int recvcount,
MPI_Datatype recvtype, int source,
- int &RecvRequestId, int *OutCount=NULL) ;
+ int &RecvRequestId, int *OutCount=nullptr) ;
int ISendRecv(void* sendbuf, int sendcount, MPI_Datatype sendtype, int dest,
int &SendRequestId, void* recvbuf, int recvcount,
MPI_Datatype recvtype, int source, int &RecvRequestId) ;
struct RequestStruct *aRequestStruct = _map_of_request_struct[ RequestId ];
if ( aRequestStruct )
return aRequestStruct->MPIStatus;
- return NULL ;
+ return nullptr ;
}
// Set the MPICompleted field of the structure Request corresponding to RequestId
//
#include "MPIAccess/MPIAccessDEC.hxx"
+#include "ProcessorGroup.hxx"
+#include "MPIProcessorGroup.hxx"
+#include "MPIAccess.hxx"
+#include "DECOptions.hxx"
+#include "LinearTimeInterpolator.hxx"
#include <cstring>
+#include <iostream>
using namespace std;
{
procs.insert(i) ;
}
-
MPIProcessorGroup *mpilg = static_cast<MPIProcessorGroup *>(const_cast<ProcessorGroup *>(&source_group));
+
auto *mpilg = static_cast<MPIProcessorGroup *>(const_cast<ProcessorGroup *>(&source_group));
_MPI_union_group = new MEDCoupling::MPIProcessorGroup( union_group->getCommInterface(),procs,mpilg->getWorldComm());
delete union_group ;
_my_rank = _MPI_union_group->myRank() ;
_data_messages_type->resize( _group_size ) ;
_data_messages = new vector< vector< void * > > ;
_data_messages->resize( _group_size ) ;
- _time_interpolator = NULL ;
+ _time_interpolator = nullptr ;
_map_of_send_buffers = new map< int , SendBuffStruct * > ;
}
switch ( aTimeInterp )
{
case WithoutTimeInterp :
- _time_interpolator = NULL ;
+ _time_interpolator = nullptr ;
_n_step_before = 0 ;
_n_step_after = 0 ;
break ;
checkSent() ;
//DoSend + DoRecv : SendRecv
- SendBuffStruct * aSendDataStruct = NULL ;
+ SendBuffStruct * aSendDataStruct = nullptr ;
if ( _asynchronous && sendbuf )
{
aSendDataStruct = new SendBuffStruct ;
}
//DoSend + DoRecv : SendRecv
- SendBuffStruct * aSendDataStruct = NULL ;
+ SendBuffStruct * aSendDataStruct = nullptr ;
if ( _asynchronous && sendbuf )
{
aSendDataStruct = new SendBuffStruct ;
int SendTimeRequestId ;
int SendDataRequestId ;
- if ( _time_interpolator == NULL )
+ if ( _time_interpolator == nullptr )
{
return MPI_ERR_OTHER ;
}
}
//DoSend : Time + SendBuff
- SendBuffStruct * aSendTimeStruct = NULL ;
- SendBuffStruct * aSendDataStruct = NULL ;
+ SendBuffStruct * aSendTimeStruct = nullptr ;
+ SendBuffStruct * aSendDataStruct = nullptr ;
if ( sendbuf && sendcount )
{
- TimeMessage * aSendTimeMessage = new TimeMessage ;
+ auto * aSendTimeMessage = new TimeMessage ;
if ( _asynchronous )
{
aSendTimeStruct = new SendBuffStruct ;
int SendTimeRequestId ;
int SendDataRequestId ;
- if ( _time_interpolator == NULL )
+ if ( _time_interpolator == nullptr )
{
return MPI_ERR_OTHER ;
}
+ And if we are in synchronous mode we delete the SendMessages.
*/
//DoSend : Time + SendBuff
- SendBuffStruct * aSendTimeStruct = NULL ;
- SendBuffStruct * aSendDataStruct = NULL ;
+ SendBuffStruct * aSendTimeStruct = nullptr ;
+ SendBuffStruct * aSendDataStruct = nullptr ;
if ( sendbuf )
{
- TimeMessage * aSendTimeMessage = new TimeMessage ;
+ auto * aSendTimeMessage = new TimeMessage ;
if ( _asynchronous )
{
aSendTimeStruct = new SendBuffStruct ;
{
int sts = MPI_SUCCESS ;
int flag = WithWait ;
- int size = _MPI_access->sendRequestIdsSize() ;
+ int const size = _MPI_access->sendRequestIdsSize() ;
int * ArrayOfSendRequests = new int[ size ] ;
- int nSendRequest = _MPI_access->sendRequestIds( size , ArrayOfSendRequests ) ;
- bool SendTrace = false ;
+ int const nSendRequest = _MPI_access->sendRequestIds( size , ArrayOfSendRequests ) ;
+ bool const SendTrace = false ;
int i ;
for ( i = 0 ; i < nSendRequest ; i++ )
{
#ifndef __MPIACCESSDEC_HXX__
#define __MPIACCESSDEC_HXX__
-#include "DEC.hxx"
-#include "LinearTimeInterpolator.hxx"
+#include "DECOptions.hxx"
-#include <map>
+#include <cstdlib>
#include <iostream>
#include "MPIAccess.hxx"
+#include "ProcessorGroup.hxx"
+#include "MPIProcessorGroup.hxx"
+#include "TimeInterpolator.hxx"
namespace MEDCoupling
{
#include "ProcessorGroup.hxx"
#include "MPIProcessorGroup.hxx"
#include "CommInterface.hxx"
-#include "InterpolationUtils.hxx"
+#include <cstdlib>
#include <iostream>
-#include <set>
-#include <algorithm>
+#include <string>
#include "mpi.h"
using namespace std;
_comm_interface.groupFree(&group_world);
throw INTERP_KERNEL::Exception("invalid argument in MPIProcessorGroup constructor (comm,pfirst,plast)");
}
- int nprocs=pend-pstart+1;
+ int const nprocs=pend-pstart+1;
int* ranks=new int[nprocs];
for (int i=pstart; i<=pend;i++)
{
*/
int MPIProcessorGroup::translateRank(const ProcessorGroup* group, int rank) const
{
- const MPIProcessorGroup* targetgroup=dynamic_cast<const MPIProcessorGroup*>(group);
+ const auto* targetgroup=dynamic_cast<const MPIProcessorGroup*>(group);
int local_rank;
MPI_Group_translate_ranks(targetgroup->_group, 1, &rank, _group, &local_rank);
return local_rank;
ProcessorGroup* MPIProcessorGroup::createComplementProcGroup() const
{
set <int> procs;
- int world_size=_comm_interface.worldSize();
+ int const world_size=_comm_interface.worldSize();
for (int i=0; i<world_size; i++)
procs.insert(i);
for (set<int>::const_iterator iter=_proc_ids.begin(); iter!= _proc_ids.end(); iter++)
#include "ProcessorGroup.hxx"
-#include <set>
#include <mpi.h>
+#include <string>
namespace MEDCoupling
{
MPIProcessorGroup (const ProcessorGroup& proc_group, std::set<int> proc_ids);
MPIProcessorGroup(const CommInterface& interface,int pstart, int pend, const MPI_Comm& world_comm=MPI_COMM_WORLD);
MPIProcessorGroup(const MPIProcessorGroup& other);
- virtual ~MPIProcessorGroup();
+ ~MPIProcessorGroup() override;
void release();
- virtual MPIProcessorGroup *deepCopy() const;
- virtual ProcessorGroup* fuse (const ProcessorGroup&) const;
- void intersect (ProcessorGroup&) { }
- int myRank() const;
- bool containsMyRank() const { int rank; MPI_Group_rank(_group, &rank); return (rank!=MPI_UNDEFINED); }
- int translateRank(const ProcessorGroup* group, int rank) const;
+ MPIProcessorGroup *deepCopy() const override;
+ ProcessorGroup* fuse (const ProcessorGroup&) const override;
+ void intersect (ProcessorGroup&) override { }
+ int myRank() const override;
+ bool containsMyRank() const override { int rank; MPI_Group_rank(_group, &rank); return (rank!=MPI_UNDEFINED); }
+ int translateRank(const ProcessorGroup* group, int rank) const override;
const MPI_Comm* getComm() const { return &_comm; }
- ProcessorGroup* createComplementProcGroup() const;
- ProcessorGroup* createProcGroup() const;
+ ProcessorGroup* createComplementProcGroup() const override;
+ ProcessorGroup* createProcGroup() const override;
MPI_Comm getWorldComm() { return _world_comm; }
private:
void updateMPISpecificAttributes();
//
#include "CommInterface.hxx"
+#include "DECOptions.hxx"
+#include "MCType.hxx"
+#include "ParaIdType.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingFieldDouble.hxx"
+#include "MEDCouplingMemArray.hxx"
#include "ProcessorGroup.hxx"
#include "MPIProcessorGroup.hxx"
#include "MPIAccessDEC.hxx"
+#include <cstddef>
+#include <ostream>
#include "MxN_Mapping.hxx"
using namespace std;
void MxN_Mapping::prepareSendRecv()
{
- CommInterface comm_interface=_union_group->getCommInterface();
+ CommInterface const comm_interface=_union_group->getCommInterface();
// sending count pattern
int* nbsend=new int[_union_group->size()];
int* nbrecv=new int[_union_group->size()];
nbsend[i]=_send_proc_offsets[i+1]-_send_proc_offsets[i];
}
- MPIProcessorGroup* group = static_cast<MPIProcessorGroup*>(_union_group);
+ auto* group = static_cast<MPIProcessorGroup*>(_union_group);
const MPI_Comm* comm=group->getComm();
comm_interface.allToAll(nbsend, 1, MPI_INT,
nbrecv, 1, MPI_INT,
delete[] nbrecv;
_recv_ids.resize(_recv_proc_offsets[_union_group->size()]);
- mcIdType* isendbuf=0;
- mcIdType* irecvbuf=0;
+ mcIdType* isendbuf=nullptr;
+ mcIdType* irecvbuf=nullptr;
if (_sending_ids.size()>0)
isendbuf = new mcIdType[_sending_ids.size()];
if (_recv_ids.size()>0)
*/
void MxN_Mapping::sendRecv(double* sendfield, MEDCouplingFieldDouble& field) const
{
- CommInterface comm_interface=_union_group->getCommInterface();
- const MPIProcessorGroup* group = static_cast<const MPIProcessorGroup*>(_union_group);
+ CommInterface const comm_interface=_union_group->getCommInterface();
+ const auto* group = static_cast<const MPIProcessorGroup*>(_union_group);
int nbcomp=(int)field.getArray()->getNumberOfComponents();
- double* sendbuf=0;
- double* recvbuf=0;
+ double* sendbuf=nullptr;
+ double* recvbuf=nullptr;
if (_sending_ids.size() >0)
sendbuf = new double[_sending_ids.size()*nbcomp];
if (_recv_ids.size()>0)
recvptr++;
}
}
- if (sendbuf!=0 && getAllToAllMethod()== Native)
+ if (sendbuf!=nullptr && getAllToAllMethod()== Native)
delete[] sendbuf;
- if (recvbuf !=0)
+ if (recvbuf !=nullptr)
delete[] recvbuf;
delete[] sendcounts;
delete[] recvcounts;
*/
void MxN_Mapping::reverseSendRecv(double* recvfield, MEDCouplingFieldDouble& field) const
{
- CommInterface comm_interface=_union_group->getCommInterface();
- const MPIProcessorGroup* group = static_cast<const MPIProcessorGroup*>(_union_group);
+ CommInterface const comm_interface=_union_group->getCommInterface();
+ const auto* group = static_cast<const MPIProcessorGroup*>(_union_group);
int nbcomp=(int)field.getArray()->getNumberOfComponents();
- double* sendbuf=0;
- double* recvbuf=0;
+ double* sendbuf=nullptr;
+ double* recvbuf=nullptr;
if (_recv_ids.size() >0)
sendbuf = new double[_recv_ids.size()*nbcomp];
if (_sending_ids.size()>0)
recvptr++;
}
}
- if (sendbuf!=0 && getAllToAllMethod() == Native)
+ if (sendbuf!=nullptr && getAllToAllMethod() == Native)
delete[] sendbuf;
- if (recvbuf!=0)
+ if (recvbuf!=nullptr)
delete[] recvbuf;
delete[] sendcounts;
delete[] recvcounts;
#ifndef __MXN_MAPPING_HXX__
#define __MXN_MAPPING_HXX__
+#include "MCType.hxx"
+#include "MCAuto.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "MPIAccessDEC.hxx"
#include "DECOptions.hxx"
-#include <vector>
+#include <ostream>
namespace MEDCoupling
{
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+#include <cstddef>
#include <mpi.h>
-#include "CommInterface.hxx"
+#include <string>
#include "Topology.hxx"
-#include "BlockTopology.hxx"
#include "ComponentTopology.hxx"
#include "ParaFIELD.hxx"
-#include "MPIProcessorGroup.hxx"
#include "DEC.hxx"
#include "NonCoincidentDEC.hxx"
}
NonCoincidentDEC::NonCoincidentDEC()
- {
- }
+ = default;
/*! Constructor of a non coincident \ref para-dec "DEC" with
* a source group on which lies a field lying on a mesh and a
{}
NonCoincidentDEC::~NonCoincidentDEC()
- {
- }
+ = default;
/*! Synchronization process. Calling this method
* synchronizes the topologies so that the target side
{
int nbelems = _local_field->getField()->getSupport()->getMesh()->getNumberOfElements(MED_EN::MED_CELL, MED_EN::MED_ALL_ELEMENTS);
int nbcomp = _local_field->getField()->getNumberOfComponents();
- double* values = new double [nbelems*nbcomp];
+ auto* values = new double [nbelems*nbcomp];
fvm_locator_exchange_point_var(_locator,
0,
values,
{
const double* values=_local_field->getField()->getValue();
int nbcomp = _local_field->getField()->getNumberOfComponents();
- double* distant_values = new double [_nb_distant_points*nbcomp];
+ auto* distant_values = new double [_nb_distant_points*nbcomp];
//cheap interpolation : the value of the cell is transferred to the point
for (int i=0; i<_nb_distant_points; i++)
#define __NONCOINCIDENTDEC_HXX__
#include "DEC.hxx"
+#include "ProcessorGroup.hxx"
struct _fvm_locator_t;
NonCoincidentDEC();
NonCoincidentDEC(ProcessorGroup& , ProcessorGroup&);
- virtual ~NonCoincidentDEC();
+ ~NonCoincidentDEC() override;
- void synchronize();
+ void synchronize() override;
void recvData();
#include "OverlapDEC.hxx"
#include "CommInterface.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingMesh.hxx"
#include "ParaMESH.hxx"
#include "ParaFIELD.hxx"
#include "MPIProcessorGroup.hxx"
#include "OverlapElementLocator.hxx"
#include "OverlapInterpolationMatrix.hxx"
#include "ICoCoMEDDoubleField.hxx"
+#include <string>
+#include <ostream>
namespace MEDCoupling
{
OverlapDEC::OverlapDEC(const std::set<int>& procIds, const MPI_Comm& world_comm):
_load_balancing_algo(1),
- _own_group(true),_interpolation_matrix(0), _locator(0),
+ _own_group(true),_interpolation_matrix(nullptr), _locator(nullptr),
_default_field_value(0.0),
- _source_field(0),_own_source_field(false),
- _target_field(0),_own_target_field(false),
+ _source_field(nullptr),_own_source_field(false),
+ _target_field(nullptr),_own_target_field(false),
_comm(MPI_COMM_NULL)
{
- MEDCoupling::CommInterface comm;
+ MEDCoupling::CommInterface const comm;
int *ranks_world=new int[procIds.size()]; // ranks of sources and targets in world_comm
std::copy(procIds.begin(),procIds.end(),ranks_world);
MPI_Group group,world_group;
comm.groupFree(&world_group);
if(_comm==MPI_COMM_NULL)
{
- _group=0;
+ _group=nullptr;
return ;
}
std::set<int> idsUnion;
_locator = nullptr;
if (_comm != MPI_COMM_NULL)
{
- MEDCoupling::CommInterface comm;
+ MEDCoupling::CommInterface const comm;
comm.commFree(&_comm);
}
_comm = MPI_COMM_NULL;
_locator->copyOptions(*this);
_locator->exchangeMeshes(*_interpolation_matrix);
std::vector< std::pair<int,int> > jobs=_locator->getToDoList();
- std::string srcMeth=_locator->getSourceMethod();
- std::string trgMeth=_locator->getTargetMethod();
+ std::string const srcMeth=_locator->getSourceMethod();
+ std::string const trgMeth=_locator->getTargetMethod();
for(std::vector< std::pair<int,int> >::const_iterator it=jobs.begin();it!=jobs.end();it++)
{
const MEDCouplingPointSet *src=_locator->getSourceMesh((*it).first);
if(!isInGroup())
return ;
- ParaMESH *paramesh = new ParaMESH(static_cast<MEDCouplingPointSet *>(const_cast<MEDCouplingMesh *>(field->getMesh())),
+ auto *paramesh = new ParaMESH(static_cast<MEDCouplingPointSet *>(const_cast<MEDCouplingMesh *>(field->getMesh())),
*_group,field->getMesh()->getName());
- ParaFIELD *tmpField=new ParaFIELD(field, paramesh, *_group);
+ auto *tmpField=new ParaFIELD(field, paramesh, *_group);
tmpField->setOwnSupport(true);
attachSourceLocalField(tmpField,true);
}
if(!isInGroup())
return ;
- ParaMESH *paramesh = new ParaMESH(static_cast<MEDCouplingPointSet *>(const_cast<MEDCouplingMesh *>(field->getMesh())),
+ auto *paramesh = new ParaMESH(static_cast<MEDCouplingPointSet *>(const_cast<MEDCouplingMesh *>(field->getMesh())),
*_group,field->getMesh()->getName());
- ParaFIELD *tmpField=new ParaFIELD(field, paramesh, *_group);
+ auto *tmpField=new ParaFIELD(field, paramesh, *_group);
tmpField->setOwnSupport(true);
attachTargetLocalField(tmpField,true);
}
#include "DEC.hxx"
#include "InterpolationOptions.hxx"
+#include "MEDCouplingFieldDouble.hxx"
#include <mpi.h>
-#include <string>
+#include <ostream>
namespace ICoCo {
class MEDDoubleField;
{
public:
OverlapDEC(const std::set<int>& procIds,const MPI_Comm& world_comm=MPI_COMM_WORLD);
- virtual ~OverlapDEC();
+ ~OverlapDEC() override;
void release();
- void sendRecvData(bool way=true);
+ void sendRecvData(bool way=true) override;
void sendData();
void recvData();
- void synchronize();
+ void synchronize() override;
void attachSourceLocalField(ParaFIELD *field, bool ownPt=false);
void attachTargetLocalField(ParaFIELD *field, bool ownPt=false);
void attachSourceLocalField(MEDCouplingFieldDouble *field);
#include "OverlapElementLocator.hxx"
#include "CommInterface.hxx"
+#include "MCType.hxx"
+#include "ParaIdType.hxx"
+#include "MEDCouplingMesh.hxx"
#include "Topology.hxx"
-#include "BlockTopology.hxx"
#include "ParaFIELD.hxx"
#include "ParaMESH.hxx"
#include "ProcessorGroup.hxx"
#include "MPIProcessorGroup.hxx"
#include "OverlapInterpolationMatrix.hxx"
-#include "MEDCouplingFieldDouble.hxx"
#include "MEDCouplingFieldDiscretization.hxx"
-#include "DirectedBoundingBox.hxx"
+#include "MEDCouplingFieldDouble.hxx"
#include "InterpKernelAutoPtr.hxx"
#include <limits>
+#include <ostream>
+#include <string>
using namespace std;
const ProcessorGroup& group, double epsAbs, int workSharingAlgo)
: _local_source_field(sourceField),
_local_target_field(targetField),
- _local_source_mesh(0),
- _local_target_mesh(0),
- _domain_bounding_boxes(0),
+ _local_source_mesh(nullptr),
+ _local_target_mesh(nullptr),
+ _domain_bounding_boxes(nullptr),
_epsAbs(epsAbs),
_group(group)
{
const MPI_Comm *OverlapElementLocator::getCommunicator() const
{
- const MPIProcessorGroup* group=static_cast<const MPIProcessorGroup*>(&_group);
+ const auto* group=static_cast<const MPIProcessorGroup*>(&_group);
return group->getComm();
}
void OverlapElementLocator::computeBoundingBoxesAndInteractionList()
{
- CommInterface comm_interface=_group.getCommInterface();
- const MPIProcessorGroup* group=static_cast<const MPIProcessorGroup*> (&_group);
+ CommInterface const comm_interface=_group.getCommInterface();
+ const auto* group=static_cast<const MPIProcessorGroup*> (&_group);
_local_space_dim=0;
if(_local_source_mesh)
_local_space_dim=_local_source_mesh->getSpaceDimension();
_local_space_dim=_local_target_mesh->getSpaceDimension();
//
const MPI_Comm* comm = group->getComm();
- int bbSize=2*2*_local_space_dim;//2 (for source/target) 2 (min/max)
+ int const bbSize=2*2*_local_space_dim;//2 (for source/target) 2 (min/max)
_domain_bounding_boxes=new double[bbSize*_group.size()];
INTERP_KERNEL::AutoPtr<double> minmax=new double[bbSize];
//Format minmax : Xmin_src,Xmax_src,Ymin_src,Ymax_src,Zmin_src,Zmax_src,Xmin_trg,Xmax_trg,Ymin_trg,Ymax_trg,Zmin_trg,Zmax_trg
//If _group.myRank()==myPair.first, current proc should fetch target mesh of myPair.second (if different from _group.myRank()).
//If _group.myRank()==myPair.second, current proc should fetch source mesh of myPair.second.
- int myProcId=_group.myRank();
+ int const myProcId=_group.myRank();
_to_do_list=_all_todo_lists[myProcId];
#ifdef DEC_DEBUG
//
// Final formatting - extract remaining keys in each map:
//
- int myProcId = _group.myRank();
+ int const myProcId = _group.myRank();
_all_todo_lists.resize(grp_size);
procID = 0;
for(const auto& itVector: full_set)
{
// Feeding now '_procs_to_send*'. A same id can appears twice. The second parameter in pair means what
// to send true=source, false=target
- int myProcId=_group.myRank();
+ int const myProcId=_group.myRank();
_procs_to_send_mesh.clear();
_procs_to_send_field.clear();
for(int i=0;i<_group.size();i++)
*/
void OverlapElementLocator::exchangeMeshes(OverlapInterpolationMatrix& matrix)
{
- int myProcId=_group.myRank();
+ int const myProcId=_group.myRank();
//starting to receive every procs whose id is lower than myProcId.
std::vector<Proc_SrcOrTgt> firstRcv, secondRcv;
for (const ProcCouple& pc: _to_do_list)
const MEDCouplingPointSet *OverlapElementLocator::getSourceMesh(int procId) const
{
- int myProcId=_group.myRank();
+ int const myProcId=_group.myRank();
if(myProcId==procId)
return _local_source_mesh;
Proc_SrcOrTgt p(procId,true);
const DataArrayIdType *OverlapElementLocator::getSourceIds(int procId) const
{
- int myProcId=_group.myRank();
+ int const myProcId=_group.myRank();
if(myProcId==procId)
- return 0;
+ return nullptr;
Proc_SrcOrTgt p(procId,true);
std::map<Proc_SrcOrTgt, AutoDAInt >::const_iterator it=_remote_elems.find(p);
return (*it).second;
const MEDCouplingPointSet *OverlapElementLocator::getTargetMesh(int procId) const
{
- int myProcId=_group.myRank();
+ int const myProcId=_group.myRank();
if(myProcId==procId)
return _local_target_mesh;
Proc_SrcOrTgt p(procId,false);
const DataArrayIdType *OverlapElementLocator::getTargetIds(int procId) const
{
- int myProcId=_group.myRank();
+ int const myProcId=_group.myRank();
if(myProcId==procId)
- return 0;
+ return nullptr;
Proc_SrcOrTgt p(procId,false);
std::map<Proc_SrcOrTgt, AutoDAInt >::const_iterator it=_remote_elems.find(p);
return (*it).second;
for (int idim=0; idim < _local_space_dim; idim++)
{
- bool intersects = (target_bb[idim*2]<source_bb[idim*2+1]+_epsAbs)
+ bool const intersects = (target_bb[idim*2]<source_bb[idim*2+1]+_epsAbs)
&& (source_bb[idim*2]<target_bb[idim*2+1]+_epsAbs);
if (!intersects)
return false;
#endif
//int myProcId=_group.myRank();
- const double *distant_bb=0;
- MEDCouplingPointSet *local_mesh=0;
- const ParaFIELD *field=0;
+ const double *distant_bb=nullptr;
+ MEDCouplingPointSet *local_mesh=nullptr;
+ const ParaFIELD *field=nullptr;
if(sourceOrTarget)//source for local mesh but target for distant mesh
{
distant_bb=_domain_bounding_boxes+procId*2*2*_local_space_dim+2*_local_space_dim;
}
AutoDAInt elems=local_mesh->getCellsInBoundingBox(distant_bb,getBoundingBoxAdjustment());
DataArrayIdType *old2new_map;
- MEDCouplingPointSet *send_mesh=static_cast<MEDCouplingPointSet *>(field->getField()->buildSubMeshData(elems->begin(),elems->end(),old2new_map));
+ auto *send_mesh=static_cast<MEDCouplingPointSet *>(field->getField()->buildSubMeshData(elems->begin(),elems->end(),old2new_map));
if(sourceOrTarget)
matrix.keepTracksOfSourceIds(procId,old2new_map);
else
scout << "(" << rank << ") RCV part of " << st << " FROM: " << procId;
std::cout << scout.str() << "\n";
#endif
- DataArrayIdType *old2new_map=0;
- MEDCouplingPointSet *m=0;
+ DataArrayIdType *old2new_map=nullptr;
+ MEDCouplingPointSet *m=nullptr;
receiveMesh(procId,m,old2new_map);
Proc_SrcOrTgt p(procId,sourceOrTarget);
_remote_meshes[p]=m;
void OverlapElementLocator::sendMesh(int procId, const MEDCouplingPointSet *mesh, const DataArrayIdType *idsToSend) const
{
- CommInterface comInterface=_group.getCommInterface();
+ CommInterface const comInterface=_group.getCommInterface();
// First stage : exchanging sizes
vector<double> tinyInfoLocalD;//tinyInfoLocalD not used for the moment
comInterface.send(&lgth,2,MPI_ID_TYPE,procId,START_TAG_MESH_XCH,*_comm);
comInterface.send(&tinyInfoLocal[0],(int)tinyInfoLocal.size(),MPI_ID_TYPE,procId,START_TAG_MESH_XCH+1,*comm);
//
- DataArrayIdType *v1Local=0;
- DataArrayDouble *v2Local=0;
+ DataArrayIdType *v1Local=nullptr;
+ DataArrayDouble *v2Local=nullptr;
mesh->serialize(v1Local,v2Local);
comInterface.send(v1Local->getPointer(),(int)v1Local->getNbOfElems(),MPI_ID_TYPE,procId,START_TAG_MESH_XCH+2,*comm);
comInterface.send(v2Local->getPointer(),(int)v2Local->getNbOfElems(),MPI_DOUBLE,procId,START_TAG_MESH_XCH+3,*comm);
mcIdType lgth[2];
MPI_Status status;
const MPI_Comm *comm=getCommunicator();
- CommInterface comInterface=_group.getCommInterface();
+ CommInterface const comInterface=_group.getCommInterface();
comInterface.recv(lgth,2,MPI_ID_TYPE,procId,START_TAG_MESH_XCH,*_comm,&status);
std::vector<mcIdType> tinyInfoDistant(lgth[0]);
ids=DataArrayIdType::New();
#define __OVERLAPELEMENTLOCATOR_HXX__
#include "InterpolationOptions.hxx"
-#include "MEDCouplingNatureOfField.hxx"
+#include "MCType.hxx"
#include "MEDCouplingPointSet.hxx"
-#include "MEDCouplingMemArray.hxx"
#include "MCAuto.hxx"
#include <mpi.h>
-#include <vector>
-#include <map>
-#include <set>
+#include <utility>
+#include <string>
+#include <ostream>
//#define DEC_DEBUG
class ProcessorGroup;
class OverlapInterpolationMatrix;
- typedef std::pair<int,int> ProcCouple; // a couple of proc IDs, typically used to define a exchange betw 2 procs
+ using ProcCouple = std::pair<int, int>; // a couple of proc IDs, typically used to define a exchange betw 2 procs
class OverlapElementLocator : public INTERP_KERNEL::InterpolationOptions
{
void sendMesh(int procId, const MEDCouplingPointSet *mesh, const DataArrayIdType *idsToSend) const;
void receiveMesh(int procId, MEDCouplingPointSet* &mesh, DataArrayIdType *&ids) const;
private:
- typedef MCAuto< MEDCouplingPointSet > AutoMCPointSet;
- typedef MCAuto< DataArrayIdType > AutoDAInt;
- typedef std::pair<int,bool> Proc_SrcOrTgt; ///< a key indicating a proc ID and whether the data is for source mesh/field or target mesh/field
+ using AutoMCPointSet = MCAuto<MEDCouplingPointSet>;
+ using AutoDAInt = MCAuto<DataArrayInt64>;
+ using Proc_SrcOrTgt = std::pair<int, bool>; ///< a key indicating a proc ID and whether the data is for source mesh/field or target mesh/field
static const int START_TAG_MESH_XCH;
// Author : Anthony Geay (CEA/DEN)
#include "OverlapInterpolationMatrix.hxx"
+#include "DECOptions.hxx"
+#include "OverlapElementLocator.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingNormalizedUnstructuredMesh.txx"
+#include "Interpolation2D.hxx"
+#include "Interpolation3D.hxx"
+#include "Interpolation2D3D.hxx"
+#include "Interpolation2D1D.hxx"
+#include "Interpolation1D.hxx"
+#include "MEDCouplingNatureOfFieldEnum"
#include "ParaMESH.hxx"
#include "ParaFIELD.hxx"
#include "ProcessorGroup.hxx"
-#include "TranslationRotationMatrix.hxx"
-#include "Interpolation.hxx"
-#include "Interpolation1D.txx"
#include "Interpolation2DCurve.hxx"
-#include "Interpolation2D.txx"
#include "Interpolation3DSurf.hxx"
#include "Interpolation3D.txx"
#include "Interpolation2D3D.txx"
#include "Interpolation2D1D.txx"
#include "MEDCouplingUMesh.hxx"
-#include "MEDCouplingFieldDouble.hxx"
-#include "MEDCouplingNormalizedUnstructuredMesh.txx"
#include "InterpolationOptions.hxx"
-#include "NormalizedUnstructuredMesh.hxx"
#include "ElementLocator.hxx"
-#include "InterpKernelAutoPtr.hxx"
+#include "MEDCouplingFieldDouble.hxx"
-#include <algorithm>
+#include <string>
using namespace std;
}
OverlapInterpolationMatrix::~OverlapInterpolationMatrix()
- {
- }
+ = default;
// TODO? Merge with MEDCouplingRemapper::prepareInterpKernelOnlyUU() ?
/**!
vector<SparseDoubleVec > sparse_matrix_part;
mcIdType colSize=0;
//computation of the intersection volumes between source and target elements
- const MEDCouplingUMesh *trgC=dynamic_cast<const MEDCouplingUMesh *>(trg);
- const MEDCouplingUMesh *srcC=dynamic_cast<const MEDCouplingUMesh *>(src);
+ const auto *trgC=dynamic_cast<const MEDCouplingUMesh *>(trg);
+ const auto *srcC=dynamic_cast<const MEDCouplingUMesh *>(src);
if ( src->getMeshDimension() == -1 )
{
if(trgC->getMeshDimension()==2 && trgC->getSpaceDimension()==2)
#ifndef __OVERLAPINTERPOLATIONMATRIX_HXX__
#define __OVERLAPINTERPOLATIONMATRIX_HXX__
-#include "MPIAccessDEC.hxx"
+#include "MCType.hxx"
+#include "OverlapElementLocator.hxx"
#include "OverlapMapping.hxx"
#include "InterpolationOptions.hxx"
#include "DECOptions.hxx"
+#include <string>
namespace MEDCoupling
{
// Author : Anthony Geay (CEA/DEN)
#include "OverlapMapping.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MCIdType.hxx"
#include "MPIProcessorGroup.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "MCAuto.hxx"
#include "InterpKernelAutoPtr.hxx"
+#include "OverlapElementLocator.hxx"
+#include "ParaIdType.hxx"
-#include <numeric>
+#include <cstddef>
#include <algorithm>
using namespace MEDCoupling;
*
* One of the 2 is necessarily null (the two can be null together)
*/
-void OverlapMapping::addContributionST(const std::vector< SparseDoubleVec >& matrixST, const DataArrayIdType *srcIds, int srcProcId, const DataArrayIdType *trgIds, int trgProcId)
+void OverlapMapping::addContributionST(const std::vector< SparseDoubleVec >& matrixST, const DataArrayIdType *srcIds, int srcProcId, const DataArrayIdType * /*trgIds*/, int trgProcId)
{
_matrixes_st.push_back(matrixST);
_source_proc_id_st.push_back(srcProcId);
printMatrixesST();
#endif
- CommInterface commInterface=_group.getCommInterface();
- const MPIProcessorGroup *group=static_cast<const MPIProcessorGroup*>(&_group);
+ CommInterface const commInterface=_group.getCommInterface();
+ const auto *group=static_cast<const MPIProcessorGroup*>(&_group);
const MPI_Comm *comm=group->getComm();
std::size_t grpSize=_group.size();
INTERP_KERNEL::AutoPtr<mcIdType> nbsend=new mcIdType[grpSize];
INTERP_KERNEL::AutoPtr<int> nbsend2=new int[grpSize];
INTERP_KERNEL::AutoPtr<int> nbsend3=new int[grpSize];
std::fill<mcIdType *>(nbsend,nbsend+grpSize,0);
- int myProcId=_group.myRank();
+ int const myProcId=_group.myRank();
for(std::size_t i=0;i<_matrixes_st.size();i++)
if(_source_proc_id_st[i]==myProcId)
nbsend[_target_proc_id_st[i]]=(int)_matrixes_st[i].size();
INTERP_KERNEL::AutoPtr<int> nbrecv1=new int[grpSize];
INTERP_KERNEL::AutoPtr<int> nbrecv2=new int[grpSize];
//
- mcIdType *tmp=0;
+ mcIdType *tmp=nullptr;
serializeMatrixStep0ST(nbrecv,
tmp,nbsend2,nbsend3,
nbrecv1,nbrecv2);
std::fill<int *>(nbsend2,nbsend2+grpSize,0);
INTERP_KERNEL::AutoPtr<int> nbrecv3=new int[grpSize];
INTERP_KERNEL::AutoPtr<int> nbrecv4=new int[grpSize];
- double *tmp2=0;
+ double *tmp2=nullptr;
mcIdType lgthOfArr=serializeMatrixStep1ST(nbrecv,bigArrRecv,nbrecv1,nbrecv2,
tmp,tmp2,
nbsend2,nbsend3,nbrecv3,nbrecv4);
*/
void OverlapMapping::computeDenoConservativeVolumic(mcIdType nbOfTuplesTrg)
{
- int myProcId=_group.myRank();
+ int const myProcId=_group.myRank();
//
_the_deno_st.clear();
std::size_t sz1=_the_matrix_st.size();
void OverlapMapping::serializeMatrixStep0ST(const mcIdType *nbOfElemsSrc, mcIdType *&bigArr, int *count, int *offsets,
int *countForRecv, int *offsetsForRecv) const
{
- std::size_t grpSize=_group.size();
+ std::size_t const grpSize=_group.size();
std::fill<int *>(count,count+grpSize,0);
std::size_t szz=0;
- int myProcId=_group.myRank();
+ int const myProcId=_group.myRank();
for(std::size_t i=0;i<_matrixes_st.size();i++)
{
if(_source_proc_id_st[i]==myProcId && _matrixes_st[i].size())// && _target_proc_id_st[i]!=myProcId
* This method performs step#1 and step#2/3. It returns the size of expected array to get allToAllV.
* It is where the locally computed matrices are serialized to be sent to adequate final proc.
*/
-mcIdType OverlapMapping::serializeMatrixStep1ST(const mcIdType *nbOfElemsSrc, const mcIdType *recvStep0, const int *countStep0, const int *offsStep0,
+mcIdType OverlapMapping::serializeMatrixStep1ST(const mcIdType *nbOfElemsSrc, const mcIdType *recvStep0, const int * /*countStep0*/, const int *offsStep0,
mcIdType *&bigArrI, double *&bigArrD, int *count, int *offsets,
int *countForRecv, int *offsForRecv) const
{
- std::size_t grpSize=_group.size();
- int myProcId=_group.myRank();
+ std::size_t const grpSize=_group.size();
+ int const myProcId=_group.myRank();
offsForRecv[0]=0;
mcIdType szz=0;
for(std::size_t i=0;i<grpSize;i++)
* - The second is the pseudo id of source proc (correspondence with true id is in attribute _the_matrix_st_source_proc_id and _the_matrix_st_source_ids)
* - the third is the srcId in the pseudo source proc
*/
-void OverlapMapping::unserializationST(mcIdType nbOfTrgElems,
+void OverlapMapping::unserializationST(mcIdType /*nbOfTrgElems*/,
const mcIdType *nbOfElemsSrcPerProc,//first all2all
- const mcIdType *bigArrRecv, const int *bigArrRecvCounts, const int *bigArrRecvOffs,//2nd all2all
- const mcIdType *bigArrRecv2, const double *bigArrDRecv2, const int *bigArrRecv2Count, const int *bigArrRecv2Offs)//3rd and 4th all2alls
+ const mcIdType *bigArrRecv, const int * /*bigArrRecvCounts*/, const int *bigArrRecvOffs,//2nd all2all
+ const mcIdType *bigArrRecv2, const double *bigArrDRecv2, const int * /*bigArrRecv2Count*/, const int *bigArrRecv2Offs)//3rd and 4th all2alls
{
_the_matrix_st.clear();
_the_matrix_st_source_proc_id.clear();
//
- std::size_t grpSize=_group.size();
+ std::size_t const grpSize=_group.size();
for(unsigned int i=0;i<grpSize;i++)
if(nbOfElemsSrcPerProc[i]!=0)
_the_matrix_st_source_proc_id.push_back(i);
_the_matrix_st[j].resize(nbOfElemsSrcPerProc[i]);
for(mcIdType k=0;k<nbOfElemsSrcPerProc[i];k++)
{
- mcIdType offs=bigArrRecv[bigArrRecvOffs[i]+k];
- mcIdType lgthOfMap=bigArrRecv[bigArrRecvOffs[i]+k+1]-offs;
+ mcIdType const offs=bigArrRecv[bigArrRecvOffs[i]+k];
+ mcIdType const lgthOfMap=bigArrRecv[bigArrRecvOffs[i]+k+1]-offs;
for(mcIdType l=0;l<lgthOfMap;l++)
_the_matrix_st[j][k][bigArrRecv2[bigArrRecv2Offs[i]+offs+l]]=bigArrDRecv2[bigArrRecv2Offs[i]+offs+l];
}
*/
void OverlapMapping::finishToFillFinalMatrixST()
{
- int myProcId=_group.myRank();
+ int const myProcId=_group.myRank();
std::size_t sz=_matrixes_st.size();
int nbOfEntryToAdd=0;
for(std::size_t i=0;i<sz;i++)
if(nbOfEntryToAdd==0)
return ;
std::size_t oldNbOfEntry=_the_matrix_st.size();
- std::size_t newNbOfEntry=oldNbOfEntry+nbOfEntryToAdd;
+ std::size_t const newNbOfEntry=oldNbOfEntry+nbOfEntryToAdd;
_the_matrix_st.resize(newNbOfEntry);
std::size_t j=oldNbOfEntry;
for(std::size_t i=0;i<sz;i++)
using namespace std;
std::size_t nbOfCompo=fieldInput->getNumberOfComponents();//to improve same number of components to test
- CommInterface commInterface=_group.getCommInterface();
- const MPIProcessorGroup *group=static_cast<const MPIProcessorGroup*>(&_group);
+ CommInterface const commInterface=_group.getCommInterface();
+ const auto *group=static_cast<const MPIProcessorGroup*>(&_group);
const MPI_Comm *comm=group->getComm();
int grpSize=_group.size();
- int myProcID=_group.myRank();
+ int const myProcID=_group.myRank();
//
INTERP_KERNEL::AutoPtr<int> nbsend=new int[grpSize];
INTERP_KERNEL::AutoPtr<int> nbsend2=new int[grpSize];
INTERP_KERNEL::AutoPtr<double> tmp=new double[nbOfCompo];
// By default field value set to default value - so mark which cells are hit
- mcIdType ntup = fieldOutput->getNumberOfTuples();
+ mcIdType const ntup = fieldOutput->getNumberOfTuples();
INTERP_KERNEL::AutoPtr<bool> hit_cells = new bool[ntup];
std::fill((bool *)hit_cells, (bool *)hit_cells+ntup, false);
/* When it is called, only the bits received from other processors (i.e. the remotely executed jobs) are in the
big matrix _the_matrix_st. */
- CommInterface commInterface=_group.getCommInterface();
- int myProcId=_group.myRank();
+ CommInterface const commInterface=_group.getCommInterface();
+ int const myProcId=_group.myRank();
std::size_t nbOfMatrixRecveived=_the_matrix_st_source_proc_id.size();
for(std::size_t i=0;i<nbOfMatrixRecveived;i++)
{
#ifndef __OVERLAPMAPPING_HXX__
#define __OVERLAPMAPPING_HXX__
-#include "MCAuto.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingMemArray.hxx"
#include "OverlapElementLocator.hxx"
#include <vector>
#include <map>
+
//#define DEC_DEBUG
namespace MEDCoupling
// Author : Anthony Geay (EDF R&D)
#include "ParaDataArray.txx"
+#include "MCType.hxx"
+#include "MEDCouplingMemArray.hxx"
using namespace MEDCoupling;
#pragma once
+#include "MCAuto.hxx"
+#include "MCType.hxx"
#include "MEDCouplingMemArray.hxx"
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingTraits.hxx"
+#include <cstddef>
+#include <vector>
+#include <string>
namespace MEDCoupling
{
#pragma once
+#include "MEDCouplingTraits.hxx"
+#include "MCType.hxx"
+#include "MEDCouplingMemArray.txx"
+#include "MCAuto.hxx"
#include "ParaDataArray.hxx"
#include "CommInterface.hxx"
-#include "MEDCouplingMemArray.txx"
+#include <cstddef>
+#include <limits>
#include <sstream>
+#include <string>
namespace MEDCoupling
{
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+#include "MEDCouplingRefCountObject.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "DisjointDEC.hxx"
+#include "MCType.hxx"
#include "Topology.hxx"
#include "BlockTopology.hxx"
#include "ComponentTopology.hxx"
#include "ParaFIELD.hxx"
#include "ParaMESH.hxx"
#include "InterpKernelUtilities.hxx"
-#include "InterpolationMatrix.hxx"
-#include <numeric>
namespace MEDCoupling
{
*/
ParaFIELD::ParaFIELD(TypeOfField type, TypeOfTimeDiscretization td, ParaMESH* para_support, const ComponentTopology& component_topology)
- :_field(0),
- _component_topology(component_topology),_topology(0),_own_support(false),
+ :_field(nullptr),
+ _component_topology(component_topology),_topology(nullptr),_own_support(false),
_support(para_support)
{
if (para_support->isStructured() || (para_support->getTopology()->getProcGroup()->size()==1 && component_topology.nbBlocks()!=1))
{
- const BlockTopology* source_topo = dynamic_cast<const BlockTopology*>(para_support->getTopology());
+ const auto* source_topo = dynamic_cast<const BlockTopology*>(para_support->getTopology());
_topology=new BlockTopology(*source_topo,component_topology);
}
else
throw INTERP_KERNEL::Exception(LOCALIZED("ParaFIELD constructor : Unstructured Support not taken into account with component topology yet"));
else
{
- const BlockTopology* source_topo=dynamic_cast<const BlockTopology*> (para_support->getTopology());
- int nb_local_comp=component_topology.nbLocalComponents();
+ const auto* source_topo=dynamic_cast<const BlockTopology*> (para_support->getTopology());
+ int const nb_local_comp=component_topology.nbLocalComponents();
_topology=new BlockTopology(*source_topo,nb_local_comp);
}
}
- int nb_components = component_topology.nbLocalComponents();
+ int const nb_components = component_topology.nbLocalComponents();
if (nb_components!=0)
{
_field=MEDCouplingFieldDouble::New(type,td);
This constructor supposes that support underlying \a subdomain_field has no ParaMESH
attached and it therefore recreates one. It therefore takes ownership over _support. The component topology associated with the field is a basic one (all components on the same processor).
*/
- ParaFIELD::ParaFIELD(MEDCouplingFieldDouble* subdomain_field, ParaMESH *sup, const ProcessorGroup& proc_group):
+ ParaFIELD::ParaFIELD(MEDCouplingFieldDouble* subdomain_field, ParaMESH *sup, const ProcessorGroup& /*proc_group*/):
_field(subdomain_field),
- _component_topology(ComponentTopology((int)_field->getNumberOfComponents())),_topology(0),_own_support(false),
+ _component_topology(ComponentTopology((int)_field->getNumberOfComponents())),_topology(nullptr),_own_support(false),
_support(sup)
{
if(_field)
_field->incrRef();
- const BlockTopology* source_topo=dynamic_cast<const BlockTopology*> (_support->getTopology());
+ const auto* source_topo=dynamic_cast<const BlockTopology*> (_support->getTopology());
_topology=new BlockTopology(*source_topo,_component_topology.nbLocalComponents());
}
_topology = nullptr;
}
- void ParaFIELD::synchronizeTarget(ParaFIELD* source_field)
+ void ParaFIELD::synchronizeTarget(ParaFIELD* /*source_field*/)
{
DisjointDEC* data_channel;
- if (dynamic_cast<BlockTopology*>(_topology)!=0)
+ if (dynamic_cast<BlockTopology*>(_topology)!=nullptr)
{
data_channel=new StructuredCoincidentDEC;
}
delete data_channel;
}
- void ParaFIELD::synchronizeSource(ParaFIELD* target_field)
+ void ParaFIELD::synchronizeSource(ParaFIELD* /*target_field*/)
{
DisjointDEC* data_channel;
- if (dynamic_cast<BlockTopology*>(_topology)!=0)
+ if (dynamic_cast<BlockTopology*>(_topology)!=nullptr)
{
data_channel=new StructuredCoincidentDEC;
}
DataArrayIdType* ParaFIELD::returnCumulativeGlobalNumbering() const
{
if(!_field)
- return 0;
- TypeOfField type=_field->getTypeOfField();
+ return nullptr;
+ TypeOfField const type=_field->getTypeOfField();
switch(type)
{
case ON_CELLS:
- return 0;
+ return nullptr;
case ON_NODES:
return _support->getGlobalNumberingNodeDA();
default:
- return 0;
+ return nullptr;
}
}
DataArrayIdType* ParaFIELD::returnGlobalNumbering() const
{
if(!_field)
- return 0;
- TypeOfField type=_field->getTypeOfField();
+ return nullptr;
+ TypeOfField const type=_field->getTypeOfField();
switch(type)
{
case ON_CELLS:
case ON_NODES:
return _support->getGlobalNumberingNodeDA();
default:
- return 0;
+ return nullptr;
}
}
over the all domain. */
double ParaFIELD::getVolumeIntegral(int icomp, bool isWAbs) const
{
- CommInterface comm_interface = _topology->getProcGroup()->getCommInterface();
+ CommInterface const comm_interface = _topology->getProcGroup()->getCommInterface();
double integral=_field->integral(icomp,isWAbs);
double total=0.;
const MPI_Comm* comm = (dynamic_cast<const MPIProcessorGroup*>(_topology->getProcGroup()))->getComm();
#include "ParaGRID.hxx"
#include "Topology.hxx"
#include "BlockTopology.hxx"
-#include "MEDCouplingMemArray.hxx"
#include "MEDCouplingCMesh.hxx"
#include "InterpKernelUtilities.hxx"
-#include <iostream>
using namespace std;
_global_axis()
{
_block_topology = dynamic_cast<BlockTopology*>(topology);
- if(_block_topology==0)
+ if(_block_topology==nullptr)
throw INTERP_KERNEL::Exception(LOCALIZED("ParaGRID::ParaGRID topology must be block topology"));
if (!_block_topology->getProcGroup()->containsMyRank())
return;
- int dimension=_block_topology->getDimension() ;
+ int const dimension=_block_topology->getDimension() ;
if (dimension != global_grid->getSpaceDimension())
throw INTERP_KERNEL::Exception(LOCALIZED("ParaGrid::ParaGrid incompatible topology"));
_grid=global_grid;
#ifndef __PARAGRID_HXX__
#define __PARAGRID_HXX__
-#include "InterpolationUtils.hxx"
#include <vector>
//
#include "ParaMESH.hxx"
+#include "MEDCouplingPointSet.hxx"
+#include "MCType.hxx"
#include "ProcessorGroup.hxx"
-#include "MPIProcessorGroup.hxx"
#include "Topology.hxx"
#include "BlockTopology.hxx"
-#include "MEDCouplingMemArray.hxx"
-#include <fstream>
-#include <vector>
+#include <string>
//inclusion for the namespaces
using namespace std;
_cell_global.takeRef(CorrespElt_local2global);
}
- ParaMESH::ParaMESH( MEDCouplingPointSet *mesh, const ProcessorGroup& proc_group, const std::string& name):
+ ParaMESH::ParaMESH( MEDCouplingPointSet *mesh, const ProcessorGroup& proc_group, const std::string& /*name*/):
_my_domain_id(proc_group.myRank()),
_block_topology(new BlockTopology(proc_group, mesh->getNumberOfCells()))
{
_cell_mesh.takeRef(mesh);
- mcIdType nb_elem=mesh->getNumberOfCells();
+ mcIdType const nb_elem=mesh->getNumberOfCells();
_explicit_topology=new BlockTopology(proc_group,nb_elem);
- mcIdType nbOfCells=mesh->getNumberOfCells();
+ mcIdType const nbOfCells=mesh->getNumberOfCells();
_cell_global = DataArrayIdType::New();
_cell_global->alloc(nbOfCells,1);
mcIdType *cellglobal=_cell_global->getPointer();
#pragma once
+#include "MCType.hxx"
+#include "MCAuto.hxx"
#include "MEDCouplingPointSet.hxx"
#include "ProcessorGroup.hxx"
-#include "MEDCouplingMemArray.hxx"
#include <string>
-#include <vector>
namespace MEDCoupling
{
// Author : Anthony Geay (EDF R&D)
#include "ParaSkyLineArray.hxx"
-#include "ProcessorGroup.hxx"
+#include "MEDCouplingSkyLineArray.hxx"
+#include "MCType.hxx"
+#include "MCAuto.hxx"
#include "MPIProcessorGroup.hxx"
-#include "Topology.hxx"
-#include "BlockTopology.hxx"
#include "CommInterface.hxx"
#include "MEDCouplingMemArray.hxx"
#include "mpi.h"
-#include <fstream>
+#include <cstddef>
#include <sstream>
-#include <numeric>
-#include <memory>
-#include <vector>
using namespace MEDCoupling;
MCAuto<ParaSkyLineArray> ParaSkyLineArray::equiRedistribute(mcIdType nbOfEntities) const
{
MPI_Comm comm(MPI_COMM_WORLD);
- CommInterface ci;
+ CommInterface const ci;
int size;
ci.commSize(comm,&size);
std::vector< MCAuto<MEDCouplingSkyLineArray> > skToBeSent(size);
#pragma once
+#include "MEDCouplingRefCountObject.hxx"
+#include "MCAuto.hxx"
+#include "MCType.hxx"
#include "MEDCouplingSkyLineArray.hxx"
-#include "ProcessorGroup.hxx"
-#include "MEDCouplingMemArray.hxx"
+#include <cstddef>
#include <string>
#include <vector>
MCAuto<ParaSkyLineArray> equiRedistribute(mcIdType nbOfEntities) const;
MEDCouplingSkyLineArray *getSkyLineArray() const;
DataArrayIdType *getGlobalIdsArray() const;
- virtual ~ParaSkyLineArray() { }
+ ~ParaSkyLineArray() override = default;
private:
ParaSkyLineArray(MEDCouplingSkyLineArray *ska, DataArrayIdType *globalIds);
protected:
// Author : Anthony Geay (EDF R&D)
#include "ParaUMesh.hxx"
-#include "ProcessorGroup.hxx"
+#include "MEDCouplingUMesh.hxx"
+#include "MCAuto.hxx"
+#include "MCType.hxx"
+#include "ParaIdType.hxx"
+#include "MEDCouplingRefCountObject.hxx"
#include "MPIProcessorGroup.hxx"
-#include "Topology.hxx"
-#include "BlockTopology.hxx"
#include "CommInterface.hxx"
-#include "MEDCouplingMemArray.hxx"
+#include "MEDCouplingMemArray.txx"
#include "mpi.h"
-#include <fstream>
-#include <sstream>
+#include <cstddef>
#include <numeric>
-#include <memory>
-#include <vector>
using namespace MEDCoupling;
MCAuto<DataArrayIdType> ParaUMesh::getCellIdsLyingOnNodesTrue(const DataArrayIdType *globalNodeIds) const
{
MPI_Comm comm(MPI_COMM_WORLD);
- CommInterface ci;
+ CommInterface const ci;
int size;
ci.commSize(comm,&size);
std::unique_ptr<mcIdType[]> nbOfElems(new mcIdType[size]),nbOfElems2(new mcIdType[size]),nbOfElems3(new mcIdType[size]);
ci.allGather(&nbOfNodeIdsLoc,1,MPI_ID_TYPE,nbOfElems.get(),1,MPI_ID_TYPE,comm);
std::vector< MCAuto<DataArrayIdType> > tabs(size);
//store for each proc the local nodeids intercepted by current proc
- int nbOfCollectiveCalls = 1;// this parameter controls the memory peak
+ int const nbOfCollectiveCalls = 1;// this parameter controls the memory peak
// loop to avoid to all procs to have all the nodes per proc
for(int subDiv = 0 ; subDiv < nbOfCollectiveCalls ; ++subDiv)
{
{
MCAuto<DataArrayIdType> localNodeIds(tabs[curRk]);
localNodeIds->sort();
- MCAuto<DataArrayIdType> localNodeIdsUnique(localNodeIds->buildUnique());
+ MCAuto<DataArrayIdType> const localNodeIdsUnique(localNodeIds->buildUnique());
MCAuto<DataArrayIdType> localCellCaptured(_mesh->getCellIdsLyingOnNodes(localNodeIdsUnique->begin(),localNodeIdsUnique->end(),true));
MCAuto<DataArrayIdType> localCellCapturedGlob(_cell_global->selectByTupleIdSafe(localCellCaptured->begin(),localCellCaptured->end()));
tabs[curRk] = localCellCapturedGlob;
MCAuto<DataArrayIdType> ParaUMesh::getCellIdsLyingOnNodesFalse(const DataArrayIdType *globalNodeIds) const
{
MPI_Comm comm(MPI_COMM_WORLD);
- CommInterface ci;
+ CommInterface const ci;
int size;
ci.commSize(comm,&size);
std::unique_ptr<mcIdType[]> nbOfElems(new mcIdType[size]),nbOfElems2(new mcIdType[size]),nbOfElems3(new mcIdType[size]);
mcIdType nbOfNodeIdsLoc(globalNodeIds->getNumberOfTuples());
ci.allGather(&nbOfNodeIdsLoc,1,MPI_ID_TYPE,nbOfElems.get(),1,MPI_ID_TYPE,comm);
// loop to avoid to all procs to have all the nodes per proc
- int nbOfCollectiveCalls = 1;// this parameter controls the memory peak
+ int const nbOfCollectiveCalls = 1;// this parameter controls the memory peak
std::vector< MCAuto<DataArrayIdType> > tabs(size);
for(int subDiv = 0 ; subDiv < nbOfCollectiveCalls ; ++subDiv)
{
globalNodeIdsOfCurProc->useArray(allGlobalNodeIds.get()+offset,false,DeallocType::CPP_DEALLOC,nbOfElemsSp[curRk],1);
offset += nbOfElemsSp[curRk];
MCAuto<DataArrayIdType> globalNodeIdsCaptured(_node_global->buildIntersection(globalNodeIdsOfCurProc));
- MCAuto<DataArrayIdType> localNodeIdsToLocate(_node_global->findIdForEach(globalNodeIdsCaptured->begin(),globalNodeIdsCaptured->end()));
+ MCAuto<DataArrayIdType> const localNodeIdsToLocate(_node_global->findIdForEach(globalNodeIdsCaptured->begin(),globalNodeIdsCaptured->end()));
MCAuto<DataArrayIdType> localCellCaptured(_mesh->getCellIdsLyingOnNodes(localNodeIdsToLocate->begin(),localNodeIdsToLocate->end(),false));
MCAuto<DataArrayIdType> localCellCapturedGlob(_cell_global->selectByTupleIdSafe(localCellCaptured->begin(),localCellCaptured->end()));
if(tabs[curRk].isNull())
ParaUMesh *ParaUMesh::redistributeCells(const DataArrayIdType *globalCellIds) const
{
MPI_Comm comm(MPI_COMM_WORLD);
- CommInterface ci;
+ CommInterface const ci;
std::unique_ptr<mcIdType[]> allGlobalCellIds,allGlobalCellIdsIndex;
int size(ci.allGatherArrays(comm,globalCellIds,allGlobalCellIds,allGlobalCellIdsIndex));
// Prepare ParaUMesh parts to be sent : compute for each proc the contribution of current rank.
globalCellIdsOfCurProc->useArray(allGlobalCellIds.get()+offset,false,DeallocType::CPP_DEALLOC,allGlobalCellIdsIndex[curRk+1]-offset,1);
// the key call is here : compute for rank curRk the cells to be sent
MCAuto<DataArrayIdType> globalCellIdsCaptured(_cell_global->buildIntersection(globalCellIdsOfCurProc));// OK for the global cellIds
- MCAuto<DataArrayIdType> localCellIdsCaptured(_cell_global->findIdForEach(globalCellIdsCaptured->begin(),globalCellIdsCaptured->end()));
+ MCAuto<DataArrayIdType> const localCellIdsCaptured(_cell_global->findIdForEach(globalCellIdsCaptured->begin(),globalCellIdsCaptured->end()));
MCAuto<MEDCouplingUMesh> meshPart(_mesh->buildPartOfMySelf(localCellIdsCaptured->begin(),localCellIdsCaptured->end(),true));
MCAuto<DataArrayIdType> o2n(meshPart->zipCoordsTraducer());// OK for the mesh
MCAuto<DataArrayIdType> n2o(o2n->invertArrayO2N2N2O(meshPart->getNumberOfNodes()));
- MCAuto<DataArrayIdType> globalNodeIdsPart(_node_global->selectByTupleIdSafe(n2o->begin(),n2o->end())); // OK for the global nodeIds
+ MCAuto<DataArrayIdType> const globalNodeIdsPart(_node_global->selectByTupleIdSafe(n2o->begin(),n2o->end())); // OK for the global nodeIds
meshPartsToBeSent[curRk] = meshPart;
globalCellIdsToBeSent[curRk] = globalCellIdsCaptured;
globalNodeIdsToBeSent[curRk] = globalNodeIdsPart;
MCAuto<DataArrayIdType> aggregatedNodeIdsSorted(aggregatedNodeIds->copySorted());
MCAuto<DataArrayIdType> nodeIdsIntoAggregatedIds(DataArrayIdType::FindPermutationFromFirstToSecondDuplicate(aggregatedNodeIdsSorted,aggregatedNodeIds));
MCAuto<DataArrayIdType> idxOfSameNodeIds(aggregatedNodeIdsSorted->indexOfSameConsecutiveValueGroups());
- MCAuto<DataArrayIdType> n2o_nodes(nodeIdsIntoAggregatedIds->selectByTupleIdSafe(idxOfSameNodeIds->begin(),idxOfSameNodeIds->end()-1));//new == new ordering so that global node ids are sorted . old == coarse ordering implied by the aggregation
+ MCAuto<DataArrayIdType> const n2o_nodes(nodeIdsIntoAggregatedIds->selectByTupleIdSafe(idxOfSameNodeIds->begin(),idxOfSameNodeIds->end()-1));//new == new ordering so that global node ids are sorted . old == coarse ordering implied by the aggregation
MCAuto<DataArrayIdType> finalGlobalNodeIds(aggregatedNodeIdsSorted->selectByTupleIdSafe(idxOfSameNodeIds->begin(),idxOfSameNodeIds->end()-1));
MCAuto<DataArrayDouble> finalCoords(coords->selectByTupleIdSafe(n2o_nodes->begin(),n2o_nodes->end()));
finalCoords->copyStringInfoFrom(*_mesh->getCoords());
#pragma once
+#include "MEDCouplingRefCountObject.hxx"
+#include "MCAuto.hxx"
+#include "MEDCouplingTraits.hxx"
+#include "CommInterface.hxx"
+#include "MCType.hxx"
#include "MEDCouplingUMesh.hxx"
-#include "ProcessorGroup.hxx"
#include "MEDCouplingMemArray.hxx"
+#include <cstddef>
#include <string>
-#include <vector>
namespace MEDCoupling
{
DataArrayIdType *getGlobalCellIds() { return _cell_global; }
DataArrayIdType *getGlobalNodeIds() { return _node_global; }
protected:
- virtual ~ParaUMesh() { }
+ ~ParaUMesh() override = default;
ParaUMesh(MEDCouplingUMesh *mesh, DataArrayIdType *globalCellIds, DataArrayIdType *globalNodeIds);
std::string getClassName() const override { return "ParaUMesh"; }
std::size_t getHeapMemorySizeWithoutChildren() const override;
{
using DataArrayT = typename Traits<T>::ArrayType;
MPI_Comm comm(MPI_COMM_WORLD);
- CommInterface ci;
+ CommInterface const ci;
if( _cell_global->getNumberOfTuples() != fieldValueToRed->getNumberOfTuples() )
throw INTERP_KERNEL::Exception("PAraUMesh::redistributeCellFieldT : invalid input length of array !");
std::unique_ptr<mcIdType[]> allGlobalCellIds,allGlobalCellIdsIndex;
{
using DataArrayT = typename Traits<T>::ArrayType;
MPI_Comm comm(MPI_COMM_WORLD);
- CommInterface ci;
+ CommInterface const ci;
if( _node_global->getNumberOfTuples() != fieldValueToRed->getNumberOfTuples() )
throw INTERP_KERNEL::Exception("PAraUMesh::redistributeNodeFieldT : invalid input length of array !");
std::unique_ptr<mcIdType[]> allGlobalCellIds,allGlobalCellIdsIndex;
globalCellIdsOfCurProc->useArray(allGlobalCellIds.get()+offset,false,DeallocType::CPP_DEALLOC,allGlobalCellIdsIndex[curRk+1]-offset,1);
// the key call is here : compute for rank curRk the cells to be sent
MCAuto<DataArrayIdType> globalCellIdsCaptured(_cell_global->buildIntersection(globalCellIdsOfCurProc));// OK for the global cellIds
- MCAuto<DataArrayIdType> localCellIdsCaptured(_cell_global->findIdForEach(globalCellIdsCaptured->begin(),globalCellIdsCaptured->end()));
+ MCAuto<DataArrayIdType> const localCellIdsCaptured(_cell_global->findIdForEach(globalCellIdsCaptured->begin(),globalCellIdsCaptured->end()));
MCAuto<MEDCouplingUMesh> meshPart(_mesh->buildPartOfMySelf(localCellIdsCaptured->begin(),localCellIdsCaptured->end(),true));
MCAuto<DataArrayIdType> o2n(meshPart->zipCoordsTraducer());// OK for the mesh
MCAuto<DataArrayIdType> n2o(o2n->invertArrayO2N2N2O(meshPart->getNumberOfNodes()));
//
#include "ProcessorGroup.hxx"
-#include "InterpolationUtils.hxx"
+#include "CommInterface.hxx"
namespace MEDCoupling
{
#include "CommInterface.hxx"
-#include <set>
+#include <string>
namespace MEDCoupling
{
ProcessorGroup (const CommInterface& interface, int start, int end);
ProcessorGroup(const CommInterface& interface,std::map<std::string,std::set<int>> proc_ids_by_name,const std::string& simCodeTag):
_comm_interface(interface),_proc_ids_by_name(proc_ids_by_name),_proc_ids(proc_ids_by_name.at(simCodeTag)) { }
- virtual ~ProcessorGroup() { }
+ virtual ~ProcessorGroup() = default;
virtual ProcessorGroup *deepCopy() const = 0;
virtual ProcessorGroup* fuse (const ProcessorGroup&) const = 0;
virtual void intersect (ProcessorGroup&) = 0;
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+#include <cstddef>
#include <mpi.h>
-#include "CommInterface.hxx"
+#include "DisjointDEC.hxx"
+#include "MCType.hxx"
+#include "ParaIdType.hxx"
#include "Topology.hxx"
#include "BlockTopology.hxx"
#include "ComponentTopology.hxx"
#include "InterpKernelUtilities.hxx"
#include <iostream>
+#include <utility>
using namespace std;
if (!_topo_source->getProcGroup()->containsMyRank())
return;
- MPIProcessorGroup* group=new MPIProcessorGroup(_topo_source->getProcGroup()->getCommInterface());
+ auto* group=new MPIProcessorGroup(_topo_source->getProcGroup()->getCommInterface());
- int myranksource = _topo_source->getProcGroup()->myRank();
+ int const myranksource = _topo_source->getProcGroup()->myRank();
vector <mcIdType>* target_arrays=new vector<mcIdType>[_topo_target->getProcGroup()->size()];
//cout<<" topotarget size"<< _topo_target->getProcGroup()->size()<<endl;
- mcIdType nb_local = _topo_source-> getNbLocalElements();
+ mcIdType const nb_local = _topo_source-> getNbLocalElements();
for (mcIdType ielem=0; ielem< nb_local ; ielem++)
{
// cout <<"source local :"<<myranksource<<","<<ielem<<endl;
for (int iproc=0; iproc < _topo_target->getProcGroup()->size(); iproc++)
{
//converts the rank in target to the rank in union communicator
- int unionrank=group->translateRank(_topo_target->getProcGroup(),iproc);
+ int const unionrank=group->translateRank(_topo_target->getProcGroup(),iproc);
_send_counts[unionrank]=(int)target_arrays[iproc].size();
}
{
if (!_topo_target->getProcGroup()->containsMyRank())
return;
- MPIProcessorGroup* group=new MPIProcessorGroup(_topo_source->getProcGroup()->getCommInterface());
+ auto* group=new MPIProcessorGroup(_topo_source->getProcGroup()->getCommInterface());
- int myranktarget = _topo_target->getProcGroup()->myRank();
+ int const myranktarget = _topo_target->getProcGroup()->myRank();
vector < vector <mcIdType> > source_arrays(_topo_source->getProcGroup()->size());
- mcIdType nb_local = _topo_target-> getNbLocalElements();
+ mcIdType const nb_local = _topo_target-> getNbLocalElements();
for (mcIdType ielem=0; ielem< nb_local ; ielem++)
{
// cout <<"TS target local :"<<myranktarget<<","<<ielem<<endl;
for (int iproc=0; iproc < _topo_source->getProcGroup()->size(); iproc++)
{
//converts the rank in target to the rank in union communicator
- int unionrank=group->translateRank(_topo_source->getProcGroup(),iproc);
+ int const unionrank=group->translateRank(_topo_source->getProcGroup(),iproc);
_recv_counts[unionrank]=(int)source_arrays[iproc].size();
}
for (std::size_t i=1; i<union_size; i++)
{
MPI_Status status;
- mcIdType* serializer=0;
+ mcIdType* serializer=nullptr;
mcIdType size;
- MPIProcessorGroup* group=new MPIProcessorGroup(*_comm_interface);
+ auto* group=new MPIProcessorGroup(*_comm_interface);
// The master proc creates a send buffer containing a serialized topology
int rank_master;
- if (topo!=0 && topo->getProcGroup()->myRank()==0)
+ if (topo!=nullptr && topo->getProcGroup()->myRank()==0)
{
MESSAGE ("Master rank");
topo->serialize(serializer, size);
// The topology is broadcasted to all processors in the group
_comm_interface->broadcast(&size, 1,MPI_ID_TYPE,rank_master,*(group->getComm()));
- mcIdType* buffer=new mcIdType[size];
- if (topo!=0 && topo->getProcGroup()->myRank()==0)
+ auto* buffer=new mcIdType[size];
+ if (topo!=nullptr && topo->getProcGroup()->myRank()==0)
copy(serializer, serializer+size, buffer);
_comm_interface->broadcast(buffer,(int)size,MPI_ID_TYPE,rank_master,*(group->getComm()));
// Processors which did not possess the source topology unserialize it
- BlockTopology* topotemp=new BlockTopology();
+ auto* topotemp=new BlockTopology();
topotemp->unserialize(buffer, *_comm_interface);
- if (topo==0)
+ if (topo==nullptr)
topo=topotemp;
else
delete topotemp;
// Memory cleaning
delete[] buffer;
- if (serializer!=0)
+ if (serializer!=nullptr)
delete[] serializer;
MESSAGE (" rank "<<group->myRank()<< " unserialize is over");
delete group;
_recv_buffer, _recv_counts, _recv_displs, MPI_DOUBLE,comm);
cout<<"end AllToAll"<<endl;
- mcIdType nb_local = _topo_target->getNbLocalElements();
+ mcIdType const nb_local = _topo_target->getNbLocalElements();
//double* value=new double[nb_local];
- double* value=const_cast<double*>(_local_field->getField()->getArray()->getPointer());
+ auto* value=const_cast<double*>(_local_field->getField()->getArray()->getPointer());
- int myranktarget=_topo_target->getProcGroup()->myRank();
+ int const myranktarget=_topo_target->getProcGroup()->myRank();
vector<int> counters(_topo_source->getProcGroup()->size());
counters[0]=0;
for (int i=0; i<_topo_source->getProcGroup()->size()-1; i++)
{
- MPIProcessorGroup* group=new MPIProcessorGroup(*_comm_interface);
- int worldrank=group->translateRank(_topo_source->getProcGroup(),i);
+ auto* group=new MPIProcessorGroup(*_comm_interface);
+ int const worldrank=group->translateRank(_topo_source->getProcGroup(),i);
counters[i+1]=counters[i]+_recv_counts[worldrank];
delete group;
}
public:
StructuredCoincidentDEC();
StructuredCoincidentDEC( ProcessorGroup& source, ProcessorGroup& target);
- virtual ~StructuredCoincidentDEC();
+ ~StructuredCoincidentDEC() override;
void release();
- void synchronize();
- void recvData();
- void sendData();
- void prepareSourceDE();
- void prepareTargetDE();
+ void synchronize() override;
+ void recvData() override;
+ void sendData() override;
+ void prepareSourceDE() override;
+ void prepareTargetDE() override;
private :
void synchronizeTopology();
}
TimeInterpolator::~TimeInterpolator()
- {
- }
+ = default;
}
#ifndef __TIMEINTERPOLATOR_HXX__
#define __TIMEINTERPOLATOR_HXX__
-#include "ProcessorGroup.hxx"
-#include <map>
-#include <iostream>
namespace MEDCoupling
{
#include "RENUMBER_BOOSTRenumbering.hxx"
+#include "MCIdType.hxx"
+#include "MCType.hxx"
#include "MEDCouplingMemArray.hxx"
#include "MCAuto.hxx"
-#include <boost/config.hpp>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/cuthill_mckee_ordering.hpp>
+#include <boost/graph/graph_selectors.hpp>
+#include <boost/graph/detail/adjacency_list.hpp>
#include <boost/graph/properties.hpp>
-#include <boost/graph/bandwidth.hpp>
+#include <boost/pending/property.hpp>
void BOOSTRenumbering::renumber(const mcIdType *graph, const mcIdType *index_graph, mcIdType nbCell, MEDCoupling::DataArrayIdType *&iperm, MEDCoupling::DataArrayIdType *&perm)
{
for (mcIdType j=index_graph[i];j<index_graph[i+1];++j)
add_edge(i,graph[j],G);
boost::property_map<Graph, boost::vertex_index_t>::type
- index_map = boost::get(boost::vertex_index, G);
+ const index_map = boost::get(boost::vertex_index, G);
boost::cuthill_mckee_ordering(G, out0->getPointer(), boost::get(boost::vertex_color, G),
boost::make_degree_map(G));
mcIdType *out0Ptr(out0->getPointer()),*out1Ptr(out1->getPointer());
#ifndef __BOOSTRENUMBERING_HXX__
#define __BOOSTRENUMBERING_HXX__
+#include "MCIdType.hxx"
+#include "MCType.hxx"
#include "RENUMBERDefines.hxx"
#include "RENUMBER_Renumbering.hxx"
class RENUMBER_EXPORT BOOSTRenumbering:public Renumbering
{
public:
- void renumber(const mcIdType *graph, const mcIdType *index_graph, mcIdType nbCell, MEDCoupling::DataArrayIdType *&iperm, MEDCoupling::DataArrayIdType *&perm);
+ void renumber(const mcIdType *graph, const mcIdType *index_graph, mcIdType nbCell, MEDCoupling::DataArrayIdType *&iperm, MEDCoupling::DataArrayIdType *&perm) override;
};
#endif /*BOOSTRENUMBERING_HXX_*/
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+#include "MCIdType.hxx"
+#include "MCType.hxx"
+#include <vector>
+#include <algorithm>
#ifdef MED_ENABLE_PARMETIS
// include parmetis.h even if it is not needed here
// to avoid inclusion of c++ definitions within extern "C"
std::vector<idx_t> indexVec( index_graph, index_graph + indexSize );
std::vector<idx_t> graphVec( graph, graph + graphSize );
std::vector<idx_t> out0Vec( nbCell ), out1Vec( nbCell );
- idx_t nb = static_cast<idx_t>( nbCell );
+ auto nb = static_cast<idx_t>( nbCell );
METIS_NodeND(&nb,indexVec.data(),graphVec.data(),&num_flag,&options,out0Vec.data(),out1Vec.data());
std::copy( out0Vec.begin(),out0Vec.end(),out0->getPointer() );
std::copy( out1Vec.begin(),out1Vec.end(),out1->getPointer() );
#ifndef __METISRENUMBERING_HXX__
#define __METISRENUMBERING_HXX__
+#include "MCIdType.hxx"
+#include "MCType.hxx"
#include "RENUMBERDefines.hxx"
#include "RENUMBER_Renumbering.hxx"
class RENUMBER_EXPORT METISRenumbering:public Renumbering
{
public:
- virtual void renumber(const mcIdType *graph, const mcIdType *index_graph, mcIdType nb_cell, MEDCoupling::DataArrayIdType *&iperm, MEDCoupling::DataArrayIdType *&perm);
+ void renumber(const mcIdType *graph, const mcIdType *index_graph, mcIdType nb_cell, MEDCoupling::DataArrayIdType *&iperm, MEDCoupling::DataArrayIdType *&perm) override;
};
#endif /*METISRENUMBERING_HXX_*/
#ifndef RENUMBERING_HXX_
#define RENUMBERING_HXX_
+#include "MCIdType.hxx"
#include "RENUMBERDefines.hxx"
#include "MCType.hxx"
-#include <vector>
namespace MEDCoupling
{
{
public:
virtual void renumber(const mcIdType *graph, const mcIdType *index_graph, mcIdType nbCell, MEDCoupling::DataArrayIdType *&iperm, MEDCoupling::DataArrayIdType *&perm) = 0;
- virtual ~Renumbering() { }
+ virtual ~Renumbering() = default;
};
#endif /*RENUMBERING_HXX_*/
#include "RenumberingFactory.hxx"
#include "RENUMBER_Renumbering.hxx"
+#include <string>
+#include <cctype>
+#include <vector>
#ifdef MED_ENABLE_METIS
#include "RENUMBER_METISRenumbering.hxx"
#endif
else
{
std::cerr << "The method has to be METIS or BOOST" << std::endl;
- return 0;
+ return nullptr;
}
#endif
#ifndef ENABLE_BOOST
#include "RENUMBER_Renumbering.hxx"
#include <string>
+#include <vector>
namespace MED_RENUMBER
{
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+#include "MCAuto.hxx"
+#include "MCType.hxx"
+#include "MCIdType.hxx"
+#include "MEDCouplingMemArray.hxx"
#include "MEDFileData.hxx"
+#include "MEDFileFieldMultiTS.hxx"
+#include "MEDFileField1TS.hxx"
#include "MEDFileMesh.hxx"
#include "MEDFileField.hxx"
#include "MEDCouplingUMesh.hxx"
+#include "RENUMBER_Renumbering.hxx"
#include "RenumberingFactory.hxx"
+#include <sstream>
#include <time.h>
#include <string>
#include <cstdlib>
-#include <fstream>
#include <iostream>
using namespace std;
<< " filename_in meshname method[BOOST/METIS] filename_out" << endl << endl;
return -1;
}
- string filename_in = argv[1];
- string meshname = argv[2];
- string type_renum = argv[3];
- string filename_out = argv[4];
+ string const filename_in = argv[1];
+ string const meshname = argv[2];
+ string const type_renum = argv[3];
+ string const filename_out = argv[4];
if(type_renum!="METIS" && type_renum!="BOOST")
{
cout << "Reading : " << flush;
MCAuto<MEDFileData> fd(MEDFileData::New(filename_in));
MEDFileMesh *m=fd->getMeshes()->getMeshWithName(meshname);
- MEDFileUMesh *mc=dynamic_cast<MEDFileUMesh *>(m);
+ auto *mc=dynamic_cast<MEDFileUMesh *>(m);
if(!mc)
{
std::ostringstream oss; oss << "In file \"" << filename_in << "\" the mesh name \"" << meshname<< "\" exists but is not unstructured !";
MCAuto<MEDCouplingUMesh> workMesh=mc->getMeshAtLevel(0);
//std::vector<mcIdType> code=workMesh->getDistributionOfTypes();
cout << "Building the graph : " << flush;
- DataArrayIdType *neighb=0,*neighbI=0;
+ DataArrayIdType *neighb=nullptr,*neighbI=nullptr;
workMesh->computeNeighborsOfCells(neighb,neighbI);
MCAuto<DataArrayIdType> neighbSafe(neighb),neighbISafe(neighbI),ipermSafe,permSafe;
const mcIdType *graph=neighbSafe->begin();
const mcIdType *graph_index=neighbISafe->begin();
// Compute permutation iperm->new2old perm->old2new
- DataArrayIdType *iperm(0),*perm(0);
+ DataArrayIdType *iperm(nullptr),*perm(nullptr);
Renumbering *renumb=RenumberingFactory(type_renum);
renumb->renumber(graph,graph_index,workMesh->getNumberOfCells(),iperm,perm);
ipermSafe=iperm; permSafe=perm;
delete renumb;
- ipermSafe=0;//erase new2old, we are using only old 2 new
+ ipermSafe=nullptr;//erase new2old, we are using only old 2 new
t_compute_graph=(double)clock();
cout << " : " << (t_compute_graph-t_read_st)/(double) CLOCKS_PER_SEC << "s" << endl;
cout.flush();
{
for(int i=0;i<fs->getNumberOfFields();i++)
{
- MEDFileFieldMultiTS *fmts=dynamic_cast<MEDFileFieldMultiTS *>(fs->getFieldAtPos(i));
+ auto *fmts=dynamic_cast<MEDFileFieldMultiTS *>(fs->getFieldAtPos(i));
if(!fmts) continue;
if(fmts->getMeshName()==meshname)
{
for(int j=0;j<fmts->getNumberOfTS();j++)
{
- MEDFileField1TS *f1ts=dynamic_cast<MEDFileField1TS*>(fmts->getTimeStepAtPos(j));
+ auto *f1ts=dynamic_cast<MEDFileField1TS*>(fmts->getTimeStepAtPos(j));
if(!f1ts) continue;
DataArrayDouble *arr=f1ts->getUndergroundDataArray();
arr->renumberInPlace(perm->begin());
