Ticket #60349: patch-cgnslib-4.1.1.diff

ParaViewCore/VTKExtensions/CGNSReader/cgio_helpers.cxx

@@ -44 +44 @@
 
   data.resize(size);
   // read data
-  if (cgio_read_all_data(cgioNum, nodeId, (void*)data.c_str()) != CG_OK)
+  if (cgio_read_all_data_type(cgioNum, nodeId, "C1", (void*)data.c_str()) != CG_OK)
   {
     return 1;
   }
@@ -80 +80 @@
   data.resize(size + 1);
 
   // read data
-  if (cgio_read_all_data(cgioNum, nodeId, &data[0]) != CG_OK)
+  if (cgio_read_all_data_type(cgioNum, nodeId, "C1", &data[0]) != CG_OK)
   {
     return 1;
   }
@@ -167 +167 @@
 int readBaseCoreInfo(int cgioNum, double baseId, CGNSRead::BaseInformation& baseInfo)
 {
   CGNSRead::char_33 dataType;
-  std::vector<int> mdata;
+  std::vector<int32_t> mdata;
 
   if (cgio_get_name(cgioNum, baseId, baseInfo.name) != CG_OK)
   {
@@ -187 +187 @@
     return 1;
   }
 
-  if (CGNSRead::readNodeData<int>(cgioNum, baseId, mdata) != 0)
+  if (CGNSRead::readNodeData<int32_t>(cgioNum, baseId, mdata) != 0)
   {
     std::cerr << "error while reading base dimension" << std::endl;
     return 1;
@@ -209 +209 @@
   bool createTimeStates = true;
   bool createIterStates = true;
 
-  std::vector<int> ndata;
+  std::vector<int32_t> ndata;
   // read node data type
   if (cgio_get_data_type(cgioNum, nodeId, dataType) != CG_OK)
   {
@@ -222 +222 @@
     return 1;
   }
 
-  if (CGNSRead::readNodeData<int>(cgioNum, nodeId, ndata) != 0)
+  if (CGNSRead::readNodeData<int32_t>(cgioNum, nodeId, ndata) != 0)
   {
     std::cerr << "error while reading number of state in base" << std::endl;
     return 1;
@@ -298 +298 @@
       }
 
       baseInfo.steps.clear();
-      CGNSRead::readNodeData<int>(cgioNum, childrenIterative[nc], baseInfo.steps);
+      CGNSRead::readNodeData<int32_t>(cgioNum, childrenIterative[nc], baseInfo.steps);
       if (static_cast<int>(baseInfo.steps.size()) != nstates)
       {
         std::cerr << "Error reading steps node";

ParaViewCore/VTKExtensions/CGNSReader/cgio_helpers.h

@@ -46 +46 @@
   cgsize_t size = 1;
   cgsize_t dimVals[12];
   int ndim;
+  constexpr const char* dtName = CGNSRead::detail::cgns_type_name<T>();
 
   if (cgio_get_dimensions(cgioNum, nodeId, &ndim, dimVals) != CG_OK)
   {
@@ -65 +66 @@
   data.resize(size);
 
   // read data
-  if (cgio_read_all_data(cgioNum, nodeId, &data[0]) != CG_OK)
+  if (cgio_read_all_data_type(cgioNum, nodeId, dtName, &data[0]) != CG_OK)
   {
     return 1;
   }

ParaViewCore/VTKExtensions/CGNSReader/vtkCGNSReader.cxx

@@ -526 +526 @@
 
   return ret;
 }
+//----------------------------------------------------------------------------
+// Small helper
+const char* get_data_type(const CGNS_ENUMT(DataType_t) dt)
+{
+  const char* dataType;
+  switch (dt)
+  {
+    case CGNS_ENUMV(Integer):
+      dataType = "I4";
+      break;
+    case CGNS_ENUMV(LongInteger):
+      dataType = "I8";
+      break;
+    case CGNS_ENUMV(RealSingle):
+      dataType = "R4";
+      break;
+    case CGNS_ENUMV(RealDouble):
+      dataType = "R8";
+      break;
+    case CGNS_ENUMV(Character):
+      dataType = "C1";
+      break;
+    default:
+      dataType = "MT";
+  }
+  return dataType;
+}
 
 //----------------------------------------------------------------------------
 vtkCGNSReader::vtkCGNSReader()
@@ -672 +699 @@
     {
       CGNSRead::char_33 gname;
       const cgsize_t offset = static_cast<cgsize_t>(self->ActualTimeStep * 32);
-      cgio_read_block_data(self->cgioNum, giterId, offset + 1, offset + 32, (void*)gname);
+      cgio_read_block_data_type(
+        self->cgioNum, giterId, offset + 1, offset + 32, "C1", (void*)gname);
       gname[32] = '\0';
       // NOTE: Names or identifiers contain no spaces and capitalization
       //       is used to distinguish individual words making up a name.
@@ -732 +760 @@
         EndsWithPointers(nodeName))
       {
         CGNSRead::char_33 gname;
-        cgio_read_block_data(self->cgioNum, iterChildId[cc],
+        cgio_read_block_data_type(self->cgioNum, iterChildId[cc],
           (cgsize_t)(self->ActualTimeStep * 32 + 1), (cgsize_t)(self->ActualTimeStep * 32 + 32),
-          (void*)gname);
+          "C1", (void*)gname);
         gname[32] = '\0';
         CGNSRead::removeTrailingWhiteSpaces(gname);
         std::string tmpStr = std::string(gname);
@@ -1197 +1225 @@
       continue;
     }
     double cgioVarId = solChildId[ff];
+    const char* fieldDataType = get_data_type(cgnsVars[ff].dt);
 
     // quick transfer of data because data types is given by cgns database
     if (cgnsVars[ff].isComponent == false)
     {
-      if (cgio_read_data(self->cgioNum, cgioVarId, fieldSrcStart, fieldSrcEnd, fieldSrcStride,
-            cellDim, fieldMemDims, fieldMemStart, fieldMemEnd, fieldMemStride,
+      if (cgio_read_data_type(self->cgioNum, cgioVarId, fieldSrcStart, fieldSrcEnd, fieldSrcStride,
+            fieldDataType, cellDim, fieldMemDims, fieldMemStart, fieldMemEnd, fieldMemStride,
             (void*)vtkVars[ff]->GetVoidPointer(0)) != CG_OK)
       {
         char message[81];
         cgio_error_message(message);
-        vtkGenericWarningMacro(<< "cgio_read_data :" << message);
+        vtkGenericWarningMacro(<< "cgio_read_data_type :" << message);
       }
     }
     else
     {
-      if (cgio_read_data(self->cgioNum, cgioVarId, fieldSrcStart, fieldSrcEnd, fieldSrcStride,
-            cellDim, fieldVectMemDims, fieldVectMemStart, fieldVectMemEnd, fieldVectMemStride,
+      if (cgio_read_data_type(self->cgioNum, cgioVarId, fieldSrcStart, fieldSrcEnd, fieldSrcStride,
+            fieldDataType, cellDim, fieldVectMemDims, fieldVectMemStart, fieldVectMemEnd,
+            fieldVectMemStride,
             (void*)vtkVars[ff]->GetVoidPointer(cgnsVars[ff].xyzIndex - 1)) != CG_OK)
       {
         char message[81];
         cgio_error_message(message);
-        vtkGenericWarningMacro(<< "cgio_read_data :" << message);
+        vtkGenericWarningMacro(<< "cgio_read_data_type :" << message);
       }
     }
     cgio_release_id(self->cgioNum, cgioVarId);
@@ -1448 +1478 @@
             continue;
           }
           double cgioVarId = varIds[ff];
+          const char* fieldDataType = get_data_type(cgnsVars[ff].dt);
 
           cgsize_t dataSize = 1;
           cgsize_t dimVals[12];
@@ -1474 +1505 @@
             // quick transfer of data because data types is given by cgns database
             if (cgnsVars[ff].isComponent == false)
             {
-              if (cgio_read_all_data(
-                    self->cgioNum, cgioVarId, (void*)vtkVars[ff]->GetVoidPointer(0)) != CG_OK)
+              if (cgio_read_all_data_type(self->cgioNum, cgioVarId, fieldDataType,
+                    (void*)vtkVars[ff]->GetVoidPointer(0)) != CG_OK)
               {
                 char message[81];
                 cgio_error_message(message);
-                vtkGenericWarningMacro(<< "cgio_read_data :" << message);
+                vtkGenericWarningMacro(<< "cgio_read_all_data_type :" << message);
               }
               if (dataSize == 1)
               {
@@ -1510 +1541 @@
               fieldVectMemDims[0] = fieldSrcEnd[0] * fieldVectMemStride[0];
               fieldVectMemEnd[0] = fieldSrcEnd[0] * fieldVectMemStride[0];
 
-              if (cgio_read_data(self->cgioNum, cgioVarId, fieldSrcStart, fieldSrcEnd,
-                    fieldSrcStride, 1, fieldVectMemDims, fieldVectMemStart, fieldVectMemEnd,
-                    fieldVectMemStride,
+              if (cgio_read_data_type(self->cgioNum, cgioVarId, fieldSrcStart, fieldSrcEnd,
+                    fieldSrcStride, fieldDataType, 1, fieldVectMemDims, fieldVectMemStart,
+                    fieldVectMemEnd, fieldVectMemStride,
                     (void*)vtkVars[ff]->GetVoidPointer(cgnsVars[ff].xyzIndex - 1)) != CG_OK)
               {
                 char message[81];
                 cgio_error_message(message);
-                vtkGenericWarningMacro(<< "cgio_read_data :" << message);
+                vtkGenericWarningMacro(<< "cgio_read_data_type :" << message);
               }
               if (dataSize == 1)
               {
@@ -2231 +2262 @@
 
     //
     CGNSRead::char_33 dataType;
-    std::vector<int> mdata;
+    std::vector<vtkTypeInt32> mdata;
 
     if (cgio_get_name(this->cgioNum, elemIdList[sec], sectionInfoList[sec].name) != CG_OK)
     {
@@ -2246 +2277 @@
       vtkErrorMacro(<< "Unexpected data type for dimension data of Element\n");
     }
 
-    CGNSRead::readNodeData<int>(cgioNum, elemIdList[sec], mdata);
+    CGNSRead::readNodeData<vtkTypeInt32>(cgioNum, elemIdList[sec], mdata);
     if (mdata.size() != 2)
     {
       vtkErrorMacro(<< "Unexpected data for Elements_t node\n");
@@ -2267 +2298 @@
 
     if (strcmp(dataType, "I4") == 0)
     {
-      std::vector<int> mdata2;
-      CGNSRead::readNodeData<int>(this->cgioNum, elemRangeId, mdata2);
+      std::vector<vtkTypeInt32> mdata2;
+      CGNSRead::readNodeData<vtkTypeInt32>(this->cgioNum, elemRangeId, mdata2);
       if (mdata2.size() != 2)
       {
         vtkErrorMacro(<< "Unexpected data for ElementRange node\n");
@@ -2278 +2309 @@
     }
     else if (strcmp(dataType, "I8") == 0)
     {
-      std::vector<cglong_t> mdata2;
-      CGNSRead::readNodeData<cglong_t>(this->cgioNum, elemRangeId, mdata2);
+      std::vector<vtkTypeInt64> mdata2;
+      CGNSRead::readNodeData<vtkTypeInt64>(this->cgioNum, elemRangeId, mdata2);
       if (mdata2.size() != 2)
       {
         vtkErrorMacro(<< "Unexpected data for ElementRange node\n");
@@ -4437 +4468 @@
 
       if (strcmp(dataType, "I4") == 0)
       {
-        std::vector<int> mdata;
-        CGNSRead::readNodeData<int>(this->cgioNum, baseChildId[zone], mdata);
+        std::vector<vtkTypeInt32> mdata;
+        CGNSRead::readNodeData<vtkTypeInt32>(this->cgioNum, baseChildId[zone], mdata);
         for (std::size_t index = 0; index < mdata.size(); index++)
         {
           zsize[index] = static_cast<cgsize_t>(mdata[index]);
@@ -4446 +4477 @@
       }
       else if (strcmp(dataType, "I8") == 0)
       {
-        std::vector<cglong_t> mdata;
-        CGNSRead::readNodeData<cglong_t>(this->cgioNum, baseChildId[zone], mdata);
+        std::vector<vtkTypeInt64> mdata;
+        CGNSRead::readNodeData<vtkTypeInt64>(this->cgioNum, baseChildId[zone], mdata);
         for (std::size_t index = 0; index < mdata.size(); index++)
         {
           zsize[index] = static_cast<cgsize_t>(mdata[index]);
@@ -4724 +4755 @@
   }
 
   // read data
-  if (cgio_read_all_data(cgioFile, childId, &FileVersion))
+  if (cgio_read_all_data_type(cgioFile, childId, "R4", &FileVersion))
   {
     vtkErrorMacro(<< "read CGNS version number");
     ierr = 0;

ParaViewCore/VTKExtensions/CGNSReader/vtkCGNSReaderInternal.cxx

@@ -36 +36 @@
 
   if (strcmp(dataType, "I4") == 0)
   {
-    std::vector<int> mdata;
-    CGNSRead::readNodeData<int>(cgioNum, rindId, mdata);
+    std::vector<vtkTypeInt32> mdata;
+    CGNSRead::readNodeData<vtkTypeInt32>(cgioNum, rindId, mdata);
     for (std::size_t index = 0; index < mdata.size(); index++)
     {
       rind[index] = static_cast<int>(mdata[index]);
@@ -45 +45 @@
   }
   else if (strcmp(dataType, "I8") == 0)
   {
-    std::vector<cglong_t> mdata;
-    CGNSRead::readNodeData<cglong_t>(cgioNum, rindId, mdata);
+    std::vector<vtkTypeInt64> mdata;
+    CGNSRead::readNodeData<vtkTypeInt64>(cgioNum, rindId, mdata);
     for (std::size_t index = 0; index < mdata.size(); index++)
     {
       rind[index] = static_cast<int>(mdata[index]);
@@ -156 +156 @@
 
   if (sizeOfCnt == sizeof(vtkIdType))
   {
-    if (cgio_read_data(cgioNum, cgioElemConnectId, srcStart, srcEnd, srcStride, dim, memDim,
-          memStart, memEnd, memStride, (void*)localElements) != CG_OK)
+    if (cgio_read_data_type(cgioNum, cgioElemConnectId, srcStart, srcEnd, srcStride, dataType, dim,
+          memDim, memStart, memEnd, memStride, (void*)localElements) != CG_OK)
     {
       char message[81];
       cgio_error_message(message);
-      std::cerr << "cgio_read_data :" << message;
+      std::cerr << "cgio_read_data_type :" << message;
       return 1;
     }
   }
@@ -181 +181 @@
         std::cerr << "Allocation failed for temporary connectivity array\n";
       }
 
-      if (cgio_read_data(cgioNum, cgioElemConnectId, srcStart, srcEnd, srcStride, dim, memDim,
-            memStart, memEnd, memStride, (void*)data) != CG_OK)
+      if (cgio_read_data_type(cgioNum, cgioElemConnectId, srcStart, srcEnd, srcStride, "I4", dim,
+            memDim, memStart, memEnd, memStride, (void*)data) != CG_OK)
       {
         delete[] data;
         char message[81];
         cgio_error_message(message);
-        std::cerr << "cgio_read_data :" << message;
+        std::cerr << "cgio_read_data_type :" << message;
         return 1;
       }
       for (cgsize_t n = 0; n < nn; n++)
@@ -204 +204 @@
         std::cerr << "Allocation failed for temporary connectivity array\n";
         return 1;
       }
-      if (cgio_read_data(cgioNum, cgioElemConnectId, srcStart, srcEnd, srcStride, dim, memDim,
-            memStart, memEnd, memStride, (void*)data) != CG_OK)
+      if (cgio_read_data_type(cgioNum, cgioElemConnectId, srcStart, srcEnd, srcStride, "I8", dim,
+            memDim, memStart, memEnd, memStride, (void*)data) != CG_OK)
       {
         delete[] data;
         char message[81];
         cgio_error_message(message);
-        std::cerr << "cgio_read_data :" << message;
+        std::cerr << "cgio_read_data_type :" << message;
         return 1;
       }
       for (cgsize_t n = 0; n < nn; n++)
@@ -258 +258 @@
 
   if (sizeOfCnt == sizeof(vtkIdType))
   {
-    if (cgio_read_data(cgioNum, cgioElemOffsetId, srcStart, srcEnd, srcStride, dim, memDim,
-          memStart, memEnd, memStride, (void*)localElementsIdx) != CG_OK)
+    if (cgio_read_data_type(cgioNum, cgioElemOffsetId, srcStart, srcEnd, srcStride, dataType, dim,
+          memDim, memStart, memEnd, memStride, (void*)localElementsIdx) != CG_OK)
     {
       char message[81];
       cgio_error_message(message);
-      std::cerr << "cgio_read_data :" << message;
+      std::cerr << "cgio_read_data_type :" << message;
       return 1;
     }
   }
@@ -283 +283 @@
         std::cerr << "Allocation failed for temporary connectivity offset array\n";
       }
 
-      if (cgio_read_data(cgioNum, cgioElemOffsetId, srcStart, srcEnd, srcStride, dim, memDim,
-            memStart, memEnd, memStride, (void*)data) != CG_OK)
+      if (cgio_read_data_type(cgioNum, cgioElemOffsetId, srcStart, srcEnd, srcStride, "I4", dim,
+            memDim, memStart, memEnd, memStride, (void*)data) != CG_OK)
       {
         delete[] data;
         char message[81];
         cgio_error_message(message);
-        std::cerr << "cgio_read_data :" << message;
+        std::cerr << "cgio_read_data_type :" << message;
         return 1;
       }
       for (cgsize_t n = 0; n < nn; n++)
@@ -306 +306 @@
         std::cerr << "Allocation failed for temporary connectivity array\n";
         return 1;
       }
-      if (cgio_read_data(cgioNum, cgioElemOffsetId, srcStart, srcEnd, srcStride, dim, memDim,
-            memStart, memEnd, memStride, (void*)data) != CG_OK)
+      if (cgio_read_data_type(cgioNum, cgioElemOffsetId, srcStart, srcEnd, srcStride, "I8", dim,
+            memDim, memStart, memEnd, memStride, (void*)data) != CG_OK)
       {
         delete[] data;
         char message[81];
         cgio_error_message(message);
-        std::cerr << "cgio_read_data :" << message;
+        std::cerr << "cgio_read_data_type :" << message;
         return 1;
       }
       for (cgsize_t n = 0; n < nn; n++)

ParaViewCore/VTKExtensions/CGNSReader/vtkCGNSReaderInternal.h

@@ -72 +72 @@
 };
 }
 
+namespace detail
+{
+template <typename T>
+constexpr const char* cgns_type_name() noexcept
+{
+  return "MT";
+}
+
+template <>
+constexpr const char* cgns_type_name<float>() noexcept
+{
+  return "R4";
+}
+
+template <>
+constexpr const char* cgns_type_name<double>() noexcept
+{
+  return "R8";
+}
+
+template <>
+constexpr const char* cgns_type_name<vtkTypeInt32>() noexcept
+{
+  return "I4";
+}
+
+template <>
+constexpr const char* cgns_type_name<vtkTypeInt64>() noexcept
+{
+  return "I8";
+}
+}
+
 typedef char char_33[33];
 
 //------------------------------------------------------------------------------
@@ -206 +239 @@
 public:
   char_33 name;
 
-  int cellDim;
-  int physicalDim;
+  int32_t cellDim;
+  int32_t physicalDim;
   //
   int baseNumber;
 
-  std::vector<int> steps;
+  std::vector<int32_t> steps;
   std::vector<double> times;
 
   // For unsteady meshes :
@@ -469 +502 @@
     // quick transfer of data if same data types
     if (sameType == true)
     {
-      if (cgio_read_data(cgioNum, coordId, srcStart, srcEnd, srcStride, cellDim, memEnd, memStart,
-            memEnd, memStride, (void*)currentCoord))
+      constexpr const char* dtNameT = detail::cgns_type_name<T>();
+      if (cgio_read_data_type(cgioNum, coordId, srcStart, srcEnd, srcStride, dtNameT, cellDim,
+            memEnd, memStart, memEnd, memStride, (void*)currentCoord))
       {
         char message[81];
         cgio_error_message(message);
-        std::cerr << "cgio_read_data :" << message;
+        std::cerr << "cgio_read_data_type :" << message;
       }
     }
     else
     {
+      constexpr const char* dtNameY = detail::cgns_type_name<Y>();
       Y* dataArray = 0;
       const cgsize_t memNoStride[3] = { 1, 1, 1 };
 
@@ -489 +524 @@
         std::cerr << "Error allocating buffer array\n";
         break;
       }
-      if (cgio_read_data(cgioNum, coordId, srcStart, srcEnd, srcStride, cellDim, memDims, memStart,
-            memDims, memNoStride, (void*)dataArray))
+      if (cgio_read_data_type(cgioNum, coordId, srcStart, srcEnd, srcStride, dtNameY, cellDim,
+            memDims, memStart, memDims, memNoStride, (void*)dataArray))
       {
         delete[] dataArray;
         char message[81];
         cgio_error_message(message);
-        std::cerr << "Buffer array cgio_read_data :" << message;
+        std::cerr << "Buffer array cgio_read_data_type :" << message;
         break;
       }
       for (vtkIdType ii = 0; ii < nPts; ++ii)