From 3608993219a2945ce42fb82659a4b27be5a00628 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?JulienD=C3=B6rner?= Date: Wed, 28 Aug 2024 08:04:22 +0200 Subject: [PATCH 1/9] add option for saving on interruption --- include/crpropa/ModuleList.h | 6 +++++ src/ModuleList.cpp.in | 43 ++++++++++++++++++++++++++++++++---- 2 files changed, 45 insertions(+), 4 deletions(-) diff --git a/include/crpropa/ModuleList.h b/include/crpropa/ModuleList.h index 38fdf7658..ed8f31b71 100644 --- a/include/crpropa/ModuleList.h +++ b/include/crpropa/ModuleList.h @@ -47,9 +47,15 @@ class ModuleList: public Module { iterator end(); const_iterator end() const; + void setInterruptAction(Module* action); + void dumpCandidate(Candidate* cand) const; + private: module_list_t modules; bool showProgress; + Module* interruptAction; + bool haveInterruptAction = false; + std::vector notFinished; // list with not finished numbers of candidates }; /** diff --git a/src/ModuleList.cpp.in b/src/ModuleList.cpp.in index c28cfd99c..fa77c6c61 100644 --- a/src/ModuleList.cpp.in +++ b/src/ModuleList.cpp.in @@ -87,6 +87,10 @@ void ModuleList::run(Candidate* candidate, bool recursive, bool secondariesFirst run(candidate->secondaries[i], recursive, secondariesFirst); } } + + // dump candidae and secondaries if interrupted. + if (candidate->isActive() && (g_cancel_signal_flag != 0)) + dumpCandidate(candidate); } void ModuleList::run(ref_ptr candidate, bool recursive, bool secondariesFirst) { @@ -114,8 +118,10 @@ void ModuleList::run(const candidate_vector_t *candidates, bool recursive, bool #pragma omp parallel for schedule(OMP_SCHEDULE) for (size_t i = 0; i < count; i++) { - if (g_cancel_signal_flag != 0) + if (g_cancel_signal_flag != 0) { + notFinished.push_back(i); continue; + } try { run(candidates->operator[](i), recursive); @@ -132,8 +138,14 @@ void ModuleList::run(const candidate_vector_t *candidates, bool recursive, bool ::signal(SIGINT, old_sigint_handler); ::signal(SIGTERM, old_sigterm_handler); // Propagate signal to old handler. - if (g_cancel_signal_flag > 0) + if (g_cancel_signal_flag > 0) { raise(g_cancel_signal_flag); + std::cerr << "in total " << notFinished.size() << " Candidates have not been started.\n"; + std::cerr << "this containes the following numbers from the CandidateVector: \n"; + for (size_t i = 0; i < notFinished.size(); i++) + std::cerr << notFinished[i] << ", "; + std::cerr << "\n"; + } } void ModuleList::run(SourceInterface *source, size_t count, bool recursive, bool secondariesFirst) { @@ -156,8 +168,10 @@ void ModuleList::run(SourceInterface *source, size_t count, bool recursive, bool #pragma omp parallel for schedule(OMP_SCHEDULE) for (size_t i = 0; i < count; i++) { - if (g_cancel_signal_flag !=0) + if (g_cancel_signal_flag !=0) { + notFinished.push_back(i); continue; + } ref_ptr candidate; @@ -189,8 +203,10 @@ void ModuleList::run(SourceInterface *source, size_t count, bool recursive, bool ::signal(SIGINT, old_signal_handler); ::signal(SIGTERM, old_sigterm_handler); // Propagate signal to old handler. - if (g_cancel_signal_flag > 0) + if (g_cancel_signal_flag > 0) { raise(g_cancel_signal_flag); + std::cerr << "Number of not started candidates from source: " << notFinished.size() << "\n"; + } } ModuleList::iterator ModuleList::begin() { @@ -222,6 +238,25 @@ void ModuleList::showModules() const { std::cout << getDescription(); } +void ModuleList::setInterruptAction(Module* action) { + interruptAction = action; + haveInterruptAction = true; +} + +void ModuleList::dumpCandidate(Candidate *cand) const { + if (! cand -> isActive()) { + KISS_LOG_WARNING << "Try to dump a candidate which is not active anymore! \n"; + return; + } + if (haveInterruptAction) { + interruptAction -> process(cand); + for (int i = 0; i < cand -> secondaries.size(); i++) { + if (cand -> secondaries[i] -> isActive()) + dumpCandidate(cand -> secondaries[i]); + } + } +} + ModuleListRunner::ModuleListRunner(ModuleList *mlist) : mlist(mlist) { } From bb34f636b211b474bff0c1235a480ae91398523c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?JulienD=C3=B6rner?= Date: Thu, 5 Sep 2024 11:50:51 +0200 Subject: [PATCH 2/9] change interrput action to output type --- include/crpropa/ModuleList.h | 5 ++-- include/crpropa/module/Output.h | 22 ++++++++++++++---- python/2_headers.i | 7 ++++-- src/ModuleList.cpp.in | 41 +++++++++++++++++++++------------ 4 files changed, 52 insertions(+), 23 deletions(-) diff --git a/include/crpropa/ModuleList.h b/include/crpropa/ModuleList.h index ed8f31b71..cf44dfbbb 100644 --- a/include/crpropa/ModuleList.h +++ b/include/crpropa/ModuleList.h @@ -4,6 +4,7 @@ #include "crpropa/Candidate.h" #include "crpropa/Module.h" #include "crpropa/Source.h" +#include "crpropa/module/Output.h" #include #include @@ -47,13 +48,13 @@ class ModuleList: public Module { iterator end(); const_iterator end() const; - void setInterruptAction(Module* action); + void setInterruptAction(Output* action); void dumpCandidate(Candidate* cand) const; private: module_list_t modules; bool showProgress; - Module* interruptAction; + Output* interruptAction; bool haveInterruptAction = false; std::vector notFinished; // list with not finished numbers of candidates }; diff --git a/include/crpropa/module/Output.h b/include/crpropa/module/Output.h index 76b28fc6e..5341a7bfe 100644 --- a/include/crpropa/module/Output.h +++ b/include/crpropa/module/Output.h @@ -52,16 +52,18 @@ namespace crpropa { They can be easily customised by enabling/disabling specific columns. */ class Output: public Module { -protected: - double lengthScale, energyScale; - std::bitset<64> fields; - +public: struct Property { std::string name; std::string comment; Variant defaultValue; }; + +protected: + double lengthScale, energyScale; + std::bitset<64> fields; + std::vector properties; bool oneDimensional; @@ -163,6 +165,18 @@ class Output: public Module { size_t size() const; void process(Candidate *) const; + + /** + * write the indices of not started candidates into the output file. + * Used for interrupting the simulation + * @param indices list of not started indices + */ + virtual void dumpIndexList(std::vector indices) { + std::cout << "indices:\t"; + for (int i = 0; i < indices.size(); i++) + std::cout << indices[i] << ", "; + std::cout << "\n"; + }; }; /** @}*/ diff --git a/python/2_headers.i b/python/2_headers.i index d34665838..2db4540bb 100644 --- a/python/2_headers.i +++ b/python/2_headers.i @@ -279,6 +279,11 @@ %feature("director") crpropa::AbstractCondition; %include "crpropa/Module.h" +%template(OutputRefPtr) crpropa::ref_ptr; +%feature("director") crpropa::Output; +%ignore crpropa::Output::dumpIndexList(std::vector); +%include "crpropa/module/Output.h" + %implicitconv crpropa::ref_ptr; %template(MagneticFieldRefPtr) crpropa::ref_ptr; %feature("director") crpropa::MagneticField; @@ -394,8 +399,6 @@ } } - -%include "crpropa/module/Output.h" %include "crpropa/module/DiffusionSDE.h" %include "crpropa/module/TextOutput.h" %include "crpropa/module/HDF5Output.h" diff --git a/src/ModuleList.cpp.in b/src/ModuleList.cpp.in index fa77c6c61..10bb5f194 100644 --- a/src/ModuleList.cpp.in +++ b/src/ModuleList.cpp.in @@ -8,6 +8,7 @@ #include #include +#include #ifndef sighandler_t typedef void (*sighandler_t)(int); #endif @@ -119,6 +120,7 @@ void ModuleList::run(const candidate_vector_t *candidates, bool recursive, bool #pragma omp parallel for schedule(OMP_SCHEDULE) for (size_t i = 0; i < count; i++) { if (g_cancel_signal_flag != 0) { +#pragma omp critical(interrupt_write) notFinished.push_back(i); continue; } @@ -140,11 +142,15 @@ void ModuleList::run(const candidate_vector_t *candidates, bool recursive, bool // Propagate signal to old handler. if (g_cancel_signal_flag > 0) { raise(g_cancel_signal_flag); - std::cerr << "in total " << notFinished.size() << " Candidates have not been started.\n"; - std::cerr << "this containes the following numbers from the CandidateVector: \n"; - for (size_t i = 0; i < notFinished.size(); i++) - std::cerr << notFinished[i] << ", "; - std::cerr << "\n"; + std::cerr << "############################################################################\n"; + std::cerr << "# Interrupted CRPropa simulation \n"; + std::cerr << "# in total " << notFinished.size() << " Candidates have not been started.\n"; + std::cerr << "# the indicies of the vector haven been written to to output file. \n"; + std::cerr << "############################################################################\n"; + + // dump list to output file + std::sort(notFinished.begin(), notFinished.end()); + interruptAction -> dumpIndexList(notFinished); } } @@ -169,6 +175,7 @@ void ModuleList::run(SourceInterface *source, size_t count, bool recursive, bool #pragma omp parallel for schedule(OMP_SCHEDULE) for (size_t i = 0; i < count; i++) { if (g_cancel_signal_flag !=0) { +#pragma omp critical(interrupt_write) notFinished.push_back(i); continue; } @@ -205,7 +212,10 @@ void ModuleList::run(SourceInterface *source, size_t count, bool recursive, bool // Propagate signal to old handler. if (g_cancel_signal_flag > 0) { raise(g_cancel_signal_flag); - std::cerr << "Number of not started candidates from source: " << notFinished.size() << "\n"; + std::cerr << "############################################################################\n"; + std::cerr << "# Interrupted CRPropa simulation \n"; + std::cerr << "# Number of not started candidates from source: " << notFinished.size() << "\n"; + std::cerr << "############################################################################\n"; } } @@ -238,22 +248,23 @@ void ModuleList::showModules() const { std::cout << getDescription(); } -void ModuleList::setInterruptAction(Module* action) { +void ModuleList::setInterruptAction(Output* action) { interruptAction = action; haveInterruptAction = true; } void ModuleList::dumpCandidate(Candidate *cand) const { - if (! cand -> isActive()) { - KISS_LOG_WARNING << "Try to dump a candidate which is not active anymore! \n"; + if (!haveInterruptAction) return; - } - if (haveInterruptAction) { + + if (cand -> isActive()) interruptAction -> process(cand); - for (int i = 0; i < cand -> secondaries.size(); i++) { - if (cand -> secondaries[i] -> isActive()) - dumpCandidate(cand -> secondaries[i]); - } + else + KISS_LOG_WARNING << "Try to dump a candidate which is not active anymore! \n"; + + for (int i = 0; i < cand -> secondaries.size(); i++) { + if (cand -> secondaries[i]) + dumpCandidate(cand -> secondaries[i]); } } From ee915116c3174fde2645d9546efb002b5eca1b2c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?JulienD=C3=B6rner?= Date: Thu, 5 Sep 2024 11:51:36 +0200 Subject: [PATCH 3/9] add dumping of index list --- include/crpropa/module/TextOutput.h | 2 ++ src/module/TextOutput.cpp | 14 ++++++++++++++ 2 files changed, 16 insertions(+) diff --git a/include/crpropa/module/TextOutput.h b/include/crpropa/module/TextOutput.h index 817fc1c0f..0c21caf43 100644 --- a/include/crpropa/module/TextOutput.h +++ b/include/crpropa/module/TextOutput.h @@ -71,6 +71,8 @@ class TextOutput: public Output { */ static void load(const std::string &filename, ParticleCollector *collector); std::string getDescription() const; + + void dumpIndexList(std::vector indicies); }; /** @}*/ diff --git a/src/module/TextOutput.cpp b/src/module/TextOutput.cpp index e979c85dc..2dda875da 100644 --- a/src/module/TextOutput.cpp +++ b/src/module/TextOutput.cpp @@ -7,6 +7,7 @@ #include "kiss/string.h" +#include #include #include #include @@ -378,4 +379,17 @@ void TextOutput::gzip() { #endif } +void TextOutput::dumpIndexList(std::vector indices) { +#pragma omp critical(FileOutput) + { + std::stringstream ss; + ss << "#" << "\t"; + for (int i = 0; i < indices.size(); i++) + ss << indices[i] << "\t"; + + const std::string cstr = ss.str(); + out-> write(cstr.c_str(), cstr.length()); + } +} + } // namespace crpropa From db8beea1d620f31fd94a215a19680c833f35e04d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?JulienD=C3=B6rner?= Date: Thu, 5 Sep 2024 11:52:00 +0200 Subject: [PATCH 4/9] add example for interrupted simulations --- doc/index.rst | 1 + .../interrupt_candidateVector.ipynb | 394 ++++++++++++++++++ .../interrupt_source.ipynb | 342 +++++++++++++++ doc/pages/interrupting-simulations.rst | 9 + 4 files changed, 746 insertions(+) create mode 100644 doc/pages/example_notebooks/interrupting_simulations/interrupt_candidateVector.ipynb create mode 100644 doc/pages/example_notebooks/interrupting_simulations/interrupt_source.ipynb create mode 100644 doc/pages/interrupting-simulations.rst diff --git a/doc/index.rst b/doc/index.rst index f398dca5b..b989cd1c5 100644 --- a/doc/index.rst +++ b/doc/index.rst @@ -31,6 +31,7 @@ Contents pages/acceleration.rst pages/extending_crpropa.rst pages/example_notebooks/propagation_comparison/Propagation_Comparison_CK_BP.ipynb + pages/interrupting-simulations.rst pages/AdditionalResources.rst diff --git a/doc/pages/example_notebooks/interrupting_simulations/interrupt_candidateVector.ipynb b/doc/pages/example_notebooks/interrupting_simulations/interrupt_candidateVector.ipynb new file mode 100644 index 000000000..8b37e3029 --- /dev/null +++ b/doc/pages/example_notebooks/interrupting_simulations/interrupt_candidateVector.ipynb @@ -0,0 +1,394 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# interrupting and continuing of a simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from crpropa import * \n", + "import numpy as np \n", + "import matplotlib.pyplot\n", + "import os \n", + "from multiprocessing import cpu_count" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## example simulation\n", + "\n", + "\n", + "We test the interruption on the propagation of a spectrum with $E^{-1}$ from a distance of 1 Gpc with 1e7 particles. \n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# create candidate vector with increasing energies\n", + "lg_E_min = 17\n", + "lg_E_max = 21\n", + "lgE = np.random.uniform(lg_E_min, lg_E_max, 100_000)\n", + "lgE.sort()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def init_candidate_vector():\n", + " \"\"\" initilize the candidate vector. Has to be done before every simulation. \"\"\"\n", + " cv = CandidateVector()\n", + " for i, _e in enumerate(lgE): \n", + " c = Candidate(i, 10**_e * eV, Vector3d(1 * Gpc, 0, 0), Vector3d(-1, 0, 0)) \n", + " cv.push_back(CandidateRefPtr(c))\n", + " return cv" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### full simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "crpropa::ModuleList: Number of Threads: 12\n", + "Run ModuleList\n", + " Started Wed Sep 4 16:28:28 2024 : [\u001b[1;32m Finished \u001b[0m] 100% Needed: 00:00:55 - Finished at Wed Sep 4 16:29:23 2024\n", + "\r" + ] + } + ], + "source": [ + "# general setup \n", + "def get_sim(filename):\n", + " \"\"\" returns a modulelist to ensure running the same modules in each case \"\"\"\n", + " \n", + " sim = ModuleList() \n", + " sim.add(SimplePropagation(1 * kpc, 10 * kpc)) # choose small steps to ensure long simulations \n", + "\n", + " obs = Observer() \n", + " obs.add(Observer1D())\n", + " out = TextOutput(filename) \n", + " obs.onDetection(out) \n", + " sim.add(obs)\n", + "\n", + " sim.setShowProgress(True)\n", + " return sim, out\n", + "\n", + "os.makedirs(\"cand_vector\", exist_ok=True)\n", + "sim, out = get_sim(\"cand_vector/full.txt\") \n", + "cv = init_candidate_vector()\n", + "sim.run(cv)\n", + "out.close()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### simulation with interruption" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "crpropa::ModuleList: Number of Threads: 12\n", + "Run ModuleList\n", + " Started Wed Sep 4 16:29:24 2024 : [====> ] 43% Finish in: 00:00:30 \r" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "crpropa::ModuleList: Signal 2 (SIGINT/SIGTERM) received\n", + "############################################################################\n", + "#\tInterrupted CRPropa simulation \n", + "# in total 56959 Candidates have not been started.\n", + "# the indicies of the vector haven been written to to output file. \n", + "############################################################################\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[32], line 8\u001b[0m\n\u001b[1;32m 6\u001b[0m sim\u001b[38;5;241m.\u001b[39msetShowProgress(\u001b[38;5;28;01mTrue\u001b[39;00m) \n\u001b[1;32m 7\u001b[0m cv \u001b[38;5;241m=\u001b[39m init_candidate_vector()\n\u001b[0;32m----> 8\u001b[0m sim\u001b[38;5;241m.\u001b[39mrun(cv)\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "sim, out = get_sim(\"cand_vector/interrupted.txt\")\n", + "\n", + "out_interrupt = TextOutput(\"cand_vector/on_interruption.txt\")\n", + "sim.setInterruptAction(out_interrupt)\n", + "\n", + "sim.setShowProgress(True) \n", + "cv = init_candidate_vector()\n", + "sim.run(cv)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "out.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "number of indices read from file: 56959\n" + ] + } + ], + "source": [ + "# load candidates from interrupted simulation \n", + "\n", + "file = \"cand_vector/on_interruption.txt\"\n", + "pc = ParticleCollector() \n", + "pc.load(file)\n", + "\n", + "# expected size of particles should be equal to the number of cores \n", + "assert pc.size() <= cpu_count() , f\"the number of loaded particles ({pc.size()}) must be lower or equal to the number of cores ({cpu_count()})\"\n", + "\n", + "# load indicies of not started candidates\n", + "with open(file, \"r\") as f: \n", + " line = f.readlines()[-1]\n", + " indices = np.array(line.strip(\"\\n\").split(\"\\t\")[1:-1], dtype= int)\n", + "\n", + "print(\"number of indices read from file:\", len(indices))" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "# create a new candidate vector with the missing particles \n", + "cv_new = pc.getContainer()\n", + "cv = init_candidate_vector()\n", + "for i, c in enumerate(cv): \n", + " if i in indices: \n", + " cv_new.push_back(c)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "crpropa::ModuleList: Number of Threads: 12\n", + "Run ModuleList\n", + " Started Wed Sep 4 16:29:55 2024 : [\u001b[1;32m Finished \u001b[0m] 100% Needed: 00:00:37 - Finished at Wed Sep 4 16:30:32 2024\n", + "\r" + ] + } + ], + "source": [ + "# run the simulation with the missing candidates \n", + "sim, out = get_sim(\"cand_vector/continued.txt\")\n", + "sim.run(cv_new)\n", + "out.close()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# show the data from the different simulations" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd \n", + "import matplotlib.pyplot as plt \n", + "\n", + "def read_crp(filename): \n", + " \"\"\" read a crpropa output file \"\"\"\n", + " \n", + " with open(filename) as f: \n", + " names = f.readline().strip(\"\\n\").split(\"\\t\")[1:]\n", + " \n", + " return pd.read_csv(filename, names = names, delimiter = \"\\t\", comment=\"#\")" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "df_full = read_crp(\"cand_vector/full.txt\")\n", + "df_first_half = read_crp(\"cand_vector/interrupted.txt\")\n", + "df_second_half = read_crp(\"cand_vector/continued.txt\")" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(43030, 56970)" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(df_first_half), len(df_second_half)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "e_bins = np.logspace(-1, 3, 101) # in EeV as default output unit \n", + "dE = np.diff(e_bins) \n", + "\n", + "dNdE_full = np.histogram(df_full.E, bins = e_bins)[0] \n", + "dNdE_first = np.histogram(df_first_half.E, e_bins)[0] \n", + "dNdE_second = np.histogram(df_second_half.E, e_bins)[0]\n", + "assert np.all(dNdE_full == (dNdE_first + dNdE_second))\n", + "\n", + "plt.figure(dpi = 150) \n", + "plt.stairs(dNdE_full, label = \"full simulation\")\n", + "plt.stairs(dNdE_first, label = \"first half\", ls = \"--\")\n", + "plt.stairs(dNdE_second, label = \"second half\", ls = \"--\")\n", + "plt.loglog()\n", + "plt.legend()\n", + "plt.ylabel(\"# particles\")\n", + "plt.xlabel(\"Energy [GeV]\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# check ID number of particles" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "id_list_full = list(df_full.ID)\n", + "id_list_full.sort() \n", + "assert np.all(id_list_full == np.arange(100_000))" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "id_list_continued = list(df_first_half.ID) + list(df_second_half.ID)\n", + "id_list_continued.sort() \n", + "assert np.all(id_list_continued == np.arange(100_000))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "CRP_Interrupt", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/doc/pages/example_notebooks/interrupting_simulations/interrupt_source.ipynb b/doc/pages/example_notebooks/interrupting_simulations/interrupt_source.ipynb new file mode 100644 index 000000000..91069e6db --- /dev/null +++ b/doc/pages/example_notebooks/interrupting_simulations/interrupt_source.ipynb @@ -0,0 +1,342 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# interruption a CRPropa simulation with a source and secondaries" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "from crpropa import * \n", + "import pandas as pd \n", + "import numpy as np \n", + "import matplotlib.pyplot as plt " + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "def read_crp(file): \n", + " with open(file, \"r\") as f: \n", + " names = f.readline().strip(\"\\n\").split(\"\\t\")[1:]\n", + " \n", + " return pd.read_csv(file, delimiter=\"\\t\", comment =\"#\", names = names)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## full simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "crpropa::ModuleList: Number of Threads: 12\n", + "Run ModuleList\n", + " Started Wed Sep 4 16:05:00 2024 : [\u001b[1;32m Finished \u001b[0m] 100% Needed: 00:01:49 - Finished at Wed Sep 4 16:06:49 2024\n", + "\r" + ] + } + ], + "source": [ + "n_sim = int(100)\n", + "\n", + "def get_sim(file):\n", + " sim = ModuleList() \n", + " sim.add(SimplePropagation())\n", + "\n", + " # add EM interactions \n", + " photon_fields = [CMB(), IRB_Gilmore12()]\n", + " for field in photon_fields:\n", + " sim.add(EMInverseComptonScattering(field, True)) # allow photons\n", + " sim.add(EMPairProduction(field, True)) # allow electrons \n", + " sim.add(EMDoublePairProduction(field, True))\n", + " sim.add(EMTripletPairProduction(field, True))\n", + "\n", + " sim.add(MinimumEnergy(10 * GeV))\n", + "\n", + " sub_dir = \"cascade/\"\n", + " out = TextOutput(f\"{sub_dir}/{file}\")\n", + " out.setEnergyScale(TeV)\n", + " obs = Observer() \n", + " obs.add(Observer1D())\n", + " obs.add(ObserverInactiveVeto())\n", + " obs.onDetection(out)\n", + " sim.add(obs) \n", + "\n", + " source = Source() \n", + " source.add(SourceParticleType(22))\n", + " source.add(SourcePosition(Vector3d(50 * Mpc, 0, 0)))\n", + " # source.add(SourcePowerLawSpectrum(1 * TeV, 500 * TeV, -1.5))\n", + " source.add(SourceEnergy(100 * TeV))\n", + "\n", + " sim.setShowProgress(True)\n", + " return source, sim \n", + "\n", + "source, sim = get_sim(\"full.txt\")\n", + "sim.run(source, n_sim)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "# load data \n", + "df_full = read_crp(\"cascade/full.txt\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## interrupted simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "crpropa::ModuleList: Number of Threads: 12\n", + "Run ModuleList\n", + " Started Wed Sep 4 16:12:35 2024 : [=====> ] 58% Finish in: 00:00:44 \r" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "crpropa::ModuleList: Signal 2 (SIGINT/SIGTERM) received\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Started Wed Sep 4 16:12:35 2024 : [=====> ] 58% Finish in: 00:00:43 \r" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "############################################################################\n", + "# Interrupted CRPropa simulation \n", + "# Number of not started candidates from source: 41\n", + "############################################################################\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[55], line 6\u001b[0m\n\u001b[1;32m 3\u001b[0m interrupt_out \u001b[38;5;241m=\u001b[39m TextOutput(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcascade/on_interrupt.txt\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 4\u001b[0m sim\u001b[38;5;241m.\u001b[39msetInterruptAction(interrupt_out)\n\u001b[0;32m----> 6\u001b[0m sim\u001b[38;5;241m.\u001b[39mrun(source, n_sim)\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "source, sim = get_sim(\"interrupt_1.txt\")\n", + "\n", + "interrupt_out = TextOutput(f\"cascade/on_interrupt.txt\")\n", + "sim.setInterruptAction(interrupt_out)\n", + "\n", + "sim.run(source, n_sim)" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "df_1 = read_crp(f\"cascade/interrupt_1.txt\") # at state of interruption" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "crpropa::ModuleList: Number of Threads: 12\n", + "Run ModuleList\n", + " Started Wed Sep 4 16:13:45 2024 : [\u001b[1;32m Finished \u001b[0m] 100% Needed: 00:00:41 - Finished at Wed Sep 4 16:14:26 2024\n", + "\r" + ] + } + ], + "source": [ + "n_missing = 41 # taken from output -> will be different on each try\n", + "\n", + "source, sim = get_sim(\"interrupt_2.txt\")\n", + "sim.run(source, n_missing) # use modulelist and source as previously defined" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "df_2 = read_crp(f\"cascade/interrupt_2.txt\")" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "number of loaded particles: 16527\n", + "crpropa::ModuleList: Number of Threads: 12\n", + "Run ModuleList\n", + " Started Wed Sep 4 16:14:27 2024 : [\u001b[1;32m Finished \u001b[0m] 100% Needed: 00:00:00 - Finished at Wed Sep 4 16:14:27 2024\n", + "\r" + ] + } + ], + "source": [ + "# close outputfile before reading \n", + "interrupt_out.close()\n", + "\n", + "\n", + "pc = ParticleCollector()\n", + "pc.load(\"cascade/on_interrupt.txt\")\n", + "\n", + "print(\"number of loaded particles:\", pc.size())\n", + "\n", + "# run simulation with missing particles\n", + "source, sim = get_sim(\"interrupt_3.txt\")\n", + "sim.run(pc.getContainer())" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [], + "source": [ + "df_3 = read_crp(\"cascade/interrupt_3.txt\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# show spectrum at earth" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "e_bins = np.logspace(-2, 2, 51)\n", + "dE = np.diff(e_bins)\n", + "e_mid = 0.5 * (e_bins[1:] + e_bins[:-1])\n", + "\n", + "get_dnde = lambda df: np.histogram(df[df.ID == 22].E, bins = e_bins)[0]/dE \n", + "\n", + "dNdE_full = get_dnde(df_full)\n", + "dNdE_1 = get_dnde(df_1)\n", + "dNdE_2 = get_dnde(df_2)\n", + "dNdE_3 = get_dnde(df_3) \n", + "\n", + "plt.figure(dpi = 150)\n", + "plt.scatter(e_mid, e_mid**2 * dNdE_full, label = \"full sim\") \n", + "plt.scatter(e_mid, e_mid**2 * dNdE_1, label = \"finished particles\", marker =\"o\",)\n", + "plt.scatter(e_mid, e_mid**2 * dNdE_2, label = \"not startet particles\", marker =\"x\")\n", + "plt.plot(e_mid, e_mid**2 * dNdE_3, label = \"on the fly particles\", fillstyle=\"none\", ls = \"\",marker =\"o\", color = \"tab:red\")\n", + "\n", + "plt.plot(e_mid, e_mid**2 * (dNdE_1 + dNdE_2 + dNdE_3), label =\"total (interrupted)\", color =\"k\")\n", + "\n", + "\n", + "plt.loglog() \n", + "plt.xlabel(r\"$E_\\gamma$ [TeV]\")\n", + "plt.ylabel(r\"$E^2 \\, dN/dE$ [a.u.]\")\n", + "plt.legend(loc = \"lower center\", ncol = 3, bbox_to_anchor=(0.5, 1.))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "CRP_Interrupt", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/doc/pages/interrupting-simulations.rst b/doc/pages/interrupting-simulations.rst new file mode 100644 index 000000000..43b3e35ee --- /dev/null +++ b/doc/pages/interrupting-simulations.rst @@ -0,0 +1,9 @@ +Interrupting simulations on runtime +------------------------------------------------ + +.. toctree:: + + example_notebooks/interrupting_simulations/interrupt_candidateVector.ipynb + example_notebooks/interrupting_simulations/interrupt_source.ipynb + + From 1730399aa0e88caab8d12616971c64a157e1b3ca Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?JulienD=C3=B6rner?= Date: Thu, 5 Sep 2024 14:12:48 +0200 Subject: [PATCH 5/9] add more details in the interrupt examle --- .../interrupt_candidateVector.ipynb | 166 +++++++++--------- .../interrupt_source.ipynb | 119 +++++++------ doc/pages/interrupting-simulations.rst | 13 +- 3 files changed, 162 insertions(+), 136 deletions(-) diff --git a/doc/pages/example_notebooks/interrupting_simulations/interrupt_candidateVector.ipynb b/doc/pages/example_notebooks/interrupting_simulations/interrupt_candidateVector.ipynb index 8b37e3029..bd6f3b447 100644 --- a/doc/pages/example_notebooks/interrupting_simulations/interrupt_candidateVector.ipynb +++ b/doc/pages/example_notebooks/interrupting_simulations/interrupt_candidateVector.ipynb @@ -4,18 +4,21 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# interrupting and continuing of a simulation" + "# interrupting and continuing of a simulation with a candidate Vector\n", + "\n", + "In this example the simulation uses a `candidateVector`, a predefined set of candidates, as source. The test simulation is a simple 1D propagation of particles in the energy range of $10^{17} eV$ to $10^{21} eV$. The candidates are order in energy, for an easier overview of the state of the simulation. No other propagation effects are considered. \n", + "\n", + "Two sets of simulation, one full simulation and one which is interrupted and continued, are compared. The candidate ID will be used as continues number to check, that all candidates are reaching the final observer and nothing is lost. " ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from crpropa import * \n", "import numpy as np \n", - "import matplotlib.pyplot\n", "import os \n", "from multiprocessing import cpu_count" ] @@ -24,12 +27,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## example simulation\n", + "## simulation setup\n", "\n", - "\n", - "We test the interruption on the propagation of a spectrum with $E^{-1}$ from a distance of 1 Gpc with 1e7 particles. \n", - "\n", - "\n" + "The candidate energies are the same for both simulation cases (with / without interrupting). " ] }, { @@ -64,12 +64,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### full simulation" + "### full simulation (no interruption)" ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -78,7 +78,7 @@ "text": [ "crpropa::ModuleList: Number of Threads: 12\n", "Run ModuleList\n", - " Started Wed Sep 4 16:28:28 2024 : [\u001b[1;32m Finished \u001b[0m] 100% Needed: 00:00:55 - Finished at Wed Sep 4 16:29:23 2024\n", + " Started Thu Sep 5 12:28:34 2024 : [\u001b[1;32m Finished \u001b[0m] 100% Needed: 00:00:48 - Finished at Thu Sep 5 12:29:22 2024\n", "\r" ] } @@ -111,12 +111,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### simulation with interruption" + "### simulation with interruption\n", + "\n", + "This simulation is interrupted after some time. This process has to be done manually." ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -125,7 +127,7 @@ "text": [ "crpropa::ModuleList: Number of Threads: 12\n", "Run ModuleList\n", - " Started Wed Sep 4 16:29:24 2024 : [====> ] 43% Finish in: 00:00:30 \r" + " Started Thu Sep 5 12:29:26 2024 : [====> ] 41% Finish in: 00:00:28 \r" ] }, { @@ -135,7 +137,7 @@ "crpropa::ModuleList: Signal 2 (SIGINT/SIGTERM) received\n", "############################################################################\n", "#\tInterrupted CRPropa simulation \n", - "# in total 56959 Candidates have not been started.\n", + "# in total 58477 Candidates have not been started.\n", "# the indicies of the vector haven been written to to output file. \n", "############################################################################\n" ] @@ -147,7 +149,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[32], line 8\u001b[0m\n\u001b[1;32m 6\u001b[0m sim\u001b[38;5;241m.\u001b[39msetShowProgress(\u001b[38;5;28;01mTrue\u001b[39;00m) \n\u001b[1;32m 7\u001b[0m cv \u001b[38;5;241m=\u001b[39m init_candidate_vector()\n\u001b[0;32m----> 8\u001b[0m sim\u001b[38;5;241m.\u001b[39mrun(cv)\n", + "Cell \u001b[0;32mIn[5], line 8\u001b[0m\n\u001b[1;32m 6\u001b[0m sim\u001b[38;5;241m.\u001b[39msetShowProgress(\u001b[38;5;28;01mTrue\u001b[39;00m) \n\u001b[1;32m 7\u001b[0m cv \u001b[38;5;241m=\u001b[39m init_candidate_vector()\n\u001b[0;32m----> 8\u001b[0m sim\u001b[38;5;241m.\u001b[39mrun(cv)\n", "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } @@ -165,23 +167,30 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ - "out.close()" + "out.close() # closing the output file to avoid data loss " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### reloading and reruning the simulation" ] }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "number of indices read from file: 56959\n" + "number of indices read from file: 58477\n" ] } ], @@ -205,7 +214,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -214,13 +223,13 @@ "cv = init_candidate_vector()\n", "for i, c in enumerate(cv): \n", " if i in indices: \n", - " cv_new.push_back(c)\n", - " " + " # accept candidates which were not started\n", + " cv_new.push_back(c)" ] }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -229,7 +238,7 @@ "text": [ "crpropa::ModuleList: Number of Threads: 12\n", "Run ModuleList\n", - " Started Wed Sep 4 16:29:55 2024 : [\u001b[1;32m Finished \u001b[0m] 100% Needed: 00:00:37 - Finished at Wed Sep 4 16:30:32 2024\n", + " Started Thu Sep 5 12:30:00 2024 : [\u001b[1;32m Finished \u001b[0m] 100% Needed: 00:00:30 - Finished at Thu Sep 5 12:30:30 2024\n", "\r" ] } @@ -245,12 +254,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# show the data from the different simulations" + "## read data from different simulations\n", + "\n", + "The data from both simulation sets are loaded and compared" ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -268,43 +279,70 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "the splited simulation has the length of 41518 and 58482\n" + ] + } + ], "source": [ "df_full = read_crp(\"cand_vector/full.txt\")\n", "df_first_half = read_crp(\"cand_vector/interrupted.txt\")\n", - "df_second_half = read_crp(\"cand_vector/continued.txt\")" + "df_second_half = read_crp(\"cand_vector/continued.txt\")\n", + "print(f\"the splited simulation has the length of {len(df_first_half)} and {len(df_second_half)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### check ID number of particles \n", + "\n", + "Checking that both simulation outputs contain all particles. The particle ID is the number of the particles in the orignial candidate vector." ] }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 12, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(43030, 56970)" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "len(df_first_half), len(df_second_half)" + "id_list_full = list(df_full.ID)\n", + "id_list_full.sort() \n", + "assert np.all(id_list_full == np.arange(100_000))" ] }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "id_list_continued = list(df_first_half.ID) + list(df_second_half.ID)\n", + "id_list_continued.sort() \n", + "assert np.all(id_list_continued == np.arange(100_000))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### energy distribution of the arriving particles" + ] + }, + { + "cell_type": "code", + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -332,42 +370,6 @@ "plt.xlabel(\"Energy [GeV]\")\n", "plt.show()" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# check ID number of particles" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [], - "source": [ - "id_list_full = list(df_full.ID)\n", - "id_list_full.sort() \n", - "assert np.all(id_list_full == np.arange(100_000))" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [], - "source": [ - "id_list_continued = list(df_first_half.ID) + list(df_second_half.ID)\n", - "id_list_continued.sort() \n", - "assert np.all(id_list_continued == np.arange(100_000))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/doc/pages/example_notebooks/interrupting_simulations/interrupt_source.ipynb b/doc/pages/example_notebooks/interrupting_simulations/interrupt_source.ipynb index 91069e6db..079967089 100644 --- a/doc/pages/example_notebooks/interrupting_simulations/interrupt_source.ipynb +++ b/doc/pages/example_notebooks/interrupting_simulations/interrupt_source.ipynb @@ -4,24 +4,33 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# interruption a CRPropa simulation with a source and secondaries" + "# interrupting and continuing of a simulation with a source\n", + "\n", + "In this example the simulation uses a `sourceInterface` and allows for the production of secondaries.\n", + "\n", + "The source emmits a limited number of photons ($n = 100$) with an energy $E = 100 \\, \\mathrm{TeV}$ at a distance of $D = 50 \\, \\mathrm{Mpc}$. The photons are propagated in 1D to the observer, taking interactions with the CMB and EBL into account. \n", + "\n", + "The interrupted simulation contains three different parts: (1) the candidates arriving at the observer before the simulation is interrupted, (2) the candidates which are in the simulation at the point of interruption and (3) the particles which have not been started before the interruption. In the case of secondaries the number of particles which are contained in the simulation is much larger than the number of cores. \n", + "\n", + "In the end, the SED of the arriving photons is compared. Small differences between the full and the interrupted simulation are expected due to the Monte-Carlo nature of the interactions. " ] }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from crpropa import * \n", "import pandas as pd \n", "import numpy as np \n", - "import matplotlib.pyplot as plt " + "import matplotlib.pyplot as plt \n", + "import os " ] }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -41,7 +50,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -50,7 +59,7 @@ "text": [ "crpropa::ModuleList: Number of Threads: 12\n", "Run ModuleList\n", - " Started Wed Sep 4 16:05:00 2024 : [\u001b[1;32m Finished \u001b[0m] 100% Needed: 00:01:49 - Finished at Wed Sep 4 16:06:49 2024\n", + " Started Thu Sep 5 14:07:59 2024 : [\u001b[1;32m Finished \u001b[0m] 100% Needed: 00:01:39 - Finished at Thu Sep 5 14:09:38 2024\n", "\r" ] } @@ -73,6 +82,7 @@ " sim.add(MinimumEnergy(10 * GeV))\n", "\n", " sub_dir = \"cascade/\"\n", + " os.makedirs(sub_dir, exist_ok=True)\n", " out = TextOutput(f\"{sub_dir}/{file}\")\n", " out.setEnergyScale(TeV)\n", " obs = Observer() \n", @@ -84,19 +94,19 @@ " source = Source() \n", " source.add(SourceParticleType(22))\n", " source.add(SourcePosition(Vector3d(50 * Mpc, 0, 0)))\n", - " # source.add(SourcePowerLawSpectrum(1 * TeV, 500 * TeV, -1.5))\n", " source.add(SourceEnergy(100 * TeV))\n", "\n", " sim.setShowProgress(True)\n", - " return source, sim \n", + " return source, sim, out\n", "\n", - "source, sim = get_sim(\"full.txt\")\n", - "sim.run(source, n_sim)" + "source, sim, out = get_sim(\"full.txt\")\n", + "sim.run(source, n_sim)\n", + "out.close()" ] }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -113,7 +123,7 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -122,7 +132,7 @@ "text": [ "crpropa::ModuleList: Number of Threads: 12\n", "Run ModuleList\n", - " Started Wed Sep 4 16:12:35 2024 : [=====> ] 58% Finish in: 00:00:44 \r" + " Started Thu Sep 5 14:09:39 2024 : [===> ] 30% Finish in: 00:01:07 \r" ] }, { @@ -136,7 +146,7 @@ "name": "stdout", "output_type": "stream", "text": [ - " Started Wed Sep 4 16:12:35 2024 : [=====> ] 58% Finish in: 00:00:43 \r" + " Started Thu Sep 5 14:09:39 2024 : [===> ] 31% Finish in: 00:01:11 \r" ] }, { @@ -145,7 +155,7 @@ "text": [ "############################################################################\n", "# Interrupted CRPropa simulation \n", - "# Number of not started candidates from source: 41\n", + "# Number of not started candidates from source: 69\n", "############################################################################\n" ] }, @@ -156,13 +166,13 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[55], line 6\u001b[0m\n\u001b[1;32m 3\u001b[0m interrupt_out \u001b[38;5;241m=\u001b[39m TextOutput(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcascade/on_interrupt.txt\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 4\u001b[0m sim\u001b[38;5;241m.\u001b[39msetInterruptAction(interrupt_out)\n\u001b[0;32m----> 6\u001b[0m sim\u001b[38;5;241m.\u001b[39mrun(source, n_sim)\n", + "Cell \u001b[0;32mIn[5], line 6\u001b[0m\n\u001b[1;32m 3\u001b[0m interrupt_out \u001b[38;5;241m=\u001b[39m TextOutput(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcascade/on_interrupt.txt\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 4\u001b[0m sim\u001b[38;5;241m.\u001b[39msetInterruptAction(interrupt_out)\n\u001b[0;32m----> 6\u001b[0m sim\u001b[38;5;241m.\u001b[39mrun(source, n_sim)\n", "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } ], "source": [ - "source, sim = get_sim(\"interrupt_1.txt\")\n", + "source, sim, out = get_sim(\"interrupt_1.txt\")\n", "\n", "interrupt_out = TextOutput(f\"cascade/on_interrupt.txt\")\n", "sim.setInterruptAction(interrupt_out)\n", @@ -172,7 +182,17 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# close datafile to avoid data loss\n", + "out.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -181,7 +201,7 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -190,21 +210,22 @@ "text": [ "crpropa::ModuleList: Number of Threads: 12\n", "Run ModuleList\n", - " Started Wed Sep 4 16:13:45 2024 : [\u001b[1;32m Finished \u001b[0m] 100% Needed: 00:00:41 - Finished at Wed Sep 4 16:14:26 2024\n", + " Started Thu Sep 5 14:10:30 2024 : [\u001b[1;32m Finished \u001b[0m] 100% Needed: 00:01:08 - Finished at Thu Sep 5 14:11:38 2024\n", "\r" ] } ], "source": [ - "n_missing = 41 # taken from output -> will be different on each try\n", + "n_missing = 69 # taken from output -> will be different on each try\n", "\n", - "source, sim = get_sim(\"interrupt_2.txt\")\n", - "sim.run(source, n_missing) # use modulelist and source as previously defined" + "source, sim, out = get_sim(\"interrupt_2.txt\")\n", + "sim.run(source, n_missing) # use modulelist and source as previously defined\n", + "out.close()" ] }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -213,17 +234,17 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "number of loaded particles: 16527\n", + "number of loaded particles: 5690\n", "crpropa::ModuleList: Number of Threads: 12\n", "Run ModuleList\n", - " Started Wed Sep 4 16:14:27 2024 : [\u001b[1;32m Finished \u001b[0m] 100% Needed: 00:00:00 - Finished at Wed Sep 4 16:14:27 2024\n", + " Started Thu Sep 5 14:11:38 2024 : [\u001b[1;32m Finished \u001b[0m] 100% Needed: 00:00:00 - Finished at Thu Sep 5 14:11:38 2024\n", "\r" ] } @@ -232,41 +253,47 @@ "# close outputfile before reading \n", "interrupt_out.close()\n", "\n", - "\n", "pc = ParticleCollector()\n", "pc.load(\"cascade/on_interrupt.txt\")\n", "\n", "print(\"number of loaded particles:\", pc.size())\n", "\n", "# run simulation with missing particles\n", - "source, sim = get_sim(\"interrupt_3.txt\")\n", - "sim.run(pc.getContainer())" + "source, sim, out = get_sim(\"interrupt_3.txt\")\n", + "sim.run(pc.getContainer())\n", + "out.close()" ] }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ - "df_3 = read_crp(\"cascade/interrupt_3.txt\")" + "try:\n", + " df_3 = read_crp(\"cascade/interrupt_3.txt\")\n", + "except: \n", + " # it can happen that all particles from the interruption time are cascaded to lower energies than the minimum energy\n", + " # in this case the dataset will be empty\n", + " print(\"no data from interrupt_3.txt\")\n", + " df_3 = pd.DataFrame({\"E\":[], \"ID\":[]})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# show spectrum at earth" + "## show spectrum at earth" ] }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -288,10 +315,10 @@ "dNdE_3 = get_dnde(df_3) \n", "\n", "plt.figure(dpi = 150)\n", - "plt.scatter(e_mid, e_mid**2 * dNdE_full, label = \"full sim\") \n", - "plt.scatter(e_mid, e_mid**2 * dNdE_1, label = \"finished particles\", marker =\"o\",)\n", - "plt.scatter(e_mid, e_mid**2 * dNdE_2, label = \"not startet particles\", marker =\"x\")\n", - "plt.plot(e_mid, e_mid**2 * dNdE_3, label = \"on the fly particles\", fillstyle=\"none\", ls = \"\",marker =\"o\", color = \"tab:red\")\n", + "plt.scatter(e_mid, e_mid**2 * dNdE_full, label = \"full sim\", color = \"tab:green\") \n", + "plt.plot(e_mid, e_mid**2 * dNdE_1, label = \"finished particles\", marker =\"s\", ls = \"\", fillstyle=\"none\")\n", + "plt.plot(e_mid, e_mid**2 * dNdE_2, label = \"not startet particles\", marker =\"x\", ls = \"\", )\n", + "plt.plot(e_mid, e_mid**2 * dNdE_3, label = \"on the fly particles\", fillstyle=\"none\", ls = \"\",marker =\"d\", color = \"tab:red\")\n", "\n", "plt.plot(e_mid, e_mid**2 * (dNdE_1 + dNdE_2 + dNdE_3), label =\"total (interrupted)\", color =\"k\")\n", "\n", @@ -302,20 +329,6 @@ "plt.legend(loc = \"lower center\", ncol = 3, bbox_to_anchor=(0.5, 1.))\n", "plt.show()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/doc/pages/interrupting-simulations.rst b/doc/pages/interrupting-simulations.rst index 43b3e35ee..df58efb19 100644 --- a/doc/pages/interrupting-simulations.rst +++ b/doc/pages/interrupting-simulations.rst @@ -1,9 +1,20 @@ Interrupting simulations on runtime ------------------------------------------------ -.. toctree:: +CRPropa simulations can be interrupted on runtime with the `SIGTERM` or `SIGINT` signals. +If the user defines an output for the interruption (called `InterruptAction`) all candidates which are currently in the simulation will be passed to this output. +In the error stream the user will see a message denoting the number of candidates which have not been started yet. +If the simulation was run with a `candidateVector` as source, the indices of the candidates which have not been started yet will be printed or written to the file. +For a simulation with a source interface, a restart with the missing number of candidates will be sufficient to continue the simulation. +.. toctree:: + :caption: Using a candidateVector as source + :maxdepth: 0 example_notebooks/interrupting_simulations/interrupt_candidateVector.ipynb + +.. toctree:: + :caption: Using a source interface + :maxdepth: 0 example_notebooks/interrupting_simulations/interrupt_source.ipynb From 2b7a4d18238c914860d1d7e68dab3c169ce6b767 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?JulienD=C3=B6rner?= Date: Thu, 5 Sep 2024 14:37:53 +0200 Subject: [PATCH 6/9] update depth --- doc/pages/interrupting-simulations.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/pages/interrupting-simulations.rst b/doc/pages/interrupting-simulations.rst index df58efb19..e43dca1b1 100644 --- a/doc/pages/interrupting-simulations.rst +++ b/doc/pages/interrupting-simulations.rst @@ -9,12 +9,12 @@ For a simulation with a source interface, a restart with the missing number of c .. toctree:: :caption: Using a candidateVector as source - :maxdepth: 0 + :maxdepth: 1 example_notebooks/interrupting_simulations/interrupt_candidateVector.ipynb .. toctree:: :caption: Using a source interface - :maxdepth: 0 + :maxdepth: 1 example_notebooks/interrupting_simulations/interrupt_source.ipynb From 0b2bd13852d339c804df4c5d4a4f110850d06c0f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?JulienD=C3=B6rner?= Date: Thu, 5 Sep 2024 16:11:37 +0200 Subject: [PATCH 7/9] exclude interrupt examples from testing --- .github/workflows/test_examples.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/test_examples.yml b/.github/workflows/test_examples.yml index 67d49fd4c..62ae5a09a 100644 --- a/.github/workflows/test_examples.yml +++ b/.github/workflows/test_examples.yml @@ -67,6 +67,8 @@ jobs: [ "$file" = "MHD_modelsipynb.py" ] || [ "$file" = "density_grid_samplingipynb.py" ] || [ "$file" = "lensing_crv4ipynb.py" ] || + [ "$file" = "interrupt_candidateVectoripynb.py" ] || + [ "$file" = "interrupt_sourceipynb.py" ] || [ "$file" = "lensing_mapsv4ipynb.py" ]; then echo "skip file $file" else From d9cca5bc230eea59d04672c2b78ea64f31f17fd6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?JulienD=C3=B6rner?= Date: Thu, 5 Sep 2024 16:14:55 +0200 Subject: [PATCH 8/9] fix whitespace --- doc/pages/interrupting-simulations.rst | 2 ++ 1 file changed, 2 insertions(+) diff --git a/doc/pages/interrupting-simulations.rst b/doc/pages/interrupting-simulations.rst index e43dca1b1..88b62c4cb 100644 --- a/doc/pages/interrupting-simulations.rst +++ b/doc/pages/interrupting-simulations.rst @@ -10,11 +10,13 @@ For a simulation with a source interface, a restart with the missing number of c .. toctree:: :caption: Using a candidateVector as source :maxdepth: 1 + example_notebooks/interrupting_simulations/interrupt_candidateVector.ipynb .. toctree:: :caption: Using a source interface :maxdepth: 1 + example_notebooks/interrupting_simulations/interrupt_source.ipynb From c8c550883833b48ac0de91b4ae0432108a72cf10 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?JulienD=C3=B6rner?= Date: Mon, 9 Sep 2024 08:22:02 +0200 Subject: [PATCH 9/9] apply code convention --- src/ModuleList.cpp.in | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/src/ModuleList.cpp.in b/src/ModuleList.cpp.in index 10bb5f194..3d96f6416 100644 --- a/src/ModuleList.cpp.in +++ b/src/ModuleList.cpp.in @@ -144,13 +144,13 @@ void ModuleList::run(const candidate_vector_t *candidates, bool recursive, bool raise(g_cancel_signal_flag); std::cerr << "############################################################################\n"; std::cerr << "# Interrupted CRPropa simulation \n"; - std::cerr << "# in total " << notFinished.size() << " Candidates have not been started.\n"; + std::cerr << "# A total of " << notFinished.size() << " candidates have not been started.\n"; std::cerr << "# the indicies of the vector haven been written to to output file. \n"; std::cerr << "############################################################################\n"; // dump list to output file std::sort(notFinished.begin(), notFinished.end()); - interruptAction -> dumpIndexList(notFinished); + interruptAction->dumpIndexList(notFinished); } } @@ -257,14 +257,15 @@ void ModuleList::dumpCandidate(Candidate *cand) const { if (!haveInterruptAction) return; - if (cand -> isActive()) - interruptAction -> process(cand); + if (cand->isActive()) + interruptAction->process(cand); else - KISS_LOG_WARNING << "Try to dump a candidate which is not active anymore! \n"; + KISS_LOG_WARNING << "ModuleList::dumpCandidate is called with a non active candidate. This should not happen for the interrupt action. Please check candidate with serieal number " + << cand->getSerialNumber() << std::endl; - for (int i = 0; i < cand -> secondaries.size(); i++) { - if (cand -> secondaries[i]) - dumpCandidate(cand -> secondaries[i]); + for (int i = 0; i < cand->secondaries.size(); i++) { + if (cand->secondaries[i]) + dumpCandidate(cand->secondaries[i]); } }