LOT2: massive substitution of int->mcIdType in the INTERP_KERNEL implementation

diff --git a/src/INTERP_KERNEL/BBTree.txx b/src/INTERP_KERNEL/BBTree.txx
index 23dcfe3be272bc39f2086d9cda58d1b51ccea178..c312a646b06c9de6e7d002ffffcc38da33de9255 100644 (file)
--- a/src/INTERP_KERNEL/BBTree.txx
+++ b/src/INTERP_KERNEL/BBTree.txx
@@ -160,7 +160,7 @@ public:
     //  terminal node : return list of elements intersecting bb
     if (_terminal)
       {
-        for (mcIdType i=0; i<_nbelems; i++)
+        for (ConnType i=0; i<_nbelems; i++)
           {
             const double* const  bb_ptr=_bb+_elems[i]*2*dim;
             bool intersects = true;

diff --git a/src/INTERP_KERNEL/CurveIntersectorP0P0.hxx b/src/INTERP_KERNEL/CurveIntersectorP0P0.hxx
index 365d4b4e44a12b23180c46fb7a31e40aaf2720b2..6c9fbf5ee00428f8220144ea17d7dd5d1994a274 100644 (file)
--- a/src/INTERP_KERNEL/CurveIntersectorP0P0.hxx
+++ b/src/INTERP_KERNEL/CurveIntersectorP0P0.hxx
@@ -38,8 +38,8 @@ namespace INTERP_KERNEL
                          double  precision, double tolerance,
                          double medianLine, int printLevel);
   public:
-    int getNumberOfRowsOfResMatrix() const;
-    int getNumberOfColsOfResMatrix() const;
+    ConnType getNumberOfRowsOfResMatrix() const;
+    ConnType getNumberOfColsOfResMatrix() const;
     void intersectCells(ConnType icellT,
                         const std::vector<ConnType>& icellsS, MyMatrix& res);
   };

diff --git a/src/INTERP_KERNEL/CurveIntersectorP0P0.txx b/src/INTERP_KERNEL/CurveIntersectorP0P0.txx
index 54cdc5b5c69132e01db9b7658fb3ca59a20f3ac0..45d5522ea0e8df4eadb9981129c0c23655492a7d 100644 (file)
--- a/src/INTERP_KERNEL/CurveIntersectorP0P0.txx
+++ b/src/INTERP_KERNEL/CurveIntersectorP0P0.txx
@@ -37,14 +37,14 @@ namespace INTERP_KERNEL
   }
 
   template<class MyMeshType, class MyMatrix>
-  int CurveIntersectorP0P0<MyMeshType,MyMatrix>
+  typename MyMeshType::MyConnType CurveIntersectorP0P0<MyMeshType,MyMatrix>
     ::getNumberOfRowsOfResMatrix() const
   {
     return BASE_INTERSECTOR::_meshT.getNumberOfElements();
   }
 
   template<class MyMeshType, class MyMatrix>
