Merge branch 'obsplane' into 'master'

added ObservationPlane

See merge request AirShowerPhysics/corsika!133

Processes/CMakeLists.txt

@@ -14,6 +14,7 @@ add_subdirectory (SwitchProcess)
 # continuous physics
 add_subdirectory (EnergyLoss)
 add_subdirectory (TrackWriter)
+add_subdirectory (ObservationPlane)
 # stack processes
 add_subdirectory (StackInspector)
 # secondaries process

Processes/ObservationPlane/CMakeLists.txt

+set (
+  MODEL_HEADERS
+  ObservationPlane.h
+  )
+
+set (
+  MODEL_SOURCES
+  ObservationPlane.cc
+  )
+
+set (
+  MODEL_NAMESPACE
+  corsika/process/observation_plane
+  )
+
+add_library (ProcessObservationPlane STATIC ${MODEL_SOURCES})
+CORSIKA_COPY_HEADERS_TO_NAMESPACE (ProcessObservationPlane ${MODEL_NAMESPACE} ${MODEL_HEADERS})
+
+# target dependencies on other libraries (also the header onlys)
+target_link_libraries (
+  ProcessObservationPlane
+  CORSIKAgeometry
+  CORSIKAprocesssequence
+  )
+
+target_include_directories (
+  ProcessObservationPlane 
+  INTERFACE 
+  $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include>
+  $<INSTALL_INTERFACE:include/include>
+  )
+
+install (FILES ${MODEL_HEADERS} DESTINATION include/${MODEL_NAMESPACE})
+
+# --------------------
+# code unit testing
+CORSIKA_ADD_TEST(testObservationPlane)
+target_link_libraries (
+  testObservationPlane
+  ProcessObservationPlane
+  CORSIKAstackinterface
+  CORSIKAthirdparty # for catch2
+)
+

Processes/ObservationPlane/ObservationPlane.cc

+/*
+ * (c) Copyright 2019 CORSIKA Project, corsika-project@lists.kit.edu
+ *
+ * See file AUTHORS for a list of contributors.
+ *
+ * This software is distributed under the terms of the GNU General Public
+ * Licence version 3 (GPL Version 3). See file LICENSE for a full version of
+ * the license.
+ */
+
+#include <corsika/process/observation_plane/ObservationPlane.h>
+
+#include <fstream>
+
+using namespace corsika::process::observation_plane;
+using namespace corsika::units::si;
+
+ObservationPlane::ObservationPlane(geometry::Plane const& vObsPlane,
+                                   std::string const& vFilename)
+    : fObsPlane(vObsPlane)
+    , fOutputStream(vFilename) {
+  fOutputStream << "#PDG code, energy / eV, distance to center / m" << std::endl;
+}
+
+corsika::process::EProcessReturn ObservationPlane::DoContinuous(
+    setup::Stack::ParticleType const& vParticle, setup::Trajectory const& vTrajectory) {
+
+  if (fObsPlane.IsAbove(vTrajectory.GetPosition(1.0001))) {
+    return process::EProcessReturn::eOk;
+  }
+
+  fOutputStream << static_cast<int>(particles::GetPDG(vParticle.GetPID())) << ' '
+                << vParticle.GetEnergy() * (1 / 1_eV) << ' '
+                << (vTrajectory.GetPosition(1) - fObsPlane.GetCenter()).norm() / 1_m
+                << std::endl;
+
+  return process::EProcessReturn::eParticleAbsorbed;
+}
+
+LengthType ObservationPlane::MaxStepLength(setup::Stack::ParticleType const&,
+                                           setup::Trajectory const& vTrajectory) {
+  if (!fObsPlane.IsAbove(vTrajectory.GetR0())) {
+    return std::numeric_limits<double>::infinity() * 1_m;
+  }
+
+  auto const pointOfIntersection = vTrajectory.GetPosition(
+      (fObsPlane.GetCenter() - vTrajectory.GetR0()).dot(fObsPlane.GetNormal()) /
+      vTrajectory.GetV0().dot(fObsPlane.GetNormal()));
+  return (vTrajectory.GetR0() - pointOfIntersection).norm();
+}

Processes/ObservationPlane/ObservationPlane.h

