Introduction to C++ Part II

$ git init # Inside project
$ gibo macOS Windows Xcode Emacs \
    Vim Python C++ \
    CMake TeX > .gitignore
$ touch readme.md
$ license-generator MIT \
    --author "Person"
$ tree -L 2
.
├── LICENSE
├── docs
│   └── pres
└── readme.org

2 directories, 2 files

// Along each -I and INCLUDE
#include<iostream>

// Starts in the same directory
// Reverse order upward
// -I and INCLUDE
#include "path-spec"

cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
# ---- Project ----
project(
  PenningTrapSimulationII
  VERSION 1.0
  LANGUAGES CXX
)
# ---- Include guards ----
if(PROJECT_SOURCE_DIR
    STREQUAL PROJECT_BINARY_DIR)
  message(
    FATAL_ERROR
    "In-source builds not allowed.
    Please make a new directory
    (called a build directory)
    and run CMake from there."
  )
endif()

$ # Works
$ cmake -H. -Bbuild
$ cmake --build build
$ cd build
$ simulation.exe

# --- Library
set(headers
  "${CMAKE_CURRENT_SOURCE_DIR}/include/math_types/iop_vec.hpp")
set(sources "${CMAKE_CURRENT_SOURCE_DIR}/src/main.cpp")
 # Build
add_executable(simulation.exe ${sources})
# Add to INCLUDE
target_include_directories(
  simulation.exe PUBLIC
  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
)

#include <math_types/iop_vec.hpp>

set(headers
  "include/data_types/iop_vec.hpp"
  "include/data_types/iop_particle.hpp"
  )

#include <data_types/iop_vec.hpp>
#include <data_types/iop_particle.hpp>

class TimeStepper {
private:
  std::vector<PhysicsProcess *> physics_list;
  iopdat::Particle p;
  double dt;

public:
  TimeStepper(double time_step_size,
              double charge,
              double mass);
 void AddProcess(PhysicsProcess*
                 process);
  void Setup(iopdat::Vector3 position,
             iopdat::Vector3 Velocity);
  void Step();
  void Print();
};

$ tree -L .
.
├── CMakeLists.txt
├── LICENSE
├── docs
│   └── pres
├── include
│   ├── data_types
│   └── phys_procs.hpp
├── libsrc
│   └── phys_procs.cpp
├── readme.org
└── src
    ├── CMakeLists.txt
    └── main.cpp

6 directories, 7 files

/**
  * @detail The algorithm is a direct interpretation
  * of standard mechanics
  */
void physproc::TimeStepper::Step() {
  iopdat::Vector3 F(0, 0, 0);
  for (int i = 0;
       i < physics_list.size(); i++) {
    F += physics_list.at(i)->Force(p);
  }
 iopdat::Vector3 dv(dt * F.x / p.mass,
                    dt * F.y / p.mass,
                    dt * F.z / p.mass);
 p.velocity += dv;
 p.position +=
    iopdat::Vector3(p.velocity.x * dt,
                    p.velocity.y * dt,
                    p.velocity.z * dt);
}

# Build order
add_dependencies(simulation.exe ioplib)
# Libraries
target_link_libraries(simulation.exe
  ioplib)
# Dependencies
add_library(
  ioplib SHARED
  "libsrc/phys_procs.cpp"
  )
# Still need the older headers
target_include_directories(
ioplib PUBLIC
$<BUILD_INTERFACE:
${PROJECT_SOURCE_DIR}/include>
)

# --- Externals ./tests/CMakeLists.txt
include(../cmake/CPM.cmake)
CPMAddPackage("gh:catchorg/Catch2@2.13.4")
add_executable(particle_tests
               main.cpp
              vector_particle-test.cpp
              phys_processes-test.cpp
)
# Link everything
target_link_libraries(particle_tests
  ioplib
  Catch2)
target_compile_features(particle_tests PRIVATE cxx_std_17)
# Project Libraries
include_directories(
../src/include/data_types
${PROJECT_SOURCE_DIR}/src/include/)
# ---- Run tests ----
add_test(NAME particleIOP-unit-tests
COMMAND $<TARGET_FILE:particle_tests>)

#include <catch2/catch.hpp>
#include <data_types/iop_particle.hpp>
#include <data_types/iop_vec.hpp>
#include <phys_procs.hpp>
#include <iostream>
TEST_CASE("Basic Vector class tests", "Vector3") {
  iopdat::Vector3 a{1, 2, 3};
REQUIRE(sizeof(a) == 24);
REQUIRE(sizeof(a) / sizeof(1) == 6);
REQUIRE(sizeof(a) / sizeof(1.0) == 3);
  iopdat::Vector3 b{4, 5, 6};
  b += a;
  REQUIRE(b.x == 5);
  REQUIRE(b.y == 7);
  REQUIRE(b.z == 9);
  std::cout << b.x;
}

steps:
- uses: actions/checkout@v2
 - name: Create Build Environment
   run: cmake -E make_directory ${{github.workspace}}/build
 - name: Configure CMake
   shell: bash
   working-directory: ${{github.workspace}}/build
   run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE
 - name: Build
   working-directory: ${{github.workspace}}/build
   shell: bash
   run: cmake --build . --config $BUILD_TYPE
 - name: Test
   working-directory: ${{github.workspace}}/build
   shell: bash
   run: ctest -C $BUILD_TYPE

    py::scoped_interpreter guard{};
    using namespace py::literals;
    // Save the necessary local variables
    // in a Python dict
    py::dict locals = py::dict{
        "signal"_a = signal,
    };
    // Execute Python code, using the variables
    // saved in `locals`
    py::exec(R"(
    import matplotlib.pyplot as plt
    plt.plot(signal)
    plt.show()

    )",
             py::globals(), locals);
    }

from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(x, y, z, c='r', marker='o')
plt.show()