-  int CurveIntersectorP0P0<MyMeshType,MyMatrix>
+  typename MyMeshType::MyConnType CurveIntersectorP0P0<MyMeshType,MyMatrix>
     ::getNumberOfColsOfResMatrix() const
   {
     return BASE_INTERSECTOR::_meshS.getNumberOfElements();
@@ -56,14 +56,14 @@ namespace INTERP_KERNEL
   {
     typename MyMatrix::value_type& resRow = res[icellT];
     std::vector<double> coordsT;
-    int t, nbSegT = 1 + BASE_INTERSECTOR::getRealTargetCoordinates(icellT,coordsT);
+    ConnType t, nbSegT = 1 + BASE_INTERSECTOR::getRealTargetCoordinates(icellT,coordsT);
     for ( t = 0; t < nbSegT; ++t )
       for(typename std::vector<ConnType>::const_iterator
             iter=icellsS.begin(); iter!=icellsS.end(); iter++)
         {
-          int iS = *iter;
+          ConnType iS = *iter;
           std::vector<double> coordsS;
-          int s, nbSegS = 1 + BASE_INTERSECTOR::getRealSourceCoordinates(iS,coordsS);
+          ConnType s, nbSegS = 1 + BASE_INTERSECTOR::getRealSourceCoordinates(iS,coordsS);
           for ( s = 0; s < nbSegS; ++s )
             {
               double surf = BASE_INTERSECTOR::intersectSegments(&coordsT[0] + t*SPACEDIM,

diff --git a/src/INTERP_KERNEL/CurveIntersectorP0P1.hxx b/src/INTERP_KERNEL/CurveIntersectorP0P1.hxx
index 0f3145cb923495698ff66be87856cf56be7fd784..e2f88f726e77ee6366f3c0330f8b6be447184256 100644 (file)
--- a/src/INTERP_KERNEL/CurveIntersectorP0P1.hxx
+++ b/src/INTERP_KERNEL/CurveIntersectorP0P1.hxx
@@ -40,8 +40,8 @@ namespace INTERP_KERNEL
   public:
     void intersectCells(ConnType icellT,
                         const std::vector<ConnType>& icellsS, MyMatrix& res);
-    int getNumberOfRowsOfResMatrix() const;
-    int getNumberOfColsOfResMatrix() const;
+    ConnType getNumberOfRowsOfResMatrix() const;
+    ConnType getNumberOfColsOfResMatrix() const;
   };
 }
 

diff --git a/src/INTERP_KERNEL/CurveIntersectorP0P1.txx b/src/INTERP_KERNEL/CurveIntersectorP0P1.txx
index 7173c55e60c2bed44a3089c796cbd9bc546461ee..51960280ec42a1672a7ff2f3efc8c214b067b4b0 100644 (file)
--- a/src/INTERP_KERNEL/CurveIntersectorP0P1.txx
+++ b/src/INTERP_KERNEL/CurveIntersectorP0P1.txx
@@ -37,14 +37,14 @@ namespace INTERP_KERNEL
   }
 
   template<class MyMeshType, class MyMatrix>
-  int CurveIntersectorP0P1<MyMeshType,MyMatrix>
+  typename MyMeshType::MyConnType CurveIntersectorP0P1<MyMeshType,MyMatrix>
     ::getNumberOfRowsOfResMatrix() const
   {
     return BASE_INTERSECTOR::_meshT.getNumberOfNodes();
   }
 
   template<class MyMeshType, class MyMatrix>
-  int CurveIntersectorP0P1<MyMeshType,MyMatrix>
+  typename MyMeshType::MyConnType CurveIntersectorP0P1<MyMeshType,MyMatrix>
     ::getNumberOfColsOfResMatrix() const
   {
     return BASE_INTERSECTOR::_meshS.getNumberOfElements();
@@ -62,15 +62,15 @@ namespace INTERP_KERNEL
   {
     std::vector<typename BASE_INTERSECTOR::TDualSegment> segmentsT;
     BASE_INTERSECTOR::getDualSegments( icellT, BASE_INTERSECTOR::_meshT, segmentsT);
-    for ( int t = 0; t < (int)segmentsT.size(); ++t )
+    for ( ConnType t = 0; t < (ConnType)segmentsT.size(); ++t )
       {
         typename MyMatrix::value_type& resRow = res[ OTT<ConnType,numPol>::ind2C( segmentsT[t]._nodeId )];
         for(typename std::vector<ConnType>::const_iterator
               iter=icellsS.begin(); iter!=icellsS.end(); iter++)
           {
-            int iS = *iter;
+            ConnType iS = *iter;
             std::vector<double> coordsS;
-            int s, nbSegS = 1 + BASE_INTERSECTOR::getRealSourceCoordinates(iS,coordsS);
+            ConnType s, nbSegS = 1 + BASE_INTERSECTOR::getRealSourceCoordinates(iS,coordsS);
             for ( s = 0; s < nbSegS; ++s )
               {
                 double surf = BASE_INTERSECTOR::intersectSegments(&segmentsT[t]._coords[0],

diff --git a/src/INTERP_KERNEL/CurveIntersectorP1P0.hxx b/src/INTERP_KERNEL/CurveIntersectorP1P0.hxx
index 76844461f0cffb419b12b92214961cf1a53f203e..d52eec2dd7377765078e907677b09bc643353f30 100644 (file)
--- a/src/INTERP_KERNEL/CurveIntersectorP1P0.hxx
+++ b/src/INTERP_KERNEL/CurveIntersectorP1P0.hxx
@@ -38,8 +38,8 @@ namespace INTERP_KERNEL
                          double precision, double tolerance, double medianLine, int printLevel);
   public:
     void intersectCells(ConnType icellT, const std::vector<ConnType>& icellsS, MyMatrix& res);
-    int getNumberOfRowsOfResMatrix() const;
-    int getNumberOfColsOfResMatrix() const;
+    ConnType getNumberOfRowsOfResMatrix() const;
+    ConnType getNumberOfColsOfResMatrix() const;
   };
 }
 

diff --git a/src/INTERP_KERNEL/CurveIntersectorP1P0.txx b/src/INTERP_KERNEL/CurveIntersectorP1P0.txx
index 831d80718c8d68a4a7990301f16ad5fb3e06f966..a5bfe0fcbb69d298b8e114ad4e82462c30e5274a 100644 (file)
--- a/src/INTERP_KERNEL/CurveIntersectorP1P0.txx
+++ b/src/INTERP_KERNEL/CurveIntersectorP1P0.txx
@@ -37,14 +37,14 @@ namespace INTERP_KERNEL
   }
 
   template<class MyMeshType, class MyMatrix>
-  int CurveIntersectorP1P0<MyMeshType,MyMatrix>
+  typename MyMeshType::MyConnType CurveIntersectorP1P0<MyMeshType,MyMatrix>
     ::getNumberOfRowsOfResMatrix() const
   {
     return BASE_INTERSECTOR::_meshT.getNumberOfElements();
   }
 
   template<class MyMeshType, class MyMatrix>
-  int CurveIntersectorP1P0<MyMeshType,MyMatrix>
+  typename MyMeshType::MyConnType CurveIntersectorP1P0<MyMeshType,MyMatrix>
     ::getNumberOfColsOfResMatrix() const
   {
     return BASE_INTERSECTOR::_meshS.getNumberOfNodes();
@@ -63,21 +63,21 @@ namespace INTERP_KERNEL
     typename MyMatrix::value_type& resRow = res[ icellT ];
     std::vector<typename BASE_INTERSECTOR::TDualSegment> segmentsS;
     std::vector<double> coordsT;
-    int t, nbSegT = 1 + BASE_INTERSECTOR::getRealTargetCoordinates(icellT,coordsT);
+    ConnType t, nbSegT = 1 + BASE_INTERSECTOR::getRealTargetCoordinates(icellT,coordsT);
     for ( t = 0; t < nbSegT; ++t )
       for(typename std::vector<ConnType>::const_iterator
             iter=icellsS.begin(); iter!=icellsS.end(); iter++)
         {
-          int iS = *iter;
+          ConnType iS = *iter;
           BASE_INTERSECTOR::getDualSegments( OTT<ConnType,numPol>::ind2C(iS),
                                              BASE_INTERSECTOR::_meshS, segmentsS);
-          for ( int s = 0; s < (int)segmentsS.size(); ++s )
+          for ( ConnType s = 0; s < (ConnType)segmentsS.size(); ++s )
             {
               double surf = BASE_INTERSECTOR::intersectSegments(&segmentsS[s]._coords[0],
                                                                 &coordsT[0] + t*SPACEDIM);
               if(surf!=0.)
                 {
-                  int nS = segmentsS[s]._nodeId;
+                  ConnType nS = segmentsS[s]._nodeId;
                   typename MyMatrix::value_type::const_iterator iterRes=resRow.find(nS);
                   if(iterRes==resRow.end())
                     resRow.insert(std::make_pair(nS,surf));

diff --git a/src/INTERP_KERNEL/CurveIntersectorP1P1.hxx b/src/INTERP_KERNEL/CurveIntersectorP1P1.hxx
index de086bb4defb1b89ed2410a31811a1aeb1ca675b..106d8529709c02073dc2fb7b141c7d48c5880dc8 100644 (file)
--- a/src/INTERP_KERNEL/CurveIntersectorP1P1.hxx
+++ b/src/INTERP_KERNEL/CurveIntersectorP1P1.hxx
@@ -40,8 +40,8 @@ namespace INTERP_KERNEL
   public:
     void intersectCells(ConnType icellT,
                         const std::vector<ConnType>& icellsS, MyMatrix& res);
-    int getNumberOfRowsOfResMatrix() const;
-    int getNumberOfColsOfResMatrix() const;
+    ConnType getNumberOfRowsOfResMatrix() const;
+    ConnType getNumberOfColsOfResMatrix() const;
   };
 }
 

diff --git a/src/INTERP_KERNEL/CurveIntersectorP1P1.txx b/src/INTERP_KERNEL/CurveIntersectorP1P1.txx
index d63d34aaebe8e47d91038115a527c6da01a05f77..dd91ee5f288dd07af06b12e17979e43beeb597d5 100644 (file)
--- a/src/INTERP_KERNEL/CurveIntersectorP1P1.txx
+++ b/src/INTERP_KERNEL/CurveIntersectorP1P1.txx
@@ -37,14 +37,14 @@ namespace INTERP_KERNEL
   }
 
   template<class MyMeshType, class MyMatrix>
-  int CurveIntersectorP1P1<MyMeshType,MyMatrix>
+  typename MyMeshType::MyConnType CurveIntersectorP1P1<MyMeshType,MyMatrix>
   ::getNumberOfRowsOfResMatrix() const
   {
     return BASE_INTERSECTOR::_meshT.getNumberOfNodes();
   }
 
   template<class MyMeshType, class MyMatrix>
-  int CurveIntersectorP1P1<MyMeshType,MyMatrix>
+  typename MyMeshType::MyConnType CurveIntersectorP1P1<MyMeshType,MyMatrix>
   ::getNumberOfColsOfResMatrix() const
   {
     return BASE_INTERSECTOR::_meshS.getNumberOfNodes();
@@ -56,22 +56,22 @@ namespace INTERP_KERNEL
   {
     std::vector<typename BASE_INTERSECTOR::TDualSegment> segmentsT, segmentsS;
     BASE_INTERSECTOR::getDualSegments( icellT, BASE_INTERSECTOR::_meshT, segmentsT);
-    for ( int t = 0; t < (int)segmentsT.size(); ++t )
+    for ( ConnType t = 0; t < (ConnType)segmentsT.size(); ++t )
       {
         typename MyMatrix::value_type& resRow = res[ OTT<ConnType,numPol>::ind2C( segmentsT[t]._nodeId )];
         for(typename std::vector<ConnType>::const_iterator
               iter=icellsS.begin(); iter!=icellsS.end(); iter++)
           {
-            int iS = *iter;
+            ConnType iS = *iter;
             BASE_INTERSECTOR::getDualSegments( OTT<ConnType,numPol>::ind2C(iS),
                                                BASE_INTERSECTOR::_meshS, segmentsS);
-            for ( int s = 0; s < (int)segmentsS.size(); ++s )
+            for ( ConnType s = 0; s < (ConnType)segmentsS.size(); ++s )
               {
                 double surf = BASE_INTERSECTOR::intersectSegments(&segmentsT[t]._coords[0],
                                                                   &segmentsS[s]._coords[0]);
                 if(surf!=0.)
                   {
-                    int nS = segmentsS[s]._nodeId;
+                    ConnType nS = segmentsS[s]._nodeId;
                     typename MyMatrix::value_type::const_iterator iterRes=resRow.find(nS);
                     if(iterRes==resRow.end())
                       resRow.insert(std::make_pair(nS,surf));

diff --git a/src/INTERP_KERNEL/CurveIntersectorP1P1PL.hxx b/src/INTERP_KERNEL/CurveIntersectorP1P1PL.hxx
index 16104ab5e38ccd475337bbcb6321631c4f4fac27..a3fb45ea08c27c2bf60e8352b81d7cdb5b1878b7 100644 (file)
--- a/src/INTERP_KERNEL/CurveIntersectorP1P1PL.hxx
+++ b/src/INTERP_KERNEL/CurveIntersectorP1P1PL.hxx
@@ -39,8 +39,8 @@ namespace INTERP_KERNEL
                            double medianLine, int printLevel);
   public:
     void intersectCells(ConnType icellT, const std::vector<ConnType>& icellsS, MyMatrix& res);
-    int getNumberOfRowsOfResMatrix() const;
-    int getNumberOfColsOfResMatrix() const;
+    ConnType getNumberOfRowsOfResMatrix() const;
+    ConnType getNumberOfColsOfResMatrix() const;
   private:
     static void AppendValueInMatrix(MyMatrix& res, ConnType nodeIdT, ConnType nodeIdS0, double val0, ConnType nodeIdS1, double val1);
     static void AppendValueInMatrix2(typename MyMatrix::value_type& resRow, ConnType nodeIdS0, double val0);

diff --git a/src/INTERP_KERNEL/CurveIntersectorP1P1PL.txx b/src/INTERP_KERNEL/CurveIntersectorP1P1PL.txx
index 60bdd97e676eb22ae844b6403dc74f09e7e6db77..e9bd3e5c287664fec1d893878df47427a599dc4f 100644 (file)
--- a/src/INTERP_KERNEL/CurveIntersectorP1P1PL.txx
+++ b/src/INTERP_KERNEL/CurveIntersectorP1P1PL.txx
@@ -34,13 +34,13 @@ namespace INTERP_KERNEL
   }
 
   template<class MyMeshType, class MyMatrix>
-  int CurveIntersectorP1P1PL<MyMeshType,MyMatrix>::getNumberOfRowsOfResMatrix() const
+  typename MyMeshType::MyConnType CurveIntersectorP1P1PL<MyMeshType,MyMatrix>::getNumberOfRowsOfResMatrix() const
   {
     return CurveIntersector<MyMeshType,MyMatrix>::_meshT.getNumberOfNodes();
   }
 
   template<class MyMeshType, class MyMatrix>
-  int CurveIntersectorP1P1PL<MyMeshType,MyMatrix>::getNumberOfColsOfResMatrix() const
+  typename MyMeshType::MyConnType CurveIntersectorP1P1PL<MyMeshType,MyMatrix>::getNumberOfColsOfResMatrix() const
   {
     return CurveIntersector<MyMeshType,MyMatrix>::_meshS.getNumberOfNodes();
   }

diff --git a/src/INTERP_KERNEL/IntegralUniformIntersector.hxx b/src/INTERP_KERNEL/IntegralUniformIntersector.hxx
index 4b9c4b7cc3b70c5d87321fc9afb4a47383a446f9..8f4f5516feb6ff8c467609c3b132068c292b7466 100644 (file)
--- a/src/INTERP_KERNEL/IntegralUniformIntersector.hxx
+++ b/src/INTERP_KERNEL/IntegralUniformIntersector.hxx
@@ -51,8 +51,8 @@ namespace INTERP_KERNEL
     typedef typename MyMeshType::MyConnType ConnType;
   public:
     IntegralUniformIntersectorP0(const MyMeshType& mesh, bool isAbs);
-    int getNumberOfRowsOfResMatrix() const;
-    int getNumberOfColsOfResMatrix() const;
+    ConnType getNumberOfRowsOfResMatrix() const;
+    ConnType getNumberOfColsOfResMatrix() const;
     void intersectCells(ConnType targetCell, const std::vector<ConnType>& srcCells, MyMatrix& res);
   };
 
@@ -63,8 +63,8 @@ namespace INTERP_KERNEL
     typedef typename MyMeshType::MyConnType ConnType;
   public:
     IntegralUniformIntersectorP1(const MyMeshType& mesh, bool isAbs);
-    int getNumberOfRowsOfResMatrix() const;
-    int getNumberOfColsOfResMatrix() const;
+    ConnType getNumberOfRowsOfResMatrix() const;
+    ConnType getNumberOfColsOfResMatrix() const;
     void intersectCells(ConnType targetCell, const std::vector<ConnType>& srcCells, MyMatrix& res);
   };
 }

diff --git a/src/INTERP_KERNEL/IntegralUniformIntersector.txx b/src/INTERP_KERNEL/IntegralUniformIntersector.txx
index c31bf6ed9f52b016d7eb3f76c2ca07e8f72d8656..d328faa6ae3bae7761d805c3806378bf8d5ddaec 100755 (executable)
--- a/src/INTERP_KERNEL/IntegralUniformIntersector.txx
+++ b/src/INTERP_KERNEL/IntegralUniformIntersector.txx
@@ -69,7 +69,7 @@ namespace INTERP_KERNEL
   }
 
   template<class MyMeshType, class MyMatrix>
-  int IntegralUniformIntersectorP0<MyMeshType,MyMatrix>::getNumberOfRowsOfResMatrix() const
+  typename MyMeshType::MyConnType IntegralUniformIntersectorP0<MyMeshType,MyMatrix>::getNumberOfRowsOfResMatrix() const
   {
     if(IntegralUniformIntersector<MyMeshType,MyMatrix>::_from_to)
       return 1;
@@ -78,7 +78,7 @@ namespace INTERP_KERNEL
   }
   
   template<class MyMeshType, class MyMatrix>
-  int IntegralUniformIntersectorP0<MyMeshType,MyMatrix>::getNumberOfColsOfResMatrix() const
+  typename MyMeshType::MyConnType IntegralUniformIntersectorP0<MyMeshType,MyMatrix>::getNumberOfColsOfResMatrix() const
   {
     if(IntegralUniformIntersector<MyMeshType,MyMatrix>::_from_to)
       return IntegralUniformIntersector<MyMeshType,MyMatrix>::_mesh.getNumberOfElements();
@@ -109,7 +109,7 @@ namespace INTERP_KERNEL
   }
 
   template<class MyMeshType, class MyMatrix>
-  int IntegralUniformIntersectorP1<MyMeshType,MyMatrix>::getNumberOfRowsOfResMatrix() const
+  typename MyMeshType::MyConnType IntegralUniformIntersectorP1<MyMeshType,MyMatrix>::getNumberOfRowsOfResMatrix() const
   {
     if(IntegralUniformIntersector<MyMeshType,MyMatrix>::_from_to)
       return 1;
@@ -118,7 +118,7 @@ namespace INTERP_KERNEL
   }
   
   template<class MyMeshType, class MyMatrix>
-  int IntegralUniformIntersectorP1<MyMeshType,MyMatrix>::getNumberOfColsOfResMatrix() const
+  typename MyMeshType::MyConnType IntegralUniformIntersectorP1<MyMeshType,MyMatrix>::getNumberOfColsOfResMatrix() const
   {
     if(IntegralUniformIntersector<MyMeshType,MyMatrix>::_from_to)
       return IntegralUniformIntersector<MyMeshType,MyMatrix>::_mesh.getNumberOfNodes();
@@ -138,7 +138,7 @@ namespace INTERP_KERNEL
     for(ConnType i=0;i<nbelem;i++)
       {
         INTERP_KERNEL::NormalizedCellType t=IntegralUniformIntersector<MyMeshType,MyMatrix>::_mesh.getTypeOfElement(OTT<ConnType,numPol>::indFC(i));
-        int lgth=connIndx[i+1]-connIndx[i];
+        ConnType lgth=connIndx[i+1]-connIndx[i];
         const ConnType *locConn=conn+OTT<ConnType,numPol>::ind2C(connIndx[i]);
         double val=computeVolSurfOfCell<ConnType,numPol,MyMeshType::MY_SPACEDIM>(t,locConn,lgth,coords);
         if(t==NORM_TRI3)
@@ -147,7 +147,7 @@ namespace INTERP_KERNEL
           val/=4.;
         else
           throw INTERP_KERNEL::Exception("Invalid cell type detected : must be TRI3 or TETRA4 ! ");
-        for(int j=0;j<lgth;j++)
+        for(ConnType j=0;j<lgth;j++)
           IntegralUniformIntersector<MyMeshType,MyMatrix>::putValueIn(OTT<ConnType,numPol>::coo2C(locConn[j]),val,res);
       }
   }

diff --git a/src/INTERP_KERNEL/Interpolation2D3D.hxx b/src/INTERP_KERNEL/Interpolation2D3D.hxx
index ddfaf93dc972cabfa1ed6b74327becb398567dce..d23b91478d2299a822a5f19cb4df47f9a62d6e46 100644 (file)
--- a/src/INTERP_KERNEL/Interpolation2D3D.hxx
+++ b/src/INTERP_KERNEL/Interpolation2D3D.hxx
@@ -47,7 +47,7 @@ namespace INTERP_KERNEL
     INTERPKERNEL_EXPORT Interpolation2D3D();
     INTERPKERNEL_EXPORT Interpolation2D3D(const InterpolationOptions& io);
     template<class MyMeshType, class MyMatrixType>
-    int interpolateMeshes(const MyMeshType& srcMesh,
+    typename MyMeshType::MyConnType interpolateMeshes(const MyMeshType& srcMesh,
                           const MyMeshType& targetMesh,
                           MyMatrixType& matrix,
                           const std::string& method);

diff --git a/src/INTERP_KERNEL/Interpolation2D3D.txx b/src/INTERP_KERNEL/Interpolation2D3D.txx
index 3531e9dce2a4b9688678bd89d84ee27ffc211c77..4e7fac89884bcb1dc258ee2590eb29e2c1b143ab 100755 (executable)
--- a/src/INTERP_KERNEL/Interpolation2D3D.txx
+++ b/src/INTERP_KERNEL/Interpolation2D3D.txx
@@ -60,7 +60,7 @@ namespace INTERP_KERNEL
    *
    */
   template<class MyMeshType, class MyMatrixType>
-  ConnType Interpolation2D3D::interpolateMeshes(const MyMeshType& srcMesh,
+  typename MyMeshType::MyConnType Interpolation2D3D::interpolateMeshes(const MyMeshType& srcMesh,
                                            const MyMeshType& targetMesh,
                                            MyMatrixType& matrix,
                                            const std::string& method)

diff --git a/src/INTERP_KERNEL/InterpolationCU.hxx b/src/INTERP_KERNEL/InterpolationCU.hxx
index 0d36165ead9a8f887488ddcf57966416f0d82efa..31c95329c1a12819130ee2831440311c7bae7f0f 100644 (file)
--- a/src/INTERP_KERNEL/InterpolationCU.hxx
+++ b/src/INTERP_KERNEL/InterpolationCU.hxx
@@ -37,10 +37,10 @@ namespace INTERP_KERNEL
     InterpolationCU(const InterpolationOptions & io);
 
     template<class MyCMeshType, class MyUMeshType, class MatrixType>
-    int interpolateMeshes(const MyCMeshType& meshS, const MyUMeshType& meshT, MatrixType& result, const char *method);
+    typename MyCMeshType::MyConnType interpolateMeshes(const MyCMeshType& meshS, const MyUMeshType& meshT, MatrixType& result, const char *method);
 
     template<class MyUMeshType, class MyCMeshType, class MatrixType>
-    int interpolateMeshesRev(const MyUMeshType& meshS, const MyCMeshType& meshT, MatrixType& result, const char *method);
+    typename MyUMeshType::MyConnType interpolateMeshesRev(const MyUMeshType& meshS, const MyCMeshType& meshT, MatrixType& result, const char *method);
 
   };
 }

diff --git a/src/INTERP_KERNEL/InterpolationCU.txx b/src/INTERP_KERNEL/InterpolationCU.txx
index bc9cdeace60da164636c3e2193f68ecfda08e38a..eae13af3afd12a9a49289af868331d97abb078e9 100644 (file)
--- a/src/INTERP_KERNEL/InterpolationCU.txx
+++ b/src/INTERP_KERNEL/InterpolationCU.txx
@@ -92,12 +92,13 @@ namespace INTERP_KERNEL
   //================================================================================
 
   template<class MyCMeshType, class MyUMeshType, class MatrixType>
-  ConnType InterpolationCU::interpolateMeshes(const MyCMeshType& src_mesh,
+  typename MyCMeshType::MyConnType InterpolationCU::interpolateMeshes(const MyCMeshType& src_mesh,
                                          const MyUMeshType& tgt_mesh,
                                          MatrixType&        result,
                                          const char *       method)
   {
     typedef typename MyCMeshType::MyConnType CConnType;
+    typedef typename MyUMeshType::MyConnType UConnType;
 
     if ( std::string("P0P0") != method )
       throw Exception("Only P0P0 method is implemented so far");
@@ -117,27 +118,27 @@ namespace INTERP_KERNEL
       }
     // create empty maps for all target elements
     result.resize( intersector->getNumberOfRowsOfResMatrix() );
-    const ConnType ret = intersector->getNumberOfColsOfResMatrix();
+    const CConnType ret = intersector->getNumberOfColsOfResMatrix();
 
     const double* src_coords[ dim ];
-    ConnType        src_nb_coords[ dim ];
-    std::map< double, ConnType> src_coord_to_index[ dim ];
+    CConnType  src_nb_coords[ dim ];
+    std::map< double, CConnType> src_coord_to_index[ dim ];
     for ( int j = 0; j < dim; ++j )
       {
         src_coords   [j] = src_mesh.getCoordsAlongAxis( _TMIC( j ));
         src_nb_coords[j] = static_cast<CConnType>(src_mesh.nbCellsAlongAxis  ( _TMIC( j ))) + 1;
-        for (ConnType i = 0; i < src_nb_coords[j]; ++i )
+        for (CConnType i = 0; i < src_nb_coords[j]; ++i )
           src_coord_to_index[j].insert( std::make_pair( src_coords[j][i], i ));
       }
 
-    const ConnType tgtu_nb_cells = tgt_mesh.getNumberOfElements();
+    const UConnType tgtu_nb_cells = tgt_mesh.getNumberOfElements();
 
     IntersectorCU<MyCMeshType, MyUMeshType, MatrixType> bbHelper(src_mesh, tgt_mesh);
     double bb[2*dim];
 
     // loop on unstructured tgt cells
 
-    for(ConnType iT=0; iT<tgtu_nb_cells; iT++)
+    for(UConnType iT=0; iT<tgtu_nb_cells; iT++)
       {
         result[ iT ].clear();
 
@@ -154,23 +155,23 @@ namespace INTERP_KERNEL
 
         // find structured src cells intersecting iT cell
         std::vector< std::vector< CConnType > > structIndices(1);
-        std::map< double, ConnType>::iterator coo_ind;
+        typename std::map< double, CConnType>::iterator coo_ind;
         for ( int j = 0; j < dim; ++j )
           {
             coo_ind = src_coord_to_index[j].lower_bound( bb[2*j+1] - eps );
             if ( coo_ind == src_coord_to_index[j].end() )
               --coo_ind;
-            ConnType max_i = coo_ind->second;
+            CConnType max_i = coo_ind->second;
 
             coo_ind = src_coord_to_index[j].upper_bound( bb[2*j  ] + eps );
             if ( coo_ind != src_coord_to_index[j].begin() )
               --coo_ind;
-            ConnType min_i = coo_ind->second;
+            CConnType min_i = coo_ind->second;
 
             std::vector< std::vector< CConnType > > newStructIndices;
             for ( unsigned int iInd = 0; iInd < structIndices.size(); ++iInd )
               {
-                for ( ConnType i = min_i; i < max_i; ++i )
+                for ( CConnType i = min_i; i < max_i; ++i )
                   {
                     std::vector< CConnType > index = structIndices[iInd];
                     index.push_back( i );
@@ -214,14 +215,17 @@ namespace INTERP_KERNEL
   //================================================================================
 
   template<class MyUMeshType, class MyCMeshType, class MatrixType>
-  ConnType InterpolationCU::interpolateMeshesRev(const MyUMeshType& meshS, const MyCMeshType& meshT, MatrixType& result, const char *method)
+  typename MyUMeshType::MyConnType InterpolationCU::interpolateMeshesRev(const MyUMeshType& meshS, const MyCMeshType& meshT, MatrixType& result, const char *method)
   {
+    typedef typename MyCMeshType::MyConnType CConnType;
+    typedef typename MyUMeshType::MyConnType UConnType;
+
     MatrixType revResult;
-    ConnType sizeT = interpolateMeshes( meshT, meshS, revResult, method );
-    ConnType sizeS = revResult.size();
+    CConnType sizeT = interpolateMeshes( meshT, meshS, revResult, method );
+    UConnType sizeS = revResult.size();
     result.resize( sizeT );
 
-    for ( ConnType iS = 0; iS < sizeS; ++iS )
+    for ( CConnType iS = 0; iS < sizeS; ++iS )
       {
         typename MatrixType::value_type & row = revResult[iS];
         typename MatrixType::value_type::iterator iT_surf = row.begin();

diff --git a/src/INTERP_KERNEL/InterpolationCurve.hxx b/src/INTERP_KERNEL/InterpolationCurve.hxx
index a194cf3cd48cebd6a94266c6fef85332dba4246e..af933231927ee5bf22fe8c5fad5b3f32b88356ea 100755 (executable)
--- a/src/INTERP_KERNEL/InterpolationCurve.hxx
+++ b/src/INTERP_KERNEL/InterpolationCurve.hxx
@@ -35,7 +35,7 @@ namespace INTERP_KERNEL
 \r
     // Main function to interpolate\r
     template<class MyMeshType, class MatrixType>\r
-    int interpolateMeshes(const MyMeshType& meshS, const MyMeshType& meshT,\r
+    typename MyMeshType::MyConnType interpolateMeshes(const MyMeshType& meshS, const MyMeshType& meshT,\r
                           MatrixType& result, const std::string& method);\r
     \r
   };\r

diff --git a/src/INTERP_KERNEL/InterpolationCurve.txx b/src/INTERP_KERNEL/InterpolationCurve.txx
index 6bd9beeb033c969480cf0147464afa8d9e0f951a..1718d9ca287a7b71ec8997390fca0baf4bebaf66 100755 (executable)
--- a/src/INTERP_KERNEL/InterpolationCurve.txx
+++ b/src/INTERP_KERNEL/InterpolationCurve.txx
@@ -73,7 +73,7 @@ namespace INTERP_KERNEL
       */
   template<class RealCurve>
   template<class MyMeshType, class MatrixType>
-  int InterpolationCurve<RealCurve>::interpolateMeshes (const MyMeshType&  myMeshS,
+  typename MyMeshType::MyConnType InterpolationCurve<RealCurve>::interpolateMeshes (const MyMeshType&  myMeshS,
                                                         const MyMeshType&  myMeshT,
                                                         MatrixType&        result,
                                                         const std::string& method)
@@ -187,17 +187,17 @@ namespace INTERP_KERNEL
     /****************************************************/
     long start_intersection = clock();
     const ConnType *connIndxT = myMeshT.getConnectivityIndexPtr();
-    for(int iT=0; iT<nbMailleT; iT++)
+    for(ConnType iT=0; iT<nbMailleT; iT++)
       {
         int nb_nodesT = connIndxT[iT+1] - connIndxT[iT];
-        std::vector<int> intersecting_elems;
+        std::vector<ConnType> intersecting_elems;
         double bb[2*SPACEDIM];
         intersector->getElemBB(bb,myMeshT,OTT<ConnType,numPol>::indFC(iT),nb_nodesT);
         my_tree.getIntersectingElems(bb, intersecting_elems);
         intersector->intersectCells(iT,intersecting_elems,result);
         counter += intersecting_elems.size();
       }
-    int ret = intersector->getNumberOfColsOfResMatrix();
+    ConnType ret = intersector->getNumberOfColsOfResMatrix();
     delete intersector;
     
     if (InterpolationOptions::getPrintLevel() >= 1)

diff --git a/src/INTERP_KERNEL/InterpolationPlanar.hxx b/src/INTERP_KERNEL/InterpolationPlanar.hxx
index d27580404615f9fb28b0fcf902f4f84e1bf7de2a..76b52f86f825d09f9f803655884a5896b5c17257 100755 (executable)
--- a/src/INTERP_KERNEL/InterpolationPlanar.hxx
+++ b/src/INTERP_KERNEL/InterpolationPlanar.hxx
@@ -43,7 +43,7 @@ namespace INTERP_KERNEL
 \r
     // Main function to interpolate triangular and quadratic meshes\r
     template<class MyMeshType, class MatrixType>\r
-    int interpolateMeshes(const MyMeshType& meshS, const MyMeshType& meshT, MatrixType& result, const std::string& method);\r
+    typename MyMeshType::MyConnType interpolateMeshes(const MyMeshType& meshS, const MyMeshType& meshT, MatrixType& result, const std::string& method);\r
   public:\r
     bool doRotate() const { return asLeafInterpPlanar().doRotate(); }\r
     double medianPlane() const { return asLeafInterpPlanar().medianPlane(); }\r

diff --git a/src/INTERP_KERNEL/InterpolationPlanar.txx b/src/INTERP_KERNEL/InterpolationPlanar.txx
index 264912bc6b5ea50970328e4f3bdd9ab0eb699113..0527ffda9d34766ed6d92662a00ba08074dfcbeb 100755 (executable)
--- a/src/INTERP_KERNEL/InterpolationPlanar.txx
+++ b/src/INTERP_KERNEL/InterpolationPlanar.txx
@@ -114,7 +114,7 @@ namespace INTERP_KERNEL
       */
   template<class RealPlanar>
   template<class MyMeshType, class MatrixType>
-  int InterpolationPlanar<RealPlanar>::interpolateMeshes(const MyMeshType& myMeshS, const MyMeshType& myMeshT, MatrixType& result, const std::string& method)
+  typename MyMeshType::MyConnType InterpolationPlanar<RealPlanar>::interpolateMeshes(const MyMeshType& myMeshS, const MyMeshType& myMeshT, MatrixType& result, const std::string& method)
   {
     static const int SPACEDIM=MyMeshType::MY_SPACEDIM;
     typedef typename MyMeshType::MyConnType ConnType;
@@ -397,12 +397,12 @@ namespace INTERP_KERNEL
     /* Loop on the target cells - core of the algorithm */
     /****************************************************/
     long start_intersection=clock();
-    long nbelem_type=myMeshT.getNumberOfElements();
+    ConnType nbelem_type=myMeshT.getNumberOfElements();
     const ConnType *connIndxT=myMeshT.getConnectivityIndexPtr();
-    for(int iT=0; iT<nbelem_type; iT++)
+    for(ConnType iT=0; iT<nbelem_type; iT++)
       {
         int nb_nodesT=connIndxT[iT+1]-connIndxT[iT];
-        std::vector<int> intersecting_elems;
+        std::vector<ConnType> intersecting_elems;
         double bb[2*SPACEDIM];
         intersector->getElemBB(bb,myMeshT,OTT<ConnType,numPol>::indFC(iT),nb_nodesT);
         my_tree.getIntersectingElems(bb, intersecting_elems);
@@ -410,7 +410,7 @@ namespace INTERP_KERNEL
         counter+=intersecting_elems.size();
         intersecting_elems.clear();
       }
-    int ret=intersector->getNumberOfColsOfResMatrix();
+    ConnType ret=intersector->getNumberOfColsOfResMatrix();
     delete intersector;
 
     if (InterpolationOptions::getPrintLevel() >=1)

diff --git a/src/INTERP_KERNEL/Intersector3DP0P0.hxx b/src/INTERP_KERNEL/Intersector3DP0P0.hxx
index ccb8ed34993dac77d31b8d6e0d12af1db39cb699..987fd7f294ea7d02defc351eb82e6818e489f581 100644 (file)
--- a/src/INTERP_KERNEL/Intersector3DP0P0.hxx
+++ b/src/INTERP_KERNEL/Intersector3DP0P0.hxx
@@ -30,8 +30,8 @@ namespace INTERP_KERNEL
   {
   public:
     Intersector3DP0P0(const MyMeshType& targetMesh, const MyMeshType& srcMesh);
-    int getNumberOfRowsOfResMatrix() const;
-    int getNumberOfColsOfResMatrix() const;
+    typename MyMeshType::MyConnType getNumberOfRowsOfResMatrix() const;
+    typename MyMeshType::MyConnType getNumberOfColsOfResMatrix() const;
   };
 }
 

diff --git a/src/INTERP_KERNEL/Intersector3DP0P0.txx b/src/INTERP_KERNEL/Intersector3DP0P0.txx
index 7b3db0bc5f01fe646a8f86e616f03fb8637fdf85..86fed9bacefd0491c6c419259af17e773d7f134e 100644 (file)
--- a/src/INTERP_KERNEL/Intersector3DP0P0.txx
+++ b/src/INTERP_KERNEL/Intersector3DP0P0.txx
@@ -31,13 +31,13 @@ namespace INTERP_KERNEL
   }
 
   template<class MyMeshType, class MyMatrix>
-  int Intersector3DP0P0<MyMeshType,MyMatrix>::getNumberOfRowsOfResMatrix() const
+  typename MyMeshType::MyConnType Intersector3DP0P0<MyMeshType,MyMatrix>::getNumberOfRowsOfResMatrix() const
   {
     return Intersector3D<MyMeshType,MyMatrix>::_target_mesh.getNumberOfElements();
   }
 
   template<class MyMeshType, class MyMatrix>
-  int Intersector3DP0P0<MyMeshType,MyMatrix>::getNumberOfColsOfResMatrix() const
+  typename MyMeshType::MyConnType Intersector3DP0P0<MyMeshType,MyMatrix>::getNumberOfColsOfResMatrix() const
   {
     return Intersector3D<MyMeshType,MyMatrix>::_src_mesh.getNumberOfElements();
   }

diff --git a/src/INTERP_KERNEL/Intersector3DP0P1.hxx b/src/INTERP_KERNEL/Intersector3DP0P1.hxx
index 0c599f04fe7c709cbba3233240ac95991cfd53d1..7032d1e112cc5fc9ed2874a32c7f3d2a1a2b32c7 100644 (file)
--- a/src/INTERP_KERNEL/Intersector3DP0P1.hxx
+++ b/src/INTERP_KERNEL/Intersector3DP0P1.hxx
@@ -30,8 +30,8 @@ namespace INTERP_KERNEL
   {
   public:
     Intersector3DP0P1(const MyMeshType& targetMesh, const MyMeshType& srcMesh);
-    int getNumberOfRowsOfResMatrix() const;
-    int getNumberOfColsOfResMatrix() const;
+    typename MyMeshType::MyConnType getNumberOfRowsOfResMatrix() const;
+    typename MyMeshType::MyConnType getNumberOfColsOfResMatrix() const;
   };
 }
 

diff --git a/src/INTERP_KERNEL/Intersector3DP0P1.txx b/src/INTERP_KERNEL/Intersector3DP0P1.txx
index 62a632caefc0062b4630d5504fb405c2932bff0e..f9e067da2b6e3c1b7957c8384d3c12c417d4fa88 100644 (file)
--- a/src/INTERP_KERNEL/Intersector3DP0P1.txx
+++ b/src/INTERP_KERNEL/Intersector3DP0P1.txx
@@ -31,13 +31,13 @@ namespace INTERP_KERNEL
   }
 
   template<class MyMeshType, class MyMatrix>
-  int Intersector3DP0P1<MyMeshType,MyMatrix>::getNumberOfRowsOfResMatrix() const
+  typename MyMeshType::MyConnType Intersector3DP0P1<MyMeshType,MyMatrix>::getNumberOfRowsOfResMatrix() const
   {
     return Intersector3D<MyMeshType,MyMatrix>::_target_mesh.getNumberOfNodes();
   }
 
   template<class MyMeshType, class MyMatrix>
-  int Intersector3DP0P1<MyMeshType,MyMatrix>::getNumberOfColsOfResMatrix() const
+  typename MyMeshType::MyConnType Intersector3DP0P1<MyMeshType,MyMatrix>::getNumberOfColsOfResMatrix() const
   {
     return Intersector3D<MyMeshType,MyMatrix>::_src_mesh.getNumberOfElements();
   }

diff --git a/src/INTERP_KERNEL/Intersector3DP1P0.hxx b/src/INTERP_KERNEL/Intersector3DP1P0.hxx
index fbaac7a69cab475e6f476fa24ce9ba925c14a125..3a310c8014642fb2dfa9830073dac9bb9de7c7cb 100644 (file)
--- a/src/INTERP_KERNEL/Intersector3DP1P0.hxx
+++ b/src/INTERP_KERNEL/Intersector3DP1P0.hxx
@@ -30,8 +30,8 @@ namespace INTERP_KERNEL
   {
   public:
     Intersector3DP1P0(const MyMeshType& targetMesh, const MyMeshType& srcMesh);
-    int getNumberOfRowsOfResMatrix() const;
-    int getNumberOfColsOfResMatrix() const;
+    typename MyMeshType::MyConnType getNumberOfRowsOfResMatrix() const;
+    typename MyMeshType::MyConnType getNumberOfColsOfResMatrix() const;
   };
 }
 

diff --git a/src/INTERP_KERNEL/Intersector3DP1P0.txx b/src/INTERP_KERNEL/Intersector3DP1P0.txx
index 7926071016964ec71080f400edee46ae6d544760..235babdfc0ae59381ee361a194a71afbec42b5b2 100644 (file)
--- a/src/INTERP_KERNEL/Intersector3DP1P0.txx
+++ b/src/INTERP_KERNEL/Intersector3DP1P0.txx
@@ -31,13 +31,13 @@ namespace INTERP_KERNEL
   }
 
   template<class MyMeshType, class MyMatrix>
-  int Intersector3DP1P0<MyMeshType,MyMatrix>::getNumberOfRowsOfResMatrix() const
+  typename MyMeshType::MyConnType Intersector3DP1P0<MyMeshType,MyMatrix>::getNumberOfRowsOfResMatrix() const
   {
     return Intersector3D<MyMeshType,MyMatrix>::_target_mesh.getNumberOfElements();
   }
   
   template<class MyMeshType, class MyMatrix>
-  int Intersector3DP1P0<MyMeshType,MyMatrix>::getNumberOfColsOfResMatrix() const
+  typename MyMeshType::MyConnType Intersector3DP1P0<MyMeshType,MyMatrix>::getNumberOfColsOfResMatrix() const
   {
     return Intersector3D<MyMeshType,MyMatrix>::_src_mesh.getNumberOfNodes();
   }

diff --git a/src/INTERP_KERNEL/Intersector3DP1P0Bary.hxx b/src/INTERP_KERNEL/Intersector3DP1P0Bary.hxx
index 4871adf4890a00d30b19305dc6845efd0a87392b..79532b6ea8c25f98a196f97f6f4d6a007bf6b43c 100644 (file)
--- a/src/INTERP_KERNEL/Intersector3DP1P0Bary.hxx
+++ b/src/INTERP_KERNEL/Intersector3DP1P0Bary.hxx
@@ -30,8 +30,8 @@ namespace INTERP_KERNEL
   {
   public:
     Intersector3DP1P0Bary(const MyMeshType& targetMesh, const MyMeshType& srcMesh);
-    int getNumberOfRowsOfResMatrix() const;
-    int getNumberOfColsOfResMatrix() const;
+    typename MyMeshType::MyConnType getNumberOfRowsOfResMatrix() const;
+    typename MyMeshType::MyConnType getNumberOfColsOfResMatrix() const;
   };
 }
 

diff --git a/src/INTERP_KERNEL/Intersector3DP1P0Bary.txx b/src/INTERP_KERNEL/Intersector3DP1P0Bary.txx
index 4c8498e7a37c482b4f906617f016f14886682d96..40a20eee0f58207a40ba03435d543195991b50af 100644 (file)
--- a/src/INTERP_KERNEL/Intersector3DP1P0Bary.txx
+++ b/src/INTERP_KERNEL/Intersector3DP1P0Bary.txx
@@ -31,13 +31,13 @@ namespace INTERP_KERNEL
   }
 
   template<class MyMeshType, class MyMatrix>
-  int Intersector3DP1P0Bary<MyMeshType,MyMatrix>::getNumberOfRowsOfResMatrix() const
+  typename MyMeshType::MyConnType Intersector3DP1P0Bary<MyMeshType,MyMatrix>::getNumberOfRowsOfResMatrix() const
   {
     return Intersector3D<MyMeshType,MyMatrix>::_target_mesh.getNumberOfElements();
   }
   
   template<class MyMeshType, class MyMatrix>
-  int Intersector3DP1P0Bary<MyMeshType,MyMatrix>::getNumberOfColsOfResMatrix() const
+  typename MyMeshType::MyConnType Intersector3DP1P0Bary<MyMeshType,MyMatrix>::getNumberOfColsOfResMatrix() const
   {
     return Intersector3D<MyMeshType,MyMatrix>::_src_mesh.getNumberOfNodes();
   }

diff --git a/src/INTERP_KERNEL/Intersector3DP1P1.hxx b/src/INTERP_KERNEL/Intersector3DP1P1.hxx
index e337bf471c9ce7b999a23265326f569bf9ad9b15..b5c1374e7d9bd4c72b2d1ea2137890ef534c9e52 100644 (file)
--- a/src/INTERP_KERNEL/Intersector3DP1P1.hxx
+++ b/src/INTERP_KERNEL/Intersector3DP1P1.hxx
@@ -30,8 +30,8 @@ namespace INTERP_KERNEL
   {
   public:
     Intersector3DP1P1(const MyMeshType& targetMesh, const MyMeshType& srcMesh);
-    int getNumberOfRowsOfResMatrix() const;
-    int getNumberOfColsOfResMatrix() const;
+    typename MyMeshType::MyConnType getNumberOfRowsOfResMatrix() const;
+    typename MyMeshType::MyConnType getNumberOfColsOfResMatrix() const;
   };
 }
 

diff --git a/src/INTERP_KERNEL/Intersector3DP1P1.txx b/src/INTERP_KERNEL/Intersector3DP1P1.txx
index 73bdbecb625f2c968670da8ef60beb1a30b2649e..5e89479167f2f95c43b3e5148a709163eb0ffeb8 100644 (file)
--- a/src/INTERP_KERNEL/Intersector3DP1P1.txx
+++ b/src/INTERP_KERNEL/Intersector3DP1P1.txx
@@ -31,13 +31,13 @@ namespace INTERP_KERNEL
   }
 
   template<class MyMeshType, class MyMatrix>
-  int Intersector3DP1P1<MyMeshType,MyMatrix>::getNumberOfRowsOfResMatrix() const
+  typename MyMeshType::MyConnType Intersector3DP1P1<MyMeshType,MyMatrix>::getNumberOfRowsOfResMatrix() const
   {
     return Intersector3D<MyMeshType,MyMatrix>::_target_mesh.getNumberOfNodes();
   }
 
   template<class MyMeshType, class MyMatrix>
-  int Intersector3DP1P1<MyMeshType,MyMatrix>::getNumberOfColsOfResMatrix() const
+  typename MyMeshType::MyConnType Intersector3DP1P1<MyMeshType,MyMatrix>::getNumberOfColsOfResMatrix() const
   {
     return Intersector3D<MyMeshType,MyMatrix>::_src_mesh.getNumberOfNodes();
   }

diff --git a/src/INTERP_KERNEL/IntersectorCU.hxx b/src/INTERP_KERNEL/IntersectorCU.hxx
index e0b6329649ec08583712147a67d3c8a96021654b..7c3214e1d4b764e2eb387e380064dee9b96e136c 100644 (file)
--- a/src/INTERP_KERNEL/IntersectorCU.hxx
+++ b/src/INTERP_KERNEL/IntersectorCU.hxx
@@ -47,8 +47,8 @@ namespace INTERP_KERNEL
     void getUElemBB(double* bb, UConnType iP);
     void getUCoordinates(UConnType icell, std::vector<double>& coords);
 
-    int getNumberOfRowsOfResMatrix() const;
-    int getNumberOfColsOfResMatrix() const;
+    UConnType getNumberOfRowsOfResMatrix() const;
+    CConnType getNumberOfColsOfResMatrix() const;
     void intersectCells(CConnType icellU, const std::vector<CConnType>& icellC, MyMatrix& res);
     double intersectGeometry(CConnType icellT, const std::vector<CConnType>& icellC) { return asLeaf().intersectGeometry(icellT,icellC); }
   protected:
@@ -61,7 +61,7 @@ namespace INTERP_KERNEL
     const MyUMeshType& _meshU;
 
     const double *     _coordsC[SPACEDIM];
-    int                _nbCellsC[SPACEDIM];
+    CConnType          _nbCellsC[SPACEDIM];
     const MyCMeshType& _meshC;
   };
 

diff --git a/src/INTERP_KERNEL/IntersectorCU.txx b/src/INTERP_KERNEL/IntersectorCU.txx
index 6fc333f7a278e9096a32ce326bfffea0baf4b5af..13f334a80eb1d24e38c8040a94b77e1d5e012ebd 100644 (file)
--- a/src/INTERP_KERNEL/IntersectorCU.txx
+++ b/src/INTERP_KERNEL/IntersectorCU.txx
@@ -123,12 +123,12 @@ namespace INTERP_KERNEL
   }
 
   _CU_TEMPLATE
-  int _INTERSECTOR_CU_::getNumberOfRowsOfResMatrix() const
+  typename MyUMeshType::MyConnType _INTERSECTOR_CU_::getNumberOfRowsOfResMatrix() const
   {
     return _meshU.getNumberOfElements();
   }
   _CU_TEMPLATE
-  int _INTERSECTOR_CU_::getNumberOfColsOfResMatrix() const
+  typename MyCMeshType::MyConnType _INTERSECTOR_CU_::getNumberOfColsOfResMatrix() const
   {
     return static_cast<CConnType>(_meshC.getNumberOfElements());
   }

diff --git a/src/INTERP_KERNEL/MappedBarycentric2DIntersectorP1P1.hxx b/src/INTERP_KERNEL/MappedBarycentric2DIntersectorP1P1.hxx
index b9d525f8ae65ddb4e8d81f5c57833609ad35d9b1..cef886d5188bc4bb51c3eacc6c68713239f2654b 100644 (file)
--- a/src/INTERP_KERNEL/MappedBarycentric2DIntersectorP1P1.hxx
+++ b/src/INTERP_KERNEL/MappedBarycentric2DIntersectorP1P1.hxx
@@ -36,8 +36,8 @@ namespace INTERP_KERNEL
   public:
     MappedBarycentric2DIntersectorP1P1(const MyMeshType& meshT, const MyMeshType& meshS, double dimCaracteristic, double md3DSurf, double minDot3DSurf, double medianPlane, double precision, int orientation);
     void intersectCells(ConnType icellT, const std::vector<ConnType>& icellsS, MyMatrix& res);
-    int getNumberOfRowsOfResMatrix() const;
-    int getNumberOfColsOfResMatrix() const;
+    ConnType getNumberOfRowsOfResMatrix() const;
+    ConnType getNumberOfColsOfResMatrix() const;
   };
 }
 

