From 5340ed5a14f6aa1cc53a33e4cdb99c0eb8d8e00b Mon Sep 17 00:00:00 2001 From: Julien Date: Thu, 7 Dec 2023 15:22:52 +0100 Subject: [PATCH 1/8] add workflow to create documentation --- .github/workflows/create_documentation.yml | 71 ++++++++++++++++++++++ 1 file changed, 71 insertions(+) create mode 100644 .github/workflows/create_documentation.yml diff --git a/.github/workflows/create_documentation.yml b/.github/workflows/create_documentation.yml new file mode 100644 index 000000000..7372c46ec --- /dev/null +++ b/.github/workflows/create_documentation.yml @@ -0,0 +1,71 @@ +name: create-documentation +on: [workflow_dispatch] + +jobs: + create-documentation: + runs-on: ubuntu-latest + + strategy: + fail-fast: false + matrix: + config: + - name: "ubuntu-20" + os: ubuntu-20.04 + cxx: "g++-9" + cc: "gcc-9" + fc: "gfortran-9" + swig_builtin: "Off" #uses swig 4.0.1 + + # define steps to take + steps: + - name: Checkout repository + uses: actions/checkout@v3 + - name: Python install + uses: actions/setup-python@v4 + with: + python-version: '3.9' + cache: 'pip' # caching pip dependencies + - name: Prerequirements + run: | + sudo apt-get update + sudo apt-get install libmuparser-dev libhdf5-serial-dev libomp5 libomp-dev libfftw3-dev libcfitsio-dev lcov doxygen graphviz + sudo apt-get install pandoc # do not only use pip to install pandoc, see https://stackoverflow.com/questions/62398231/building-docs-fails-due-to-missing-pandoc + pip install -r doc/pages/example_notebooks/requirements.txt # load requrements for notebooks + pip install sphinx sphinx_rtd_theme m2r2 nbsphinx breathe pandoc exhale # load requirements for documentation + - name: Set up the build + env: + CXX: ${{ matrix.config.cxx }} + CC: ${{ matrix.config.cc }} + FC: ${{ matrix.config.fc }} + run: | + mkdir build + cd build + cmake .. -DCMAKE_INSTALL_PREFIX=$HOME/.local \ + -DENABLE_PYTHON=True -DENABLE_TESTING=ON -DENABLE_SWIG_BUILTIN=${{ matrix.config.swig_builtin }} \ + -DSIMD_EXTENSIONS=native -DBUILD_DOC=True -DENABLE_COVERAGE=True + - name: Build CRPropa + run: | + cd build + make -j + - name: run test + run: | + cd build + make test + continue-on-error: true + - name: coverage report + run: | + cd build + make coverage + tar -zcvf coverage.tar.gz coverageReport + - name: build documentation + run: | + cd build + make doc + tar -zcvf documentation.tar.gz doc + - name: archive documentation + uses: actions/upload-artifact@v3 + with: + name: "documentation" + path: | + build/documentation.tar.gz + build/coverage.tar.gz From b93746fdc9a27f941c2d8c86f7a1c6b5da6634a4 Mon Sep 17 00:00:00 2001 From: JulienDoerner Date: Tue, 9 Jan 2024 08:09:27 +0100 Subject: [PATCH 2/8] add test for examples --- .github/workflows/test_examples.yml | 77 +++++++++++++++++++++++++++++ 1 file changed, 77 insertions(+) create mode 100644 .github/workflows/test_examples.yml diff --git a/.github/workflows/test_examples.yml b/.github/workflows/test_examples.yml new file mode 100644 index 000000000..d03d888c8 --- /dev/null +++ b/.github/workflows/test_examples.yml @@ -0,0 +1,77 @@ +name: crpropa-example-test +on: [push, pull_request] + +jobs: + linux: + runs-on: ${{ matrix.config.os }} + strategy: + fail-fast: false + matrix: + config: + - name: "ubuntu-20" + os: ubuntu-20.04 + cxx: "g++-9" + cc: "gcc-9" + fc: "gfortran-9" + swig_builtin: "Off" #uses swig 4.0.1 + py: "/usr/bin/python3" #python 3.8 + steps: + - name: Checkout repository + uses: actions/checkout@v3 + - name: Preinstall + run: | + sudo apt-get update + sudo apt-get install libmuparser-dev python3-dev python-dev python3-numpy python-numpy python3-setuptools python-setuptools libhdf5-serial-dev libomp5 libomp-dev libfftw3-dev libcfitsio-dev lcov + pip3 install -r doc/pages/example_notebooks/requirements.txt # load requrements for notebooks + pip3 install --upgrade Pygments + pip3 install --upgrade numpy + - name: Set up the build + env: + CXX: ${{ matrix.config.cxx }} + CC: ${{ matrix.config.cc }} + FC: ${{ matrix.config.fc }} + run: | + mkdir build + cd build + cmake .. -DCMAKE_INSTALL_PREFIX=$HOME/.local -DENABLE_PYTHON=True -DPYTHON_EXECUTABLE=${{ matrix.config.py }} -DENABLE_TESTING=Off -DENABLE_SWIG_BUILTIN=${{ matrix.config.swig_builtin }} -DSIMD_EXTENSIONS=native + - name: Build CRPropa + run: | + cd build + make install -j + - name: convert notebooks to python + env: + PYTHONPATH: "/home/runner/.local/lib/python3.8/site-packages/" + runfolder: "/home/runner/notebook_run" + run: | + mkdir "$runfolder" + cd doc/pages/example_notebooks/ + for file in */*.ipynb; do + echo "$file" + if [ -f "$file" ]; then + f=(${file//// }) + f=${f[1]} + f=(${f//./}) + finalFile="$runfolder"/"$f".py + echo "convert notebook $file to script $finalFile" + jupyter nbconvert --to python "$file" --stdout | grep -v -e "^get_ipython" > "$runfolder"/"$f".py + fi + done + - name: run all python scripts + env: + PYTHONPATH: "$/home/runner/.local/lib/python3.8/site-packages/" + runfolder: "/home/runner/notebook_run" + run: | + cp doc/pages/example_notebooks/galactic_lensing/crpropa_output.txt "$runfolder"/ + cd "$runfolder" + for file in *.py; do + if [ "$file" = "custom-photon-fieldipynb.py" ] || + [ "$file" = "MHD_modelsipynb.py" ] || + [ "$file" = "density_grid_samplingipynb.py" ] || + [ "$file" = "lensing_crv4ipynb.py" ] || + [ "$file" = "lensing_mapsv4ipynb.py" ]; then + echo "skip file $file" + else + echo "run file $file" + python3 $file + fi + done From e140b902b8e3b58a6c99c8226a5be64b9335aba2 Mon Sep 17 00:00:00 2001 From: JulienDoerner Date: Tue, 9 Jan 2024 08:10:45 +0100 Subject: [PATCH 3/8] remove photon propagation with DINT and ELECA from examples --- .../secondaries/photons.ipynb | 288 ------------------ 1 file changed, 288 deletions(-) diff --git a/doc/pages/example_notebooks/secondaries/photons.ipynb b/doc/pages/example_notebooks/secondaries/photons.ipynb index 59814e3e4..529d4b85a 100644 --- a/doc/pages/example_notebooks/secondaries/photons.ipynb +++ b/doc/pages/example_notebooks/secondaries/photons.ipynb @@ -123,294 +123,6 @@ "ylabel(\"Number of Particles\")\n", "show()" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Photon Propagation outside of CRPropa with EleCa and DINT\n", - "\n", - "There are two main ways to propagate electromagnetic particles (EM particles: photons, electrons, positrons) in CRPropa:\n", - "\n", - "1) propagation as part of the CRPropa simulation chain\n", - "\n", - "2) propagation outside of the CRPropa simulation chain\n", - "\n", - "The following describes option 2, for which CRPropa provides three functions.\n", - "EM particles can either be propagated individually using the external EleCa code (suitable for high energies), or their spectra can be propagated with the transport code DINT (suitable for low energies).\n", - "Alternatively, a combined option is available that processes high energy photons with Eleca and then calculates the resulting spectra with DINT down to low energies.\n", - "\n", - "All three functions take as input a plain-text file with EM particles in the format given in the \"Photons from Proton Propagation\" example below.\n", - "In the following examples the input file \"photon_monoenergetic_source.dat\" contains 1000 photons with E = 50 EeV from a photon source at 4 Mpc distance.\n", - "\n", - "The last example \"Photons from Proton Propagation\" shows how to obtain secondary EM particles from a simulation of hadronic cosmic rays.\n", - "\n", - "Note that the differing results in EleCa (and correspondingly the high energy part of the combined option) are due to an incorrect sampling of the background photon energies in EleCa. The EleCa support will be removed in the near future.\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Photons from Proton Propagation\n", - "\n", - "The generation of photons has to be enabled for the individual energy-loss processes in the module chain. Also, separate photon output can be added:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "crpropa::ModuleList: Number of Threads: 8\n" - ] - } - ], - "source": [ - "from crpropa import *\n", - "\n", - "# source setup\n", - "source = Source()\n", - "source.add(SourceParticleType(nucleusId(1, 1)))\n", - "source.add(SourcePowerLawSpectrum(10 * EeV, 100 * EeV, -2))\n", - "source.add(SourceUniform1D(3 * Mpc, 100.00001 * Mpc))\n", - "\n", - "# setup module list for proton propagation\n", - "m = ModuleList()\n", - "m.add(SimplePropagation(0, 10 * Mpc))\n", - "m.add(MinimumEnergy(1 * EeV))\n", - "\n", - "# observer\n", - "obs1 = Observer() # proton output\n", - "obs1.add( Observer1D() )\n", - "obs1.add( ObserverPhotonVeto() ) # we don't want photons here\n", - "obs1.onDetection( TextOutput('proton_output.txt', Output.Event1D) )\n", - "m.add(obs1)\n", - "obs2 = Observer() # photon output\n", - "obs2.add( ObserverDetectAll() ) # stores the photons at creation without propagating them\n", - "obs2.add( ObserverNucleusVeto() ) # we don't want hadrons here\n", - "out2 = TextOutput('photon_output.txt', Output.Event1D)\n", - "out2.enable(Output.CreatedIdColumn) # enables the necessary columns to be compatible with the DINT and EleCa propagation\n", - "out2.enable(Output.CreatedEnergyColumn)\n", - "out2.enable(Output.CreatedPositionColumn)\n", - "out2.disable(Output.CandidateTagColumn)\n", - "obs2.onDetection( out2 )\n", - "m.add(obs2)\n", - "\n", - "# secondary electrons are disabled here\n", - "m.add(ElectronPairProduction(CMB(), False))\n", - "# enable secondary photons\n", - "m.add(PhotoPionProduction(CMB(), True))\n", - "\n", - "# run simulation\n", - "m.run(source, 10000, True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The file 'photon_output.txt' will contain approximately 300 photons and can be processed as the photon example below." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Propagation with EleCa\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "jupyter": { - "outputs_hidden": true - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2023-02-02 13:46:17 [WARNING] EleCa propagation is deprecated and is no longer supported. Please use the EM* (EMPairProduction, EMInverseComptonScattering, ...) modules instead.\n", - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Run ElecaPropagation\n", - " Started Thu Feb 2 13:46:17 2023 : [\u001b[1;32m Finished \u001b[0m] 100% Needed: 00:00:01 - Finished at Thu Feb 2 13:46:18 2023\n", - "\r" - ] - } - ], - "source": [ - "import crpropa\n", - "\n", - "# Signature: ElecaPropagation(inputfile, outputfile, showProgress=True, lowerEnergyThreshold=5*EeV, magneticFieldStrength=1*nG, background=\"ALL\")\n", - "crpropa.ElecaPropagation(\"photon_output.txt\", \"photons_eleca.dat\", True, 0.1*crpropa.EeV, 0.1*crpropa.nG)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Propagation with DINT\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "jupyter": { - "outputs_hidden": true - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2023-02-02 13:46:20 [WARNING] DINT propagation is deprecated and is no longer supported. Please use the EM* (EMPairProduction, EMInverseComptonScattering, ...) modules instead.\n", - "\n" - ] - } - ], - "source": [ - "import crpropa\n", - "\n", - "# Signature: DintPropagation(inputfile, outputfile, IRFlag=4, RadioFlag=4, magneticFieldStrength=1*nG, aCutcascade_Magfield=0)\n", - "crpropa.DintPropagation(\"photon_output.txt\", \"spectrum_dint.dat\", 4, 4, 0.1*crpropa.nG)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Combined Propagation" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "jupyter": { - "outputs_hidden": true - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Run EleCa propagation\n", - " Started Thu Feb 2 13:46:28 2023 : [\u001b[1;32m Finished \u001b[0m] 100% Needed: 00:00:00 - Finished at Thu Feb 2 13:46:28 2023\n", - "\r" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2023-02-02 13:46:28 [WARNING] EleCa+DINT propagation is deprecated and is no longer supported. Please use the EM* (EMPairProduction, EMInverseComptonScattering, ...) modules instead.\n", - "\n" - ] - } - ], - "source": [ - "import crpropa\n", - "\n", - "# Signature: DintElecaPropagation(inputfile, outputfile, showProgress=True, crossOverEnergy=0.5*EeV, magneticFieldStrength=1*nG, aCutcascade_Magfield=0)\n", - "crpropa.DintElecaPropagation(\"photon_output.txt\", \"spectrum_dint_eleca.dat\", True, 0.5*crpropa.EeV, 0.1*crpropa.nG)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### (Optional) Plotting of Results" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "jupyter": { - "outputs_hidden": false - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "%matplotlib inline\n", - "import matplotlib.pyplot as plt\n", - "\n", - "plt.figure(figsize=(6,6))\n", - "\n", - "plt.loglog(clip_on=False)\n", - "plt.yscale(\"log\", nonpositive='clip')\n", - "plt.xlabel('Energy [eV]')\n", - "plt.ylabel ('$E^2 dN/dE$ [a.u.]')\n", - "\n", - "# Plot the EleCa spectrum\n", - "elecaPhotons = genfromtxt(\"photons_eleca.dat\")\n", - "binEdges = 10**arange(12, 24, .1)\n", - "logBinCenters = log10(binEdges[:-1]) + 0.5 * (log10(binEdges[1:]) - log10(binEdges[:-1]))\n", - "binWidths = (binEdges[1:] - binEdges[:-1])\n", - "data = histogram(elecaPhotons[:,1] * 1E18, bins=binEdges)\n", - "J = data[0] / binWidths\n", - "E = 10**logBinCenters\n", - "step(E, J * E**2, c='m', label='EleCa')\n", - "\n", - "#Plot the DINT spectrum\n", - "data = genfromtxt(\"spectrum_dint.dat\", names=True)\n", - "lE = data['logE']\n", - "E = 10**lE\n", - "dE = 10**(lE + 0.05) - 10**(lE - 0.05)\n", - "J = data['photons'] / dE\n", - "step(E, J * E**2 , c='b', where='mid', label='DINT')\n", - "\n", - "#Plot the combined DINT+EleCa spectrum\n", - "data = genfromtxt(\"spectrum_dint_eleca.dat\", names=True)\n", - "lE = data['logE']\n", - "E = 10**lE\n", - "dE = 10**(lE + 0.05) - 10**(lE - 0.05)\n", - "J = data['photons'] / dE\n", - "step(E, J * E**2 , c='r', where='mid', label='Combined')\n", - "\n", - "# Nice limits\n", - "xlim(1e14, 1e20)\n", - "ylim(bottom=1e17)\n", - "legend(loc='upper left')\n", - "show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From daf9f68b9e82487402c27749a1cf2a5399347d8a Mon Sep 17 00:00:00 2001 From: Julien Date: Tue, 9 Jan 2024 08:17:16 +0100 Subject: [PATCH 4/8] add requirement file for notebook testing --- doc/pages/example_notebooks/requirements.txt | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 doc/pages/example_notebooks/requirements.txt diff --git a/doc/pages/example_notebooks/requirements.txt b/doc/pages/example_notebooks/requirements.txt new file mode 100644 index 000000000..de0d4c0fd --- /dev/null +++ b/doc/pages/example_notebooks/requirements.txt @@ -0,0 +1,10 @@ +# collection of all packages used in the analyis of the example notebooks. This is used for the automatic test of the notebooks +numpy +matplotlib +pandas +healpy +seaborn +scipy +tqdm +h5py +jupyter \ No newline at end of file From 15371d3728f6084a03f58427393ff1bcbd5a62f5 Mon Sep 17 00:00:00 2001 From: Julien Date: Tue, 9 Jan 2024 08:29:30 +0100 Subject: [PATCH 5/8] add crpropa output for lensing example --- .../galactic_lensing/crpropa_output.txt | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 doc/pages/example_notebooks/galactic_lensing/crpropa_output.txt diff --git a/doc/pages/example_notebooks/galactic_lensing/crpropa_output.txt b/doc/pages/example_notebooks/galactic_lensing/crpropa_output.txt new file mode 100644 index 000000000..dcb010a15 --- /dev/null +++ b/doc/pages/example_notebooks/galactic_lensing/crpropa_output.txt @@ -0,0 +1,11 @@ +# taken from https://github.com/CRPropa/CRPropa3/blob/2577c47ad898db13ce3b17c153e700041f304da4/galactic_lensing/crpropa_output.txt +1552.209 1000010010 1000260560 6.3094 1137.0405 118.8033 117.3283 120.0056 198.3873 -48.1072 250.9588 0.23085 0.06390 -0.97089 -0.76661 0.63718 -0.07947 0.000 +1553.387 1000010010 1000260560 6.3049 1137.0405 119.3010 117.8840 119.3933 198.3873 -48.1072 250.9588 -0.52969 0.57890 -0.61993 -0.76661 0.63718 -0.07947 0.000 +1552.209 1000010010 1000260560 6.3094 1137.0405 118.8033 117.3283 120.0056 198.3873 -48.1072 250.9588 0.23085 0.06390 -0.97089 -0.76661 0.63718 -0.07947 0.000 +1553.387 1000010010 1000260560 6.3049 1137.0405 119.3010 117.8840 119.3933 198.3873 -48.1072 250.9588 -0.52969 0.57890 -0.61993 -0.76661 0.63718 -0.07947 0.000 +2507.574 1000010010 1000020040 5.7274 157.5835 119.0234 117.9255 118.5094 64.1676 230.1578 58.0133 -0.24543 -0.93458 -0.25754 -0.21277 0.71704 -0.66376 0.000 + 597.459 1000010010 1000260560 9.6493 869.9225 119.0855 117.4122 119.7995 161.5538 74.8338 161.2846 -0.80199 0.46811 0.37105 -0.20573 0.14302 0.96810 0.000 +1059.588 1000010010 1000260560 17.2427 7507.9875 118.9984 117.3895 118.5193 332.7822 143.8280 378.0030 -0.19054 0.28077 0.94067 -0.18628 0.64559 -0.74061 0.000 +1342.343 1000010010 1000010010 17.7414 135.4199 118.9361 118.4267 118.8868 125.1438 25.9860 115.6526 0.01002 -0.98594 -0.16682 0.04910 -0.03836 -0.99806 0.000 + 140.527 1000010010 1000070140 50.7971 6946.8090 117.6596 117.8698 119.9085 173.0595 28.5316 197.1513 -0.17251 0.29795 -0.93886 -0.18122 0.95242 -0.24506 0.000 + 792.198 1000010010 1000070140 23.8203 765.9928 118.0031 117.7912 118.2653 221.2443 140.1373 120.6517 0.97493 0.06808 -0.21183 0.79843 0.58276 0.15130 0.000 From af49a15d4a69619fb4c4b44d4c783639a1a37c71 Mon Sep 17 00:00:00 2001 From: Julien Date: Tue, 9 Jan 2024 10:50:30 +0100 Subject: [PATCH 6/8] remove tag column from output --- doc/pages/example_notebooks/sim4D/sim4D.ipynb | 29 +++++++++++-------- 1 file changed, 17 insertions(+), 12 deletions(-) diff --git a/doc/pages/example_notebooks/sim4D/sim4D.ipynb b/doc/pages/example_notebooks/sim4D/sim4D.ipynb index 8fd639191..5bab6f2c3 100644 --- a/doc/pages/example_notebooks/sim4D/sim4D.ipynb +++ b/doc/pages/example_notebooks/sim4D/sim4D.ipynb @@ -38,16 +38,16 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "crpropa::ModuleList: Number of Threads: 8\n", + "crpropa::ModuleList: Number of Threads: 16\n", "Run ModuleList\n", - " Started Thu Feb 2 14:33:15 2023 : [\u001b[1;32m Finished \u001b[0m] 100% Needed: 00:04:17 - Finished at Thu Feb 2 14:37:32 2023\n", + " Started Tue Jan 9 10:49:16 2024 : [\u001b[1;32m Finished \u001b[0m] 100% Needed: 00:00:34 - Finished at Tue Jan 9 10:49:50 2024\n", "\r" ] } @@ -112,31 +112,29 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ - "columnnames=['D', 'z', 'ID', 'E', 'X', 'Y', 'Z', 'Px', 'Py', 'Pz','ID0', 'E0', 'X0', 'Y0', 'Z0', 'P0x', 'P0y', 'P0z', 'tag']\n", - "types = [float]*18 + [str]\n", + "columnnames=['D', 'z', 'ID', 'E', 'X', 'Y', 'Z', 'Px', 'Py', 'Pz','ID0', 'E0', 'X0', 'Y0', 'Z0', 'P0x', 'P0y', 'P0z']\n", + "types = [float] * len(columnnames)\n", "import numpy as np\n", "data = np.loadtxt('./output.txt', dtype={'names': columnnames, 'formats': types})" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -147,6 +145,13 @@ "plt.xlabel(r'observed redshift $z$')\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From f9c93ee5824c88ebd265750a2c31eb1f00420a4e Mon Sep 17 00:00:00 2001 From: Julien Date: Tue, 9 Jan 2024 11:39:54 +0100 Subject: [PATCH 7/8] update plotting for newer matplotlib versions --- .../trajectories/trajectories.ipynb | 27 +++++++++---------- 1 file changed, 12 insertions(+), 15 deletions(-) diff --git a/doc/pages/example_notebooks/trajectories/trajectories.ipynb b/doc/pages/example_notebooks/trajectories/trajectories.ipynb index cf2c0aa80..332b45e9f 100644 --- a/doc/pages/example_notebooks/trajectories/trajectories.ipynb +++ b/doc/pages/example_notebooks/trajectories/trajectories.ipynb @@ -45,7 +45,7 @@ "Lc = 192.0 kpc\n", "sqrt() = 8.0 nG\n", "<|B|> = 7.4 nG\n", - "B(10 Mpc, 0, 0) = Vector(0.21059, -1.94174, 1.69713) nG\n" + "B(10 Mpc, 0, 0) = Vector(0.210589, -1.94174, 1.69713) nG\n" ] } ], @@ -139,24 +139,14 @@ "execution_count": 5, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_961678/2311979340.py:22: MatplotlibDeprecationWarning: Calling gca() with keyword arguments was deprecated in Matplotlib 3.4. Starting two minor releases later, gca() will take no keyword arguments. The gca() function should only be used to get the current axes, or if no axes exist, create new axes with default keyword arguments. To create a new axes with non-default arguments, use plt.axes() or plt.subplot().\n", - " ax = fig.gca(projection='3d')# , aspect='equal'\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -182,7 +172,7 @@ "sizes = [sizeDict[z] for z in Z]\n", "\n", "fig = plt.figure(figsize=(12, 5))#plt.figaspect(0.5))\n", - "ax = fig.gca(projection='3d')# , aspect='equal'\n", + "ax = fig.add_axes(111, projection=\"3d\")\n", "\n", "ax.scatter(x,y,z+6, 'o', s=sizes, color=colors)\n", "\n", @@ -198,6 +188,13 @@ "\n", "show()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 6dc913eef84a49d0e5adc92d5eacc9d3063c4982 Mon Sep 17 00:00:00 2001 From: Julien Date: Thu, 11 Jan 2024 17:08:25 +0100 Subject: [PATCH 8/8] fix typo --- .github/workflows/create_documentation.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/create_documentation.yml b/.github/workflows/create_documentation.yml index 7372c46ec..5888cfc81 100644 --- a/.github/workflows/create_documentation.yml +++ b/.github/workflows/create_documentation.yml @@ -30,7 +30,7 @@ jobs: sudo apt-get update sudo apt-get install libmuparser-dev libhdf5-serial-dev libomp5 libomp-dev libfftw3-dev libcfitsio-dev lcov doxygen graphviz sudo apt-get install pandoc # do not only use pip to install pandoc, see https://stackoverflow.com/questions/62398231/building-docs-fails-due-to-missing-pandoc - pip install -r doc/pages/example_notebooks/requirements.txt # load requrements for notebooks + pip install -r doc/pages/example_notebooks/requirements.txt # load requirements for notebooks pip install sphinx sphinx_rtd_theme m2r2 nbsphinx breathe pandoc exhale # load requirements for documentation - name: Set up the build env: