math_utilities.h

Go to the documentation of this file.

 
#pragma once
 
// STL Includes
#include <cmath>
#include <tuple>
 
// External Includes
 
// Local Includes
#include "../global/global.h"
#include "../global/global_cuda.h"
#include "../utils/basic_structs.h"
#include "../utils/gpu.hpp"
 
namespace math_utils
{
// =========================================================================
template <typename T>
inline std::tuple<T, T, T> rotateCoords(Real const &x_1, Real const &x_2, Real const &x_3, Real const &pitch,
                                        Real const &yaw)
{
  // Compute the sines and cosines. Correct for floating point errors if
  // the angle is 0.5*M_PI
  Real const sin_yaw   = std::sin(yaw);
  Real const cos_yaw   = (yaw == 0.5 * M_PI) ? 0 : std::cos(yaw);
  Real const sin_pitch = std::sin(pitch);
  Real const cos_pitch = (pitch == 0.5 * M_PI) ? 0 : std::cos(pitch);
 
  // Perform the rotation
  Real const x_1_rot = (x_1 * cos_pitch * cos_yaw) + (x_2 * sin_yaw) + (x_3 * sin_pitch * cos_yaw);
  Real const x_2_rot = (x_1 * cos_pitch * sin_yaw) + (x_2 * cos_yaw) + (x_3 * sin_pitch * sin_yaw);
  Real const x_3_rot = (x_1 * sin_pitch) + (x_3 * cos_pitch);
 
  if (std::is_same<T, int>::value) {
    return {round(x_1_rot), round(x_2_rot), round(x_3_rot)};
  } else if (std::is_same<T, Real>::value) {
    return {x_1_rot, x_2_rot, x_3_rot};
  }
}
// =========================================================================
 
// =========================================================================
inline __device__ __host__ Real dotProduct(Real const &a1, Real const &a2, Real const &a3, Real const &b1,
                                           Real const &b2, Real const &b3)
{
  return a1 * b1 + ((a2 * b2) + (a3 * b3));
};
// =========================================================================
 
// =========================================================================
inline __device__ __host__ Real SquareMagnitude(Real const &v1, Real const &v2, Real const &v3)
{
  return dotProduct(v1, v2, v3, v1, v2, v3);
};
// =========================================================================
 
// =====================================================================================================================
inline __device__ __host__ void Cyclic_Permute_Once(hydro_utilities::VectorXYZ<Real> &vec)
{
  Real temp = vec.x();
  vec.x()   = vec.y();
  vec.y()   = vec.z();
  vec.z()   = temp;
}
// =====================================================================================================================
 
// =====================================================================================================================
inline __device__ __host__ void Cyclic_Permute_Twice(hydro_utilities::VectorXYZ<Real> &vec)
{
  Real temp = vec.y();
  vec.y()   = vec.x();
  vec.x()   = vec.z();
  vec.z()   = temp;
}
// =====================================================================================================================
 
template <typename T>
__device__ __host__ T clamp(T val, T lo, T hi)
{
  const T tmp = val < lo ? lo : val;
  return tmp > hi ? hi : tmp;
}
 
}  // namespace math_utils