Address use of c-style casts warnings

Author: gsjaardema

packages/seacas/applications/conjoin/CJ_Internals.C

@@ -1,5 +1,5 @@
 /*
- * Copyright(C) 1999-, 20242024, ,  National Technology & Engineering Solutions
+ * Copyright(C) 1999-, 20242024, , ,  National Technology & Engineering Solutions
  * of Sandia, LLC (NTESS).  Under the terms of Contract DE-NA0003525 with
  * NTESS, the U.S. Government retains certain rights in this software.
  *
@@ -311,7 +311,7 @@ int Excn::Internals::put_metadata(const Mesh<INT> &mesh, const CommunicationMeta
   int varid = 0;
   {
     std::array dim{timedim};
-    if ((status = nc_def_var(exodusFilePtr, VAR_WHOLE_TIME, nc_flt_code(exodusFilePtr), 1,
+    if ((status = nc_def_var(exodusFilePtr, VAR_WHOLE_TIME, static_cast<nc_flt_code>(exodusFilePtr), 1,
                              Data(dim), &varid)) != NC_NOERR) {
       std::string errmsg = fmt::format(
           "Error: failed to define whole time step variable in file id {}", exodusFilePtr);

packages/seacas/applications/conjoin/Conjoin.C

@@ -68,7 +68,7 @@ namespace {
   static const T tolerance = 100.0 * std::numeric_limits<T>::epsilon();
   return std::fabs(v1 - v2) <= std::fabs(v1+v2)*tolerance;
 #else
-    return (float)v1 == (float)v2;
+  return static_cast<float>(v1) == static_cast<float>(v2);
 #endif
   }
 } // namespace
@@ -651,7 +651,7 @@ int conjoin(Excn::SystemInterface &interFace, T /* dummy */, INT /* dummy int */
       fmt::print("{}", time_stamp(tsFormat));
     }
 
-    error += get_put_coordinates(global, part_count, local_mesh, (T)0);
+    error += get_put_coordinates(global, part_count, local_mesh, static_cast<T>(0));
 
     if (debug_level & 1) {
       fmt::print("{}", time_stamp(tsFormat));
@@ -819,11 +819,11 @@ int conjoin(Excn::SystemInterface &interFace, T /* dummy */, INT /* dummy int */
         fmt::print("{}Global Variables...\n", time_stamp(tsFormat));
       }
       error += ex_get_var(id, global_times[time_step].localStepNumber + 1, EX_GLOBAL, 0, 0,
-                          global_vars.count(), (void *)Data(global_values));
+                          global_vars.count(), static_cast<void *>(Data(global_values)));
       // Map ...
       for (int ig = 0; ig < global_vars.count(Excn::InOut::IN_); ig++) {
         if (global_vars.index_[ig] > 0) {
-          SMART_ASSERT(ig < (int)global_values.size());
+          SMART_ASSERT(ig < static_cast<int>(global_values.size()));
           output_global_values[global_vars.index_[ig] - 1] = global_values[ig];
         }
       }
