lob.hpp

Go to the documentation of this file.

// This file is a part of lob, an exterior ballistics calculation library
// Copyright (c) 2025  Joel Benway
// Please see end of file for extended copyright information
 
#pragma once
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <limits>
 
#include "lob/lob_export.hpp"
 
namespace lob {

LOB_EXPORT const char* Version();

enum class LOB_EXPORT DragFunctionT : uint8_t {
  kG1,  
  kG2,  
  kG5,  
  kG6,  
  kG7,  
  kG8   
};

enum class LOB_EXPORT AtmosphereReferenceT : uint8_t {
  kArmyStandardMetro,  
  kIcao  
};

enum class LOB_EXPORT ClockAngleT : uint8_t {
  kIII = 0U,  
  kII,        
  kI,         
  kXII,       
  kXI,        
  kX,         
  kIX,        
  kVIII,      
  kVII,       
  kVI,        
  kV,         
  kIV         
};  // enum class ClockAngleT

static constexpr auto kNaN = std::numeric_limits<float>::quiet_NaN();

struct LOB_EXPORT Input {
  static constexpr uint8_t kTableSize{
      85};  
  std::array<uint16_t, kTableSize> drags{};  
  float table_coefficent{
      kNaN};  
  float speed_of_sound{kNaN};  
  uint16_t velocity{0};        
  float mass{kNaN};            
  float optic_height{kNaN};    
  struct Gravity {             
    float x{kNaN};  
    float y{kNaN};  
  } gravity;
  struct Wind {     
    float x{kNaN};  
    float z{kNaN};  
  } wind;
  struct Coriolis {           
    float cos_l_sin_a{kNaN};  
    float sin_l{kNaN};        
    float cos_l_cos_a{kNaN};  
  } corilolis;
  float zero_angle{
      kNaN};  
  float aerodynamic_jump{kNaN};  
  float stability_factor{kNaN};  
};  // struct Input
 
class Impl;

class LOB_EXPORT Builder {
 public:
  Builder();                          
  ~Builder();                         
  Builder(const Builder& other);      
  Builder(Builder&& other) noexcept;  
  Builder& operator=(
      const Builder& rhs);  
  Builder& operator=(
      Builder&& rhs) noexcept;  

  Builder& BallisticCoefficentPsi(float value);
  Builder& BCAtmosphere(AtmosphereReferenceT type);
  Builder& BCDragFunction(DragFunctionT type);
  Builder& DiameterInch(float value);
  Builder& LengthInch(float value);
  Builder& MachVsDragTable(const float* pmachs, const float* pdrags,
                           size_t size);
  template <size_t N>
  Builder& MachVsDragTable(const std::array<float, N>& machs,
                           const std::array<float, N>& drags) {
    return MachVsDragTable(machs.data(), drags.data(), N);
  }

  Builder& MassGrains(float value);
  Builder& InitialVelocityFps(uint16_t value);
  Builder& OpticHeightInches(float value);
  Builder& TwistInchesPerTurn(float value);
  Builder& ZeroAngleMOA(float value);
  Builder& ZeroDistanceYds(float value);
  Builder& ZeroImpactHeightInches(float value);
  Builder& AltitudeOfFiringSiteFt(float value);
  Builder& AirPressureInHg(float value);
  Builder& AltitudeOfBarometerFt(float value);
  Builder& TemperatureDegF(float value);
  Builder& AltitudeOfThermometerFt(float value);
  Builder& RelativeHumidityPercent(float value);
  Builder& WindHeading(ClockAngleT value);
  Builder& WindHeadingDeg(float value);
  Builder& WindSpeedFps(float value);
  Builder& WindSpeedMph(float value);
  Builder& AzimuthDeg(float value);
  Builder& LatitudeDeg(float value);
  Builder& RangeAngleDeg(float value);
  Input Build();
 
 private:
  static constexpr size_t kBufferSize{392};
  union AlignmentT {
    double foo;
    size_t bar;
  };
  alignas(AlignmentT) std::array<uint8_t, kBufferSize> buffer_{};
  Impl* pimpl_{nullptr};
};  // class Builder

struct LOB_EXPORT Options {
  uint16_t min_speed{0};  
  uint16_t min_energy{0};  
  float max_time{kNaN};    
  uint16_t step_size{0};   
};  // struct Options

struct LOB_EXPORT Output {
  uint32_t range{0};       
  uint16_t velocity{0};    
  uint32_t energy{0};      
  float elevation{0.0F};   
  float deflection{0.0F};  
  float time_of_flight{0.0F};  
};  // struct Output

LOB_EXPORT size_t Solve(const Input& in, const uint32_t* pranges, Output* pouts,
                        size_t size, const Options& options);

template <size_t N>
size_t Solve(const Input& in, const std::array<uint32_t, N>* pranges,
             std::array<Output, N>* pouts, const Options& options = Options{}) {
  return Solve(in, pranges->data(), pouts->data(), N, options);
}

LOB_EXPORT double MoaToMil(double value);

LOB_EXPORT double MoaToDeg(double value);

LOB_EXPORT double MoaToIphy(double value);

LOB_EXPORT double MoaToInch(double value, double range_ft);

LOB_EXPORT double MilToMoa(double value);

LOB_EXPORT double MilToDeg(double value);

LOB_EXPORT double MilToIphy(double value);

LOB_EXPORT double MilToInch(double value, double range_ft);

LOB_EXPORT double DegToMoa(double value);

LOB_EXPORT double DegToMil(double value);

LOB_EXPORT double InchToMoa(double value, double range_ft);

LOB_EXPORT double InchToMil(double value, double range_ft);

LOB_EXPORT double InchToDeg(double value, double range_ft);

LOB_EXPORT double JToFtLbs(double value);

LOB_EXPORT double FtLbsToJ(double value);

LOB_EXPORT double MtoYd(double value);

LOB_EXPORT double YdToFt(double value);

LOB_EXPORT double MToFt(double value);

LOB_EXPORT double FtToIn(double value);

LOB_EXPORT double MmToIn(double value);

LOB_EXPORT double CmToIn(double value);

LOB_EXPORT double YdToM(double value);

LOB_EXPORT double FtToM(double value);

LOB_EXPORT double FtToYd(double value);

LOB_EXPORT double InToMm(double value);

LOB_EXPORT double InToCm(double value);

LOB_EXPORT double InToFt(double value);

LOB_EXPORT double PaToInHg(double value);

LOB_EXPORT double MbarToInHg(double value);

LOB_EXPORT double PsiToInHg(double value);

LOB_EXPORT double LbsToGrain(double value);

LOB_EXPORT double GToGrain(double value);

LOB_EXPORT double KgToGrain(double value);

LOB_EXPORT double KgSqMToPmsi(double value);

LOB_EXPORT double FpsToMps(double value);

LOB_EXPORT double MpsToFps(double value);

LOB_EXPORT double KphToMph(double value);

LOB_EXPORT double KnToMph(double value);

LOB_EXPORT double MsToS(double value);

LOB_EXPORT double UsToS(double value);

LOB_EXPORT double SToMs(double value);

LOB_EXPORT double SToUs(double value);

LOB_EXPORT double DegCToDegF(double value);
 
}  // namespace lob
 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.