+/*
+ * (c) Copyright 2019 CORSIKA Project, corsika-project@lists.kit.edu
+ *
+ * See file AUTHORS for a list of contributors.
+ *
+ * This software is distributed under the terms of the GNU General Public
+ * Licence version 3 (GPL Version 3). See file LICENSE for a full version of
+ * the license.
+ */
+
+#ifndef _Processes_ObservationPlane_h_
+#define _Processes_ObservationPlane_h_
+
+#include <corsika/geometry/Plane.h>
+#include <corsika/process/ContinuousProcess.h>
+#include <corsika/setup/SetupStack.h>
+#include <corsika/setup/SetupTrajectory.h>
+#include <corsika/units/PhysicalUnits.h>
+
+#include <fstream>
+
+namespace corsika::process::observation_plane {
+
+  /**
+   * The ObservationPlane writes PDG codes, energies, and distances of particles to the
+   * central point of the plane into its output file. The particles are considered
+   * "absorbed" afterwards.
+   */
+  class ObservationPlane : public corsika::process::ContinuousProcess<ObservationPlane> {
+
+  public:
+    ObservationPlane(geometry::Plane const& vObsPlane, std::string const& vFilename);
+    void Init() {}
+
+    corsika::process::EProcessReturn DoContinuous(
+        corsika::setup::Stack::ParticleType const& vParticle,
+        corsika::setup::Trajectory const& vTrajectory);
+
+    corsika::units::si::LengthType MaxStepLength(
+        corsika::setup::Stack::ParticleType const&,
+        corsika::setup::Trajectory const& vTrajectory);
+
+  private:
+    geometry::Plane const fObsPlane;
+    std::ofstream fOutputStream;
+  };
+} // namespace corsika::process::observation_plane
+
+#endif

Processes/ObservationPlane/testObservationPlane.cc

+/*
+ * (c) Copyright 2019 CORSIKA Project, corsika-project@lists.kit.edu
+ *
+ * See file AUTHORS for a list of contributors.
+ *
+ * This software is distributed under the terms of the GNU General Public
+ * Licence version 3 (GPL Version 3). See file LICENSE for a full version of
+ * the license.
+ */
+
+#define CATCH_CONFIG_MAIN // This tells Catch to provide a main() - only do this in one
+                          // cpp file
+#include <catch2/catch.hpp>
+
+#include <corsika/process/observation_plane/ObservationPlane.h>
+
+#include <corsika/geometry/Point.h>
+#include <corsika/geometry/RootCoordinateSystem.h>
+#include <corsika/geometry/Vector.h>
+
+#include <corsika/particles/ParticleProperties.h>
+#include <corsika/units/PhysicalUnits.h>
+
+using namespace corsika::units::si;
+using namespace corsika::process::observation_plane;
+using namespace corsika;
+using namespace corsika::geometry;
+using namespace corsika::particles;
+
+TEST_CASE("ContinuousProcess interface", "[proccesses][observation_plane]") {
+
+  auto const& rootCS = RootCoordinateSystem::GetInstance().GetRootCoordinateSystem();
+
+  /*
+    Test with downward going 1_GeV neutrino, starting at 0,1_m,10m
+
+    ObservationPlane has origin at 0,0,0
+   */
+
+  Point const start(rootCS, {0_m, 1_m, 10_m});
+  Vector<units::si::SpeedType::dimension_type> vec(rootCS, 0_m / second, 0_m / second,
+                                                   -units::constants::c);
+  Line line(start, vec);
+  Trajectory<Line> track(line, 10_m / units::constants::c);
+
+  // setup particle stack, and add primary particle
+  setup::Stack stack;
+  stack.Clear();
+  {
+    auto elab2plab = [](HEPEnergyType Elab, HEPMassType m) {
+      return sqrt((Elab - m) * (Elab + m));
+    };
+    stack.AddParticle(
+        std::tuple<Code, units::si::HEPEnergyType, corsika::stack::MomentumVector, Point,
+                   units::si::TimeType>{
+            Code::NuMu, 1_GeV,
+            corsika::stack::MomentumVector(
+                rootCS, {0_GeV, 0_GeV, -elab2plab(1_GeV, NuMu::GetMass())}),
+            Point(rootCS, {1_m, 1_m, 10_m}), 0_ns});
+  }
+  auto particle = stack.GetNextParticle();
+
+  SECTION("horizontal plane") {
+
+    Plane const obsPlane(Point(rootCS, {0_m, 0_m, 0_m}),
+                         Vector<dimensionless_d>(rootCS, {0., 0., 1.}));
+    ObservationPlane obs(obsPlane, "particles.dat");
+
+    obs.Init();
+    [[maybe_unused]] const LengthType length = obs.MaxStepLength(particle, track);
+    [[maybe_unused]] const process::EProcessReturn ret =
+        obs.DoContinuous(particle, track);
+
+    SECTION("steplength") { REQUIRE(length == 10_m); }
+
+    /*
+    SECTION("horizontal plane") {
+      REQUIRE(true); // todo: we have to check content of output file...
+
+    }
+    */
+  }
+
+  SECTION("inclined plane") {
+    Plane const obsPlane(Point(rootCS, {0_m, 0_m, 0_m}),
+                         Vector<dimensionless_d>(rootCS, {1., 1., 0.5}));
+    ObservationPlane obs(obsPlane, "particles.dat");
+
+    obs.Init();
+    [[maybe_unused]] const LengthType length = obs.MaxStepLength(particle, track);
+    [[maybe_unused]] const process::EProcessReturn ret =
+        obs.DoContinuous(particle, track);
+
+    SECTION("steplength") { REQUIRE(length == 12_m); }
+  }
+}