diff --git a/source/api_cc/src/DeepPotPT.cc b/source/api_cc/src/DeepPotPT.cc
index af8a0c0252..232c9efd31 100644
--- a/source/api_cc/src/DeepPotPT.cc
+++ b/source/api_cc/src/DeepPotPT.cc
@@ -2,9 +2,13 @@
 #ifdef BUILD_PYTORCH
 #include "DeepPotPT.h"
 
+#include <cstdint>
+
 #include "common.h"
 #include "device.h"
+
 using namespace deepmd;
+
 torch::Tensor createNlistTensor(const std::vector<std::vector<int>>& data) {
   std::vector<torch::Tensor> row_tensors;
 
@@ -155,7 +159,7 @@ void DeepPotPT::compute(ENERGYVTYPE& ener,
   at::Tensor coord_wrapped_Tensor =
       torch::from_blob(coord_wrapped.data(), {1, nall_real, 3}, options)
           .to(device);
-  std::vector<int64_t> atype_64(datype.begin(), datype.end());
+  std::vector<std::int64_t> atype_64(datype.begin(), datype.end());
   at::Tensor atype_Tensor =
       torch::from_blob(atype_64.data(), {1, nall_real}, int_option).to(device);
   if (ago == 0) {
@@ -199,17 +203,18 @@ void DeepPotPT::compute(ENERGYVTYPE& ener,
   if (!fparam.empty()) {
     fparam_tensor =
         torch::from_blob(const_cast<VALUETYPE*>(fparam.data()),
-                         {1, static_cast<long int>(fparam.size())}, options)
+                         {1, static_cast<std::int64_t>(fparam.size())}, options)
             .to(device);
   }
   c10::optional<torch::Tensor> aparam_tensor;
   if (!aparam_.empty()) {
-    aparam_tensor = torch::from_blob(
-                        const_cast<VALUETYPE*>(aparam_.data()),
-                        {1, lmp_list.inum,
-                         static_cast<long int>(aparam_.size()) / lmp_list.inum},
-                        options)
-                        .to(device);
+    aparam_tensor =
+        torch::from_blob(
+            const_cast<VALUETYPE*>(aparam_.data()),
+            {1, lmp_list.inum,
+             static_cast<std::int64_t>(aparam_.size()) / lmp_list.inum},
+            options)
+            .to(device);
   }
   c10::Dict<c10::IValue, c10::IValue> outputs =
       (do_message_passing == 1)
@@ -340,7 +345,7 @@ void DeepPotPT::compute(ENERGYVTYPE& ener,
       torch::from_blob(coord_wrapped.data(), {1, natoms, 3}, options)
           .to(device);
   inputs.push_back(coord_wrapped_Tensor);
-  std::vector<int64_t> atype_64(atype.begin(), atype.end());
+  std::vector<std::int64_t> atype_64(atype.begin(), atype.end());
   at::Tensor atype_Tensor =
       torch::from_blob(atype_64.data(), {1, natoms}, int_options).to(device);
   inputs.push_back(atype_Tensor);
@@ -355,7 +360,7 @@ void DeepPotPT::compute(ENERGYVTYPE& ener,
   if (!fparam.empty()) {
     fparam_tensor =
         torch::from_blob(const_cast<VALUETYPE*>(fparam.data()),
-                         {1, static_cast<long int>(fparam.size())}, options)
+                         {1, static_cast<std::int64_t>(fparam.size())}, options)
             .to(device);
   }
   inputs.push_back(fparam_tensor);
@@ -364,7 +369,8 @@ void DeepPotPT::compute(ENERGYVTYPE& ener,
     aparam_tensor =
         torch::from_blob(
             const_cast<VALUETYPE*>(aparam.data()),
-            {1, natoms, static_cast<long int>(aparam.size()) / natoms}, options)
+            {1, natoms, static_cast<std::int64_t>(aparam.size()) / natoms},
+            options)
             .to(device);
   }
   inputs.push_back(aparam_tensor);
diff --git a/source/api_cc/src/DeepPotTF.cc b/source/api_cc/src/DeepPotTF.cc
index 7bf2bebce4..6b39e0ada9 100644
--- a/source/api_cc/src/DeepPotTF.cc
+++ b/source/api_cc/src/DeepPotTF.cc
@@ -2,6 +2,7 @@
 #ifdef BUILD_TENSORFLOW
 #include "DeepPotTF.h"
 
+#include <cstdint>
 #include <stdexcept>
 
 #include "AtomMap.h"
@@ -549,7 +550,7 @@ void DeepPotTF::tile_fparam_aparam(std::vector<VALUETYPE>& out_param,
     out_param.resize(static_cast<size_t>(nframes) * dparam);
     for (int ii = 0; ii < nframes; ++ii) {
       std::copy(param.begin(), param.end(),
-                out_param.begin() + static_cast<unsigned long>(ii) * dparam);
+                out_param.begin() + static_cast<std::uint64_t>(ii) * dparam);
     }
   } else if (param.size() == static_cast<size_t>(nframes) * dparam) {
     out_param = param;
diff --git a/source/op/pt/comm.cc b/source/op/pt/comm.cc
index 11047ad1d6..ce497ac62d 100644
--- a/source/op/pt/comm.cc
+++ b/source/op/pt/comm.cc
@@ -1,13 +1,20 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
-#if defined(GOOGLE_CUDA) || defined(TENSORFLOW_USE_ROCM)
-#include "device.h"
-#endif
-#include <torch/torch.h>
+
 #ifdef USE_MPI
 #include <mpi.h>
 #ifdef OMPI_MPI_H
 #include <mpi-ext.h>
 #endif
+#endif
+#include <torch/torch.h>
+
+#include <cstdint>
+
+#if defined(GOOGLE_CUDA) || defined(TENSORFLOW_USE_ROCM)
+#include "device.h"
+#endif
+
+#ifdef USE_MPI
 template <typename T>
 static MPI_Datatype get_mpi_type();
 
@@ -21,6 +28,7 @@ MPI_Datatype get_mpi_type<double>() {
   return MPI_DOUBLE;
 }
 #endif
+
 class Border : public torch::autograd::Function<Border> {
  public:
   static torch::autograd::variable_list forward(
@@ -321,9 +329,9 @@ class Border : public torch::autograd::Function<Border> {
   static void unpack_communicator(const torch::Tensor& communicator_tensor,
                                   MPI_Comm& mpi_comm) {
 #ifdef OMPI_MPI_H
-    long int* communicator = communicator_tensor.data_ptr<long int>();
+    std::int64_t* communicator = communicator_tensor.data_ptr<std::int64_t>();
 #else
-    long int* ptr = communicator_tensor.data_ptr<long int>();
+    std::int64_t* ptr = communicator_tensor.data_ptr<std::int64_t>();
     int* communicator = reinterpret_cast<int*>(ptr);
 #endif
     mpi_comm = reinterpret_cast<MPI_Comm>(*communicator);