@@ -1350,7 +1350,7 @@ namespace {
             for (size_t n = 0; n < npe; n++) {
               size_t node = part_loc_node_to_global[local_linkage[pos++] - 1];
               if (debug_level & 4) {
-                SMART_ASSERT(block_linkage[global_pos] == (int)node + 1 ||
+                SMART_ASSERT(block_linkage[global_pos] == static_cast<int>(node) + 1 ||
                              block_linkage[global_pos] == 0);
               }
               block_linkage[global_pos++] = node + 1;
@@ -1667,7 +1667,7 @@ namespace {
     // sorted and there are no duplicates, we just need to see if the id
     // at global_node_map.size() == global_node_map.size();
     INT  max_id        = global_node_map[global->nodeCount - 1].id;
-    bool is_contiguous = (int64_t)max_id == static_cast<int64_t>(global_node_map.size());
+    bool is_contiguous = static_cast<int64_t>(max_id) == static_cast<int64_t>(global_node_map.size());
     fmt::print("Node map {} contiguous.\n", (is_contiguous ? "is" : "is not"));
 
     // Create the map that maps from a local part node to the
@@ -1774,7 +1774,7 @@ namespace {
     // sorted and there are no duplicates, we just need to see if the id
     // at global_node_map.size() == global_node_map.size();
     INT  max_id        = global_node_map[global->nodeCount - 1];
-    bool is_contiguous = (int64_t)max_id == static_cast<int64_t>(global_node_map.size());
+    bool is_contiguous = static_cast<int64_t>(max_id) == static_cast<int64_t>(global_node_map.size());
     fmt::print("Node map {} contiguous.\n", (is_contiguous ? "is" : "is not"));
 
     // Create the map that maps from a local part node to the
@@ -2048,7 +2048,7 @@ namespace {
     int  num_vars;
     auto id = Excn::ExodusFile(p);
     ex_get_variable_param(id, vars.type(), &num_vars);
-    if ((size_t)num_vars != vars.index_.size() - extra) {
+    if (static_cast<size_t>(num_vars) != vars.index_.size() - extra) {
       fmt::print("ERROR: Part mesh {} has a different number of {} variables ({}) than the root "
                  "part mesh ({}) which is not allowed.\n",
                  p, vars.label(), num_vars, vars.index_.size() - extra);
@@ -2207,7 +2207,7 @@ namespace {
       for (size_t ns = 0; ns < set_ids.size(); ns++) {
 
         std::vector<INT> glob_ns_nodes(total_node_count + 1);
-        std::fill(glob_ns_nodes.begin(), glob_ns_nodes.end(), (INT)0);
+        std::fill(glob_ns_nodes.begin(), glob_ns_nodes.end(), static_cast<INT>(0));
 
         size_t lns = glob_sets[ns].position_;
         for (size_t p = 0; p < part_count; p++) {
@@ -2444,7 +2444,7 @@ namespace {
                 size_t global_elem =
                     local_mesh[p].localElementToGlobal[sets[p][lss].elems[i] - 1] + 1;
                 elem_side[offset + i] =
-                    std::make_pair((INT)global_elem, (INT)sets[p][lss].sides[i]);
+		  std::make_pair(static_cast<INT>(global_elem), static_cast<INT>(sets[p][lss].sides[i]));
               }
               offset += sets[p][lss].sideCount;
               break;
@@ -2480,7 +2480,7 @@ namespace {
                   size_t global_elem =
                       local_mesh[p].localElementToGlobal[sets[p][lss].elems[i] - 1] + 1;
                   std::pair<INT, INT> es =
-                      std::make_pair((INT)global_elem, (INT)sets[p][lss].sides[i]);
+		    std::make_pair(static_cast<INT>(global_elem), static_cast<INT>(sets[p][lss].sides[i]));
 
                   auto   iter = std::lower_bound(elem_side.begin(), elem_side.end(), es);
                   size_t pos  = iter - elem_side.begin();
@@ -3001,7 +3001,7 @@ namespace {
   {
     size_t max_ent = local_mesh[0].count(Excn::ObjectType::NODE);
     for (size_t p = 1; p < part_count; p++) {
-      if ((size_t)local_mesh[p].count(Excn::ObjectType::NODE) > max_ent) {
+      if (static_cast<size_t>(local_mesh[p].count(Excn::ObjectType::NODE)) > max_ent) {
         max_ent = local_mesh[p].count(Excn::ObjectType::NODE);
       }
     }

packages/seacas/applications/epu/EP_ExodusFile.C

@@ -83,7 +83,7 @@ namespace {
 Excn::ExodusFile::ExodusFile(int processor) : myProcessor_(processor)
 {
   SMART_ASSERT(processor < processorCount_)(processor)(processorCount_);
-  SMART_ASSERT(fileids_.size() == (size_t)processorCount_);
+  SMART_ASSERT(fileids_.size() == static_cast<size_t>(processorCount_));
   if (!keepOpen_ && processor != 0) {
     float version          = 0.0;
     int   cpu_word_size    = cpuWordSize_;

packages/seacas/applications/epu/EP_Internals.C

@@ -1,5 +1,5 @@
 /*
- * Copyright(C) 1999-2024,  National Technology & Engineering Solutions
+ * Copyright(C) 1999-2025,  National Technology & Engineering Solutions
  * of Sandia, LLC (NTESS).  Under the terms of Contract DE-NA0003525 with
  * NTESS, the U.S. Government retains certain rights in this software.
  *
@@ -132,11 +132,11 @@ int Excn::Internals<INT>::write_meta_data(const Mesh &mesh, const std::vector<Bl
                                           const std::vector<FaceBlock<INT>> &faceblocks,
                                           const CommunicationMetaData       &comm)
 {
-  SMART_ASSERT((int)blocks.size() == mesh.blockCount);
-  SMART_ASSERT((int)nodesets.size() == mesh.nodesetCount);
-  SMART_ASSERT((int)sidesets.size() == mesh.sidesetCount);
-  SMART_ASSERT((int)edgeblocks.size() == mesh.edgeBlockCount);
-  SMART_ASSERT((int)faceblocks.size() == mesh.faceBlockCount);
+  SMART_ASSERT(static_cast<int>(blocks.size()) == mesh.blockCount);
+  SMART_ASSERT(static_cast<int>(nodesets.size()) == mesh.nodesetCount);
+  SMART_ASSERT(static_cast<int>(sidesets.size()) == mesh.sidesetCount);
+  SMART_ASSERT(static_cast<int>(edgeblocks.size()) == mesh.edgeBlockCount);
+  SMART_ASSERT(static_cast<int>(faceblocks.size()) == mesh.faceBlockCount);
 
   // May need to reorder the element blocks based on the 'offset_'
   // member. An element block contains the elements from 'offset_+1'
@@ -281,7 +281,7 @@ int Excn::Internals<INT>::write_meta_data(const Mesh &mesh, const std::vector<Bl
 
       for (int i = 0; i < mesh.blockCount; i++) {
         if (blocks[i].attributeCount > 0) {
-          SMART_ASSERT((size_t)blocks[i].attributeCount == blocks[i].attributeNames.size());
+          SMART_ASSERT(static_cast<size_t>(blocks[i].attributeCount) == blocks[i].attributeNames.size());
           for (int j = 0; j < blocks[i].attributeCount; j++) {
             std::memset(names[j], '\0', name_size + 1);
             if (!blocks[i].attributeNames[j].empty()) {
@@ -852,7 +852,7 @@ int Excn::Internals<INT>::put_metadata(const std::vector<NodeSet<INT>> &nodesets
     //  NOTE: exi_inc_file_item is used to find the number of node sets
     // for a specific file and returns that value incremented.
     int cur_num_node_sets =
-        (int)exi_inc_file_item(exodusFilePtr, exi_get_counter_list(EX_NODE_SET));
+      static_cast<int>(exi_inc_file_item(exodusFilePtr, exi_get_counter_list(EX_NODE_SET)));
 
     if (nodesets[i].nodeCount == 0) {
       continue;
@@ -1003,7 +1003,7 @@ int Excn::Internals<INT>::put_metadata(const std::vector<SideSet<INT>> &sidesets
     //  NOTE: exi_inc_file_item is used to find the number of side sets
     // for a specific file and returns that value incremented.
     int cur_num_side_sets =
-        (int)exi_inc_file_item(exodusFilePtr, exi_get_counter_list(EX_SIDE_SET));
+      static_cast<int>(exi_inc_file_item(exodusFilePtr, exi_get_counter_list(EX_SIDE_SET)));
 
     if (sidesets[i].sideCount == 0) {
       continue;
@@ -1118,7 +1118,7 @@ int Excn::Internals<INT>::put_non_define_data(const std::vector<SideSet<INT>> &s
   }
 
   // Output sideset ids...
-  int                       num_sidesets = (int)sidesets.size();
+  int                       num_sidesets = static_cast<int>(sidesets.size());
   std::vector<ex_entity_id> sideset_id(num_sidesets);
   for (int i = 0; i < num_sidesets; i++) {
     sideset_id[i] = sidesets[i].id;
@@ -1180,7 +1180,7 @@ int Excn::Internals<INT>::put_metadata(const std::vector<EdgeBlock<INT>> &edgebl
     //  NOTE: exi_inc_file_item is used to find the number of edge blocks
     // for a specific file and returns that value incremented.
     int cur_num_edge_blocks =
-        (int)exi_inc_file_item(exodusFilePtr, exi_get_counter_list(EX_EDGE_BLOCK));
+      static_cast<int>(exi_inc_file_item(exodusFilePtr, exi_get_counter_list(EX_EDGE_BLOCK)));
 
     if (edgeblocks[i].edgeCount == 0) {
       continue;
@@ -1255,7 +1255,7 @@ int Excn::Internals<INT>::put_non_define_data(const std::vector<EdgeBlock<INT>>
   }
 
   // Output edgeblock ids...
-  int                       num_edgeblocks = (int)edgeblocks.size();
+  int                       num_edgeblocks = static_cast<int>(edgeblocks.size());
   std::vector<ex_entity_id> edgeblock_id(num_edgeblocks);
   for (int i = 0; i < num_edgeblocks; i++) {
     edgeblock_id[i] = edgeblocks[i].id;
@@ -1317,7 +1317,7 @@ int Excn::Internals<INT>::put_metadata(const std::vector<FaceBlock<INT>> &facebl
     //  NOTE: exi_inc_file_item is used to find the number of face blocks
     // for a specific file and returns that value incremented.
     int cur_num_face_blocks =
-        (int)exi_inc_file_item(exodusFilePtr, exi_get_counter_list(EX_FACE_BLOCK));
+      static_cast<int>(exi_inc_file_item(exodusFilePtr, exi_get_counter_list(EX_FACE_BLOCK)));
 
     if (faceblocks[i].faceCount == 0) {
       continue;
@@ -1393,7 +1393,7 @@ int Excn::Internals<INT>::put_non_define_data(const std::vector<FaceBlock<INT>>
   }
 
   // Output faceblock ids...
-  int                       num_faceblocks = (int)faceblocks.size();
+  int                       num_faceblocks = static_cast<int>(faceblocks.size());
   std::vector<ex_entity_id> faceblock_id(num_faceblocks);
   for (int i = 0; i < num_faceblocks; i++) {
     faceblock_id[i] = faceblocks[i].id;
@@ -1433,7 +1433,7 @@ namespace {
     }
 
     if (sizeof(INT) == sizeof(int64_t)) {
-      status = nc_put_var_longlong(exoid, var_id, (long long int *)Data(array));
+      status = nc_put_var_longlong(exoid, var_id, (long long int*)Data(array));
     }
     else {
       status = nc_put_var_int(exoid, var_id, Data(array));

packages/seacas/applications/epu/epu.C

@@ -208,7 +208,7 @@ namespace {
   template <typename INT> bool is_sequential(std::vector<INT> &map)
   {
     for (size_t i = 0; i < map.size(); i++) {
-      if (map[i] != (INT)i + 1) {
+      if (map[i] != static_cast<INT>(i) + 1) {
         return false;
       }
     }
@@ -536,9 +536,9 @@ int main(int argc, char *argv[])
         // if that value > max_open_file, then use square root.
         // if that is still too large, just do no subcycles... and implement
         // a recursive subcycling capability at some point...
-        int sub_cycle_count = (int)(std::pow(processor_count, 1.0 / 3) + 0.9);
+        int sub_cycle_count = static_cast<int>((std::pow(processor_count, 1.0 / 3) + 0.9));
         if (((processor_count + sub_cycle_count - 1) / sub_cycle_count) > max_open_file) {
-          sub_cycle_count = (int)std::sqrt(processor_count);
+          sub_cycle_count = static_cast<int>(std::sqrt(processor_count));
         }
 
         if (((processor_count + sub_cycle_count - 1) / sub_cycle_count) < max_open_file) {
@@ -1429,7 +1429,7 @@ int epu(SystemInterface &interFace, int start_part, int part_count, int cycle)
           // Map ...
           for (int ig = 0; ig < global_vars.count(InOut::IN); ig++) {
             if (global_vars.index_[ig] > 0) {
-              SMART_ASSERT(ig < (int)global_values.size());
+              SMART_ASSERT(ig < static_cast<int>(global_values.size()));
               output_global_values[global_vars.index_[ig] - 1] = global_values[ig];
             }
           }
@@ -1927,7 +1927,7 @@ namespace {
     }
 
     std::array<INT, 1> ids{1};
-    std::array<INT, 1> cnts{(INT)gnodes.size()};
+    std::array<INT, 1> cnts{static_cast<INT>(gnodes.size())};
     error = ex_put_cmap_params(ExodusFile::output(), Data(ids), Data(cnts), nullptr, nullptr,
                                output_processor);
     if (error < 0) {
@@ -2124,7 +2124,7 @@ namespace {
           glob_blocks[b].elementCount += temp_block.num_entry;
           glob_blocks[b].nodesPerElement = temp_block.num_nodes_per_entry;
           glob_blocks[b].attributeCount  = temp_block.num_attribute;
-          glob_blocks[b].position_       = (int)b;
+          glob_blocks[b].position_       = static_cast<int>(b);
           copy_string(glob_blocks[b].elType, temp_block.topology);
         }
 
@@ -2444,7 +2444,7 @@ namespace {
     // sorted and there are no duplicates, we just need to see if the id
     // at global_element_map.size() == global_element_map.size();
     bool is_contiguous = global_element_map.empty() ||
-                         ((size_t)global_element_map.back() == global_element_map.size());
+      (static_cast<size_t>(global_element_map.back()) == global_element_map.size());
     if (rank == 0) {
       fmt::print("Element id map {} contiguous.\n", (is_contiguous ? "is" : "is not"));
     }
@@ -2621,7 +2621,7 @@ namespace {
     // sorted and there are no duplicates, we just need to see if the id
     // at global_edge_map.size() == global_edge_map.size();
     bool is_contiguous =
-        global_edge_map.empty() || ((size_t)global_edge_map.back() == global_edge_map.size());
+      global_edge_map.empty() || (static_cast<size_t>(global_edge_map.back()) == global_edge_map.size());
     if (rank == 0) {
       fmt::print("Edge id map {} contiguous.\n", (is_contiguous ? "is" : "is not"));
     }
@@ -2798,7 +2798,7 @@ namespace {
     // sorted and there are no duplicates, we just need to see if the id
     // at global_face_map.size() == global_face_map.size();
     bool is_contiguous =
-        global_face_map.empty() || ((size_t)global_face_map.back() == global_face_map.size());
+      global_face_map.empty() || (static_cast<size_t>(global_face_map.back()) == global_face_map.size());
     if (rank == 0) {
       fmt::print("Face id map {} contiguous.\n", (is_contiguous ? "is" : "is not"));
     }
@@ -2969,7 +2969,7 @@ namespace {
     // sorted and there are no duplicates, we just need to see if the id
     // at global_node_map.size() == global_node_map.size();
     bool is_contiguous =
-        global_node_map.empty() || ((size_t)global_node_map.back() == global_node_map.size());
+      global_node_map.empty() || (static_cast<size_t>(global_node_map.back()) == global_node_map.size());
     if (rank == 0) {
       fmt::print("Node map {} contiguous.\n", (is_contiguous ? "is" : "is not"));
     }
@@ -3393,14 +3393,14 @@ namespace {
         // output nodeset
         // NOTE: global_node above is 1-based.
         glob_sets[ns].nodeCount =
-            std::accumulate(glob_ns_nodes.begin(), glob_ns_nodes.end(), (INT)0);
+	  std::accumulate(glob_ns_nodes.begin(), glob_ns_nodes.end(), static_cast<INT>(0));
         glob_sets[ns].nodeSetNodes.resize(glob_sets[ns].entity_count());
         glob_sets[ns].dfCount = glob_sets[ns].nodeCount;
 
         // distFactors is a vector of 'char' to allow storage of either float or double.
         glob_sets[ns].distFactors.resize(glob_sets[ns].dfCount * ExodusFile::io_word_size());
 
-        T     *glob_df = (T *)(Data(glob_sets[ns].distFactors));
+        T     *glob_df = (T *)Data(glob_sets[ns].distFactors);
         size_t j       = 0;
         for (size_t i = 1; i <= total_node_count; i++) {
           if (glob_ns_nodes[i] == 1) {
@@ -3804,7 +3804,7 @@ namespace {
           glob_edgeblocks[b].edgeCount += temp_block.num_entry;
           glob_edgeblocks[b].nodesPerEdge   = temp_block.num_nodes_per_entry;
           glob_edgeblocks[b].attributeCount = temp_block.num_attribute;
-          glob_edgeblocks[b].position_      = (int)b;
+          glob_edgeblocks[b].position_      = static_cast<int>(b);
           copy_string(glob_edgeblocks[b].elType, temp_block.topology);
         }
 
@@ -4179,7 +4179,7 @@ namespace {
           glob_faceblocks[b].faceCount += temp_block.num_entry;
           glob_faceblocks[b].nodesPerFace   = temp_block.num_nodes_per_entry;
           glob_faceblocks[b].attributeCount = temp_block.num_attribute;
-          glob_faceblocks[b].position_      = (int)b;
+          glob_faceblocks[b].position_      = static_cast<int>(b);
           copy_string(glob_faceblocks[b].elType, temp_block.topology);
         }