diff --git a/src/INTERP_KERNEL/MappedBarycentric2DIntersectorP1P1.txx b/src/INTERP_KERNEL/MappedBarycentric2DIntersectorP1P1.txx
index 4088f3fdc7a814a8ad6ac54cdfe0f88c094e0105..4939806e9b5eb03e84181eda06ff784812e6137b 100644 (file)
--- a/src/INTERP_KERNEL/MappedBarycentric2DIntersectorP1P1.txx
+++ b/src/INTERP_KERNEL/MappedBarycentric2DIntersectorP1P1.txx
@@ -55,7 +55,7 @@ namespace INTERP_KERNEL
         if(SPACEDIM==3)
           PlanarIntersector<MyMeshType,MyMatrix>::projectionThis(&CoordsS[0],&CoordsTTmp[0],ToConnType(CoordsS.size())/SPACEDIM,nbOfNodesT);
         const ConnType *startOfCellNodeConnT=PlanarIntersector<MyMeshType,MyMatrix>::_connectT+OTT<ConnType,numPol>::conn2C(PlanarIntersector<MyMeshType,MyMatrix>::_connIndexT[icellT]);
-        for(int nodeIdT=0;nodeIdT<nbOfNodesT;nodeIdT++)
+        for(ConnType nodeIdT=0;nodeIdT<nbOfNodesT;nodeIdT++)
           {
             typename MyMatrix::value_type& resRow=res[OTT<ConnType,numPol>::ind2C(startOfCellNodeConnT[nodeIdT])];
             if( PointLocatorAlgos<MyMeshType>::isElementContainsPointAlg2D(&CoordsTTmp[nodeIdT*SPACEDIM],&CoordsS[0],4,PlanarIntersector<MyMeshType,MyMatrix>::_precision) )
@@ -74,7 +74,7 @@ namespace INTERP_KERNEL
                 resLoc[3] =  mco[0]     * (1.-mco[1]);
 
                 const ConnType *startOfCellNodeConnS=PlanarIntersector<MyMeshType,MyMatrix>::_connectS+OTT<ConnType,numPol>::conn2C(PlanarIntersector<MyMeshType,MyMatrix>::_connIndexS[*iter]);
-                for(int nodeIdS=0;nodeIdS<4;nodeIdS++)
+                for(ConnType nodeIdS=0;nodeIdS<4;nodeIdS++)
                   {
                     if(fabs(resLoc[nodeIdS])>PlanarIntersector<MyMeshType,MyMatrix>::_precision)
                       {
@@ -96,13 +96,13 @@ namespace INTERP_KERNEL
   }
 
   template<class MyMeshType, class MyMatrix>
-  int MappedBarycentric2DIntersectorP1P1<MyMeshType,MyMatrix>::getNumberOfRowsOfResMatrix() const
+  typename MyMeshType::MyConnType MappedBarycentric2DIntersectorP1P1<MyMeshType,MyMatrix>::getNumberOfRowsOfResMatrix() const
   {
     return PlanarIntersector<MyMeshType,MyMatrix>::_meshT.getNumberOfNodes();
   }
 
   template<class MyMeshType, class MyMatrix>
-  int MappedBarycentric2DIntersectorP1P1<MyMeshType,MyMatrix>::getNumberOfColsOfResMatrix() const
+  typename MyMeshType::MyConnType MappedBarycentric2DIntersectorP1P1<MyMeshType,MyMatrix>::getNumberOfColsOfResMatrix() const
   {
     return PlanarIntersector<MyMeshType,MyMatrix>::_meshS.getNumberOfNodes();
   }

diff --git a/src/INTERP_KERNEL/Planar2D1DIntersectorP0P0.hxx b/src/INTERP_KERNEL/Planar2D1DIntersectorP0P0.hxx
index 8f125a974e78b56dba4e45f560732402ef71ad7b..b59a9bb5501cb522568ee13ac3475a59f5aedb90 100644 (file)
--- a/src/INTERP_KERNEL/Planar2D1DIntersectorP0P0.hxx
+++ b/src/INTERP_KERNEL/Planar2D1DIntersectorP0P0.hxx
@@ -37,8 +37,8 @@ namespace INTERP_KERNEL
     Planar2D1DIntersectorP0P0(const MyMeshType& meshT, const MyMeshType& meshS,
                               double dimCaracteristic, double precision, double md3DSurf, double minDot3DSurf, double medianPlane, bool doRotate, int orientation, int printLevel);
   public:
-    int getNumberOfRowsOfResMatrix() const;
-    int getNumberOfColsOfResMatrix() const;
+    ConnType getNumberOfRowsOfResMatrix() const;
+    ConnType getNumberOfColsOfResMatrix() const;
     const typename PlanarIntersector<MyMeshType,MyMatrix>::DuplicateFacesType* getIntersectFaces() const
     {
       return &_intersect_faces;

diff --git a/src/INTERP_KERNEL/Planar2D1DIntersectorP0P0.txx b/src/INTERP_KERNEL/Planar2D1DIntersectorP0P0.txx
index ecc8c1e4c22a709db365a00857c2b3a3a9745d6e..5c85b45e7a1f838ac23f712600f92e4becb6d3c1 100644 (file)
--- a/src/INTERP_KERNEL/Planar2D1DIntersectorP0P0.txx
+++ b/src/INTERP_KERNEL/Planar2D1DIntersectorP0P0.txx
@@ -33,13 +33,13 @@ namespace INTERP_KERNEL
   }
 
   template<class MyMeshType, class MyMatrix, class ConcreteP0P0Intersector>
-  int Planar2D1DIntersectorP0P0<MyMeshType,MyMatrix,ConcreteP0P0Intersector>::getNumberOfRowsOfResMatrix() const
+  typename MyMeshType::MyConnType Planar2D1DIntersectorP0P0<MyMeshType,MyMatrix,ConcreteP0P0Intersector>::getNumberOfRowsOfResMatrix() const
   {
     return PlanarIntersector<MyMeshType,MyMatrix>::_meshT.getNumberOfElements();
   }
 
   template<class MyMeshType, class MyMatrix, class ConcreteP0P0Intersector>
-  int Planar2D1DIntersectorP0P0<MyMeshType,MyMatrix,ConcreteP0P0Intersector>::getNumberOfColsOfResMatrix() const
+  typename MyMeshType::MyConnType Planar2D1DIntersectorP0P0<MyMeshType,MyMatrix,ConcreteP0P0Intersector>::getNumberOfColsOfResMatrix() const
   {
     return PlanarIntersector<MyMeshType,MyMatrix>::_meshS.getNumberOfElements();
   }
@@ -47,12 +47,12 @@ namespace INTERP_KERNEL
   template<class MyMeshType, class MyMatrix, class ConcreteP0P0Intersector>
   void Planar2D1DIntersectorP0P0<MyMeshType,MyMatrix,ConcreteP0P0Intersector>::intersectCells(ConnType icellT, const std::vector<ConnType>& icellsS, MyMatrix& res)
   {
-    int nbNodesT=PlanarIntersector<MyMeshType,MyMatrix>::_connIndexT[icellT+1]-PlanarIntersector<MyMeshType,MyMatrix>::_connIndexT[icellT];
+    ConnType nbNodesT=PlanarIntersector<MyMeshType,MyMatrix>::_connIndexT[icellT+1]-PlanarIntersector<MyMeshType,MyMatrix>::_connIndexT[icellT];
     typename MyMatrix::value_type& resRow=res[icellT];
     for(typename std::vector<ConnType>::const_iterator iter=icellsS.begin();iter!=icellsS.end();iter++)
       {
-        int iS=*iter;
-        int nbNodesS=PlanarIntersector<MyMeshType,MyMatrix>::_connIndexS[iS+1]-PlanarIntersector<MyMeshType,MyMatrix>::_connIndexS[iS];
+        ConnType iS=*iter;
+        ConnType nbNodesS=PlanarIntersector<MyMeshType,MyMatrix>::_connIndexS[iS+1]-PlanarIntersector<MyMeshType,MyMatrix>::_connIndexS[iS];
         bool isColinear = false;
         double surf=intersectGeometry1D(OTT<ConnType,numPol>::indFC(icellT),OTT<ConnType,numPol>::indFC(iS),
                                         nbNodesT,nbNodesS, isColinear);
@@ -69,7 +69,7 @@ namespace INTERP_KERNEL
             }
           else
             {
-              std::set<int> targetCellSet;
+              std::set<ConnType> targetCellSet;
               targetCellSet.insert(icellT);
               _intersect_faces.insert(std::make_pair(iS, targetCellSet));
             }

diff --git a/src/INTERP_KERNEL/PlanarIntersectorP0P0.hxx b/src/INTERP_KERNEL/PlanarIntersectorP0P0.hxx
index 5b23d1862bfacf413ea6f6cb4c7491b1a5fda14b..9beb3c2db0781a0487fcf96029218761c55907e0 100644 (file)
--- a/src/INTERP_KERNEL/PlanarIntersectorP0P0.hxx
+++ b/src/INTERP_KERNEL/PlanarIntersectorP0P0.hxx
@@ -36,8 +36,8 @@ namespace INTERP_KERNEL
   protected:
     PlanarIntersectorP0P0(const MyMeshType& meshT, const MyMeshType& meshS, double dimCaracteristic, double precision, double md3DSurf, double minDot3DSurf, double medianPlane, bool doRotate, int orientation, int printLevel);
   public:
-    int getNumberOfRowsOfResMatrix() const;
-    int getNumberOfColsOfResMatrix() const;
+    ConnType getNumberOfRowsOfResMatrix() const;
+    ConnType getNumberOfColsOfResMatrix() const;
     void intersectCells(ConnType icellT, const std::vector<ConnType>& icellsS, MyMatrix& res);
     /*!
      * Contrary to intersectCells method here icellS and icellT are \b not in \b C mode but in mode of MyMeshType.

diff --git a/src/INTERP_KERNEL/PlanarIntersectorP0P0.txx b/src/INTERP_KERNEL/PlanarIntersectorP0P0.txx
index 478ff1c15f4d7c5d7953116144006b43115bda5d..02d38c4df61defcb878db240f5a9fcb2680cb4b9 100644 (file)
--- a/src/INTERP_KERNEL/PlanarIntersectorP0P0.txx
+++ b/src/INTERP_KERNEL/PlanarIntersectorP0P0.txx
@@ -33,13 +33,13 @@ namespace INTERP_KERNEL
   }
 
   template<class MyMeshType, class MyMatrix, class ConcreteP0P0Intersector>
-  int PlanarIntersectorP0P0<MyMeshType,MyMatrix,ConcreteP0P0Intersector>::getNumberOfRowsOfResMatrix() const
+  typename MyMeshType::MyConnType PlanarIntersectorP0P0<MyMeshType,MyMatrix,ConcreteP0P0Intersector>::getNumberOfRowsOfResMatrix() const
   {
     return PlanarIntersector<MyMeshType,MyMatrix>::_meshT.getNumberOfElements();
   }
 
   template<class MyMeshType, class MyMatrix, class ConcreteP0P0Intersector>
-  int PlanarIntersectorP0P0<MyMeshType,MyMatrix,ConcreteP0P0Intersector>::getNumberOfColsOfResMatrix() const
+  typename MyMeshType::MyConnType PlanarIntersectorP0P0<MyMeshType,MyMatrix,ConcreteP0P0Intersector>::getNumberOfColsOfResMatrix() const
   {
     return PlanarIntersector<MyMeshType,MyMatrix>::_meshS.getNumberOfElements();
   }
@@ -47,12 +47,12 @@ namespace INTERP_KERNEL
   template<class MyMeshType, class MyMatrix, class ConcreteP0P0Intersector>
   void PlanarIntersectorP0P0<MyMeshType,MyMatrix,ConcreteP0P0Intersector>::intersectCells(ConnType icellT, const std::vector<ConnType>& icellsS, MyMatrix& res)
   {
-    int nbNodesT=PlanarIntersector<MyMeshType,MyMatrix>::_connIndexT[icellT+1]-PlanarIntersector<MyMeshType,MyMatrix>::_connIndexT[icellT];
+    ConnType nbNodesT=PlanarIntersector<MyMeshType,MyMatrix>::_connIndexT[icellT+1]-PlanarIntersector<MyMeshType,MyMatrix>::_connIndexT[icellT];
     typename MyMatrix::value_type& resRow=res[icellT];
     for(typename std::vector<ConnType>::const_iterator iter=icellsS.begin();iter!=icellsS.end();iter++)
       {
-        int iS=*iter;
-        int nbNodesS=PlanarIntersector<MyMeshType,MyMatrix>::_connIndexS[iS+1]-PlanarIntersector<MyMeshType,MyMatrix>::_connIndexS[iS];
+        ConnType iS=*iter;
+        ConnType nbNodesS=PlanarIntersector<MyMeshType,MyMatrix>::_connIndexS[iS+1]-PlanarIntersector<MyMeshType,MyMatrix>::_connIndexS[iS];
         double surf=intersectGeometry(OTT<ConnType,numPol>::indFC(icellT),OTT<ConnType,numPol>::indFC(iS),nbNodesT,nbNodesS);
         surf=PlanarIntersector<MyMeshType,MyMatrix>::getValueRegardingOption(surf);
         if(surf!=0.)

diff --git a/src/INTERP_KERNEL/PlanarIntersectorP0P1.hxx b/src/INTERP_KERNEL/PlanarIntersectorP0P1.hxx
index f05225b94c4fa4bcaba5ed54fca0022b031a4e3e..2095c2ce63651e85e818572180cb9d24c89e67a0 100644 (file)
--- a/src/INTERP_KERNEL/PlanarIntersectorP0P1.hxx
+++ b/src/INTERP_KERNEL/PlanarIntersectorP0P1.hxx
@@ -38,8 +38,8 @@ namespace INTERP_KERNEL
     PlanarIntersectorP0P1(const MyMeshType& meshT, const MyMeshType& meshS, double dimCaracteristic, double precision, double md3DSurf, double minDot3DSurf, double medianPlane, bool doRotate, int orientation, int printLevel);
   public:
     void intersectCells(ConnType icellT, const std::vector<ConnType>& icellsS, MyMatrix& res);
-    int getNumberOfRowsOfResMatrix() const;
-    int getNumberOfColsOfResMatrix() const;
+    ConnType getNumberOfRowsOfResMatrix() const;
+    ConnType getNumberOfColsOfResMatrix() const;
     /*!
      * Contrary to intersectCells method here icellS and icellT are \b not in \b C mode but in mode of MyMeshType.
      */

diff --git a/src/INTERP_KERNEL/PlanarIntersectorP0P1.txx b/src/INTERP_KERNEL/PlanarIntersectorP0P1.txx
index e5a60d431e0c805d9484f030114f0cc19f97f21e..25a38bb9a4697606f459e5de5fbc108e8f56aae5 100644 (file)
--- a/src/INTERP_KERNEL/PlanarIntersectorP0P1.txx
+++ b/src/INTERP_KERNEL/PlanarIntersectorP0P1.txx
@@ -35,13 +35,13 @@ namespace INTERP_KERNEL
   }
 
   template<class MyMeshType, class MyMatrix, class ConcreteP0P1Intersector>
-  int PlanarIntersectorP0P1<MyMeshType,MyMatrix,ConcreteP0P1Intersector>::getNumberOfRowsOfResMatrix() const
+  typename MyMeshType::MyConnType PlanarIntersectorP0P1<MyMeshType,MyMatrix,ConcreteP0P1Intersector>::getNumberOfRowsOfResMatrix() const
   {
     return PlanarIntersector<MyMeshType,MyMatrix>::_meshT.getNumberOfNodes();
   }
 
   template<class MyMeshType, class MyMatrix, class ConcreteP0P1Intersector>
-  int PlanarIntersectorP0P1<MyMeshType,MyMatrix,ConcreteP0P1Intersector>::getNumberOfColsOfResMatrix() const
+  typename MyMeshType::MyConnType PlanarIntersectorP0P1<MyMeshType,MyMatrix,ConcreteP0P1Intersector>::getNumberOfColsOfResMatrix() const
   {
     return PlanarIntersector<MyMeshType,MyMatrix>::_meshS.getNumberOfElements();
   }
@@ -52,13 +52,13 @@ namespace INTERP_KERNEL
   template<class MyMeshType, class MyMatrix, class ConcreteP0P1Intersector>
   void PlanarIntersectorP0P1<MyMeshType,MyMatrix,ConcreteP0P1Intersector>::intersectCells(ConnType icellT, const std::vector<ConnType>& icellsS, MyMatrix& res)
   {
-    int nbNodesT=PlanarIntersector<MyMeshType,MyMatrix>::_connIndexT[icellT+1]-PlanarIntersector<MyMeshType,MyMatrix>::_connIndexT[icellT];
+    ConnType nbNodesT=PlanarIntersector<MyMeshType,MyMatrix>::_connIndexT[icellT+1]-PlanarIntersector<MyMeshType,MyMatrix>::_connIndexT[icellT];
     double triangle[9];
     double quadrangle[12];
     std::vector<double> sourceCellCoords;
     int orientation=1;
     const ConnType *startOfCellNodeConn=PlanarIntersector<MyMeshType,MyMatrix>::_connectT+OTT<ConnType,numPol>::conn2C(PlanarIntersector<MyMeshType,MyMatrix>::_connIndexT[icellT]);
-    for(int nodeIdT=0;nodeIdT<nbNodesT;nodeIdT++)
+    for(ConnType nodeIdT=0;nodeIdT<nbNodesT;nodeIdT++)
       {
         ConnType curNodeTInCmode=OTT<ConnType,numPol>::coo2C(startOfCellNodeConn[nodeIdT]);
         std::copy(PlanarIntersector<MyMeshType,MyMatrix>::_coordsT+curNodeTInCmode*SPACEDIM,
@@ -66,9 +66,9 @@ namespace INTERP_KERNEL
         typename MyMatrix::value_type& resRow=res[curNodeTInCmode];
         for(typename std::vector<ConnType>::const_iterator iter=icellsS.begin();iter!=icellsS.end();iter++)
           {
-            int iS=*iter;
+            ConnType iS=*iter;
             PlanarIntersector<MyMeshType,MyMatrix>::getRealSourceCoordinates(OTT<ConnType,numPol>::indFC(iS),sourceCellCoords);
-            for(int subTriT=1;subTriT<=nbNodesT-2;subTriT++)
+            for(ConnType subTriT=1;subTriT<=nbNodesT-2;subTriT++)
               {
                 std::copy(PlanarIntersector<MyMeshType,MyMatrix>::_coordsT+OTT<ConnType,numPol>::coo2C(startOfCellNodeConn[(nodeIdT+subTriT)%nbNodesT])*SPACEDIM,
                           PlanarIntersector<MyMeshType,MyMatrix>::_coordsT+OTT<ConnType,numPol>::coo2C(startOfCellNodeConn[(nodeIdT+subTriT)%nbNodesT])*SPACEDIM+SPACEDIM,

diff --git a/src/INTERP_KERNEL/PlanarIntersectorP0P1Bary.hxx b/src/INTERP_KERNEL/PlanarIntersectorP0P1Bary.hxx
index 14a0ce60bd55608c42544f28cb91672e007943ad..214cb98ffbbf9a3683256b358c97b349368951d2 100644 (file)
--- a/src/INTERP_KERNEL/PlanarIntersectorP0P1Bary.hxx
+++ b/src/INTERP_KERNEL/PlanarIntersectorP0P1Bary.hxx
@@ -37,8 +37,8 @@ namespace INTERP_KERNEL
     PlanarIntersectorP0P1Bary(const MyMeshType& meshT, const MyMeshType& meshS, double dimCaracteristic, double precision, double md3DSurf, double minDot3DSurf, double medianPlane, bool doRotate, int orientation, int printLevel);
   public:
     void intersectCells(ConnType icellT, const std::vector<ConnType>& icellsS, MyMatrix& res);
-    int getNumberOfRowsOfResMatrix() const;
-    int getNumberOfColsOfResMatrix() const;
+    ConnType getNumberOfRowsOfResMatrix() const;
+    ConnType getNumberOfColsOfResMatrix() const;
     /*!
      * Contrary to intersectCells method here icellS and icellT are \b not in \b C mode but in mode of MyMeshType.
      */

diff --git a/src/INTERP_KERNEL/PlanarIntersectorP0P1Bary.txx b/src/INTERP_KERNEL/PlanarIntersectorP0P1Bary.txx
index b7c8ab25fdc717c67c362ea93028b44cf5cb40fc..63d735fffe33b439c3a617c5f23324f50fbfa772 100755 (executable)
--- a/src/INTERP_KERNEL/PlanarIntersectorP0P1Bary.txx
+++ b/src/INTERP_KERNEL/PlanarIntersectorP0P1Bary.txx
@@ -49,13 +49,13 @@ namespace INTERP_KERNEL
   }
 
   template<class MyMeshType, class MyMatrix, class ConcreteP0P1Intersector>
-  int PlanarIntersectorP0P1Bary<MyMeshType,MyMatrix,ConcreteP0P1Intersector>::getNumberOfRowsOfResMatrix() const
+  typename MyMeshType::MyConnType PlanarIntersectorP0P1Bary<MyMeshType,MyMatrix,ConcreteP0P1Intersector>::getNumberOfRowsOfResMatrix() const
   {
     return PlanarIntersector<MyMeshType,MyMatrix>::_meshT.getNumberOfNodes();
   }
 
   template<class MyMeshType, class MyMatrix, class ConcreteP0P1Intersector>
-  int PlanarIntersectorP0P1Bary<MyMeshType,MyMatrix,ConcreteP0P1Intersector>::getNumberOfColsOfResMatrix() const
+  typename MyMeshType::MyConnType PlanarIntersectorP0P1Bary<MyMeshType,MyMatrix,ConcreteP0P1Intersector>::getNumberOfColsOfResMatrix() const
   {
     return PlanarIntersector<MyMeshType,MyMatrix>::_meshS.getNumberOfElements();
   }
@@ -76,12 +76,12 @@ namespace INTERP_KERNEL
     for(typename std::vector<ConnType>::const_iterator iter=icellsS.begin();iter!=icellsS.end();iter++)
     {
       std::vector<double> srcCellCoords,srcCellCoordsTmp,nodeCeffs;
-      int iS=*iter;
+      ConnType iS=*iter;
       NormalizedCellType tS=PlanarIntersector<MyMeshType,MyMatrix>::_meshS.getTypeOfElement(OTT<ConnType,numPol>::indFC(iS));
       bool isSourceQuad=CellModel::GetCellModel(tS).isQuadratic();
       PlanarIntersector<MyMeshType,MyMatrix>::getRealSourceCoordinates(OTT<ConnType,numPol>::indFC(iS),srcCellCoords);
       std::vector<double> *srcCoords(&srcCellCoords);
-      int srcNbNodes = ToConnType(srcCellCoords.size())/SPACEDIM;
+      ConnType srcNbNodes = ToConnType(srcCellCoords.size())/SPACEDIM;
       if(SPACEDIM==3)
         {
           srcCellCoordsTmp=srcCellCoords;

diff --git a/src/INTERP_KERNEL/PlanarIntersectorP0P1PL.hxx b/src/INTERP_KERNEL/PlanarIntersectorP0P1PL.hxx
index c0b91f5d7a0a17c866235d1542354dcd54febed1..790982344236469e9392978ade13146bad6ebd5f 100644 (file)
--- a/src/INTERP_KERNEL/PlanarIntersectorP0P1PL.hxx
+++ b/src/INTERP_KERNEL/PlanarIntersectorP0P1PL.hxx
@@ -36,8 +36,8 @@ namespace INTERP_KERNEL
   public:
     PlanarIntersectorP0P1PL(const MyMeshType& meshT, const MyMeshType& meshS, double dimCaracteristic, double md3DSurf, double minDot3DSurf, double medianPlane, double precision, int orientation);
     void intersectCells(ConnType icellT, const std::vector<ConnType>& icellsS, MyMatrix& res);
-    int getNumberOfRowsOfResMatrix() const;
-    int getNumberOfColsOfResMatrix() const;
+    ConnType getNumberOfRowsOfResMatrix() const;
+    ConnType getNumberOfColsOfResMatrix() const;
   };
 }
 

diff --git a/src/INTERP_KERNEL/PlanarIntersectorP0P1PL.txx b/src/INTERP_KERNEL/PlanarIntersectorP0P1PL.txx
index 9495980232f34f80c43db1355da33adc064c0c2d..25de970a8a2d484d9a6580f342bd28e572c0f380 100644 (file)
--- a/src/INTERP_KERNEL/PlanarIntersectorP0P1PL.txx
+++ b/src/INTERP_KERNEL/PlanarIntersectorP0P1PL.txx
@@ -46,7 +46,7 @@ namespace INTERP_KERNEL
     const ConnType *startOfCellNodeConnT=PlanarIntersector<MyMeshType,MyMatrix>::_connectT+OTT<ConnType,numPol>::conn2C(PlanarIntersector<MyMeshType,MyMatrix>::_connIndexT[icellT]);
     std::vector<double> coordsTarget;
     PlanarIntersector<MyMeshType,MyMatrix>::getRealTargetCoordinates(OTT<ConnType,numPol>::indFC(icellT),coordsTarget);
-    int nbNodesT=ToConnType(coordsTarget.size())/SPACEDIM;
+    ConnType nbNodesT=ToConnType(coordsTarget.size())/SPACEDIM;
     ii=0;
     for(typename std::vector<ConnType>::const_iterator iter2=icellsS.begin();iter2!=icellsS.end();iter2++,ii++)
       {
@@ -54,7 +54,7 @@ namespace INTERP_KERNEL
         std::vector<double> tmpTarget(coordsTarget);
         if(SPACEDIM==3)
           PlanarIntersector<MyMeshType,MyMatrix>::projectionThis(&tmpSource[0],&tmpTarget[0],ToConnType(tmpSource.size())/SPACEDIM,nbNodesT);
-        for(int nodeIdT=0;nodeIdT<nbNodesT;nodeIdT++)
+        for(ConnType nodeIdT=0;nodeIdT<nbNodesT;nodeIdT++)
           {
             if(PointLocatorAlgos<MyMeshType>::isElementContainsPointAlg2D(&tmpTarget[0]+nodeIdT*SPACEDIM,&tmpSource[0],ToConnType(tmpSource.size())/SPACEDIM,PlanarIntersector<MyMeshType,MyMatrix>::_precision))
               {
@@ -69,13 +69,13 @@ namespace INTERP_KERNEL
   }
 
   template<class MyMeshType, class MyMatrix>
-  int PlanarIntersectorP0P1PL<MyMeshType,MyMatrix>::getNumberOfRowsOfResMatrix() const
+  typename MyMeshType::MyConnType PlanarIntersectorP0P1PL<MyMeshType,MyMatrix>::getNumberOfRowsOfResMatrix() const
   {
     return PlanarIntersector<MyMeshType,MyMatrix>::_meshT.getNumberOfNodes();
   }
   
   template<class MyMeshType, class MyMatrix>
-  int PlanarIntersectorP0P1PL<MyMeshType,MyMatrix>::getNumberOfColsOfResMatrix() const
+  typename MyMeshType::MyConnType PlanarIntersectorP0P1PL<MyMeshType,MyMatrix>::getNumberOfColsOfResMatrix() const
   {
     return PlanarIntersector<MyMeshType,MyMatrix>::_meshS.getNumberOfElements();
   }

diff --git a/src/INTERP_KERNEL/PlanarIntersectorP1P0.hxx b/src/INTERP_KERNEL/PlanarIntersectorP1P0.hxx
index cbc7f716334a1d30c81eb0be5b74d8050a7823b0..94630f70995256d1c9de52f0d1506c7d75aa8112 100644 (file)
--- a/src/INTERP_KERNEL/PlanarIntersectorP1P0.hxx
+++ b/src/INTERP_KERNEL/PlanarIntersectorP1P0.hxx
@@ -37,8 +37,8 @@ namespace INTERP_KERNEL
     PlanarIntersectorP1P0(const MyMeshType& meshT, const MyMeshType& meshS, double dimCaracteristic, double precision, double md3DSurf, double minDot3DSurf, double medianPlane, bool doRotate, int orientation, int printLevel);
   public:
     void intersectCells(ConnType icellT, const std::vector<ConnType>& icellsS, MyMatrix& res);
-    int getNumberOfRowsOfResMatrix() const;
-    int getNumberOfColsOfResMatrix() const;
+    ConnType getNumberOfRowsOfResMatrix() const;
+    ConnType getNumberOfColsOfResMatrix() const;
     /*!
      * Contrary to intersectCells method here icellS and icellT are \b not in \b C mode but in mode of MyMeshType.
      */

diff --git a/src/INTERP_KERNEL/PlanarIntersectorP1P0.txx b/src/INTERP_KERNEL/PlanarIntersectorP1P0.txx
index 8db87d35293c2417fc53768da55c47446b788a50..f10ea00b634d41404df094ceea8e23dda1a69041 100644 (file)
--- a/src/INTERP_KERNEL/PlanarIntersectorP1P0.txx
+++ b/src/INTERP_KERNEL/PlanarIntersectorP1P0.txx
@@ -34,13 +34,13 @@ namespace INTERP_KERNEL
   }
 
   template<class MyMeshType, class MyMatrix, class ConcreteP1P0Intersector>
-  int PlanarIntersectorP1P0<MyMeshType,MyMatrix,ConcreteP1P0Intersector>::getNumberOfRowsOfResMatrix() const
+  typename MyMeshType::MyConnType PlanarIntersectorP1P0<MyMeshType,MyMatrix,ConcreteP1P0Intersector>::getNumberOfRowsOfResMatrix() const
   {
     return PlanarIntersector<MyMeshType,MyMatrix>::_meshT.getNumberOfElements();
   }
 
   template<class MyMeshType, class MyMatrix, class ConcreteP1P0Intersector>
-  int PlanarIntersectorP1P0<MyMeshType,MyMatrix,ConcreteP1P0Intersector>::getNumberOfColsOfResMatrix() const
+  typename MyMeshType::MyConnType PlanarIntersectorP1P0<MyMeshType,MyMatrix,ConcreteP1P0Intersector>::getNumberOfColsOfResMatrix() const
   {
     return PlanarIntersector<MyMeshType,MyMatrix>::_meshS.getNumberOfNodes();
   }
@@ -61,7 +61,7 @@ namespace INTERP_KERNEL
     typename MyMatrix::value_type& resRow=res[icellT];
     for(typename std::vector<ConnType>::const_iterator iter=icellsS.begin();iter!=icellsS.end();iter++)
       {
-        int iS=*iter;
+        ConnType iS=*iter;
         int nbNodesS=PlanarIntersector<MyMeshType,MyMatrix>::_connIndexS[iS+1]-PlanarIntersector<MyMeshType,MyMatrix>::_connIndexS[iS];
         const ConnType *startOfCellNodeConn=PlanarIntersector<MyMeshType,MyMatrix>::_connectS+OTT<ConnType,numPol>::conn2C(PlanarIntersector<MyMeshType,MyMatrix>::_connIndexS[iS]);
         for(int nodeIdS=0;nodeIdS<nbNodesS;nodeIdS++)

diff --git a/src/INTERP_KERNEL/PlanarIntersectorP1P0Bary.hxx b/src/INTERP_KERNEL/PlanarIntersectorP1P0Bary.hxx
index 60a3f7af68e29df31c4ee0a7b20de6d16aa14451..25d149d426344cf2b804ec46c388a09f1b779553 100644 (file)
--- a/src/INTERP_KERNEL/PlanarIntersectorP1P0Bary.hxx
+++ b/src/INTERP_KERNEL/PlanarIntersectorP1P0Bary.hxx
@@ -37,8 +37,8 @@ namespace INTERP_KERNEL
     PlanarIntersectorP1P0Bary(const MyMeshType& meshT, const MyMeshType& meshS, double dimCaracteristic, double precision, double md3DSurf, double minDot3DSurf, double medianPlane, bool doRotate, int orientation, int printLevel);
   public:
     void intersectCells(ConnType icellT, const std::vector<ConnType>& icellsS, MyMatrix& res);
-    int getNumberOfRowsOfResMatrix() const;
-    int getNumberOfColsOfResMatrix() const;
+    ConnType getNumberOfRowsOfResMatrix() const;
+    ConnType getNumberOfColsOfResMatrix() const;
     /*!
      * Contrary to intersectCells method here icellS and icellT are \b not in \b C mode but in mode of MyMeshType.
      */

diff --git a/src/INTERP_KERNEL/PlanarIntersectorP1P0Bary.txx b/src/INTERP_KERNEL/PlanarIntersectorP1P0Bary.txx
index 009079a52da2dd24586cf4f33f96f19b1cd6567d..442177dd47a23cdabda83475db74040fa7a24843 100755 (executable)
--- a/src/INTERP_KERNEL/PlanarIntersectorP1P0Bary.txx
+++ b/src/INTERP_KERNEL/PlanarIntersectorP1P0Bary.txx
@@ -51,13 +51,13 @@ namespace INTERP_KERNEL
   }
 
   PLAN_INTER_TEMPLATE
-  int PLAN_INTERSECTOR::getNumberOfRowsOfResMatrix() const
+  typename MyMeshType::MyConnType PLAN_INTERSECTOR::getNumberOfRowsOfResMatrix() const
   {
     return PlanarIntersector<MyMeshType,MyMatrix>::_meshT.getNumberOfElements();
   }
 
   PLAN_INTER_TEMPLATE
-  int PLAN_INTERSECTOR::getNumberOfColsOfResMatrix() const
+  typename MyMeshType::MyConnType PLAN_INTERSECTOR::getNumberOfColsOfResMatrix() const
   {
     return PlanarIntersector<MyMeshType,MyMatrix>::_meshS.getNumberOfNodes();
   }
@@ -76,7 +76,7 @@ namespace INTERP_KERNEL
     // target cell data
     PlanarIntersector<MyMeshType,MyMatrix>::getRealTargetCoordinates(OTT<ConnType,numPol>::indFC(icellT),tgtCellCoords);
     std::vector<double> * tgtCoords = & tgtCellCoords;
-    int tgtNbNodes = ToConnType(tgtCellCoords.size())/SPACEDIM;
+    ConnType tgtNbNodes = ToConnType(tgtCellCoords.size())/SPACEDIM;
     NormalizedCellType tT=PlanarIntersector<MyMeshType,MyMatrix>::_meshT.getTypeOfElement(OTT<ConnType,numPol>::indFC(icellT));
     bool isTargetQuad=CellModel::GetCellModel(tT).isQuadratic();
 
@@ -85,7 +85,7 @@ namespace INTERP_KERNEL
     // treat each source triangle
     for(typename std::vector<ConnType>::const_iterator iter=icellsS.begin();iter!=icellsS.end();iter++)
     {
-      int iS=*iter;
+      ConnType iS=*iter;
       PlanarIntersector<MyMeshType,MyMatrix>::getRealSourceCoordinates(OTT<ConnType,numPol>::indFC(iS),srcTriaCoords);
       const ConnType *startOfCellNodeConn=PlanarIntersector<MyMeshType,MyMatrix>::_connectS+OTT<ConnType,numPol>::conn2C(PlanarIntersector<MyMeshType,MyMatrix>::_connIndexS[iS]);
       if(SPACEDIM==3)

diff --git a/src/INTERP_KERNEL/PlanarIntersectorP1P0PL.hxx b/src/INTERP_KERNEL/PlanarIntersectorP1P0PL.hxx
index 8a14b069d838a1fd4cc21199002248251741dd08..a01a10026788b8f0d5e30e78a2c15ee47b12ce92 100644 (file)
--- a/src/INTERP_KERNEL/PlanarIntersectorP1P0PL.hxx
+++ b/src/INTERP_KERNEL/PlanarIntersectorP1P0PL.hxx
@@ -36,8 +36,8 @@ namespace INTERP_KERNEL
   public:
     PlanarIntersectorP1P0PL(const MyMeshType& meshT, const MyMeshType& meshS, double dimCaracteristic, double md3DSurf, double minDot3DSurf, double medianPlane, double precision, int orientation);
     void intersectCells(ConnType icellT, const std::vector<ConnType>& icellsS, MyMatrix& res);
-    int getNumberOfRowsOfResMatrix() const;
-    int getNumberOfColsOfResMatrix() const;
+    ConnType getNumberOfRowsOfResMatrix() const;
+    ConnType getNumberOfColsOfResMatrix() const;
   };
 }
 

diff --git a/src/INTERP_KERNEL/PlanarIntersectorP1P0PL.txx b/src/INTERP_KERNEL/PlanarIntersectorP1P0PL.txx
index 1fb758943ba54fcd50b954f816424e9fb4e00a5e..6cf35469bf0eee8128a21cabaa2c7e66baf7e8e7 100644 (file)
--- a/src/INTERP_KERNEL/PlanarIntersectorP1P0PL.txx
+++ b/src/INTERP_KERNEL/PlanarIntersectorP1P0PL.txx
@@ -93,13 +93,13 @@ namespace INTERP_KERNEL
   }
 
   template<class MyMeshType, class MyMatrix>
-  int PlanarIntersectorP1P0PL<MyMeshType,MyMatrix>::getNumberOfRowsOfResMatrix() const
+  typename MyMeshType::MyConnType PlanarIntersectorP1P0PL<MyMeshType,MyMatrix>::getNumberOfRowsOfResMatrix() const
   {
     return PlanarIntersector<MyMeshType,MyMatrix>::_meshT.getNumberOfElements();
   }
   
   template<class MyMeshType, class MyMatrix>
-  int PlanarIntersectorP1P0PL<MyMeshType,MyMatrix>::getNumberOfColsOfResMatrix() const
+  typename MyMeshType::MyConnType PlanarIntersectorP1P0PL<MyMeshType,MyMatrix>::getNumberOfColsOfResMatrix() const
   {
     return PlanarIntersector<MyMeshType,MyMatrix>::_meshS.getNumberOfNodes();
   }

diff --git a/src/INTERP_KERNEL/PlanarIntersectorP1P1.hxx b/src/INTERP_KERNEL/PlanarIntersectorP1P1.hxx
index b4873ffd0b9de65778fa54fd96e46fa22991854b..4307715222a2e94c856cea187700d594ba223193 100644 (file)
--- a/src/INTERP_KERNEL/PlanarIntersectorP1P1.hxx
+++ b/src/INTERP_KERNEL/PlanarIntersectorP1P1.hxx
@@ -37,8 +37,8 @@ namespace INTERP_KERNEL
     PlanarIntersectorP1P1(const MyMeshType& meshT, const MyMeshType& meshS, double dimCaracteristic, double precision, double md3DSurf, double minDot3DSurf, double medianPlane, bool doRotate, int orientation, int printLevel);
   public:
     void intersectCells(ConnType icellT, const std::vector<ConnType>& icellsS, MyMatrix& res);
-    int getNumberOfRowsOfResMatrix() const;
-    int getNumberOfColsOfResMatrix() const;
+    ConnType getNumberOfRowsOfResMatrix() const;
+    ConnType getNumberOfColsOfResMatrix() const;
 
     double intersectGeometryGeneral(const std::vector<double>& targetCoords, const std::vector<double>& sourceCoords) { return asLeaf().intersectGeometryGeneral(targetCoords,sourceCoords); }
   protected:

diff --git a/src/INTERP_KERNEL/PlanarIntersectorP1P1.txx b/src/INTERP_KERNEL/PlanarIntersectorP1P1.txx
index 3834fcaf4bb65d4b7bc1c46e11e7e07e464f7c7e..32cd8e6f09c3f80eada15140691219a60e9de808 100644 (file)
--- a/src/INTERP_KERNEL/PlanarIntersectorP1P1.txx
+++ b/src/INTERP_KERNEL/PlanarIntersectorP1P1.txx
@@ -35,13 +35,13 @@ namespace INTERP_KERNEL
   }
 
   template<class MyMeshType, class MyMatrix, class ConcreteP1P1Intersector>
-  int PlanarIntersectorP1P1<MyMeshType,MyMatrix,ConcreteP1P1Intersector>::getNumberOfRowsOfResMatrix() const
+  typename MyMeshType::MyConnType PlanarIntersectorP1P1<MyMeshType,MyMatrix,ConcreteP1P1Intersector>::getNumberOfRowsOfResMatrix() const
   {
     return PlanarIntersector<MyMeshType,MyMatrix>::_meshT.getNumberOfNodes();
   }
 
   template<class MyMeshType, class MyMatrix, class ConcreteP1P1Intersector>
-  int PlanarIntersectorP1P1<MyMeshType,MyMatrix,ConcreteP1P1Intersector>::getNumberOfColsOfResMatrix() const
+  typename MyMeshType::MyConnType PlanarIntersectorP1P1<MyMeshType,MyMatrix,ConcreteP1P1Intersector>::getNumberOfColsOfResMatrix() const
   {
     return PlanarIntersector<MyMeshType,MyMatrix>::_meshS.getNumberOfNodes();
   }
@@ -66,7 +66,7 @@ namespace INTERP_KERNEL
         typename MyMatrix::value_type& resRow=res[curNodeTInCmode];
         for(typename std::vector<ConnType>::const_iterator iter=icellsS.begin();iter!=icellsS.end();iter++)
           {
-            int iS=*iter;
+            ConnType iS=*iter;
             int nbNodesS=PlanarIntersector<MyMeshType,MyMatrix>::_connIndexS[iS+1]-PlanarIntersector<MyMeshType,MyMatrix>::_connIndexS[iS];
             const ConnType *startOfCellNodeConnS=PlanarIntersector<MyMeshType,MyMatrix>::_connectS+OTT<ConnType,numPol>::conn2C(PlanarIntersector<MyMeshType,MyMatrix>::_connIndexS[iS]);
             for(int nodeIdS=0;nodeIdS<nbNodesS;nodeIdS++)

diff --git a/src/INTERP_KERNEL/PlanarIntersectorP1P1PL.hxx b/src/INTERP_KERNEL/PlanarIntersectorP1P1PL.hxx
index e85c337d897e494a9b8bd9f610d7de8bd40017b0..724d7433bc53f68512cdddaa1913ccd76716d80f 100644 (file)
--- a/src/INTERP_KERNEL/PlanarIntersectorP1P1PL.hxx
+++ b/src/INTERP_KERNEL/PlanarIntersectorP1P1PL.hxx
@@ -36,8 +36,8 @@ namespace INTERP_KERNEL
   public:
     PlanarIntersectorP1P1PL(const MyMeshType& meshT, const MyMeshType& meshS, double dimCaracteristic, double md3DSurf, double minDot3DSurf, double medianPlane, double precision, int orientation);
     void intersectCells(ConnType icellT, const std::vector<ConnType>& icellsS, MyMatrix& res);
-    int getNumberOfRowsOfResMatrix() const;
-    int getNumberOfColsOfResMatrix() const;
+    ConnType getNumberOfRowsOfResMatrix() const;
+    ConnType getNumberOfColsOfResMatrix() const;
   };
 }
 

diff --git a/src/INTERP_KERNEL/PlanarIntersectorP1P1PL.txx b/src/INTERP_KERNEL/PlanarIntersectorP1P1PL.txx
index 557538e5c38541d5f58fc910e8f6768d66c0061c..ed82199f6dfa29f984c787b6735b05a370f65bb7 100644 (file)
--- a/src/INTERP_KERNEL/PlanarIntersectorP1P1PL.txx
+++ b/src/INTERP_KERNEL/PlanarIntersectorP1P1PL.txx
@@ -42,7 +42,7 @@ namespace INTERP_KERNEL
   {
     std::vector<double> CoordsT;
     PlanarIntersector<MyMeshType,MyMatrix>::getRealTargetCoordinates(OTT<ConnType,numPol>::indFC(icellT),CoordsT);
-    int nbOfNodesT=ToConnType(CoordsT.size())/SPACEDIM;
+    ConnType nbOfNodesT=ToConnType(CoordsT.size())/SPACEDIM;
     for(typename std::vector<ConnType>::const_iterator iter=icellsS.begin();iter!=icellsS.end();iter++)
       {
         NormalizedCellType tS=PlanarIntersector<MyMeshType,MyMatrix>::_meshS.getTypeOfElement(OTT<ConnType,numPol>::indFC(*iter));
@@ -84,13 +84,13 @@ namespace INTERP_KERNEL
   }
 
   template<class MyMeshType, class MyMatrix>
-  int PlanarIntersectorP1P1PL<MyMeshType,MyMatrix>::getNumberOfRowsOfResMatrix() const
+  typename MyMeshType::MyConnType PlanarIntersectorP1P1PL<MyMeshType,MyMatrix>::getNumberOfRowsOfResMatrix() const
   {
     return PlanarIntersector<MyMeshType,MyMatrix>::_meshT.getNumberOfNodes();
   }
   
   template<class MyMeshType, class MyMatrix>
-  int PlanarIntersectorP1P1PL<MyMeshType,MyMatrix>::getNumberOfColsOfResMatrix() const
+  typename MyMeshType::MyConnType PlanarIntersectorP1P1PL<MyMeshType,MyMatrix>::getNumberOfColsOfResMatrix() const
   {
     return PlanarIntersector<MyMeshType,MyMatrix>::_meshS.getNumberOfNodes();
   }

diff --git a/src/INTERP_KERNEL/Polyhedron3D2DIntersectorP0P0.txx b/src/INTERP_KERNEL/Polyhedron3D2DIntersectorP0P0.txx
index ecc0ddb8da8ceb60d5b24d3ade0056ec5fe67f6d..57d42e9d9019c76ffaae4649f524f46feedbb540 100644 (file)
--- a/src/INTERP_KERNEL/Polyhedron3D2DIntersectorP0P0.txx
+++ b/src/INTERP_KERNEL/Polyhedron3D2DIntersectorP0P0.txx
@@ -104,13 +104,13 @@ namespace INTERP_KERNEL
         const CellModel& cellModelCell=CellModel::GetCellModel(normCellType);
         const MyMeshType& src_mesh = Intersector3D<MyMeshType,MyMatrixType>::_src_mesh;
         unsigned nbOfNodes4Type=cellModelCell.isDynamic() ? src_mesh.getNumberOfNodesOfElement(cellSrcIdx) : cellModelCell.getNumberOfNodes();
-        int *polyNodes=new int[nbOfNodes4Type];
+        mcIdType *polyNodes=new mcIdType[nbOfNodes4Type];
         double **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
-            const int globalNodeNum = getGlobalNumberOfNode(i, OTT<ConnType,numPol>::indFC(*iterCellS), src_mesh);
-            polyNodes[i] = globalNodeNum;
+            const ConnType globalNodeNum = getGlobalNumberOfNode(i, OTT<ConnType,numPol>::indFC(*iterCellS), src_mesh);
+            polyNodes[i] = ToIdType( globalNodeNum );
             polyCoords[i] = const_cast<double*>(src_mesh.getCoordinatesPtr()+MyMeshType::MY_SPACEDIM*globalNodeNum);
           }
 

diff --git a/src/INTERP_KERNEL/VolSurfFormulae.hxx b/src/INTERP_KERNEL/VolSurfFormulae.hxx
index f7269bfcf5d414e9c056685f7689318f501e68d1..da543be2fb0051fad950585ee1097cca67d631a2 100644 (file)
--- a/src/INTERP_KERNEL/VolSurfFormulae.hxx
+++ b/src/INTERP_KERNEL/VolSurfFormulae.hxx
@@ -469,10 +469,10 @@ namespace INTERP_KERNEL
   {
     std::size_t nbOfFaces=std::count(connec,connec+lgth,-1)+1;
     double volume=0.;
-    const int *work=connec;
+    const ConnType *work=connec;
     for(std::size_t iFace=0;iFace<nbOfFaces;iFace++)
       {
-        const int *work2=std::find(work+1,connec+lgth,-1);
+        const ConnType *work2=std::find(work+1,connec+lgth,-1);
         std::size_t nbOfNodesOfCurFace=std::distance(work,work2);
         double areaVector[3]={0.,0.,0.};
         for(std::size_t ptId=0;ptId<nbOfNodesOfCurFace;ptId++)
@@ -592,10 +592,10 @@ namespace INTERP_KERNEL
   {
     std::size_t nbOfFaces=std::count(connec,connec+lgth,-1)+1;
     res[0]=0.; res[1]=0.; res[2]=0.;
-    const int *work=connec;
+    const ConnType *work=connec;
     for(std::size_t i=0;i<nbOfFaces;i++)
       {
-        const int *work2=std::find(work+1,connec+lgth,-1);
+        const ConnType *work2=std::find(work+1,connec+lgth,-1);
         int nbOfNodesOfCurFace=(int)std::distance(work,work2);
         // projection to (u,v) of each faces of polyh to compute integral(x^2/2) on each faces.
         double normal[3];
@@ -660,7 +660,7 @@ namespace INTERP_KERNEL
         work=connec;
         for(std::size_t i=0;i<nbOfFaces;i++)
           {
-            const int *work2=std::find(work+1,connec+lgth,-1);
+            const ConnType *work2=std::find(work+1,connec+lgth,-1);
             int nbOfNodesOfCurFace=(int)std::distance(work,work2);
             double normal[3];
             areaVectorOfPolygon<ConnType,numPol>(work,nbOfNodesOfCurFace,coords,normal);